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

雨霖先森 2022-10-16 11:54:33

常用类之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);
    
}
}
...全文
69 回复 打赏 收藏 转发到动态 举报
写回复
用AI写文章
回复
切换为时间正序
请发表友善的回复…
发表回复
12常用类(枚举、包装类、Math、Random、String、常量池、StringBuffer、StringBuilder·、System、Runtime、Date、SimpleDateForma)
常用类 1.枚举 使用enum修饰类，用于规定一些特殊的值，枚举中的值都是静态常量，枚举也可以用于switch中 package com.qfedu.test1; ​ public enum Week { SUN,MON,TUE,WED,THUR,FRI,SAT } package com.qfedu.test1; ​ public class TestEnum { // enum枚举也可以用于 switch中 // 根据枚举的值 输出一周的天数 public
常用类/正则表达式/枚举
2017.12.30 学习内容 1.常用类； 2.正则表达式； 3.枚举。 一.常用类  1.Math类（final类）   其成员变量及成员方法时静态的。 eg:   2.Random类：    常用方法：（1）public int nextInt(int bound) 返回从0（包含）到bound（不包含）的一个“伪随机”整数值；           （2）pub
常用类
常用类和异常 回顾 1 包装类: byte- Byte short-Short int-Integer long -Long float-Float double-Double char- Character boolean -Boolean Integer 1 如果使用 Integer 创建对象，数据在堆中存放 2 Integer i=10...
14-常用类
BigDecimal.ROUND_UP // 最后一位大于0就向上进1位 BigDecimal.ROUND_DOWN：// 去掉超出0的部分 BigDecimal.ROUND_HALF_UP // 四舍五入>=0.5就进1，小于0.5就舍去 BigDecimal.ROUND_HALF_DOWN // <=0.5就舍去，只有大于0.5才是进1。2、在项目查询条件的时候，往往会选择时间范围，请根据当前日期，2022年4月13日，打印出前后7天的日期范围，按照yyyy-MM-dd 的格式输出。
Java学习day21：System类、Runtime类、Date类、Calendar类（知识点详解）
Java学习day21：System类、Runtime类、Date类、Calendar类 一、System类 这个类应该说是我们最熟悉的一个类了，是一个系统类，常用的输入输出都需要依靠这个类。1.常用方法1.1currentTimeMillis()这个获取当前时间的方法用的比较多，能够获取从1970-现在的毫秒数---
Java

51,407

社区成员

86,107

社区内容

发帖
与我相关
我的任务
社区描述
Java相关技术讨论
javaspring bootspring cloud 技术论坛（原bbs）
社区管理员
  • Java相关社区
  • 小虚竹
  • 谙忆
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
暂无公告

试试用AI创作助手写篇文章吧

+ 用AI写文章