Video + Resumen de productos secos de cadena gráfica

1. Introducción y explicación en video de las cadenas de caracteres.

1. La cadena es una constante, el método de representación: encerrado entre comillas dobles ""
2. Cadena de valor en el que no se puede modificar después de la creación , cada vez que sienta la cadena ha cambiado y que es la creación de una nueva cadena

Haga clic aquí para ir a la estación B para ver el video.

Dos, dos formas de crear una cadena

Método 1: crear mediante nuevo

String str = new String("abcd");

Método 2: crear directamente

String str1 = ("abcd");

En tercer lugar, la longitud de la adquisición de cadenas: método length ()

String str1 = ("abcd");
int length = str1.length();
System.out.println("abcd的长度为："+length)；//4

Cuarto, use el método == y equals () para comparar dos cadenas

1. Use == para comparar dos cadenas (analizando así la diferencia entre dos formas de crear cadenas)

Para los tipos de referencia , el == realizada es comparar el valor de dirección

		String str = new String("abcd");//第一种创建方式：通过new创建
		String str1 = new String("abcd");//第一种创建方式：通过new创建
		String stra = "abcd";//第二种创建方式：直接创建
		String strb = "abcd";//第二种创建方式：直接创建
		System.out.println(str == str1);//new出的两个字符串对象之间比较，false
		System.out.println(str == stra);//new出的字符串对象与直接创建的字符串对象之间比较，false
		System.out.println(stra == strb);//直接创建的两个字符串对象之间比较，true

(1) Para la comparación entre dos cadenas creadas de la nueva manera

De System.out.println(str == str1);//new出的两个字符串对象之间比较，falselos resultados de ejecución del código, podemos ver:

		String str = new String("abcd");//第一种创建方式：通过new创建
		String str1 = new String("abcd");//第一种创建方式：通过new创建

• Los objetos de cadena str y str1 creados por new tienen el mismo contenido
• Pero debido a que es nuevo, son dos objetos diferentes, por lo que sus valores de dirección deben ser diferentes.

Para tipos de referencia == comparar valores de dirección

• Entonces el resultado de ejecución es falso

(2) Comparación entre dos cadenas creadas directamente

De System.out.println(stra == strb);//直接创建的两个字符串对象之间比较，truelos resultados de ejecución del código, podemos ver:

		String stra = "abcd";//第二种创建方式：直接创建
		String strb = "abcd";//第二种创建方式：直接创建
		System.out.println(stra == strb);//true

1. Crear y dirigir los objetos de cadena stra STRB del mismo contenido y el mismo valor de dirección

2. Los motivos son los siguientes:

   Crea directamente objeto de cadena se almacena en una piscina constante de cadena de

   Cadena de la piscina constante que no parece duplicar la cadena de dirección que corresponde al objeto , que puede garantizar que la cadena no se repetirá

3. Así Stra y strb el valor de la dirección es la misma , los resultados operativos en lo cierto

(3) Comparación entre la cadena creada directamente y la cadena creada por new

De System.out.println(str == stra);//new出的字符串与直接创建的字符串对象之间比较，falselos resultados de ejecución del código, podemos ver:

		String str = new String("abcd");//第一种创建方式：通过new创建
		String stra = "abcd";//第二种创建方式：直接创建

• El str creado por new y el objeto stra string creado directamente tienen el mismo contenido

• Pero el nuevo fuera del objeto de cadena almacenada en la pila , uno es para crear directamente un objeto de cadena almacenada en una piscina constante de cadena de

• Entonces sus valores de dirección deben ser diferentes

• Entonces el resultado de ejecución es falso

2. Compare dos cadenas con el método equals (): compare si el contenido de las dos cadenas es el mismo

• Porque los contenidos de estas 4 cadenas son todos "abcd"
• Entonces, cuando se compara con el método equals () , el resultado es verdadero

		String str = new String("abcd");
		String str1 = new String("abcd");
		String stra = "abcd";
		String strb = "abcd";
		System.out.println(str.equals(str1));//true
		System.out.println(str.equals(stra));//true
		System.out.println(stra.equals(strb));//true

Cinco, la conexión de la cadena

(1) Conectar con "+": se puede conectar con diferentes tipos

		String str = new String("abcd");
		int a = 12;
		String b = a + str;
		System.out.println(b);//12abcd

(2) Conéctese con el método concat (): solo se puede utilizar para la conexión de cadenas y cadenas

		String str1 = new String("abcd");
		String str2 = str.concat(str1);
		System.out.println(str1);//abcd
		System.out.println(str2);//abcdabcd

La salida de str1 y str2 anterior se puede entender mucho antes:

Cadena de valor en el que no se puede modificar después de la creación , cada vez que sienta la cadena ha cambiado y que es la creación de una nueva cadena

Seis, determinar si una cadena contiene la cadena especificada

La "secuencia de valores de caracteres es más esotérica" ​​aquí.

En los primeros días, podemos entender directamente que el uso del método contiene () puede:

• Compruebe si una cadena contiene la cadena especificada

• Tales como: El ejemplo siguiente es determinado cadena str en si contiene "ab" secuencia

   	String str = new String("abcd");
   	boolean judge = str.contains("ab");
   	System.out.println(judge);//true

Siete, la conversión del caso de la cadena

(1) Convertir cadena en mayúscula a minúscula

		String strc = ("ABREa");
		System.out.println(strc);//ABREa
		System.out.println(strc.toLowerCase(););//abrea

De la salida de strc y strc.toLowerCase () anterior, puede comprender lo que se dijo anteriormente:

Cadena de valor en el que no se puede modificar después de la creación , cada vez que sienta la cadena ha cambiado y que es la creación de una nueva cadena

(2) Convertir cadenas en minúsculas a mayúsculas

		String str = new String("abcd");
		System.out.println(str);//abcd
		System.out.println(str.toUpperCase(););//ABCD

De la salida de str y str.toUpperCase () anterior, puede comprender lo que se dijo anteriormente:

Cadena de valor en el que no se puede modificar después de la creación , cada vez que sienta la cadena ha cambiado y que es la creación de una nueva cadena

8. Obtenga el carácter correspondiente al índice especificado

Nota: El índice de la cadena comienza desde 0

		String str = new String("abcd");
		System.out.println(str);//abcd
		System.out.println(str.charAt(1));//b

De la salida de str y str.charAt (1) anterior, puede comprender lo que se dijo anteriormente:

Cadena de valor en el que no se puede modificar después de la creación , cada vez que sienta la cadena ha cambiado y que es la creación de una nueva cadena

Nueve, obtenga el índice de la primera aparición de la cadena especificada

Los resultados de salida de los siguientes dos métodos de conversión se pueden entender bien antes:

Cadena de valor en el que no se puede modificar después de la creación , cada vez que sienta la cadena ha cambiado y que es la creación de una nueva cadena

El primero:

		String str4 = "012345618a9";
		int index = str4.indexOf("1");//找到字符串"1"首次出现的索引
		System.out.println(index2);//1
		System.out.println("=====================");
		int index1 = str4.indexOf("1", index + 1);//从index2 + 1开始找字符串"1"首次出现的索引
		System.out.println(index3);//7

• Cuando index2 = 1, index 1 registra la primera aparición de la subcadena "1"
• Así pues, en busca de la "1" segunda subserie posición que parece ser de index2 + 1 posición para empezar a buscar
• Porque se ha encontrado la posición de index2
• Si también encontrar la ubicación de índice 2 = 1 , entonces el índice es 1 o encontradas
  

El segundo tipo:

		String str5 = "012345612a9";
		int index4 = str5.indexOf('2');//找到字符'2'首次出现的索引
		System.out.println(index4);//2
		System.out.println("=====================");
		int index5 = str5.indexOf('2', index4 + 1);//从index4 + 1开始找字符'2'首次出现的索引
		System.out.println(index5);//8

• Cuando index4 = 2, index 2 registra la posición de la primera aparición del carácter '2'
• Así look para el segundo carácter '2' posición parece ser de Index4 + 1 posición para empezar a buscar
• Porque se ha encontrado la posición de index4
• Si también encontrar la ubicación de Index4 = 1 , entonces el índice se encuentra todavía 2

Diez, matriz de caracteres de conversión de cadena y conversión entre cadena y tipos de datos básicos

Vea aquí para una explicación detallada ~~

(1) Matriz de caracteres de conversión de cadenas

		String str = new String("abcd");
		char ch[] = str.toCharArray();//将字符串转换为字符数组
		for(int i =0;i<ch.length;i++) {//遍历得到的字符数组
			System.out.println(ch[i]);
		}

(2) Conversión entre cadenas de caracteres y tipos de datos básicos

1. Convertir cadena a tipo de datos básico: tome la conversión de cadena a int como ejemplo

		//字符串转换成int型
		String stre = "123456";
		int a1 = Integer.parseInt(stre);//对应的包装类.parsexxx 方法
		System.out.println(a1+2);//123458，证明是int型

2. Conversión de tipos de datos básicos a cadenas: tomando como ejemplo la conversión de tipo int a cadenas

		//int型转换成字符串
		int num =123;
		String strs = String.valueOf(num);// String.valueOf()方法
		System.out.println(strs+12);//12312，证明是字符串

Los productos secos para esta cadena se resumirán ~~

Todos son bienvenidos a la cuenta pública "Estación de intercambio de contenido de programación de Xiao Qiao"
para encontrar a Xiao Qiao para jugar ~
Aprender Java + Algoritmo ~
Hay más recursos esperándote ~