Recientemente aprendí la clase JAVA String y escribí un blog para registrar las notas de estudio, principalmente introduciendo cadenas Java de cinco partes, (1) Introducción a String String (2) String String Métodos comunes (3) String String Operaciones convencionales como Truncar y Encontrar particiones, etc., (4) las características de almacenamiento y la inmutabilidad de las cadenas, (5) la comparación entre String, StringBuilder y Stringbuffer.
(1) Introducción a String
En JAVA, usamos String para representar cadenas, como "abd", "132asdjkdv", etc. Todos los literales de cadena (por ejemplo "abc") en los programas Java se implementan como instancias de esta clase.
String es una clase fianl que representa una secuencia inmutable de caracteres. Las cadenas no se modifican; sus valores no se pueden cambiar después de la creación. El búfer de cadenas admite cadenas variables. Dado que los objetos String son inmutables, se pueden compartir. P.ej:
String str = "abc";
Es equivalente a:
char data [] = {'a', 'b', 'c'};
Cadena str = nueva Cadena (datos);
Las características de la cuerda:
- El contenido de la cadena nunca se puede cambiar después de su creación. (Énfasis)
- Debido a que la cadena es inmutable después de su creación, la cadena se puede compartir.
- El resultado del procesamiento de cadenas es equivalente a la matriz de caracteres char [], pero el principio subyacente es la matriz de bytes [].
- El objeto de cadena creado por nuevo, cada vez que nuevo, se aplicará a un espacio de memoria, aunque el contenido es el mismo, pero el valor de la dirección es diferente,
- La cadena dada en forma de "", siempre que la secuencia de caracteres sea la misma (el orden y el caso sean exactamente iguales), no importa cuántas veces aparezca en el código del programa, la JVM solo creará un objeto String y colóquelo en el grupo de constantes de cadena de la memoria del montón.
Puntos a tener en cuenta en la aplicación String
- String s1 = "a"; Descripción: Se crea una cadena con el literal "a" en el grupo de constantes de cadena.
- s1 = s1 + "b"; Explicación: De hecho, el objeto de cadena "a" original se ha descartado y ahora se genera una cadena s1 + "b" (es decir, "ab") en el espacio de almacenamiento dinámico. Si estas operaciones que cambian el contenido de la cadena se ejecutan varias veces, se almacenará una gran cantidad de objetos de cadena duplicados en la memoria, lo que reduce la eficiencia. Si dicha operación se coloca en un bucle, afectará en gran medida el rendimiento del programa.
- String s2 = "ab"; Descripción: crea directamente una cadena con el literal "ab" en el grupo de constantes de cadena.
- String s3 = "a" + "b"; Descripción: s3 apunta a la cadena "ab" que se ha creado en el grupo de constantes de cadenas. String s4 = s1.intern (); Descripción: Después de llamar a intern () para el objeto s1 en el espacio del montón, la cadena "ab" que ya existe en el grupo de constantes se asignará a s4.
(Dos) métodos de cadena de uso común
Los métodos más utilizados de la clase String en Java son los siguientes:
Ejemplo de programa:
package strings;
/**
* Created with IntelliJ IDEA.
* User: yongping Li
* Date: 2020/11/14
* Time: 10:47
* Description: No Description
*/
/*
String类适用于描述字符串事物。那么它就提供了多个方法对字符串进行操作。
常用的方法如下：
1、获取：
1.1 字符串中包含的字符数，也就是字符串的长度。
int length():获取长度。
1.2 根据位置获取该位置上的某个字符。
char charAt(int index):返回指定索引处的char值。
1.3 根据字符获取该字符在字符串的位置。
int indexOf(String str):返回的是str在字符串中第一次出现的位置。
int indexOf(int ch,int fromIndex):从fromIndex指定位置开始，获取ch在字符串中出现的位置。
int lastIndexOf(int ch):反向索引一个字符出现的位置
2、判断：
2.1 字符串中是否包含某一个子串。
boolean contains(str);
特殊之处：indexOf(str):可以索引str第一次出现的位置，如果返回-1表示该str不在字符串中存在。
所以，也可以用于对指定判断是否包含。
if(str.indexOf("aa")!=-1)
而且该方法既可以判断，又可以获取出现的位置
2.2 字符中是否有内容。
boolean isEmpty():原理就是判断长度是否为0.
2.3 字符串是否是以指定内容开头。
boolean startsWith(str);
2.4 字符串是否是以指定内容结尾。
boolean endsWith(str);
2.5判断字符串内容是否相同。复写Object类中的equals方法。
boolean equals(str);
2.6 判断内容是否相同，并忽略大小写
boolean equalsIgnoreCase();
3、转换
3.1 将字符数组转换成字符串。
构造函数： String(char[])
String(char[],offset,count):将字符数组中的一部分转换成字符串。
静态方法：
static String copyValueOf(char[]);
static String copyvalueOf(char[] data, int offset, int count);
3.2 将字符串转换成字符数组（重点）。
char[] toCharArray();
3.3 将字节数组转换成字符串。
String(byte[])
String(byte[],offset,count):将字节数组中的一部分转换成字符串。
3.4 将字符串转换成字节数组
3.5 将基本数据类型转换成字符串。
String valueOf(int);
String valueOf(double);
特殊：字符串和字节数组在转换过程中是可以指定编码表的。
4、替换
String replace(oldchar,newchar);
5、切割
String[] split(regex);
6、子串 获取字符串中的一部分
String substring(begin);
String substring(begin,end);
7、转换，去除空格，比较
7.1 将字符串转成大写或者小写。
String toUpperCase();
String toLowerCase();
7.2 将字符串两端的多个空格去除。
String trim();
7.3 将两个字符串进行自然顺序的比较。
*/
public class StringDemo {
//转换，去除空格，比较
public static void method_7(){
String s="Hello Java";
sop("原字符串为："+s);
//转换大小写
sop(s.toUpperCase());
sop(s.toLowerCase());
//去除空格
sop(s.trim());
//字符串比较
String s1="acc";
String s2="aaa";
sop(s1.compareTo(s2));
}
//子串 获取字符串中的一部分
public static void method_sub(){
String s="abcdefghijklmnopqrstuvwxyz";
sop("原字符串为");
sop(s);
String s1=s.substring(9); //从指定位置到结尾。如果角标不存在，则会出现字符串角标越界异常。
sop("获取的子串s1为：");
sop(s1);
String s2=s.substring(7,20); //包含头，不包含尾。 获取整个字符串：s.substring(0,s.length());
sop("获取的子串s2为：");
sop(s2);
}
//切割
public static void method_split(){
String s="zhangsan,lisi,wangwu";
String[] arr=s.split("a");
sop("原字符串为：");
sop(s);
sop("切割后的字符串为：");
for(int x=0;x<arr.length;x++)
{
System.out.print(arr[x]+" ");
}
System.out.println();
}
//判断
public static void method_is(){
String str="ArrayDemo.java";
String str1="arraydemo.java";
//判断文件名称是否以Array开头
sop(str.startsWith("Array"));
//判断文件名称是否是以.java结尾
sop(str.endsWith(".java"));
//判断文件名称中是否包含Demo
sop(str.contains("Demo"));
//判断两个文件名是否相同（区分大小写）
sop(str.equals(str1));
//判断两个文件名是否相同（不区分大小写）
sop(str.equalsIgnoreCase(str1));
}
//获取
public static void method_get(){
String str="abcdeakpf";
sop("字符串为："+str);
//长度
sop("字符串的长度为："+str.length());
//根据索引获取字符
sop("角标为四的位置上的字符为："+str.charAt(4));//当访问到字符串中不存在的角标时，会发生 StringIndexOutOfBoundsException异常
//根据字符获取索引
sop("从角标为3的位置开始往后索引 a 出现的位置为："+str.indexOf('a',3));//如果没有找到返回-1
//反向索引一个字符出现的位置
sop("从字符串右面开始索引第一个a出现的位置为："+str.lastIndexOf("a"));
}
//转换
public static void method_trans(){
char[] arr={'a','b','c','d','e','f','g','h'};
String str="jkasdhavsgjv";
char[] a=str.toCharArray();
//字符串操作
System.out.print("将字符串转换为字符数组为：[");
for(int x=0;x<a.length;x++)
{
if(x<a.length-1)
System.out.print(a[x]+",");
else
System.out.print("]");
}
System.out.println();
//字符数组操作
System.out.print("字符数组为：[");
for(int x=0;x<arr.length;x++)
{
if(x<arr.length-1)
System.out.print(arr[x]+",");
else
System.out.print("]");
}
System.out.println();
String s=new String(arr);
sop("转换成字符串为："+s);
//获取从角标为1的位置的字符开始三个字符
String s1=new String(arr,1,3);
sop("从角标为1的位置的字符开始三个字符组成的字符串为："+s1);
}
//替换
public static void method_replace(){
String s=" hello java ";
String s1=s.replace('a', 'n'); //如果要替换的字符不存在，则返回的还是原字符串
sop("原来的字符串为："+s);
sop("替换字符后的字符串为："+s1);
}
//主函数
public static void main(String[] args) {
method_get();
method_is();
method_trans();
method_replace();
method_split();
method_sub();
method_7();
}
//输出结果
public static void sop(Object obj){
System.out.println(obj);
}
}resultado de la operación:
字符串为：abcdeakpf
字符串的长度为：9
角标为四的位置上的字符为：e
从角标为3的位置开始往后索引 a 出现的位置为：5
从字符串右面开始索引第一个a出现的位置为：5
true
true
true
false
true
将字符串转换为字符数组为：[j,k,a,s,d,h,a,v,s,g,j,]
字符数组为：[a,b,c,d,e,f,g,]
转换成字符串为：abcdefgh
从角标为1的位置的字符开始三个字符组成的字符串为：bcd
原来的字符串为： hello java
替换字符后的字符串为： hello jnvn
原字符串为：
zhangsan,lisi,wangwu
切割后的字符串为：
zh ngs n,lisi,w ngwu
原字符串为
abcdefghijklmnopqrstuvwxyz
获取的子串s1为：
jklmnopqrstuvwxyz
获取的子串s2为：
hijklmnopqrst
原字符串为：Hello Java
HELLO JAVA
hello java
Hello Java
2
Process finished with exit code 0
(3) Operación convencional de cadenas
Las operaciones regulares de una cadena incluyen búsqueda, intercepción y segmentación. Estos métodos correspondientes en la clase String se pueden llamar directamente o una llamada completa de varios métodos.
package strings;
/**
* Created with IntelliJ IDEA.
* User: yongping Li
* Date: 2020/11/14
* Time: 10:53
* Description: No Description
*/
public class newStringDemo {
public static void main(String[] args) {
/*
* 查找子串
*/
String str1="dwqae12232aebdalf";
//查找指定字符第一次出现的位置
int first1=str1.indexOf(97);//参数为字符的ascii码
//查找指定字符串第一次出现的位置
int first2=str1.indexOf("12");
//查找指定字符第一次出现的位置，从索引处开始（包括索引处）
int first3=str1.indexOf(97, 0);
//查找指定字符串第一次出现的位置，从索引处开始（包括索引处
int first4=str1.indexOf("12232",0);
System.out.println("first1="+first1);
System.out.println("first1="+first2);
System.out.println("first1="+first3);
System.out.println("first1="+first4);
System.out.println("-------------");
/*
* 截取字符串
*/
//从索引处到末尾（不包括索引处）
String substr1=str1.substring(5);
//指定区间（包括结束索引处）
String substr2=str1.substring(5, 10);
System.out.println("substr1="+substr1);
System.out.println("substr2="+substr2);
System.out.println("-------------");
/*
* 分割字符串
*/
//以a为分割字符
String[] splitstr=str1.split("a");
for(String res : splitstr){
System.out.println(res);
}
//注：如果分割字符为正则表达式里的字符，则需要"\"做转义
}
}
Los resultados de la operación son los siguientes ·:
first1=3
first1=5
first1=3
first1=5
-------------
substr1=12232aebdalf
substr2=12232
-------------
dwq
e12232
ebd
lf
Process finished with exit code 0(4) Las características de almacenamiento y la inmutabilidad de las cuerdas.
En la asignación de memoria de Java, hay un total de 3 tipos de grupos de constantes, a saber , grupo de constantes de clase , grupo de constantes de tiempo de ejecución y grupo de constantes de cadena. La estructura de memoria de JVM es:
Análisis de memoria cuando se define String:
Definición de clase String
String s1 = "abc";
String s2 = "abc";
s1 = "hola";
Análisis de la memoria de cadenas:
Comparación de dos métodos de definición de String
String S="abc";
String s=new String("abc");Análisis de memoria:
Comparación de cadena y matriz de caracteres:
//String的两种定义方式
String a="abc";
String s=new String("abc");
char[] arr={'a','b'};
char [] ass={'a','b','c','d','e'};
String s=new String(arr,13,43);
Análisis de memoria:
En resumen, String s = "adb", abd se almacena en el grupo constante, String s = new String ("abd"), s apunta al valor en el montón y el valor apunta a abd en el grupo constante;
La inmutabilidad de String significa que cada método en String que parece modificar el valor de String en realidad crea un nuevo objeto String para contener el objeto String modificado, mientras que el objeto String original no ha cambiado.
Ejemplo de programa:
package strings;//: strings/Immutable.java
public class Immutable {
public static String upcase(String s) {
return s.toUpperCase();
}
public static void main(String[] args) {
String q = "howdy";
System.out.println(q); // howdy
String qq = upcase(q);
System.out.println(qq); // HOWDY
System.out.println(q); // howdy
}
} /* Output:
howdy
HOWDY
howdy
*///:~
El resultado de la operación es
Ejemplo de código:
package strings;
/**
* Created with IntelliJ IDEA.
* User: yongping Li
* Date: 2020/11/14
* Time: 15:10
* Description: No Description
*/
public class StringTest {
public static void main(String[] args) {
String str1 = "abc";
String str2 = "bcd";
System.out.println(str1);
System.out.println(str2);
str1 = str2;
System.out.println(str1);
System.out.println(str2);
System.out.println(str1 == str2);
//.......
str1 = new String("bcd");
System.out.println(str1);
System.out.println(str1 == str2);
}
}
resultado de la operación:
Ejecutar análisis de proceso:
Comience a ejecutar el programa:
String str1 = "abc";
String str2 = "bcd";
(Desde la perspectiva de la memoria) Cuando se utilizan valores literales para crear una cadena, el compilador buscará en el área del método estático (grupo constante de cadenas) para encontrar si hay valores literales (aquí, abc y bcd). , será en un método estático.Cree en el área (grupo constante de cadena), y asigne valores a nuestro str1 y str2 (asigne la dirección de abc a str1, lo mismo es cierto para str2);
luego
str1 = str2;
Cuando el objeto se crea posteriormente
str1 = nueva cadena ("bcd");
Cuando se comparan los dos:
str2 = nueva cadena ("bcd");
System.out.println (str1 == str2);
(5) Comparación entre String StringBuilder y StringBuffer
StringBuilder y StringBuffer son mejoras de String. Sabemos que String tiene inmutabilidad y determinismo de longitud, es decir, una secuencia de caracteres inmutable. Entonces, cómo definir una secuencia de caracteres variable, java.lang.StringBuffer representa una secuencia de caracteres variable, puede agregar o elimine el contenido de la cadena, y no se generarán nuevos objetos en este momento. Muchos métodos son iguales a String. Cuando se pasa como parámetro, el valor se puede cambiar dentro del método.
La clase StringBuffer es diferente de String en que sus objetos deben generarse utilizando un constructor. Hay tres constructores:
StringBuffer (): un búfer de cadena con una capacidad inicial de 16
StringBuffer (int size): construye un búfer de cadena con una capacidad especificada
StringBuffer (String str): inicializa el contenido al contenido de cadena especificado
Método común
StringBuffer append (xxx): proporciona una gran cantidad de métodos append () para empalmar cadenas
StringBuffer delete (int start, int end): elimina el contenido en la posición especificada
StringBuffer replace (int start, int end, String str): reemplaza la posición [start, end) con str
Insertar StringBuffer (int offset, xxx): insertar xxx en la posición especificada StringBuffer reverse (): invertir la secuencia de caracteres actual
StringBuilder y StringBuffer son muy similares, ambos representan secuencias de caracteres variables y los métodos para proporcionar funciones relacionadas también son los mismos.
Preguntas de la entrevista: Compare String, StringBuffer, StringBuilder
Cadena (JDK1.0): secuencia de caracteres inmutable
StringBuffer (JDK1.0): secuencia de caracteres variable, baja eficiencia, seguridad de subprocesos
StringBuilder (JDK 5.0): secuencia de caracteres variable, alta eficiencia, hilo inseguro. Nota: Si se pasa como parámetro, String dentro del método no cambiará su valor, StringBuffer y StringBuilder cambiarán su valor.
Estructura de herencia:
Comparación de los tres
1) String es una secuencia de caracteres inmutable, StringBuilder y StringBuffer son secuencias de caracteres variables.
2) Velocidad de ejecución StringBuilder> StringBuffer> String.
3) StringBuilder no es seguro para subprocesos, StringBuffer es seguro para subprocesos
(6) Conversión entre String y tipos de datos básicos
