Java内部类和常用类

我不是女神ヾ 2023-09-27 09:13 40阅读 0赞

### 文章目录 ###

*  01 内部类
 *   *  成员内部类：
     *  静态内部类：
     *  局部内部类：
     *  匿名内部类：
 *  02 Object类
 *   *  getClass() 方法
     *  hashCode() 方法
     *  toString() 方法
     *  equals() 方法
     *  finalize() 对象
 *  03 包装类
 *   *  类型转换：装箱和拆箱
     *  基本类型和字符串之间的转换
     *  Integer整数缓冲区
 *  04 String 类
 *   *  常用方法
     *  案例演示：
 *  05 可变字符串 StringBuffer&Builder
 *  06 BigDecimal 类
 *  07 Date 类
 *  08 Calendar 类
 *  09 SimpleDateFormat 类
 *  10 System 类
 *  11 Math 类
 *  12 Random 类

--------------------

# 01 内部类 #

内部类：在一个类的内部再定义一个完整的类；

class Outer{
         //外部类
    	class Inner{
        
    	//内部类
    	}
    }

特点：

1.  编译之后可生成独立的字节码文件；
2.  内部类可直接访问外部类的私有成员，而不破坏封装；
3.  可为外部类提供必要的内部功能组件；

## 成员内部类： ##

*  在类的内部定义，与实例变量、实例方法同级别的类；
 *  外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象（先创建外部类对象才能创建内部变量）；
 *  当外部类、内部类存在重名属性时，会优先访问内部类属性；
 *  成员内部类不能定义静态成员（但是可以定义静态常量 static public）；

public class Demo01 {
        
        private String name = "hello";
        private int age = 1; //和外部类重名
    
        class Steal{
         //成员内部类
        	static final String test = "成员内部类不能定义静态成员，但是可以定义静态常量 ";
            
            public void print(){
        
                int age =10; //和外部类重名，优先输出外部类
                System.out.println(name);
                System.out.println(age);
                System.out.println(Demo01.this.age); //这样就可以输出外部类的age了
            }
        }
    
        public static void main(String[] args) {
        
            Demo01 demo01 = new Demo01();
            Steal steal = demo01.new Steal(); //通过外部类来实例化内部类
            steal.print(); //通过内部类来访问私有变量
    
            //也可以一步到位
            Steal steal1 = new Demo01().new Steal();
            steal.print(); //输出 hello 10
        }
    }

## 静态内部类： ##

*  不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员（相当于一个外部类）；
 *  只能直接访问外部类的静态成员（实例成员需要实例化外部类对象）；

//外部类
    public class Demo02 {
        
        private String name = "我";
    
        //静态内部类，和外部类相同
        static class Inner{
          //只有内部类才可以static修饰
           private String address ="成都";
           static int num = 128;
           public void show(){
        
               //调用外部类
               //先创建外部类对象
               Demo02 demo02 = new Demo02();
               //调用外部类对象的属性
               System.out.println(demo02.name);
               //调用静态内部类的属性
               System.out.println(address);
               //调用静态内部类的静态属性
               System.out.println(Inner.num);
           }
        }
        public static void main(String[] args) {
        
            //直接创建静态内部类
            Demo02.Inner inner = new Demo02.Inner();
            //因为静态内部类可以视为和外部类一样，所以可以直接new
            Inner inner1 = new Inner();
            inner.show();
            inner1.show();
        }
    }

## 局部内部类： ##

*  定义在外部类方法中，作用范围和创建对象范围仅限于当前方法；
 *  局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为 final ；
 *  限制类的使用范围：只能在当前方法中使用；

//外部类
    public class Demo03 {
        
        private  String name = "刘德华";
    
        public void show(){
        
            //定义局部变量
            /*final*/String address = "中国";  //也不能定义static静态变量 但可以static final静态常量
    		
            //局部内部类 （注意：不能加任何访问修饰符）
            class Inner {
        
                private String email = "@163.com";
    
                public void print(){
        
                    //可以直接访问外部类的属性（前提是方法是非静态的）
                    System.out.println(name); //如果方法是静态的，就通过对象调用Demo03.this.name
                    //访问内部类的属性
                    System.out.println(this.email);
                    //访问局部变量(jdk1.7要求变量必须是常量，jdk1.8自动添加final)
                    //输出的其实不是变量address其实是常量
                /*  因为下面还有局部类的对象，所以局部类并没有消失，但局部变量却消失了，所以这里其实是常量
                相当于System.out.println("中国"); 常量！ */
                } 
            }
            //想要外部类调用局部内部类的print ，先创建局部内部类对象；
            Inner inner = new Inner();
            inner.print();
        }
        public static void main(String[] args) {
        
            Demo03 demo03 = new Demo03();
            demo03.show();
        }
    }

## 匿名内部类： ##

*  没有类名的局部内部类（一切特征都与局部内部类相同）；
 *  必须继承一个父类、抽象类或者实现一个接口；
 *  定义类、实现类、创建对象的语法合并，只能创建一个该类的对象；
 *  优点：减少代码量；缺点：可读性差

![在这里插入图片描述][21a1177d21e34193bf7a522812c511ab.png]

//接口
    public interface USB {
        
        //定义一个服务接口
        void service();
    }
    
    //继承接口写方法
    public class Mouse implements USB{
        
        @Override
        public void service() {
        
            System.out.println("连接成功");
        }
    }
    
    //main方法
    public class TestUSB {
        
        public static void main(String[] args) {
        
            //创建接口类型的变量
            USB usb = new Mouse();
            usb.service();
            
            //局部内部类
            class F implements USB{
        
                @Override
                public void service() {
        
                    System.out.println("连接成功！！！");
                }
            }
            //使用局部内部类创建变量
            F f = new F();
            f.service();  //只用了一次局部内部类，比较浪费
            
            //匿名内部类优化(相当于创建了一个局部内部类)
            USB niming = new USB() {
         //这里是接口 也可以是抽象类 父类
                @Override
                public void service() {
        
                    System.out.println("匿名内部类，连接成功");
                }
            };
            niming.service();
        }
    }

--------------------

# 02 Object类 #

*  超类、基类，所有类的直接或间接父类，位于继承树的最顶层；
 *  任何类，如没有extends继承某个类，都默认直接或间接继承Object类；
 *  Object类中定义的方法，是所有对象都具备的方法；
 *  Object类型可以存储任何对象：
    
     *  作为参数，可接受任何对象；
     *  作为返回值，可返回任何对象；
 *  可通过[API帮助文档来查看][API]；

## getClass() 方法 ##

public final Class<?> getClass(){
        }

*  返回引用存储的实际对象类型；
 *  应用：通常用于判断两个引用中实际存储对象类型是否一致；

## hashCode() 方法 ##

public int hashCode(){
        }

*  返回对象的哈希码值；
 *  哈希值是根据对象的地址或字符串或数字使用hash算法计算出来的 int 类型的数值；
 *  一般情况下相同对象返回相同的哈希码；

## toString() 方法 ##

public String toString(){
        }

*  返回该对象的字符串表现形式；
 *  可以根据程序需求覆盖该方法，如：展示对象的各个属性值；

public class Demo01 {
        
        private String name;
        private int age;
    
        public Demo01() {
         //构造方法（无参构造）alt+insert
        }
    
        public Demo01(String name, int age) {
         //有参构造 alt+insert
            this.name = name;
            this.age = age;
        }
        //封装以后，用get和set来读取和输入
        public String getName() {
         //alt+insert Getter 和 Setter
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        public static void main(String[] args) {
        
            Demo01 s1 = new Demo01();
            Demo01 s2 = new Demo01();
    
            //用getClass()方法 判断s1和s2是不是同一个类型
            Class class1 = s1.getClass();
            Class class2 = s2.getClass();
            if (class1==class2){
        
                System.out.println("属于同一个类型");//输出这个
            }else {
        
                System.out.println("不属于同一个类型");
            }
            System.out.println("----------------");
    
            //使用hashCode() 方法
            System.out.println(s1.hashCode());
            System.out.println(s2.hashCode());
            //因为存储的地址不一样，输出的地址也是不一样的
            Demo01 s3=s1;//s1的地址赋给了s3
            System.out.println(s3.hashCode()); //输出的hashCode和s1一样
            System.out.println("----------------");
    
    
            //使用toString()方法
            System.out.println(s1.toString());//如果打印的不是想要的可以自行重写方法
            System.out.println(s2.toString());//alt+insert选择toString()可以快速重写
        }
    }

## equals() 方法 ##

public boolean equals (Object obj){
        }

*  默认实现为（this == obj），比较两个对象地址是否相同；

public class Demo01 {
        
        private String name;
        private int age;
    
        public Demo01() {
         //构造方法（无参构造）alt+insert
        }
    
        public Demo01(String name, int age) {
         //有参构造 alt+insert
            this.name = name;
            this.age = age;
        }
        //封装以后，用get和set来读取和输入
        public String getName() {
         //alt+insert Getter 和 Setter
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
    
    
        public static void main(String[] args) {
        
            Demo01 s1 = new Demo01();
            Demo01 s2 = new Demo01();
    
            //用getClass()方法 判断s1和s2是不是同一个类型
            Class class1 = s1.getClass();
            Class class2 = s2.getClass();
            if (class1==class2){
        
                System.out.println("属于同一个类型");//输出这个
            }else {
        
                System.out.println("不属于同一个类型");
            }
            System.out.println("----------------");
    
            //使用hashCode() 方法
            System.out.println(s1.hashCode());
            System.out.println(s2.hashCode());
            //因为存储的地址不一样，输出的地址也是不一样的
            Demo01 s3=s1;//s1的地址赋给了s3
            System.out.println(s3.hashCode()); //输出的hashCode和s1一样
            System.out.println("----------------");
    
    
            //使用toString()方法
            System.out.println(s1.toString());//如果打印的不是想要的可以自行重写方法
            System.out.println(s2.toString());//alt+insert选择toString()可以快速重写
            System.out.println("--------------------");
    
            //equals()方法 判断两个对象是否相等
            System.out.println(s1.equals(s2));//输出false
            Demo01 p1 = new Demo01("小明",17);
            Demo01 p2 = new Demo01("小明",17);
            System.out.println(p1.equals(p2));//因为地址不一样，输出还是false
            //如果输入内容是一样的，想返回true，可以重写equals()方法
        }
    }

**equals() 方法覆盖步骤（重写）：**

1.  比较两个引用是否指向同一个对象；
2.  判断 obj 是否为 null ；
3.  判断两个引用指向的实际对象类型是否一致；
4.  强制类型转换；
5.  依次比较各个属性值是否相同；  
    ![在这里插入图片描述][c6b17cc164d64ed8bfe9676a49bcad42.png]

![在这里插入图片描述][689d43a44902420496e681d31222b73e.png]

## finalize() 对象 ##

*  当对象被判定为垃圾对象时，由JVM调用此方法，用以标记垃圾对象，进入回收队列；
    
     *  垃圾对象：没有有效引用指向此对象时，为垃圾对象；
     *  垃圾回收：由GC销毁垃圾对象，释放数据存储空间；
     *  自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象；
     *  手动回收机制：使用 System.gc() ； 通知JVM执行垃圾回收；

![在这里插入图片描述][ebab43ac3a14463d9d8b6d26f6407c09.png]  
![在这里插入图片描述][fd818f953d9648fda69702901e687d2d.png]

--------------------

# 03 包装类 #

什么是包装类:

*  基本数据类型所对应的引用数据类型；
 *  Object 可统一所有数据（也就是所有类型的数据都可以用Object类型来接收），包装类的默认值时null；  
    ![在这里插入图片描述][f02da3064d6a4a719a4b7d71b1bc26b7.jpeg]

> 可以在 [JDK API 手册][API] 查找，在 java.lang 包里

## 类型转换：装箱和拆箱 ##

*  基本类型变量存在栈里面；
 *  引用类型变量存在堆里面；
 *  装箱：基本变量转成引用类型，放到堆里面
 *  拆箱：引用类型转成基本类型，放到栈里面  
    ![在这里插入图片描述][16ce2d61986a43d98f00c900cc964d6e.png]

public class Demo02 {
        
        public static void main(String[] args) {
        
            //类型转换：装箱：基本类型转成引用类型的过程
            int num = 18;//基本类型
            //使用Integer类创建对象
            Integer integer1 = new Integer(num);
            Integer integer2 = Integer.valueOf(num); //两者一样
            System.out.println(integer1);//输出18
    
            //类型转换：拆箱：引用类型转换成基本类型
            Integer integer3 = new Integer(100);
            int num2 = integer3.intValue();
            System.out.println(num2);//输出100
    
            //JDK1.5以后，提供自动装箱和拆箱
            int age = 30;
            //自动装箱
            Integer integer4 = age;
            //自动拆箱
            int age1 = integer4;
            System.out.println(integer4);//输出30
            System.out.println(age1);//输出30
        }
    }

其实JDK1.5以后的自动装箱拆箱是编译器加的，反编译后可看到手动的方法；

## 基本类型和字符串之间的转换 ##

*  perseXXX() 静态方法：能够把字符串转换为不同的基本类型

转为的类.perse转为的类();
    Integer.perseInt(str);  String 转 int
    Boolean.perseBoolean(str); String 转 boolean

//基本类型和字符串之间转换
    public class Demo03 {
        
        public static void main(String[] args) {
        
            //基本类型转成字符串
            int n1 = 100;
            //方法一：+"" (加号和空字符)
            String s1 = n1+"";
            //方法二：使用Integer中的toString()方法
            String s2 = Integer.toString(n1);
            System.out.println(s1);
            System.out.println(s2);
            //还可以使用toString()的重载方法toString(int i,int radix)将i以radix进制输出
            String s3 = Integer.toString(n1,2);
            System.out.println(s3); //将n1以2进制形式输出
    
            //字符串转为基本类型
            String str = "128";
            //使用Integer.parseXXX();
            int n2 = Integer.parseInt(str); //只有数值类型的字符串才能转为int "12x"这样就不行
            System.out.println(n2);
    
            //字符串转为boolean类型:"true"转为true，非"true"都转为false
            String str2 = "true";
            String str3 = "lololo"; //只要不是"true"都输出false
            boolean b1 = Boolean.parseBoolean(str2);
            boolean b2 = Boolean.parseBoolean(str3);
            System.out.println(b1);
            System.out.println(b2);
        }
    }

## Integer整数缓冲区 ##

*  Java预先创建了256个常用的整数包装类型对象；
 *  在实际应用中，对已创建的对象进行复用；
 *  Crtl+Alt+点击包名或方法名 可查看源码，可以查看缓冲区数值范围

public class Demo04 {
        
        public static void main(String[] args) {
        
            //面试题
            Integer integer1 = new Integer(100);
            Integer integer2 = new Integer(100);
            System.out.println(integer1 == integer2);//输出false 因为地址不一样
    
            Integer integer3 = 100;//自动装箱，相当于下面这个
            Integer integer4 = Integer.valueOf(100);
            System.out.println(integer3 == integer4);//true
    
            Integer integer5 = 200;//自动装箱，相当于下面这个
            Integer integer6 = Integer.valueOf(200);
            System.out.println(integer5 == integer6);//false 因为valueOf()缓冲区[-128.127]256个处理元素
            //在缓冲区数值范围以内，如果相同，就直接赋予地址，所以在[-128,127]内的数值相同，地址也相同，超出就不同了
        }
    }

--------------------

# 04 String 类 #

*  字符串是常量，创建之后不可改变；
 *  字符串字面存储值在字符串池中，可以共享；
 *   *  String s = “Hello”; //产生一个对象，字符串池中存储；
 *  String s = new String (“Hello”); //产生两个对象，堆、池各存储一个  
    ![在这里插入图片描述][dde6c9ba9b794847ab807a2de0214ef2.png]

![在这里插入图片描述][c03789c53bd94d79809dc21b1fb3b36f.png]

## 常用方法 ##

public void append(); 在字符串末尾添加
    
    public int length(); 返回字符串的长度
    
    public char charAt(int );根据下标获取字符
    
    public boolean contains(String str);判断当前字符串是否包含str
    
    public char[] toCharArray(); 将字符串转换成数组
    
    public int indexOf(String str); 查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1；
    
    public int lastIndexOf(String str); 查找字符串在当前字符串中最后一次出现的下标索引
    
    public String trim(); 去掉字符串前后的空格
    
    public String toUpperCase(); 将小写转成大写
    
    public boolean endsWith(String str);  判断字符串是否是以str结尾
                   startsWith()
    
    public String replace (char oldChar,char newChar); 将旧字符串替换成新字符串
    
    public String[] split (String str); 根据str做拆分
    
    equals()；比较相等；      compareTo() 比较大小

实例：

public class Demo01 {
        
        public static void main(String[] args) {
        
            String name1 = "hello";//"hello"常量存储在字符串池中
            name1 = "你好";//“你好”赋值给name变量
            //给字符串赋值时，并没有修改数据，而是重新开辟一个空间（不可变性）
            String name2 = "你好";
    
            //字符串的另一种创建方式
            String str1 = new String("JAVA");//两个对象，浪费空间
            String str2 = new String("JAVA");
            System.out.println(str1==str2);//false 对象不一样，地址不一样（但堆里面的对象指向字符串池中的是同一个""JAVA）
            System.out.println(str1.equals(str2));//字符串比较不要用==，要用equals()方法：比的是数据，不是地址
    
            //字符串方法的使用
            //length(); 返回字符串的长度
            //harAt(int );根据下标获取字符
            //contains(String str);判断当前字符串是否包含str
            String content = "JAVA";
            System.out.println(content.length());//输出9
            System.out.println(content.charAt(1));//输出A
            System.out.println(content.contains("JA"));//true
            System.out.println(content.contains("C++"));//false
    
            //toCharArray(); 将字符串转换成数组
            //indexOf(String str); 查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1；
            //lastIndexOf(String str); 查找字符串在当前字符串中最后一次出现的下标索引
            System.out.println(Arrays.toString(content.toCharArray()));//[J, A, V, A]
            System.out.println(content.indexOf("A"));//1
            System.out.println(content.lastIndexOf("A"));//3
    
            //trim(); 去掉字符串前后的空格
            //toUpperCase(); 将小写转成大写
            //endWith(String str);  判断字符串是否是以str结尾
            String content2 = "  hello world  ";
            System.out.println(content2.trim());//hello world
            System.out.println(content2.toUpperCase());//HELLO WORLD
            String filename = "hello.java";
            System.out.println(filename.endsWith(".java"));//true
            System.out.println(filename.startsWith("hello"));//true
    
            //replace(char oldChar,char newChar); 将旧字符串替换成新字符串
            //split(String str); 根据str做拆分
            String text = "我爱JAVA，JAVA真香";
            String say = "JAVA，是 YYDS JAVA N0.1";
            System.out.println(text.replace("JAVA","C++"));//我爱C++，C++真香
            String[] array = say.split(" ");//根据空格来拆分
            for (String string:array
                 ) {
        
                System.out.println(string);
            }
            String[] arr = say.split("[ ，]");//根据空格和逗号来拆分
            for (String string:arr
            ) {
        
                System.out.println(string);
            }
    
            //equals()
            //compareTo() 比较大小
            String s1 = "hello";
            String s2 = "HELLO";
            System.out.println(s1.equals(s2));//false
            System.out.println(s1.equalsIgnoreCase(s2));//true 忽略大小写比较
            String s3 = "abc";
            String s4 = "xyz";
            System.out.println(s3.compareTo(s4));//-23 只比第一个 a=97 x=120 位置相减
            String s5 = "abcdef";
            System.out.println(s3.compareTo(s5));//-3 前面的值都相等，就比长短
        }
    }

## 案例演示： ##

> 需求: 已知 String str = “this is a text”;
> 
> 1.  将 str 中的单词单独获取出来；
> 2.  将 str 中的 text 替换为 practice；<---------------
> 3.  在 text 前面插入一个 easy； <----------------
> 4.  将每个单词的首字母改为大写；

public class Demo02 {
        
        /*      已知 String str = "this is a text";
                1. 将 str 中的单词单独获取出来；
                2. 将 str 中的text替换为practice；
                3. 在 text 前面插入一个 easy；
                4. 将每个单词的首字母改为大写；
        */
        public static void main(String[] args) {
        
            String str = "this is a text";
            //1. 将str中的单词单独获取出来
            String[] array = str.split(" "); //用空格分开
              //用个遍历来输出数组
            for (String s:array
                 ) {
        
                System.out.println(s);
            }
            //2. 将str中的text替换为practice
            String str2 = str.replace("text","practice");
            System.out.println(str2);
            //3.text前加easy
            String str3 = str.replace("text","easy text");
            System.out.println(str3);
            //4.每个单词首字符大写
            for (int i = 0; i < array.length; i++) {
        
                char first = array[i].charAt(0);
                char upperfirst = Character.toUpperCase(first);//把第一个字符转成大写
                String news = upperfirst+array[i].substring(1);//把大写首字母拼接起来
                System.out.println(news);
            }
        }
    }

--------------------

# 05 可变字符串 StringBuffer&Builder #

（可看作String的拓展类）

*  StringBuffer：可变长字符串，JDK1.0提供，运行效率慢，线程安全；
 *  StringBuilder：可变长字符串，JDK5.0提供，运行速率快、线程不安全；
 *  比String类效率高，节省内存；
 *  StringBuffer类和StringBuilder类方法是一样的，单线程更推荐使用StringBuilder

/*
            StringBuffer 和 StringBuilder 的使用
            区别1；效率比String高
            区别2：比String节省内存
     */
    public class Demo03 {
        
        public static void main(String[] args) {
        
            StringBuffer sb = new StringBuffer();
            //append(); 追加
            sb.append("Java");
            System.out.println(sb.toString());//Java
            sb.append("世界第一");
            System.out.println(sb.toString());//Java世界第一
    
            //insert();添加
            sb.insert(0,"我认为");
            System.out.println(sb.toString());
    
            //replace();替换
            sb.replace(0,3,"Hello");//将0到2个字符(含头不含尾)替换为"Hello"
            System.out.println(sb.toString());//Hello为Java世界第一
    
            //delete();删除
            sb.delete(0,5); //将0到4个字符删除（含头不含尾）
            System.out.println(sb.toString());//Java世界第一
    
            //reverse();反转
            sb.reverse();
            System.out.println(sb.toString());//一第界世avaJ
    
            //delete(0,str.length());清空
            sb.delete(0, sb.length());
            System.out.println(sb.length());//0
        }
    }

//验证StringBuilder效率高于String
    public class Demo04 {
        
        public static void main(String[] args) {
        
            //String开始时间
            long start1 = System.currentTimeMillis();
            String s1 = ""; //初始一个空字符串
            for (int i = 0; i < 99999; i++) {
        
                s1 += i;
            }
            long end1 = System.currentTimeMillis(); //结束时间
            System.out.println("String用时："+(end1-start1));//String用时：24550
    
            //StringBuilder时间
            long start2 = System.currentTimeMillis();
            StringBuilder s2 = new StringBuilder();
            for (int i = 0; i < 99999; i++) {
        
                s2.append(i);
            }
            long end2 = System.currentTimeMillis();
            System.out.println("StringBuilder用时："+(end2-start2));//StringBuilder用时：2
        }
    }

--------------------

# 06 BigDecimal 类 #

![在这里插入图片描述][2ac5e3ebe7c84633bc4e04c3b095a636.png]  
因为BigDecimal是精确存储的；

*  位置：java.math 包中
 *  作用：精确计算浮点数
 *  创建方式：BigDecimal bd = new BidDecimal (“1.0”);
 *  注意：赋值要以字符串的形式，避免精度丢失
 *  方法：
    
     *  BigDecimal add (BigDecimal bd); 加
     *  BigDecimal subtract (BigDecimal bd); 减
     *  BigDecimal multiply (BigDecimal bd); 乘
     *  BigDecimal divide (BigDecimal bd); 除
 *  除法：divide (BigDecimal bd, int scale , RoundingMode mode) ;
    
     *  参数 scale ：指定精确到小数点后几位
     *  参数 mode：
        
         *  指定小数部分的取舍模式，通常采用四舍五入的模式；
         *  取值为 BigDecimal.ROUND\_HALF\_UP

import java.math.BigDecimal;
    
    public class Demo01 {
        
        public static void main(String[] args) {
        
            double d1 = 1.0;
            double d2 = 0.9;
            System.out.println(d1-d2);//0.09999999999999998
            double result=(1.4-0.5)/0.9;
            System.out.println(result);//0.9999999999999999
            //因为double、float 是用近似值存储的
            //对于高精度计算 比如银行 就不行
            //需要使用精度更高的类 -> BigDecimal
    
            //BigDecimal 大的浮点数精确计算
            BigDecimal num1 = new BigDecimal("1.0"); //赋值一定要用字符串！！！
            BigDecimal num2 = new BigDecimal("0.9");//内部会运算把字符串转为数值类型
            //类运算不能用加减乘除这些运算符，得用方法
            //subtract减法
            BigDecimal num3 = num1.subtract(num2);//subtract减法
            System.out.println(num3);//0.1
            //add加法
            //multiply乘法
            //divide除法
            BigDecimal x = new BigDecimal("1.4")
                           .subtract(new BigDecimal("0.5"))
                           .divide(new BigDecimal("0.9"));
            System.out.println(x);//1
    
    //      BigDecimal r = new BigDecimal("10").divide(new BigDecimal("3"));
            //因为10/3除不尽，没有告诉要保留几位小数，所以会报错
            BigDecimal r = new BigDecimal("10").divide(new BigDecimal("3"),3,BigDecimal.ROUND_HALF_UP);
            System.out.println(r);//3.333                                    //保留三位小数，以四舍五入的形式ROUND_HALF_UP
        }
    }

--------------------

# 07 Date 类 #

*  Date 表示特定的瞬间，精确到毫秒；
 *  Date 类中的大部分方法都已经被 Calendar 类中的方法所取代；
 *  时间单位
    
     *  1 秒 = 1000毫秒
     *  1毫秒 = 1000微秒
     *  1微秒 = 1000纳秒
 *  详细方法API看[JDK帮助文档][API]

import java.util.Date;
    
    public class Demo01 {
        
        public static void main(String[] args) {
        
            //创建Date类
            //今天
            Date date1 = new Date();
            System.out.println(date1.toString());//Sun Sep 11 16:10:07 CST 2022
            System.out.println(date1.toLocaleString());//2022-9-11 16:10:07
            //昨天
            Date date2 = new Date(date1.getTime()-(60*60*24*1000));
            System.out.println(date2.toLocaleString());//2022-9-10 16:15:40
    
            //方法after before
            boolean b1 = date1.after(date2);
            System.out.println(b1);//true
            boolean b2 = date1.before(date2);
            System.out.println(b2);//false
    
            //比较compareTo()
            int i = date1.compareTo(date2);
            System.out.println(i);//1 输出1为大 输出-1为小，输出0为一样
    
            boolean b3 = date1.equals(date2);
            System.out.println(b3);//false
        }
    }

--------------------

# 08 Calendar 类 #

*  Calendar 提供了获取或设置各种日历字段的方法；
 *  构造方法：

protected Calendar ();  由于修饰符是 protected ，所以无法直接创建该对象；

但可以通过静态方法来  
![在这里插入图片描述][b0c6a1e79c2447bb87bd36fc41528bd7.png]

import java.util.Calendar;
    
    public class Demo02 {
        
        public static void main(String[] args) {
        
            //创建Calendar对象
            Calendar calendar = Calendar.getInstance();
            System.out.println(calendar.getTime().toLocaleString());//2022-9-11 16:44:21
            System.out.println(calendar.getTimeInMillis());//1662885861433
            //获取时间信息
            //获取年
            int year = calendar.get(Calendar.YEAR);//全是常量字段
            //获取月 0-11
            int month = calendar.get(Calendar.MONTH);
            //获取日
            int day = calendar.get(Calendar.DAY_OF_MONTH);
            //获取小时
            int hour = calendar.get(Calendar.HOUR_OF_DAY);//HOUR12小时 HOUR_OF_DAY24小时
            //获取分钟
            int minute = calendar.get(Calendar.MINUTE);
            //获取秒
            int second = calendar.get(Calendar.SECOND);
            System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);
            //2022年9月11日16:44:21
            //修改时间
            Calendar date = Calendar.getInstance(); //获取当前时间
            System.out.println(date.getTime().toLocaleString());
            date.set(Calendar.DAY_OF_MONTH,4);//修改到4号
            System.out.println(date.getTime().toLocaleString());//2022-9-4 16:50:42
            date.set(Calendar.HOUR,0);
            System.out.println(date.getTime().toLocaleString());//2022-9-4 12:50:42
    
            //add方法修改时间
            date.add(Calendar.YEAR,-3);//倒退三年
            System.out.println(date.getTime().toLocaleString());//2019-9-4 12:50:42
    
            //getActualMaximum();获取最大日期
            int max1 = date.getActualMaximum(Calendar.DAY_OF_MONTH);//30 当前月 最多天数
            System.out.println(max1);
    
            int min1 = date.getActualMinimum(Calendar.DAY_OF_MONTH);//1 当前月最小天数
            System.out.println(min1);
    
            int max2 = date.getActualMaximum(Calendar.MONTH);//11 最大多少个月，但因为是0-11，所以相当于12个月
            System.out.println(max2);
            int min2 = date.getActualMinimum(Calendar.MONTH);
            System.out.println(min2);//0
        }
    }

--------------------

# 09 SimpleDateFormat 类 #

*  SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类；
 *  进行格式化（日期 -> 文本）；解析（文本 -> 日期）；

常用的时间模式字母：  
![在这里插入图片描述][f8a5c50e004748acb344c7b23fd030ee.png]

import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class Demo03 {
        
        public static void main(String[] args) throws Exception{
        
            //创建SimpleDateFormat对象   y年M月
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
            SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
            SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy/MM/dd");
            //创建Date
            Date date = new Date();
            //格式化date (把日期转成字符串)
            String str1 = sdf1.format(date);
            String str2 = sdf2.format(date);
            String str3 = sdf3.format(date);
            System.out.println(str1);//2022年09月11日 17:35:53
            System.out.println(str2);//2022/09/11 17:35:53
            System.out.println(str3);//2022/09/11
    
            //解析 (把字符串转成日期)
            Date date2 = sdf1.parse("2019年05月02日 05:20:28");//会有异常，先抛出去
            System.out.println(date2.toLocaleString());
        }
    }

--------------------

# 10 System 类 #

> **System.out.println (“换行输出”)；  
> System.out.print (“不换行输出”)；  
> System.out.printf (“格式控制部分”，表达式1，表达式2，…，表达式n)；  
> System.out.printf (“%d,%f”,12,12.8)；  
> System.out.printf (“%md 输出占m列的int数据”,12345)；  
> System.out.printf (“%m.nf 输出浮点数据占m列，保留n位”,3.14159)；**

*  System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的（不用创建对象）；

![在这里插入图片描述][13466d3270c24811aa0d2069f62be633.png]

public class Demo01 {
        
        public static void main(String[] args) {
        
            //arraycopy(src,srcPos,dest,destPos,length):数组的复制 /* 属于native本地方法，是JVM调用C/C++实现的，所以效率极高*/
            //src 源数组
            //srcPos 从哪个位置开始复制0
            //dest 目标数组
            //destPos 目标数组的位置
            //length 复制的长度
            int[] array = {
        1,2,3,4,5,6,7,8};
            int[] dest = new int[8];
            System.arraycopy(array,0,dest,0,8);
            for (int i = 0; i < dest.length; i++) {
        
                System.out.print(dest[i]+"\t");//1	2	3	4	5	6	7	8
            }
            //Arrays.copyOf(original,newLength) 也是数组复制
    
            //System.currentTimeMillis() 返回1970年...至今时间，可以用来计时
            long start = System.currentTimeMillis();
            {
        
                for (int i = 0; i < 999999; i++) {
        
                    for (int j = 0; j < 99999; j++) {
        
                        int result = i + j;
                    }
                }
            }
            long end = System.currentTimeMillis();
            System.out.println("用时"+(end - start));//用时6
    
            //System.gc(); 建议垃圾回收；（不赋值给变量会被回收 例如 new Student("小明"，3)）
    
            //System.exit(); 退出jvm
            System.exit(0); //0表示正常退出；非0表示异常退出
            System.out.println("end");//这段代码不会被执行
        }
    }

--------------------

# 11 Math 类 #

java.lang.Math 提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一般为double类型；如果需要强大的数学运算能力，计算高等数学中的相关内容，可以使用 apache commons 下面的Math类

public class Demo01 {
        
        public static void main(String[] args) {
        
            //静态方法，无需new直接用
            System.out.println(Math.PI); //3.141592653589793
            System.out.println(Math.round(3.14));//3 四舍五入
            System.out.println(Math.ceil(3.14));//4.0 向上取整
            System.out.println(Math.floor(3.14));//3.0 向下取整
    
            System.out.println(Math.sqrt(64));//8.0 开平方
            System.out.println(Math.pow(2,5));//32.0  幂
    
            System.out.println(Math.abs(-5));//5  绝对值
            System.out.println(Math.max(30,40));//40 最大值
            System.out.println(Math.min(30,40));//30 最小值
    
            System.out.println(Math.random());//0.9026453415035203
        }
    }

--------------------

# 12 Random 类 #

Math类中虽然为我们提供了产生随机数的方法 Math.random() ；但是通常我们需要的随机数范围并不是 \[0,1\] 之间的 double 类型的数据，这就需要对其进行一些复杂的运算，如果使用 Math.random() 计算过于复杂的话，我们可以使用另外一种方式得到随机数，即 Random 类，这个给类是专门用来生成随机数的，并且 Math.random() 底层调用的就是 Random 的 nextDouble() 方法;

*  使用 Random 生成 \[10,40\] 之间的随机正数

import java.util.Random;
    
    public class TestRandom {
        
        public static void main(String[] args) {
        
            //Random rand = new Random(100);参数100是种子数 
            //只要种子数和nextInt()中的参数一致，每次生成的随机数都是一样的（伪随机数）
            Random rand = new Random();
            //产生 0-10 的随机整数
            int num1 = rand.nextInt(10);
            System.out.println(num1);
            //获得4位随机整数 1000 - 9999
            int num2 = rand.nextInt(9000)+1000;
            System.out.println(num2);
            
            //还有 nextDouble()
            //     nextFloat()
            //     nextBoolean()
            //         ...
            //        同理
        }
    }

--------------------

[21a1177d21e34193bf7a522812c511ab.png]: https://img-blog.csdnimg.cn/21a1177d21e34193bf7a522812c511ab.png
[API]: https://download.csdn.net/download/Lov1_BYS/86512924
[c6b17cc164d64ed8bfe9676a49bcad42.png]: https://img-blog.csdnimg.cn/c6b17cc164d64ed8bfe9676a49bcad42.png
[689d43a44902420496e681d31222b73e.png]: https://img-blog.csdnimg.cn/689d43a44902420496e681d31222b73e.png
[ebab43ac3a14463d9d8b6d26f6407c09.png]: https://img-blog.csdnimg.cn/ebab43ac3a14463d9d8b6d26f6407c09.png
[fd818f953d9648fda69702901e687d2d.png]: https://img-blog.csdnimg.cn/fd818f953d9648fda69702901e687d2d.png
[f02da3064d6a4a719a4b7d71b1bc26b7.jpeg]: https://img-blog.csdnimg.cn/f02da3064d6a4a719a4b7d71b1bc26b7.jpeg
[16ce2d61986a43d98f00c900cc964d6e.png]: https://img-blog.csdnimg.cn/16ce2d61986a43d98f00c900cc964d6e.png
[dde6c9ba9b794847ab807a2de0214ef2.png]: https://img-blog.csdnimg.cn/dde6c9ba9b794847ab807a2de0214ef2.png
[c03789c53bd94d79809dc21b1fb3b36f.png]: https://img-blog.csdnimg.cn/c03789c53bd94d79809dc21b1fb3b36f.png
[2ac5e3ebe7c84633bc4e04c3b095a636.png]: https://img-blog.csdnimg.cn/2ac5e3ebe7c84633bc4e04c3b095a636.png
[b0c6a1e79c2447bb87bd36fc41528bd7.png]: https://img-blog.csdnimg.cn/b0c6a1e79c2447bb87bd36fc41528bd7.png
[f8a5c50e004748acb344c7b23fd030ee.png]: https://img-blog.csdnimg.cn/f8a5c50e004748acb344c7b23fd030ee.png
[13466d3270c24811aa0d2069f62be633.png]: https://img-blog.csdnimg.cn/13466d3270c24811aa0d2069f62be633.png