1. Uso de String
1.1, método de instanciação de string
Método 1: Através da definição literal (os dados são declarados no pool constante de cadeias de caracteres na área do método)
Método 2: através do novo construtor + (salve o valor do endereço quando os dados estiverem no espaço de heap)
String s1 = "javaEE";
String s2 = "hadoop";
String s3 = "javaEEhadoop";
String s4 = "javaEE" + "hadoop";
String s5 = s1+ "hadoop";
String s6 ="javaEE" +s2;
final String s7 = "javaEE";//常量
String s8 = s7 + "hadoop";
System.out.println(s3 == s8);//在常量池
System.out.println(s3 == s4);
System.out.println(s3 == s5);
System.out.println(s3 == s6);
System.out.println(s5 == s6);
Resultados de saída: verdadeiro, verdadeiro, falso, falso, falso
1.2 Conclusão da costura: o resultado da costura de constantes e constantes está no pool constante, e não haverá constantes com o mesmo conteúdo no pool constante. Enquanto houver uma variável, o resultado estará na pilha. Se o resultado da costura chamar intern (), o valor de retorno será Na piscina constante
1.3, String: string
1.String é declarado como final e não pode ser herdado. Use "" para indicar que
2.String implementa a interface serializável e suporta serialização ao representar a string.
Implementa a interface comparável: indica que a string pode ser comparada em tamanho
3.String internal Definiu o valor final char [] para armazenar dados da string
4.String: Sequência de caracteres que representa imutabilidade: Abreviação:
manifestação de imutabilidade : 1. Ao atribuir novamente a string, é necessário redesignar a área de memória para atribuir o valor, não é possível usar o original. Alguns valores são atribuídos
2. Ao unir uma sequência existente, você também precisa reatribuir a atribuição da área de memória, não é possível usar a atribuição original do valor
3. Ao chamar replace () de String para modificar a sequência ou o caractere especificado Quando, é necessário reatribuir a atribuição da área de memória.
5. Atribua um valor a uma string de maneira literal (diferente da nova) .A string no momento é declarada no método area-> string constant pool
6. O pool constante da string não armazena strings do mesmo conteúdo
String s1 = "abc";//字面量创建方式
String s2 = "abc";
s1 = "hello";
System.out.println(s1 == s2 );
System.out.println(s1);//hello
System.out.println(s2);//abc
System.out.println("****************************");
String s3 = "abc";
s3 +="def";
System.out.println(s3);//abcdef
System.out.println(s2);//abc 说明s3在拼接之后是，新开辟了一块空间
System.out.println("*************");
String s4 = "abc";
String s5 = s4.replace('a','m');
System.out.println(s4);//abc
System.out.println(s5);//mbc
1.4 Problema de conversão do projeto String para outras estruturas
① Conversão entre String e byte []
Codificação: String-> byte []: chama getBytes () da String
decodificação: byte [] -> String: chama o construtor de String
Nota: Ao decodificar, o conjunto de caracteres usado deve ser o mesmo que o conjunto de caracteres usado para a codificação, caso contrário, ficará ilegível
String str = "abc123";
byte[] bytes = str.getBytes();//使用默认的编码集
System.out.println(Arrays.toString(bytes));
Conversão entre String e char []
String-> char []: chame toCharArray ()
char [] -> String: chame o construtor de string
String str1 = "abc123";
char[] c = str1.toCharArray();
for (int i = 0; i < c.length; i++) {
System.out.println(c[i]);
}
Relationship Relação de conversão entre String e tipos de dados básicos e classes de empacotamento
String-->基本数据类型、包装类：调用包装类的静态方法parseXxx(str);
基本数据类型、包装类 --> String:调用重载的方法valueOf(xxx);
1.5, o uso do método String
（1）charAt(int index) 返回指定索引处的 char 值
（2）compareTo(String anotherString) 按字典顺序比较两个字符串，
（3）compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写
（4）concat(String str) 将指定字符串连接到此字符串的结尾，等价于用"+"
（5）contains(CharSequence s） 当且仅当此字符串包含指定的 char 值序列时，返回 true
（6）endsWith(String suffix) 测试此字符串是否以指定的后缀结束
（7）equals(Object anObject) 将此字符串与指定的对象比较
（8）format(String format, Object args) 使用指定的格式字符串和参数返回一个格式化字符串
（9）indexOf(int ch) 与 indexOf(int ch, int fromIndex)
返回在此字符串中第一次出现指定字符处的索引，后者要从指定的索引开始搜索
（10）indexOf(String str) 与 indexOf(String str, int fromIndex)
返回指定子字符串在此字符串中第一次出现处的索引，后者要从指定的索引开始搜索
（11）isEmpty() 当且仅当 length() 为 0 时返回 true
（12）lastIndexOf(int ch) 与 lastIndexOf(int ch, int fromIndex)
返回指定字符在此字符串中最后一次出现处的索引，后者要从指定的索引处开始进行反向搜索
（13）lastIndexOf(String str) 与 lastIndexOf(String str, int fromIndex)
返回指定子字符串在此字符串中最后一次出现处的索引，后者要从指定的索引开始反向搜索
（14）length() 返回此字符串的长度
（15）matches(String regex) 字符串是否匹配给定的正则表达式
（16）replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的
（17）replaceAll(String regex, String replacement) 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串
（18）replaceFirst(String regex, String replacement) 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串
（19）split(String regex) 根据给定正则表达式的匹配拆分此字符串
（20）startsWith(String prefix)
startsWith(String prefix, int toffset)
测试此字符串是否以指定的前缀开始，后者要从指定的索引开始搜索
（21）toCharArray() 将此字符串转换为一个新的字符数组
（22） toLowerCase() 与toLowerCase(Locale locale)
将此 String 中的所有字符都转换为小写，前者是使用默认环境，后者是使用指定Locale的规则
（23）toString() 返回此对象本身
（24）toUpperCase() 与 toUpperCase(Locale locale)
将此 String 中的所有字符都转换为大写，前者是使用默认环境，后者是使用指定Locale的规则
（25）trim() 返回字符串的副本，忽略前导空白和尾部空白
（26）valueOf(int i) 返回 int 参数的字符串表示形式（int 可以换成其他类型）
Pergunta da entrevista: String s = new String ("abc"); Crie objetos dessa maneira, quantos objetos são criados na memória?
Resposta: Dois, um é a nova estrutura no espaço de heap e o outro são os dados no pool constante correspondente a char []: "abc"
Incorporam a imutabilidade de strings
String str = new String("good");
char[] ch = {'t','e','s','t'};
public void chage(String str,char ch[]){
str ="test ok";
ch[0] = 'b';
}
public static void main(String[] args) {
StringTest st = new StringTest();
st.chage(st.str,st.ch);
System.out.println(st.str);//good;
System.out.println(st.ch);//best
}
2. Sobre o uso de StringBuffer e StringBuilder (ambos são semelhantes, a seguir é um exemplo de StringBuffer)
2.1 Semelhanças e diferenças entre String e StringBuffer e StringBuilder
- String: sequência de caracteres imutável, a parte inferior usa char [] para armazenamento
- StringBuffer: sequência de caracteres variável, a parte inferior usa char [] para armazenamento, thread-safe e baixa eficiência
- StringBuilder: sequência de caracteres variável, a parte inferior usa char [] para armazenamento, novo no jdk5.0, thread inseguro e alta eficiência
2.2 Análise do código fonte e expansão da capacidade
Análise do código fonte
String str = new String();//char[] value = new char[0];
String str1 = new String();//char[] value = new char[]{'a','b','c'};
StringBuffer sb = new StringBuffer();//char[] value = new char[16];底层创建了一个长度为16的char数组
Problema de expansão;
- Se a matriz subjacente de dados a serem adicionados não puder ser colocada, você precisará expandir a matriz subjacente.
- Por padrão, a expansão é duas vezes a matriz original +2 e os elementos da matriz original são copiados para a nova matriz
2.3 Uso de métodos
1. O método de acréscimo
anexo público StringBuffer (booleano b)
O objetivo desse método é anexar conteúdo ao final do objeto StringBuffer atual, semelhante à conexão de strings. Depois de chamar esse método, o conteúdo do objeto StringBuffer também muda.
2. O método de inserção
inserção pública StringBuffer (int offset, boolean b)
A função é inserir conteúdo no objeto StringBuffer e formar uma nova seqüência.
3. O método deleteCharAt
public StringBuffer deleteCharAt (int index)
A função desse método é excluir o caractere na posição especificada e, em seguida, formar o conteúdo restante em uma nova seqüência de caracteres.
4. O método inverso
public StringBuffer reverse ()
A função é reverter o conteúdo do objeto StringBuffer e formar uma nova seqüência.
5. O método trimToSize
public void trimToSize ()
A função desse método é reduzir o espaço de armazenamento no objeto StringBuffer para o mesmo comprimento que o comprimento da string, reduzindo o desperdício de espaço.
6. O método setCharAt
public void setCharAt (índice int, char ch)
A função é modificar o caractere na posição de índice no objeto para o novo caractere ch.
public int indexOf (String str)
public int length (String str)
public String subString (int start, int end) Especifica
public char charAt (int n)
//构造函数：可以空参构造，也可以用String、CharSequence来构造
//public StringBuffer(int capacity) capacity默认为16，如果用int来构造可以自己设置默认的capacity。
StringBuffer sbuffer = new StringBuffer("Hello");
//appen()：不需要创建新对象，直接返回append后的StringBuffer对象。
sbuffer.append(" World !");
System.out.println(sbuffer);
//reverse()：翻转StringBuffer对象并返回。
sbuffer.reverse();
System.out.println(sbuffer);
//replace()：用于替换指定位置的内容，如果start和end相同，效果等同于insert()。
sbuffer.replace(0, 1, "~");
sbuffer.reverse();
System.out.println(sbuffer);
//insert()：在指定位置插入（char、String、int、folat、boolean等）。
//length()：返回StringBuffer的长度。
sbuffer.insert(sbuffer.length(), " !");
System.out.println(sbuffer);
//delete()：删除指定位置区间的字符。
sbuffer.delete(sbuffer.length() - 1, sbuffer.length());
System.out.println(sbuffer);
Classe de tempo comum de duas datas da classe Java usada
https://blog.csdn.net/weixin_43244120/article/details/105188644
Três das classes comumente usadas de Java - outras classes (interfaces)
https://blog.csdn.net/weixin_43244120/article/details/105189069
