Clase de cadena básica de Java (día 6)

1.Descripción general de la clase de cadena

API （Application Programming Interface,应用程序编程接口）
	1.Java写好的技术（功能代码），咱们可以直接调用。
	2.Oracle也为Java提供的这些功能代码提供了相应的API文档（技术使用说明书）。

	3.String.lang.String类代表字符串，String类定义的变量可以用于指向字符串对象，然后操作该字符串。
	4.Java程序中的所有字符串文字（例如“abc”）都为此类的对象
	5.String常被称为不可变字符串类型，它的对象在创建后不能被更改。

1. ¿Qué es una cuerda? ¿Qué se puede hacer?
Respuesta: Tipo de cadena, puede definir una variable de cadena para que apunte a un objeto de cadena.
2. ¿Por qué String es una cadena inmutable?
Respuesta: (1) Cada modificación de la variable String en realidad genera y crea un nuevo objeto string.
(2) Los objetos de cadena originales permanecen sin cambios, por lo que se denominan cadenas inmutables.

2. Dos formas de crear objetos usando la clase String

方式一：直接使用" "定义。（推荐的）
方式二：通过String类的构造器创建对象。

Luego lo usamos en la idea:

public class StringDemo1 {
    
    
    public static void main(String[] args) {
    
    
        // 方式一：直接使用双引号得到字符串对象
        String name = "我爱你China";
        System.out.println(name);

        // 方式二：
        //1.public String():创建一个空白字符对象，不含有任何内容（几乎不用// ）
        String s1 = new String();
        System.out.println(s1);

        //2.public String(String):根据传入的字符串内容，来创建字符对象（几乎不用）
        String s2 = new String("我是中国人");
        System.out.println(s2);

        //3.public String(char[] c):根据字符数组的内容，来创建字符串对象
        char[] chars = {
    
    'a' , 'b' ,'中' , '国'};
        String s3 = new String(chars);
        System.out.println(s3);

        // 4.public String(byte[] b): 根据字节数组的内容，来创建字符串对象
        byte[] bytes = {
    
    97 , 98, 99 ,65 ,66 ,67};
        String s4 = new String(bytes);
        System.out.println(s4);

3. Preguntas comunes de la entrevista sobre cadenas

1.以" "方式给出的字符串对象,在字符串常量迟中存储,而且相同内容只会在其中存储一份.
2.通过构造器new对象,每new一次都会产生一个新对象,放在堆内存中.

        String ss1 = "abc";
        String ss2 = "abc";
        System.out.println(ss1 == ss2);

        String ss3 = "abc";
        String ss4 = "abc";
        System.out.println(ss3 == ss4);

Resultado de ejecución:
verdadero El principio de
verdadero
es en realidad este:


mira

4. API de uso común para la comparación de contenido de cadena y clase de cadena

1. Comparación del contenido de la cadena:
   se recomienda utilizar la comparación "igual" proporcionada por la clase String: solo le importa el mismo contenido
   Nombre del método descripción
   public boolean equals(object an0object) Compare esta cadena con el objeto especificado, solo le importa si ¡El contenido del carácter es consistente!
   public boolean equalsIgnoreCase(String anotherString) Compara esta cadena con el objeto especificado, ignorando las cadenas de comparación de casos. Solo le importa si el contenido del carácter es consistente. Practiquemos la idea
   :

import java.util.Scanner;

public class StringEqualsDemo4 {
    
    
    public static void main(String[] args) {
    
    
        //1.正确登录名和密码
        String okname = "yueyue";
        String okPassword = "123456";

        //2. 请你输入登录名称和密码
        Scanner sc = new Scanner(System.in);
        System.out.println("登录名称:");
        String name = sc.next();
        System.out.println("登录密码:");
        String password = sc.next();

        //3.判断用户输入的登录名称和密码与正确的内容是否相等
        if (okname.equals(name)  && okPassword.equals(password)){
    
    
            System.out.println("登录成功");
        }else{
    
    
            System.out.println("用户名或者密码错误了");
        }

        //4. 忽略大小写比较内容的API;一般用于比较验证码这样的业务逻辑
        String sysCode = "23AdFh";
        String code1 = "23aDfh";
        System.out.println(sysCode.equals(code1));
        System.out.println(sysCode.equalsIgnoreCase(code1));

    }
}
E:\Java\jdk-11.0.9\bin\java.exe "-javaagent:E:\soft\IntelliJ IDEA 2021.2.1\lib\idea_rt.jar=65339:E:\soft\IntelliJ IDEA 2021.2.1\bin" -Dfile.encoding=UTF-8 -classpath E:\java\example\out\production\Demo1 demo3.StringEqualsDemo4
登录名称:
yueyue
登录密码:
123456
登录成功
false
true

Process finished with exit code 0

5. API de la clase String de uso común: operaciones de recorrido, reemplazo, interceptación y división

1.public int length() Devuelve la longitud de esta cadena
2.public char charAt(int index) Obtiene el carácter en una determinada posición de índice
3.public char[ ] toCharArray(): convierte la cadena actual en una matriz de caracteres y devuelve
4 .public String substring(int beginInex, int endIndex) intercepta según el inicio y el índice para obtener una nueva cadena
5. public String substring(int beginIndex) intercepta desde el índice pasado e intercepta hasta el final para obtener una nueva cadena 6.public
String replace(CharSequence target, CharSequence replacement) utiliza el nuevo valor para reemplazar el valor antiguo en la cadena para obtener una nueva cadena.
7.public String[ ] split(String regex) corta la cadena de acuerdo con lo pasado. reglas. Obtenga una matriz de cadenas y devuélvala.
Practiquémoslo en la idea:

public class Stringdemo2 {
    
    
    public static void main(String[] args) {
    
    
        // 1.pubic int length(): 获取字符串的长度
        String name = "我爱你中国love";
        System.out.println(name.length());

        //2.public char charAt(int index):获取某个索引位置
        char c = name.charAt(1);
        System.out.println(c);

        System.out.println("-------遍历字符串中的每个字符--------");
        for (int i = 0; i < name.length() ; i++) {
    
    
            char ch = name.charAt(i);
            System.out.println(ch);

        }

        // 3.public char[] toCharArray(); 把字符串转换成字符数组
        char[] chars = name.toCharArray();
        for (int i = 0; i < chars.length; i++) {
    
    
            char ch = chars[i];
            System.out.println(ch);
        }

        //4.public String substring(int beginIndex, int endIndex):截取内容(包前不包后)
        String name2 = "Java是最厉害的编程语言!";
        String rs = name2.substring(0, 9);
        System.out.println(rs);
        String rs1 = name2.substring(4, 9);
        System.out.println(rs1);

        // 5.public String substring(int beginIndex):从当前索引一直截取到末尾
        String rs2 = name2.substring(4);
        System.out.println(rs2);

        //6.public String replace(CharSequence target, CharSequence replacement)
        String name3 = "奥特曼是最厉害的80后,奥特曼帮帮的,我好爱奥特曼";
        String rs3 = name3.replace("奥特曼","***");
        System.out.println(rs3);

        //7.public boolean contains(CharSequence s)
        System.out.println(name3.contains("奥特曼"));
        System.out.println(name3.contains("奥特曼"));

        // 8.public boolean startsWith(String prefix)
        System.out.println(name3.startsWith("奥特曼"));
        System.out.println(name3.startsWith("奥特曼是最厉害的"));
        System.out.println(name3.startsWith("奥特曼是最厉害的2"));

        //9.public String[] split(String s): 按照某个内容把字符串分割成字符串数组返回
        String name4 = "王宝,贾乃,陈羽";
        String[] names = name4.split(",");
        for (int i = 0; i < name.length(); i++) {
    
    
            System.out.println("选择了:" + names[i]);
        }

    }
}
E:\Java\jdk-11.0.9\bin\java.exe "-javaagent:E:\soft\IntelliJ IDEA 2021.2.1\lib\idea_rt.jar=65403:E:\soft\IntelliJ IDEA 2021.2.1\bin" -Dfile.encoding=UTF-8 -classpath E:\java\example\out\production\Demo1 demo3.Stringdemo2
9
爱
-------遍历字符串中的每个字符--------
我
爱
你
中
国
l
o
v
e
我
爱
你
中
国
l
o
v
e
Java是最厉害的
是最厉害的
是最厉害的编程语言!
***是最厉害的80后,***帮帮的,我好爱***
true
false
true
true
false
选择了:王宝
选择了:贾乃
选择了:陈羽

Resumir

Hay muchas clases poderosas en la clase String y debemos usar cada una de ellas con habilidad.