String类

　　String对象是不可变的，字符串一旦创建，内容不能再改变。底层用char[]存放,故可以使用字符串直接量或字符数组创建一个字符串对象（其中String类中有13个构造方法），下面的语句使用字符串直接量

"welcome to java"创建一个String对象message：

String message = new String("welcome to java");

　　java将字符串直接量看着String对象，所以，下面的语句是合法的：

String message = "welcome to java";

　　还可以用字符数组创建一个字符串

char[] charArray = {'g','o','o','d'};
String message = new String(charArray);

　　注意：String变量存储的是对String对象的引用，String对象里存储的才是字符串的值。严格地讲，术语String变量、String对象和字符串值是不同的。但在大多数情况下，它们之间的区别是可以忽略的。为简单起见，术语字符串将经常被用于指String变量、String对象和字符串的值。

不可变字符串与限定字符串

　　String对象是不可变的，它的内容是不能改变的。下列代码会改变你字符串的内容吗？

String s = "java";
s = "HTML";

　　答案是不能.第一条语句创建了内容为“java”的String对象，并将其引用赋值给s。第二条语句创建了一个内容为“HTML”的新String对象，并将其引用赋值给s。赋值后第一个String对象仍然存在，但是不能再访问它，因为变量s现在指向了新的对象。

　　因为字符串是不可改变的，但同时又会频繁的使用，所以java虚拟机为了提高效率并节约内存，对具有相同字符序列的字符串直接量使用同一个实例。这样的实例称为限定的（interned）字符串。例如，下面的语句：

String s1 = "a";
String s2 = "b";
String s3 = "a"+ "b";
String s4 = s1 + s2;
String s5 = "ab";
String s6 = s4.intern();
//问
System.out.println(s3 == s4);
System.out.println(s3 == s5);
System.out.println(s3 == s6);
String x2 = new String("c") + new String("d");
String x1 = "cd";
x2.intern();
//问,如果调换了[最后两行代码]的位置呢，如果是jdk1.6呢
System. out.println(x1 == x2);

　　从字节码和常量池的角度来分析下刚才这些代码的底层原理

String的常用操作

public int length()：获取字符串当中含有的字符个数，返回字符串长度。
public String concat(String str)：将当前字符串和参数字符串str连接，返回值新的字符串。
public char charAt(int index)：获取指定索引位置的单个字符。（索引从0开始。）
public String toUpperCase()：返回所有字母大写的新字符串
public String toLowerCase()：返回所有字母小写的新字符串
public String trim(): 返回去掉两边空白字符的新字符串。
//字符串比较
public boolean equals(String str):如果该字符串等于字符串str，返回true
public boolean equalsIgnoreCase(String str):如果该字符串等于字符串str，返回true.不区分大小写
public int compareTo(String str):返回一个大于0、等于0、小于0的整数，表明一个字符串是否大于、等于或者小于str
public int compareToIgnoreCase(String str):返回一个大于0、等于0、小于0的整数，表明一个字符串是否大于、等于或者小于str。不区分大小写
public boolean startsWith(String prefix): 返回字符串是否以前缀prefix开头
public boolean endsWith(String suffix): 返回字符串是否以后缀suffix结束
public boolean contains(String str): 检查字符串中是否包含子串str
//字符串截取
public String substring(int begin):截取字符串，从特定位置begin的字符开始到字符串结尾。
public String substring(int begin,int end):截取字符串，从特定位置begin的字符开始到end-1的字符。（长度为end - begin）
//字符串查找，提供了几个版本的indexOf和lastIndexOf方法
public int indexOf(String str)：查找参数字符串在本字符串当中首次出现str的索引位置，如果没有返回-1值。
public int indexOf(String str,int fromIndex)：查找参数字符串在本字符串当中fromIndex之后首次出现str的索引位置，如果没有返回-1值。
public int lastIndexOf(String str)：查找参数字符串在本字符串当中最后一个出现str的索引位置，如果没有返回-1值。
public int lastIndexOf(String str,int fromIndex)：查找参数字符串在本字符串当中fromIndex之前出现最后一个str的索引位置，如果没有返回-1值。

字符串的替换和分割

　　一旦创建了字符串，它的内容就不能改变。但是，方法replace、replaceAll和replaceFirst会返回一个源自原始字符串的新字符串（并未改变原始字符串）。replace方法有几个重载方法。split方法可以从一个指定分隔符的字符串中提取标识。

public String replace(String oldString,String newString):将字符串中所有匹配的子串old String替换为新串newString
public String replaceAll(String oldString,String newString):将字符串中所有匹配的子串old String替换为新串newString。支持模式匹配（正则表达式）
public String[] split(String delimiter):从一个指定分隔符的字符串中提取标识,返回标识字符串数组

String token = "赵老师是一个好老师,你喜欢赵老师吗？";
//将所有的赵老师替换为Miss Cang
String info = token.replace("赵老师", "Miss Cang");
System.out.println(info);
//替换第一个找到的赵老师
System.out.println(token.replaceFirst("赵老师", "Miss Cang"));
//替换全部，支持模式匹配（正则表达式）
System.out.println(token.replaceAll("赵老师", "Miss Cang"));

//分割
String[] tokens = "Linux@Java@Spring".split("@");
for(String token : tokens)
   System.out.println(token);

依照模式匹配、替换和分割

String str = "java in action";
System.out.println(str.matches("java.*"));
        System.out.println("========================");
String reg = "^1[358]\\d{9}$";
System.out.println("110".matches(reg));
System.out.println("1300".matches(reg));
System.out.println("17300001111".matches(reg));
System.out.println("15300001121".matches(reg));

　　详情请参考正则表达式

字符串与数组之间的转换

　　字符串不是数组，但是字符串可以转换成数组，反之亦然。

//字符串和字符数组进行转换
char[] letters = token.toCharArray();
System.out.println(letters.length);
        
new String(letters);
//
System.out.println(new String(letters,0,3));

将字符和数值转换成字符串

　　回顾下，可以使用Double.parseDouble(str)或者Integer.parseInt(str)将一个字符串转为一个double或者int值，也可以使用字符串的连接操作符将字符或者数值转换为字符串。另外一种将数字转为字符串的方法是使用重载的静态valueOf方法。

格式化字符串

　　String.format(format,item1,item2,...,itemn)

StringBuffer和StringBuilder

　　StringBuffer和StringBuilder类似于String类，区别在于String类是不可改变的。一般来说，只要使用字符串的 地方，都可以使用StringBuffer/StringBuilder类.StringBuffer和StringBuilder比String更加灵活。可以给一个StringBuffer和StringBuilder中添加、插入或追加新的内容，但是String对象一旦创建，它的值就固定了。

　　除了StringBuffer中修改缓冲区的方法是同步的（只有一个任务被允许执行），StringBuffer与StringBuilder类是很相似的。如果是多任务并发访问，就使用StringBuffer，可以防止StringBuffer崩溃。而如果是单任务访问，使用StringBuilder会更有效。StringBuffer和StringBuilder中的构造方法和其它方法机会是完全一样的

package edu.uestc.avatar;

public class StringBuilderDemo {
    public static void main(String[] args) {
        //emp(empno,ename,job,mgr,sal,comm,hiredate,deptno)
        //select empno,ename,job,mgr,sal,comm,hiredate,deptno from emp
        if(args == null || args.length == 0) return;
        StringBuilder sb = new StringBuilder("select");
        for(String token : args) {
            sb.append(' ').append(token).append(',');
        }
        //删除最后一个对于的,字符
        sb.deleteCharAt(sb.length() - 1);
        sb.append(" from emp");
        
        //将StringBuilder转成String
        String sql = sb.toString();
        System.out.println(sql);
    }
}

示例：判断回文字符串时忽略既非字母又非数字的字符

package edu.uestc.avatar;

import java.util.Scanner;

/**
 * 判断回文字符串时忽略既非字母又非数字的字符
 *    1、过滤出原始字符串中的字母，组成一个新的字符串
 *    2、将新的字符串进行反转
 *    3、将反转后的字符串和过滤后字符串进行比较，如果相等则为回文串
 */
public class Plalindrome {
    public static void main(String[] args) {
        System.out.println("请输入一个字符串:");
        Scanner input = new Scanner(System.in);
        String token = input.nextLine();
        input.close();
        String ret = filter(token);
        //将ret进行反转
        String reverse = reverse(ret);
        String message = String.format("%s忽略掉既非字母又非数字的字符后是否为回文字符串:%b", token,ret.equals(reverse));
        System.out.println(message);
    }

    /**
     * 字符串反转
     */
    private static String reverse(String ret) {
        StringBuilder sb = new StringBuilder(ret);
        return sb.reverse().toString();
    }

    /**
     * 过滤出字母字符，组成一个新的字符串
     */
    private static String filter(String token) {
        if(token == null)return "";
        StringBuilder sb = new StringBuilder("");
        for(int i = 0; i < token.length(); i++) {
            if(Character.isLetter(token.charAt(i)))
                sb.append(token.charAt(i));
        }
        return sb.toString();
    }
}

StringJoiner

　　要高效拼接字符串，应该使用StringBuilder。很多时候，我们把数组打印成字符串是这样处理的

public class ArrayDemo {
    public static void main(String[] args) {
        String[] names = {"peppa","emily","jorge","suzy","pedro"};
        printArray(names);
    }
    
    public static void printArray(String[] names) {
        var sb = new StringBuilder("[");
        for (String name : names) 
            sb.append(name).append(", ");
        //去掉最后的", ":
        sb.delete(sb.length() - 2, sb.length());
        sb.append(']');
        System.out.println(sb.toString());
    }
}
//运行效果：[peppa, emily, jorge, suzy, pedro]

　　类似用分隔符拼接数组的需求很常见，所以Java标准库还提供了一个StringJoiner来干这个事：

public static void printArray(String[] names) {
    var sj = new StringJoiner(", ");
    for (String name : names) 
        sj.add(name);
    System.out.println(sj.toString());
}

　　慢着！用StringJoiner的结果少了前面的"["和结尾的"]"！遇到这种情况，需要给StringJoiner指定“开头”和“结尾”

public static void printArray(String[] names) {
    var sj = new StringJoiner(", ", "[", "]");
    for (String name : names) 
        sj.add(name);
    System.out.println(sj.toString());
}

　　String.join()

　　String还提供了一个静态方法join()，这个方法在内部使用了StringJoiner来拼接字符串，在不需要指定“开头”和“结尾”的时候，用String.join()更方便：

public static void printArray(String[] names) {
    System.out.println(String.join(", ",names));
}