Java常用类最新教程通俗易懂

1.内部类
2.包装类
3.Object类
4.String类
5.BigDecimal类
6.system类

1.内部类

成员内部类、静态内部类(static)、局部内部类(在方法内)、匿名内部类(常用在接口或抽象类)

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

特点：

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

Outer$Inner.class

Outer.class

// 身体
public class Body{ //生成1个class文件
    // 头部
    class Header{ // 会生成另一个class文件,文件名用$分隔外和内 类名
    }
}

1.1.成员内部类

在类的内部定义，与实例变量、实例方法同级别的类
外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象(先创建外部类对象才能创建内部类对象)
当外部类、内部类存在重名属性时，会优先访问内部类属性
成员内部类里不能定义静态成员、可以包含静态常量(final)

//Outer.java
public class Outer{// 外部类
    //实例变量
    private String name = "张三";
    private int age = 20;

    class Inner{//内部类
        private String address = "北京";
        private String phone = "110";
        private String name = "李四";
        //private static String country = "中国"; //编译报错,不能定义静态成员
        private static final String country = "中国"; //编译通过,可以包含静态常量

        public void show(){
            //打印外部类属性 此时有重名属性name
            //访问外部类属性用 Outer.this.name
            sout(Outer.this.name); // 张三
            sout(age); //建议外部类属性全部加Outer.this.
            //打印内部类中的属性
            sout(name); // 李四
            sout(this.address); //建议给所有属性加this
            sout(this.phone);
        }
    }
}

//Test.java
public class Test{
    psvm(String[] args){
        Outer outer = new Outer();// 创建外部类对象
        Inner inner = outer.new Inner();// 创建内部类对象
        //Inner inner = new Outer().new Inner();//也可把上面2行改成这样
        inner.show();
    }
}

1.2.静态内部类

不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员

//Outer.java
public class Outer{// 外部类,不能用static修饰
    //实例变量
    private String name = "xxx";
    private int age = 20;

    static class Inner{// 静态内部类，和外部类相同级别
        private String address = "上海";
        private String phone = "111";
        private static int count = 1000;// 静态成员

        public void show(){
            // 访问外部类的属性
            //sout(name); //编译报错,不能直接访问,当作外部类同级的类去访问
            Outer outer = new Outer();// 1. 先创建外部类对象
            sout(outer.name);//xxx 2. 调用外部类对象的属性
            sout(outer.age);//20
            // 调用静态内部类的属性和方法
            sout(address);//上海
            sout(phone);//111
            sout(Inner.count);//1000 调用静态内部类的静态属性
        }
    }
}

//Test.java
public class Test{
    psvm(String[] args){
        Outer.Inner inner = new Outer.Inner();// 直接创建静态内部类对象
        inner.show();
    }
}

1.3.局部内部类

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

//Outer.java
public class Outer{// 外部类
    //实例变量
    private String name = "刘德华";
    private int age = 35;

    //方法
    public void show(){
        String address = "sz";// 定义局部变量
        //private String address = "sz";//编译报错 不能加private

        // 局部内部类：注意不能加任何访问修饰符
        //private class Inner{//编译报错 不能加private之类
        class Inner{ //只能在show()方法中使用
            private String phone = "114";
            private String email = "humble_zh@163.com";
            //private static int count = 2000;//编译报错 不能定义static变量
            private final static int count = 2000;//编译通过 能定义常量

            public void show2(){
              //访问外部类的属性
              //无重名，相当于Outer.this.name,如果show2()是static的,就不能直接访问
              sout(name); //刘德华
              sout(Outer.this.age); //35
              // 访问内部类的属性
              sout(phone); //114
              sout(this.email); //humble_zh@163.com

              // 访问局部变量 jdk1.7要求必须常量final、jdk1.8自动添加final
              sout(address); //sz  //自动帮 String address = "sz"; 加了final
              //address = "bj"; //编译报错 final不能修改
              //为啥指定final？
              //show().address属于栈内，方法返回后变量就回收了
              //new Inner()的对象在堆，show()返回后，inner对象未回收，不能访问已被回收的address
        }
      }

      //如果没有下面2行，则没有任何输出
      Inner inner = new Inner();//创建局部内部类对象
      inner.show2();
    }
}

//Test.java
public class Test{
    psvm(String[] args){
        Outer outer = new Outer();// 创建外部类对象
        outer.show();
    }
}

1.4.匿名内部类

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

//Usb.java
public interface Usb{ void service(); }

//Mouse.java
public class Mouse implements Usb{
    @Override
    public void service(){ sout("成功连接电脑，Mouse开始工作"); }
}

//TestUsb.java
public class TestUsb{
    psvm(String[] args){
        /*
        Usb usb = new Mouse();//创建接口类型变量
        usb.service();//成功连接电脑，Mouse开始工作
        */

        /* //局部内部类
        class Fan implements Usb{
            @Override
            public void service(){ sout("成功连接电脑，Fan开始工作") }
        }

        //使用局部内部类创建对象
        Usb usb = new Fan();
        usb.service(); //成功连接电脑，fan开始工作
        */

        //上面使用局部内部类，用完之后就不再用了，没必要定义一个带名字的类
        //使用匿名内部类优化（相当于创建了一个局部内部类）
        //Usb usb = new Usb(); //编译报错 interface 不能实例化
        Usb usb = new Usb(){ //Usb() 可以是 interface, 抽象类, 父类
            @Override
            public void service(){ sout("成功连接电脑，xxx开始工作") }
        };
        usb.service(); //成功连接电脑，xxx开始工作
    }
}

2.Object 类

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

clone(),equals(),finalize(),getClass(),hashCode(),notify(),notifyAll(),toString(),wait(),wait(timeout)

getClass() 方法

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

Student s1=new Student("aaa",20);
Student s2=new Student("bbb",22);
// getClass返回 class类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
// 判断s1 和 s2是不是同一个类型
if(class1 == class2){ sout("true"); }
else{ sout("false"); }

hashCode()方法

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

Student s1=new Student("aaa",20);
Student s2=new Student("bbb",22);
sout(s1.hashCode()); //s1的hash和s2不相等
sout(s2.hashCode()); //因为是两个地址
Student s3 = s1; //s3和s1变量在栈内，但对象实例在堆
sout(s3.hashCode());//此时s3的hashCode与s1相同

toString()方法

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

sout(s1.toString()); // 直接打印包+类名+哈希值(hex)

//在Student.java内重写toString()
class Student{
    ...
    // 重写 alt + enter + s
    @override
    public String toString(){ return "Student [name = " + name + ", age = " + age + "]"; }
    ...
}

sout(s1.toString()); // 打印override后的格式

equals()方法

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

// 判断两个对象是否相等
sout(s1.equals(s2)); // false

Student s4 = new Student("小明", 17);
Student s5 = new Student("小明", 17);
sout(s4.equals(s5)); // false 堆中地址不同

// 不想比较地址，那就在Student.java重写该方法为:比较内容
/* 步骤
   1. 比较两个应用是否指向同一个对象
   2. 判断obj是否为null
   3. 判断两个引用只想的实际对象类型是否一致
   4. 强制类型转换
   5. 依次比较各个属性值是否相同
 */
@override
public boolean equals(Object obj){
    // 1.
    if(this == obj){ return true; }
    // 2.
    if(obj == null){ return false; }
    // 3.判断是否同一个类型
    //if(this.getClass() == obj.getClass()){  }
    //不想用getClass()可以用instanceof 判断对象是否是某种类型
    if(obj instanceof Student){
        // 4.强制类型转换
        Student s = (Student)obj;
        // 5. 比较属性
        if(this.name.equals(s.getName()) && this.age == s.getAge()){ return true; }
    }
    return false;
}

//重写equals()之后下面调用就返回true
sout(s4.equals(s5));

//TODO
if(obj instanceof Student)和if(this.getClass() == obj.getClass())这两个方法效果相同，一般用左边的。

但我觉得这两个方法判断的效果是不是不相同啊。
举个例子，Object——Person——Student这样的继承关系
Object obj = new Student（）；
Person person = new Person（）；
System.out.println(person.equals(obj));
如果用if(obj instanceof Person），那应该是True，因为obj是Student的实例，与Person有继承关系。

如果用if(this.getClass() == obj.getClass())，那应该是False，因为obj引用的是Student类，而person是Person类

感觉这里是不是还是用if(this.getClass() == obj.getClass())判断更好一点啊
还有后面有个小笔误，整数缓冲区那里integer3,4，后面是100，不是new Integer（100）
sout(content.length()); // 10
sout(content.charAt(content.length() - 1)); // 言
唔这里应该是20和1
是100；自动装箱相当于Integer.valueOf(100)；如果是new，不会进缓冲区，会打印false；
if(obj instanceof Person）这里的需求是需要判断两个类之间是否有直接或间接继承关系，不是判断是否一致；只有有继承关系，才能进行强制类型转换

finalize() 方法

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

//Student.java
@Override
protected void finalize() throws Throwable{ sout(this.name + "对象被回收了"); }

//Test.java
psvm(String[] args){
    Student s1 = new Student("aaa", 20); // 不是垃圾
    new Student("bbb", 20); // 是垃圾 会被回收
    System.gc();//手动调用，回收垃圾
    sout("回收垃圾");
    // 打印出
    //回收垃圾
    //bbb对象被回收了”
}

3.包装类

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

基本数据类型在栈，自己没有方法调用（因为不是类）。包装成引用数据类型之后就是类，实例存在于堆。

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

类型转换与装箱、拆箱

装箱：基本转引用 (栈->堆);拆箱相反。

8种包装类提供不用类型间的转换方式
1. Number父类中提供的6个共性方法
2. parseXXX( )静态方法
3. valueOf( )静态方法
注意：需保证类型兼容，否则抛出NumberFormatException异常

psvm(String[] args){
    // 装箱， 基本类型 -> 引用类型
    int num1 = 18;// 基本类型
    // 使用Integer类创建对象
    Integer integer1 = new Integer(num1); //构造方法
    Integer integer2 = Integer.valueOf(num1);

    // 拆箱， 引用类型 -> 基本类型
    Integer integer3 = new Integer(100); //创建引用类型
    int num2 = integer3.intValue(); //转成基本类型

    // 上述为jdk1.5之前方法，之后提供了自动装箱拆箱
    int age = 30;
    Integer integer4 = age; // 自动装箱 编译器自动补全为 integer4 = age.valueOf();
    int age2 = integer4; // 自动拆箱 编译器自动补全为 age2 = integer4.intValue();

    // 基本类型和字符串之间转换
    // 1. 基本类型转成字符串
    int n1 = 100;
    // 1.1 使用+号
    String s1 = n1 + "";
    // 1.2 使用Integer中的toString()方法
    String s2 = Integer.toString(n1);
    String s2 = Integer.toString(n1, 16);//Integer.toString(n1, x); // x为进制要求

    // 2. 字符串转成基本类型
    String str = "150";
    int n2 = Integer.parseInt(str); // 使用Integer.parseXXX();
    //int n2 = Integer.parseInt("150o"); // 编译报错 只能是数字字符不能是字母或其他

    // boolean 字符串形式转成基本类型，只有"true" -> true,非“true" -> false
    String str2 = "true";
    boolean b1 = Boolean.parseBoolean(str2);
}

整数缓冲区

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

psvm(String[] args){
    // 面试题
    Integer integer1 = new Integer(100);
    Integer integer2 = new Integer(100);
    sout(integer1 == integer2); // false 栈里面两个变量存的地址不相等

    Integer integer3 = 100; // 自动装箱 编译器自动补全为 =Integer.valueOf(100); //new Integer(100);
    Integer integer4 = 100; //编译器自动补全为 =Integer.valueOf(100);
    sout(integer3 == integer4); // true

    Integer integer5 = 200; // 自动装箱 编译器自动补全为 =Integer.valueOf(200); //new Integer(200);
    Integer integer6 = 200; //编译器自动补全为 =Integer.valueOf(200);//new Integer(200);
    sout(integer5 == integer6); // false

    // 100在缓存区数组 [-128, 127] 内，故valueOf()返回的地址相同(共/复用同一个堆内的对象)
    // 200不在缓存区数组 [-128, 127] 内，故valueOf()返回 new Integer();的地址
}

//源码
public static Integer valueOf(int i){
    //堆:IntegerCache常量数组,范围[-128,127],若i在范围内,直接返回数组对应元素的地址
    if(i >= IntegerCache.low && i <= IntegerCache.high) //low:-128 high:127
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

4.String 类

字符串是常量，创建之后不可改变
字符串字面值存储在字符串池中，可以共享(内存分:栈、堆、方法区。字符串存在方法区的字符串池里)
String s = "Hello";产生一个对象，字符串池中存储
String s = new String("Hello");产生两个对象，堆、池各一个

String name = "Hello"; //name在栈，"Hello"在方法区的字符串池内
name = "zhangsan"; //name在栈,更换指向为方法区的字符串池内的"zhangsan",此时"Hello"成为了垃圾
String name2 = "zhangsan"; //name2在栈和name指向同为方法区的字符串池内的"zhangsan"

String s = "Hello"; //产生一个对象，字符串池中存储
String s = new String("Hello"); //产生两个对象，堆和池 各一个;但堆内的对象指向的是方法区里的对象

String str1 = new String("java"); //产生两个对象，堆和池 各一个 浪费空间
String str2 = new String("java"); //产生两个对象，堆和池 各一个 浪费空间
sout(str1==str2); //false 因为堆内是两个实例，栈内的str1和str2保存的地址不一样
sout(str1.equals(str2)); //true

常用方法

//String content = "java是世界上最好的编程语言";
String content = "java是世界上最好的java编程语言,java真香";
sout(content.length()); // 15 // 1.int length(); 返回字符串长度
sout(content.charAt(0)); // j // 2.char charAt(int index); 返回某个位置的字符
sout(content.charAt(content.length() - 1)); // 言
//sout(content.charAt(content.length())); //编译报错 访问越界
sout(content.contains("java")); // true // 3.boolean contains(String str); 判断是否包含某个字符串

sout(Arrays.toString(content.toCharArray())); //[j,a...] //4.char[] toCharArray(); 返回字符串对应数组
sout(content.indexOf("java")); //0 //5.int indexOf(String); 返回子字符串首次出现的下标,失败-1
sout(content.indexOf("java", 4)); //从索引4开始找 返回11
sout(content.lastIndexOf("java")); //12//6.int lastIndexOf(); 返回字符串最后一次出现的下标,失败-1

String ct = "   hello World   ";
sout(ct.trim()); // "hello World" // 7. trim(); //去掉字符串前后空格
sout(ct.toUpperCase()); // HELLO WORLD // 8. toUpperCase(); toLowerCase(); 转换大小写
sout(ct.toLowerCase()); // hello world
sout(ct.endWith("World")); // true // 9. endWith(str); startWith(str);  判断是否以str 结尾、开头
sout(ct.startWith("hello")) // true

// 10. replace(char old, char new); 用new的字符或字符串替换old的字符或字符串
sout(content.replace("java", "php")); // php是最好的语言...

String say = "java is the best    programing language,java xiang";
String[] arr = arr.say.split("[ ,]+ "); // "[ ,]+" 表示空格 逗号切分 +号表示切分可以多个 比如多个空格 // 11. split(); 对字符串拆分
sout(arr.length); // 5
for(String string : arr){ sout(string); }
// 打印出
//java
//is
//the
//best
//programing
//language
//java
//xiang

// 补充两个equals返回bool,compareTo()比较差值
String s1 = "hello";
String s2 = "HELLO";
sout(s1.equals(s2));// false
sout(s1.equalsIgnoreCase(s2));//true 忽略大小写比较true

// compareTo(); 两字符不同时比较字符字典序的ascii码
String s3="abc"; //a:97
String s4="xyz"; //x:120
sout(s3.compareTo(s4));//-23

String s5="abc";
String s6="abcxyz";
sout(s5.compareTo(s6));//-3// 字符相同时返回长度差

案例演示

需求：

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

psvm(String[] args){
    String str = "this is a text";

    String[] arr = str.split(" "); //1
    for(String s : arr){ sout(s); }

    String str2 = str.replace("text", "practice"); //2
    String str3 = str.replace("text", "easy text"); //3

    for(int i = 0; i < arr.length; i++){ //4
        char first = arr[i].charAt(0);
        char upperfirst = Character.toUpperCase(first);
        String newstr = upperfirst + arr[i].substring(1);
    }
}

可变字符串

StringBuffer : 可变长字符串，运行效率比String快，比StringBuilder慢、线程安全
StringBuilder : 可边长字符串、运行快、线程不安全

效率都比String高且节省内存

psvm(String[] args){
    //StringBuffer sb = new StringBuffer();// StringBuffer 和 StringBuilder 用法一致
    StringBuilder sb = new StringBuilder();// StringBuffer 和 StringBuilder 用法一致
    sb.append("java no1");// 1. append(); 追加
    sb.insert(0, "我在最前面");//我在最前面java no1 //2. insert(); 添加、插入
    sb.replace(0, 5, "hello"); //hellojava no1 //左闭右开// 3.replace(); 替换
    sb.delete(0, 5); //java no1 //左闭右开// 4. delete(); 删除
    sb.delete(0, sb.length());// 5. 清空
}

//验证StringBuilder效率比String高
psvm(String[] args){
    long start = System.currentTimeMillis();
    /*
    String string = "";
    for(int i=0; i < 99999; i++){ string+=i; }
    sout(string); //总共用时47475ms
    */

    StringBuilder sb = new StringBuilder();
    for(int i=0; i < 99999; i++){ sb.append(i); }
    sout(sb.toString()); //总共用时308ms

    long end = System.currentTimeMillis();
    sout(end-start);
}

5.BigDecimal 类

位置 java.math 包中
作用精确计算浮点数
创建方式 BigDecimal bd = new BigDecimal("1.0");

//double在内存里存的是近似值,在要求精度比较高的场景(银行余额)就无法使用
double d1=1.0;
double d2=0.9;
sout(d1-d2);//0.0999999...

double result=(1.4-0.5)/0.9;
sout(result);//0.999999...

BigDecimal bd1 = new BigDecimal("1.0"); //传参需用字符串,因为数字本身是double就有可能不精确
BigDecimal bd2 = new BigDecimal("0.9");

BigDecimal r1 = bd1.subtract(bd2);// 减法
sout(r1); // 0.1

BigDecimal r2 = bd1.add(bd2);//1.9 加法

BigDecimal r3 = bd1.multiply(bd2);//0.90 乘法


BigDecimal r4 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"));//1 除法
BigDecimal r5 = new BigDecimal("20").divide(new BigDecimal("3"), 2, BigDecimal.ROUND_HALF_UP);//6.67 除不尽时 2:保留位数 ROUND_HALF_UP:为四舍五入

Date 类

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

时间单位：1s = 1,000ms = 1,000,000 μs = 1,000,000,000 = ns

psvm(String[] args){
    Date date1 = new Date();// 1 创建Date对象 用java.util,java.sql是继承java.util的
    sout(date1.toString()); //SAT Jan 23 22:25:23 CST 2021
    sout(date1.toLocaleString()); // 已过时 但也能用 2021-1-23 22:25:24

    // 创建昨天的
    Date date2 = new Date(date1.getTime() - (60*60*24*1000));
    sout(date2.toLocaleString()); //2021-1-22 22:25:24

    // 2 方法after before
    boolean b1 = date1.after(date2);
    sout(b1); //true
    boolean b2 = date1.before(date2);
    sout(b2); //false

    int d = date1.compareTo(date2);// 比较compareTo();
    sout(d); // 大为1,小为-1,等为0

    boolean b3 = date1.equals(date2);// 比较是否相等 equals()
    sout(b3); // false
}

Calendar

Calendar提供了获取或设置各种日历字段的方法
构造方法 protected Calendar(); 由于是protected 所以无法直接创建
其他方法

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

psvm(String[] args){
    Calendar calendar = Calendar.getInstance();// 1. 创建 Calendar 对象
    sout(calendar.getTime().toLocaleString());//2021-01-23 16:16:05
    sout(calendar.getTimeInMillis());
    // 2. 获取时间信息
    int year = calendar.get(Calendar.YEAR);// 获取年
    int month = calendar.get(Calendar.MONTH);// 获取月 从 0 - 11
    int month = calendar.get(Calendar.DAY_OF_MONTH);// 日
    int hour = calendar.get(Calendar.HOUR_OF_DAY);// HOUR_OF_DAY(24时制),HOUR(12时制)
    int minute = calendar.get(Calendar.MINUTE);// 分钟
    int second = calendar.get(Calendar.SECOND);// 秒
    // 3. 修改时间
    Calendar calendar2 = Calendar.getInstance();
    calendar2.set(Calendar.DAY_OF_MONTH, 22); //时间改为今月的22号
    // 4. add修改时间
    calendar2.add(Calendar.HOUR, 1); // 1为加1小时 -1为减1小时
    // 5. 补充方法
    int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);//31,月末一天
    int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);//1,月初一天
}

SimpleDateFormat

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

字母	日期或时间	示例
y	年	2019
M	年中月份	08
d	月中天数	10
H	一天中小时（0-23）	22
m	分钟	16
s	秒	59
S	毫秒	356

psvm(String[] args) throws Exception{
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 1. 创建对象
    Date date = new Date();// 2. 创建Date
    String str = sdf.format(date);//格式化date（日期->字符串）
    sout(str);//2021-01-23 16:28:49
    Date date2 = sdf.parse("2021-01-22 16:28:49");//解析(字符串->时间)若字符串不匹配创建对象时设定的格式就会抛出异常
    sout(date2);//Fri Jan 22 16:28:49 CST 2021
}

6.System类

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

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

psvm(String[] args){
    //arraycopy 复制
    //src-原数组 srcPos-从哪个位置开始复制0 dest-目标数组 destPos-目标数组的位置 length-复制的长度
    int[] arr = {20, 18, 15, 8, 35, 26, 45, 90};
    int[] dest = new int[8];
    //System.arraycopy(arr, 0, dest, 0, 8);
    System.arraycopy(arr, 4, dest, 4, 4)
    for(int i=0; i<dest.length; i++){ sout(dest[i]); }//0, 0, 0, 0, 35, 26, 45, 90

    //Arrays.copyOf(original, newLength)底层就是调用System.arraycopy(),System.arraycopy()再底层就是用C/C++实现的

    sout(System.currentTimeMillis());//可用于计算代码用时

    System.gc(); //前面 finalize() 方法已经演示

    System.exit(0);
}

Zhihong's Blog

java学习2 Java常用类最新教程通俗易懂

Java常用类最新教程通俗易懂

1.内部类

1.1.成员内部类

1.2.静态内部类

1.3.局部内部类

1.4.匿名内部类

2.Object 类

getClass() 方法

hashCode()方法

toString()方法

equals()方法

finalize() 方法

3.包装类

类型转换与装箱、拆箱

整数缓冲区

4.String 类

常用方法

案例演示

可变字符串

5.BigDecimal 类

Date 类

Calendar

SimpleDateFormat

6.System类

Java常用类最新教程 通俗易懂

1.内部类

1.1.成员内部类

1.2.静态内部类

1.3.局部内部类

1.4.匿名内部类

2.Object 类

getClass() 方法

hashCode()方法

toString()方法

equals()方法

finalize() 方法

3.包装类

类型转换与装箱、拆箱

整数缓冲区

4.String 类

常用方法

案例演示

可变字符串

5.BigDecimal 类

Date 类

Calendar

SimpleDateFormat

6.System类

Java常用类最新教程通俗易懂