Notas de estudo JAVA – coleção de classes comumente usadas

classe interna

Classe interna de membro, classe interna estática, classe interna local, classe interna anônima

Conceito: Definir uma classe completa dentro de uma classe

Características:

• Após a compilação, arquivos de bytecode independentes podem ser gerados
• Classes internas podem acessar diretamente membros privados de classes externas sem quebrar o encapsulamento
• Fornece componentes funcionais internos necessários para classes externas

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

classe interna membro

• Definido dentro de uma classe, uma classe no mesmo nível que variáveis ​​de instância e métodos de instância
• Uma instância que faz parte de uma classe externa.Ao criar um objeto de classe interno,ele deve contar com o objeto de classe externo.
• Quando houver atributos com o mesmo nome na classe externa e na classe interna, os atributos da classe interna serão acessados ​​primeiro.
• Membros estáticos não podem ser definidos em classes internas de membros e podem conter 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();
    }
}

classe interna estática

• Não depende de objetos de classe externos, pode ser criado diretamente ou acessado por meio de nomes de classes e membros estáticos podem ser declarados

//外部类
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();
    }
}

classe interna local

• Definido em um método de classe externo , o escopo e o escopo do objeto criado são limitados ao método atual
• Quando uma classe interna local acessa uma variável local no método atual de uma classe externa, a variável deve ser modificada para final porque não pode garantir que o ciclo de vida da variável seja igual a ela mesma.
• Limitar o escopo de uso de uma classe

//外部类
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();
    }
}

classe interna anônima

• Classe interna local sem nome de classe (todas as características são iguais à classe interna local)
• Deve herdar uma classe pai ou implementar uma interface
• A sintaxe de definição de classe, implementação de classe e criação de objeto é mesclada.Apenas um objeto desta classe pode ser criado.
• Vantagens: Reduza a quantidade de código
• Desvantagens: pouca legibilidade

//接口
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();
    }

classe interna anônima

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

Classe de objeto

• Superclasse, classe base, a classe pai direta ou indireta de todas as classes, localizada no nível superior da árvore de herança
• Qualquer classe que não escreva "estende" para indicar que herda uma determinada classe herdará diretamente da classe Object por padrão, caso contrário será herdada indiretamente.
• Os métodos definidos na classe Object são métodos que todos os objetos possuem
• O tipo Object pode armazenar qualquer objeto
  • Como parâmetro, qualquer objeto pode ser aceito
  • Como valor de retorno, qualquer objeto pode ser retornado

método getClass

• public final Class<?> getClass(){}
• Retorna o tipo de objeto real armazenado na referência
• Aplicação: Geralmente usado para determinar se os tipos de objetos armazenados reais em duas referências são 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 hashCode

• public int hashCode(){}
• Retorna o valor do código hash deste objeto
• O valor hash é um valor do tipo int calculado usando o algoritmo hash baseado no endereço, string ou número do objeto.
• Geralmente, o mesmo objeto retorna o mesmo 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(){}
• Retorna a representação em string (representação) deste objeto
• Este método pode ser substituído de acordo com os requisitos do programa, tais como: exibir cada valor de atributo do 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){}
• A implementação padrão é (this == obj), que compara se os endereços de dois objetos são iguais.
• Pode ser sobrescrito para comparar se o conteúdo de dois objetos é o mesmo

//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;
}

finalizar método

• Quando um objeto é determinado como lixo, esse método é chamado automaticamente pela JVM para marcar o objeto lixo e entrar na fila de reciclagem.
• Objeto lixo: Quando não há nenhuma referência válida apontando para este objeto, ele é um objeto lixo.
• Coleta de lixo: objetos de lixo são destruídos pelo gc e liberam espaço de armazenamento de dados
• Mecanismo de reciclagem automática: a memória da JVM se esgota e todos os objetos de lixo são reciclados de uma vez
• Mecanismo de reciclagem manual: Use **System.gc();** para notificar a JVM para realizar a coleta de lixo

@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对象被回收了
    }
}

Embalagem

• Tipos de dados de referência correspondentes a tipos de dados básicos
• O objeto pode unificar todos os dados e o valor padrão da classe wrapper é nulo.
• Tipos básicos e variáveis ​​locais existem no espaço de pilha e tipos de referência armazenam espaço de heap.

Tipos de dados básicos	tipo de embalagem
byte	Byte
curto	Curto
interno	Inteiro
longo	Longo
flutuador	Flutuador
dobro	Dobro
boleano	boleano
Caracteres	Personagem

Conversão de tipo, boxing e unboxing

• 8 classes wrapper fornecem métodos de conversão entre diferentes tipos

  • Seis métodos comuns fornecidos na classe pai Number

    2. parseXXX( )método estático

    3. valueOf( )método estático

• Nota: A compatibilidade de tipo deve ser garantida, caso contrário, uma NumberFormatException será lançada

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 inteiro

• Java pré-cria 256 objetos de tipo de empacotamento de certificado comumente usados
• Em aplicações reais, reutilize objetos criados

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);
        }
         */
    }

Classe de cordas

• Strings são constantes e não podem ser alteradas após a criação.
• Literais de string são armazenados em um pool de strings e podem ser compartilhados
• String s = "Hello";Gere um objeto e armazene-o no pool de strings
• String s = new String("Hello");Gere dois objetos, um para o heap e outro para o pool.

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 comuns

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,比较长度
    }
}

Apresentação do caso

precisar:

1. String conhecida str = “este é um texto”;
2. Obtenha as palavras em str individualmente
3. Substitua o texto em str por prática
4. Insira um texto fácil antes
5. Coloque a primeira letra de cada palavra em maiúscula

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 
        }
    }
}

string mutável

• StringBuffer: String de comprimento variável, operação lenta, thread-safe
• StringBuilder: pode estender strings, rodar rápido e não é seguro para threads
• Diferença de String
  1. Mais eficiente que String
  2. Economiza memória 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álise de eficiência de tempo

//开始时间
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

Classe BigDecimal

• Localização java.mathno pacote
• Função para calcular com precisão números de ponto flutuante
• Como criarBigDecimal 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);
}

Classe de dados

• A data representa um instante específico, com precisão de milissegundos. A maioria dos métodos da classe Date foram substituídos por métodos da classe Calendar
• Unidade de tempo: 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
}

Aula de calendário

• O Calendário fornece métodos para obter ou definir vários campos do calendário
• O construtor protected Calendar();não pode ser criado diretamente porque está protegido.
• Outros métodos

nome do método	ilustrar
Calendário estático getInstance()	Obtenha o calendário usando fuso horário e região padrão
void set(int ano, int mês, int data, int hora do dia, int minuto, int segundo)	Defina o ano, mês, dia, hora, minuto e segundo do calendário
int get(campo int)	Retorna o valor do campo de calendário fornecido. Campos como ano, mês, dia
void setTime (data data)	Define esta hora do calendário com a data especificada
Data getHora()	Retorna uma data que representa a hora deste calendário
void add(campo int, valor int)	Adicione ou subtraia a quantidade de tempo de um campo especificado de acordo com as regras do calendário
getTimeInMilles longo()	Retorna o valor do tempo deste calendário em milissegundos

    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
    }

Classe SimpleDateFormat

• SimpleDateFormat é uma classe concreta para formatar e analisar datas de maneira dependente da localidade
• Formato (data → texto), análise (texto → data)
• Letras de padrão de tempo comumente usadas

carta	data ou hora	Exemplo
sim	Ano	2019
08	mês do meio do ano	08
d	Dias do mês	10
H	Hora do dia (0-23)	22
eu	minuto	16
é	Segundo	59
S	milissegundo	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
    }

Classe do sistema

• Usado principalmente para obter dados de atributos do sistema e outras operações, o método de construção é privado

nome do método	ilustrar
cópia de array vazio estático(…)	copiar matriz
static longo currentTimeMillis();	Obtenha a hora atual do sistema e retorne o valor em milissegundos
vazio estático gc();	Recomenda-se que a JVM inicie rapidamente o período de coleta de lixo para coletar o lixo.
saída vazia estática (status int);	Saia do jvm. Se o parâmetro for 0, significa sair do jvm normalmente. Se não for 0, significa sair 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("---程序结束---");
    }