Notas de estudio de JAVA: colección de clases de uso común

clase interna

Clase interna miembro, clase interna estática, clase interna local, clase interna anónima

Concepto: definir una clase completa dentro de una clase

Características:

• Después de la compilación, se pueden generar archivos de código de bytes independientes.
• Las clases internas pueden acceder directamente a miembros privados de clases externas sin romper la encapsulación.
• Proporciona los componentes funcionales internos necesarios a las clases externas.

//身体
public class Body {
    
    
    private String name;
    //头部
    class Header{
    
    
      	//也会生成class文件 同时生成构造函数
      	//可以直接访问外部类私有成员
        public void showName(){
    
    
            System.out.println(name);
        }
    }
}

clase interna miembro

• Definido dentro de una clase, una clase al mismo nivel que las variables de instancia y los métodos de instancia.
• Una instancia que forma parte de una clase externa. Al crear un objeto de clase interna, debe confiar en el objeto de clase externa.
• Cuando hay atributos con el mismo nombre en la clase externa y en la clase interna, se accederá primero a los atributos de la clase interna.
• Los miembros estáticos no se pueden definir en clases internas de miembros y pueden contener constantes estáticas (final)

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

    //内部类
    class Inner{
    
    
        private String address = "北京";
        private String phone = "110";
        private String name = "李四";
        //方法
        public void show(){
    
    
            //打印外部类属性 此时有重名属性name
            System.out.println(Outer.this.name); // 张三
            System.out.println(age);
            //打印内部类中的属性
            System.out.println(name); // 李四
            System.out.println(address);
            System.out.println(phone);
        }
    }
}

public class TestOuter {
    
    
    public static void main(String[] args) {
    
    
        // 创建外部类对象
        Outer outer = new Outer();
        // 创建内部类对象
        Outer.Inner inner = outer.new Inner();

        //一步到位
        Outer.Inner inner1 = new Outer().new Inner();
        inner1.show();
    }
}

clase interna estática

• No depende de objetos de clase externos, se puede crear directamente o acceder a través de nombres de clase y se pueden declarar miembros estáticos.

//外部类
public class Outer {
    
    
    private String name = "张三";
    private int age = 18;

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

        public void show() {
    
    
            //调用外部类属性
            //1.先创建外部类对象
            Outer outer = new Outer();
            //2.调用外部类对象的属性
            System.out.println(outer.name);
            System.out.println(outer.age);
            //调用静态内部类属性
            System.out.println(address);
            System.out.println(phone);
            //调用静态内部类的静态属性
            System.out.println(Inner.count);
        }
    }

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

clase interna local

• Definido en un método de clase externo , el alcance y el alcance del objeto creado están limitados al método actual.
• Cuando una clase interna local accede a una variable local en el método actual de una clase externa, la variable debe modificarse a final porque no se puede garantizar que el ciclo de vida de la variable sea el mismo que ella misma.
• Limitar el alcance de uso de una clase.

//外部类
public class Outer {
    
    
    private String name = "刘德华";
    private int age = 20;

    public void show() {
    
    
        //定义局部变量
        final String address = "深圳";
        //局部内部类 注意：不可以添加任何访问修饰符
        class Inner {
    
    
            //局部内部类的属性
            private String phone = "158";
            private String email = "[email protected]";

            public void show2() {
    
    
                //访问外部类的属性
                System.out.println(Outer.this.name);
                System.out.println(Outer.this.age);
                //访问内部类的属性
                System.out.println(this.phone);
                System.out.println(this.email);
                //访问局部变量,jdk1.7要求，变量必须是常量，jdk1.8 自动添加final
                System.out.println(address);
            }
        }
        //创建局部内部类对象
        Inner inner = new Inner();
        inner.show2();
    }
}

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

clase interna anónima

• Clase interna local sin nombre de clase (todas las características son las mismas que las de la clase interna local)
• Debe heredar una clase principal o implementar una interfaz
• La sintaxis de definir una clase, implementar una clase y crear un objeto se fusiona y solo se puede crear un objeto de esta clase.
• Ventajas: Reducir la cantidad de código.
• Desventajas: mala legibilidad

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

public class Mouse implements USB{
    
    
    @Override
    public void service() {
    
    
        System.out.println("连接电脑成功，鼠标开始工作");
    }
}

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

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

clase interna anónima

public class TestUsb {
    
    
//使用匿名内部类(相当于创建了一个局部内部类)
        USB usb = new USB() {
    
    
            @Override
            public void service() {
    
    
                System.out.println("连接电脑成功，风扇开始工作");
            }
        };
        usb.service();
}

Clase de objeto

• Superclase, clase base, la clase principal directa o indirecta de todas las clases, ubicada en el nivel superior del árbol de herencia.
• Cualquier clase que no escriba "extiende" para indicar que hereda una determinada clase heredará directamente de la clase Objeto de forma predeterminada; de lo contrario, se heredará indirectamente.
• Los métodos definidos en la clase Objeto son métodos que todos los objetos tienen.
• El tipo de objeto puede almacenar cualquier objeto.
  • Como parámetro se puede aceptar cualquier objeto.
  • Como valor de retorno, se puede devolver cualquier objeto.

método getClass

• public final Class<?> getClass(){}
• Devuelve el tipo de objeto real almacenado en la referencia.
• Aplicación: generalmente se usa para determinar si los tipos de objetos almacenados reales en dos referencias son consistentes.

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

método de código hash

• public int hashCode(){}
• Devuelve el valor del código hash de este objeto.
• El valor hash es un valor de tipo int calculado utilizando el algoritmo hash basado en la dirección, cadena o número del objeto.
• Generalmente, el mismo objeto devuelve el mismo código hash.

//hashCode方法
Student s3=s1;
System.out.println(s1.hashCode());//356573597
System.out.println(s2.hashCode());//1735600054
System.out.println(s3.hashCode());//356573597

método toString

• public String toSring(){}
• Devuelve la representación de cadena (representación) de este objeto.
• Este método se puede anular según los requisitos del programa, como por ejemplo: mostrar cada valor de atributo del objeto

//3. toString方法
System.out.println(s1.toString());//Demo07.Student@1540e19d
System.out.println(s2.toString());//Demo07.Student@677327b6

//原码
public String toString() {
    
    
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

@Override
    public String toString() {
    
    
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
}

método igual

• public boolean equals(Object obj){}
• La implementación predeterminada es (this == obj), que compara si las direcciones de dos objetos son las mismas.
• Se puede sobrescribir para comparar si el contenido de dos objetos es el mismo

//4. equals方法 判断两个对象是否相等
System.out.println(s1.equals(s2)); // false
Student s4 = new Student("小明", 17);
Student s5 = new Student("小明", 17);
System.out.println(s4.equals(s5)); // false 堆中地址不同


// 重写 改变其比较内容
/*
步骤  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()){
    
    
  //
  // }
  // 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;
}

método de finalización

• Cuando se determina que un objeto es un objeto basura, la JVM llama automáticamente a este método para marcar el objeto basura e ingresar a la cola de reciclaje.
• Objeto basura: cuando no hay una referencia válida que apunte a este objeto, es un objeto basura.
• Recolección de basura: gc destruye los objetos basura y libera espacio de almacenamiento de datos
• Mecanismo de reciclaje automático: la memoria de la JVM se agota y todos los objetos basura se reciclan a la vez.
• Mecanismo de reciclaje manual: use **System.gc();** para notificar a la JVM que realice la recolección de basura

@Override
protected void finalize() throws Throwable{
    
    
  sout(this.name + "对象被回收了");
}
//测试类
public class TestStudent2 {
    
    
    public static void main(String[] args) {
    
    
        Student s1 = new Student("aaa", 29); // 不是垃圾
        Student s2 = new Student("bbb", 29); // 不是垃圾
        Student s3 = new Student("ccc", 29); // 不是垃圾
        Student s4 = new Student("ddd", 29); // 不是垃圾
        Student s5 = new Student("eee", 29); // 不是垃圾
        new Student("bbb", 30); // 是垃圾 会被回收
        //回收垃圾
        System.gc();
        System.out.println("回收垃圾");
        // 打印出 “回收垃圾
        // bbb对象被回收了
    }
}

embalaje

• Tipos de datos de referencia correspondientes a tipos de datos básicos
• El objeto puede unificar todos los datos y el valor predeterminado de la clase contenedora es nulo.
• Los tipos básicos y las variables locales existen en el espacio de la pila, y los tipos de referencia almacenan el espacio del montón.

Tipos de datos básicos	tipo de embalaje
byte	Byte
corto	Corto
En t	Entero
largo	Largo
flotar	Flotar
doble	Doble
booleano	Booleano
carbonizarse	Personaje

Conversión de tipo, boxeo y unboxing.

• 8 clases contenedoras proporcionan métodos de conversión entre diferentes tipos

  • Seis métodos comunes proporcionados en la clase principal Number

    2. parseXXX( )método estático

    3. valueOf( )método estático

• Nota: Se debe garantizar la compatibilidad de tipos; de lo contrario, se generará una excepción 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;
  // 自动拆箱
  int age2 = integer4;
  
  // 基本类型和字符串之间转换
  // 1. 基本类型转成字符串
  int n1 = 100;
  // 1.1 使用+号
  String s1 = n1 + "";
  // 1.2 使用Integer中的toString()方法
  String s2 = Integer.toString(n1);
  String s2 = Integer.toString(n1, x); // x为进制要求
  String s3 = Integer.toBinaryString(n1);//转换成二进制
  
  // 2. 字符串转成基本类型
  String str = "150";
  // 使用Integer.parseXXX();
  int n2 = Integer.parseInt(str);
  
  // boolean 字符串形式转成基本类型，"true" ---> true 非“true ———> false
  String str2 = "true";
  boolean b1 = Boolean.parseBoolean(str2);
}

buffer de enteros

• Java crea previamente 256 objetos de tipo empaquetado de certificados de uso común
• En aplicaciones reales, reutilice los objetos creados.

public static void main(String[] args) {
    
    
        //面试题
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1 == integer2);//false

        Integer integer3 = 100;// 自动装箱
        // 相当于调用 Integer.valueOf(100);
        Integer integer4 = 100;
        System.out.println(integer3 == integer4);//true

        Integer integer5 = 200;// 自动装箱
        Integer integer6 = 200;
        System.out.println(integer5==integer6);//false
        //valueOf 方法
        // 因为缓存区数组 [-128, 127] 在这之内地址一样
        // 不在cache数组区间内 则 new Integer(i);
        /*
        public static Integer valueOf(int i) {
            if (i >= Integer.IntegerCache.low && i <= Integer.IntegerCache.high)
                return Integer.IntegerCache.cache[i + (-Integer.IntegerCache.low)];
            return new Integer(i);
        }
         */
    }

clase de cadena

• Las cadenas son constantes y no se pueden cambiar después de su creación.
• Los literales de cadena se almacenan en un grupo de cadenas y se pueden compartir
• String s = "Hello";Genere un objeto y guárdelo en el grupo de cadenas.
• String s = new String("Hello");Genere dos objetos, uno para el montón y otro para el grupo.

public static void main(String[] args) {
    
    
        //产生一个对象，字符串池中存储
        String name = "hello";//"hello" 常量存储在字符串池中
        //不可变性
        name = "zhansgan"; // "张三"赋值给name,给字符串赋值是没有修改数据
        //不是将字符串池中"hello"的值更改，而是重新在字符串池中开辟新的空间
        System.out.println(name);

        String name2 = "zhangsan";//指向原来字符串池中的"zhansgan"
        //字符串字面值存储在字符串池中，可以共享

        //演示字符串的另一种创建方式
        // 产生两个对象，堆、池各一个
        String str1 = new String("java");
        String str2 = new String("java");
        System.out.println(str1==str2);//false
}

Métodos comunes

public class Demo11 {
    
    
    public static void main(String[] args) {
    
    
        // 1. length(); 返回字符串长度
        // 2. charAt(int index); 返回某个位置的字符
        // 3. contains(String str); 判断是否包含某个字符串
        String content = "java是最好的语言";
        System.out.println(content.length());//10
        System.out.println(content.charAt(1));//a
        System.out.println(content.contains("java"));//true

        // 4. toCharArray(); 返回字符串对应数组
        // 5. indexOf(); 返回子字符串首次出现的位置
        // 6. lastIndexOf(); 返回字符串最后一次出现的位置
        char[] str = content.toCharArray();
        System.out.println(str[1]);//a
        System.out.println(content.toCharArray());//java是最好的语言
        System.out.println(Arrays.toString(content.toCharArray()));//[j, a, v, a, 是, 最, 好, 的, 语, 言]
        System.out.println(content.indexOf("ava"));//1
        System.out.println(content.indexOf("ava", 4));//从索引4开始找 返回-1
        System.out.println(content.lastIndexOf("java"));//0

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

        // 10. replace(char old, char new); 用心的字符或字符串替换旧的字符或字符串
        // 11. split(); 对字符串拆分
        System.out.println(ct.replace("hello", "fuck"));// fuck world
        String say = "java is the best language";
        String[] arr = say.split(" ");// "[ ,]+" 表示空格 逗号切分 +号表示切分可以多个 比如多个空格
        for (String s : arr) {
    
    
            System.out.println(s);
        }
        /* 打印
        java
        is
        the
        best
        language
         */

        // 补充两个equals/compareTo();比较大小
        String s1 = "hello";
        String s2 = "HELLO";
        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equalsIgnoreCase(s2));// 忽略大小写比较true

        // compareTo(); 两字符不同时比较字符字典序的ascii码
        // 字符相同时比较长度 返回差值
        String s3 = "abc";//97
        String s4 = "xyzaa";//120
        System.out.println(s3.compareTo(s4));//-23

        String s5 = "abc";//97
        String s6 = "abcxyz";//120
        System.out.println(s5.compareTo(s6));//-3,比较长度
    }
}

Presentación del caso

necesidad:

1. Cadena conocida str = “este es un texto”;
2. Obtener las palabras en str individualmente
3. Reemplazar texto en str con práctica
4. Insertar un texto fácil antes
5. Poner en mayúscula la primera letra de cada palabra.

public class Demo12 {
    
    
    public static void main(String[] args) {
    
    
        //1.将str中的单词单独获取
        String str = "this is a text";
        String[] arr = str.split(" ");
        for (String s : arr) {
    
    
            System.out.println(s);
        }
        //2.将str中的text替换成practice
        String str2 = str.replace("text", "practice");
        System.out.println(str2);//this is a practice
        //3.在text前面插入一个easy
        String str3 = str.replace("text", "easy text");
        System.out.println(str3);//this is a easy text
        //4.将每个单词的首字母改为大写
        for (int i = 0; i < arr.length; i++) {
    
    
            char first = arr[i].charAt(0);
            char upperFirst = Character.toUpperCase(first);
            String news = upperFirst + arr[i].substring(1); //substring 截取，开始脚标
            System.out.print(news + " ");//This Is A Text 
        }
    }
}

cadena mutable

• StringBuffer: cadena de longitud variable, funcionamiento lento, seguro para subprocesos
• StringBuilder: puede extender cadenas, se ejecuta rápido y no es seguro para subprocesos
• Diferencia de cadena
  1. Más eficiente que String
  2. Ahorra memoria que String

public static void main(String[] args) {
    
    
        // StringBuffer 和 StringBuilder 用法一致
        StringBuffer sb = new StringBuffer();
        // 1. append(); 追加
        sb.append("java");
        System.out.println(sb.toString());//java
        // 2. insert(); 添加、插入
        sb.insert(0, "在第一个位置插入");
        System.out.println(sb.toString());//在第一个位置插入java
        // 3.replace(); 替换
        sb.replace(0, 3, "hello"); // 左闭右开
        System.out.println(sb.toString());//hello个位置插入java
        // 4. delete(); 删除
        sb.delete(0, 5); // 左闭右开
        System.out.println(sb.toString());
        // 5. 反转
        sb.reverse();
        System.out.println(sb.toString());
        // 6. 清空
        sb.delete(0, sb.length());
        System.out.println(sb.toString());
}

Análisis de eficiencia del tiempo.

//开始时间
long start = System.currentTimeMillis();
String string = "";
for (int i = 0; i < 9999; i++) {
    
    
	string += i+" ";
}
System.out.println(string);
long end = System.currentTimeMillis();
System.out.println("用时："+(end-start));//用时：514

long start2 = System.currentTimeMillis();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 9999; i++) {
    
    
	sb.append(i);
}
System.out.println(sb.toString());
long end2 = System.currentTimeMillis();
System.out.println("用时："+(end2-start2));//用时：2

Clase BigDecimal

• Ubicación java.mathen el paquete
• Función para calcular con precisión números de coma flotante
• Como crearBigDecimal bd = new BigDecimal("1.0");

public static void main(String[] args) {
    
    
        double d1 = 1.0;
        double d2 = 0.9;
        System.out.println(d1 - d2);//0.09999999999999998
        //面试题
        double result = (1.4 - 0.5) / 0.9;
        System.out.println(result);//0.9999999999999999
        //BigDecimal ,大的浮点数精确计算
        BigDecimal bd1 = new BigDecimal("1.0");//需要用字符串
        BigDecimal bd2 = new BigDecimal("0.9");
        // 减法
        BigDecimal r1 = bd1.subtract(bd2);
        System.out.println(r1);//0.1
        //加法
        BigDecimal r2 = bd1.add(bd2);
        System.out.println(r2);
        //乘法
        BigDecimal r3 = bd1.multiply(bd2);
        System.out.println(r3);
        //除法
        BigDecimal r4 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"));
        System.out.println(r4);
        //除不尽时 x填保留位数 后面为四舍五入之意
        BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_EVEN);//3.33
        System.out.println(r5);
}

clase de datos

• La fecha representa un instante específico, con una precisión de milisegundos. La mayoría de los métodos de la clase Fecha han sido reemplazados por métodos de la clase Calendario.
• Unidad de tiempo: 1s = 1.000ms = 1.000.000 μs = 1.000.000.000 = ns

public static void main(String[] args) {
    
    
        // 1 创建Date对象
        //今天
        Date date1 = new Date();
        System.out.println(date1.toString());//Fri Jan 06 21:15:33 CST 2023
        System.out.println(date1.toLocaleString());//2023-1-6 21:16:01
        //昨天
        Date date2 = new Date(date1.getTime()-1000*60*60*24);
        System.out.println(date2.toLocaleString());//2023-1-5 21:17:08

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

        // 比较compareTo();
        int d = date1.compareTo(date2);
        System.out.println(d); // 多的为1 少的为 -1

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

clase de calendario

• Calendario proporciona métodos para obtener o configurar varios campos del calendario
• El constructor protected Calendar();no se puede crear directamente porque está protegido.
• Otros metodos

nombre del método	ilustrar
Calendario estático getInstance()	Obtener calendario usando la zona horaria y la región predeterminadas
conjunto vacío (int año, int mes, int fecha, int hora del día, int minuto, int segundo)	Establecer el año, mes, día, hora, minuto y segundo del calendario
int get(campo int)	Devuelve el valor del campo de calendario dado. Campos como año, mes, día.
void setTime(Fecha fecha)	Establece esta hora del calendario con la fecha dada.
Fecha obtener hora()	Devuelve una fecha que representa la hora de este calendario.
anular agregar (campo int, cantidad int)	Sumar o restar la cantidad de tiempo a un campo específico de acuerdo con las reglas del calendario
largo getTimeInMilles()	Devuelve el valor de tiempo de este calendario en milisegundos.

    public static void main(String[] args) {
    
    
        // 1. 创建 Calendar 对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());//2023-1-6 21:50:13
        System.out.println(calendar.getTimeInMillis());//1673013029291
        // 2. 获取时间信息
        // 获取年
        int year = calendar.get(Calendar.YEAR);//2023
        // 获取月 从 0 - 11
        int month = calendar.get(Calendar.MONTH);//0
        // 日
        int day = calendar.get(Calendar.DAY_OF_MONTH);//6
        //小时
        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);
        //2023年01月6日 21:55:36
        System.out.println(year + "年" + month + 1 + "月" + day + "日 " + hour + ":" + minute + ":" + second);
        // 3. 修改时间
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH, 5);
        System.out.println(calendar2.getTime().toLocaleString());//2023-1-5 21:57:02
        // 4. add修改时间
        calendar2.add(Calendar.HOUR, 1); // x为正就加 负就减
        System.out.println(calendar2.getTime().toLocaleString());//2023-1-5 22:57:40
        // 5. 补充方法
        int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);// 月数最大天数 31
        int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);//1
    }

Clase SimpleDateFormat

• SimpleDateFormat es una clase concreta para formatear y analizar fechas de manera dependiente de la configuración regional.
• Formato (fecha → texto), análisis (texto → fecha)
• Letras de patrones de tiempo de uso común

carta	fecha u hora	Ejemplo
y	Año	2019
08	mes de mitad de año	08
d	dias en el mes	10
h	Hora del día (0-23)	22
metro	minuto	dieciséis
s	Segundo	59
S	milisegundo	356

public static void main(String[] args) {
    
    
        // 1. 创建对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd");
        // 2. 创建Date
        Date date = new Date();
        // 格式化date（日期→字符串）
        String str = sdf.format(date);
        System.out.println(str);//2023年01月06日 22:07:41
        // 解析（字符串→时间）
        Date date2 = null;
        try {
    
    
            date2 = sdf.parse("2001年2月24日 10:24:55");
        } catch (ParseException e) {
    
    
            e.printStackTrace();
        }
        System.out.println(date2);//Sat Feb 24 10:24:55 CST 2001
    }

clase de sistema

• Se utiliza principalmente para obtener datos de atributos del sistema y otras operaciones, el método de construcción es privado.

nombre del método	ilustrar
copia de matriz vacía estática (…)	copiar matriz
estático largo currentTimeMillis();	Obtenga la hora actual del sistema y devuelva el valor de milisegundos
vacío estático gc();	Se recomienda que la jvm inicie rápidamente el período de recolección de basura para recolectar basura.
salida de vacío estático (estado int);	Salga de jvm. Si el parámetro es 0, significa salir de jvm normalmente. Si no es 0, significa salir de forma anormal.

    public static void main(String[] args) {
    
    
        //1. arraycopy 数组的复制
        //src-原数组 srcPos-从哪个位置开始复制0 dest-目标数组 destPos-目标数组的位置 length-复制的长度
        int[] arr = {
    
    20, 18, 15, 8, 35, 26, 45, 90};
        int[] dest = new int[8];
        //System.arraycopy(src, srcPos, dest, destPos, length);
        System.arraycopy(arr, 0, dest, 0, arr.length - 1);
        for (int i : dest) {
    
    
            System.out.print(i + " ");
        }
        //20 18 15 8 35 26 45 0
        // Arrays.copyOf(original, newLength)
        System.out.println(System.currentTimeMillis());//1673014964891

        //2. currentTimeMillis()
        long start = System.currentTimeMillis();
        for (int i = 0; i < 999999; i++) {
    
    
            for (int j = 0; j < 999999; j++) {
    
    
                int result = i+j;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("用时："+(end-start));//用时：10

        //3. gc() 垃圾回收期器回收垃圾
        System.gc();

        //4. exit() 退出jvm 如果参数是0表示正常退出jvm 非0表示异常退出
        System.exit(0);
        System.out.println("---程序结束---");
    }