Notas de estudio de Java (13) Capítulo 13 - Clases comunes

13.1 Clases de contenedor

13.1.1 Clasificación de clases de empaque, conversión de clases de empaque y datos básicos, demostraciones de casos, pruebas en el aula

• 1. Clasificación de los envases

WrapperType.java

1. Tipos de referencia correspondientes para los ocho tipos de datos básicos: clases contenedoras
2. Con las características de la clase, puede llamar al método en la clase.
3. Como se muestra en la imagen:
   
   
   
   

• 2. Conversión entre clases contenedoras y datos básicos
  Demostrar la conversión mutua entre clases contenedoras y tipos de datos básicos Aquí, int y Integer se usan para demostrar.
  (1) Encajonado y desempaquetado manual antes de jdk5, encajonado: tipo básico -> tipo de empaque, de lo contrario, desempaquetado
  (2) Encajonado y desempaquetado automático después de jdk5 (incluido jdk5)
  (3) Encajonado automático La capa inferior de la caja llama al método valueOf , como Integer.valueof
  (4) El uso de otras clases de empaquetado es similar, por lo que no daré ejemplos uno por uno

• 3. Caso de demostración
  Integer01.java

public class Integer01 {
    
    
    public static void main(String[] args) {
    
    
        //演示int <--> Integer 的装箱和拆箱
        //jdk5前是手动装箱和拆箱
        //手动装箱 int->Integer
        int n1 = 100;
        Integer integer = new Integer(n1);
        Integer integer1 = Integer.valueOf(n1);

        //手动拆箱
        //Integer -> int
        int i = integer.intValue();

        //jdk5后，就可以自动装箱和自动拆箱
        int n2 = 200;
        //自动装箱 int->Integer
        Integer integer2 = n2; //底层使用的是 Integer.valueOf(n2)
        //自动拆箱 Integer->int
        int n3 = integer2; //底层仍然使用的是 intValue()方法
    }
}

• 4. Prueba en el aula

¿Es correcto el siguiente código? Si es correcto, ¿cuál es la salida?

13.1.2 Conversión mutua entre tipo de empaque y tipo String

WrapperVSString.java

Demostración de caso, tome la conversión de enteros y cadenas como ejemplo, otros son similares:

public class WrapperVSString {
    
    
    public static void main(String[] args) {
    
    
        //包装类(Integer)->String
        Integer i = 100;//自动装箱
        //方式1
        String str1 = i + "";//i本身没有变化
        //方式2
        String str2 = i.toString();
        //方式3
        String str3 = String.valueOf(i);

        //String -> 包装类(Integer)
        String str4 = "12345";
        Integer i2 = Integer.parseInt(str4);//使用到自动装箱
        Integer i3 = new Integer(str4);//用构造器,Interger里边构造器挺多

        System.out.println("ok~~");
    }
}

13.1.3 Métodos comunes de la clase Integer y la clase Character

La clase WrapperMethod.java
Integer y Character tienen algunos métodos comunes, usémoslos juntos.

public class WrapperMethod {
    
    
    public static void main(String[] args) {
    
    
        System.out.println(Integer.MIN_VALUE); //返回最小值
        System.out.println(Integer.MAX_VALUE);//返回最大值

        System.out.println(Character.isDigit('a'));//判断是不是数字
        System.out.println(Character.isLetter('a'));//判断是不是字母
        System.out.println(Character.isUpperCase('a'));//判断是不是大写
        System.out.println(Character.isLowerCase('a'));//判断是不是小写

        System.out.println(Character.isWhitespace('a'));//判断是不是空格
        System.out.println(Character.toUpperCase('a'));//转成大写
        System.out.println(Character.toLowerCase('A'));//转成小写
    }
}

13.1.4 Preguntas de entrevista de clase entera

• Pregunta 1

  WrapperExercise02.java
  Mire el siguiente código, ¿cuál es el resultado? ¿Por qué? 2 min
  

public class WrapperExercise02 {
    
    
    public static void main(String[] args) {
    
    
        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i == j);  //False
        //所以，这里主要是看范围 -128 ~ 127 就是直接返回
        /*
        解读
        //1. 如果i 在 IntegerCache.low(-128)~IntegerCache.high(127),就直接从数组返回
        //2. 如果不在 -128~127,就直接 new Integer(i)
         public static Integer valueOf(int i) { 源码
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }
         */
        Integer m = 1; //底层 Integer.valueOf(1); -> 阅读源码
        Integer n = 1;//底层 Integer.valueOf(1);
        System.out.println(m == n); //T
        //所以，这里主要是看范围 -128 ~ 127 就是直接返回
        //，否则，就new Integer(xx);
        Integer x = 128;//底层Integer.valueOf(1);
        Integer y = 128;//底层Integer.valueOf(1);
        System.out.println(x == y);//False
    }
}

• Pregunta 2

  Eche un vistazo al siguiente código para ver qué resultados se muestran.
  Nota: siempre que haya tipos de datos básicos, el juicio es si los valores son los mismos

public class WrapperExercise03 {
    
    
    public static void main(String[] args) {
    
    
        //示例一
        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        System.out.println(i1 == i2);//F
//示例二
        Integer i3 = new Integer(128);
        Integer i4 = new Integer(128);
        System.out.println(i3 == i4);//F

//示例三
        Integer i5 = 127;//底层Integer.valueOf(127)
        Integer i6 = 127;//-128~127
        System.out.println(i5 == i6); //T
//示例四
        Integer i7 = 128;
        Integer i8 = 128;
        System.out.println(i7 == i8);//F
//示例五
        Integer i9 = 127; //Integer.valueOf(127)
        Integer i10 = new Integer(127);
        System.out.println(i9 == i10);//F

        //示例六
        Integer i11=127;
        int i12=127;
//只要有基本数据类型，判断的是值是否相同
        System.out.println(i11==i12); //T
//示例七
        Integer i13=128;
        int i14=128;
        System.out.println(i13==i14);//T
    }
}

13.2 La clase de cadena

13.2.1 Comprender y crear objetos de la clase String

cadena01.java

1. El objeto String se utiliza para guardar una cadena, es decir, un conjunto de secuencias de caracteres
2. Un objeto constante de cadena es una secuencia de caracteres entre comillas dobles. Por ejemplo: "Hola", "12.97", "chico", etc.
3. Los caracteres de la cadena utilizan la codificación de caracteres Unicode y un carácter (no distingue entre letras y caracteres chinos) ocupa dos bytes.
4. Constructores más utilizados para la clase String (consulte el manual para otros):
   String s1 = new String();
   String s2 = new String(String original);
   String s3 = new String(char [ ] a);
   String s4 = new String(char [ ] a,int startIndex,int count)
   String s5 = new String(byte [ ] b);

Explicación:

Después de realizar la serialización, se puede transmitir en la red.

Nota:
1. El objeto String se utiliza para guardar una cadena, es decir, un conjunto de secuencias de caracteres
2. "jack" es una constante de cadena, una secuencia de caracteres entre comillas dobles
3. Los caracteres de una cadena utilizan la codificación de caracteres Unicode , un carácter (no distingue letras o caracteres chinos) ocupa dos bytes
4. La clase String tiene muchos constructores, y la sobrecarga de los constructores
se usa comúnmente: String s1 = new String();
String s2 = new String(String original );
String s3 = new String(char[] a);
String s4 = new String(char[] a,int startIndex,int count)
String s5 = new String(byte[] b)
5. La clase String implementa la interfaz Serializable【La cadena se puede serializar: Sí En la transmisión de red]
interfaz Comparable [Los objetos de cadena se pueden comparar en tamaño]
6. La cadena es una clase final y no puede ser heredada por otras clases
7. La cadena tiene un atributo valor de carácter final privado[]; se utiliza para almacenar el contenido de la cadena. La esencia de una cadena sigue siendo una matriz de caracteres
8. Debe tenerse en cuenta que el valor es un tipo final y no se puede modificar (la comprensión real requiere habilidad): es decir, el valor no puede apuntar a una nueva dirección, pero el contenido de un se puede cambiar un solo carácter

public class String01 {
    
    
    public static void main(String[] args) {
    
    
        //1.String 对象用于保存字符串，也就是一组字符序列
        //2. "jack" 字符串常量, 双引号括起的字符序列
        //3. 字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占两个字节
        //4. String 类有很多构造器，构造器的重载
        //   常用的有 String  s1 = new String(); //
        //String  s2 = new String(String original);
        //String  s3 = new String(char[] a);
        //String  s4 =  new String(char[] a,int startIndex,int count)
        //String s5 = new String(byte[] b)
        //5. String 类实现了接口 Serializable【String 可以串行化:可以在网络传输】
        //                 接口 Comparable [String 对象可以比较大小]
        //6. String 是final 类，不能被其他的类继承
        //7. String 有属性 private final char value[]; 用于存放字符串内容
		// 8. 一定要注意：value 是一个final类型，不可以修改(真正理解需要功力)：
 		//  即value不能指向新的地址，但是单个字符内容是可以变化

        String name = "jack"; //jack是常量
        name = "tom"; //name还可以指向tom，不是常量
        
        final char[] value = {
    
    'a','b','c'};
        char[] v2 = {
    
    't','o','m'};
        value[0] = 'H';
        //value = v2; 报错，因为不可以修改 value地址
    }
}

13.2.2 Dos formas de crear un objeto String y la diferencia entre las dos formas

13.2.3 Preguntas de la prueba en el aula

• Pregunta 1
  
  
• Pregunta 2
  
• Pregunta 3

Entre ellos, System.out.println(b==b.intern());b apunta al montón y b.intern apunta a la dirección del conjunto de constantes.

• Pregunta 4
  
• Pregunta 5
  

13.3 Propiedades de las cadenas

13.3.1 Descripción

1. String es una clase final que representa una secuencia inmutable de caracteres
2. Las cadenas son inmutables. Una vez que se asigna un objeto String, su contenido es inmutable.
3. ¿Cuántos objetos se crean con la siguiente declaración?Dibuje un diagrama de diseño de memoria.
   String s1 = "hola";
   s1 = "jaja"; //Crear 2 objetos.
   Debido a que no hay jaja en el grupo constante, se creará y se apuntará.

13.3.2 Preguntas de la entrevista

• Pregunta 1
  
• Pregunta 2
  
  

public class StringExercise08 {
    
    
    public static void main(String[] args) {
    
    
        String a = "hello"; //创建 a对象
        String b = "abc";//创建 b对象
        //解读，用debug一步一步看
        //1. 先 创建一个 StringBuilder sb = StringBuilder()
        //2. 执行  sb.append("hello");
        //3. sb.append("abc");
        //4. String c= sb.toString()
        //最后其实是 c 指向堆中的对象(String) value[] -> 池中 "helloabc"
        String c = a + b;
        String d = "helloabc";
        System.out.println(c == d);//真还是假? 是false，因为d是直接指向池，c指向堆
        String e = "hello" + "abc";//常量相加，直接看池， e指向常量池
        System.out.println(d == e);//真还是假? 是true
    }
}

• Pregunta 3
  ¿Qué genera el siguiente código y explica por qué?

Strings1 = "hspedu";
String s2 = "java' ;
String s5 = "hspedujava"; 
String s6 = (s1 + s2).intern();
System.out.println(s5 == s6);
System.out.println(s5.equals(s6));

Respuesta: Si no entiende .intern(), consulte la tercera pregunta de 13.2.3 en esta sección

• Pregunta 4
  

Respuesta: hspand, hava
Nota:
el java de ch es una matriz, y la matriz se coloca en el montón de forma predeterminada.
Llamar a un método generará una nueva pila.
str=“java", la cadena en la nueva pila ya no apunta a la cadena en el montón, sino que vuelve a apuntar a java en el grupo. Después de
ejecutar la última declaración en el método, la pila recién abierta se destruye y regresa a la pila principal El ex.str en System.out.println(ex.str+"and") en la pila principal todavía se refiere al str en el montón.

No entiendo Mira el video de Han Shunping en la sección 0470.

13.4 Métodos comunes de la clase String

13.4.1 Descripción

La clase String contiene constantes de cadena. Cada actualización necesita abrir espacio nuevamente, lo cual es ineficiente, por lo que el diseñador de Java también proporciona StringBuilder y StringBuffer para mejorar la función de String y mejorar la eficiencia. [Presentaremos StringBuilder y StringBuffer en detalle más adelante]

Mire este código, cada vez que el ciclo for tiene que volver a abrir el espacio, la eficiencia es baja

String s = new String("");
for( int i= o; i< 80000; i++){
    
    
s += "hello";
}

13.4.2 Lista de métodos comunes de la clase String

• El primer grupo:
  código de demostración:

public class StringMethod01 {
    
    
    public static void main(String[] args) {
    
    
        //1. equals 前面已经讲过了. 比较内容是否相同，区分大小写
        String str1 = "hello";
        String str2 = "Hello";
        System.out.println(str1.equals(str2));// False

        // 2.equalsIgnoreCase 忽略大小写的判断内容是否相等
        String username = "johN";
        if ("john".equalsIgnoreCase(username)) {
    
    
            System.out.println("Success!");
        } else {
    
    
            System.out.println("Failure!");
        }
        // 3.length 获取字符的个数，字符串的长度
        System.out.println("南昌大学".length()); // 4
        // 4.indexOf 获取字符在字符串对象中第一次出现的索引，索引从0开始，如果找不到，返回-1
        String s1 = "wer@terwe@g";
        int index = s1.indexOf('@');
        System.out.println(index);// 3
        System.out.println("weIndex=" + s1.indexOf("we"));//0
        // 5.lastIndexOf 获取字符在字符串中最后一次出现的索引，索引从0开始，如果找不到，返回-1
        s1 = "wer@terwe@g@";
        index = s1.lastIndexOf('@');
        System.out.println(index);//11
        System.out.println("ter的位置=" + s1.lastIndexOf("ter"));//4
        // 6.substring 截取指定范围的子串
        String name = "hello,张三";
        //下面name.substring(6) 从索引6开始截取后面所有的内容
        System.out.println(name.substring(6));//截取后面的字符
        //name.substring(0,5)表示从索引0开始截取，截取到索引 5-1=4位置,不包括5
        System.out.println(name.substring(0,5));//hello
        System.out.println(name.substring(2,5));//llo
    }
}

• El segundo grupo
  toUpperCase //Convertir a mayúsculas
  aLowerCase //Convertir a minúsculas
  concat //Concatenar cadena
  reemplazar reemplazar caracteres en la cadena
  dividir dividir cadena, para algunos caracteres divididos, necesitamos escapar como | \\ y otros
  casos: Poema de cadena = "Es mediodía en el día de cavar, el sudor gotea por el suelo, quién conoce la comida china, cada grano es duro"; y la ruta del archivo. compareTo //Compara el tamaño
  de dos cadenas
  conCharArray //Convierte a
  formato de matriz de caracteres / /Cadena de formato, %s cadena %c carácter %d entero %.2f caso de punto flotante
  , formato y salida de la información de una persona.

public class StringMethod02 {
    
    
    public static void main(String[] args) {
    
    
        // 1.toUpperCase转换成大写
        String s = "heLLo";
        System.out.println(s.toUpperCase());//HELLO
        // 2.toLowerCase
        System.out.println(s.toLowerCase());//hello
        // 3.concat拼接字符串
        String s1 = "宝玉";
        s1 = s1.concat("林黛玉").concat("薛宝钗").concat("together");
        System.out.println(s1);//宝玉林黛玉薛宝钗together
        
        // 4.replace 替换字符串中的字符
        s1 = "宝玉 and 林黛玉 林黛玉 林黛玉";
        //在s1中，将 所有的 宝玉 替换成 jack
        // 解读: s1.replace() 方法执行后，返回的结果才是替换过的.注意对 s1没有任何影响
        String s11 = s1.replace("宝玉", "jack");
        System.out.println(s1);//宝玉 and 林黛玉 林黛玉 林黛玉
        System.out.println(s11);//jack and 林黛玉 林黛玉 林黛玉
		s1=s1.replace("宝玉", "jack");//但是如果重新赋值给是s1的话，结果就是下边的
        System.out.println(s1);//jack and 林黛玉 林黛玉 林黛玉
        
        // 5.split 分割字符串, 对于某些分割字符，我们需要 转义比如 | \\等
        String poem = "锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";
        //解读：
        // 1. 以 , 为标准对 poem 进行分割 , 返回一个数组
        // 2. 在对字符串进行分割时，如果有特殊字符，需要加入 转义符 \ 
        String[] split = poem.split(","); //结果为：锄禾日当午汗滴禾下土谁知盘中餐粒粒皆辛苦
        poem = "E:\\aaa\\bbb"; //  这里的\\转的时候下边需要写4个\\\\
        split = poem.split("\\\\");
        System.out.println("==分割后内容===");
        for (int i = 0; i < split.length; i++) {
    
    
            System.out.println(split[i]);
        }
        
        // 6.toCharArray 转换成字符数组
        s = "happy";
        char[] chs = s.toCharArray();
        for (int i = 0; i < chs.length; i++) {
    
    
            System.out.println(chs[i]);
        }
        
        // 7.compareTo 比较两个字符串的大小，如果前者大，则返回正数，后者大，则返回负数，如果相等，返回0
        // 解读
        // (1) 如果长度相同，并且每个字符也相同，就返回 0
        // (2) 如果长度相同或者不相同，但是在进行比较时，可以区分大小
        //     就返回 if (c1 != c2) {
    
    
        //                return c1 - c2;
        //            }
        // (3) 如果前面的部分都相同，就返回 str1.len - str2.len
        String a = "jcck";// len = 3
        String b = "jack";// len = 4
        System.out.println(a.compareTo(b)); // 返回值是 'c' - 'a' = 2的值
		
		// 8.format 格式字符串
        /* 占位符有:
         * %s 字符串 %c 字符 %d 整型 %.2f 浮点型  */
        String name = "john";
        int age = 10;
        double score = 56.857;
        char gender = '男';
        //将所有的信息都拼接在一个字符串.
        String info =
                "我的姓名是" + name + "年龄是" + age + ",成绩是" + score + "性别是" + gender + "。希望大家喜欢我！";

        System.out.println(info);

        //解读
        //1. %s , %d , %.2f %c 称为占位符
        //2. 这些占位符由后面变量来替换（填充）
        //3. %s 表示后面由 字符串来替换
        //4. %d 是整数来替换
        //5. %.2f 表示使用小数来替换，替换后，只会保留小数点后两位, 并且进行四舍五入的处理
        //6. %c 使用char 类型来替换
        String formatStr = "我的姓名是%s 年龄是%d，成绩是%.2f 性别是%c.希望大家喜欢我！";

        String info2 = String.format(formatStr, name, age, score, gender);

        System.out.println("info2=" + info2);
    }
}

13.5 Clase StringBuffer

13.5.1 Introducción básica

1. La clase principal directa de StringBuffer es AbstractStringBuilder
   2. StringBuffer implementa Serializable, es decir, los objetos de StringBuffer se pueden serializar
   3. En la clase principal, AbstractStringBuilder tiene el valor de atributo char[], que no es final. , por lo que se almacena en el montón, a diferencia de String almacenado en el grupo
   4. StringBuffer es una clase final y no se puede heredar
   5. Debido a que el contenido de caracteres de StringBuffer existe en el valor char[], todo está cambiando (agregando/eliminando), y no hay necesidad de reemplazarlo cada vez Dirección (es decir, no crear un nuevo objeto cada vez), por lo que la eficiencia es mayor que Cadena

13.5.2 Cadena frente a StringBuffer

1. String guarda las constantes de cadena, y el valor dentro no se puede cambiar.Cada actualización de la clase String en realidad cambia la dirección, lo cual es menos eficiente//porque el valor se coloca en el grupo valor de carácter final privado[l;
2. StringBuffer guarda variables de cadena, y el valor dentro se puede cambiar. Cada vez que se actualiza StringBuffer, el contenido se puede actualizar, en lugar de actualizar la dirección cada vez, lo cual es más eficiente/ /char[ value;1 Esto se coloca en el montón.

13.5.3 Constructor de StringBuffer

public class StringBuffer02 {
    
    
    public static void main(String[] args) {
    
    
    
        //构造器的使用
        //解读
        //1. 创建一个 大小为 16的 char[] ,用于存放字符内容
        StringBuffer stringBuffer = new StringBuffer();

        //2 通过构造器指定 char[] 大小
        StringBuffer stringBuffer1 = new StringBuffer(100);
        
        //3. 通过 给一个String 创建 StringBuffer, char[] 大小就是 str.length() + 16
        StringBuffer hello = new StringBuffer("hello")  //默认是容器是16.现在又加了5个，容器变成了21
    }
}

13.5.4 Convertir entre String y StringBuffer

public class StringAndStringBuffer {
    
    
    public static void main(String[] args) {
    
    

        //看 String——>StringBuffer
        String str = "hello tom";
        //方式1 使用构造器
        //注意： 返回的才是StringBuffer对象，对str 本身没有影响
        StringBuffer stringBuffer = new StringBuffer(str);
        //方式2 使用的是append方法
        StringBuffer stringBuffer1 = new StringBuffer();
        stringBuffer1 = stringBuffer1.append(str);

        //看看 StringBuffer ->String
        StringBuffer stringBuffer3 = new StringBuffer("韩顺平教育");
        //方式1 使用StringBuffer提供的 toString方法
        String s = stringBuffer3.toString();
        //方式2: 使用构造器来搞定
        String s1 = new String(stringBuffer3);
    }
}

13.5.5 Métodos comunes de la clase StringBuffer

1. añadir anexar
2. eliminar eliminar (inicio, fin)
3. Cambie replace (inicio, fin, cadena) // reemplace el contenido entre inicio----fin, excluyendo el final
4. Verifique indexOf //Encuentre el índice de la primera aparición de la subcadena en la cadena, si no se encuentra, devuelva -1
5. insertar
6. Obtener la longitud de longitud

public class StringBufferMethod {
    
    
    public static void main(String[] args) {
    
    

        StringBuffer s = new StringBuffer("hello");
        //增
        s.append(',');// "hello,"
        s.append("张三丰");//"hello,张三丰"
        s.append("赵敏").append(100).append(true).append(10.5);//"hello,张三丰赵敏100true10.5"
        System.out.println(s);//"hello,张三丰赵敏100true10.5"


        //删
        /* 删除索引为>=start && <end 处的字符
         * 解读: 删除 11~14的字符 [11, 14)
         */
        s.delete(11, 14);
        System.out.println(s);//"hello,张三丰赵敏true10.5"
        
        //改
        //解读，使用 周芷若 替换 索引9-11的字符 [9,11)
        s.replace(9, 11, "周芷若");
        System.out.println(s);//"hello,张三丰周芷若true10.5"
        //查找指定的子串在字符串第一次出现的索引，如果找不到返回-1
        int indexOf = s.indexOf("张三丰");
        System.out.println(indexOf);//6
        
        //插
        //解读，在索引为9的位置插入 "赵敏",原来索引为9的内容自动后移
        s.insert(9, "赵敏");
        System.out.println(s);//"hello,张三丰赵敏周芷若true10.5"
        //长度
        System.out.println(s.length());//22
        System.out.println(s);
    }
}

13.5.6 Preguntas de prueba de la clase StringBuffer

• Pregunta 1

String str = null;
StringBuffer sb = new StringBuffer();
sb.append(str);
System.out.println(sb.length());
System.out.println(sb);
StringBuffer sb1 = new StringBuffer(str);
System.out.println(sb1);

Respuesta

public class StringBufferExercise01 {
    
    
    public static void main(String[] args) {
    
    
        String str = null;// ok
        StringBuffer sb = new StringBuffer(); //ok
        sb.append(str);//需要看源码 , 底层调用的是 AbstractStringBuilder 的 appendNull
        System.out.println(sb.length());//4

        System.out.println(sb);//null
        //下面的构造器，会抛出NullpointerException
        StringBuffer sb1 = new StringBuffer(str);//看底层源码 super(str.length() + 16);
        System.out.println(sb1);
    }
}

• Pregunta 2

Ingrese el nombre del producto y el precio del producto, solicite un ejemplo del efecto de impresión y use el método aprendido previamente para completar:
nombre del producto precio del producto
teléfono móvil 123,564.591 / como precio 3,456,789.88
Requisitos: cada tres dígitos antes del punto decimal del precio están separados por comas y la salida.

public class StringBufferExercise02 {
    
    
    public static void main(String[] args) {
    
    
        /*
        思路分析
        1. 定义一个Scanner 对象，接收用户输入的 价格(String)
        2. 希望使用到 StringBuffer的 insert ，需要将 String 转成 StringBuffer
        3. 然后使用相关方法进行字符串的处理
         */

        String price = "8123564.59";
        StringBuffer sb = new StringBuffer(price);
        //先完成一个最简单的实现123,564.59
        //找到小数点的索引，然后在该位置的前3位，插入,即可
//        int i = sb.lastIndexOf(".");
//        sb = sb.insert(i - 3, ",");

        //上面的两步需要做一个循环处理,才是正确的
        for (int i = sb.lastIndexOf(".") - 3; i > 0; i -= 3) {
    
    
            sb = sb.insert(i, ",");
        }
        System.out.println(sb);//8,123,564.59
    }
}

13.6 La clase StringBuilder

13.6.1 Introducción básica

1. Una secuencia mutable de caracteres. Esta clase proporciona una API compatible con StringBuffer, pero no garantiza la sincronización (StringBuilder no es seguro para subprocesos). Esta clase está diseñada como un reemplazo directo para StringBuffer cuando un único subproceso utiliza el búfer de cadena . Si es posible, se recomienda usar esta clase primero porque es más rápida que StringBuffer en la mayoría de las implementaciones [detrás de la prueba].
2. Las operaciones principales en StringBuilder son los métodos de agregar e insertar, que pueden sobrecargarse para aceptar cualquier tipo de datos.

detalle:

• 1. StringBuilder hereda la clase AbstractStringBuilder
• 2. Se implementa Serializable, lo que indica que el objeto StringBuilder se puede serializar (el objeto se puede transmitir a través de la red y guardar en un archivo)
• 3. StringBuilder es una clase final y no se puede heredar
• 4. La secuencia de caracteres del objeto stringBuilder todavía se almacena en el valor char[] de su clase principal AbstractStringBuilder, por lo tanto, la secuencia de caracteres está en el montón
• 5. El método de StringBuilder no maneja la exclusión mutua, es decir, no hay una palabra clave sincronizada, por lo que StringBuilder se usa en el caso de un solo hilo

13.6.2 Métodos comunes de StringBuilder

Tanto StringBuilder como StringBuffer representan secuencias de caracteres variables y el método es el mismo. Así que usa lo mismo que StringBuffer

13.6.3 Comparación de String, StringBuffer y StringBuilder

1. StringBuilder es muy similar a StringBuffer, ambos representan secuencias de caracteres variables y el método es el mismo
2. Cadena: secuencia de caracteres inmutable, baja eficiencia, pero alta tasa de reutilización. (La tasa de reutilización significa que hay un "java" en el grupo, y si el contenido del objeto sigue siendo java, significa que no volverá a escribir java en el grupo y no se volverá a crear. Varios objetos pueden apuntar a una piscina. constante.)
3. StringBuffer: secuencia de caracteres variable, alta eficiencia (adición y eliminación), seguridad de subprocesos, consulte el código fuente
4. StringBuilder: secuencia de caracteres variable, la más eficiente, hilo inseguro
5. Notas sobre el uso de String:
   string s="a"; 1/Se creó una cadena
   S += "b";//De hecho, el objeto de cadena "a" original se descartó y ahora se genera una cadena s+ "b" (también conocido como "ab"). Si estas operaciones de cambio del contenido de la cadena se realizan varias veces, una gran cantidad de objetos de cadena duplicados permanecerán en la memoria, lo que reducirá la eficiencia. Si dicha operación se coloca en un bucle, afectará en gran medida el rendimiento del programa => Conclusión: si hacemos muchos cambios en String, no use String

13.6.4 Prueba de eficiencia de String, StringBuffer y StringBuilder

Eficiencia: StringBuilder > StringBuffer > String

public class StringVsStringBufferVsStringBuilder {
    
    
    public static void main(String[] args) {
    
    

        long startTime = 0L;
        long endTime = 0L;
        StringBuffer buffer = new StringBuffer("");

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
    
    //StringBuffer 拼接 20000次
            buffer.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer的执行时间：" + (endTime - startTime));


        StringBuilder builder = new StringBuilder("");
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
    
    //StringBuilder 拼接 20000次
            builder.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder的执行时间：" + (endTime - startTime));


        String text = "";
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
    
    //String 拼接 20000
            text = text + i;
        }
        endTime = System.currentTimeMillis();
        System.out.println("String的执行时间：" + (endTime - startTime));

    }
}

13.6.5 Selección de String, StringBuffer y StringBuilder

Principios utilizados, conclusiones:

• 1. Si hay muchas operaciones de modificación en la cadena, generalmente use StringBuffer o StringBuilder
• 2. Si hay una gran cantidad de operaciones de modificación en la cadena, y en el caso de un solo hilo, use StringBuilder
• 3. Si hay una gran cantidad de operaciones de modificación en la cadena, y en el caso de subprocesos múltiples, use StringBuffer
• 4. Si nuestra cadena rara vez se modifica y varios objetos hacen referencia a ella, use Cadena, como información de configuración (como nombre de usuario, contraseña, ip de la base de datos de configuración), etc.
• El método de StringBuilder es el mismo que el de StringBuffer.

13.7 Clase de matemáticas

• Introducción básica
  La clase Math contiene métodos para realizar operaciones matemáticas básicas, como exponenciales elementales, logaritmos, raíces cuadradas y funciones trigonométricas.

13.7.1 Lista de métodos (ambos son métodos estáticos), casos de aplicación de métodos comunes

demostración de código:

public class MathMethod {
    
    
    public static void main(String[] args) {
    
    
        //看看Math常用的方法(静态方法)
        //1.abs 绝对值
        int abs = Math.abs(-9);
        System.out.println(abs);//9
        
        //2.pow 求幂
        double pow = Math.pow(2, 4);//2的4次方
        System.out.println(pow);//16
        
        //3.ceil 向上取整,返回>=该参数的最小整数(转成double);
        double ceil = Math.ceil(3.9);
        System.out.println(ceil);//4.0
        
        //4.floor 向下取整，返回<=该参数的最大整数(转成double)
        double floor = Math.floor(4.001);
        System.out.println(floor);//4.0
        
        //5.round 四舍五入  Math.floor(该参数+0.5)
        long round = Math.round(5.51);
        System.out.println(round);//6
        
        //6.sqrt 求开方
        double sqrt = Math.sqrt(9.0);
        System.out.println(sqrt);//3.0

        //7.random 求随机数
        //  random 返回的是 0 <= x < 1 之间的一个随机小数
        // 思考：请写出获取 a-b之间的一个随机整数,a,b均为整数 ，比如 a = 2, b=7
        //  即返回一个数 x  2 <= x <= 7
        // 解读 Math.random() * (b-a) 返回的就是 0  <= 数 <= b-a
        // (1) (int)(a) <= x <= (int)(a + Math.random() * (b-a +1) )
        // (2) 使用具体的数给小伙伴介绍 a = 2  b = 7
        //  (int)(a + Math.random() * (b-a +1) ) = (int)( 2 + Math.random()*6)
        //  Math.random()*6 返回的是 0 <= x < 6 小数
        //  2 + Math.random()*6 返回的就是 2<= x < 8 小数
        //  (int)(2 + Math.random()*6) = 2 <= x <= 7
        // (3) 公式就是  (int)(a + Math.random() * (b-a +1) )
        for(int i = 0; i < 100; i++) {
    
    
            System.out.println((int)(2 +  Math.random() * (7 - 2 + 1)));
        }

        //max , min 返回最大值和最小值
        int min = Math.min(1, 9);
        int max = Math.max(45, 90);
        System.out.println("min=" + min);
        System.out.println("max=" + max);
    }
}

13.8 La clase Matrices

13.8.1 Casos de aplicación de métodos comunes de la clase Arrays

Arrays contiene una serie de métodos estáticos para administrar o manipular matrices (como ordenar y buscar).

• 1. toString devuelve la forma de cadena de la matriz
  Arrays.toString(arr)

• 2. clasificación por clasificación (clasificación natural y clasificación personalizada) Integer arr[] = {1,-1,7,0,89,1};
  ArraysSortCustom.java

• 3. BinarySearch busca a través del método de búsqueda binaria, que debe ordenarse. ArraysMethod02.java
  int index = Arrays.binarySearch(arr, 3);

• 4. copyOf Copia de los elementos de la matriz
  Integer[ newArr = Arrays.copyOf(arr, arr.length);

• 5. Llenar
  Entero[] num = new Entero[1{9,3,21;Arrays.fill(num, 99);

• 6. equals compara si el contenido de dos elementos del arreglo es completamente consistente booleano equals = Arrays.equals(arr, arr2);

• 7. asList convierte un conjunto de valores en una lista
  List asList = Arrays.asList(2,3,4.5,6,1);
  System.out.println("asList=" + asList);

Código punto 1-2:

import java.util.Arrays;
import java.util.Comparator;

public class ArraysMethod01 {
    
    
    public static void main(String[] args) {
    
    

        Integer[] integers = {
    
    1, 20, 90};
        //之前方法遍历数组
//        for(int i = 0; i < integers.length; i++) {
    
    
//            System.out.println(integers[i]);
//        }
        //直接使用Arrays.toString方法，显示数组
       System.out.println(Arrays.toString(integers));//


        //演示 sort方法的使用
        Integer arr[] = {
    
    1, -1, 7, 0, 89};
        //进行排序
        //解读
        //1. 可以直接使用冒泡排序 , 也可以直接使用Arrays提供的sort方法排序
        //2. 因为数组是引用类型，所以通过sort排序后，会直接影响到 实参 arr
        //3. sort重载的，也可以通过传入一个接口 Comparator 实现定制排序
        
        //sort排序里边的定制排序
        //4. 调用 定制排序 时，传入两个参数 (1) 排序的数组 arr
        //   (2) 实现了Comparator接口的匿名内部类 , 要求实现  compare方法
        //5. 先演示效果，再解释
        //6. 这里体现了接口编程的方式 , 看看源码，就明白
        //   源码分析
        //(1) Arrays.sort(arr, new Comparator()
        //(2) 最终到 TimSort类的 private static <T> void binarySort(T[] a, int lo, int hi, int start,
        //                                       Comparator<? super T> c)()
        //(3) 执行到 binarySort方法的代码, 会根据动态绑定机制 c.compare()执行我们传入的
        //    匿名内部类的 compare ()
        //     while (left < right) {
    
    
        //                int mid = (left + right) >>> 1;
        //                if (c.compare(pivot, a[mid]) < 0)
        //                    right = mid;
        //                else
        //                    left = mid + 1;
        //            }
        //(4) new Comparator() {
    
    
        //            @Override
        //            public int compare(Object o1, Object o2) {
    
    
        //                Integer i1 = (Integer) o1;
        //                Integer i2 = (Integer) o2;
        //                return i2 - i1;
        //            }
        //        }
        //(5) public int compare(Object o1, Object o2) 返回的值>0 还是 <0
        //    会影响整个排序结果, 这就充分体现了 接口编程+动态绑定+匿名内部类的综合使用
        //    将来的底层框架和源码的使用方式，会非常常见
        //Arrays.sort(arr); // 默认排序方法
        //定制排序
        Arrays.sort(arr, new Comparator() {
    
    
            @Override
            public int compare(Object o1, Object o2) {
    
    
                Integer i1 = (Integer) o1;
                Integer i2 = (Integer) o2;
                return i2 - i1;
            }
        });
        System.out.println("===排序后===");
        System.out.println(Arrays.toString(arr));//
    }
}

ArraysSortCustom.java, escriba la ordenación de burbujas usted mismo, profundice la comprensión de la ordenación personalizada.

import java.util.Arrays;
import java.util.Comparator;

public class ArraysSortCustom {
    
    
    public static void main(String[] args) {
    
    

        int[] arr = {
    
    1, -1, 8, 0, 20};
        //bubble01(arr);

        bubble02(arr, new Comparator() {
    
    
            @Override
            public int compare(Object o1, Object o2) {
    
    
                int i1 = (Integer) o1;
                int i2 = (Integer) o2;
                return i2 - i1;// return i2 - i1;
            }
        });
        System.out.println("==定制排序后的情况==");
        System.out.println(Arrays.toString(arr));

    }

    //使用冒泡完成排序
    public static void bubble01(int[] arr) {
    
    
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
    
    
            for (int j = 0; j < arr.length - 1 - i; j++) {
    
    
                //从小到大
                if (arr[j] > arr[j + 1]) {
    
    
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    //结合冒泡 + 定制
    public static void bubble02(int[] arr, Comparator c) {
    
    
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
    
    
            for (int j = 0; j < arr.length - 1 - i; j++) {
    
    
                //数组排序由 c.compare(arr[j], arr[j + 1])返回的值决定
                if (c.compare(arr[j], arr[j + 1]) > 0) {
    
    
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

Código para los puntos 3-7:

import java.util.Arrays;
import java.util.List;

public class ArraysMethod02 {
    
    
    public static void main(String[] args) {
    
    
        Integer[] arr = {
    
    1, 2, 90, 123, 567};
        // binarySearch 通过二分搜索法进行查找，要求必须排好
        // 解读
        //1. 使用 binarySearch 二叉查找
        //2. 要求该数组是有序的. 如果该数组是无序的，不能使用binarySearch
        //3. 如果数组中不存在该元素，就返回 return -(low + 1);  // key not found.
        int index = Arrays.binarySearch(arr, 567);
        System.out.println("index=" + index);

        //copyOf 数组元素的复制
        // 解读
        //1. 从 arr 数组中，拷贝 arr.length个元素到 newArr数组中
        //2. 如果拷贝的长度 > arr.length 就在新数组的后面 增加 null
        //3. 如果拷贝长度 < 0 就抛出异常NegativeArraySizeException
        //4. 该方法的底层使用的是 System.arraycopy()
        Integer[] newArr = Arrays.copyOf(arr, arr.length);
        System.out.println("==拷贝执行完毕后==");
        System.out.println(Arrays.toString(newArr));

        //ill 数组元素的填充
        Integer[] num = new Integer[]{
    
    9,3,2};
        //解读
        //1. 使用 99 去填充 num数组，可以理解成是替换原理的元素
        Arrays.fill(num, 99);
        System.out.println("==num数组填充后==");
        System.out.println(Arrays.toString(num));

        //equals 比较两个数组元素内容是否完全一致
        Integer[] arr2 = {
    
    1, 2, 90, 123};
        //解读
        //1. 如果arr 和 arr2 数组的元素一样，则方法true;
        //2. 如果不是完全一样，就返回 false
        boolean equals = Arrays.equals(arr, arr2);
        System.out.println("equals=" + equals);

        //asList 将一组值，转换成list
        //解读
        //1. asList方法，会将 (2,3,4,5,6,1)数据转成一个List集合
        //2. 返回的 asList 编译类型 List(接口)
        //3. asList 运行类型 java.util.Arrays#ArrayList, 是Arrays类的
        //   静态内部类 private static class ArrayList<E> extends AbstractList<E>
        //              implements RandomAccess, java.io.Serializable
        List asList = Arrays.asList(2,3,4,5,6,1);
        System.out.println("asList=" + asList);
        System.out.println("asList的运行类型" + asList.getClass());
    }
}

13.8.2 Ejercicios de clase de matrices

Caso: clase de libro personalizado, que contiene nombre y precio, ordenados por precio (de mayor a menor). Se requiere usar dos formas de clasificación, hay un Libro [] libros = 4 objetos de libro.Use
la transferencia aprendida previamente para implementar la clase interna anónima de la interfaz Comparator, también conocida como clasificación personalizada.
Según el precio (1) de grande a pequeño (2) de pequeño a grande (3) según la longitud del título del libro de grande a pequeño Libro
[] libros = nuevo Libro[4];
libros[0] = nuevo Libro("Sueño de Mansiones Rojas", 100);
libros[1] = nuevo Libro("Jin Ping Mei Xin", 90);
libros[2] = nuevo Libro("Resumen de la Juventud 20 años", 5);
libros[ 3] = nuevo Libro("java desde la entrada hasta el abandono~", 300);

import java.util.Arrays;
import java.util.Comparator;

public class ArrayExercise {
    
    
    public static void main(String[] args) {
    
    
    
        Book[] books = new Book[4];
        books[0] = new Book("红楼梦", 100);
        books[1] = new Book("金瓶梅新", 90);
        books[2] = new Book("青年文摘20年", 5);
        books[3] = new Book("java从入门到放弃~", 300);

        //(1)price从大到小

//        Arrays.sort(books, new Comparator() {
    
    
//            //这里是对Book数组排序，因此  o1 和 o2 就是Book对象
//            @Override
//            public int compare(Object o1, Object o2) {
    
    
//                Book book1 = (Book) o1;
//                Book book2 = (Book) o2;
//                double priceVal = book2.getPrice() - book1.getPrice();
//                //这里进行了一个转换，因为此类重写返回的是int类型，现在是double，
                 //不能把上边的返回类型改成double，改了就不算重写了,可以用double接受，再用if else判断
//                //如果发现返回结果和我们输出的不一致，就修改一下返回的 1 和 -1
//                if(priceVal > 0) {
    
    
//                    return  1;
//                } else  if(priceVal < 0) {
    
    
//                    return -1;
//                } else {
    
    
//                    return 0;
//                }
//            }
//        });

        //(2)price从小到大
//        Arrays.sort(books, new Comparator() {
    
    
//            //这里是对Book数组排序，因此  o1 和 o2 就是Book对象
//            @Override
//            public int compare(Object o1, Object o2) {
    
    
//                Book book1 = (Book) o1;
//                Book book2 = (Book) o2;
//                double priceVal = book2.getPrice() - book1.getPrice();
//                //这里老师进行了一个转换
//                //如果发现返回结果和我们输出的不一致，就修改一下返回的 1 和 -1
//                if(priceVal > 0) {
    
    
//                    return  -1;
//                } else  if(priceVal < 0) {
    
    
//                    return 1;
//                } else {
    
    
//                    return 0;
//                }
//            }
//        });

        //(3)按照书名长度从大到小
        Arrays.sort(books, new Comparator() {
    
    
            //这里是对Book数组排序，因此  o1 和 o2 就是Book对象
            @Override
            public int compare(Object o1, Object o2) {
    
    
                Book book1 = (Book) o1;
                Book book2 = (Book) o2;
                //要求按照书名的长度来进行排序
                return book2.getName().length() - book1.getName().length();
            }
        });
        System.out.println(Arrays.toString(books));
    }
}

class Book {
    
    
    private String name;
    private double price;

    public Book(String name, double price) {
    
     //构造器
        this.name = name;
        this.price = price;
    }
//get、set方法
    public String getName() {
    
    return name;}
    public void setName(String name) {
    
    this.name = name; }
    public double getPrice() {
    
    return price;  }
    public void setPrice(double price) {
    
    this.price = price;}

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

13.9 La clase Sistema

13.9.1 Métodos y casos comunes de la clase System

• 1. salir Salir del programa actual
• 2. arraycopy: copia elementos de matriz, que es más adecuado para llamadas subyacentes. Generalmente, Arrays.copyOf se usa para completar la copia de matrices.
  int[] src={1,2,3};
  int[] dest = new int[3 ];
  System.arraycopy( src, 0, dest, 0,3);
• 3. currentTimeMillens: devuelve el número de milisegundos desde 1970-1-1 hasta la hora actual
• 4. gc: Ejecute el mecanismo de recolección de basura System.gc();

import java.util.Arrays;

public class System_ {
    
    
    public static void main(String[] args) {
    
    

     
        //exit 退出当前程序
     
//        System.out.println("ok1");
//        //解读
//        //1. exit(0) 表示程序退出
//        //2. 0 表示一个状态 , 正常的状态
//        System.exit(0);//
//        System.out.println("ok2");

        //arraycopy ：复制数组元素，比较适合底层调用，一般使用Arrays.copyOf完成复制数组
        int[] src={
    
    1,2,3};
        int[] dest = new int[3];// dest 当前是 {0,0,0}
        //解读
        //1. 主要是搞清楚这五个参数的含义
        //2.
        //     源数组（上面是下面一行的注释）
        //     * @param      src      the source array.
        
        //     srcPos： 从源数组的哪个索引位置开始拷贝
        //     * @param      srcPos   starting position in the source array.
        
        //     dest : 目标数组，即把源数组的数据拷贝到哪个数组
        //     * @param      dest     the destination array.
        
        //     destPos: 把源数组的数据拷贝到 目标数组的哪个索引
        //     * @param      destPos  starting position in the destination data.
        
        //     length: 从源数组拷贝多少个数据到目标数组
        //     * @param      length   the number of array elements to be copied.
        System.arraycopy(src, 0, dest, 0, src.length);
        System.out.println("dest=" + Arrays.toString(dest));//[1, 2, 3]

        //currentTimeMillens:返回当前时间距离1970年1月1日 的毫秒数
        // 解读:
        System.out.println(System.currentTimeMillis());
    }
}

13.10 Clases BigInteger y BigDecimal

escenarios de aplicación;

• 1. Biglnteger es adecuado para guardar números enteros relativamente grandes
• 2. BigDecimal es adecuado para almacenar tipos de punto flotante (decimales) con mayor precisión

13.10.1 Métodos comunes de BigInteger y BigDecimal

1. agregar agregar
2. restar menos
3. multiplicar multiplicar
4. dividir

Código para el método BigInteger

import java.math.BigInteger;

public class BigInteger_ {
    
    
    public static void main(String[] args) {
    
    

        //当我们编程中，需要处理很大的整数，long 不够用
        //可以使用BigInteger的类来搞定
//        long l = 23788888899999999999999999999l;
//        System.out.println("l=" + l);

        BigInteger bigInteger = new BigInteger("23788888899999999999999999999");
        BigInteger bigInteger2 = new BigInteger("10099");
        System.out.println(bigInteger);
        //解读
        //1. 在对 BigInteger 进行加减乘除的时候，需要使用对应的方法，不能直接进行 + - * /
        //2. 可以创建一个 要操作的 BigInteger 然后进行相应操作
        BigInteger add = bigInteger.add(bigInteger2);
        System.out.println(add);//
        BigInteger subtract = bigInteger.subtract(bigInteger2);
        System.out.println(subtract);//减
        BigInteger multiply = bigInteger.multiply(bigInteger2);
        System.out.println(multiply);//乘
        BigInteger divide = bigInteger.divide(bigInteger2);
        System.out.println(divide);//除
    }
}

Código para BigDecimal:

import java.math.BigDecimal;
public class BigDecimal_ {
    
    
    public static void main(String[] args) {
    
    
        //当我们需要保存一个精度很高的数时，double 不够用
        //可以是 BigDecimal
//        double d = 1999.11111111111999999999999977788d;
//        System.out.println(d);
        BigDecimal bigDecimal = new BigDecimal("1999.11");
        BigDecimal bigDecimal2 = new BigDecimal("3");
        System.out.println(bigDecimal);

        //解读
        //1. 如果对 BigDecimal进行运算，比如加减乘除，需要使用对应的方法
        //2. 创建一个需要操作的 BigDecimal 然后调用相应的方法即可
        System.out.println(bigDecimal.add(bigDecimal2));
        System.out.println(bigDecimal.subtract(bigDecimal2));
        System.out.println(bigDecimal.multiply(bigDecimal2));
  //System.out.println(bigDecimal.divide(bigDecimal2));//除不尽无限循环可能抛出异常ArithmeticException
        //在调用divide 方法时，指定精度即可. BigDecimal.ROUND_CEILING
        //如果有无限循环小数，就会保留 分子 的精度
        System.out.println(bigDecimal.divide(bigDecimal2, BigDecimal.ROUND_CEILING));
    }
}

13.11 Clase de fecha

13.11.1 La clase de fecha de primera generación

1. Fecha: precisión de milisegundos, que representa un momento específico
2. SimpleDateFormat: una clase para formatear y analizar fechas, y una clase concreta para formatear y analizar fechas de SimpleDateFormat. Permite formatear (fecha -> texto), analizar (texto -> fecha) y normalizar.

SimpleDateFormat debe seguir el siguiente

código de especificación:

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Date01 {
    
    
    public static void main(String[] args) throws ParseException {
    
    

        //解读
        //1. 获取当前系统时间
        //2. 这里的Date 类是在java.util包
        //3. 默认输出的日期格式是国外的方式, 因此通常需要对格式进行转换
        Date d1 = new Date(); //获取当前系统时间
        System.out.println("当前日期=" + d1);
        Date d2 = new Date(9234567); //通过指定毫秒数得到时间，距离1970
        System.out.println("d2=" + d2); //获取某个时间对应的毫秒数


        //解读
        //1. 创建 SimpleDateFormat对象，可以指定相应的格式
        //2. 这里的格式使用的字母是规定好，不能乱写

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss E");
        String format = sdf.format(d1); // format:将日期转换成指定格式的字符串
        System.out.println("当前日期=" + format);

        //解读
        //1. 可以把一个格式化的String 转成对应的 Date
        //2. 得到Date 仍然在输出时，还是按照国外的形式，如果希望指定格式输出，需要转换
        //3. 在把String -> Date ， 使用的 sdf 格式需要和你给的String的格式一样，否则会抛出转换异常
        String s = "1996年01月01日 10:20:30 星期一";
        Date parse = sdf.parse(s);
        System.out.println("parse=" + sdf.format(parse));
    }
}

13.11.2 La clase de fecha de segunda generación

código:

import java.util.Calendar;

public class Calendar_ {
    
    
    public static void main(String[] args) {
    
    
        //解读
        //1. Calendar是一个抽象类， 并且构造器是private
        //2. 可以通过 getInstance() 来获取实例，不能new，因为是私有的
        //3. 提供大量的方法和字段提供给程序员
        //4. Calendar没有提供对应的格式化的类，因此需要程序员自己组合来输出(灵活)
        //5. 如果我们需要按照 24小时进制来获取时间， Calendar.HOUR ==改成=> Calendar.HOUR_OF_DAY
        Calendar c = Calendar.getInstance(); //创建日历类对象//比较简单，自由
        System.out.println("c=" + c);
        //2.获取日历对象的某个日历字段
        System.out.println("年：" + c.get(Calendar.YEAR));
        // 这里为什么要 + 1, 因为Calendar 返回月时候，是按照 0 开始编号
        System.out.println("月：" + (c.get(Calendar.MONTH) + 1));
        System.out.println("日：" + c.get(Calendar.DAY_OF_MONTH));
        System.out.println("小时：" + c.get(Calendar.HOUR));
        System.out.println("分钟：" + c.get(Calendar.MINUTE));
        System.out.println("秒：" + c.get(Calendar.SECOND));
        //Calender 没有专门的格式化方法，所以需要程序员自己来组合显示
        System.out.println(c.get(Calendar.YEAR) + "-" + (c.get(Calendar.MONTH) + 1) + "-" + c.get(Calendar.DAY_OF_MONTH) +" " + c.get(Calendar.HOUR_OF_DAY) + ":" + c.get(Calendar.MINUTE) + ":" + c.get(Calendar.SECOND) );
    }
}

13.11.3 La clase de fecha de tercera generación

• Análisis insuficiente de las dos generaciones anteriores de clases de fecha
  JDK 1.0 contiene una clase java.util.Date, pero la mayoría de sus métodos quedaron obsoletos después de la introducción de la clase Calendar en JDK 1.1.
• Y Calendar también tiene problemas:

1. Mutabilidad: las clases como fechas y horas deben ser inmutables. (y el calendario es variable)
2. Compensación: el año en Fecha comienza en 1900 y el mes comienza en 0.
3. Formato: el formato solo es útil para la fecha, no para el calendario.
4. Además, no son seguros para subprocesos; no pueden manejar segundos bisiestos, etc. (cada 2 días, 1 segundo adicional)

• La clase de fecha de tercera generación
  LocalDate (fecha/año, mes, día), LocalTime (hora/hora, minuto, segundo), LocalDateTime (fecha, hora/año, mes, día, hora, minuto, segundo) JDK8 agregado LocalDate solo
  contiene la fecha, puede obtener el campo de fecha
  LocalTime solo contiene la hora, puede Obtener el campo de hora
  LocalDateTime contiene fecha + hora, puede obtener campos de fecha y hora

import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Collection;

public class LocalDate_ {
    
    
    public static void main(String[] args) {
    
    
        //第三代日期
        //解读
        //1. 使用now() 返回表示当前日期时间的 对象
        LocalDateTime ldt = LocalDateTime.now(); //LocalDate.now();//LocalTime.now()
        System.out.println(ldt);

        //2. 使用DateTimeFormatter 对象来进行格式化
        // 创建 DateTimeFormatter对象
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");//格式标准就按之前的截图
        String format = dateTimeFormatter.format(ldt);
        System.out.println("格式化的日期=" + format);

        System.out.println("年=" + ldt.getYear());
        System.out.println("月=" + ldt.getMonth());
        System.out.println("月=" + ldt.getMonthValue());
        System.out.println("日=" + ldt.getDayOfMonth());
        System.out.println("时=" + ldt.getHour());
        System.out.println("分=" + ldt.getMinute());
        System.out.println("秒=" + ldt.getSecond());

        LocalDate now = LocalDate.now(); //可以获取年月日
        LocalTime now2 = LocalTime.now();//获取到时分秒


        //提供 plus 和 minus方法可以对当前时间进行加或者减
        //看看890天后，是什么时候 把 年月日-时分秒
        LocalDateTime localDateTime = ldt.plusDays(890);
        System.out.println("890天后=" + dateTimeFormatter.format(localDateTime));

        //看看在 3456分钟前是什么时候，把 年月日-时分秒输出
        LocalDateTime localDateTime2 = ldt.minusMinutes(3456);
        System.out.println("3456分钟前 日期=" + dateTimeFormatter.format(localDateTime2));

    }
}

• Más métodos de la clase de fecha de tercera generación Clase
  LocalDateTime Clase
  MonthDay: Verificar si hay eventos repetidos
  Si es un año bisiesto
  Agregar cierta parte de la fecha
  Usar el método más para probar una cierta parte del tiempo
  Usar el método menos para probar ver la fecha de hace un año y un año después
  Otro método, al usarlo, puede verificar la API usted mismo

13.11.4 Clase de fecha de formato DateTimeFormatter

Similar a SimpleDateFormat
DateTimeFormat dtf = DateTimeFormatter.ofPattern(format);
String str = dtf.format(date object);

Consulte el código anterior para ver el código de ejemplo.

13.11.5 Marca de tiempo instantánea

Similar a la forma en que Date
proporciona una serie de conversiones con la clase Date
Instant—>Date:
Date date = Date.from(instant);
Date—>lnstant:
Instant instant = date.tolnstant(0);

public class Instant_ {
    
    
    public static void main(String[] args) {
    
    

        //1.通过 静态方法 now() 获取表示当前时间戳的对象
        Instant now = Instant.now();
        System.out.println(now);
        //2. 通过 from 可以把 Instant转成 Date
        Date date = Date.from(now);
        //3. 通过 date的toInstant() 可以把 date 转成Instant对象
        Instant instant = date.toInstant();
    }
}

13.12 Tarea para este capítulo

• Pregunta 1
  

public class Homework01 {
    
    
    public static void main(String[] args) {
    
    
        //测试
        String str = "abcdef";
        System.out.println("===交换前===");
        System.out.println(str);
        try {
    
    
            str = reverse(str, 1, 4);
        } catch (Exception e) {
    
    
            System.out.println(e.getMessage());
            return;
        }
        System.out.println("===交换后===");
        System.out.println(str);
    }

    /**
     * (1) 将字符串中指定部分进行反转。比如将"abcdef"反转为"aedcbf"
     * (2) 编写方法 public static String reverse(String  str, int start , int end) 搞定
     * 思路分析
     * (1) 先把方法定义确定
     * (2) 字符串本身是final的，不能修改，因此把 String 转成 char[] ，因为char[] 的元素是可以交换的
     * (3) 画出分析示意图
     * (4) 代码实现
     */
    public static String reverse(String str, int start, int end) {
    
    

        //对输入的参数做一个验证
        //重要的编程技巧分享!!!
        //(1) 写出正确的情况
        //(2) 然后取反即可
        //(3) 这样写，你的思路就不乱
        if(!(str != null && start >= 0 && end > start && end < str.length())) {
    
    
            throw new RuntimeException("参数不正确");
        }

        char[] chars = str.toCharArray();
        char temp = ' '; //交换辅助变量
        for (int i = start, j = end; i < j; i++, j--) {
    
    
            temp = chars[i];
            chars[i] = chars[j];
            chars[j] = temp;
        }
        //使用chars 重新构建一个String 返回即可
        return new String(chars);
    }
}

• Pregunta 2. preguntas de programación

Ingrese el nombre de usuario, la contraseña y la dirección de correo electrónico. Si la información se ingresa correctamente, se le indicará que el registro se realizó correctamente; de ​​lo contrario, se generará un objeto anormal. Requisitos: (1) La longitud del nombre de usuario es 2 o
3 o 4
(2) La longitud de la contraseña es 6 y todos los números son obligatorios isDigital
(3) El buzón contiene @ y . y @ está delante de .

public class Homework02 {
    
    
    public static void main(String[] args) {
    
    

        String name = "abc";
        String pwd = "123456";
        String email = "ti@[email protected]";

        try {
    
    
            userRegister(name,pwd,email);
            System.out.println("恭喜你，注册成功~");
        } catch (Exception e) {
    
    
            System.out.println(e.getMessage());
        }
    }


    /** 思路分析
     * (1) 先编写方法 userRegister(String name, String pwd, String email) {}
     * (2) 针对 输入的内容进行校核，如果发现有问题，就抛出异常，给出提示
     * (3) 单独的写一个方法，判断 密码是否全部是数字字符 boolean
     */

    private static void userRegister(String name, String pwd, String email)
    {
    
    

        //再加入一些校验
        if(!(name != null && pwd != null && email != null)) {
    
    
            throw  new RuntimeException("参数不能为null");
        }

        //过关
        //第一关
        int userLength = name.length();
        if (!(userLength >= 2 && userLength <= 4)) {
    
    
            throw new RuntimeException("用户名长度为2或3或4");
        }

        //第二关
        if (!(pwd.length() == 6 && isDigital(pwd))) {
    
    
            throw new RuntimeException("密码的长度为6，要求全是数字");
        }

        //第三关
        int i = email.indexOf('@');
        int j = email.indexOf('.');
        if (!(i > 0 && j > i)) {
    
    
            throw new RuntimeException("邮箱中包含@和.   并且@在.的前面");
        }
    }

    //单独的写一个方法，判断 密码是否全部是数字字符 boolean
    public static boolean isDigital(String str) {
    
    
        char[] chars = str.toCharArray();
        for (int i = 0; i < chars.length; i++) {
    
    
            if (chars[i] < '0' || chars[i] > '9') {
    
    
                return false;
            }
        }
        return true;
    }
}

• 3. Preguntas de programación
  

package com.hspedu.homework;
public class Homework03 {
    
    
    public static void main(String[] args) {
    
    
        String name = "Willian Jefferson Clinton";
        printName(name);
    }

    /**思路分析
     * (1) 对输入的字符串进行 分割split(" ")
     * (2) 对得到的String[] 进行格式化String.format（）
     * (3) 对输入的字符串进行校验即可
     */
    public static void printName(String str) {
    
    

        if(str == null) {
    
    
            System.out.println("str 不能为空");
            return;
        }

        String[] names = str.split(" ");
        if(names.length != 3) {
    
    
            System.out.println("输入的字符串格式不对");
            return;
        }

        String format = String.format("%s,%s .%c", names[2], names[0], names[1].toUpperCase().charAt(0));
        //names[1].toUpperCase().charAt(0)的意思是先把所有的大写，再取第一个字母。
        System.out.println(format);
    }
}

• 4. Preguntas de programación

Ingrese una cadena para determinar cuántas letras mayúsculas, cuántas letras minúsculas y cuántos números hay en ella

public class Homework04 {
    
    
    public static void main(String[] args) {
    
    
            String str = "abcHsp U 1234";
            countStr(str);
    }

    /** 思路分析
     * (1) 遍历字符串，如果 char 在 '0'~'9' 就是一个数字
     * (2) 如果 char 在 'a'~'z' 就是一个小写字母
     * (3) 如果 char 在 'A'~'Z' 就是一个大写字母
     * (4) 使用三个变量来记录 统计结果
     */
    public static void countStr(String str) {
    
    
        if (str == null) {
    
    
            System.out.println("输入不能为 null");
            return;
        }
        int strLen = str.length();
        int numCount = 0;
        int lowerCount = 0;
        int upperCount = 0;
        int otherCount = 0;
        for (int i = 0; i < strLen; i++) {
    
    
            if(str.charAt(i) >= '0' && str.charAt(i) <= '9') {
    
    
                numCount++;
            } else if(str.charAt(i) >= 'a' && str.charAt(i) <= 'z') {
    
    
                lowerCount++;
            } else if(str.charAt(i) >= 'A' && str.charAt(i) <= 'Z') {
    
    
                upperCount++;
            } else {
    
    
                otherCount++;
            }
        }

        System.out.println("数字有 " + numCount);
        System.out.println("小写字母有 " + lowerCount);
        System.out.println("大写字母有 " + upperCount);
        System.out.println("其他字符有 " + otherCount);
    }
}

• El segundo falso en el lado izquierdo de la pregunta 5
  
  se debe a que a y b son de la clase Animal, y el método de igualdad no se reescribe. La esencia es juzgar si a y b son el mismo objeto, pero se reescribe la igualdad de String. para comparar los dos Si los contenidos de los valores son iguales.