常用类之Math类+Random类+ Runtime类+System类+大数值运算类+枚举

妖狐艹你老母 2024-04-11 09:57 59阅读 0赞

## 常用类之Math类+Random类+ Runtime类+System类+大数值运算类+枚举 ##

### 一、Math类的使用 ###

public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		
    		System.out.println("求次方：" + Math.pow(4,2));//16.0
    		System.out.println("求平方根：" + Math.sqrt(9));//3.0
    		System.out.println("求绝对值：" + Math.abs(-200));//200
    		System.out.println("向下取整（地板）：" + Math.floor(1.9));//1.0
    		System.out.println("向上取整（天花板）：" + Math.ceil(1.1));//2.0
    		System.out.println("四舍五入：" + Math.rint(1.59));//2.0
    		System.out.println("获取最大值：" + Math.max(14, 84));//84
    		System.out.println("获取最小值：" + Math.min(45, 100));//45
    		
    		//需求：随机出1~100的数字
    		System.out.println("随机1~100的数字：" + ((int)(Math.random()*100) + 1));//75		
    	}
    }

#### 1.Math面试题 ####

public class Test02 {
        
    
    	public static void main(String[] args) {
        
    		System.out.println(Integer.MIN_VALUE);//-2147483648--> -2的31次方
    		System.out.println(Integer.MAX_VALUE);//2147483647-->  2的31次方-1		
    		//Math.abs()以可能会返回负数吗？
    		System.out.println(Math.abs(Integer.MIN_VALUE));//-2147483648
    		System.out.println(Math.abs(Integer.MAX_VALUE));//2147483647
    	}
    }

#### 2.静态导入 ####

##### 1.含义：将该类中所有的静态属性和静态方法都导入到本类里，成为本类自己的静态属性和静态方法 #####

##### 2.缺点：可读性较差（原因：代码一多，你就分不清该方法是静态导入类中的还是本类中的静态方法） #####

import static java.lang.Math.*;
    public class Test03 {
        
    
    	public static void main(String[] args) {
        
    		
    		System.out.println("求次方：" + pow(3, 2));//9.0
    		System.out.println("求平方根：" + sqrt(9));//3.0
    		System.out.println("求绝对值：" + abs((-100)));//666888
    	}
    	
    	public static int abs(int i) {
        
    		return 666888;
    	}
    }

### 二、Random类 – 随机类 ###

import java.util.Random;
    public class Test01 {
        
    	public static void main(String[] args) {
        
    		
    		//创建随机类的对象
    		Random ran = new Random();
    		
    		System.out.println("随机int取值范围内的数字：" + ran.nextInt());
    		System.out.println("随机0~9的数字：" + ran.nextInt(10));
    		System.out.println("随机double取值范围内的数字：" + ran.nextDouble());
    		System.out.println("随机boolean取值范围内的数字：" + ran.nextBoolean());
    	}
    }

#### 1.Random类的案例 ####

##### 需求：随机点名器 #####

import java.util.Random;
    public class Test02 {
        
    
    	public static void main(String[] args) {
        
    		
    		String[] names = {
        "百里守约","黄忠","狄仁杰","成吉思汗","孙尚香","露可娜娜"};
    		
    		Random ran = new Random();
    		int index = ran.nextInt(names.length);
    		
    		System.out.println(names[index]);
    	}
    }

#### 2.理解Random的种子数 ####

##### 需求：种子数固定，随机出的数字也是固定的 #####

import java.util.Random;
    public class Test03 {
        
    
    	public static void main(String[] args) {
        
    		
    		//创建Random对象，底层种子数是随机生成的
    //		Random random = new Random();
    		//创建Random对象，并设置种子数
    		Random random = new Random(200);
    		System.out.println(random.nextInt());
    		
    		System.out.println("----------------");
    		
    		MyRandom myRandom = new MyRandom();
    		
    		System.out.println(myRandom.nextInt());
    		System.out.println(myRandom.nextInt(10));
    	}
    }

public class MyRandom {
        
    	//种子数
    	private long seed;
    
    	public MyRandom() {
        
    		this(System.nanoTime());
    	}
    	public MyRandom(long seed) {
        
    		this.seed = seed;
    	}
    
    	public static long seedniquifier(){
        
    		long current = System.currentTimeMillis();
    		for(;;){
        
    			current *= 181783497276652981L;
    			if(current%7 == 0 || current%9 == 0 || current%4==0){
        
    				return current;
    			}
    		}
    	}
    	public int nextInt(){
        
    		return (int) seed;
    	}
    	public int nextInt(int num){
        
    		return Math.abs((int) seed) % num;
    	}
    }

### 三、Runtime – 运行环境 ###

public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		
    		Runtime run = Runtime.getRuntime();
    		
    		System.out.println("获取最大操作数：" + run.availableProcessors());
    		System.out.println("获取最大内存数(字节)："  + run.maxMemory());
    		System.out.println("获取闲置内存数(字节)：" + run.freeMemory());
    	}
    }

#### 考虑一段代码的效率 ：运行时常 、消耗内存 ####

public class Test02 {
        
    
    	public static void main(String[] args) {
        
    		
    		//实验一：计算出下列代码的运行时常
    		
    //		Runtime run = Runtime.getRuntime();
    //		
    //		long startMemory = run.freeMemory();
    //		long startTime = System.currentTimeMillis();//获取自1970.1.1 0:0:0到现在的毫秒数
    //		String str = "妲己";
    //		for (int i = 0; i < 10000; i++) {
        
    //			str += "小可爱，皇冠给你带~~";
    //		}
    //		long endTime = System.currentTimeMillis();
    //		long endMemory = run.freeMemory();
    //		
    //		System.out.println("消耗时间：" + (endTime-startTime));//消耗时间：726
    //		System.out.println("消耗内存：" + (startMemory-endMemory));//消耗内存：-725189288(Java的垃圾回收器回收了一部分内存)
    		
    		//实验二：计算出下列代码的运行时常
    		Runtime run = Runtime.getRuntime();
    		long startMemory = run.freeMemory();
    		long startTime = System.currentTimeMillis();//获取自1970.1.1 0:0:0到现在的毫秒数
    		StringBuilder sb = new StringBuilder("妲己");
    		for (int i = 0; i < 10000; i++) {
        
    			sb.append("小可爱，皇冠给你带~~");
    		}
    		long endTime = System.currentTimeMillis();
    		long endMemory = run.freeMemory();
    		
    		System.out.println("消耗时间：" + (endTime-startTime));//消耗时间：2
    		System.out.println("消耗内存：" + (startMemory-endMemory));//消耗内存：765456
    	}
    }

### 四、System – 系统类 ###

#### 1.属性 ####

public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		
    		//系统标准的输入流（方向：控制台->程序）
    		InputStream in = System.in;
    		Scanner scan = new Scanner(in);
    		String str = scan.next();
    		scan.close();
    		
    		//系统标准的输出流（方向：程序->控制台）
    	//	PrintStream out = System.out;
    	//  out.println(str);
    		
    		//系统标准的错误输出流（方向：程序->控制台）
    		PrintStream err = System.err;
    		err.println(str);
    	}
    }

#### 2.研究System.out 和 System.err ####

##### System.out 和 System.err 是两个线程中的代码 #####

public class Test02 {
        
    
    	public static void main(String[] args) {
        
    		
    		System.out.println("花花");
    		System.err.println("明明");
    		System.out.println("莎莎");
    	}
    }

#### 3.System的方法 ####

import java.util.Arrays;
    import java.util.Properties;
    public class Test03 {
        
    
    	public static void main(String[] args) {
        
    		
    		//退出当前虚拟机 （0-正常退出）
    		//System.exit(0);
    		
    		//获取系统的配置文件
    		Properties properties = System.getProperties();
    		System.out.println(properties);
    		
    		//通过Key获取到对应的值
    		String value = System.getProperty("os.name");
    		System.out.println(value);//Window 10
    		
    		String[] names = {
        "百里守约","黄忠","狄仁杰","成吉思汗","孙尚香","露可娜娜"};
    		String[] newNames = new String[4];
    		
    		System.arraycopy(names, 1, newNames, 0, 4);
    		System.out.println(Arrays.toString(newNames));
    	}
    }

### 五、整数的大数值运算类 ###

import java.math.BigInteger;
    public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		BigInteger big1 = new BigInteger("12345678900");
    		BigInteger big2 = new BigInteger("12345678900");
    		
    		BigInteger add = big1.add(big2);
    		System.out.println(add);//24691357800
    		
    		BigInteger subtract = big1.subtract(big2);
    		System.out.println(subtract);//0
    		
    		BigInteger multiply = big1.multiply(big2);
    		System.out.println(multiply);//152415787501905210000
    		
    		BigInteger divide = big1.divide(big2);
    		System.out.println(divide);//1
    	}
    }

#### 1.小数的大数值运算类 ####

import java.math.BigDecimal;
    public class Test02 {
        
    
    	public static void main(String[] args) {
        
    		
    		BigDecimal big1 = new BigDecimal("0.5");
    		BigDecimal big2 = new BigDecimal("0.4");
    		
    		BigDecimal add = big1.add(big2);
    		System.out.println(add);//0.9
    		
    		BigDecimal subtract = big1.subtract(big2);
    		System.out.println(subtract);//0.1
    		
    		BigDecimal multiply = big1.multiply(big2);
    		System.out.println(multiply);//0.2
    		
    		BigDecimal divide = big1.divide(big2);
    		System.out.println(divide);//1.25	
    	}
    }

#### 2.小数的大数值运算类的注意事项 ####

import java.math.BigDecimal;
    public class Test03 {
        
    
    	public static void main(String[] args) {
        
    		BigDecimal big1 = new BigDecimal("10");
    		BigDecimal big2 = new BigDecimal("3");
    		
    		BigDecimal divide = big1.divide(big2, 3,BigDecimal.ROUND_HALF_UP);
    		System.out.println(divide);
    	}
    }

### 六、枚举 ###

#### 1.枚举引入案例 ####

##### 1.需求：编写季节类（Season），该类只有四个对象（spring，summer，autumn，winter） #####

##### 2.小结： #####

###### 1.一个类只有一个对象 – 单例模式 ######

###### 2.一个类只有固定的几个对象 – 枚举 ######

public class Test01 {
        
    
    	 public static void main(String[] args) {
        
    		 
    		 System.out.println(Season.spring);//Season [name=春天, info=万物复苏]
    		 System.out.println(Season.summer);//Season [name=夏天, info=汗如雨下]
    		 System.out.println(Season.autumn);//Season [name=秋天, info=秋高气爽]
    		 System.out.println(Season.winter);//Season [name=冬天, info=银装素裹]
    		 			 
    	}
    }

public class Season {
        
    
    	public static final Season spring = new Season("春天", "万物复苏");
    	public static final Season summer = new Season("夏天", "汗如雨下");
    	public static final Season autumn = new Season("秋天", "秋高气爽");
    	public static final Season winter = new Season("冬天", "银装素裹");
    	
    	private String name;
    	private String info;
    	
    	private Season() {
        
    	}
    
    	public Season(String name, String info) {
        
    		this.name = name;
    		this.info = info;
    	}
    
    	public String getName() {
        
    		return name;
    	}
    
    	public void setName(String name) {
        
    		this.name = name;
    	}
    
    	public String getInfo() {
        
    		return info;
    	}
    
    	public void setInfo(String info) {
        
    		this.info = info;
    	}
    
    	@Override
    	public String toString() {
        
    		return "Season [name=" + name + ", info=" + info + "]";
    	}	
    }

#### 2.枚举的常用方法 ####

public class Test02 {
        
    
    	public static void main(String[] args) {
        
    		
    		//获取Season枚举类中指定名字的对象
    		Season season1 = Enum.valueOf(Season.class, "spring");
    		System.out.println(season1);//春天---春雨绵绵
    		
    		//获取Season枚举类中指定名字的对象
    		Season season2 = Season.valueOf("spring");
    		System.out.println(season2);//春天---春雨绵绵
    		
    		System.out.println("----------------");
    		
    		//获取Season枚举类中所有的对象
    		Season[] seasons = Season.values();
    		for (Season season : seasons) {
        
    			//春天---春雨绵绵
    			//夏天---烈日炎炎
    			//秋天---硕果累累
    			//冬天---白雪皑皑
    			System.out.println(season);
    		}
    	}
    }

//自定义枚举类 不能显示继承，但是默认(隐式)继承Enum
    public enum Season {
        
    	//枚举类的第一行必须声明对象，默认使用public static final修饰
    	
    	//默认调用无参构造
    	//spring,summer,autumn,winter;
    	
    	//调用有参构造       声明对象
    	spring("春天","春雨绵绵"),
    	summer("夏天","烈日炎炎"),
    	autumn("秋天","硕果累累"),
    	winter("冬天","白雪皑皑");
    	
    	private String name;
    	private String info;
    	
    	private Season() {
        
    		
    	}
    
    	private Season(String name, String info) {
        
    		this.name = name;
    		this.info = info;
    	}
    
    	public String getName() {
        
    		return name;
    	}
    
    	public void setName(String name) {
        
    		this.name = name;
    	}
    
    	public String getInfo() {
        
    		return info;
    	}
    
    	public void setInfo(String info) {
        
    		this.info = info;
    	}
    
    	@Override
    	public String toString() {
        
    		return  name + "---" + info;
    	}	
    }

#### 3.枚举案例之 状态机 ####

import java.util.Scanner;
    public class Test01 {
        
    
    	public static void main(String[] args) {
        
    
    		Scanner scan = new Scanner(System.in);
    
    		System.out.println("请输入信号灯：RED、YELLOW、GREEN");
    		String next = scan.next();
    
    		Signal signal = Signal.valueOf(next);
    
    		String trafficInstruct = getTrafficInstruct(signal);
    		System.out.println(trafficInstruct);
    		scan.close();		
    	}
    
    	private static String getTrafficInstruct(Signal signal) {
        
    		String instruct = "信号灯故障";
    		switch (signal) {
        
    		case RED:
    			instruct = "红灯停";
    			break;
    		case YELLOW:
    			instruct = "黄灯请注意";
    			break;	
    		case GREEN:
    			instruct = "绿灯行";
    			break;
    		}
    		return instruct;
    	}
    }

public enum Signal {
        
    
    	RED, YELLOW, GREEN
    }

#### 4.枚举案例 之 错误码 ####

###### 需求：学生管理系统的 添加功能的错误码枚举 ######

public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		System.out.println(AddCode.A_ERROR);
    		System.out.println(AddCode.B_ERROR);
    		System.out.println(AddCode.OK);
    	}
    }

public enum AddCode {
        
    	A_ERROR(-1,"添加失败 - 学生信息不合法"), 
    	B_ERROR(-2,"添加失败 - 已有该学生"), 
    	OK(1,"添加成功");
    
    	private int code;
    	private String message;
    	
    	private AddCode() {
        
    		
    	}
    
    	private AddCode(int code, String message) {
        
    		this.code = code;
    		this.message = message;
    	}
    
    	public int getCode() {
        
    		return code;
    	}
    
    	public void setCode(int code) {
        
    		this.code = code;
    	}
    
    	public String getMessage() {
        
    		return message;
    	}
    
    	public void setMessage(String message) {
        
    		this.message = message;
    	}
    	
    	@Override
    	public String toString() {
        
    	
    		return code + " -- " + message;
    	}
    }

#### 5.枚举案例 之 组织枚举 ####

##### 1.含义：创建类或者是接口，把众多相同功能的枚举给组织起来 #####

##### 2.注意：一般使用接口去组织 #####

###### 1.使用类去组织枚举：类中的枚举会默认添加static ######

###### 2.使用接口取组织枚举：接口中的枚举会默认添加public static ######

##### 3.需求： #####

###### 学生管理系统的 添加、删除、修改功能的错误码枚举 ######

public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		
    		System.out.println(Code.AddCode.A_ERROR);
    		System.out.println(Code.DeleteCode.A_ERROR);
    		System.out.println(Code.UpdateCode.A_ERROR);
    	}
    }

//组织枚举
    public class Code {
        
    
    	public enum AddCode {
        
    
    		A_ERROR(-1,"添加失败 - 学生信息不合法"),
    		B_ERROR(-2,"添加失败 - 已有该学生"),
    		OK(1,"添加成功");
    		
    		private int code;
    		private String message;
    		
    		private AddCode() {
        
    			
    		}
    
    		private AddCode(int code, String message) {
        
    			this.code = code;
    			this.message = message;
    		}
    
    		public int getCode() {
        
    			return code;
    		}
    
    		public void setCode(int code) {
        
    			this.code = code;
    		}
    
    		public String getMessage() {
        
    			return message;
    		}
    
    		public void setMessage(String message) {
        
    			this.message = message;
    		}
    		
    		@Override
    		public String toString() {
        
    			return code + " -- " + message;
    		}
    	}
    	
    	public enum DeleteCode {
        
    
    		A_ERROR(-1,"删除失败 - 学生信息不合法"),
    		B_ERROR(-2,"删除失败 - 没有该学生"),
    		OK(1,"删除成功");
    		
    		private int code;
    		private String message;
    		
    		private DeleteCode() {
        
    			
    		}
    
    		private DeleteCode(int code, String message) {
        
    			this.code = code;
    			this.message = message;
    		}
    
    		public int getCode() {
        
    			return code;
    		}
    
    		public void setCode(int code) {
        
    			this.code = code;
    		}
    
    		public String getMessage() {
        
    			return message;
    		}
    
    		public void setMessage(String message) {
        
    			this.message = message;
    		}
    		
    		@Override
    		public String toString() {
        
    			return code + " -- " + message;
    		}
    	}
    	
    	public enum UpdateCode {
        
    
    		A_ERROR(-1,"修改失败 -- 学生信息不合法"),
    		B_ERROR(-2,"修改失败 - 没有该学生"),
    		C_ERROR(-3,"修改失败 - 修改类型错误"),
    		D_ERROR(-4,"修改失败 - 修改类型转换异常"),
    		E_ERROR(-5,"修改失败 - 修改类型不合法"),
    		F_ERROR(-6,"修改失败 - 目标班级上有学生"),
    		G_ERROR(-7,"修改失败 - 目标学号上有学生"),
    		OK(1,"修改成功");
    		
    		private int code;
    		private String message;
    		
    		private UpdateCode() {
        
    			
    		}
    
    		private UpdateCode(int code, String message) {
        
    			this.code = code;
    			this.message = message;
    		}
    
    		public int getCode() {
        
    			return code;
    		}
    
    		public void setCode(int code) {
        
    			this.code = code;
    		}
    
    		public String getMessage() {
        
    			return message;
    		}
    
    		public void setMessage(String message) {
        
    			this.message = message;
    		}
    		
    		@Override
    		public String toString() {
        
    			return code + " -- " + message;
    		}
    	}
    
    }

#### 6.枚举案例 之 策略枚举 ####

##### 1.需求：制作学校工资结算 #####

##### 2.分析： #####

> 员工类别：行政、讲师
> 
> 部分：Chinese(语文老师)、Math(数学老师)、English(英语老师)、人事(行政)、财务(行政)、校长(行政)

public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		
    		double salary1 = Salary.Math.getSalary(1500,100,40,800);
    		System.out.println(salary1);//6300.0
    		
    		double salary2 = Salary.President.getSalary(2000, 0, 0, 4000);
    		System.out.println(salary2);//6000.0
    	}
    }

import java.math.BigDecimal;
    
    public enum Salary {
        
    
    	Chinese(Staff.TEACHER),
    	Math(Staff.TEACHER),
    	English(Staff.TEACHER),
    	Personnel(Staff.administration),
    	Finance(Staff.administration),
    	President(Staff.administration);
    	
    	private Staff staff;
    	private Salary(Staff staff) {
        
    		this.staff = staff;
    	}
    	
    	
    	public double getSalary(double baseSalary, int classHour, double teachingHourSubsidy,
    			double achievements) {
        	
    		return staff.calculationSalary(baseSalary, classHour, teachingHourSubsidy, achievements);
    	}
    	
    	public enum Staff{
        
    		
    		TEACHER{
        
    			@Override
    			public double calculationSalary(double baseSalary, int classHour, double teachingHourSubsidy,
    					double achievements) {
        
    				
    				BigDecimal big1 = new BigDecimal(String.valueOf(baseSalary));
    				BigDecimal big2 = new BigDecimal(String.valueOf(classHour));
    				BigDecimal big3 = new BigDecimal(String.valueOf(teachingHourSubsidy));
    				BigDecimal big4 = new BigDecimal(String.valueOf(achievements));
    				double doubleValue = big2.multiply(big3).add(big1).add(big4).doubleValue();
    				return doubleValue;
    			}
    		},
    		administration {
        
    			@Override
    			public double calculationSalary(double baseSalary, int classHour, double teachingHourSubsidy,
    					double achievements) {
        
    				BigDecimal big1 = new BigDecimal(String.valueOf(baseSalary));
    				BigDecimal big2 = new BigDecimal(String.valueOf(achievements));
    				double doubleValue = big1.add(big2).doubleValue();
    				return doubleValue;
    			}
    	};
    			
    	/**
    	 * 计算工资的方法
    	 * @param baseSalary 基本工资
    	 * @param classHour 课时
    	 * @param teachingHourSubsidy 课时费
    	 * @param achievements 绩效
    	 * @return 工资
    	 */
    	public abstract double calculationSalary(double baseSalary,int classHour,double teachingHourSubsidy,double achievements);
    	
    }
    }