Clase de objeto Java

La clase Java Object es la clase principal de todas las clases, es decir, todas las clases Java heredan Object y las subclases pueden usar todos los métodos de Object.
La clase Object se encuentra en el paquete java.lang y se importará automáticamente al compilar. Cuando creamos una clase, si no hereda explícitamente una clase principal, automáticamente heredará Object y se convertirá en una subclase de Object.

Métodos importantes de la clase comúnmente utilizados

public String toString()
devuelve la representación de cadena del objeto
Ejemplo:

public class Test {
    
    
    public static void main(String[] args) {
    
    
        Person person = new Person();
        //调用person对象的方法toString()
        String s = person.toString();
        //com.yls.demo1.Person@1b6d3586  这是对象在内存中的“地址”
        System.out.println(s);
        //com.yls.demo1.Person@1b6d3586
        System.out.println(person);  
        //得出结论 输出语句中必须(默认）调用toString()方法 
        //无权更改，sun公司规定死的
        //输出语句System.out.println(对象)调用对象的toString()
        //System.out.println(对象)==System.out.println(对象.toString())
    }
}

En el desarrollo real, el método toString() de la clase principal generalmente se reescribe y, en lugar de la representación de dirección de objeto predeterminada, creamos nuestra propia representación de cadena

Anular el método toString() de la clase principal

public class Person {
    
    
    /**
     * 重写父类的方法toString
     * 返回字符串
     * @return
     * 重写方法的目标：方法中，返回类中成员变量的值
     */
    private  String name;
    private  int age;
    public Person(){
    
    }
    public Person(String name, int age) {
    
    
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString(){
    
    
        return name +":" + age;
    }
}


public class Test {
    
    
    public static void main(String[] args) {
    
    
        Person person = new Person("李四",25);
        //调用person对象的方法toString()
        String s = person.toString();
        //李四:25
        System.out.println(s);
        //李四:25
        System.out.println(person);  
    }
}

boolean equals(Object obj)
compara si dos objetos son iguales, java cree que cualquier objeto es comparable
método de clase de objeto es igual al código fuente:

public boolean equals(Object obj) {
    
    
        return (this == obj);
    }
    //this指调用者，obj指传入的Object对象参数

De forma predeterminada, se compara la dirección de memoria del objeto
, pero la dirección del objeto general no es comparable, por lo que debemos reescribir nuestro método de igualdad para establecer nuestra propia forma de comparación del objeto. El
ejemplo es el siguiente:


    @Override
    public boolean equals(Object obj){
    
    
        //健壮性判断1，如果obj的值为null，比较的另一个对象不存在
        if (obj == null) {
    
    
            return false;
        }
        //健壮性判断2，判断this和obj是不是一个对象，如果是就直接返回true
        if(this == obj){
    
    
            return true;
        }
        //这里涉及一个多态的问题，
        //obj应该向下转型为Person才可以调用age
        //同时需注意安全性判断
        if (obj instanceof Person) {
    
    
            Person p = (Person) obj;
            return this.age == p.age;
        }
        //不是Person 没有可比性
        return false;
    }


 Person person = new Person("李四",25);
 Person person1 = new Person("王二", 25);
 boolean b = person.equals(person1);
 System.out.println(b);   //true

Clase de cadena de cadena

java.lang.Object
java.lang.String
Todas las interfaces implementadas:
Serializable, CharSequence, Comparable < String >
Herede la clase Object e implemente tres interfaces. El objeto de cadena es una constante. Una vez creado, no se puede modificar.
Simplemente escriba " " en el programa Objetos de la clase String

Principio de implementación de
cadena El tipo de datos de cadena no existe en Java, y su principio de implementación es que el
"abc" representado por la matriz char[] es en realidad char[] ch = {'a', 'b', 'c' } para indicar que
después de la versión JDK9, para ahorrar memoria, la matriz de caracteres se convierte en una matriz de bytes
JDK8 y antes son todas las matrices de caracteres

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    
    
    /** The value is used for character storage. */
    private final char value[];   //成员变量char数组
	......

El modificador final antes de la matriz indica la matriz final.Una vez que se establece su dirección, se bloqueará (constante) por seguridad de subprocesos.

Propiedades de las constantes de cadena

   public static void main(String[] args) {
    
    
        String a = "abc";
        String s = new String("abc");  //new对象新开一片堆，与a String对象中的数组地址不一样
        System.out.println(a == s);   //false
        System.out.println("---------------");

        /**
         * s1保存的是String对象
         * s2 = "hello" 和s1中的字符串在内存中的数组表现是一样的 ，JVM为了节约内存两者共用
         * s1的地址赋值给s2
         */
        String s1 = "hello";
        String s2 = "hello";
        System.out.println(s1==s2); //true
        System.out.println("---------------");

        /**
         * s3 和 s4都是变量，变量在编译的时候，javac不确定变量的计算结果是什么
         * 运行的时候jvm会为s3＋s4的结果新开内存空间
         */
        String s3 = "hhh";
        String s4 = "ooo";
        String s5 ="hhhooo";
        System.out.println(s5 ==(s3+s4)); //false
        System.out.println("---------------");
        /**
         * "hhh" "ooo" 是常量，值在编译期间就已经确定
         * 运行时期不会建立新的内存空间
         */
        System.out.println(s5==("hhh"+"ooo"));//true

    }

constructor de cadenas

String(byte[] bytes)
Construye una nueva cadena decodificando la matriz de bytes especificada utilizando el conjunto de caracteres predeterminado de la plataforma.
La matriz de bytes String (byte[] bytes, int offset, int length)
se convierte en una cadena, utilizando el conjunto de caracteres predeterminado de la plataforma, el parámetro off representa el comienzo de la matriz y len representa el número de conversiones
String(byte[] bytes, String charsetName)
charsetName es una tabla de códigos que puede especificar usted mismo. Por ejemplo, especifique
el código GBK GBK en la idea. Para distinguirlo del inglés,
2 bytes de valor negativo significan que un carácter chino
utf-8 tiene 3 bytes y representa un carácter chino

    public static void Byte2string(){
    
    
        /**
         * String(byte[] bytes)
         * 通过使用平台的默认字符集解码指定的字节数组来构造新的 String
         * wiodows 中文版 默认字符集是GBK  ，idea启动时为jvm添加启动参数会把默认字符集改为UTF-8
         */
        byte[] b ={
    
    97,98,99};
        String s = new String(b);
        System.out.println(s); //abc

        //数组的一部分转换为字符串
        //从索引1开始，两个字符
        String s1 = new String(b,1,2);
        System.out.println(s1);//bc
    }
    public static void main(String[] args) {
    
    
        Byte2string();
    }

Solo la matriz de bytes está relacionada con la tabla de codificación, y nada más

String(char[] value)
convierte una matriz en una cadena
La matriz de cadena (valor char[], compensación int, longitud int)
se convierte en una cadena, el parámetro off representa el comienzo de la matriz y len representa el número de conversiones

    public static void Char2string(){
    
    
        //构造方法，数组转为字符串
        char ch [] ={
    
    'a','b','c','q'};
        String s = new String(ch);
        System.out.println(s);//abcq
        //数组转为字符串转一部分
        String s1 = new String(ch, 1, 2);
        System.out.println(s1);//bc
    }

Métodos comunes de la clase String

Método de juicio de la clase String

boolean equals(Object anObject)
Compara esta cadena con el objeto especificado.
boolean equalsIgnoreCase(String anotherString)
compara este String con otros Strings, ignorando mayúsculas y minúsculas
boolean comienza con (String str)
determina si la cadena comienza con otra cadena y devuelve verdadero si es
boolean termina con (String str)
determina si la cadena termina con otra cadena y devuelve verdadero si es
boolean contains(CharSequence s)
Devuelve verdadero si y solo si esta cadena contiene la secuencia especificada de valores char.
boolean isEmpty()
determina si la longitud de la cadena es 0 y devuelve verdadero si y solo si es 0

 /**boolean equals(Object anObject)
         * 字符串直接的比较
         * String继承自Object，重写父类方法
         */
        boolean b  = "abcd".equalsIgnoreCase("ABCD");
        boolean c  = "abcd".equals("abcD");
        boolean d = "Hello,world".startsWith("Hello");
        boolean e = "world,Hello".endsWith("Hello");
        boolean f = "Hello fine".contains("fi");
        boolean ff = "Hello fine".contains("if");

        System.out.println(b);  //true
        System.out.println(c);  //false
        System.out.println(d);  //ture
        System.out.println(e);  //true
        System.out.println(f);  //true
        System.out.println(ff); //false

El método equals reescrito por sun es el siguiente

 public boolean equals(Object anObject) {
    
    
        if (this == anObject) {
    
    
            return true;
        }
        if (anObject instanceof String) {
    
    
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
    
    
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
    
    
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

El método para obtener la clase String, el valor de retorno no es necesariamente

int length() devuelve la longitud de la cadena, el número de caracteres en la cadena
char charAt(int index) devuelve un solo carácter en el índice especificado
int indexOf(String str) devuelve la cadena especificada, el índice de la primera aparición en la cadena actual
int lastindexOf(String str) devuelve la cadena especificada, el índice de la última aparición en la cadena actual
String substring(int start, int end) intercepta una cadena, y los parámetros indican los índices inicial y final, donde la intercepción incluye el índice inicial y no incluye el índice final

 		//int length()返回字符串长度，字符串中字符的个数
        int length = "abcde".length();
        System.out.println(length);// 5
        //char charAt(int index) 返回指定索引上的单个字符
        char chr = "hedfgg".charAt(3);
        System.out.println(chr); //f
        //int indexOf(String str)返回指定的字符串，在当前字符串中第一次出现的索引
        int index = "hello word so smart".indexOf("s");
        System.out.println(index);//11
        //以s第一次出现为准
        int index1 = "hello word so smart".indexOf("so");
        System.out.println(index1);//11
        //int lastindexOf(String str)返回指定的字符串，在当前字符串中最后一次出现的索引
        int index2 = "hello word so smart".lastIndexOf(" ");
        System.out.println(index2);//13
        //String substring(int start,int end)截取字符串，参数表示开始和结束索引，其中截取包含开始索引，不包含结束索引
        String str = "hello world";  //是锁死的字面量”hello world”
        String str1 = str.substring(2,5);  //如果不赋值的化仍然是原str ，需要赋值新的字符串
        System.out.println(str1);//llo
        System.out.println(str.substring(2,5));//llo

Método de comparación de la clase String

public int compareTo(String anotherString)
Compara dos cadenas lexicográficamente (orden natural). Las comparaciones se basan en el valor Unicode de cada carácter de la cadena.

		/**
         * int compareTo(String anotherString) 按字典顺序（自然顺序）比较两个字符串
         */
        String str1 = "abcdef";
        String str2 = "abdefg";
        String str3 = "abcdef";
        String str4 = "abcdeg";
        /**
         * 返回值是int
         * 返回值为负，调用者小
         * 返回值为正，调用者大
         * 返回值为0，一样大
         */
        int i = str1.compareTo(str2);
        int j = str1.compareTo(str3);
        int k = str1.compareTo(str4);
        System.out.println(i);  //-1  底层是数组，数组中一个一个的比较 c<d为负，后边就不比了
        System.out.println(j);  //0   一个一个的比较，都相同 返回0
        System.out.println(k);  //-1  f<g为负

Métodos de la clase String, eliminar espacios, reemplazar, cortar

String trim() elimina los espacios a ambos lados de la cadena, pero no elimina los espacios en el medio
String replace (String oldString, String newString) reemplaza la cadena
String []split("cadena de reglas") corta la cadena

		// String trim() 去掉字符串两边的空格，中间的空格不去掉
        String str =" aa c bb d ";
        String s = str.trim();
        System.out.println(s); //aa c bb d

        //String []split("规则字符串") 对字符串进行切割
        String str1Split ="aa,bb,cc,dd";
        String[] strings = str1Split.split(",");
        for(int i =0; i< strings.length;i++){
    
    
            System.out.println(strings[i]);    // aa  bb cc dd
        }
        //String replace(String oldString,String newString)替换字符串
        String strReplace = "how are you ?";
        String replace = strReplace.replace("o", "ee");
        System.out.println(replace);  //heew are yeeu ?

Expresión regular de clase de cadena relacionada

clase de personaje:
- [abc]Esta posición de la cadena solo puede ser abc
- [^abc]Esta posición de la cadena no puede ser abc
- [a-zA-Z]Esta posición de la cadena debe ser una letra, 52 caracteres
- [^a-zA-Z]Esta posición de la cadena no debe ser una letra, 52 caracteres
Clase de número:
- [0-9]Esta posición de la cadena solo puede ser un número.
- [^0-9]Esta posición de la cadena no puede ser un número.
- [\d]Equivalente a[0-9]
- [\D]Equivalente a[^0-9]
Caracteres predefinidos:
- .coincide con todos los caracteres
- [\d]Equivalente a[0-9]
- [\D]Equivalente a[^0-9]
- [\w]Caracteres de texto, incluidos números, letras y guiones bajos[a-zA-Z0-9_]
- [\W]Caracteres de texto, no puede contener números, letras, guiones bajos[^a-zA-Z0-9_]
Cuantificadores:
- X{m} El carácter X solo puede aparecer m veces al{3}
- X{m,} El carácter X aparece al menos m veces
- X{m,n} El carácter X aparece al menos m veces y no más de n veces
- X? El carácter X aparece una vez, o no aparece en absoluto
- X* X Este carácter aparece cero o más veces
- X+ X Este personaje aparece al menos una vez (aparece una o más veces)

Verificación de coincidencia regular de cadena

boolen matches(String regex)
indica si esta cadena coincide con la expresión regular dada.
Si la coincidencia es exitosa, devuelve verdadero, si falla, devuelve falso.
Ejemplo:

/**
     *  检查邮箱
     *  规则需求 :
     * @ 前面 : 可以是字母,数字,_  
     * @ 后面 : 数字,字母  sina qq 126 1393 yahoo gmail 
     * . 固定 : com  cn org  edu gov 字母  
     */
public static void stringMethod2(){
    
    
    String email = "[email protected]";
    // "[a-zA-Z0-9] == [\\w] \\两个\其中一个代表转义"
    //"[\\w]+" 表示[\w] 匹配一次或多次
    //(\\.[a-z]+)+ 表示(\\.[a-z]+)这个匹配组匹配一次或多次  比如.com.cn
    String reg = "[\\w]+@[a-z0-9]+(\\.[a-z]+)+"; 
    boolean b = email.matches(reg);
    System.out.println(b);

}
/**
     *  正则表达式检查手机号是否合法
     * 规则需求
     *  开头必须是1,长度固定11
     *  第二位3 4 5 6 7 8 9
     *  第三位 必须是都是数字
     */
public static void stringMethod(){
    
    
    String tel = "13800138000";
    //定义正则的规则,也是字符串
    String regex = "1[3459678][0-9]{9}";
    //正则规则,和字符串校验
    //String类的方法 matches()
    boolean b = tel.matches(regex);
    System.out.println(b);
}

String[] split(String regex)
Divide esta cadena en coincidencias de la expresión regular dada.

   public static void stringMethod3(){
    
    
        String str = "as123d387654w5465fasfr234567sa";
        String[] strings = str.split("\\d+");
        for (int i = 0; i < strings.length; i++) {
    
    
            System.out.println(strings[i]);
        }  //as d w fasfr sa
        System.out.println("================");
        String ip = "192.....168.....35.121";
        String[] ipArray = ip.split("\\.+");
        for (int i = 0; i < ipArray.length; i++) {
    
    
            System.out.println(ipArray[i]);  
        }// 192  168   35 121
    }

String replaceAll(String regex, String replace)
Reemplaza cada subcadena de esta cadena que coincida con la expresión regular dada con el reemplazo dado.
String replaceFirst(String regex, String replace)
Reemplaza la primera subcadena de esta cadena que coincide con la expresión regular dada con el reemplazo dado.

 public static void stringMethod4(){
    
    
        String str = "as123d387654w5465fasfr234567sa";
        //字符串中的所有数组,换成#
        String repString = str.replaceAll("\\d+","#");
        System.out.println(repString);//as#d#w#fasfr#sa

        String first =  str.replaceFirst("\\d+","#");
        System.out.println(first);//as#d387654w5465fasfr234567sa
    }

En el desarrollo de programas String Builder
, a menudo se encuentra la concatenación de cadenas. La forma directa es usar el símbolo "+" para realizar el empalme directo de cadenas, pero este método creará un objeto String cada vez que se ejecute, lo cual es ineficiente. y requiere mucho tiempo Desperdicio de espacio. Este problema se puede evitar utilizando la clase StringBuilder
public final class StringBuilder
extends Object
implements Serializable, CharSequence
es una secuencia de caracteres variable (matriz de caracteres). Esta clase proporciona una API con StringBuffer, pero no se garantiza la sincronización.
Al crear un objeto, la longitud de inicialización de la matriz en StringBuilder es de 16 caracteres

StringBuilder expande automáticamente la matriz, se realiza la nueva matriz y los elementos de la matriz original se copian en la nueva matriz.

Conclusión: no importa cómo realice las operaciones de cadena, siempre habrá una sola matriz dentro de StringBuilder

La clase StringBuilder es una clase no segura para subprocesos que se ejecuta rápidamente

StringBuffer es una clase segura para subprocesos que se ejecuta lentamente y es utilizada por programas de subprocesos múltiples

Los métodos de construcción de las dos clases son exactamente los mismos que los otros métodos.

 	   StringBuilder builder = new StringBuilder(20);
        builder.append("helo");
        System.out.println(builder); //helo
        builder.insert(3,"world");
        System.out.println(builder);//helworldo

        StringBuilder builder1 = new StringBuilder(16);
        System.out.println(builder1.append("hello").append("world").append("  ").append("over"));// helloworld  over

Métodos comunes de clase de objeto Java y clase de cadena y métodos comunes

Clase de objeto Java

Métodos importantes de la clase comúnmente utilizados

Clase de cadena de cadena

Métodos comunes de la clase String

Supongo que te gusta