Java学习笔记(No.14)

Java常用类(No.14)

​ Java常用类(Common Class)主要是解决某一方面的问题。其包括：“Object类、Boolean类、Character类、Byte类、Short类、Integer类、Long类、Float类、Double类、Date类、Calendar类、LocalDate类、LocalTime类、LocalDateTime类、DateFormat类、SimpleDateFormat类、DateTimeFormatter类、Array类、String类、StringBuffer类、StringBuilder类、Math类、File类、Enum类”等。

1、Object类(Object Class)

​ Object类是所有Java类的根基类，若在类的声明中未使用“extends”关键字指明其基类，则默认其基类为“Object类”。其包括：“toString方法、hashCode方法、equals方法、clone方法、getClass方法(用于“反射”)、wait方法(有三种形式(用于“多线程”)，如：“wait()、wait(long timeout)、wait(long timeout,int nanos)”)、notify方法(用于“多线程”)、notifyAll方法(用于“多线程”)、finalize方法(用于“GC”)”。

1.1、toString方法(toString Method)

• 1.1.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass;
/**
 * 打印对象的时候默认调用当前对象的toString方法；
 * 若不重写toString方法，则默认调用Object类的toString方法；
 * 一般建议通过系统自动生成重写toString方法的代码，尽量不要手写，不然容易出错。
 */
public class ToStringMethod {
    public static void main(String[] args) {
        User user1 = new User();
        user1.id="001";
        user1.name="学山学海";
        System.out.println(user1);//等价于System.out.println(user1.toString());
        User user2 = new User();
        System.out.println(user2);//等价于System.out.println(user2.toString());
    }
}
class User{
    public String id;
    public String name;
    public String password;
    //重写toString方法
    @Override
    public String toString() {
        return "User{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}

• 1.1.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

User{id='001', name='学山学海'}
User{id='null', name='null'}

• 1.1.3、注意事项(Matters Needing Attention)
  • 1.1.3.1、打印对象的时候默认调用当前对象的toString方法。
  • 1.1.3.2、若不重写toString方法，则默认调用Object类的toString方法。
  • 1.1.3.3、一般建议通过系统自动生成重写toString方法的代码，尽量不要手写，不然容易出错。

1.2、hashCode方法(hashCode Method)

• 1.2.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.object;
import java.util.Objects;//导入工具类“Objects”
/**
 *Object类定义的hashCode方法确实为不同的对象返回不同的整数，即使用Object类hashCode方法来确定对象的唯一性；
 *Object类的hashCode有时就是对象在内存中的地址(类似于从引用类型到int类型的转换)；
 *写代码时要注意hashCode不要相同，尽量将其进行散列(即，哈希)；
 */
public class HashCodeMethod {
    public static void main(String[] args) {
        Person person = new Person();
        person.id=1;
        person.name="学山学海";
        System.out.println("person.hashCode()结果为："+person.hashCode());//调用Person类重写的hashCode方法
    }
}
class Person{
    public int id;
    public String name;
//    @Override
//    public boolean equals(Object o) {
//        if (this == o) return true;
//        if (o == null || getClass() != o.getClass()) return false;
//        Person person = (Person) o;
//        return id == person.id && Objects.equals(name, person.name);
//    }
    @Override
    public int hashCode() {
        return Objects.hash(id, name);
    }
}

• 1.2.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

person.hashCode()结果为：720546236

1.2.3、注意事项(Matters Needing Attention)

• 1.2.3.1、Object类定义的hashCode方法确实为不同的对象返回不同的整数，即使用Object类hashCode方法来确定对象的唯一性。
• 1.2.3.2、Object类的hashCode有时就是对象在内存中的地址(类似于从引用类型到int类型的转换)。
• 1.2.3.3、写代码时要注意hashCode不要相同，尽量将其进行散列(即，哈希)。

1.3、equals方法(equals Method)

1.3.1、equals常规对象比较(Equals General Object Comparison)

• 1.3.1.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass;
import java.util.Objects;
//基本数据类型(如：int类型数据)使用equals方法比较的是两者间值是否相等
public class EqualsMethod {
    public static void main(String[] args) {
        Scientist scientist1 = new Scientist(1, "袁爷爷", "中国杂交水稻之父");
        Scientist scientist2 = new Scientist(1, "袁隆平", "世界杂交水稻之父");
        Star star1 = new Star(2, "马尔泰.若曦", "明星");
        Star star2 = new Star(2, "张晓", "偶像");
        System.out.println("Scientist类已重写equals方法：");
        System.out.println("==================================================");
        System.out.println("scientist1==scientist2结果为：" + (scientist1 == scientist2));//比较的是对象内存地址，而不是对象属性中具体的值
        System.out.println("scientist1.equals(scientist2)结果为：" + (scientist1.equals(scientist2)));//已重写Scientist类equals方法时，则调用Scientist类equals自定义方法比较对象属性中具体的值
        System.out.println("==================================================");
        System.out.println("Star类未重写equals方法：");
        System.out.println("==================================================");
        System.out.println("star1==star2结果为：" + (star1 == star2));//比较对象内存地址，而不是对象属性中具体的值
        System.out.println("star1.equals(star2)结果为：" + (star1.equals(star2)));//未重写Star类equals方法时，默认调用Object类equals方法比较对象内存地址
        System.out.println("==================================================");
    }
}
class Scientist {
    public int idCard;
    public String name;
    public String characterDescription;
    //声明有参构造方法
    public Scientist(int idCard, String name, String characterDescription) {
        this.idCard = idCard;
        this.name = name;
        this.characterDescription = characterDescription;
    }
    //重写equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Scientist scientist = (Scientist) o;
        return idCard == scientist.idCard;
    }
    //重写hashCode方法
    @Override
    public int hashCode() {
        return Objects.hash(idCard);
    }
}
class Star {
    public int idCard;
    public String name;
    public String characterDescription;
    //声明有参构造方法
    public Star(int idCard, String name, String characterDescription) {
        this.idCard = idCard;
        this.name = name;
        this.characterDescription = characterDescription;
    }
}

• 1.3.1.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

Scientist类已重写equals方法：
==================================================
scientist1==scientist2结果为：false
scientist1.equals(scientist2)结果为：true
==================================================
Star类未重写equals方法：
==================================================
star1==star2结果为：false
star1.equals(star2)结果为：false
==================================================

1.3.2、equals深化组合对象比较(Equals Deepen Combination Object Comparison)

• 1.3.2.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass;
import java.util.Objects;
/**
 *比较的对象如果是一个组合关系，切记要重写自定义属性类的equals方法，否则会默认调用Object类的equals方法
 */
public class EqualsDeepenMethod {
    public static void main(String[] args) {
        Computer computer1 = new Computer(1,"鸿蒙",new Cpu(11,"龙芯1"));
        Computer computer2 = new Computer(1,"鸿蒙",new Cpu(11,"龙芯2"));
        System.out.println("重写Computer类与Cpu类自定义属性equals方法：");
        System.out.println("=================================================");
        System.out.println("computer1==computer2结果为："+(computer1==computer2));//比较对象内存地址
        System.out.println("computer1.equals(computer2)结果为："+(computer1.equals(computer2)));//比较对象属性值
        System.out.println("=================================================");
    }
}
class Computer{
    public int id;
    public String name;
    public Cpu cpu;
    //有参构造方法
    public Computer(int id, String name, Cpu cpu) {
        this.id = id;
        this.name = name;
        this.cpu = cpu;
    }
    //重写equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Computer computer = (Computer) o;
        return id == computer.id && Objects.equals(name, computer.name) && Objects.equals(cpu, computer.cpu);
    }
    //重写hashCode方法
    @Override
    public int hashCode() {
        return Objects.hash(id, name, cpu);
    }
}
class Cpu{
    public int id;
    public String name;
    //有参构造方法
    public Cpu(int id, String name) {
        this.id = id;
        this.name = name;
    }
    //重写equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Cpu cpu = (Cpu) o;
        return id == cpu.id;
    }
    //重写hashCode方法
    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

• 1.3.2.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

重写Computer类与Cpu类自定义属性equals方法：
=================================================
computer1==computer2结果为：false
computer1.equals(computer2)结果为：true
=================================================

1.3.3、equals和hashCode的羁绊(The Fetter Of Equals And hashCode)

• 1.3.3.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass;
import java.util.Objects;
/**
 *若两个对象equals(即，相等)，则它们的hashCode(即，哈希码)一定相等；
 *若两个对象hashCode(即，哈希码)相等，则它们不一定equals(即，相等)，需先验证hashCode，再验证equals。如：“超过hashCode最大值时”
 */
public class EqualsAndHashcode {
    public static void main(String[] args) {
        Water water1 = new Water(1,"湖水");
        Water water2 = new Water(1,"海水");
        System.out.println("water1.hashCode()结果为："+water1.hashCode());
        System.out.println("water2.hashCode()结果为："+water2.hashCode());
        System.out.println("water1.equals(water2)结果为："+water1.equals(water2));
    }
}
class Water{
    public int id;
    public String name;
    public Water(int id, String name) {
        this.id = id;
        this.name = name;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Water water = (Water) o;
        return id == water.id;
    }
    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

• 1.3.3.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

water1.hashCode()结果为：32
water2.hashCode()结果为：32
water1.equals(water2)结果为：true

1.3.4、注意事项(Matters Needing Attention)

• 1.3.4.1、基本数据类型(如：int类型数据)使用equals方法比较的是两者间值是否相等。
• 1.3.4.2、未重写该类自定义属性的equals方法时，则默认调用Object类equals方法比较两者间对象内存地址是否相等。
• 1.3.4.3、重写该类自定义属性的equals方法时，则调用该类自定义属性的equals方法比较两者间对象属性的具体值是否相等。
• 1.3.4.4、若比较的对象是一个组合关系，切记要重写自定义属性类的equals方法，否则会默认调用Object类的equals方法。
• 1.3.4.5、若两个对象equals(即，相等)，则它们的hashCode(即，哈希码)一定相等。
• 1.3.4.6、若两个对象hashCode(即，哈希码)相等，则它们不一定equals(即，相等)，需先验证hashCode，再验证equals。如：“超过hashCode最大值时”。
• 1.3.4.7、创建类时，建议尽量重写toString、equals、hashCode方法。

1.4、clone方法(Clone Method)

1.4.1、常规克隆(General Clone)

• 1.4.1.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.object;
import java.util.Objects;
/**
 * 克隆一个类的对象时，首先要实现这个类的Cloneable接口，然后重写Object类的clone方法，且必须提高其访问权限(由“protected”更改为“public”)
 */
public class CloneGeneralMethod {
    public static void main(String[] args) throws CloneNotSupportedException {
        Fire fire1 = new Fire(1, "柴火");
        Fire fire2 = (Fire) fire1.clone();//调用Fire类重写的clone方法
        System.out.println("fire1==fire2结果为："+(fire1==fire2));//比较对象内存地址
        System.out.println("fire1.equals(fire2)结果为："+fire1.equals(fire2));//比较对象属性值
    }
}
class Fire implements Cloneable {
    public int id;
    public String name;
    //有参构造方法
    public Fire(int id, String name) {
        this.id = id;
        this.name = name;
    }
    //重写toString方法
    @Override
    public String toString() {
        return "Fire{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
    //重写equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Fire fire = (Fire) o;
        return id == fire.id && Objects.equals(name, fire.name);
    }
    //重写hashCode方法
    @Override
    public int hashCode() {
        return Objects.hash(id, name);
    }
    //重写clone方法
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

• 1.4.1.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

fire1==fire2结果为：false
fire1.equals(fire2)结果为：true

1.4.2、浅度克隆(Shallow Clone)

• 1.4.2.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.object;
public class CloneShallowMethod {
    public static void main(String[] args) throws CloneNotSupportedException {
        Car car1 = new Car(1, new Engine(11, "卓越"), new Tire(22, "正新"));
        Car car2= (Car) car1.clone();
        System.out.println("clone方法的浅度克隆：");
        System.out.println("===========================================");
        System.out.println("car1.toString()结果为："+car1.toString());
        System.out.println("car2.toString()结果为："+car2.toString());
        System.out.println("===========================================");
    }
}
class Car implements Cloneable{
    public int id;
    public Engine engine;
    public Tire tire;
    public Car(int id, Engine engine, Tire tire) {
        this.id = id;
        this.engine = engine;
        this.tire = tire;
    }
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    @Override
    public String toString() {
        return "Car{" +
                "id=" + id +
                ", engine=" + engine +
                ", tire=" + tire +
                '}';
    }
}
class Engine{
    public int eid;
    public String name;
    public Engine(int eid, String name) {
        this.eid = eid;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Engine{" +
                "eid=" + eid +
                ", name='" + name + '\'' +
                '}';
    }
}
class Tire{
    public int tid;
    public String name;
    public Tire(int tid, String name) {
        this.tid = tid;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Tire{" +
                "tid=" + tid +
                ", name='" + name + '\'' +
                '}';
    }
}

• 1.4.2.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

clone方法的浅度克隆：
===========================================
car1.toString()结果为：Car{id=1, engine=Engine{eid=11, name='卓越'}, tire=Tire{tid=22, name='正新'}}
car2.toString()结果为：Car{id=1, engine=Engine{eid=11, name='卓越'}, tire=Tire{tid=22, name='正新'}}
===========================================

1.4.3、深度克隆(Deep Clone)

• 1.4.3.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.object;
public class CloneDeepMethod {
    public static void main(String[] args) throws CloneNotSupportedException {
        CarDeep carDeep1 = new CarDeep(1, new EngineDeep(11, "卓越"), new TireDeep(22, "正新"));
        CarDeep carDeep2= (CarDeep) carDeep1.clone();
        System.out.println("clone方法的深度克隆：");
        System.out.println("===========================================");
        System.out.println("carDeep1.toString()结果为："+carDeep1.toString());
        System.out.println("carDeep2.toString()结果为："+carDeep2.toString());
        System.out.println("===========================================");
        System.out.println("将carDeep1.engine.name=\"极致\"后：");
        carDeep1.engine.name="极致";
        System.out.println("===========================================");
        System.out.println("carDeep1.toString()结果为："+carDeep1.toString());
        System.out.println("carDeep2.toString()结果为："+carDeep2.toString());
        System.out.println("===========================================");
        System.out.println("将carDeep1.tire.name=\"米其林\"后：");
        carDeep1.tire.name="米其林";
        System.out.println("===========================================");
        System.out.println("carDeep1.toString()结果为："+carDeep1.toString());
        System.out.println("carDeep2.toString()结果为："+carDeep2.toString());
        System.out.println("===========================================");
    }
}
class CarDeep implements Cloneable{
    public int id;
    public EngineDeep engine;
    public TireDeep tire;
    //有参构造方法
    public CarDeep(int id, EngineDeep engine, TireDeep tire) {
        this.id = id;
        this.engine = engine;
        this.tire = tire;
    }
    //重写clone方法
    @Override
    public Object clone() throws CloneNotSupportedException {
        CarDeep carD= (CarDeep) super.clone();//CarDeep类中对象carD的浅度克隆
        carD.engine= (EngineDeep) this.engine.clone();//CarDeep类中使用类EngineDeep对象engine的深度克隆
        carD.tire= (TireDeep) this.tire.clone();//CarDeep类中使用类TireDeep对象tire的深度克隆
        return carD;//返回CarDeep类中对象carD
    }
    //重写toString方法
    @Override
    public String toString() {
        return "Car{" +
                "id=" + id +
                ", engine=" + engine +
                ", tire=" + tire +
                '}';
    }
}
class EngineDeep implements Cloneable{
    public int eid;
    public String name;
    //有参构造方法
    public EngineDeep(int eid, String name) {
        this.eid = eid;
        this.name = name;
    }
    //重写toString方法
    @Override
    public String toString() {
        return "Engine{" +
                "eid=" + eid +
                ", name='" + name + '\'' +
                '}';
    }
    //重写clone方法
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class TireDeep implements Cloneable{
    public int tid;
    public String name;
    //有参构造方法
    public TireDeep(int tid, String name) {
        this.tid = tid;
        this.name = name;
    }
    //重写toString方法
    @Override
    public String toString() {
        return "Tire{" +
                "tid=" + tid +
                ", name='" + name + '\'' +
                '}';
    }
    //重写clone方法
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

• 1.4.3.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

clone方法的深度克隆：
===========================================
carDeep1.toString()结果为：Car{id=1, engine=Engine{eid=11, name='卓越'}, tire=Tire{tid=22, name='正新'}}
carDeep2.toString()结果为：Car{id=1, engine=Engine{eid=11, name='卓越'}, tire=Tire{tid=22, name='正新'}}
===========================================
将carDeep1.engine.name="极致"后：
===========================================
carDeep1.toString()结果为：Car{id=1, engine=Engine{eid=11, name='极致'}, tire=Tire{tid=22, name='正新'}}
carDeep2.toString()结果为：Car{id=1, engine=Engine{eid=11, name='卓越'}, tire=Tire{tid=22, name='正新'}}
===========================================
将carDeep1.tire.name="米其林"后：
===========================================
carDeep1.toString()结果为：Car{id=1, engine=Engine{eid=11, name='极致'}, tire=Tire{tid=22, name='米其林'}}
carDeep2.toString()结果为：Car{id=1, engine=Engine{eid=11, name='卓越'}, tire=Tire{tid=22, name='正新'}}
===========================================

1.4.4、注意事项(Matters Needing Attention)

• 1.4.4.1、克隆一个类的对象时，首先要实现这个类的Cloneable接口，然后重写Object类的clone方法，且必须提高其访问权限(由“protected”更改为“public”)。
• 1.4.4.2、浅度克隆一个类的对象时，只需要实现这个类的Cloneable接口，然后重写Object类的clone方法，且必须提高其访问权限(由“protected”更改为“public”)。
• 1.4.4.3、深度克隆一个类的对象时，需要全部实现这个类以及类中其它使用类的Cloneable接口，然后分别都重写Object类的clone方法，且必须提高其访问权限(由“protected”更改为“public”)。

2、包装类(Wrapper Class)

​ 由于Java中的基本数据类型不是面向对象的，有时候不方便将其转换成对象进行操作，因此Java专门为八种基本数据类型分别设计了各自对应的类，而这八种类统称为“包装类(Wrapper Class)”。

​ 八大基本数据类型及其包装类的对应关系如下表所示。

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

2.1、包装类常见属性与方法(Common Properties And Methods Of Wrapper Class)

• 2.1.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.wrapper;
public class CommonPropertiesAndMethods {
    public static void main(String[] args) {
        Integer i=123;//int类型数据
        System.out.println("调用Integer包装类对象的toString方法：");
        System.out.println("=================================");
        System.out.println("i.toString()结果为："+i.toString());
        System.out.println("=================================");
        String s1="1";//String类型数据
        String s2="2";//String类型数据
        System.out.println("调用Integer包装类对象的parseInt方法：");
        System.out.println("=================================");
        System.out.println("(s1+s2)结果为："+(s1+s2));
        System.out.println("(Integer.parseInt(s1)+Integer.parseInt(s2))结果为："+(Integer.parseInt(s1)+Integer.parseInt(s2)));//将String类型数据转换成int类型数据
        System.out.println("=================================");
        System.out.println("调用Integer包装类的MIN_VALUE与MAX_VALUE属性：");
        System.out.println("=================================");
        System.out.println("(Integer.MIN_VALUE)结果为："+(Integer.MIN_VALUE));//Integer包装类最小值
        System.out.println("(Integer.MAX_VALUE)结果为："+(Integer.MAX_VALUE));//Integer包装类最大值
        System.out.println("=================================");
        System.out.println("调用Integer包装类的TYPE属性：");
        System.out.println("=================================");
        System.out.println("(Integer.TYPE)结果为："+(Integer.TYPE));//Integer包装类的类型
        System.out.println("=================================");
        System.out.println("调用Integer包装类的toBinaryString静态方法：");
        System.out.println("=================================");
        System.out.println("(Integer.toBinaryString(i))结果为："+(Integer.toBinaryString(i)));//将10进制int类型数据转换成2进制int类型数据
        System.out.println("=================================");
        System.out.println("调用Integer包装类的toOctalString静态方法：");
        System.out.println("=================================");
        System.out.println("(Integer.toOctalString(i))结果为："+(Integer.toOctalString(i)));//将10进制int类型数据转换成8进制int类型数据
        System.out.println("=================================");
        System.out.println("调用Integer包装类的toHexString静态方法：");
        System.out.println("=================================");
        System.out.println("(Integer.toHexString(i))结果为："+(Integer.toHexString(i)));//将10进制int类型数据转换成16进制int类型数据
        System.out.println("=================================");
        String s3="1.2";//String类型数据
        String s4="3.4";//String类型数据
        System.out.println("调用Double包装类对象的parseDouble方法：");
        System.out.println("=================================");
        System.out.println("(s3+s4)结果为："+(s3+s4));
        System.out.println("(Double.parseDouble(s3)+Double.parseDouble(s4))结果为："+(Double.parseDouble(s3)+Double.parseDouble(s4)));//将String类型数据转换成double类型数据
        System.out.println("=================================");
        System.out.println("调用Double包装类的MIN_VALUE与MAX_VALUE属性：");
        System.out.println("=================================");
        System.out.println("(Double.MIN_VALUE)结果为："+(Double.MIN_VALUE));//Double包装类最小值
        System.out.println("(Double.MAX_VALUE)结果为："+(Double.MAX_VALUE));//Double包装类最大值
        System.out.println("=================================");
        System.out.println("调用Double包装类的TYPE属性：");
        System.out.println("=================================");
        System.out.println("(Double.TYPE)结果为："+(Double.TYPE));//Double包装类的类型
        System.out.println("=================================");
        char c1='1';//char类型数据
        char c2='a';//char类型数据
        System.out.println("调用Character包装类对象的isDigit方法：");
        System.out.println("=================================");
        System.out.println("(Character.isDigit(c1))结果为："+(Character.isDigit(c1)));//判断char类型数据是否为数字
        System.out.println("(Character.isDigit(c2))结果为："+(Character.isDigit(c2)));//判断char类型数据是否为数字
        System.out.println("=================================");
        System.out.println("调用Character包装类的MIN_VALUE与MAX_VALUE属性：");
        System.out.println("=================================");
        System.out.println("((int)(Character.MIN_VALUE))结果为："+((int)(Character.MIN_VALUE)));//Character包装类最小值
        System.out.println("((int)(Character.MAX_VALUE))结果为："+((int)(Character.MAX_VALUE)));//Character包装类最大值
        System.out.println("=================================");
        System.out.println("调用Character包装类的TYPE属性：");
        System.out.println("=================================");
        System.out.println("(Character.TYPE)结果为："+(Character.TYPE));//Character包装类的类型
        System.out.println("=================================");
//        System.out.println(i.hashCode()+"---"+Integer.valueOf(i).hashCode());
    }
}

• 2.1.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

调用Integer包装类对象的toString方法：
=================================
i.toString()结果为：123
=================================
调用Integer包装类对象的parseInt方法：
=================================
(s1+s2)结果为：12
(Integer.parseInt(s1)+Integer.parseInt(s2))结果为：3
=================================
调用Integer包装类的MIN_VALUE与MAX_VALUE属性：
=================================
(Integer.MIN_VALUE)结果为：-2147483648
(Integer.MAX_VALUE)结果为：2147483647
=================================
调用Integer包装类的TYPE属性：
=================================
(Integer.TYPE)结果为：int
=================================
调用Integer包装类的toBinaryString静态方法：
=================================
(Integer.toBinaryString(i))结果为：1111011
=================================
调用Integer包装类的toOctalString静态方法：
=================================
(Integer.toOctalString(i))结果为：173
=================================
调用Integer包装类的toHexString静态方法：
=================================
(Integer.toHexString(i))结果为：7b
=================================
调用Double包装类对象的parseDouble方法：
=================================
(s3+s4)结果为：1.23.4
(Double.parseDouble(s3)+Double.parseDouble(s4))结果为：4.6
=================================
调用Double包装类的MIN_VALUE与MAX_VALUE属性：
=================================
(Double.MIN_VALUE)结果为：4.9E-324
(Double.MAX_VALUE)结果为：1.7976931348623157E308
=================================
调用Double包装类的TYPE属性：
=================================
(Double.TYPE)结果为：double
=================================
调用Character包装类对象的isDigit方法：
=================================
(Character.isDigit(c1))结果为：true
(Character.isDigit(c2))结果为：false
=================================
调用Character包装类的MIN_VALUE与MAX_VALUE属性：
=================================
((int)(Character.MIN_VALUE))结果为：0
((int)(Character.MAX_VALUE))结果为：65535
=================================
调用Character包装类的TYPE属性：
=================================
(Character.TYPE)结果为：char
=================================

2.2、包装类创建方法与自动装箱拆箱(Creating Methods And Autoboxing Unboxing of Wrapper Class)

• 2.2.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.wrapper;
public class CreatingMethodsAndAutoboxingUnboxing {
    public static void main(String[] args) {
        //创建包装类对象
        System.out.println("创建包装类对象");
        System.out.println("========================");
        Integer i1=new Integer(1);//装箱
        System.out.println("装箱：i1="+i1);
        Integer i2=new Integer("2");//装箱
        System.out.println("装箱：i2="+i2);
        Integer i3=3;//自动装箱
        System.out.println("自动装箱：i3="+i3);
        Integer i4=Integer.valueOf(4);//装箱
        System.out.println("装箱：i4="+i4);
        Integer i5=Integer.valueOf("5");//装箱
        System.out.println("装箱：i5="+i5);
        Integer i6=Integer.valueOf("1001",2);//装箱
        System.out.println("装箱：i6="+i6);
        Integer i7=Integer.valueOf("1001",8);//装箱
        System.out.println("装箱：i7="+i7);
        Integer i8=Integer.valueOf("8",10);//装箱
        System.out.println("装箱：i8="+i8);
        Integer i9=Integer.valueOf("1001",16);//装箱
        System.out.println("装箱：i9="+i9);
        System.out.println("========================");
        System.out.println("创建基本类型数据");
        System.out.println("========================");
        int ii1=Integer.valueOf(111);//自动拆箱
        System.out.println("自动拆箱：ii1="+ii1);
        int ii2=Integer.valueOf("112");//自动拆箱
        System.out.println("自动拆箱：ii2="+ii2);
        int ii3=Integer.valueOf("1001",2);//自动拆箱
        System.out.println("自动拆箱：ii3="+ii3);
        int ii4=Integer.valueOf("1001",8);//自动拆箱
        System.out.println("自动拆箱：ii4="+ii4);
        int ii5=Integer.valueOf("8",10);//自动拆箱
        System.out.println("自动拆箱：ii5="+ii5);
        int ii6=Integer.valueOf("1001",16);//自动拆箱
        System.out.println("自动拆箱：ii6="+ii6);
        int ii7=Integer.valueOf(117).intValue();//拆箱
        System.out.println("拆箱：ii7="+ii7);
        System.out.println("========================");
    }
}

• 2.2.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

创建包装类对象
========================
装箱：i1=1
装箱：i2=2
自动装箱：i3=3
装箱：i4=4
装箱：i5=5
装箱：i6=9
装箱：i7=513
装箱：i8=8
装箱：i9=4097
========================
创建基本类型数据
========================
自动拆箱：ii1=111
自动拆箱：ii2=112
自动拆箱：ii3=9
自动拆箱：ii4=513
自动拆箱：ii5=8
自动拆箱：ii6=4097
拆箱：ii7=117
========================

2.3、缓存(Cache)

• 2.3.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.wrapper;
public class CacheInteger {
    public static void main(String[] args) {
        System.out.println("整型缓存(IntegerCache)");
        System.out.println("=====================================");
        //使用Integer类默认缓存创建对象，Integer类缓存区间"-128~127"
        Integer i1 = Integer.valueOf(1);
        Integer i2 = Integer.valueOf(1);
        System.out.println("(i1==i2)结果为："+(i1 == i2));
        /**
         *自动装箱默认使用Integer类“valueOf”方法在缓存中创建Integer类对象，且缓存可以节省自动装箱创建Integer类对象的空间，
         *若超过缓存区间范围时，则使用“new Integer类名称”方法在堆内存中创建Integer类对象
         */
        Integer i11 = -128;//自动装箱默认使用Integer类“valueOf”方法在缓存中创建Integer类对象
        Integer i12 = -128;//自动装箱默认使用Integer类“valueOf”方法在缓存中创建Integer类对象
        System.out.println("(i11==i12)结果为："+(i11 == i12));
        Integer i21 = 128;//超过缓存区间范围时，则使用“new Integer类名称”方法在堆内存中创建Integer类对象
        Integer i22 = 128;//超过缓存区间范围时，则使用“new Integer类名称”方法在堆内存中创建Integer类对象
        System.out.println("(i21==i22)结果为："+(i21 == i22));
        //不会使用缓存，每次都是在堆内存中创建Integer类对象
        Integer i3=new Integer(1);
        Integer i4=new Integer(1);
        System.out.println("(i3==i4)结果为："+(i3 == i4));
        System.out.println("=====================================");
    }
}

• 2.3.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

整型缓存(IntegerCache)
=====================================
(i1==i2)结果为：true
(i11==i12)结果为：true
(i21==i22)结果为：false
(i3==i4)结果为：false
=====================================

2.4、注意事项(Matters Needing Attention)

• 2.4.1、装箱就是把一个基本数据类型转换为其对应包装类的对象。
• 2.4.2、拆箱就是把一个包装类的对象转换为其对应基本数据类型。
• 2.4.3、自动装箱与拆箱的功能就是所谓的“编译器蜜糖(Compiler Sugar，也称“语法糖(Syntactic sugar，也译为糖衣语法)”)”，但同时要避免拆箱时的空指针异常(NullPointerException)，即，千万不要让包装类对象为空(Null)时拆箱。
• 2.4.4、自动装箱默认使用包装类“valueOf”方法在缓存中创建包装类对象，且缓存可以节省自动装箱创建包装类对象的空间，若超过缓存区间范围时，则使用“new 包装类名称”方法在堆内存中创建包装类对象。

3、日期时间相关类(Date Time Related Class)

​ 计算机中并不会存储日期时间格式的数据(如：“1970/01/01 00:00:00”)，时间在计算中就是一个数字，以毫秒为单位。

3.1、Date类(Date Class)

​ Date类，也称“日期时间类”。

• 3.1.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.datetime;
import java.util.Date;
public class DateClass {
    public static void main(String[] args) {
        //获取当前系统时间
        Date date1 = new Date();
        System.out.println("date1.toString()结果为：" + date1.toString());
        //获取指定时间
        Date date2 = new Date(1000L * 60 * 60 * 24 * (365 * 51 + 13));
        System.out.println("date2.toString()结果为：" + date2.toString());
        //日期时间类对象的比较
        Date date3 = new Date();
        Date date4 = new Date();
        System.out.println("(date3==date4)结果为："+(date3 == date4));//比较对象内存地址
        System.out.println("(date3.equals(date4))结果为："+(date3.equals(date4)));//比较对象属性值(即，时间毫秒数是否一致)
        System.out.println("(date3.hashCode()==date4.hashCode())结果为："+(date3.hashCode()==date4.hashCode()));//若比较对象equals，则对象hashCode也相等，否则对象hashCode不相等
        //日期时间类对象的哈希码值
        System.out.println("date3.hashCode()结果为："+date3.hashCode());
        System.out.println("date4.hashCode()结果为："+date4.hashCode());
        //获取时间对应的毫秒数
        System.out.println("date1.getTime()结果为：" + date1.getTime());
        System.out.println("date2.getTime()结果为：" + date2.getTime());
        System.out.println("date3.getTime()结果为：" + date3.getTime());
        System.out.println("date4.getTime()结果为：" + date4.getTime());
    }
}

• 3.1.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

date1.toString()结果为：Fri Jun 25 09:29:27 CST 2021
date2.toString()结果为：Fri Jan 01 08:00:00 CST 2021
(date3==date4)结果为：false
(date3.equals(date4))结果为：true
(date3.hashCode()==date4.hashCode())结果为：true
date3.hashCode()结果为：1086929819
date4.hashCode()结果为：1086929819
date1.getTime()结果为：1624584567508
date2.getTime()结果为：1609459200000
date3.getTime()结果为：1624584567521
date4.getTime()结果为：1624584567521

3.2、Calendar类(Calendar Class)

​ Calendar类，也称“日历类”。

• 3.2.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.datetime;
import java.util.Calendar;
import java.util.Date;
public class CalendarClass {
    public static void main(String[] args) {
        /**
         *不推荐使用：已弃用，获取Date类指定的日期时间属性值(格式:"xxxx年xx月xx日xx时xx分xx秒")
         *Date date = new Date();
         *System.out.println(date.getYear()+"年"+date.getMonth()+"月"+date.getDay()+"日"+date.getHours()+"时"+date.getMinutes()+"分"+date.getSeconds()+"秒");
         */
        //创建Calendar类对象实例
        Calendar calendar=Calendar.getInstance();
        //System.out.println("calendar.toString()结果为："+calendar.toString());
        //推荐使用：获取Calendar类指定的日期时间属性值(格式:"xxxx年xx月xx日xx时xx分xx秒")
        calendar.set(2021,1,1,1,1,1);//使用Calendar类set方法设置指定时间
        System.out.println("使用Calendar类get方法获取Calendar类set方法设置的时间(年月日时分秒)：");
        System.out.println("==============================================");
        System.out.println(calendar.get(Calendar.YEAR)+"年"+(calendar.get(Calendar.MONTH)+1)+"月"+calendar.get(Calendar.DAY_OF_MONTH)+"日"+calendar.get(Calendar.HOUR_OF_DAY)+"时"+calendar.get(Calendar.MINUTE)+"分"+calendar.get(Calendar.SECOND)+"秒"+calendar.get(Calendar.MILLISECOND)+"毫秒");
        System.out.println("==============================================");
        calendar.setTime(new Date(300000000000L));//使用Calendar类setTime方法设置指定时间
        System.out.println("使用Calendar类get方法获取Calendar类setTime方法设置的时间(年月日时分秒)：");
        System.out.println("==============================================");
        System.out.println(calendar.get(Calendar.YEAR)+"年"+(calendar.get(Calendar.MONTH)+1)+"月"+calendar.get(Calendar.DAY_OF_MONTH)+"日"+calendar.get(Calendar.HOUR_OF_DAY)+"时"+calendar.get(Calendar.MINUTE)+"分"+calendar.get(Calendar.SECOND)+"秒"+calendar.get(Calendar.MILLISECOND)+"毫秒");
        System.out.println("==============================================");
        calendar.setTimeInMillis(500000000000L);//使用Calendar类setTimeInMillis方法设置指定时间
        System.out.println("使用Calendar类get方法获取Calendar类setTimeInMillis方法设置的时间(年月日时分秒)：");
        System.out.println("==============================================");
        System.out.println(calendar.get(Calendar.YEAR)+"年"+(calendar.get(Calendar.MONTH)+1)+"月"+calendar.get(Calendar.DAY_OF_MONTH)+"日"+calendar.get(Calendar.HOUR_OF_DAY)+"时"+calendar.get(Calendar.MINUTE)+"分"+calendar.get(Calendar.SECOND)+"秒"+calendar.get(Calendar.MILLISECOND)+"毫秒");
        System.out.println("==============================================");
    }
}

• 3.2.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

使用Calendar类get方法获取Calendar类set方法设置的时间(年月日时分秒)：
==============================================
2021年2月1日1时1分1秒464毫秒
==============================================
使用Calendar类get方法获取Calendar类setTime方法设置的时间(年月日时分秒)：
==============================================
1979年7月5日13时20分0秒0毫秒
==============================================
使用Calendar类get方法获取Calendar类setTimeInMillis方法设置的时间(年月日时分秒)：
==============================================
1985年11月5日8时53分20秒0毫秒
==============================================

3.3、LocalDate、LocalTime、LocalDateTime类(LocalDate And LocalTime And LocalDateTime Class)

​ LocalDate类，也称“本地日期类”；LocalTime类，也称“本地时间类”；LocalDateTime类，也称“本地日期时间类”，它们都是JDK8的新特性。

• 3.3.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.datetime;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
public class LocalDateAndLocalTimeAndLocalDateTime {
    public static void main(String[] args) {
        //当前系统日期(年月日)
        LocalDate ld1 = LocalDate.now();
        //设定LocalDate类的日期(年月日)
        LocalDate ld2 = LocalDate.of(2021, 2, 1);
        //获取LocalDate类的日期(年月日)
        System.out.println("获取LocalDate类的日期：");
        System.out.println("============================================");
        System.out.println(ld1);
        System.out.println(ld1.getYear() + "年" + ld1.getMonthValue() + "月" + ld1.getDayOfMonth() + "日");
        System.out.println(ld2);
        System.out.println(ld2.getYear() + "年" + ld2.getMonthValue() + "月" + ld2.getDayOfMonth() + "日");
        System.out.println("============================================");
        //当前系统时间(时分秒)
        LocalTime lt1 = LocalTime.now();
        //设定LocalTime类的当前系统时间(时分秒)
        LocalTime lt2 = LocalTime.of(13, 14, 15, 1);
        LocalTime lt3 = LocalTime.ofSecondOfDay(60 * 60 * 1);
        LocalTime lt4 = LocalTime.ofNanoOfDay(1000000000L * 60 * 60 * 10);
        //获取LocalTime类的时间(时分秒)
        System.out.println("获取LocalTime类的时间：");
        System.out.println("============================================");
        System.out.println(lt1);
        System.out.println(lt1.getHour() + "时" + lt1.getMinute() + "分" + lt1.getSecond() + "秒" + lt1.getNano() + "纳秒");
        System.out.println(lt2);
        System.out.println(lt2.getHour() + "时" + lt2.getMinute() + "分" + lt2.getSecond() + "秒" + lt2.getNano() + "纳秒");
        System.out.println(lt3);
        System.out.println(lt3.getHour() + "时" + lt3.getMinute() + "分" + lt3.getSecond() + "秒" + lt3.getNano() + "纳秒");
        System.out.println(lt4);
        System.out.println(lt4.getHour() + "时" + lt4.getMinute() + "分" + lt4.getSecond() + "秒" + lt4.getNano() + "纳秒");
        System.out.println("============================================");
        //当前系统日期时间(年月日时分秒)
        LocalDateTime ldt1 = LocalDateTime.now();
        //设定LocalDateTime类的当前系统日期时间(年月日时分秒)
        LocalDateTime ldt2=LocalDateTime.of(2021,6,6,6,6,6,6);
        LocalDateTime ldt3=ldt2.withDayOfMonth(1);//更改日期时间中天的参数值
        LocalDateTime ldt4=ldt2.plusDays(1);//将日期时间中天的参数值加1
        LocalDateTime ldt5=ldt2.minusDays(1);//将日期时间中天的参数值减1
        //获取LocalDateTime类的当前系统日期时间(年月日时分秒)
        System.out.println("获取LocalDateTime类的日期时间：");
        System.out.println("============================================");
        System.out.println(ldt1);
        System.out.println(ldt1.getYear() + "年" + ldt1.getMonthValue() + "月" + ldt1.getDayOfMonth() + "日" + ldt1.getHour() + "时" + ldt1.getMinute() + "分" + ldt1.getSecond() + "秒" + ldt1.getNano() + "纳秒");
        System.out.println(ldt2);
        System.out.println(ldt2.getYear() + "年" + ldt2.getMonthValue() + "月" + ldt2.getDayOfMonth() + "日" + ldt2.getHour() + "时" + ldt2.getMinute() + "分" + ldt2.getSecond() + "秒" + ldt2.getNano() + "纳秒");
        System.out.println(ldt3);
        System.out.println(ldt3.getYear() + "年" + ldt3.getMonthValue() + "月" + ldt3.getDayOfMonth() + "日" + ldt3.getHour() + "时" + ldt3.getMinute() + "分" + ldt3.getSecond() + "秒" + ldt3.getNano() + "纳秒");
        System.out.println(ldt4);
        System.out.println(ldt4.getYear() + "年" + ldt4.getMonthValue() + "月" + ldt4.getDayOfMonth() + "日" + ldt4.getHour() + "时" + ldt4.getMinute() + "分" + ldt4.getSecond() + "秒" + ldt4.getNano() + "纳秒");
        System.out.println(ldt5);
        System.out.println(ldt5.getYear() + "年" + ldt5.getMonthValue() + "月" + ldt5.getDayOfMonth() + "日" + ldt5.getHour() + "时" + ldt5.getMinute() + "分" + ldt5.getSecond() + "秒" + ldt5.getNano() + "纳秒");
        System.out.println("============================================");
    }
}

• 3.3.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

获取LocalDate类的日期：
============================================
2021-06-25
2021年6月25日
2021-02-01
2021年2月1日
============================================
获取LocalTime类的时间：
============================================
14:27:10.901
14时27分10秒901000000纳秒
13:14:15.000000001
13时14分15秒1纳秒
01:00
1时0分0秒0纳秒
10:00
10时0分0秒0纳秒
============================================
获取LocalDateTime类的日期时间：
============================================
2021-06-25T14:27:10.901
2021年6月25日14时27分10秒901000000纳秒
2021-06-06T06:06:06.000000006
2021年6月6日6时6分6秒6纳秒
2021-06-01T06:06:06.000000006
2021年6月1日6时6分6秒6纳秒
2021-06-07T06:06:06.000000006
2021年6月7日6时6分6秒6纳秒
2021-06-05T06:06:06.000000006
2021年6月5日6时6分6秒6纳秒
============================================

3.4、DateFormat、SimpleDateFormat类(DateFormat And SimpleDateFormat Class)

​ DateFormat类是日期/时间格式化子类(SimpleDateFormat类)的抽象类，它以语言无关的方式格式化和分析日期或时间。 日期/时间格式化子类(SimpleDateFormat类)允许格式化(即日期文本)，解析(文本日期)和归一化。 该日期表示为一个Date对象，或自1970年1月1日00:00:00 GMT以来的毫秒。

• 3.4.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.datetime;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateFormatAndSimpleDateFormat {
    public static void main(String[] args) throws ParseException {
        String pattern = "yyyy-MM-dd HH:mm:ss:SSS";
        Date d1 = new Date();
        String dateConvertString = date2String(pattern, d1);//将日期时间转换为字符串
        System.out.println("将日期时间("+d1+")转换为字符串："+dateConvertString);
//        pattern = "yyyy年MM月dd日 HH时mm分ss秒SSS毫秒";
        Date d2 = string2Date(pattern, dateConvertString);//将字符串转换为日期时间
        System.out.println("将字符串("+dateConvertString+")转换为日期时间："+d2);
    }
    private static Date string2Date(String pattern, String string) throws ParseException {
        //将字符串转换为日期时间
        DateFormat dateFormat = new SimpleDateFormat(pattern);//抽象父类引用指向子类对象
        return dateFormat.parse(string);
    }
    private static String date2String(String pattern, Date date) {
        //将日期时间转换为字符串
        DateFormat dateFormat = new SimpleDateFormat(pattern);//抽象父类引用指向子类对象
        return dateFormat.format(date);
    }
    //自动封装类方法代码块的快捷键：先选中代码块，然后按住“Ctrl+Alt+M”不放，直到弹出对话框，再输入封装类的方法名称，最后回车即可
}

• 3.4.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

将日期时间(Fri Jun 25 22:08:01 CST 2021)转换为字符串：2021-06-25 22:08:01:106
将字符串(2021-06-25 22:08:01:106)转换为日期时间：Fri Jun 25 22:08:01 CST 2021

3.5、DateTimeFormatter类(DateTimeFormatter Class)

​ DateTimeFormatter类，也称“日期时间格式化类”。

• 3.5.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.datetime;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class DateTimeFormatterClass {
    public static void main(String[] args) {
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss:SSS");//使用日期时间格式化类的静态方法实例化日期时间格式化类的对象
        LocalDateTime localDateTime = LocalDateTime.now();//当前系统日期时间
        String dateConvertString = date2String(dateTimeFormatter, localDateTime);//将日期时间转换为字符串
        System.out.println("将日期时间(" + localDateTime + ")转换为字符串：" + dateConvertString);//输出日期时间字符串
        LocalDateTime ldt = string2Date(dateConvertString, dateTimeFormatter);//将字符串转换为日期时间
        System.out.println("将字符串(" + dateConvertString + ")转换为日期时间：" + ldt);//输出日期时间
    }
    private static LocalDateTime string2Date(String dateConvertString, DateTimeFormatter dateTimeFormatter) {
        //将字符串转换为日期时间
        return LocalDateTime.parse(dateConvertString, dateTimeFormatter);
    }
    private static String date2String(DateTimeFormatter dateTimeFormatter, LocalDateTime localDateTime) {
        //将日期时间转换为字符串
        return localDateTime.format(dateTimeFormatter);
    }
    //自动封装类方法代码块的快捷键：先选中代码块，然后按住“Ctrl+Alt+M”不放，直到弹出对话框，再输入封装类的方法名称，最后回车即可
}

• 3.5.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

将日期时间(2021-06-25T22:27:55.553)转换为字符串：2021-06-25 22:27:55:553
将字符串(2021-06-25 22:27:55:553)转换为日期时间：2021-06-25T22:27:55.553

3.6、注意事项(Matters Needing Attention)

• **3.6.1、LocalDate、LocalTime、LocalDateTime类构造方法为私有的，不能使用关键字"new"创建对象 **。
• 3.6.2、DateFormat类是抽象类，只能由继承其的子类(SimpleDateFormat类)来创建实例化对象，即，父类的引用指向子类对象。
• 3.6.3、可以使用类的静态方法实例化类的对象。

4、数组(Array)

​ 数组(Array)就是"若干个相同类型数据的有序集合(Ordered Set)"，其中每一个数据称为数组的"元素(Element)"，每一个数组元素都通过一个下标(Subscript)或索引(Index)来访问(Access)。具体使用示例如CSDN博客"Java数组详解(No.11))"所示。

5、字符串相关类(String Related Class)

5.1、String类创建对象方法(String Class Create Object Method)

• 5.1.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.string;
public class StringClassCreateObjectMethod {
    public static void main(String[] args) {
        //通过构造器(即，构造方法)创建String类对象
        System.out.println("通过构造器(即，构造方法)创建String类对象：");
        System.out.println("===========================================");
        String str0 = new String();
        System.out.println(str0);
        byte[] byteStr = {1, 2, 3};
        String str1 = new String(byteStr);
        System.out.println(str1);
        char[] byteChar = {'a', 'b', 'c'};
        String str2 = new String(byteChar);
        System.out.println(str2);
        String str3 = new String("123abc");
        System.out.println(str3);
        System.out.println("===========================================");
        //通过字符字面常量创建String类对象
        System.out.println("通过字符字面常量创建String类对象：");
        System.out.println("===========================================");
        String str4 = "字符字面常量";
        System.out.println(str4);
        System.out.println("===========================================");
    }
}

• 5.1.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

通过构造器(即，构造方法)创建String类对象：
===========================================


abc
123abc
===========================================
通过字符字面常量创建String类对象：
===========================================
字符字面常量
===========================================

5.2、String类常用方法(String Class Common Method)

• 5.2.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.string;
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
public class StringClassCommonMethod {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //定义字符串
        String str1 = "abcdef";
        String str2 = "ABCDEF";
        //返回一个字符串中指定索引位置的字符值
        System.out.println("str1.charAt(2)结果为：" + str1.charAt(2));
        //返回指定字符串在一个字符串中第一次出现的的索引位置，从前往后找
        System.out.println("\"abccba\".indexOf(\"c\")结果为："+"abccba".indexOf("c"));
        //返回指定字符串在一个字符串中最后一次出现的的索引位置，从后往前找
        System.out.println("\"abccba\".lastIndexOf(\"c\")结果为："+"abccba".lastIndexOf("c"));
        //字符串也可以比较大小，默认按照字典顺序进行比较，其结果为负数代表“小于”，其结果为正数代表“大于”，其结果为零代表“等于”
        //使用String类的compareTo方法比较2个对象的大小(区分大小写)
        System.out.println("str1.compareTo(str2)结果为：" + str1.compareTo(str2));
        //使用String类的compareToIgnoreCase方法比较2个对象的大小(不区分大小写)
        System.out.println("str1.compareToIgnoreCase(str2)结果为：" + str1.compareToIgnoreCase(str2));
        //使用String类的equals方法比较2个对象是否相等(区分大小写)
        System.out.println("str1.equals(str2)结果为：" + str1.equals(str2));
        //使用String类的equalsIgnoreCase方法比较2个对象是否相等(不区分大小写)
        System.out.println("str1.equalsIgnoreCase(str2)结果为：" + str1.equalsIgnoreCase(str2));
        //字符串拼接(将指定的字符串连接到此字符串的末尾)
        //其中指定的字符串是不变的，如果拼接字符串只能返回拼接后的字符串
        String str3 = str1.concat(str2);
        System.out.println("str1结果为："+str1+""+",str2结果为："+str2);//拼接后，str1与str2不变
        System.out.println("str1.concat(str2)结果为：" + str3);//拼接后，str3为最终返回的拼接字符串
        //判断一个字符串中是否包含指定字符串，若包含则返回“true”，否则返回“fasle”
        System.out.println("str1.contains(str2)结果为："+str1.contains(str2));
        System.out.println("str3.contains(str1)结果为："+str3.contains(str1));
        //判断一个字符串中是否以指定字符串开始，若是则返回“true”，否则返回“fasle”
        System.out.println("str3.startsWith(str1)结果为："+str3.startsWith(str1));
        System.out.println("str3.startsWith(str2)结果为："+str3.startsWith(str2));
        //判断一个字符串中是否以指定字符串结尾，若是则返回“true”，否则返回“fasle”
        System.out.println("str3.endsWith(str1)结果为："+str3.endsWith(str1));
        System.out.println("str3.endsWith(str2)结果为："+str3.endsWith(str2));
        //获取字符串的字节码形式(根据字符编码格式返回字节数组)
        byte[] byteStr=str3.getBytes();
        for (byte b : byteStr) {
            System.out.print(b+"\t");
        }
        System.out.println();
        System.out.println(Arrays.toString("中国".getBytes()));
        System.out.println(Arrays.toString("中国".getBytes("UTF-8")));
        System.out.println(Arrays.toString("中国".getBytes("GBK")));
        //判断字符串是否为空
        System.out.println("\"\".isEmpty()结果为："+"".isEmpty()+",\" \".isEmpty()结果为："+" ".isEmpty());
        //System.out.println("\"\".isBlank()结果为："+"".isBlank()+",\" \".isBlank()结果为："+" ".isBlank());//JDK11新特性，新增空格字符时也当作空
        //获取字符串的长度
        System.out.println("str1.length()结果为："+str1.length());
        /**
         * 返回一个重复多次的字符串(JDK11新特性，即，将指定字符串复制指定次数后作为返回字符串)
         * System.out.println("123".repeat(3));//输出结果为“123123123”
         */
        //字符串替换
        System.out.println("\"aAa\".replace(\"a\",\"A\")结果为："+"aAa".replace("a","A"));
        System.out.println("\"a1b2c3d4e5f\".replaceAll(\"\\\\d\",\"-\")结果为："+"a1b2c3d4e5f".replaceAll("\\d","-"));
        //字符串分割(切分)
        String[] splitStr="a-b-c".split("-");//字符串分割后，返回一个字符串数组
        System.out.println("\"a-b-c\".split(\"-\")结果为："+Arrays.toString(splitStr));
        //字符串截取
        System.out.println("abcdefg\".substring(2,3)结果为："+"abcdefg".substring(2,3));//其范围为:[beginIndex,endIndex)，不包含索引“endIndex”对应值
        System.out.println("\"abcdefg\".substring(2)结果为："+"abcdefg".substring(2));//其范围为:[beginIndex，字符串结尾索引]
        System.out.println("\"abcdefg\".substring(2,\"abcdefg\".length())结果为："+"abcdefg".substring(2,"abcdefg".length()));//等价于"abcdefg".substring(2)
        //字符串小写
        System.out.println("\"aBcD\".toLowerCase()结果为："+"aBcD".toLowerCase());
        //字符串大写
        System.out.println("\"aBcD\".toUpperCase()结果为："+"aBcD".toUpperCase());
        //字符串前后空格去除
        System.out.println("\" a b c \".trim()结果为："+ "a b c ".trim());
        //将基本类型的数据转换成字符串
        System.out.println("String.valueOf('对')结果为："+String.valueOf('对')+",String.valueOf(true)结果为："+String.valueOf(true));
    }
}

• 5.2.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

str1.charAt(2)结果为：c
"abccba".indexOf("c")结果为：2
"abccba".lastIndexOf("c")结果为：3
str1.compareTo(str2)结果为：32
str1.compareToIgnoreCase(str2)结果为：0
str1.equals(str2)结果为：false
str1.equalsIgnoreCase(str2)结果为：true
str1结果为：abcdef,str2结果为：ABCDEF
str1.concat(str2)结果为：abcdefABCDEF
str1.contains(str2)结果为：false
str3.contains(str1)结果为：true
str3.startsWith(str1)结果为：true
str3.startsWith(str2)结果为：false
str3.endsWith(str1)结果为：false
str3.endsWith(str2)结果为：true
97	98	99	100	101	102	65	66	67	68	69	70	
[-28, -72, -83, -27, -101, -67]
[-28, -72, -83, -27, -101, -67]
[-42, -48, -71, -6]
"".isEmpty()结果为：true," ".isEmpty()结果为：false
str1.length()结果为：6
"aAa".replace("a","A")结果为：AAA
"a1b2c3d4e5f".replaceAll("\\d","-")结果为：a-b-c-d-e-f
"a-b-c".split("-")结果为：[a, b, c]
abcdefg".substring(2,3)结果为：c
"abcdefg".substring(2)结果为：cdefg
"abcdefg".substring(2,"abcdefg".length())结果为：cdefg
"aBcD".toLowerCase()结果为：abcd
"aBcD".toUpperCase()结果为：ABCD
" a b c ".trim()结果为：a b c
String.valueOf('对')结果为：对,String.valueOf(true)结果为：true

5.3、String类六种内存模型分析(Analysis Of Six Memory Models Of String Class)

• 5.3.1、使用字面量创建String类对象(Use Literal Create String Class Object)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.string;
public class MemoryModelAnalysis001 {
    public static void main(String[] args) {
        /**
         *使用字面量(即，"双引号的字符串")来创建String类对象
         *若字面量存在于常量池，则无任何操作，否则在常量池中创建该字面量
         *相同字面量对应的所有String类对象内存地址是相同的
         */
        String str1="123";//str1为变量，123为字面量
        String str2="123";//str2为变量，123为字面量
        System.out.println("(str1==str2)结果为："+(str1==str2));//结果为“true”，即，对象内存地址相同
    }
}

​ 其内存分析示意图，如下图所示。

• 5.3.2、使用new关键字创建String类对象(Use New Keyword Create String Class Object)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.string;
public class MemoryModelAnalysis002 {
    public static void main(String[] args) {
        /**
         *使用new关键字来创建String类对象
         *首先在堆内存创建对象(无论堆内存是否存在相同字面量的对象)，然后判断字面量是否存在于常量池，若存在则无任何操作，否则在常量池中创建该字面量
         */
        String str1 = new String("123");
        String str2 = new String("123");
        System.out.println("(str1==str2)结果为："+(str1==str2));//结果为“false”，即，对象内存地址不同
    }
}

​ 其内存分析示意图，如下图所示。

• 5.3.3、String类常量折叠(String Class Constant Fold)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.string;
public class MemoryModelAnalysis003 {
    public static void main(String[] args) {
        /**
         *String类常量折叠(即，使用2个字面量相追加创建String类对象)
         *判断这2个字面量以及相加后的字面量在常量池中是否存在，若存在则无任何操作，否则则在常量池中创建相应的字面量
         */
        String str1=new String("123");
        String str2="1"+"23";
        System.out.println("(str1==str2)结果为："+(str1==str2));//结果为“false”，即，对象内存地址不同
    }
}

​ 其内存分析示意图，如下图所示。

• 5.3.4、使用2个new关键字相追加创建String类对象(Use Two New Keywords To Append Create String Class Object)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.string;
public class MemoryModelAnalysis004 {
    public static void main(String[] args) {
        /**
         *使用2个new关键字相追加创建String类对象
         *首先会在堆内存创建这2个对象以及相加后的对象，然后判断这2个对象的字面量在常量池中是否存在，若存在则无任何操作，否则则在常量池中创建相应的字面量
         */
        String str1=new String("1")+new String("23");
        String str2="123";
        System.out.println("(str1==str2)结果为："+(str1==str2));//结果为“false”，即，对象内存地址不同
    }
}

​ 其内存分析示意图，如下图所示。

• 5.3.5、使用字面常量追加new关键字创建String类对象(Use Literal Constant To Append New Keyword To Create String Class Object)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.string;
public class MemoryModelAnalysis005 {
    public static void main(String[] args) {
        /**
         *使用字面量(即，"双引号的字符串")追加new关键字创建String类对象
         *首先会在堆内存创建这2个对象(1个是new关键字创建的对象，另1个是相加后的对象)，然后判断字面量与new关键字创建的对象的字面量在常量池中是否存在，若存在则无任何操作，否则则在常量池中创建相应的字面量
         */
        String str1="1"+new String("23");
        String str2="123";
        System.out.println("(str1==str2)结果为："+(str1==str2));//结果为“false”，即，对象内存地址不同
    }
}

​ 其内存分析示意图，如下图所示。

• 5.3.6、使用字面常量追加字符串变量创建String类对象(Use Literal Constant To Append String Variable To Create String Class Object)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.string;
public class MemoryModelAnalysis006 {
    public static void main(String[] args) {
        /**
         *使用字面量(即，"双引号的字符串")追加字符串变量创建String类对象
         *首先会在堆内存创建1个字面量与字符串变量相加后的对象(不会进入常量池)，然后判断字面量在常量池中是否存在，若存在则无任何操作，否则则在常量池中创建相应的字面量
         */
        String str1="3";
        String str2="12"+str1;
        String str3="123";
        System.out.println("(str2==str3)结果为："+(str2==str3));//结果为“false”，即，对象内存地址不同
    }
}

​ 其内存分析示意图，如下图所示。

5.4、String类intern方法(String Class Intern Method)

• 5.4.1、示例代码一(Sample Code One)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.string;
public class InternMethod001 {
    public static void main(String[] args) {
        /**
         *使用字面量(即，"双引号的字符串")来创建String类对象str1
         *若对象str1字面量"123"存在于常量池，则直接返回地址，否则在常量池中创建对象str1字面量"123"，并返回此地址
         *str1指向常量池地址0xm1，str1.intern()指向常量池地址0xm1
         */
        String str1="123";//str1为变量，123为字面量
        System.out.println("(str1==str1.intern())结果为："+(str1==str1.intern()));
    }
}

​ 其内存分析示意图，如下图所示。

• 5.4.2、示例代码二(Sample Code Two)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.string;
public class InternMethod002 {
    public static void main(String[] args) {
        /**
         *使用new关键字来创建String类对象str1
         *首先在堆内存创建对象str1(无论堆内存是否存在相同字面量的对象)，然后判断字面量"123"是否存在于常量池，若存在则直接返回地址，否则在常量池中创建字面量"123"，并返回此地址
         *使用str1.intern()方法时，判断对象str1字面量"123"是否存在于常量池，若存在则直接返回地址，否则在常量池中存放"堆内存中字面量"123"对象str1的引用"，并返回此地址
         *str1指向堆内存地址0xh1，str1.intern()指向常量池地址0xm1
         */
        String str1 = new String("123");
        System.out.println("(str1==str1.intern())结果为："+(str1==str1.intern()));
    }
}

​ 其内存分析示意图，如下图所示。

• 5.4.3、示例代码三(Sample Code Three)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.string;
public class InternMethod003 {
    public static void main(String[] args) {
        /**
         *先用new关键字来创建String类对象str1，再用字面量来创建String类对象str2
         *第1步，首先在堆内存创建对象str1(无论堆内存是否存在相同字面量的对象)，然后判断字面量"123"是否存在于常量池，若存在则直接返回地址，否则在常量池中创建字面量"123"，并返回此地址
         *第2步，判断对象str2字面量"123"是否存在于常量池，若存在则直接返回地址，否则在常量池中创建对象str2字面量"123"，并返回此地址
         *使用str1.intern()方法时，判断对象str1字面量"123"是否存在于常量池，若存在则直接返回地址，否则在常量池中存放"堆内存中字面量"123"对象str1的引用"，并返回此地址
         *str1指向堆内存地址0xh1，str1.intern()指向常量池地址0xm1，str2指向常量池地址0xm1
         */
        String str1 = new String("123");
        String str2="123";
        System.out.println("(str1==str2)结果为："+(str1==str2));
        System.out.println("(str1==str1.intern())结果为："+(str1==str1.intern()));
        System.out.println("(str1.intern()==str2)结果为："+(str1.intern()==str2));
    }
}

​ 其内存分析示意图，如下图所示。

• 5.4.4、示例代码四(Sample Code Four)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.string;
public class InternMethod004 {
    public static void main(String[] args) {
        /**
         *使用2个new关键字相追加创建String类对象str1
         *首先在堆内存创建3个对象[字面量"1"的对象、字面量"2"的对象、str1对象](无论堆内存是否存在相同字面量的对象)，
         *然后判断字面量"1"或"2"是否存在于常量池，若存在则直接返回地址，否则在常量池中创建字面量"1"或"2"，并返回此地址
         *使用str1.intern()方法时，判断对象str1字面量"123"是否存在于常量池，若存在则直接返回地址，否则在常量池中存放"堆内存中字面量"123"对象str1的引用"，并返回此地址
         *str1指向堆内存地址0xh3，str1.intern()指向堆内存地址0xh3
         */
        String str1 = new String("1")+new String("23");
        System.out.println("(str1==str1.intern())结果为："+(str1==str1.intern()));
    }
}

​ 其内存分析示意图，如下图所示。

• 5.4.5、示例代码五(Sample Code Five)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.string;
public class InternMethod005 {
    public static void main(String[] args) {
        /**
         *先用字面量来创建String类对象str1，接着用2个new关键字相追加来创建String类对象str2，再用字面量来创建String类对象str3
         *第1步，判断字对象str1字面量"123"是否存在于常量池，若存在则直接返回地址，否则在常量池中创建对象str1字面量"123"，并返回此地址
         *第2步，首先在堆内存创建3个对象[字面量"1"的对象、字面量"2"的对象、str2对象](无论堆内存是否存在相同字面量的对象)，
         *然后判断字面量"1"或"2"是否存在于常量池，若存在则直接返回地址，否则在常量池中创建字面量"1"或"2"，并返回此地址
         *第3步，判断对象str3字面量"123"是否存在于常量池，若存在则直接返回地址，否则在常量池中创建对象str3字面量"123"，并返回此地址
         *使用str2.intern()方法时，判断对象str2字面量"123"是否存在于常量池，若存在则直接返回地址，否则在常量池中存放"堆内存中字面量"123"对象str2的引用"，并返回此地址
         *str1指向常量池地址0xm1，str2指向堆内存地址0xh3，str2.intern()指向常量池地址0xm1，str3指向常量池地址0xm1
         */
        String str1="123";
        String str2 = new String("1")+new String("23");
        String str3="123";
        System.out.println("(str1==str2)结果为："+(str1==str2));
        System.out.println("(str1==str2.intern())结果为："+(str1==str2.intern()));
        System.out.println("(str2==str2.intern())结果为："+(str2==str2.intern()));
        System.out.println("(str1==str3)结果为："+(str1==str3));
        System.out.println("(str2==str3)结果为："+(str2==str3));
        System.out.println("(str2.intern()==str3)结果为："+(str2.intern()==str3));
    }
}

​ 其内存分析示意图，如下图所示。

• 5.4.6、示例代码六(Sample Code Six)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.string;
public class InternMethod006 {
    public static void main(String[] args) {
        /**
         *先用2个new关键字相追加来创建String类对象str1，再用字面量来创建String类对象str2
         *第1步，首先在堆内存创建3个对象[字面量"1"的对象、字面量"2"的对象、str1对象](无论堆内存是否存在相同字面量的对象)，
         *然后判断字面量"1"或"2"是否存在于常量池，若存在则直接返回地址，否则在常量池中创建字面量"1"或"2"，并返回此地址
         *第2步，使用str1.intern()方法时，判断对象str1字面量"123"是否存在于常量池，若存在则直接返回地址，否则在常量池中存放"堆内存中字面量"123"对象str1的引用"，并返回此地址
         *第3步，判断对象str2字面量"123"是否存在于常量池，若存在则直接返回地址，否则在常量池中创建对象str2字面量"123"，并返回此地址
         *str1指向堆内存地址0xh3，str1.intern()指向堆内存地址0xh3，str2指向堆内存地址0xh3
         */
        String str1 = new String("1")+new String("23");
        str1.intern();
        String str2="123";
        System.out.println("(str1==str2)结果为："+(str1==str2));
        System.out.println("(str1.intern()==str2)结果为："+(str1.intern()==str2));
    }
}

​ 其内存分析示意图，如下图所示。

5.5、String类核心源码分析(Core Source Code Analysis Of String Class)

​ 其核心源码分析，如以下信息所示。

/**
 *public final class String implements CharSequence
 *没有子类，没有多态和重写，本身方法不会被多态，且实现了CharSequence接口。
 */
/**
 *The value is used for character storage
 *private final char value[];
 *字符串底层代码还是一个字符数组，字符串中的字符会存到数组(value)。
 *value是一个成员变量，只能在代码块或者构造器进行初始化，且只能初始化一次。
 */
/**
 *Cache the hash code for the string
 *private int hash; // Default to 0
 *因为字符串是不可变的，所以对应hash码值也是不变的，hash码值默认为零
 */
/**
 *public String() {
 *    this.value = "".value;
 *}
 *默认情况下，当使用“String str=new String();”创建字符串时会创建一个空字符串("")，
 *而此时使用“str="123";”则会创建一个新的字符串("123")。
 */

5.6、StringBuffer类与StringBuilder类常用方法(Common Methods Of StringBuffer Class And StringBuilder Class)

• 5.6.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.string;
/**
 *String类：不可变字符序列
 *StringBuffer类：可变字符序列，速度慢，多线程安全
 *StringBuilder类：可变字符序列，速度快，多线程不安全
 *一般多数使用String类，在多字符串拼接时建议使用StringBuilder类，而多线程时建议使用StringBuffer类
 */
public class StringBufferAndStringBuilder {
    public static void main(String[] args) {
        //StringBuffer构造方法
        StringBuffer stringBuffer1=new StringBuffer();
        StringBuffer stringBuffer2=new StringBuffer("123");
        System.out.println("stringBuffer1.toString()结果为："+stringBuffer1.toString());
        System.out.println("stringBuffer2.toString()结果为："+stringBuffer2.toString());
        //StringBuffer类append方法：添加字符序列
        System.out.println("stringBuffer1.append(\"456\").toString()结果为："+stringBuffer1.append("456").toString());
        System.out.println("stringBuffer2.append(\"456\").toString()结果为："+stringBuffer2.append("456").toString());
        //StringBuffer类delete方法：删除指定区间段"[开始位置,结束位置)"的字符序列
        System.out.println("stringBuffer1.delete(0,1).toString()结果为："+stringBuffer1.delete(0,1).toString());
        System.out.println("stringBuffer2.delete(0,1).toString()结果为："+stringBuffer2.delete(0,1).toString());
        //StringBuffer类deleteCharAt方法：移出指定位置上的字符序列
        System.out.println("stringBuffer1.deleteCharAt(0).toString()结果为："+stringBuffer1.deleteCharAt(0).toString());
        System.out.println("stringBuffer2.deleteCharAt(0).toString()结果为："+stringBuffer2.deleteCharAt(0).toString());
        //StringBuffer类insert方法：在指定位置上插入字符序列
        System.out.println("stringBuffer1.insert(0,1).toString()结果为："+stringBuffer1.insert(0,1).toString());
        System.out.println("stringBuffer2.insert(0,1).toString()结果为："+stringBuffer2.insert(0,1).toString());
        //StringBuffer类setCharAt方法：在指定位置上设置字符序列
        stringBuffer1.setCharAt(0,'2');
        stringBuffer2.setCharAt(0,'2');
        //StringBuffer类toString方法：将字符序列转换为字符串形式
        System.out.println("stringBuffer1.toString()结果为："+stringBuffer1.toString());
        System.out.println("stringBuffer2.toString()结果为："+stringBuffer2.toString());
        //StringBuffer类reverse方法：逆序字符序列
        System.out.println("stringBuffer1.reverse().toString()结果为："+stringBuffer1.reverse().toString());
        System.out.println("stringBuffer2.reverse().toString()结果为："+stringBuffer2.reverse().toString());
        //StringBuilder构造方法
        StringBuilder stringBuilder1=new StringBuilder();
        StringBuilder stringBuilder2=new StringBuilder("987");
        System.out.println("stringBuilder1.toString()结果为："+stringBuilder1.toString());
        System.out.println("stringBuilder2.toString()结果为："+stringBuilder2.toString());
        //StringBuilder类append方法：添加字符序列
        System.out.println("stringBuilder1.append(\"654\").toString()结果为："+stringBuilder1.append("654").toString());
        System.out.println("stringBuilder2.append(\"654\").toString()结果为："+stringBuilder2.append("654").toString());
        //StringBuilder类delete方法：删除指定区间段"[开始位置,结束位置)"的字符序列
        System.out.println("stringBuilder1.delete(0,1).toString()结果为："+stringBuilder1.delete(0,1).toString());
        System.out.println("stringBuilder2.delete(0,1).toString()结果为："+stringBuilder2.delete(0,1).toString());
        //StringBuilder类deleteCharAt方法：移出指定位置上的字符序列
        System.out.println("stringBuilder1.deleteCharAt(0).toString()结果为："+stringBuilder1.deleteCharAt(0).toString());
        System.out.println("stringBuilder2.deleteCharAt(0).toString()结果为："+stringBuilder2.deleteCharAt(0).toString());
        //StringBuilder类insert方法：在指定位置上插入字符序列
        System.out.println("stringBuilder1.insert(0,1).toString()结果为："+stringBuilder1.insert(0,1).toString());
        System.out.println("stringBuilder2.insert(0,1).toString()结果为："+stringBuilder2.insert(0,1).toString());
        //StringBuilder类setCharAt方法：在指定位置上设置字符序列
        stringBuilder1.setCharAt(0,'2');
        stringBuilder2.setCharAt(0,'2');
        //StringBuilder类toString方法：将字符序列转换为字符串形式
        System.out.println("stringBuilder1.toString()结果为："+stringBuilder1.toString());
        System.out.println("stringBuilder2.toString()结果为："+stringBuilder2.toString());
        //StringBuilder类reverse方法：逆序字符序列
        System.out.println("stringBuilder1.reverse().toString()结果为："+stringBuilder1.reverse().toString());
        System.out.println("stringBuilder2.reverse().toString()结果为："+stringBuilder2.reverse().toString());
    }
}

• 5.6.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

stringBuffer1.toString()结果为：
stringBuffer2.toString()结果为：123
stringBuffer1.append("456").toString()结果为：456
stringBuffer2.append("456").toString()结果为：123456
stringBuffer1.delete(0,1).toString()结果为：56
stringBuffer2.delete(0,1).toString()结果为：23456
stringBuffer1.deleteCharAt(0).toString()结果为：6
stringBuffer2.deleteCharAt(0).toString()结果为：3456
stringBuffer1.insert(0,1).toString()结果为：16
stringBuffer2.insert(0,1).toString()结果为：13456
stringBuffer1.toString()结果为：26
stringBuffer2.toString()结果为：23456
stringBuffer1.reverse().toString()结果为：62
stringBuffer2.reverse().toString()结果为：65432
stringBuilder1.toString()结果为：
stringBuilder2.toString()结果为：987
stringBuilder1.append("654").toString()结果为：654
stringBuilder2.append("654").toString()结果为：987654
stringBuilder1.delete(0,1).toString()结果为：54
stringBuilder2.delete(0,1).toString()结果为：87654
stringBuilder1.deleteCharAt(0).toString()结果为：4
stringBuilder2.deleteCharAt(0).toString()结果为：7654
stringBuilder1.insert(0,1).toString()结果为：14
stringBuilder2.insert(0,1).toString()结果为：17654
stringBuilder1.toString()结果为：24
stringBuilder2.toString()结果为：27654
stringBuilder1.reverse().toString()结果为：42
stringBuilder2.reverse().toString()结果为：45672

5.7、基于字符串的数据加密与解密练习(Exercise Of Data Encryption And Decryption Base On String)

• 5.7.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.string;
import java.nio.charset.StandardCharsets;
/**
 * 密码学：大写字母(ABCDEFGHIJKLMNOPQRSTUVWXYZ)、小写字母(abcdefghijklmnopqrstuvwxyz)
 * 静态加密与解密字符串(加密或解密原则：字母+加密或解密基数，字母以外字符不变，若“字母+加密或解密基数”大于最大字母位置值时，则继续从最小字母位置值开始往后计算，若“字母+加密或解密基数”小于最小字母位置值时，则继续从最大字母位置值开始往前计算)
 * 动态加密与解密字符串(加密或解密原则：字母+字母位置值，字母以外字符不变，若“字母+字母位置值”大于最大字母位置值时，则继续从最小字母位置值开始往后计算，若“字母-字母位置值”小于最小字母位置值时，则继续从最大字母位置值开始往前计算)
 */
public class StringEncryptionAndDecryption {
    private static final byte lowercaseLetterMin = "a".getBytes()[0];
    private static final byte lowercaseLetterMax = "z".getBytes()[0];
    private static final byte uppercaseLetterMin = "A".getBytes()[0];
    private static final byte uppercaseLetterMax = "Z".getBytes()[0];
    private static byte[] byteArray = "".getBytes();
    private static byte byteBase;
    public static void main(String[] args) {
        String str = "1Aa2Bb3Cc4Dd5Ee6Ff7Gg8Hh9Ii10Jj11Kk12Ll13Mm14Nn15Oo16Pp17Qq18Rr19Ss20Tt21Uu22Vv23Ww24Xx25Yy26Zz";//字符串
        //静态加密与解密字符串
        byte baseStaticEncryption1 = 1;//静态加密基数
        String stringStaticEncryption1 = staticEncryptionOrDecryptionString(str, baseStaticEncryption1);//静态加密字符串
        System.out.println("字符串(" + str + ")按基数(" + baseStaticEncryption1 + ")静态加密后结果：");
        System.out.println(stringStaticEncryption1);
        byte baseStaticEncryption2 = (byte) (-1 * baseStaticEncryption1);//静态解密基数
        String stringStaticEncryption2 = staticEncryptionOrDecryptionString(stringStaticEncryption1, baseStaticEncryption2);//静态解密字符串
        System.out.println("字符串(" + stringStaticEncryption1 + ")按基数(" + baseStaticEncryption2 + ")静态解密后结果：");
        System.out.println(stringStaticEncryption2);
        byte baseStaticEncryption3 = 27;//静态加密基数
        String stringStaticEncryption3 = staticEncryptionOrDecryptionString(str, baseStaticEncryption3);//静态加密字符串
        System.out.println("字符串(" + str + ")按基数(" + baseStaticEncryption3 + ")静态加密后结果：");
        System.out.println(stringStaticEncryption3);
        byte baseStaticEncryption4 = (byte) (-1 * baseStaticEncryption3);//静态解密基数
        String stringStaticEncryption4 = staticEncryptionOrDecryptionString(stringStaticEncryption3, baseStaticEncryption4);//静态解密字符串
        System.out.println("字符串(" + stringStaticEncryption3 + ")按基数(" + baseStaticEncryption4 + ")静态解密后结果：");
        System.out.println(stringStaticEncryption4);
        //动态加密与解密字符串
        String stringDynamicEncryption1 = dynamicEncryptionOrDecryptionString(str, true);//动态加密字符串
        System.out.println("字符串(" + str + ")动态加密后结果：");
        System.out.println(stringDynamicEncryption1);
        String stringDynamicEncryption2 = dynamicEncryptionOrDecryptionString(stringDynamicEncryption1, false);//动态解密字符串
        System.out.println("字符串(" + stringDynamicEncryption1 + ")动态解密后结果：");
        System.out.println(stringDynamicEncryption2);
    }
    public static String staticEncryptionOrDecryptionString(String str, byte base) {
        /**
         *静态加密或解密字符串
         *加密或解密原则：字母+加密或解密基数(base)，字母以外字符不变，若“字母+加密或解密基数(base)”大于最大字母位置值时，则继续从最小字母位置值开始往后计算，若“字母+加密或解密基数(base)”小于最小字母位置值时，则继续从最大字母位置值开始往前计算
         */
        byteArray = str.getBytes();
        byteBase = (byte) (base % (lowercaseLetterMax - lowercaseLetterMin + 1));
        /**
         System.out.println("字符串(" + str + ")静态加密或解密前对应的字节码：");
         for (byte b : byteArray) {
         System.out.print(b + "\t");
         }
         System.out.println();
         */
        for (int i = 0; i < byteArray.length; i++) {
            if ((byteArray[i] >= lowercaseLetterMin) && (byteArray[i] <= lowercaseLetterMax)) {
                //小写字母(a-z)字节码：(97)-(97+26-1)
                if (byteArray[i] + byteBase < lowercaseLetterMin) {
                    byteArray[i] = (byte) (lowercaseLetterMax - (lowercaseLetterMin - (byteArray[i] + byteBase)) + 1);
                } else if (byteArray[i] + byteBase <= lowercaseLetterMax) {
                    byteArray[i] += byteBase;
                } else {
                    byteArray[i] = (byte) (lowercaseLetterMin + (byteArray[i] + byteBase - lowercaseLetterMax) - 1);
                }
            } else if ((byteArray[i] >= uppercaseLetterMin) && (byteArray[i] <= uppercaseLetterMax)) {
                //小写字母(A-Z)字节码：(65)-(65+26-1)
                if (byteArray[i] + byteBase < uppercaseLetterMin) {
                    byteArray[i] = (byte) (uppercaseLetterMax - (uppercaseLetterMin - (byteArray[i] + byteBase)) + 1);
                } else if (byteArray[i] + byteBase <= uppercaseLetterMax) {
                    byteArray[i] += byteBase;
                } else {
                    byteArray[i] = (byte) (uppercaseLetterMin + (byteArray[i] + byteBase - uppercaseLetterMax) - 1);
                }
            } else {
                //小写与小写字母以外的字符
            }
        }
        /**
         System.out.println("字符串(" + str + ")静态加密或解密后对应的字节码：");
         for (byte b : byteArray) {
         System.out.print(b + "\t");
         }
         System.out.println();
         String strStaticEncryptionOrDecryption=new String(byteArray);
         System.out.println("字符串(" + str + ")静态加密或解密后对应的字符串："+strStaticEncryptionOrDecryption);
         */
        return new String(byteArray);
    }
    public static String dynamicEncryptionOrDecryptionString(String str, boolean isEncryption) {
        /**
         *动态加密或解密字符串
         *加密或解密原则：字母+字母位置值，字母以外字符不变，若“字母+字母位置值”大于最大字母位置值时，则继续从最小字母位置值开始往后计算，若“字母-字母位置值”小于最小字母位置值时，则继续从最大字母位置值开始往前计算
         */
        byteArray = str.getBytes();
        /**
         System.out.println("字符串(" + str + ")动态加密或解密前对应的字节码：");
         for (byte b : byteArray) {
         System.out.print(b + "\t");
         }
         System.out.println();
         */
        for (int i = 0; i < byteArray.length; i++) {
            if (isEncryption) {
                byteBase = (byte) ((i + 1) % (lowercaseLetterMax - lowercaseLetterMin + 1));//动态加密
            } else {
                byteBase = (byte) ((-1 * (i + 1)) % (lowercaseLetterMax - lowercaseLetterMin + 1));//动态解密
            }
            if ((byteArray[i] >= lowercaseLetterMin) && (byteArray[i] <= lowercaseLetterMax)) {
                //小写字母(a-z)字节码：(97)-(97+26-1)
                if (byteArray[i] + byteBase < lowercaseLetterMin) {
                    byteArray[i] = (byte) (lowercaseLetterMax - (lowercaseLetterMin - (byteArray[i] + byteBase)) + 1);
                } else if (byteArray[i] + byteBase <= lowercaseLetterMax) {
                    byteArray[i] += byteBase;
                } else {
                    byteArray[i] = (byte) (lowercaseLetterMin + (byteArray[i] + byteBase - lowercaseLetterMax) - 1);
                }
            } else if ((byteArray[i] >= uppercaseLetterMin) && (byteArray[i] <= uppercaseLetterMax)) {
                //小写字母(A-Z)字节码：(65)-(65+26-1)
                if (byteArray[i] + byteBase < uppercaseLetterMin) {
                    byteArray[i] = (byte) (uppercaseLetterMax - (uppercaseLetterMin - (byteArray[i] + byteBase)) + 1);
                } else if (byteArray[i] + byteBase <= uppercaseLetterMax) {
                    byteArray[i] += byteBase;
                } else {
                    byteArray[i] = (byte) (uppercaseLetterMin + (byteArray[i] + byteBase - uppercaseLetterMax) - 1);
                }
            } else {
                //小写与小写字母以外的字符
            }
        }
        /**
         System.out.println("字符串(" + str + ")动态加密或解密后对应的字节码：");
         for (byte b : byteArray) {
         System.out.print(b + "\t");
         }
         System.out.println();
         String strDynamicEncryptionOrDecryption=new String(byteArray);
         System.out.println("字符串(" + str + ")动态加密或解密后对应的字符串："+strDynamicEncryptionOrDecryption);
         */
        return new String(byteArray);
    }
}

• 5.7.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

字符串(1Aa2Bb3Cc4Dd5Ee6Ff7Gg8Hh9Ii10Jj11Kk12Ll13Mm14Nn15Oo16Pp17Qq18Rr19Ss20Tt21Uu22Vv23Ww24Xx25Yy26Zz)按基数(1)静态加密后结果：
1Bb2Cc3Dd4Ee5Ff6Gg7Hh8Ii9Jj10Kk11Ll12Mm13Nn14Oo15Pp16Qq17Rr18Ss19Tt20Uu21Vv22Ww23Xx24Yy25Zz26Aa
字符串(1Bb2Cc3Dd4Ee5Ff6Gg7Hh8Ii9Jj10Kk11Ll12Mm13Nn14Oo15Pp16Qq17Rr18Ss19Tt20Uu21Vv22Ww23Xx24Yy25Zz26Aa)按基数(-1)静态解密后结果：
1Aa2Bb3Cc4Dd5Ee6Ff7Gg8Hh9Ii10Jj11Kk12Ll13Mm14Nn15Oo16Pp17Qq18Rr19Ss20Tt21Uu22Vv23Ww24Xx25Yy26Zz
字符串(1Aa2Bb3Cc4Dd5Ee6Ff7Gg8Hh9Ii10Jj11Kk12Ll13Mm14Nn15Oo16Pp17Qq18Rr19Ss20Tt21Uu22Vv23Ww24Xx25Yy26Zz)按基数(27)静态加密后结果：
1Bb2Cc3Dd4Ee5Ff6Gg7Hh8Ii9Jj10Kk11Ll12Mm13Nn14Oo15Pp16Qq17Rr18Ss19Tt20Uu21Vv22Ww23Xx24Yy25Zz26Aa
字符串(1Bb2Cc3Dd4Ee5Ff6Gg7Hh8Ii9Jj10Kk11Ll12Mm13Nn14Oo15Pp16Qq17Rr18Ss19Tt20Uu21Vv22Ww23Xx24Yy25Zz26Aa)按基数(-27)静态解密后结果：
1Aa2Bb3Cc4Dd5Ee6Ff7Gg8Hh9Ii10Jj11Kk12Ll13Mm14Nn15Oo16Pp17Qq18Rr19Ss20Tt21Uu22Vv23Ww24Xx25Yy26Zz
字符串(1Aa2Bb3Cc4Dd5Ee6Ff7Gg8Hh9Ii10Jj11Kk12Ll13Mm14Nn15Oo16Pp17Qq18Rr19Ss20Tt21Uu22Vv23Ww24Xx25Yy26Zz)动态加密后结果：
1Cd2Gh3Kl4Op5St6Wx7Ab8Ef9Ij10No11St12Xy13Cd14Hi15Mn16Rs17Wx18Bc19Gh20Lm21Qr22Vw23Ab24Fg25Kl26Pq
字符串(1Cd2Gh3Kl4Op5St6Wx7Ab8Ef9Ij10No11St12Xy13Cd14Hi15Mn16Rs17Wx18Bc19Gh20Lm21Qr22Vw23Ab24Fg25Kl26Pq)动态解密后结果：
1Aa2Bb3Cc4Dd5Ee6Ff7Gg8Hh9Ii10Jj11Kk12Ll13Mm14Nn15Oo16Pp17Qq18Rr19Ss20Tt21Uu22Vv23Ww24Xx25Yy26Zz

5.8、注意事项(Matters Needing Attention)

• 5.8.1、字符串也可以比较大小，默认按照字典顺序进行比较，其结果为负数代表“小于”，其结果为正数代表“大于”，其结果为零代表“等于”。
• 5.8.2、字符串拼接时，其中指定的字符串是不变的，如果拼接字符串只能返回拼接后的字符串。
• 5.8.3、类对象为空(即，null)时，容易引发“空指针异常”。
• 5.8.4、使用字面量创建String类对象时，判断字面量是否存在于常量池，若存在则无任何操作，否则在常量池中创建字面量，且相同字面量对应的所有String类对象内存地址是相同的。
• 5.8.5、使用new关键字创建String类对象时，首先在堆内存创建new关键字对象(无论堆内存是否存在相同字面量的对象)，然后判断new关键字对象字面量是否存在于常量池，若存在则无任何操作，否则在常量池中创建new关键字对象字面量。
• 5.8.6、使用字面量拼接(即，字面量折叠或常量折叠)创建String类对象时，判断拼接后的字面量是否存在于常量池，若存在则无任何操作，否则在常量池中创建拼接后的字面量。
• 5.8.7、使用new关键字拼接创建String类对象时，首先在堆内存创建各个new关键字对象与拼接后的对象(无论堆内存是否存在相同字面量的对象)，然后判断各个new关键字对象字面量是否存在于常量池，若存在则无任何操作，否则在常量池中创建各个new关键字对象。
• 5.8.8、使用字面量拼接new关键字创建String类对象时，首先判断字面量是否存在于常量池，若存在则无任何操作，否则在常量池中创建字面量，接着在堆内存创建new关键字对象与拼接后的对象(无论堆内存是否存在相同字面量的对象)，然后判断new关键字对象字面量是否存在于常量池，若存在则无任何操作，否则在常量池中创建new关键字对象。
• 5.8.9、使用字面量拼接变量创建String类对象时，首先判断变量是否存在于常量池，若存在则无任何操作，否则在常量池中创建变量，接着判断字面量是否存在于常量池，若存在则无任何操作，否则在常量池中创建字面量，再接着在堆内存创建拼接后的对象(无论堆内存是否存在相同字面量的对象)。
• 5.8.10、使用String类intern方法时，将字面量(即，字符串)存放到常量池中。1、若字面量存在于常量池，则直接返回当前地址；2、若字面量不存在于常量池且字面量不存在于堆内存，则在常量池中创建字面量，并返回当前地址；3、若字面量存在于堆内存且字面量不存在于常量池，则在常量池中创建一个堆内存中存放字面量对象的引用地址，并返回当前地址；4、若字面量存在于堆内存且字面量存在于常量池，则直接返回常量池当前地址。
• 5.8.11、String类为"不可变字符序列"，StringBuffer类为"可变字符序列，线程安全，但是效率低"，StringBuffer类为"可变字符序列，线程不安全，但是效率高"。

6、数学类(Math Class)

• 6.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.math;
public class CommonMethod {
    public static void main(String[] args) {
        //最大值
        System.out.println("Math.max(1.23210,1.23211)结果为："+Math.max(1.23210,1.23211));
        //最小值
        System.out.println("Math.min(1.23210,1.23211)结果为："+Math.min(1.23210,1.23211));
        //随机数
        System.out.println("Math.random()结果为："+Math.random());
        //绝对值：幂等
        System.out.println("Math.abs(-1.0)结果为："+Math.abs(-1.0));
        System.out.println("ath.abs(Math.abs(-1.0))结果为："+Math.abs(Math.abs(-1.0)));
        //四舍五入
        System.out.println("Math.round(1.499)结果为："+Math.round(1.499));
        System.out.println("Math.round(-1.499)结果为："+Math.round(-1.499));
        System.out.println("Math.round(2.500)结果为："+Math.round(2.500));
        System.out.println("Math.round(-2.500)结果为："+Math.round(-2.500));
        //向上取整
        System.out.println("Math.ceil(1.23)结果为："+Math.ceil(1.23));
        System.out.println("Math.ceil(-1.23)结果为："+Math.ceil(-1.23));
        //向下取整
        System.out.println("Math.floor(1.23)结果为："+Math.floor(1.23));
        System.out.println("Math.floor(-1.23)结果为："+Math.floor(-1.23));
        //次幂(乘方)
        System.out.println("Math.pow(10,1)结果为："+Math.pow(10,1));
        System.out.println("Math.pow(10,0)结果为："+Math.pow(10,0));
        System.out.println("Math.pow(10,-1)结果为："+Math.pow(10,-1));
        //正平方根
        System.out.println("Math.sqrt(9)结果为："+Math.sqrt(9));
        //log对数
        System.out.println("Math.log(10)结果为："+Math.log(10));
        System.out.println("Math.log10(10)结果为："+Math.log10(10));
        System.out.println("Math.log1p(10)结果为："+Math.log1p(10));
        //三角函数
        System.out.println("Math.sin(60)结果为："+Math.sin(60));//正弦
        System.out.println("Math.cos(60)结果为："+Math.cos(60));//余弦
        System.out.println("Math.tan(60)结果为："+Math.tan(60));//正切
        System.out.println("Math.atan(60)结果为："+Math.atan(60));//反正切
    }
}

• 6.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

Math.max(1.23210,1.23211)结果为：1.23211
Math.min(1.23210,1.23211)结果为：1.2321
Math.random()结果为：0.16841005134196396
Math.abs(-1.0)结果为：1.0
ath.abs(Math.abs(-1.0))结果为：1.0
Math.round(1.499)结果为：1
Math.round(-1.499)结果为：-1
Math.round(2.500)结果为：3
Math.round(-2.500)结果为：-2
Math.ceil(1.23)结果为：2.0
Math.ceil(-1.23)结果为：-1.0
Math.floor(1.23)结果为：1.0
Math.floor(-1.23)结果为：-2.0
Math.pow(10,1)结果为：10.0
Math.pow(10,0)结果为：1.0
Math.pow(10,-1)结果为：0.1
Math.sqrt(9)结果为：3.0
Math.log(10)结果为：2.302585092994046
Math.log10(10)结果为：1.0
Math.log1p(10)结果为：2.3978952727983707
Math.sin(60)结果为：-0.3048106211022167
Math.cos(60)结果为：-0.9524129804151563
Math.tan(60)结果为：0.320040389379563
Math.atan(60)结果为：1.554131203080956

7、文件类(File Class)

​ File类是“文件和目录路径名的抽象表示形式”。

7.1、File类常用方法(File Class Common Method)

• 7.1.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.file;
import java.io.File;
public class CommonMethod {
    public static void main(String[] args) {
        //创建File类对象
        File file=new File("D:\\Program Files");
        System.out.println("file结果为："+file);
        //是否可以读取文件
        System.out.println("file.canRead()结果为："+file.canRead());
        //是否可以写入文件
        System.out.println("file.canWrite()结果为："+file.canWrite());
        //是否可以执行文件
        System.out.println("file.canExecute()结果为："+file.canExecute());
        //文件是否存在
        System.out.println("file.exists()结果为："+file.exists());
        //获取文件路径
        System.out.println("file.getPath()结果为："+file.getPath());
        //获取绝对文件
        System.out.println("file.getAbsoluteFile()结果为："+file.getAbsoluteFile());
        //获取文件绝对路径
        System.out.println("file.getAbsolutePath()结果为："+file.getAbsolutePath());
        //获取文件的父文件
        System.out.println("file.getParentFile()结果为："+file.getParentFile());
        //获取文件的父路径
        System.out.println("file.getParent()结果为："+file.getParent());
        //获取文件对应的磁盘总空间
        System.out.println("file.getTotalSpace()结果为："+file.getTotalSpace()+"字节(B)");
        System.out.println("(file.getTotalSpace()*1.0/1024/1024/1024)结果为："+(file.getTotalSpace()*1.0/1024/1024/1024)+"千兆字节(GB)");
        //获取文件对应的磁盘空闲空间
        System.out.println("file.getFreeSpace()结果为："+file.getFreeSpace()+"字节(B)");
        System.out.println("(file.getFreeSpace()*1.0/1024/1024/1024)结果为："+(file.getFreeSpace()*1.0/1024/1024/1024)+"千兆字节(GB)");
        //获取文件对应的磁盘可用空间
        System.out.println("file.getUsableSpace()结果为："+file.getUsableSpace()+"字节(B)");
        System.out.println("(file.getUsableSpace()*1.0/1024/1024/1024)结果为："+(file.getUsableSpace()*1.0/1024/1024/1024)+"千兆字节(GB)");
        //获取文件对应的磁盘已使用空间
        System.out.println("(file.getTotalSpace()*1.0-file.getUsableSpace()*1.0)结果为："+(file.getTotalSpace()*1.0-file.getUsableSpace()*1.0)+"字节(B)");
        System.out.println("((file.getTotalSpace()*1.0-file.getUsableSpace()*1.0)/1024/1024/1024)结果为："+((file.getTotalSpace()*1.0-file.getUsableSpace()*1.0)/1024/1024/1024)+"千兆字节(GB)");
    }
}

• 7.1.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

file结果为：D:\Program Files
file.canRead()结果为：true
file.canWrite()结果为：true
file.canExecute()结果为：true
file.exists()结果为：true
file.getPath()结果为：D:\Program Files
file.getAbsoluteFile()结果为：D:\Program Files
file.getAbsolutePath()结果为：D:\Program Files
file.getParentFile()结果为：D:\
file.getParent()结果为：D:\
file.getTotalSpace()结果为：246961664000字节(B)
(file.getTotalSpace()*1.0/1024/1024/1024)结果为：230.00097274780273千兆字节(GB)
file.getFreeSpace()结果为：178874249216字节(B)
(file.getFreeSpace()*1.0/1024/1024/1024)结果为：166.58962631225586千兆字节(GB)
file.getUsableSpace()结果为：178874249216字节(B)
(file.getUsableSpace()*1.0/1024/1024/1024)结果为：166.58962631225586千兆字节(GB)
(file.getTotalSpace()*1.0-file.getUsableSpace()*1.0)结果为：6.8087414784E10字节(B)
((file.getTotalSpace()*1.0-file.getUsableSpace()*1.0)/1024/1024/1024)结果为：63.411346435546875千兆字节(GB)

7.2、File类显示子文件目录(File Class Display Sub File Directory)

7.2.1、查看子文件目录(View Sub File Directory)

• 7.2.1.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.file;
import java.io.File;
public class ViewSubFileDirectory {
    public static void main(String[] args) {
        //文件分隔符
        System.out.println("文件分隔符");
        System.out.println("==================================================");
        System.out.println("File.separator结果为："+File.separator);
        System.out.println("==================================================");
        //查看文件的子文件目录
        File file = new File("D:\\Program Files");
        //判断文件是否为文件夹目录
        if(file.isDirectory()){
            //获取文件目录的所有子文件(全路径)
            System.out.println("获取文件目录("+file+")的所有子文件：");
            System.out.println("==================================================");
            File[] subFile1=file.listFiles();
            for (int i = 0; i < subFile1.length; i++) {
                //System.out.println(subFile1[i]);
                System.out.println(subFile1[i].getAbsolutePath());
            }
            System.out.println("==================================================");
            //获取文件目录的所有子文件路径(不是全路径，只是子文件或子文件夹名称)
            System.out.println("获取文件目录("+file+")的所有子文件路径：");
            System.out.println("==================================================");
            String[] subFile2=file.list();
            for (int i = 0; i < subFile2.length; i++) {
                System.out.println(subFile2[i]);
            }
            System.out.println("==================================================");
        }
    }
}

• 7.2.1.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

文件分隔符
==================================================
File.separator结果为：\
==================================================
获取文件目录(D:\Program Files)的所有子文件：
==================================================
D:\Program Files\CSR
D:\Program Files\JetBrains
D:\Program Files\Microsoft SQL Server
D:\Program Files\MXPLC
D:\Program Files\PostgreSQL
D:\Program Files\RealVNC
D:\Program Files\TortoiseSVN
D:\Program Files\Typora
D:\Program Files\WinRAR
==================================================
获取文件目录(D:\Program Files)的所有子文件路径：
==================================================
CSR
JetBrains
Microsoft SQL Server
MXPLC
PostgreSQL
RealVNC
TortoiseSVN
Typora
WinRAR
==================================================

7.2.2、练习(Exercise)

​ 练习作业：使用递归(尽量有缩进)打印输出指定文件目录下的所有子文件(包含子文件夹中的子文件)。

• 7.2.2.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.file;
import java.io.File;
/**
 * 练习作业：使用递归(尽量有缩进)打印输出指定文件目录下的所有子文件(包含子文件夹中的子文件)
 */
public class ViewAllSubFile {
    public static void main(String[] args) {
        File file = new File("E:\\Environment\\Java\\IDEA");//创建File类对象
        System.out.println(file.getAbsolutePath());//输出文件绝对路径
        printViewAllSubFile(file);//递归(尽量有缩进)打印输出指定文件目录下的所有子文件
    }
    public static void printViewAllSubFile(File file) {
        /**
         *递归(尽量有缩进)打印输出指定文件目录下的所有子文件
         */
        //判断文件是否为文件夹目录
        if (file.isDirectory()) {
            //File类对象为文件夹
            File[] fileArr = file.listFiles();//获取文件目录的所有子文件
            String[] fileString = file.list();//获取文件目录的所有子文件路径
            for (int i = 0; i < fileArr.length; i++) {
                System.out.println(fillCharacter((int) (fileArr[i].toString().length() - fileString[i].toString().length()), "-") + fileString[i]);//输出子文件或子文件夹路径
                printViewAllSubFile(fileArr[i]);//递归(尽量有缩进)打印输出指定文件目录下的所有子文件
            }
        }
        return;//返回方法参数并退出方法
    }
    private static String fillCharacter(int length, String charStr) {
        /**
         *填充指定长度的指定字符
         */
        String str = "";
        for (int i = 0; i < length; i++) {
            str += charStr;
        }
        return str;
    }
}

• 7.2.2.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

E:\Environment\Java\IDEA
-------------------------StageOne
----------------------------------.idea
----------------------------------------.gitignore
----------------------------------------misc.xml
----------------------------------------modules.xml
----------------------------------------uiDesigner.xml
----------------------------------------workspace.xml
----------------------------------javase
-----------------------------------------javase.iml
-----------------------------------------src
---------------------------------------------com
-------------------------------------------------xueshanxuehai
---------------------------------------------------------------array
---------------------------------------------------------------------ApplicationArray1.java
---------------------------------------------------------------------ApplicationArray2.java
---------------------------------------------------------------------ApplicationArray3.java
---------------------------------------------------------------------ApplicationArray4.java
---------------------------------------------------------------------ApplicationTwoDimensionalArray.java
---------------------------------------------------------------------ArrayClass.java
---------------------------------------------------------------------ArrayDeclarationAndCreation.java
---------------------------------------------------------------------BubbleSortAlgorithm.java
---------------------------------------------------------------------InitializationArray.java
---------------------------------------------------------------------SparseArray.java
---------------------------------------------------------------basic
---------------------------------------------------------------------Comments.java
---------------------------------------------------------------------Constant.java
---------------------------------------------------------------------DataTypeExtension.java
---------------------------------------------------------------------HelloWorld.java
---------------------------------------------------------------------JavaDoc.java
---------------------------------------------------------------------TypeConversion.java
---------------------------------------------------------------------Variable.java
---------------------------------------------------------------commonclass
---------------------------------------------------------------------------datetime
------------------------------------------------------------------------------------CalendarClass.java
------------------------------------------------------------------------------------DateClass.java
------------------------------------------------------------------------------------DateFormatAndSimpleDateFormat.java
------------------------------------------------------------------------------------DateTimeFormatterClass.java
------------------------------------------------------------------------------------LocalDateAndLocalTimeAndLocalDateTime.java
---------------------------------------------------------------------------file
--------------------------------------------------------------------------------CommonMethod.java
--------------------------------------------------------------------------------CreateFile.java
--------------------------------------------------------------------------------CreateFileDirectory.java
--------------------------------------------------------------------------------DeleteFileAndFolder.java
--------------------------------------------------------------------------------DeleteFileDirectory.java
--------------------------------------------------------------------------------ViewAllSubFile.java
--------------------------------------------------------------------------------ViewSubFileDirectory.java
---------------------------------------------------------------------------math
--------------------------------------------------------------------------------CommonMethod.java
---------------------------------------------------------------------------object
----------------------------------------------------------------------------------CloneDeepMethod.java
----------------------------------------------------------------------------------CloneGeneralMethod.java
----------------------------------------------------------------------------------CloneShallowMethod.java
----------------------------------------------------------------------------------EqualsAndHashcode.java
----------------------------------------------------------------------------------EqualsDeepenMethod.java
----------------------------------------------------------------------------------EqualsMethod.java
----------------------------------------------------------------------------------HashCodeMethod.java
----------------------------------------------------------------------------------ToStringMethod.java
---------------------------------------------------------------------------string
----------------------------------------------------------------------------------CommonMethod.java
----------------------------------------------------------------------------------CreateObjectMethod.java
----------------------------------------------------------------------------------InternMethod001.java
----------------------------------------------------------------------------------InternMethod002.java
----------------------------------------------------------------------------------InternMethod003.java
----------------------------------------------------------------------------------InternMethod004.java
----------------------------------------------------------------------------------InternMethod005.java
----------------------------------------------------------------------------------InternMethod006.java
----------------------------------------------------------------------------------MemoryModelAnalysis001.java
----------------------------------------------------------------------------------MemoryModelAnalysis002.java
----------------------------------------------------------------------------------MemoryModelAnalysis003.java
----------------------------------------------------------------------------------MemoryModelAnalysis004.java
----------------------------------------------------------------------------------MemoryModelAnalysis005.java
----------------------------------------------------------------------------------MemoryModelAnalysis006.java
----------------------------------------------------------------------------------SourceCodeAnalysis.java
----------------------------------------------------------------------------------StringBufferAndStringBuilder.java
----------------------------------------------------------------------------------StringEncryptionAndDecryption.java
---------------------------------------------------------------------------wrapper
-----------------------------------------------------------------------------------CacheInteger.java
-----------------------------------------------------------------------------------CommonPropertiesAndMethods.java
-----------------------------------------------------------------------------------CreatingMethodsAndAutoboxingUnboxing.java
---------------------------------------------------------------exception
-------------------------------------------------------------------------CallCustomException.java
-------------------------------------------------------------------------CatchException.java
-------------------------------------------------------------------------CustomException.java
-------------------------------------------------------------------------ThrowException.java
-------------------------------------------------------------------------ThrowsException.java
---------------------------------------------------------------method
----------------------------------------------------------------------CommandLineDeliveryParameter.class
----------------------------------------------------------------------CommandLineDeliveryParameter.java
----------------------------------------------------------------------ConsoleCalculator.java
----------------------------------------------------------------------DefinitionAndCallMethod.java
----------------------------------------------------------------------OverloadMethod.java
----------------------------------------------------------------------RecursiveMethod.java
----------------------------------------------------------------------VariableParameter.java
---------------------------------------------------------------multithread
---------------------------------------------------------------------------InheritThreadClass.java
---------------------------------------------------------------oop
-------------------------------------------------------------------Abstract.java
-------------------------------------------------------------------Abstract1.java
-------------------------------------------------------------------Abstract2.java
-------------------------------------------------------------------ClassAndObjectCreation.java
-------------------------------------------------------------------ClassConstructor.java
-------------------------------------------------------------------CreateObjectMemoryAnalysis.java
-------------------------------------------------------------------DefinitionAndCallMethod.java
-------------------------------------------------------------------Dog.java
-------------------------------------------------------------------Encapsulation.java
-------------------------------------------------------------------Human.java
-------------------------------------------------------------------Inherit.java
-------------------------------------------------------------------InnerClass.java
-------------------------------------------------------------------InstanceofAndTypeConversion.java
-------------------------------------------------------------------Interface.java
-------------------------------------------------------------------MethodOverride.java
-------------------------------------------------------------------Outer.java
-------------------------------------------------------------------Override1.java
-------------------------------------------------------------------Override2.java
-------------------------------------------------------------------Peoples.java
-------------------------------------------------------------------Pet.java
-------------------------------------------------------------------Pets.java
-------------------------------------------------------------------Polices.java
-------------------------------------------------------------------Polymorphic.java
-------------------------------------------------------------------Scientists.java
-------------------------------------------------------------------Static.java
-------------------------------------------------------------------Students.java
-------------------------------------------------------------------Super.java
-------------------------------------------------------------------Teachers.java
-------------------------------------------------------------------TimerService.java
-------------------------------------------------------------------UserService.java
-------------------------------------------------------------------UserServiceImpl.java
---------------------------------------------------------------operator
------------------------------------------------------------------------ArithmeticalOperator.java
------------------------------------------------------------------------ConditionalOperator.java
------------------------------------------------------------------------ExtendedAssignmentOperator.java
------------------------------------------------------------------------LogicalOperator.java
------------------------------------------------------------------------MathClass.java
------------------------------------------------------------------------PositionalOperator.java
------------------------------------------------------------------------RelationalOperator.java
---------------------------------------------------------------processcontrol
------------------------------------------------------------------------------BreakContinueGotoExercise.java
------------------------------------------------------------------------------DoWhileCyclicStructure.java
------------------------------------------------------------------------------EnhanceForCyclicStructure.java
------------------------------------------------------------------------------ForCyclicStructure.java
------------------------------------------------------------------------------IfDoubleSelectionStructure.java
------------------------------------------------------------------------------IfMultipleSelectionStructure.java
------------------------------------------------------------------------------IfSingleSelectionStructure.java
------------------------------------------------------------------------------NestedIfSelectionStructure.java
------------------------------------------------------------------------------PrintTriangle.java
------------------------------------------------------------------------------ScannerClass1.java
------------------------------------------------------------------------------ScannerClass2.java
------------------------------------------------------------------------------ScannerClass3.java
------------------------------------------------------------------------------ScannerClass4.java
------------------------------------------------------------------------------ScannerClass5.java
------------------------------------------------------------------------------SwitchSelectionStructure.class
------------------------------------------------------------------------------SwitchSelectionStructure.java
------------------------------------------------------------------------------WhileCyclicStructure.java
----------------------------------out
--------------------------------------production
-------------------------------------------------javase
--------------------------------------------------------com
------------------------------------------------------------xueshanxuehai
--------------------------------------------------------------------------array
--------------------------------------------------------------------------------ApplicationArray1.class
--------------------------------------------------------------------------------ApplicationArray2.class
--------------------------------------------------------------------------------ApplicationArray3.class
--------------------------------------------------------------------------------ApplicationArray4.class
--------------------------------------------------------------------------------ApplicationTwoDimensionalArray.class
--------------------------------------------------------------------------------ArrayClass.class
--------------------------------------------------------------------------------ArrayDeclarationAndCreation.class
--------------------------------------------------------------------------------BubbleSortAlgorithm.class
--------------------------------------------------------------------------------InitializationArray.class
--------------------------------------------------------------------------------SparseArray.class
--------------------------------------------------------------------------basic
--------------------------------------------------------------------------------Comments.class
--------------------------------------------------------------------------------Constant.class
--------------------------------------------------------------------------------DataTypeExtension.class
--------------------------------------------------------------------------------HelloWorld.class
--------------------------------------------------------------------------------JavaDoc.class
--------------------------------------------------------------------------------TypeConversion.class
--------------------------------------------------------------------------------Variable.class
--------------------------------------------------------------------------commonclass
--------------------------------------------------------------------------------------datetime
-----------------------------------------------------------------------------------------------CalendarClass.class
-----------------------------------------------------------------------------------------------DateClass.class
-----------------------------------------------------------------------------------------------DateFormatAndSimpleDateFormat.class
-----------------------------------------------------------------------------------------------DateTimeFormatterClass.class
-----------------------------------------------------------------------------------------------LocalDateAndLocalTimeAndLocalDateTime.class
--------------------------------------------------------------------------------------file
-------------------------------------------------------------------------------------------CommonMethod.class
-------------------------------------------------------------------------------------------CreateFile.class
-------------------------------------------------------------------------------------------CreateFileDirectory.class
-------------------------------------------------------------------------------------------DeleteFileAndFolder.class
-------------------------------------------------------------------------------------------DeleteFileDirectory.class
-------------------------------------------------------------------------------------------ViewAllSubFile.class
-------------------------------------------------------------------------------------------ViewSubFileDirectory.class
--------------------------------------------------------------------------------------math
-------------------------------------------------------------------------------------------CommonMethod.class
--------------------------------------------------------------------------------------object
---------------------------------------------------------------------------------------------Car.class
---------------------------------------------------------------------------------------------CarDeep.class
---------------------------------------------------------------------------------------------CloneDeepMethod.class
---------------------------------------------------------------------------------------------CloneGeneralMethod.class
---------------------------------------------------------------------------------------------CloneShallowMethod.class
---------------------------------------------------------------------------------------------Computer.class
---------------------------------------------------------------------------------------------Cpu.class
---------------------------------------------------------------------------------------------Engine.class
---------------------------------------------------------------------------------------------EngineDeep.class
---------------------------------------------------------------------------------------------EqualsAndHashcode.class
---------------------------------------------------------------------------------------------EqualsDeepenMethod.class
---------------------------------------------------------------------------------------------EqualsMethod.class
---------------------------------------------------------------------------------------------Fire.class
---------------------------------------------------------------------------------------------HashCodeMethod.class
---------------------------------------------------------------------------------------------Person.class
---------------------------------------------------------------------------------------------Scientist.class
---------------------------------------------------------------------------------------------Star.class
---------------------------------------------------------------------------------------------Tire.class
---------------------------------------------------------------------------------------------TireDeep.class
---------------------------------------------------------------------------------------------ToStringMethod.class
---------------------------------------------------------------------------------------------User.class
---------------------------------------------------------------------------------------------Water.class
--------------------------------------------------------------------------------------string
---------------------------------------------------------------------------------------------CommonMethod.class
---------------------------------------------------------------------------------------------CreateObjectMethod.class
---------------------------------------------------------------------------------------------InternMethod001.class
---------------------------------------------------------------------------------------------InternMethod002.class
---------------------------------------------------------------------------------------------InternMethod003.class
---------------------------------------------------------------------------------------------InternMethod004.class
---------------------------------------------------------------------------------------------InternMethod005.class
---------------------------------------------------------------------------------------------InternMethod006.class
---------------------------------------------------------------------------------------------MemoryModelAnalysis001.class
---------------------------------------------------------------------------------------------MemoryModelAnalysis002.class
---------------------------------------------------------------------------------------------MemoryModelAnalysis003.class
---------------------------------------------------------------------------------------------MemoryModelAnalysis004.class
---------------------------------------------------------------------------------------------MemoryModelAnalysis005.class
---------------------------------------------------------------------------------------------MemoryModelAnalysis006.class
---------------------------------------------------------------------------------------------SourceCodeAnalysis.class
---------------------------------------------------------------------------------------------StringBufferAndStringBuilder.class
---------------------------------------------------------------------------------------------StringEncryptionAndDecryption.class
--------------------------------------------------------------------------------------wrapper
----------------------------------------------------------------------------------------------CacheInteger.class
----------------------------------------------------------------------------------------------CommonPropertiesAndMethods.class
----------------------------------------------------------------------------------------------CreatingMethodsAndAutoboxingUnboxing.class
--------------------------------------------------------------------------exception
------------------------------------------------------------------------------------CallCustomException.class
------------------------------------------------------------------------------------CatchException.class
------------------------------------------------------------------------------------CustomException.class
------------------------------------------------------------------------------------ThrowException.class
------------------------------------------------------------------------------------ThrowsException.class
--------------------------------------------------------------------------method
---------------------------------------------------------------------------------CommandLineDeliveryParameter.class
---------------------------------------------------------------------------------ConsoleCalculator.class
---------------------------------------------------------------------------------DefinitionAndCallMethod.class
---------------------------------------------------------------------------------OverloadMethod.class
---------------------------------------------------------------------------------RecursiveMethod.class
---------------------------------------------------------------------------------VariableParameter.class
--------------------------------------------------------------------------multithread
--------------------------------------------------------------------------------------InheritThreadClass.class
--------------------------------------------------------------------------oop
------------------------------------------------------------------------------Abstract.class
------------------------------------------------------------------------------Abstract1.class
------------------------------------------------------------------------------Abstract2.class
------------------------------------------------------------------------------ClassAndObjectCreation.class
------------------------------------------------------------------------------ClassConstructor.class
------------------------------------------------------------------------------CreateObjectMemoryAnalysis.class
------------------------------------------------------------------------------DefinitionAndCallMethod.class
------------------------------------------------------------------------------Dog.class
------------------------------------------------------------------------------Encapsulation.class
------------------------------------------------------------------------------Human.class
------------------------------------------------------------------------------Inherit.class
------------------------------------------------------------------------------InnerClass$1.class
------------------------------------------------------------------------------InnerClass.class
------------------------------------------------------------------------------InnerClassInterface.class
------------------------------------------------------------------------------InstanceofAndTypeConversion.class
------------------------------------------------------------------------------Interface.class
------------------------------------------------------------------------------MethodOverride.class
------------------------------------------------------------------------------OtherClass.class
------------------------------------------------------------------------------Outer$1LocalInner.class
------------------------------------------------------------------------------Outer$MemberInner.class
------------------------------------------------------------------------------Outer$StaticInner.class
------------------------------------------------------------------------------Outer.class
------------------------------------------------------------------------------Override1.class
------------------------------------------------------------------------------Override2.class
------------------------------------------------------------------------------Peoples.class
------------------------------------------------------------------------------Person.class
------------------------------------------------------------------------------Pet.class
------------------------------------------------------------------------------Pets.class
------------------------------------------------------------------------------Polices.class
------------------------------------------------------------------------------Polymorphic.class
------------------------------------------------------------------------------Scientists.class
------------------------------------------------------------------------------Static.class
------------------------------------------------------------------------------Student.class
------------------------------------------------------------------------------Students.class
------------------------------------------------------------------------------Super.class
------------------------------------------------------------------------------Teachers.class
------------------------------------------------------------------------------TimerService.class
------------------------------------------------------------------------------UserService.class
------------------------------------------------------------------------------UserServiceImpl.class
--------------------------------------------------------------------------operator
-----------------------------------------------------------------------------------ArithmeticalOperator.class
-----------------------------------------------------------------------------------ConditionalOperator.class
-----------------------------------------------------------------------------------ExtendedAssignmentOperator.class
-----------------------------------------------------------------------------------LogicalOperator.class
-----------------------------------------------------------------------------------MathClass.class
-----------------------------------------------------------------------------------PositionalOperator.class
-----------------------------------------------------------------------------------RelationalOperator.class
--------------------------------------------------------------------------processcontrol
-----------------------------------------------------------------------------------------BreakContinueGotoExercise.class
-----------------------------------------------------------------------------------------DoWhileCyclicStructure.class
-----------------------------------------------------------------------------------------EnhanceForCyclicStructure.class
-----------------------------------------------------------------------------------------ForCyclicStructure.class
-----------------------------------------------------------------------------------------IfDoubleSelectionStructure.class
-----------------------------------------------------------------------------------------IfMultipleSelectionStructure.class
-----------------------------------------------------------------------------------------IfSingleSelectionStructure.class
-----------------------------------------------------------------------------------------NestedIfSelectionStructure.class
-----------------------------------------------------------------------------------------PrintTriangle.class
-----------------------------------------------------------------------------------------ScannerClass1.class
-----------------------------------------------------------------------------------------ScannerClass2.class
-----------------------------------------------------------------------------------------ScannerClass3.class
-----------------------------------------------------------------------------------------ScannerClass4.class
-----------------------------------------------------------------------------------------ScannerClass5.class
-----------------------------------------------------------------------------------------SwitchSelectionStructure.class
-----------------------------------------------------------------------------------------WhileCyclicStructure.class
-------------------------Workspace
-----------------------------------Project
-------------------------------------------JavaDoc
---------------------------------------------------allclasses-frame.html
---------------------------------------------------allclasses-noframe.html
---------------------------------------------------com
-------------------------------------------------------xueshanxuehai
---------------------------------------------------------------------Basic
---------------------------------------------------------------------------JavaDoc.html
---------------------------------------------------------------------------package-frame.html
---------------------------------------------------------------------------package-summary.html
---------------------------------------------------------------------------package-tree.html
---------------------------------------------------constant-values.html
---------------------------------------------------deprecated-list.html
---------------------------------------------------help-doc.html
---------------------------------------------------index-files
---------------------------------------------------------------index-1.html
---------------------------------------------------------------index-2.html
---------------------------------------------------------------index-3.html
---------------------------------------------------index.html
---------------------------------------------------overview-tree.html
---------------------------------------------------package-list
---------------------------------------------------script.js
---------------------------------------------------stylesheet.css

7.3、File类创建文件目录(File Class Create File Directory)

• 7.3.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.file;
import java.io.File;
public class CreateFileDirectory {
    public static void main(String[] args) {
        /**
         *创建文件目录
         *File类mkdir方法：只能创建父级目录存在的子文件目录
         *File类mkdirs方法：可以创建父级目录不存在的子文件目录
         */
        File fileMkdir1=new File("E:\\JavaSE1");
        if(!fileMkdir1.exists()){
            //文件目录不存在
            System.out.println("文件("+fileMkdir1.toString()+")使用fileMkdir1.mkdir()方法创建结果为："+fileMkdir1.mkdir());
        }
        File fileMkdir2=new File("E:\\JavaSE1\\File\\mkdir");
        if(!fileMkdir2.exists()){
            //文件目录不存在
            System.out.println("文件("+fileMkdir2.toString()+")fileMkdir2.mkdir()方法创建结果为："+fileMkdir2.mkdir());
        }
        File fileMkdirs1=new File("E:\\JavaSE2");
        if(!fileMkdirs1.exists()){
            //文件目录不存在
            System.out.println("文件("+fileMkdirs1.toString()+")fileMkdirs1.mkdirs()方法创建结果为："+fileMkdirs1.mkdirs());
        }
        File fileMkdirs2=new File("E:\\JavaSE2\\File\\mkdirs");
        if(!fileMkdirs2.exists()){
            //文件目录不存在
            System.out.println("文件("+fileMkdirs2.toString()+")fileMkdirs2.mkdirs()方法创建结果为："+fileMkdirs2.mkdirs());
        }
    }
}

• 7.3.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

文件(E:\JavaSE1)使用fileMkdir1.mkdir()方法创建结果为：true
文件(E:\JavaSE1\File\mkdir)fileMkdir2.mkdir()方法创建结果为：false
文件(E:\JavaSE2)fileMkdirs1.mkdirs()方法创建结果为：true
文件(E:\JavaSE2\File\mkdirs)fileMkdirs2.mkdirs()方法创建结果为：true

7.4、File类创建文件(File Class Create File)

• 7.4.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.file;
import java.io.File;
import java.io.IOException;
public class CreateFile {
    public static void main(String[] args) throws IOException {
        /**
         *创建文件
         *File类createNewFile方法：创建任意指定类型的文件
         */
        File file1=new File("E:\\JavaSE","1.txt");
        if(!file1.exists()){
            if(!file1.getParentFile().exists()){
                boolean bool1=file1.getParentFile().mkdirs();
                System.out.println("文件("+file1.getParentFile().toString()+")file1.getParentFile().mkdirs()方法创建结果为："+bool1);
                if(bool1){
                    System.out.println("文件("+file1.toString()+")使用file1.createNewFile()方法创建结果为："+file1.createNewFile());
                }
            }else{
                System.out.println("文件("+file1.toString()+")使用file1.createNewFile()方法创建结果为："+file1.createNewFile());
            }
        }
    }
}

• 7.4.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

文件(E:\JavaSE)file1.getParentFile().mkdirs()方法创建结果为：true
文件(E:\JavaSE\1.txt)使用file1.createNewFile()方法创建结果为：true

7.5、File类删除文件与文件夹(File Class Delete File And Folder)

7.5.1、删除文件与文件夹(Delete File And Folder)

• 7.5.1.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.file;
import java.io.File;
public class DeleteFileAndFolder {
    public static void main(String[] args) {
        /**
         *删除文件与文件夹
         *File类delete方法：删除任意指定的文件与文件夹
         */
        //删除文件
        File file1=new File("E:\\JavaSE\\1.txt");
        System.out.println("文件("+file1.toString()+")使用file1.delete()方法删除结果为："+file1.delete());
        //删除文件夹
        File file2=new File("E:\\JavaSE\\2");
        System.out.println("文件("+file2.toString()+")使用file2.delete()方法删除结果为："+file2.delete());
    }
}

• 7.5.1.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

文件(E:\JavaSE\1.txt)使用file1.delete()方法删除结果为：true
文件(E:\JavaSE\2)使用file2.delete()方法删除结果为：true

7.5.2、删除包含子文件与子文件夹的文件目录(Delete File Directory of Contain Sub File And Sub Folder)

• 7.5.2.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.file;
import java.io.File;
/**
 * 练习作业：使用递归删除包含子文件与子文件夹的文件目录
 */
public class DeleteFileDirectory {
    public static void main(String[] args) {
        File file = new File("E:\\JavaSE");//创建File类对象
        System.out.println("文件目录(E:\\JavaSE)的所有子文件与子文件夹(删除前)：");
        if(file.exists()){
            File[] fileArr1 = file.listFiles();//获取文件目录的所有子文件
            for (int i = 0; i < fileArr1.length; i++) {
                System.out.println(fileArr1[i]);
            }
        }
        System.out.println("递归删除包含子文件与子文件夹的文件目录(E:\\JavaSE)");
        while(file.exists()){
            //若指定文件目录还存在，则继续删除包含子文件与子文件夹的文件目录
            deleteFileDirectory(file);//递归删除包含子文件与子文件夹的文件目录
        }
        System.out.println("文件目录及其所有子文件与子文件夹(删除后)");
        if(file.exists()) {
            System.out.println("文件目录："+file.toString());
            System.out.println("所有子文件与子文件夹：");
            File[] fileArr2 = file.listFiles();//获取文件目录的所有子文件
            for (int i = 0; i < fileArr2.length; i++) {
                System.out.println(fileArr2[i]);
            }
        }
    }
    public static void deleteFileDirectory(File file) {
        /**
         *递归删除包含子文件与子文件夹的文件目录
         */
        //判断文件是否为文件夹目录
        if (file.isDirectory()) {
            //File类对象为文件夹
            File[] fileArr = file.listFiles();//获取文件目录的所有子文件
            if (fileArr.length == 0) {
                file.delete();//删除文件夹
            }
            for (int i = 0; i < fileArr.length; i++) {
                deleteFileDirectory(fileArr[i]);//递归删除包含子文件与子文件夹的文件目录
            }
        } else {
            file.delete();//删除文件
        }
        return;//返回方法参数并退出方法
    }
}

• 7.5.2.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

文件目录(E:\JavaSE)的所有子文件与子文件夹(删除前)：
E:\JavaSE\1.txt
E:\JavaSE\2
递归删除包含子文件与子文件夹的文件目录(E:\JavaSE)
文件目录及其所有子文件与子文件夹(删除后)

8、枚举类(Enum Class)

​ 枚举是指一个经过排序的、被打包成一个单一实体的项列表。一个枚举的实例可以使用枚举项列表中任意单一项的值。枚举通常用来表示“颜色、方式、类别、状态等数目有限、形式离散、表达又极为明确的量”。

​ 枚举是JDK1.5开始引入的新类型。其可以理解为一种特殊的Java类，在这个特殊类中定义几个静态常量，每个常量都是这个类的实例，通过关键字enum实现，自动继承自Enum类。

8.1、枚举类常规使用(Enum Class General Use)

• 8.1.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.enumclass;
public class GeneralUse {
    public static void main(String[] args) {
        Employee employee1=new Employee(1,"小红",EmployeeType.UNQUALIFIED);
        Employee employee2=new Employee(2,"小橙",EmployeeType.QUALIFIED);
        Employee employee3=new Employee(3,"小黄",EmployeeType.COMMONLY);
        Employee employee4=new Employee(4,"小绿",EmployeeType.EXCELLENT);
        System.out.println(employee1.id+","+employee1.name+","+employee1.employeeType);
        System.out.println(employee2.id+","+employee2.name+","+employee2.employeeType);
        System.out.println(employee3.id+","+employee3.name+","+employee3.employeeType);
        System.out.println(employee4.id+","+employee4.name+","+employee4.employeeType);
    }
}
class Employee{
    //员工类
    public int id;
    public String name;
    public EmployeeType employeeType;
    public Employee(int id, String name, EmployeeType employeeType) {
        this.id = id;
        this.name = name;
        this.employeeType = employeeType;
    }
}
enum EmployeeType{
    //员工的枚举类型(即，枚举所有的员工类型)
    UNQUALIFIED,//不合格
    QUALIFIED,//合格
    COMMONLY,//一般
    EXCELLENT;//优秀
}

• 8.1.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

1,小红,UNQUALIFIED
2,小橙,QUALIFIED
3,小黄,COMMONLY
4,小绿,EXCELLENT

8.2、枚举类深化使用(Enum Class Deepen Use)

• 8.2.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.enumclass;
public class DeepenUse {
    public static void main(String[] args) {
        Teacher teacher1=new Teacher(1,"李老师", TeacherType.PRIMARY);
        Teacher teacher2=new Teacher(2,"刘老师", TeacherType.INTERMEDIATE);
        Teacher teacher3=new Teacher(3,"罗老师", TeacherType.SENIOR);
        Teacher teacher4=new Teacher(4,"金老师", TeacherType.SUPER);
        Teacher teacher5=new Teacher(5,"彭老师", TeacherType.SUPER);
 System.out.println(teacher1.id+","+teacher1.name+","+teacher1.teacherType+","+teacher1.teacherType.getLevel()+","+teacher1.teacherType.getSalary()+","+teacher1.teacherType.getSubsidy());
 System.out.println(teacher2.id+","+teacher2.name+","+teacher2.teacherType+","+teacher2.teacherType.getLevel()+","+teacher2.teacherType.getSalary()+","+teacher2.teacherType.getSubsidy());
 System.out.println(teacher3.id+","+teacher3.name+","+teacher3.teacherType+","+teacher3.teacherType.getLevel()+","+teacher3.teacherType.getSalary()+","+teacher3.teacherType.getSubsidy());
 System.out.println(teacher4.id+","+teacher4.name+","+teacher4.teacherType+","+teacher4.teacherType.getLevel()+","+teacher4.teacherType.getSalary()+","+teacher4.teacherType.getSubsidy());
 System.out.println(teacher5.id+","+teacher5.name+","+teacher5.teacherType+","+teacher5.teacherType.getLevel()+","+teacher5.teacherType.getSalary()+","+teacher5.teacherType.getSubsidy());
        //枚举对象不管被使用多少次，内存中都只会被创建一次，而且只有在第一次加载枚举类的时候创建
        System.out.println("(teacher4.teacherType==teacher5.teacherType)结果为："+(teacher4.teacherType==teacher5.teacherType));
        //遍历枚举类对象
        System.out.println("遍历枚举类对象：");
        for (TeacherType tt : TeacherType.values()) {
            System.out.println(tt.toString()+","+tt.name()+","+tt.getLevel()+","+tt.getSalary()+","+tt.getSubsidy());
        }
    }
}
class Teacher{
    //教师类
    public int id;
    public String name;
    public TeacherType teacherType;
    /**
     *教师类的构造器
     * @param id 编号
     * @param name 姓名
     * @param teacherType 教师枚举类型
     */
    public Teacher(int id, String name, TeacherType teacherType) {
        this.id = id;
        this.name = name;
        this.teacherType = teacherType;
    }
}
enum TeacherType{
    //教师的枚举类型(即，枚举所有的教师类型)
    PRIMARY(1,1000,100),//初级
    INTERMEDIATE(2,2000,200),//中级
    SENIOR(3,3000,300),//高级
    SUPER(4,4000,400);//特级
    private int level;
    private int salary;
    private int subsidy;
    /**
     *枚举类的构造器
     * @param level 级别
     * @param salary 薪资
     * @param subsidy 补助
     */
    TeacherType(int level, int salary, int subsidy) {
        this.level = level;
        this.salary = salary;
        this.subsidy = subsidy;
    }
    public int getLevel() {
        return level;
    }
    public int getSalary() {
        return salary;
    }
    public int getSubsidy() {
        return subsidy;
    }
}

• 8.2.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

1,李老师,PRIMARY,1,1000,100
2,刘老师,INTERMEDIATE,2,2000,200
3,罗老师,SENIOR,3,3000,300
4,金老师,SUPER,4,4000,400
5,彭老师,SUPER,4,4000,400
(teacher4.teacherType==teacher5.teacherType)结果为：true
遍历枚举类对象：
PRIMARY,PRIMARY,1,1000,100
INTERMEDIATE,INTERMEDIATE,2,2000,200
SENIOR,SENIOR,3,3000,300
SUPER,SUPER,4,4000,400

• 8.2.3、内存分析(Memory Analysis)

​ 枚举类单例对象内存分析示意图，如下图所示。

8.3、注意事项(Matters Needing Attention)

• 8.3.1、枚举对象不管被使用多少次，内存中都只会被创建一次，而且只有在第一次加载枚举类的时候创建。

9、工具类(Tool Class)

​ 一般的类名后加上"s"结尾的类称为“工具类”，如：“Objects类、Arrays类、Collections类”等。

9.1、Objects工具类(Objects Tool Class)

• 9.1.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.tool;
import java.util.Objects;
public class ObjectsClass {
    public static void main(String[] args) {
        //生成对象的哈希码值
        System.out.println("Objects.hash(\"12345\")结果为："+Objects.hash("12345"));
        //返回对象的内容的字符串表示形式
        System.out.println("Objects.toString(null)结果为："+Objects.toString(null));
        System.out.println("Objects.toString(new ObjectsClass())结果为："+Objects.toString(new ObjectsClass()));
        //返回对象的内容的字符串表示形式，若第一个参数不是null，则返回第一个参数调用toString的结果，toString返回第二个参数。
        System.out.println("Objects.toString(null,\"空\")结果为："+Objects.toString(null,"空"));
        System.out.println("Objects.toString(new ObjectsClass(),\"空\")结果为："+Objects.toString(new ObjectsClass(),"空"));
        //比较2个对象是否相等，若相等则返回true,否则返回false
        System.out.println("Objects.equals(new ObjectsClass(),new ObjectsClass())结果为："+ Objects.equals(new ObjectsClass(),new ObjectsClass()));
        System.out.println("Objects.equals(\"123\",\"123\")结果为："+ Objects.equals("123","123"));
        //判断对象是否为空，若为空则返回true，否则返回false
        System.out.println("Objects.isNull(null)结果为："+Objects.isNull(null));
        System.out.println("Objects.isNull(new ObjectsClass())结果为："+Objects.isNull(new ObjectsClass()));
        System.out.println("Objects.isNull(\"\")结果为："+Objects.isNull(""));
    }
}

• 9.1.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

Objects.hash("12345")结果为：46792786
Objects.toString(null)结果为：null
Objects.toString(new ObjectsClass())结果为：com.xueshanxuehai.commonclass.tool.ObjectsClass@1b6d3586
Objects.toString(null,"空")结果为：空
Objects.toString(new ObjectsClass(),"空")结果为：com.xueshanxuehai.commonclass.tool.ObjectsClass@4554617c
Objects.equals(new ObjectsClass(),new ObjectsClass())结果为：false
Objects.equals("123","123")结果为：true
Objects.isNull(null)结果为：true
Objects.isNull(new ObjectsClass())结果为：false
Objects.isNull("")结果为：false

9.2、Arrays工具类(Arrays Tool Class)

• 9.2.1、示例代码(Sample Code)

​ 其示例，如以下代码所示。

package com.xueshanxuehai.commonclass.tool;
import java.util.Arrays;
public class ArraysClass {
    public static void main(String[] args) {
        int[] intArray1={1,3,5,7,9,8,6,4,2,0};
        int[] intArray2={1,3,5,7,9,8,6,4,2,0};
        //返回指定数组的内容的字符串表示形式
        System.out.println("Arrays.toString(intArray1)结果为："+Arrays.toString(intArray1));
        System.out.println("Arrays.toString(intArray2)结果为："+Arrays.toString(intArray2));
        //比较2个数组是否相等，若相等则返回true,否则返回false
        System.out.println("Arrays.equals(intArray1,intArray2)结果为："+Arrays.equals(intArray1,intArray2));
        //填充指定元素给指定数组的每个元素
        int[] intArray3=new int[10];
        Arrays.fill(intArray3,10);
        System.out.println("Arrays.toString(intArray3)结果为："+Arrays.toString(intArray3));
        //复制指定长度的数组，若指定长度大于复制数组的长度，则用零填充后面的数组元素，若指定长度小于复制数组的长度，则截取指定长度的复制数组元素。
        int[] intArray4=Arrays.copyOf(intArray3,15);
        int[] intArray5=Arrays.copyOf(intArray3,5);
        System.out.println("Arrays.toString(intArray4)结果为："+Arrays.toString(intArray4));
        System.out.println("Arrays.toString(intArray5)结果为："+Arrays.toString(intArray5));
        //升序排序数组元素
        Arrays.sort(intArray1);
        System.out.println("Arrays.toString(intArray1)结果为："+Arrays.toString(intArray1));
        //二分法查找指定数组元素在数组中的位置下标索引(且若要正确找到，则数组各元素必须是已升序排序)
        System.out.println("Arrays.binarySearch(intArray1,6)结果为："+Arrays.binarySearch(intArray1,6));
        System.out.println("Arrays.binarySearch(intArray2,6)结果为："+Arrays.binarySearch(intArray2,6));
    }
}

• 9.2.2、运行结果(Run Result)

​ 其运行结果，如以下信息所示。

Arrays.toString(intArray1)结果为：[1, 3, 5, 7, 9, 8, 6, 4, 2, 0]
Arrays.toString(intArray2)结果为：[1, 3, 5, 7, 9, 8, 6, 4, 2, 0]
Arrays.equals(intArray1,intArray2)结果为：true
Arrays.toString(intArray3)结果为：[10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
Arrays.toString(intArray4)结果为：[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0]
Arrays.toString(intArray5)结果为：[10, 10, 10, 10, 10]
Arrays.toString(intArray1)结果为：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Arrays.binarySearch(intArray1,6)结果为：6
Arrays.binarySearch(intArray2,6)结果为：-4

参考资料(Reference Data)：

学习网站地址(即"学习网址",Learning Website Address)：Java常用类