Java内部类和常用类

苗半里

已于 2022-10-28 17:18:31 修改

阅读量375

点赞数 2

分类专栏： Java学习文章标签： java jvm 开发语言

于 2022-09-11 20:08:45 首次发布

本文链接：https://blog.csdn.net/Lov1_BYS/article/details/126786475

版权

Java学习专栏收录该内容

52 篇文章 11 订阅

订阅专栏

01 内部类

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

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

特点：

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

成员内部类：

在类的内部定义，与实例变量、实例方法同级别的类；
外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象（先创建外部类对象才能创建内部变量）；
当外部类、内部类存在重名属性时，会优先访问内部类属性；
成员内部类不能定义静态成员（但是可以定义静态常量 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();
    }
}

匿名内部类：

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

在这里插入图片描述

//接口
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帮助文档来查看；

getClass() 方法

public final Class<?> getClass(){}

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

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();
        //判断s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1==class2){
            System.out.println("属于同一个类型");
        }else{
            System.out.println("不属于同一个类型");
        }
    }
}

hashCode() 方法

public int hashCode(){}

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

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();
        //使用hashCode() 方法
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        //因为存储的地址不一样，输出的地址也是不一样的
        Demo01 s3=s1;//s1的地址赋给了s3
        System.out.println(s3.hashCode()); //输出的hashCode和s1一样
    }
}

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() 方法覆盖步骤（重写）：

比较两个引用是否指向同一个对象；
判断 obj 是否为 null ；
判断两个引用指向的实际对象类型是否一致；
强制类型转换；
依次比较各个属性值是否相同；

在这里插入图片描述

finalize() 对象

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

在这里插入图片描述

03 包装类

什么是包装类:

基本数据类型所对应的引用数据类型；
Object 可统一所有数据（也就是所有类型的数据都可以用Object类型来接收），包装类的默认值时null；

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

类型转换：装箱和拆箱

基本类型变量存在栈里面；
引用类型变量存在堆里面；
装箱：基本变量转成引用类型，放到堆里面
拆箱：引用类型转成基本类型，放到栈里面

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”); //产生两个对象，堆、池各存储一个

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()方法：比的是数据，不是地址
    }
}

在这里插入图片描述

常用方法

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”;

将 str 中的单词单独获取出来；
将 str 中的 text 替换为 practice；<---------------
在 text 前面插入一个 easy； <----------------
将每个单词的首字母改为大写；

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 类

在这里插入图片描述
因为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帮助文档

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 ，所以无法直接创建该对象；

但可以通过静态方法来
在这里插入图片描述

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

常用的时间模式字母：
在这里插入图片描述

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系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的（不用创建对象）；

在这里插入图片描述

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()
        //         ...
        //        同理
    }
}

苗半里

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java内部类和常用类

Java内部类、Object类、包装类、String类、StringBuffer&Builder类、BigDecimal类、Date类、Calendar类、SimpleDateFormat类、 System类、Math类、Random类
复制链接

扫一扫