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{@Overridepublic 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{@Overridepublic void service() {System.out.println("成功连接电脑，风扇开始工作");}}// 使用局部内部类创建对象Usb usb1 = new Fan();usb1.service();// 使用匿名内部类进行优化（相当于创建了一个局部内部类），new Usb() 可以是父类，也可以是接口Usb usb2 = new Usb() {@Overridepublic 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{@Overridepublic 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(){@Overridepublic 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("小华", "哈士奇"){@Overridepublic 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()@Overridepublic boolean equals(Object obj) {// 判断两个对象是否是同一个引用if (this==obj){return true;}// 判断obj是否nullif (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;}@Overrideprotected 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 包装类对应

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); // 因为这里比较的是引用类型的地址，所以这里打印出falseInteger 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); // -> falseSystem.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;ichar 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或者falseSystem.out.println(b1);boolean b2 = date1.before(date2); // date1在date2之前，返回ture或者falseSystem.out.println(b2);// 比较 compareToint 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月，要想正常显示则+1int 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

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");// 创建DateDate 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系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的。

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;iSystem.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();// 退出jvmSystem.exit(0);System.out.println("结束了"); // 此行代码不打印}
}

11、总结

• 内部类
  • 在一个类的内部再定义一个完整的类。
  • 成员内部类、静态内部类、局部内部类、匿名内部类。
• Object类
  • 所有类的直接或间接父类，可存储任何对象。
• 包装类
  • 基本数据类型所对应的引用数据类型，可以使Object统一所有数据。
• String类
  • 字符串是常量，创建之后不可改变，字面值保存在字符串池中，可以共享。
• BigDecimal
  • 可精确计算浮点数。
• Date
  • 特定时间
• Calendar
  • 日历
• System
  • 系统类