关于后端:String类及常用方法

String：字符串，应用一对双引号“”引起来示意。

String申明为final的，不能够被继承
String实现了Serializable接口：示意字符串是反对序列化的。（序列化在IO流会提及）
String实现了Comparable接口：示意String能够比拟大小
String外部定义了final char[] value用于存储字符串数据
String：代表不可变的字符序列，有着不可变的个性；简称：不可变性
通过字面量的形式（区别于new）给一个字符串赋值，此时的字符串值申明在字符串常量池中。
字符串常量池中是不会存储雷同内容的字符串的。

不可变的个性
指的是在办法区中，有着字符串常量池，比方你申明了一个字符串叫“abc”，赋值给一个变量s1，你又申明一个变量s2，你也赋值“abc”。其实他俩指向的地址是一样的。不会说你再申明一个雷同的内容而去给你新增。
体现：

当对字符串从新赋值时，须要从新指定内存区域赋值，不能应用原有的value进行赋值。

意思就是你不能把原来的值更改，在字符串常量池中会再创一个你从新赋值的值，把新值的地址给你须要从新赋值的变量

当对现有的字符串进行连贯操作时，也须要从新指定内存区域赋值，不能应用原有的value进行赋值。
当调用String的replace办法时，批改指定的字符或字符串时，也须要从新指定内存区域赋值，不能应用原有的value进行赋值。

举例：
@Test
public void test1() {

    String s1 = "abc";    String s2 = "abc";

// s1 = "hello";

    System.out.println(s1 == s2);    System.out.println(s1);    System.out.println(s2);    System.out.println("************");        String s3 = "abc";    s3 += "def";    System.out.println(s3);    System.out.println("************");    String s4 = "abc";    String s5 = s4.replace('a', 'd');    System.out.println(s4);    System.out.println(s5);

}
复制代码

String实例化形式

实质上this.value = new char[0],创立了一个长度为0的char型数组
String s1 = new String();
比方()里写"hello"，相当于底层创立了长度为5的char数组；this.value = original.value
String s2 = new String(String original);
this.value = Arrays.copyOf(value,value.length),将char数组的内容复制给s3
String s3 = new String(char[] a);
从char数组的starIndex下标开始，放count个元素给s4
String s4 = new String(char[] a,int starIndex,int count);

Q：String s1 = "abc" 与 String s1 = new String("abc")的区别
String的实例化有两种形式：

通过字面量定义的形式
通过new + 结构器的形式

@Test
public void test(){

//1.通过字面量定义的形式//此时的s1和s2的数据javaEE申明在办法区中的字符串常量池中String s1 = "javaEE";String s2 = "javaEE";//2.通过new + 结构器的形式//此时的s3和s4保留的地址值，是数据在堆空间中开拓空间当前对应的地址值String s3 = new String("javaEE");String s4 = new String("javaEE");System.out.println(s1 == s2); //trueSystem.out.println(s1 == s4); //falseSystem.out.println(s3 == s4); //false

}
复制代码

Q：String s = new String("abc");形式创建对象，在内存中创立了几个对象？
A：两个；一个是堆空间中new构造，另一个是char[]对象的常量池中的数据："abc"

String的拼接操作

常量和常量的拼接后果是在常量池中。且常量池中不会存在雷同内容的常量。
只有其中有一个是变量，后果就在堆中。

@Test
public void test1(){

String s1 = "javaEE";String s2 = "hello";String s3 = "javaEEhello";String s4 = "javaEE" + "hello";String s5 = s1 + "hello";String s6 = "javaEE" + s2;String s7 = s1 + s2;System.out.println(s3 == s4); //trueSystem.out.println(s3 == s5); //falseSystem.out.println(s3 == s6); //falseSystem.out.println(s3 == s7); //falseSystem.out.println(s5 == s6); //falseSystem.out.println(s5 == s7); //falseSystem.out.println(s6 == s7); //false

}
复制代码

如果拼接的后果调用intern()办法，返回值就在常量池中

String s8 = s5.intern();//返回失去的s8应用的是常量池中曾经存在的"javaEEhello"
System.out.println(s3 == s8); //true
复制代码

String的罕用办法
比拟重要的：length()、charAt()、compareTo()

int length()：返回字符串的长度： return value.length

char charAt(int index)：返回某索引处的字符return value[index]

boolean isEmpty()：判断是否是空字符串：return value.length == 0

String toLowerCase()：应用默认语言环境，将 String 中的所有字符转换为小写

String toUpperCase()：应用默认语言环境，将 String 中的所有字符转换为大写

String trim()：返回字符串的正本，疏忽前导空白和尾部空白

boolean equals(Object obj)：比拟字符串的内容是否雷同

boolean equalsIgnoreCase(String anotherString)：与equals办法相似，疏忽大小写

String concat(String str)：将指定字符串连贯到此字符串的结尾。等价于用“+”

int compareTo(String anotherString)：比拟两个字符串的大小

String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最初的一个子字符串。

String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不蕴含)的一个子字符串。

@Test
public void test(){

String s1 = "HelloWorld";System.out.println(s1.length()); //字符串长度System.out.println(s1.charAt(0)); //取字符串第一个地位元素System.out.println(s1.isEmpty()); //判断字符串是否为空String s2 = s1.toLowerCase(); //s1不变，把s1所有字母变成小写给s2System.out.println(s1);System.out.println(s2);String s3 = "  he ll o wor ld  ";String s4 = s3.trim();//去除s3后面和前面的空格，两头的空格仍然保留System.out.println(s3);System.out.println(s4);String s5 = "HelloWorld";String s6 = "helloworld";System.out.println(s5.equals(s6)); //比拟s5和s6的内容是否一样System.out.println(s5.equalsIgnoreCase(s6)); //疏忽大小写，比拟s5和s6的内容是否一样String s7 = s5.concat("def"); //concat()和 "+"用法统一System.out.println(s7);String s8 = "abc";String s9 = "abe";System.out.println(s8.compareTo(s9));//比拟大小，a跟a比，顺次，c的码比e小2String s10 = "北京天安门广场";String s11 = s10.substring(2); //从索引为2的元素开始System.out.println(s11);String s12 = s10.substring(2, 5); //不包含索引为5的元素System.out.println(s12);

}
复制代码

boolean endsWith(String suffix)：测试此字符串是否以指定的后缀完结

boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始

boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始

boolean contains(CharSequence s)：当且仅当此字符串蕴含指定的 char 值序列时，返回 true

int **
indexOf**(String str)：返回指定子字符串在此字符串中第一次呈现处的索引

int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次呈现处的索引，从指定的索引开始

int lastIndexOf(String str)：返回指定子字符串在此字符串中最左边呈现处的索引

int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最初一次呈现处的索引，从指定的索引开始反向搜寻

注：indexOf和lastIndexOf办法如果未找到都是返回-1
@Test
public void test1(){

String s1 = "helloworld";boolean b1 = s1.endsWith("ld");//依据须要写几个字符，判断是否以写的字符为结尾。留神辨别大小写System.out.println(b1);boolean b2 = s1.startsWith("He"); //判断是否以写的字符为开始。留神辨别大小写System.out.println(b2);boolean b3 = s1.startsWith("ll",2); //判断指定地位是否以写的字符为开始System.out.println(b3);String s2 = "wo";System.out.println(s1.contains(s2)); //判断一个字符串是否蕴含另一个字符串System.out.println(s1.indexOf("lo")); //返回指定的字符串在此字符串中第一次呈现的地位System.out.println(s1.indexOf("lo",5)); //从索引5的地位开始找lo这个子字符串String s3 = "helloworlord";System.out.println(s3.lastIndexOf("or")); //从后往前找or这个子字符串，返回索引地位System.out.println(s3.lastIndexOf("or",8)); //从索引8开始往左寻找or

}
复制代码

替换：

String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中呈现的所有 oldChar 失去的。
String replace(CharSequence target, CharSequence replacement)：应用指定的字面值替换序列替换此字符串所有匹配字面值指标序列的子字符串。
String replaceAll(String regex, String replacement)：应用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
String replaceFirst(String regex, String replacement)：应用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。

匹配:

boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。

切片：

String[] split(String regex)：依据给定正则表达式的匹配拆分此字符串。
String[] split(String regex, int limit)：依据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全副都放到最初一个元素中。

@Test
public void test2(){

//replace既能够替换单个字符也能够替换字符串String s1 = "北北爱吃北京的北京烤鸭";String s2 = s1.replace('北', '南');System.out.println(s1);System.out.println(s2);String s3 = s1.replace("北京", "南京");System.out.println(s3);System.out.println("*************************");String str = "12hello34world5java7891mysql456";//把字符串中的数字替换成,，如果后果中结尾和结尾有，的话去掉String string = str.replaceAll("\d+", ",").replaceAll("^,|,$", ""); //\d以及^|$是正则表达式的内容System.out.println(string);System.out.println("*************************");str = "12345";//判断str字符串中是否全副有数字组成，即有1-n个数字组成boolean matches = str.matches("\d+");System.out.println(matches);String tel = "0571-4534289";//判断这是否是一个杭州的固定电话boolean result = tel.matches("0571-\d{7,8}");System.out.println(result);System.out.println("*************************");str = "hello|world|java";String[] strs = str.split("\|");for (int i = 0; i < strs.length; i++) {    System.out.println(strs[i]);}System.out.println();s2 = "hello.world.java";String[] strs2 = s2.split("\.");for (int i = 0; i < strs2.length; i++) {    System.out.println(strs2[i]);}

}
复制代码

String与其余类转换
与包装类、根本数据类型
String转换为根本数据类型、包装类
调用包装类的静态方法：parseXxx(str)
@Test
public void test(){

String s1 = "123";int num = Integer.parseInt(s1);

}
复制代码
根本数据类型、包装类转换为 String
调用重载的valueOf(xxx) 或加上 ""
@Test
public void test(){

int num = 123;String s1 = String.valueOf(num);String s2 = num + "";

}
复制代码

与char[]数组
String 转换为 char[]数组
应用String的toCharArray()办法
@Test
public void test(){

String s1 = "123abc";char[] charArray = s1.toCharArray();for (int i = 0; i < charArray.length; i++) {    System.out.print(charArray[i]);}

}
复制代码
char[]数组转换为 String
调用String的结构器
@Test
public void test(){

char arr[] = {'h','e','l','l','o'};String s = new String(arr);System.out.println(s);

}
复制代码

与byte[]数组
String 转换为 byte[]数组
调用String的getBytes()
@Test
public void test(){

String s1 = "abc123";byte[] bytes = s1.getBytes();System.out.println(Arrays.toString(bytes));//遍历

}
复制代码

编码：字符串 ---> 字节
解码：字节 ---> 字符串

byte[]数组转换为 String
调用String的结构器
@Test
public void test(){

String s1 = "abc123";byte[] bytes = s1.getBytes();String s = new String(bytes);//解码System.out.println(s);

}
复制代码
留神：
转换成byte[]数组时能够指定编码集，默认为utf-8，如果用其余的，当解码时（字节 ---> 字符串）如果不明确指定则会呈现乱码。起因就是编码集和解码集不统一。