【java基础系列】14- Java的内部类与常用类

Java的内部类与常用类

1、内部类

1.1 内部类的分类

成员内部类
静态内部类
局部内部类
匿名内部类

1.2 什么是内部类？

概念：在一个类的内部再定义一个完整的类。
特点：
- 编译之后可生成独立的字节码文件。
- 内部类可直接访问外部类的私有成员，而不破坏封装。
- 可为外部类提供必要的内部功能组件。

1.2.1 案例（一）

编译之后可生成独立的字节码文件。

package com.goshawk.chapter_02;

public class Outer {
    class Inner {

    }
}

将上述代码的文件进行编译：javac Outer.java

在这里插入图片描述

12.2 案例（二）

内部类可直接访问外部类的私有成员，而不破坏封装。

package com.goshawk.chapter_02;

public class Outer {
    private String name;

    class Inner {
        public void show(){
            System.out.println(name);
        }
    }
}

1.3 成员内部类

在类的内部定义，与实例变量、实例方法同级别的类。
外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。
- Outer out = new Outer();
- Inner in = out.new Inner();
当外部类、内部类存在重名属性时，会优先访问内部类属性。
成员内部类不能定义静态成员，但是可以定义静态常量。
- private static String country = "深圳"; ×
- private static final String country = "深圳"; ✓

1.3.1 案例（一）

创建内部对象

package com.goshawk.chapter_02;

/**
 * 外部类
 */
public class Outer {
    // 实例变量
    private String name = "李四";
    private int age = 21;

    // 内部类
    class Inner {
        private String address = "深圳";
        private String phone = "18100000001";
        // 方法
        public void show(){
            // 打印外部类的属性
            System.out.println(name);
            System.out.println(age);
            // 打印内部类的属性
            System.out.println(address);
            System.out.println(phone);
        }
    }
}

package com.goshawk.chapter_02;

import com.goshawk.chapter_02.Outer.Inner;

public class TestOuter {
    public static void main(String[] args) {
        // 创建内部对象的方式一
        // 1、创建外部类对象
        Outer outer = new Outer();
        // 2、创建内部类对象
        Inner inner = outer.new Inner();
        inner.show();
        // 创建内部对象的方式二
        Inner inner1 = new Outer().new Inner();
        inner1.show();
    }
}

1.3.2 案例（二）

当外部类、内部类存在重名属性时，会优先访问内部类属性。

package com.goshawk.chapter_02;

/**
 * 外部类
 */
public class Outer {
    // 实例变量
    private String name = "李四";
    private int age = 21;

    // 内部类
    class Inner {
        private String address = "深圳";
        private String phone = "18100000001";

        private String name = "乌米";
        // 方法
        public void show(){
            // 内部类与外部类的属性名相同，优先打印内部类的属性
            System.out.println(name);
            // 内部类的属性名和外部类的属性名相同时，使用Outer.this来进行访问外部类的属性
            System.out.println(Outer.this.name);

        }
    }
}

1.4 静态内部类

不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。
只能直接访问外部类的静态成员（实例成员需实例化外部类对象）。
- Outer.Inner inner = new Outer.Inner();
- Outer.Inner.show();
注意：只有在内部类才能使用static修饰类，外部类或者普通类是不能使用static关键字进行修饰的。

1.4.1 案例

package com.goshawk.chapter_02.section_2;

/**
 * 外部类
 */
public class Outer {
    // 实例变量
    private String name = "李四";
    private int age = 21;


    /**
     * 静态内部类，和外部类相同
     * 为什么要使用静态内部类？
     * 因为这个静态内部类要被外部类所使用，给外部提供一些功能
     */
    static class Inner {
        private String address = "上海";

        // 静态成员
        private static int count = 1000;

        public void show(){
            // 调用外部类的属性
            // 1、先创建外部类对象
            Outer outer = new Outer();
            // 2、调用外部类对象的属性
            System.out.println(outer.name);
            System.out.println(outer.age);

            // 调用静态内部类的属性
            System.out.println(address);

            // 调用静态内部类的静态属性
            System.out.println(Inner.count);
        }

    }
}

package com.goshawk.chapter_02.section_2;

public class TestOuter {
    public static void main(String[] args) {
        // 直接创建静态内部类对象
        Outer.Inner inner = new Outer.Inner();
        // 调用方法
        inner.show();
    }
}

1.5 局部内部类

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

1.5.1 案例

package com.goshawk.chapter_02.section_3;

/**
 * 外部类
 */
public class Outer {
    // 实例变量
    private String name = "李四";
    private int age = 21;

    public void show(){
        // 定义局部变量
        /**
         * 在JDK1.8之后则自动加final
         *
         * 为什么要加final呢？
         * 因为如果不加final的话，在show这个方法执行完毕后，局部变量就会释放（消失），
         *
         * 这里注意此时用于存放创建局部内部类对象的inner变量会消失，
         * 但是show方法内部创建的局部内部类对象（new Inner()）不会消失，
         * 以及局部内部类（Inner）也不会消失。
         * 如果此时的局部变量不存在，那么将导致局部内部类找不到这个局部变量address，
         * 所以这里必须要使其变成一个常量，而局部内部类引用的也不再是address，而是深圳。
         *
         * 所以说要想在局部内部类引用局部变量，则必须要使用final对局部变量进行修饰。
         *
         * 还要注意一点就是局部内部类不能声明静态变量，但是可以声明静态常量。
         */
        String address = "深圳";
        // final String address1 = "深圳";

        // 局部内部类：注意不能加任何访问修饰符
        class Inner{
            // 局部内部类的属性
            private String phone = "13100000001";
            private String email = "lisi@163.com";
            private final static int count = 1000;

            public void show2(){
                // 访问外部类的属性
                System.out.println(name);
                System.out.println(Outer.this.age);
                // 访问内部类的属性
                System.out.println(phone);
                System.out.println(this.email);
                // 访问局部变量，（在JDK1.7要求变量必须是常量，也就是要加上final，但是在JDK1.8之后则自动加final）
                System.out.println(address);
            }
        }
        // 创建局部内部类对象
        Inner inner = new Inner();
        inner.show2();
    }
}

package com.goshawk.chapter_02.section_3;

public class TestOuter {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }
}

1.6 匿名内部类

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

1.6.1 案例（一）

实现接口的匿名类

package com.goshawk.chapter_02.section_4;

/**
 * 接口
 */
public interface Usb {
    // 服务
    void service();
}

package com.goshawk.chapter_02.section_4;

/**
 * Mouse类实现了Usb接口
 */
public class Mouse implements Usb{
    @Override
    public void service() {
        System.out.println("连成功连接电脑，鼠标开始工作");
    }
}

package com.goshawk.chapter_02.section_4;

public class TestUsb {
    public static void main(String[] args) {
        // 创建接口类型的变量
        Usb usb = new Mouse();

        usb.service();

        // 局部内部类
        class Fan implements Usb{
            @Override
            public void service() {
                System.out.println("成功连接电脑，风扇开始工作");
            }
        }
        // 使用局部内部类创建对象
        Usb usb1 = new Fan();
        usb1.service();

        // 使用匿名内部类进行优化（相当于创建了一个局部内部类），new Usb() 可以是父类，也可以是接口
        Usb usb2 = new Usb() {
            @Override
            public void service() {
                System.out.println("成功连接电脑，风扇2开始工作");
            }
        };
        usb2.service();
    }

}

1.6.2 案例（二）

匿名子类（继承父类）

package com.goshawk.chapter_02.section_4;

public class Animal {
    private String name;
    // 品种
    private String breed;
    // 年龄
    protected int age;
    // 性别
    public String sex;

    public Animal(){}

    public Animal(String name) {
        this.name = name;
    }

    public void eat(){
        System.out.println("动物吃东西");
    }

    public void sleep(){
        System.out.println("动物睡觉");
    }
}

package com.goshawk.chapter_02.section_4;

public class Bird extends Animal{
    @Override
    public void eat() {
        System.out.println("cuckoo - 杜鹃吃虫子");
    }

    public void show() {
        System.out.println("大家好，我是杜鹃");
    }
}

package com.goshawk.chapter_02.section_4;

public class TestBird {


    public static void main(String[] args) {
        Bird bird = new Bird();
        bird.eat();

        // 匿名子类，继承自Animal类，可以重写父类方法
        Animal bird1 = new Animal(){
            @Override
            public void eat() {
                System.out.println("Magpie - 喜鹊鸟吃虫子");
                super.sleep();
                TestBird testBird = new TestBird();
                System.out.println("访问外部类final修饰的变量：");
            }
        };
        bird1.eat();


    }
}

1.6.3 案例（三）

匿名内部类访问其外部类方法

package com.goshawk.chapter_02.section_4;

public class Dog {
    private final String GOGS = "狗类";

    public void sleep(){
        System.out.println("匿名内部类访问其外部类方法");
        System.out.println("狗在睡觉");
    }

    class Poodle {
        private String name = "小帽";
        private String breed = "贵宾犬";

        public Poodle(String name, String breed){
            this.name = name;
            this.breed = breed;
        }

        public void eat(){
            System.out.println(breed + " " + name + "在吃狗粮");
        }

    }
    Poodle poodle = new Poodle("小华", "哈士奇"){
        @Override
        public void eat() {
            System.out.println("访问外部类final修饰的变量:" + GOGS);
            System.out.println("访问外部类方法");
            sleep();

            super.eat();
        }
    };

    public void print() {
        poodle.eat();
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.print();
    }

}

注意：使用javac Dog.java进行编译后，匿名内部类编译之后可生成独立的字节码文件。
- 匿名内部类：Dog$1.class。
- 内部类：Dog$Poodle.class。

在这里插入图片描述

1.7 为什么要使用内部类？

每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个（接口的）实现，对于内部类都没有影响。
方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏。
方便编写事件驱动程序。
方便编写线程代码。

1.8 内部类的作用

实现了更好的封装，普通类（非内部类）的访问修饰符不能为private或protected，而内部类可以。当我们将内部类声明为private时，只有外部类可以访问内部类，很好地隐藏了内部类。
内部类可以继承（extends）或实现（implements）其他的类或接口，而不受外部类的影响。
内部类可以直接访问外部类的字段和方法，即使是用private修饰的，相反的，外部类不能直接访问内部类的成员。

2、`Object`类

超类。基类，所有类的直接或间接父类，位于继承树的最顶层。
任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承。
Object类中所定义的方法，是所有对象都具备的方法。
Object类型可以存储任何对象。
- 作为参数，可接收任何对象。
- 作为返回值，可返回任何对象。

3、`Object`类常用方法

3.1 `getClass()`方法

public final Class<?> getClass(){}
返回引用中存储的实际对象类型。
应用：通常用于判断两个引用中实际存储对象类型是否一致。

3.1.1 案例

package com.goshawk.chapter_02.section_5;

public class Student {
    private String name;
    private int age;

    public Student(){}

    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package com.goshawk.chapter_02.section_5;

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("小明", 20);
        Student s2 = new Student("小赵", 21);
        // 判断s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1==class2){
            System.out.println("s1和s2属于同一个类型");
        }else {
            System.out.println("s1和s2不属于同一个类型");
        }
    }
}

3.2 `hashCode()`方法

public int hashCode(){}
返回该对象的哈希码值。
哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值。
一般情况下相同对象返回相同哈希码。

3.2.1 案例

package com.goshawk.chapter_02.section_5;

public class Student {
    private String name;
    private int age;

    public Student(){}

    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package com.goshawk.chapter_02.section_5;

public class TestStudent {
    public static void main(String[] args) {

        Student s1 = new Student("小明", 20);
        Student s2 = new Student("小赵", 21);

        // hashCode()
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        Student s3 = s1;
        System.out.println(s3.hashCode()); // s3.hashCode() == s1.hashCode()
    }
}

3.3 `toString()`方法

public String toString(){}
返回该对象的字符串表示（表现形式）。
可以根据程序需求覆盖该方法，如：展示对象各个属性值。

3.3.1 案例

package com.goshawk.chapter_02.section_5;

public class Student {
    private String name;
    private int age;

    public Student(){}

    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
		// 重写toString()
    public String toString() {
        return name + ": " + age;
    }
    
    
}

package com.goshawk.chapter_02.section_5;

public class TestStudent {
    public static void main(String[] args) {

        Student s1 = new Student("小明", 20);
        Student s2 = new Student("小赵", 21);

        // toString()
        System.out.println("-----------3、toString()-----------");
        System.out.println(s1.toString());
        System.out.println(s2.toString());
    }
}

3.4 `equals()`方法

public boolean equals(Object obj){}
默认实现为（this == obj），比较两个对象地址是否相同。
可进行覆盖，比较两个对象的内容是否相同。

3.4.1 `equals()`方法覆盖步骤

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

package com.goshawk.chapter_02.section_5;

import java.util.Objects;

public class Student extends Object{
    private String name;
    private int age;

    public Student(){}

    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


    // 重写equals()
    @Override
    public boolean equals(Object obj) {
        // 判断两个对象是否是同一个引用
        if (this==obj){
            return true;
        }
        // 判断obj是否null
        if (obj==null){
            return false;
        }
        // 判断是否是同一个类型
//        if (this.getClass()==obj.getClass()){
//
//        }
        // instanceof判断对象是否是某种类型
        if (obj instanceof Student){
            // 强制转换类型
            Student s = (Student) obj;
            // 比较属性
            if (this.name.equals(s.getName())&&this.age==getAge()){
                return true;
            }
        }
        return false;
    }
}

package com.goshawk.chapter_02.section_5;

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("小明", 20);
        Student s2 = new Student("小赵", 21);
        System.out.println("-----------1、getClass()-----------");

        // equals()，判断两个对象是否相等
        System.out.println("-----------4、equals()-----------");
        System.out.println(s1.equals(s2));

        Student s4 = new Student("小李", 23);
        Student s5 = new Student("小李", 23);
        System.out.println(s4.equals(s5));
    }
}

3.5 `finalize()`方法

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

3.5.1 案例

package com.goshawk.chapter_02.section_5;

import java.util.Objects;

public class Student extends Object{
    private String name;
    private int age;

    public Student(){}

    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println(this.name + "对象被回收");
    }
}

package com.goshawk.chapter_02.section_5;

public class TestStudent2 {
    public static void main(String[] args) {
//        Student s1 = new Student("小明", 20);
//        Student s2 = new Student("小赵", 21);
//        Student s3 = new Student("小李", 23);
//        Student s4 = new Student("小甘", 24);
        new Student("小明", 20);
        new Student("小赵", 21);
        new Student("小李", 23);
        new Student("小甘", 24);

        // 回收垃圾
        System.gc();
        System.out.println("回收垃圾");


    }
}

4、包装类

4.1 什么是包装类？

基本数据类型所对应的引用数据类型。
Object可统一所有数据，包装类的默认值是null。

4.2 包装类对应

基本数据类型	包装类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

4.3 类型转换与装箱、拆箱

4.3.1 什么是装箱？

装箱：将基本数据类型转换为包装类类型（引用类型）

Integer integer1 = new Integer(num1);
Integer integer2 = Integer.valueOf(num1);

4.3.2 什么是拆箱？

拆箱：将包装类类型转换为基本数据类型

Integer integer3 = new Integer(100);
int num2 = integer3.intValue();

4.3.3 自动装箱和自动拆箱

package com.goshawk.chapter_02.section_6;

public class Demo {
    public static void main(String[] args) {
        // 类型转换：装箱 --> 基本类型转成引用类型的过程

        // 基本类型
        int num1 = 18;
        // 使用Integer类创建对象

        // JDK1.5之前
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);
        System.out.println("手动装箱");
        System.out.println(integer1);
        System.out.println(integer2);

        // 类型转换：拆箱 --> 引用类型转成基本类型的过程
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();
        System.out.println("手动拆箱");
        System.out.println(num2);

        // JDK1.5之后，提供自动装箱和拆箱
        int age = 30;
        // 自动装箱
        Integer integer4 = age;
        System.out.println("自动装箱");
        System.out.println(integer4);
        // 自动拆箱
        int age2 = integer4;
        System.out.println("自动拆箱");
        System.out.println(age2);
    }
}

使用自动装箱或者自动拆箱后，将编译之后的.class文件进行反编译，会自动转成手动装箱或者手动拆箱的格式。

4.3.4 基本类型和字符串转换

8种包装类提供不同类型间的转换方式：
- Number父类中提供的6个共性方法。
- parseXXX()静态方法。XXX - > 基本类型
- valueOf()静态方法。
注意：需保证类型兼容，否则抛出NumberFormatException异常。

package com.goshawk.chapter_02.section_6;

public class Demo {
    public static void main(String[] args) {

        // 基本类型和字符串之间转换
        // 1、基本类型转成字符串
        int n1 = 15;
        // 1.1> 使用 + 号
        String s1 = n1 + "";
        // 1.2> 使用Integer中的toString()方法
        String s2 = Integer.toString(n1);
        // 1.3> 使用使用Integer中的toString()的重载方法
        String s3 = Integer.toString(n1, 16); // radix 表示基数，我这里表示转成16进制

        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);

        // 2、字符串转成基本类型

        String str = "150"; // 这里注意不能出现非数字类型
        // 使用Integer.parseXXX();
        int n2 = Integer.parseInt(str);
        System.out.println(n2);

        // boolean字符串转成基本类型 "true" -> true ，非"true" ->false（如果给的字符串不是true，那么将转成false）
        String str2 = "true";
        boolean b1 = Boolean.parseBoolean(str2);
        System.out.println(b1);

    }
}

4.3.5 整数缓冲区

Java预先创建256个常用的整数包装类型对象。
在实际应用当中，对已创建的对象进行复用。

package com.goshawk.chapter_02.section_6;

public class Demo1 {
    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.valueOf方法
        Integer integer4 = 100;
        // Integer integer4 = Integer.valueOf(100);
        System.out.println(integer3 == integer4); // true 因为100在：-128 ~ 127之间内（为什么是这个范围呢？参考Integer.valueOf的源码）

        Integer integer5 = 200; // 自动装箱
        Integer integer6 = 200;
        System.out.println(integer5 == integer6); // false  因为200不在：-128 ~ 127之间内
    }
}

5、`String`类

5.1 `String`的概述

字符串是常量，创建之后不可改变。
字符串字面值存储在字符串池中，可以共享。（字符串池在方法区中；方法区在JDK1.8之前也称为永久代，JDK1.8之后称为元空间。）
String s = "Hello";产生一个对象，字符串池中存储。
String s = new String("Hello"); // 产生两个对象，堆、字符串池各存储一个 。

package com.goshawk.chapter_02.section_6;

public class Demo2 {
    public static void main(String[] args) {
        String name = "hello"; // 常量存储在字符串池中
        System.out.println(name.hashCode());
        name = "lisi"; // 李四赋值给name变量，给字符串赋值时，并没有修改数据，而是重新开辟一个空间。
        System.out.println(name.hashCode());
        String name1 = "lisi";
        System.out.println(name1.hashCode());

        // 字符串的创建方式
        String str = new String("Java");
        String str2 = new String("Java");
        System.out.println(str==str2); // -> false
        System.out.println(str.equals(str2)); // -> true
    }
}

在这里插入图片描述

5.2 `String`的常用方法

public int length()：返回字符串的长度。
public char charAt(int index)：根据下标获取字符。
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 String toLowerCase()：将大写转成大写。
public boolean endWith(String str)：判断字符串是否以str结尾。
public boolean startWith(String str)：判断字符串是否以str开头。
public String replace(char oldChar, char newChar)：将旧字符串替换成新字符串。
public String[] split(String str)：根据str做拆分。

5.2.1 案例（一）

package com.goshawk.chapter_02.section_6;

import java.util.Arrays;

public class Demo2 {
    public static void main(String[] args) {

        // 字符串方法的使用
        String content = "java是一种编程语言";

        // length();返回字符串的长度
        // charAt(int index);返回某个位置的字符
        // contains(String str);判断是否包含某个子字符串
        System.out.println(content.length());
        System.out.println(content.charAt(content.length()-1));
        System.out.println(content.contains("java"));

        // toCharArray()返回字符串对应的数组
        // indexOf() 返回字符串首次出现的位置
        // lastIndexOf() 返回字符串最后一次出现的位置
        System.out.println(Arrays.toString(content.toCharArray()));
        System.out.println(content.indexOf("java"));
        System.out.println(content.indexOf("java", 4));
        System.out.println(content.lastIndexOf("java"));

        // trim() 去掉字符串前后的空格
        // toUpperCase() 将小写转成大写
        // toLowerCase() 将大写转成大写
        // endWith() 判断字符串是否以`str`结尾
        // startWith() 判断字符串是否以`str`开头
        String content2 = " hello word ";
        System.out.println(content2.trim());
        System.out.println(content2.toUpperCase());
        System.out.println(content2.toLowerCase());
        String filename = "hello.java";
        System.out.println(filename.endsWith(".java"));
        System.out.println(filename.startsWith("hello"));

        // replace() 用新的字符或字符串 替换 旧的字符或字符串
        // split() 对字符串进行拆分
        System.out.println(content.replace("java", "py"));

        String say = "java,python is the best   programing language";
        String[] arr = say.split("[ ,]+"); // + 表示可能出现多个
        System.out.println(arr.length);
        for (String string : arr){
            System.out.println(string);
        }

        // equals() 、 compareTo() 比较大小
        String s1 = "hello";
        String s2 = "HELLO";
        System.out.println(s1.equalsIgnoreCase(s2)); // 忽略大小写比较

        String s3 = "abc";
        String s4 = "def";
        // 将a的ASCII码值97与d的ASCII码值100 -> 97-100。如果第一个都是a，则开始比较第二个字符，依次类推。
        System.out.println(s3.compareTo(s4));

        String s5 = "abc";
        String s6 = "abcdef";
        // s5的长度为3，s6的长度为6 -> 3-6=-3。
        System.out.println(s5.compareTo(s6));
    }
}

5.2.2 案例（二）

要求
- 已知String str = "this is a text";
- 将str中的单词单独获取出来
- 将str中的text替换成practice
- 在text前面插入一个easy
- 将每个单词的首字母改成大写

package com.goshawk.chapter_02.section_6;

public class Demo3 {
    public static void main(String[] args) {
        String str = "this is the text";
        String[] arr = str.split(" ");
        for (String string : arr){
            System.out.println(string);
        }
        
        String str2 = str.replace("text", "practice");
        System.out.println(str2);
        
        String str3 = str.replace("text", "easy text");
        System.out.println(str3);
        
        for (int i=0;i<arr.length;i++){
            char first = arr[i].charAt(0);
            // 把第一个字符转成大写
            char upperfirst = Character.toUpperCase(first);
            
            String newStr = upperfirst+arr[i].substring(1); // 截取
            System.out.println(newStr);
        }
    }
}

5.2.3 可变字符串

StringBuffer：可变长字符串，`JDK1.0提供，运行效率慢、线程安全。
StringBuilder：可变长字符串，JDK5.0提供，运行效率快，线程不安全。

5.2.3.1 案例（一）

package com.goshawk.chapter_02.section_6;

public class Demo4 {
    public static void main(String[] args) {
        StringBuffer str = new StringBuffer();
        // StringBuilder str = new StringBuilder();
        
        // append追加
        str.append("动物园有大象");
        System.out.println(str.toString());
        str.append("有猴子");
        System.out.println(str.toString());
        // insert添加
        str.insert(0, "先看到长颈鹿，");
        System.out.println(str.toString());
        // replace替换
        str.replace(0, 3, "孔雀");
        System.out.println(str.toString());
        // delete删除
        str.delete(0, 2);
        System.out.println(str.toString());
        // 清空
        str.delete(0, str.length());
        System.out.println(str.length());
    }
}

5.2.3.2 案例（二）

验证StringBuilder效率高于String。

package com.goshawk.chapter_02.section_6;

public class Demo5 {
    public static void main(String[] args) {
        // 开始时间
        long startTime = System.currentTimeMillis();
//        String string = "";
//        for (int i=0;i<99999;i++){
//            string+=i;
//        }
//        System.out.println(string);
        
        StringBuilder str = new StringBuilder();
        for (int i=0;i<99999;i++){
            str.append(i);
        }
        System.out.println(str.toString());

        long endTime = System.currentTimeMillis();
        System.out.println("用时："+(endTime-startTime));
    }
}

6、`BigDecimal`类

6.1 案例（一）

public class TestBigDecimal{
  public static void main(String[] args){
    double d1 = 1.0;
    double d2 = 0.9;
    System.out.println(d1-d2);
    
    double result = (1.4-0.5)/0.9;
    System.out.println(result);
  }
}

输出：

0.09999999999999998
0.9999999999999999

很多实际应用中需要精确运算，而double是近似值存储，不在符合要求，需要借助BigDecimal。

6.2 `BigDecimal`的使用

位置：java.math包中
作用：精确计算浮点数。
创建方式：BigDecimal bd = new BigDecimal("1.0");
除法：divide(BigDecimal bd, int scal, RoundingMode mode)
- 参数scal：指定精确到小数点后几位。
- 参数mode：
  - 指定小数部分的取舍模式，通常采用四舍五入的模式。
  - 取值为BigDecimal.ROUND_HALF_UP。

6.3 案例（二）

package com.goshawk.chapter_02.section_6;

import java.math.BigDecimal;

public class Demo6 {
    public static void main(String[] args) {

        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");
        // 减法
        BigDecimal result1 = bd1.subtract(bd2);
        System.out.println(result1);
        // 加法
        BigDecimal result2 = bd1.add(bd2);
        System.out.println(result2);
        // 乘法
        BigDecimal result3 = bd1.multiply(bd2);
        System.out.println(result3);
        // 除法
        BigDecimal result4 = new BigDecimal("1.4")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.9"));
        System.out.println(result4);
        // 除法除不尽
        BigDecimal result5 = new BigDecimal("10")
                // 保留两位小数，且四舍五入
                .divide(new BigDecimal("3"), 2, BigDecimal.ROUND_HALF_UP);

    }

}

7、Date 类

Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已被Calendar类中的方法所取代（JDK1.1之后）。
时间单位：
- 1秒=1000毫秒。
- 1毫秒=1000微秒。
- 1微秒=1000纳秒。

7.1 案例（一）

package com.goshawk.chapter_02.section_6;

import java.util.Date;

public class Demo7 {
    public static void main(String[] args) {
        // 今天
        Date date1 = new Date();
        System.out.println(date1.toString());
        System.out.println(date1.toLocaleString());
        // 昨天
        Date date2 = new Date(date1.getTime()-(60*60*24*1000));
        System.out.println(date2.toLocaleString());

        boolean b1 = date1.after(date2); // date1在date2之后，返回ture或者false
        System.out.println(b1);

        boolean b2 = date1.before(date2); // date1在date2之前，返回ture或者false
        System.out.println(b2);

        // 比较 compareTo
        int d1 = date1.compareTo(date2);
        System.out.println(d1);
        int d2 = date2.compareTo(date1);
        System.out.println(d2);
        // 比较是否相等equals()
        boolean b3 = date1.equals(date2);
        System.out.println(b3);
    }
}

8、Calendar 类

Calendar提供了获取或设置各种日历字段的方法。
构造方法
- protected Calendar()：由于修饰符是protected，所以无法直接创建该对象。

其他方法

方法名	说明
Static Calendar getlnstance()	使用默认时区和区域获取日历
Void set(int year, int month, int date, int hourofday, int minute, int second)	设置日历的年、月、日、时、分、秒。
int get(int field)	返回给定日历字段的值。字段比如年、月、日等。
Void setTime(Date date)	用给定的Date设置此日历的时间。Date-Calendar
Date getTime()	返回一个Date表示此日历的时间。Calendar-Date
Void add(int field, int amount)	按照日历的规则，给指定字段添加或减少时间量
long getTimeMillies()	毫秒为单位返回该日历的时间值。

8.1 案例（一）

package com.goshawk.chapter_02.section_6;

import java.util.Calendar;

public class Demo8 {
    public static void main(String[] args) {
        // 创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());

        // 获取时间信息
        // 获取年
        int year = calendar.get(Calendar.YEAR);
        // 获取月 0-11月，要想正常显示则+1
        int month = calendar.get(Calendar.MONTH);
        // 获取日
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        // 获取小时
        int hour = calendar.get(Calendar.HOUR_OF_DAY); // HOUR 12小时; HOUR_OF_DAY 24小时
        // 获取分钟
        int minute = calendar.get(Calendar.MINUTE);
        // 获取秒
        int second = calendar.get(Calendar.SECOND);
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);

        // 修改时间
        Calendar calendar1 = Calendar.getInstance();
        calendar1.set(Calendar.DAY_OF_MONTH, 5);
        System.out.println(calendar1.getTime().toLocaleString());

        // add方法修改时间
        calendar1.add(Calendar.HOUR, 1);
        System.out.println(calendar1.getTime().toLocaleString());
        calendar1.add(Calendar.HOUR, -1);
        System.out.println(calendar1.getTime().toLocaleString());

        int max = calendar1.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = calendar1.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max);
        System.out.println(min);

    }
}

9、SimpleDateFormat 类

SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类。
进行格式化（日期 -> 文本）、解析（文本 -> 日期）。
常用的时间模式字母

字母日期或时间示例
y 年 2022
M 年中月份 08
d 月中天数 22
H 1天中小时数（0-23） 16
M 分钟 13
s 秒 59
S 毫秒 367

字母	日期或时间	示例
y	年	2022
M	年中月份	08
d	月中天数	22
H	1天中小时数（0-23）	16
M	分钟	13
s	秒	59
S	毫秒	367

9.1 案例（一）

package com.goshawk.chapter_02.section_6;

import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo9 {
    public static void main(String[] args) throws Exception{
        // 创建SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy/MM/dd");
        // 创建Date
        Date date = new Date();
        // 格式化date 把日期转换成字符串
        String str = sdf.format(date);
        System.out.println(str);

        // 解析 把字符串转成日期
        Date date1 = sdf1.parse("1990/05/01");
        System.out.println(date1);

    }
}

10、System 类

System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的。

方法名	说明
static void arraycopy(…)	复制数组
Static long currentTimeMillis();	获取当前系统时间，返回的是毫秒值
Static void gc();	建议JVM赶快启动垃圾回收器回收垃圾
static void exit(int status);	退出jvm，如果参数是0表示正常退出jvm，非0表示异常退出jvm

10.1 案例（一）

package com.goshawk.chapter_02.section_6;

public class Demo10 {
    public static void main(String[] args) {
        // arraycopy 数组复制
        // src 源数组
        // srcPos：从哪个位置开始赋值 0
        // dest：目标数组
        // destPos: 目标数组的位置
        // length: 赋值的长度
        int[] arr = {20, 18, 16, 14, 26, 45, 89, 22};
        int[] dest = new int[8];

        System.arraycopy(arr, 0, dest, 0, arr.length);
        // System.arraycopy(arr, 4, dest, 4, 4);
        for (int i=0;i<dest.length;i++){
            System.out.println(dest[i]);
        }

        // Arrays.copyOf(original, newLength)
        System.out.println(System.currentTimeMillis());

        long start = System.currentTimeMillis();
        for (int i = 0; i<9999999;i++){
            for (int j=0;j<9999999;j++){
                int result=i+j;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("用时:"+(end-start));

        Student s1 = new Student("aaa", 17); // 对象被变量使用是不回收的
        Student s2 = new Student("bbb", 18);
        Student s3 = new Student("ccc", 19);

        new Student("aaa", 17);
        new Student("bbb", 18);
        new Student("ccc", 19);
        // System.gc() 告诉垃圾回收器回收垃圾
        System.gc();

        // 退出jvm
        System.exit(0);
        System.out.println("结束了"); // 此行代码不打印

    }
}