Java进阶_常用类

常用类

Object类

介绍object

• JDK类库的根类: Object

• 这个老祖宗类中的方法我们需要先研究一下，因为这些方法都是所有子类通用的。任何一个类默认继承object。就算没有直接继承，最终也会间接继承。

• object类当中有哪些常用的方法?

  • 我们去哪里找这些方法呢?
    • 第一种方法:去源代码当中。(但是这种方式比较麻烦，源代码也比较难)
    • 第二种方法:去查阅java的类库的帮助文档。

• 什么是API ?

  • 应用程序编程接口。（Application Program Interface）
  • 整个JDK的类库就是一个javaSE的API。
  • 每一个API都会配置一套API帮助文档。
  • SUN公司提前写好的这套类库就是API。(一般每一份API都对应一份API帮助文档。)

• 超类、基类，所有类的直接或间接父类，位于继承树的最顶层。

• 任何类，如没有书写extends显示继承某个类，都默认直接继承0bject类,否则为间接继承。

• Object类中所定义的方法，是所有对象都具备的方法。

• 0bject类型可以存储任何对象。

  • 作为参数，可接受任何对象。
  • 作为返回值，可返回任何对象。

Object常见的方法

getClass()方法

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

package com.mike.test;
 
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;
    }
 
    public static void main(String[] args) {
        Student s1 = new Student("小明",21);
        Student s2 = new Student("小红",20);
        //判断S1和S2是不是同一个类型
        Class s1Class = s1.getClass();
        Class s2Class = s2.getClass();
        System.out.println(s1.equals(s2));//equals是用来比较内容的
        if (s1Class==s2Class){
            System.out.println("s1和s2属于同一个类型");
        }else System.out.println("s1和s2不属于同一个类型");
    }
}
 
                //输出结果：
                //false
                //s1和s2属于同一个类型

hashCode()方法

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

package com.mike.test;
 
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;
    }
 
    public static void main(String[] args) {
        Student s1 = new Student("小明",21);
        Student s2 = new Student("小红",20);
        Student s3 =s1;
        //判断S1和S2是不是同一个类型
        Class s1Class = s1.getClass();
        Class s2Class = s2.getClass();
        System.out.println(s1.equals(s2));//equals是用来比较地址的
        if (s1Class==s2Class){
            System.out.println("s1和s2属于同一个类型");
        }else System.out.println("s1和s2不属于同一个类型");
        //hashCode()方法
        System.out.println("s1的哈希码值："+s1.hashCode());
        System.out.println("s2的哈希码值："+s2.hashCode());
        System.out.println("s3的哈希码值："+s3.hashCode());
        System.out.println(s3.getName());
        System.out.println(s3.getAge());
    }
}
 
 
            /*输出结果：
            false
            s1和s2属于同一个类型
            s1的哈希码值：460141958
            s2的哈希码值：1163157884
            s3的哈希码值：460141958
            小明
            21
            */

toString()方法

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

没有重写toString()方法

package com.mike.test;
 
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;
    }
 
    public static void main(String[] args) {
        Student s1 = new Student("小明",21);
        Student s2 = new Student("小红",20);
        Student s3 =s1;
 
        System.out.println(s1.toString());
        System.out.println(s2.toString());
        System.out.println(s3.toString());
    }
}
        /*输出结果：
        com.mike.test.Student@1b6d3586
        com.mike.test.Student@4554617c
        com.mike.test.Student@1b6d3586
        */

重写toString()方法

package com.mike.test;
 
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()方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
 
    public static void main(String[] args) {
        Student s1 = new Student("小明",21);
        Student s2 = new Student("小红",20);
        Student s3 =s1;
 
        System.out.println(s1.toString());
        System.out.println(s2.toString());
        System.out.println(s3.toString());
    }
}
 
            /*输出结果
            Student{name='小明', age=21}
            Student{name='小红', age=20}
            Student{name='小明', age=21}
            */

equals()方法

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

package com.mike.test;
 
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;
    }
 
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
 
    public static void main(String[] args) {
        Student s1 = new Student("小明",21);
        Student s2 = new Student("小红",20);
        Student s3 =s1;
 
        System.out.println(s1.equals(s2));
        System.out.println(s2.equals(s3));
        System.out.println(s3.equals(s1));
    }
}
            /*输出结果（比较的是地址）
                false
                false
                true
            */

• equals()方法覆盖步骤
  • 比较两个引用是否指向同一个对象。
  • 判断obj是否为null。
  • 判断两个引用指向的实际对象类型是否一致。
  • 强制类型转换。
  • 依次比较各个属性值是否相同。

如果要比较对象的内容，就要重写equals()方法

package com.mike.test;
 
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;
    }
 
 
    @Override
    public boolean equals(Object obj) {
        //1.判断两个对象是否是同一个引用
        if (this==obj){
            return true;
        }
        //2.判断obj是否为null
        if (obj==null){
            return false;
        }
        //3.判断是否是同一个类型
/*        if (this.getClass()==obj.getClass()){
        }
        换下面一种写法更好
        */
        //instanceof 判断对象是否是某种类型
        if (obj instanceof Student){
            //4.强制转换
            Student s = (Student) obj;
            //5.比较属性
            if (this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }
        return false;
    }
 
    public static void main(String[] args) {
        Student s1 = new Student("小明",21);
        Student s2 = new Student("小红",20);
        Student s3 =s1;
        Student s4 = new Student("小红",20);
 
        System.out.println(s1.equals(s3));
        System.out.println(s2.equals(s4));
    }
}
                /*输出结果（比较的是内容）
                true
                true
                */

finalize()方法

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

重写finalize()方法

package com.mike.test;
 
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;
    }
 
 
    @Override
    public boolean equals(Object obj) {
        //1.判断两个对象是否是同一个引用
        if (this==obj){
            return true;
        }
        //2.判断obj是否为null
        if (obj==null){
            return false;
        }
        //3.判断是否是同一个类型
/*        if (this.getClass()==obj.getClass()){
        }
        换下面一种写法更好
        */
        //instanceof 判断对象是否是某种类型
        if (obj instanceof Student){
            //4.强制转换
            Student s = (Student) obj;
            //5.比较属性
            if (this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }
        return false;
    }
 
 
    @Override
    protected void finalize() throws Throwable {
        System.out.println(this.name+"对象被回收了");
    }
 
    public static void main(String[] args) {
        Student s1 = new Student("小明",21);
        Student s2 = new Student("小红",20);
        Student s3 = new Student("小王",22);
        Student s4 = new Student("小刘",18);
        Student s5 = new Student("小刚",20);
        //回收垃圾
        System.gc();
        System.out.println("回收垃圾");
 
    }
}
                /*输出结果
                回收垃圾
                */
				//发现s1~s5没有垃圾被回收
				//说明没有垃圾回收

当我们new对象，然后不给对象引用变量时（也就是匿名内部类）

package com.mike.test;
 
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;
    }
 
 
    @Override
    public boolean equals(Object obj) {
        //1.判断两个对象是否是同一个引用
        if (this==obj){
            return true;
        }
        //2.判断obj是否为null
        if (obj==null){
            return false;
        }
        //3.判断是否是同一个类型
/*        if (this.getClass()==obj.getClass()){
        }
        换下面一种写法更好
        */
        //instanceof 判断对象是否是某种类型
        if (obj instanceof Student){
            //4.强制转换
            Student s = (Student) obj;
            //5.比较属性
            if (this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }
        return false;
    }
 
 
    @Override
    protected void finalize() throws Throwable {
        System.out.println(this.name+"对象被回收了");
    }
 
    public static void main(String[] args) {
           new Student("小明",21);
           new Student("小红",20);
           new Student("小王",22);
           new Student("小刘",18);
           new Student("小刚",20);
        //回收垃圾
        System.gc();
        System.out.println("回收垃圾");
 
    }
}
                /*输出结果
                回收垃圾
                小刚对象被回收了
                小刘对象被回收了
                小王对象被回收了
                小红对象被回收了
                小明对象被回收了
                */

Integer类（包装类）

什么是包装类

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

包装类对应

类型转换与装箱、拆箱

• 8种包装类提供不同类型间的转换方式:
  • Number父类中提供的6个共性方法。
  • parseXXX()静态方法。

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

package com.mike.test;
 
public class Test {
    public static void main(String[] args) {
 
        //基本类型和字符串之间转换
        //1基本类型转成字符串
        int n1 = 255;
        //1.1使用+号
        String s1 = n1+"";
        //1.2使用Integer中的toString()方法
        String s2 = Integer.toString(n1);
        //这里的radix表示进制的意思，16表示转换成16进制的数
        String s3 = Integer.toString(n1,16);
        //toBinaryString()转换成二进制的意思
        //toHexString()转换成十六进制的意思
        //toOctalString()转换成八进制的意思
        //总的来说toString(int i,int radix)就可以转换想要的进制了
        System.out.println("基本类型转成字符串");
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(n1+"转换成16进制:"+s3);
        System.out.println("========================");
 
 
        //2字符串转成基本类型
        String s4 = "150";
        //使用Integer.parseXXX();
        int n2 = Integer.parseInt(s4);
        System.out.println("字符串转成基本类型");
        System.out.println(n2);
        System.out.println("========================");
 
        //boolean字符串形式转成基本类型，"true"--->true     非"true"---->false
        String s5 = "true";
        boolean b1= Boolean.parseBoolean(s5);
        String s6 = "tree";
        String s7 = "false";
        boolean b2= Boolean.parseBoolean(s6);
        boolean b3= Boolean.parseBoolean(s7);
        System.out.println("boolean字符串形式转成基本类型");
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
    }
}
 
            /*输出结果
                基本类型转成字符串
                255
                255
                255转换成16进制:ff
                ========================
                字符串转成基本类型
                150
                ========================
                boolean字符串形式转成基本类型
                true
                false
                false
            */

装箱和拆箱

package com.mike.test;
 
public class Test {
    public static void main(String[] args) {
 
        //类型转换:装箱,基本类型转成引用类型的过程
        //基本类型
        int num1 = 18;
        //1.使用Integer类创建对象,用构造方法来转换
        Integer integer1 = new Integer(num1);
        //2.使用Integer类的valueOf()方法来转换
        Integer integer2 = Integer.valueOf(num1);
 
        System.out.println("装箱");
        System.out.println(integer1);
        System.out.println(integer2);
        System.out.println("===========================");
 
        //类型转型:拆箱,引用类型转成基本类型
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();
        System.out.println("拆箱");
        System.out.println(num2);
        System.out.println("===========================");
 
        //JDK1.5之后,提供自动装箱和拆箱
        int age1 = 30;
        //自动装箱
        Integer integer4 = age1;
        System.out.println("自动装箱");
        System.out.println(integer4);
        System.out.println("===========================");
        //自动拆箱
        int age2=integer4;
        System.out.println("自动拆箱");
        System.out.println(age2);
    }
}
                /*输出结果
                装箱
                18
                18
                ===========================
                拆箱
                100
                ===========================
                自动装箱
                30
                ===========================
                自动拆箱
                30
                */
 

Integer缓冲区

整数缓冲区

整数缓冲区：-128~127=======>256个常用的整数包装类型对象

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

注意：如果Integer的数值的地址不在-128~127之间，则new Integer(i)

面试题

package com.mike.test;
 
public class Test {
    public static void main(String[] args) {
        //面试题
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1==integer2);//比较的是地址
        System.out.println(integer1.equals(integer2));//比较数值
        System.out.println("================================");
//============================================================================
        //这里的自动装箱调用的是Integer.valueOf
        //即：Integer integer3 = Integer.valueOf(100);
        //Integer integer4 = Integer.valueOf(100);
        Integer integer3 = 100;//jdk1.5之后，支持自动装箱，自动转换为int类型
        Integer integer4 = 100;
        System.out.println(integer3==integer4);//比较的是Integer缓冲区100的地址，所以为true
        System.out.println(integer3.equals(integer4));//比较数值
        System.out.println("================================");
//===========================================================================
        //这里的自动装箱调用的是Integer.valueOf
        //即：Integer integer5 = Integer.valueOf(200);
        //Integer integer6 = Integer.valueOf(200);
        Integer integer5 = 200;//由于200不在-128~127之间，则开辟一个新的地址存放
        Integer integer6 = 200;
        System.out.println(integer5==integer6);//这里就是比较新的两个不一样的地址，所以为false
        System.out.println(integer5.equals(integer6));//比较数值
 
 
    }
}
            /*输出结果
                false
                true
                ================================
                true
                true
                ================================
                false
                true
            */

String类

String

科普小知识：equals在Object类中比的是地址，但是Sun公司在String要中重写了equals，重写为比较值，基本Sun公司在每个类中都重写了equals方法。所以有时候我们看到equals比较的是地址的时候，说明这是自己创建的一个类，然后这个类并没有重写equals方法，自己创建的类默认继承Object类，Object里的equals是没有重写的哦。

• 字符串是常量，创建之后不可改变。
• 字符串字面值存储在字符串池中（也就是方法区中），可以共享。
• String s = "Hello" ;产生一个对象，字符串池中存储。
• String s = new String(“Hello”); //产生两个对象，堆、池各存储一个。

package com.mike.test;
 
public class Test {
    public static void main(String[] args) {
        String name = "hello";//"hello"常量存储在字符串池中。
        name = "zhangsan";//"张三"赋值给name变量,给字符串赋值时，并没有修改数据。而是重新开辟一个空间
        String name2 = "zhangsan";
    }
}

给字符串重新赋值的状态

给不同的string变量赋相同值时（对比上面的图）

• hello值变成垃圾被回收，开辟新的空间，name和name2指向同一个方法区的地址，并不是修改原来的空间里的值

字符串的另一种创建方式，new String();

package com.mike.test;
 
public class Test {
    public static void main(String[] args) {
        String name = "hello";//"hello"常量存储在字符串池中。
        name = "zhangsan";//"张三"赋值给name变量,给字符串赋值时，并没有修改数据。而是重新开辟一个空间
        String name2 = "zhangsan";
 
        //演示字符串的另一种创建方式，new String();
        String str = new String("Java");
    }
}
 
//注意：虽然说有堆和池各有一个字符串，但是程序运行的时候，堆里的字符串还是指向池里的字符串

当我们又new了一个新的相同的string值时

package com.mike.test;
 
public class Test {
    public static void main(String[] args) {
        String name = "hello";//"hello"常量存储在字符串池中。
        name = "zhangsan";//"张三"赋值给name变量,给字符串赋值时，并没有修改数据。而是重新开辟一个空间
        String name2 = "zhangsan";
 
        //演示字符串的另一种创建方式，new String();
        String str = new String("Java");
        String str2=new String("java");
        System. out . println( str==str2);
 
    }
}
            /*输出结果
            false
            */
//从下面的图中我们可以看到，虽然都是指向了池中同一个java，但是new的时候，在堆中开辟了新的空间
//所以栈中的地址是先从堆指向池，new String();是比较堆中的地址，直接赋值不new对象，是比较池的地址

//用equals比较String的变量

package com.mike.test;
 
public class Test {
    public static void main(String[] args) {
        String name = "hello";//"hello"常量存储在字符串池中。
        name = "zhangsan";//"张三"赋值给name变量,给字符串赋值时，并没有修改数据。而是重新开辟一个空间
        String name2 = "zhangsan";
 
        //演示字符串的另一种创建方式，new String();
        String str = new String("java");
        String str2=new String("java");
        System.out.println(name==name2);//比较池地址
        System.out.println(name.equals(name2));//比较池内容
        System.out.println(str==str2);//比较堆地址
        System.out.println(str.equals(str2));//比较堆内容
    }
}
            /*输出结果
                true
                true
                false
                true
            */

看图理解

String常用方法

• 1、public int length() :返回字符串的长度。
• 2、public char charAt(int index) :根据下标获取字符。
• 3、public boolean contains (String str) :判断当前字符串中是否包含str。
• 4、public char[] toCharArray() :将字符串转换成数组。
• 5、public int indexOf (String str) :查找str首次出现的下标，存在，则返回该下标;不存在，则返回-1。
• 6、public int lastIndexOf (String str) :查找字符串在当前字符串中最后一次出现的下标索引。
• 7、public String trim() :去掉字符串前后的空格。
• 8、public String toUpperCase () :将小写转成大写。
• 9、public String toLowerCase () :将大写转成小写。
• 10、public boolean endWith(String str) :判断字符串是否以str结尾。(区分大小写)
• 11、public boolean startWith(String str) :判断字符串是否以str开头。(区分大小写)
• 12、public String replace (char oldChar, char newChar): 将旧字符串替换成新字符串
• 13、public String[]  split(String str) :根据str做拆分。

1、字符串的使用length()，charAt(int index)，contains (String str)

package com.mike.test;
 
public class Test {
    public static void main(String[] args) {
        //字符串方法的使用
        //1、public int length():返回字符串的长度。
        //2、public char charAt(int index):根据下标获取字符。
        //3、public boolean contains (String str):判断当前字符串中是否包含str。
        String content="java是世界上最好的编程语言";
        System.out.println(content.length());//如果字符串有空格，也算一个字符
        System.out.println(content.charAt(3));
        System.out.println(content.contains("语言"));
        System.out.println(content.contains("PHP"));
    }
}
            /*输出结果
                15
                a
                true
                false
            */

2、字符串的使用toCharArray()，indexOf(String str)，lastIndexOf(String str)

package com.mike.test;
 
import java.util.Arrays;
 
public class Test {
    public static void main(String[] args) {
        String content="java是世界上最好的java编程语言，java真香";
        //4、public char[] toCharArray():将字符串转换成数组。
        //5、public int indexOf(String str):查找str首次出现的下标，存在，则返回该下标;不存在，则返回-1。
        //6、public int lastIndexOf(String str):查找字符串在当前字符串中最后一次出现的下标索引。
        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"));
    }
}
            /*输出结果
            [j, a, v, a, 是, 世, 界, 上, 最, 好, 的, j, a, v, a, 编, 程, 语, 言, ，, j, 			a, v, a, 真, 香]
            0
            11
            20
            */

3、字符串的使用trim()，toUpperCase()，endWith(String str)

package com.mike.test;
 
import com.sun.xml.internal.bind.v2.runtime.reflect.Accessor;
 
import java.util.Arrays;
 
public class Test {
    public static void main(String[] args) {
        String content = "   Hello！Word！   ";
        //7、public String trim():去掉字符串前后的空格。
        //8、public String toUpperCase():将小写转成大写。
        //9、public boolean endWith(String str):判断字符串是否以str结尾。
        System.out.println(content.trim());
        System.out.println(content.toUpperCase());
        System.out.println(content.toLowerCase());
        String str = "Hellow.java";
        System.out.println(str.endsWith("va"));
        System.out.println(str.startsWith("hello"));
    }
}
            /*输出结果
                Hello！Word！
                   HELLO！WORD！   (前后还是存在空格的，没有改变字符串的值，空格也是字符串)
                   hello！word！   
                true
                false
            */

4、字符串的使用replace(char oldChar,char newChar)，split(String str)

package com.mike.test;
 
import com.sun.xml.internal.bind.v2.runtime.reflect.Accessor;
 
import java.util.Arrays;
 
public class Test {
    public static void main(String[] args) {
        String content = "Hello！Word！";
        //10、public String replace(char oldChar,char newChar):将旧字符串替换成新字符串
        //11、public String[] split(String str):根据str做拆分。
        System.out.println(content.replace("Word", "Earth"));
        System.out.println(content.replace('H', 'h'));
        String say = "java is the best programing language,java xiang";
//        String[] s = say.split(" ");
        String[] s = say.split("[ ,]");//需要空格和逗号作为分格符号时，可以用中括号，里面空格+逗号
//        String[] s = say.split("[ ,]+");//如果一个字符串连续出现多个空格，可以在后面加个+
        System.out.println(s.length);
        for (String s1 : s) {
            System.out.println(s1);
        }
    }
}
            /*输出结果
                Hello！Earth！
                hello！Word！
                8
                java
                is
                the
                best
                programing
                language
                java
                xiang
            */

5、补充String类的两个方法：equals()和compareTo();

• equals()是用来比较数据是否相同
• compareTo()是用来比较大小/长度（就是比较字典表（编码表）里的顺序（位置））

package com.mike.test;
 
import com.sun.xml.internal.bind.v2.runtime.reflect.Accessor;
 
import java.util.Arrays;
 
public class Test {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "HELLO";
        System.out.println(s1.equals(s2));//考虑大小写的比较
        System.out.println(s1.equalsIgnoreCase(s2));//忽略大小写的比较
//==========================================================================       
        String s3 = "abc";//a=97,b=98,c=99
        String s4 = "xyz";//x=120,y=121,z=122
        String s5 = "ayzawe";//s5和s3第一个字母相同，直接从第二个字母开始比较
        System.out.println(s3.compareTo(s4));//97-120= -23
        System.out.println(s3.compareTo(s5));//98-121= -23
//==========================================================================
        String s6 = "abc";
        String s7 = "abcdef";
        System.out.println(s6.compareTo(s7));//观察s6和s7,这时候不比大小，比他们的长度，0-3=-3
    }
}
            /*输出结果
                false
                true
                -23
                -23
                -3
            */

6、可变字符串

• StringBuffer: 可变长字符串，JDK1. 0提供，运行效率慢、线程安全。
• StringBuilder:可变长字符串，JDK5. 0提供，运行效率快、线程不安全。
• StringBuffer和StringBuilder比String效率高，更节省内存

package com.mike.test;
 
import com.sun.xml.internal.bind.v2.runtime.reflect.Accessor;
 
import java.util.Arrays;
 
public class Test {
    public static void main(String[] args) {
       // StringBuffer string = new StringBuffer();//推荐使用StringBuffer，线程安全性
        StringBuilder string = new StringBuilder();//想用StringBuilder直接替换就行了，用法一样
        //1、append();追加
        string.append("Java世界第一");
        System.out.println(string.toString());
        string.append("Java真香");
        System.out.println(string.toString());
        string.append("Java真不错");
        System.out.println(string.toString());
        //2、insert();添加,插入
        string.insert(0,"我在最前面");
        System.out.println(string.toString());
        //3、replace();替换
        string.replace(13,19,"Java好就业");//含头不含尾
        System.out.println(string.toString());
        //4、delete();删除
        string.delete(0,5);
        System.out.println(string.toString());
        //清空
        string.delete(0,string.length());
        System.out.println(string.length());
 
 
    }
}
            /*输出结果
                Java世界第一
                Java世界第一Java真香
                Java世界第一Java真香Java真不错
                我在最前面Java世界第一Java真香Java真不错
                我在最前面Java世界第一Java好就业Java真不错
                Java世界第一Java好就业Java真不错
                0
            */

测试String和StringBuilder的效率

1、测试String

package com.mike.test;
 
import com.sun.xml.internal.bind.v2.runtime.reflect.Accessor;
 
import java.util.Arrays;
 
public class Test {
    public static void main(String[] args) {
        //开始时间
        long start = System.currentTimeMillis();
        String string = "";//空字符串
        for (int i = 0; i < 9999; i++) {
            string+=i;
        }
//        System.out.println(string);
        //结束时间
        long end = System.currentTimeMillis();
        System.out.println("String用时："+(end-start));
    }
}
            /*输出结果
           String用时：399
            */

2、测试StringBuilder

package com.mike.test;
 
 
public class Test {
    public static void main(String[] args) {
        //开始时间
        long start = System.currentTimeMillis();
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < 9999; i++) {
            stringBuilder.append(i);
        }
//        System.out.println(stringBuilder.toString());
        //结束时间
        long end = System.currentTimeMillis();
        System.out.println("stringBuilder用时："+(end-start));
    }
}
            /*输出结果
           StringBuilder用时：2
            */

综上所知：在运行效率中：（快）StringBuilder > StringBuffer > String（慢）

BigDecimal类

引入问题

思考:以下程序输出结果是多少?

上机运行

package com.mike.test;
 
 
public class Test {
    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类

BigDecimal类

位置: java.smath包中。
作用:精确计算浮点数。
创建方式: BigDecimal bd = new BigDecimal( “1.0”);

方法：

• 加法：add();
• 减法：subtract();
• 乘法：multiply();
• 除法：divide();

package com.mike.test;
 
 
import java.math.BigDecimal;
 
public class Test {
    public static void main(String[] args) {
 
        //BigDecimal,大的浮点数精确计算
        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");
        //subtract();减法
        System.out.println(bd1.subtract(bd2));
        //加法
        System.out.println(bd1.add(bd2));
        //乘法
        System.out.println(bd1.multiply(bd2));
        //除法
        System.out.println(new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9")));
        BigDecimal b1 = new BigDecimal("10");
        BigDecimal b2 = new BigDecimal("3");
        //对于除不尽的结果，必须保留两位小数，否则会报错
        BigDecimal result2 = b1.divide(b2, 2, BigDecimal.ROUND_HALF_UP);//保留两位小数，BigDecimal.ROUND_HALF_UP采用四舍五入
        System.out.println(result2);
    }
}
            /*输出结果
                0.1
                1.9
                0.90
                1
                3.33
            */

Date类

介绍Date

• Date表示特定的瞬间，精确到毫秒。Date类中 的大部分方法都已经被Calendar类中的方法所取代。

• 时间单位

  • 1秒=1000毫秒
  • 1毫秒=1000微秒
  • 1微秒=1000纳秒

1、创建时间

package com.mike.test;
 
 
import java.util.Date;
 
public class Test {
    public static void main(String[] args) {
        //1、创建Date对象
        //今天的时间（此时此刻）
        Date date1 = new Date();
        System.out.println(date1.toString());
        System.out.println("今天的时间（此时此刻）");
        System.out.println(date1.toLocaleString());//虽然过时了，但是还是可以使用的
        //昨天的时间(今天的时间减去一天的毫秒数就是昨天此时此刻的时间)
        System.out.println("昨天此时此刻的时间");
        Date date2 = new Date(date1.getTime()-(60*60*24*1000));
        System.out.println(date2.toLocaleString());
    }
}
            /*输出结果(时间是变化的，每次运行都不一样)
                Sun Mar 06 16:15:57 CST 2022
                今天的时间（此时此刻）
                2022-3-6 16:15:57
                昨天此时此刻的时间
                2022-3-5 16:15:57
            */

2、Date类的方法

• after
• before

package com.mike.test;
 
 
import java.util.Date;
 
public class Test {
    public static void main(String[] args) {
        //1、创建Date对象
        //今天的时间（此时此刻）
        Date date1 = new Date();
        Date date2 = new Date(date1.getTime()-(60*60*24*1000));
        //2、方法
        boolean b1 = date1.after(date2);
        System.out.println(b1);
        boolean b2 = date1.before(date2);
        System.out.println(b2);
        
         //比较compareTo();
        System.out.println(date1.compareTo(date2));
        System.out.println(date2.compareTo(date1));
        System.out.println(date2.compareTo(date2));
        //比较是否相等equals()
        System.out.println(date1.equals(date2));
    }
}
            /*输出结果
                true
                false
                1
                -1
                0
                false
            */

Calendar类

介绍Calendar类

• Calendar提供了获取或设置各种日历字段的方法。

• 构造方法

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

• 其他方法

  

获取年月日，时分秒

package com.mike.test;
 
 
import java.util.Calendar;
import java.util.Date;
 
public class Test {
    public static void main(String[] args) {
        //1、创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());
        //2、获取时间信息
        //获取年
        int year = calendar.get(Calendar.YEAR);
        System.out.println(year);
        //获取月
        int month = calendar.get(Calendar.MONTH);
        System.out.println(month+1);
        //获取日
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);
        //获取时
        int hour = calendar.get(Calendar.HOUR_OF_DAY);//HOUR 12小时，HOUR_OF_DAY 24小时
        System.out.println(hour);
        //获取分
        int minute = calendar.get(Calendar.MINUTE);
        System.out.println(minute);
        //获取秒
        int second = calendar.get(Calendar.SECOND);
        System.out.println(second);
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);
    }
}
            /*输出结果
                2022-3-6 22:56:53
                1646578613678
                2022
                3
                6
                22
                56
                53
                2022年3月6日22:56:53
            */

修改时间

package com.mike.test;
 
 
import com.sun.org.apache.bcel.internal.util.Class2HTML;
 
import java.util.Calendar;
import java.util.Date;
 
public class Test {
    public static void main(String[] args) {
        //3、修改时间
        //下面这个是把时间修改为昨天的此时此刻
        Calendar calendar2 =Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH,5);//写这行代码的时候是2022.3.6，这里的5表示2022.3.5
        System.out.println(calendar2.getTime().toLocaleString());
 
        //4、add方法修改时间
        calendar2.add(Calendar.HOUR,1);//增加一小时
        System.out.println(calendar2.getTime().toLocaleString());
        calendar2.add(Calendar.HOUR,-1);//减少一小时
        System.out.println(calendar2.getTime().toLocaleString());
 
        //5、补充方法
        int maxDay = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
        int minDay = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
 
        System.out.println(maxDay);
        System.out.println(minDay);
    }
}
            /*输出结果
                2022-3-5 22:56:53
                2022-3-5 23:56:53
                2022-3-5 22:56:53
                31
                1
            */

SimpleDateFormat类

介绍SimpleDateFormat

• Simpl eDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类。
• 进行格式化(日期—>文本)、解析(文本—>日期)。
• 常用的时间模式字母

Date日期转换为SimpleDateFormat

package com.mike.test;
 
 
import com.sun.org.apache.bcel.internal.util.Class2HTML;
 
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
 
public class Test {
    public static void main(String[] args) throws ParseException {
      //1、创建SimpleDateFormat对象
        // y 年  M 月  d 日  H 时  m 分  s 秒
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
//        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");
        //2、创建Date
        Date date = new Date();
        //3、格式化Date（把日期转换成字符串）
        String str = sdf.format(date);
        String str2 = sdf2.format(date);
        System.out.println(str);
        System.out.println(str2);
 
        //4、解析（把字符串转换成日期）
        Date date2 = sdf2.parse("1999-09-09");//必须按照sdf2的样子写，还要抛出异常
        System.out.println(date2.toString());
        System.out.println(date2.toLocaleString());
    }
}
            /*输出结果
                2022年03月06日 23:17:17
                2022-03-06
                Thu Sep 09 00:00:00 CST 1999
                1999-9-9 0:00:00
            */

System类

1、介绍System类

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

2、练习代码

package com.mike.test;
 
 
import java.util.Arrays;
 
public class Test {
    public static void main(String[] args){
        //arrayCopy();数组的复制
        //src:源数组
        //srcPos:从哪个位置开始复制0~
        //dest: 目标数组
        //destPos:目标数组的位置
        //length: 复制的长度
        int[] arr = {20,18,15,8,35,26,45,90};//原数组
        int[] dest = new int[8];
        System.arraycopy(arr,0,dest,0,arr.length);
 
        for (int i = 0; i < dest.length; i++) {
            System.out.print(dest[i]+"\t");
        }
        System.out.println("复制完成");
        //Arrays. copy0f(original, newLength)就是用System.arraycopy()实现的
 
        //System.currentTimeMillis()方法可以用来计时，获取当前时间的毫秒数
        System.out.println(System.currentTimeMillis());
        long start = System.currentTimeMillis();
        for (int i = 0; i < 99999; i++) {
            for (int j = 0; j < 9999; j++) {
                int result=i+j;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("这个过程执行了"+(end-start)+"毫秒");
        //System.gc();告诉垃圾回收器回收垃圾
    }
}
            /*输出结果
                20	18	15	8	35	26	45	90	复制完成
                1646581538650
                这个过程执行了8毫秒
            */