String类

String类：代表字符串；是一个final类，代表不可变的字符序列。字符串是常量，用双引号括起来，创建之后不能更改。

String构造方法
public String()
public String(char[] chs)
public String(byte[] bys)
String s = “abc”;

String对象的创建
String str = “abc”;
String s2 = new String(String original);
String s3 = new String(char[] ch);
String s4 = new String(char[] ch,int startIndex,int ncount);

使用“==”进行比较
如果是基本数据类型，对值进行比较
如果是引用类型，对地址进行比较

面试题
String s1 = “abc”;
String s2 = “def”;
String s3 = “abcdef”;
String s4 = “abc” + “def”;
String s5 = s1 + “def”;
String s6 = “abc” + s2;
String s7 = s5.intern();

s3 == s4(true) s3==s5(false) s3 == s6(false) s5 == s6(false) s3 == s7(true)
原因：1.字面量加字面量结果在常量池当中
2.只要有变量进行相加，结果在堆当中
3.如果拼接结果使用intern，结果在常量池当中

String方法
int length():获取字符串长度

				String str = "HelloWorld";
        System.out.println(str.length());//10

char charAt(int index):某个下标下，字符的值，下标从0开始计算

			String str = "HelloWorld";
        System.out.println(str.charAt(5));//'w'

boolean isEmpty():判断是否为空（空的话返回true）

			String str = "HelloWorld";
        String str2 = "";
        System.out.println(str.isEmpty());//false
        System.out.println(str2.isEmpty());//true

String toLowerCase()：将所有字母全部转换成小写

		String str = "HelloWorld";
      System.out.println(str.toLowerCase());//helloworld

String toUpperCase():将所有字母转换为大写

	String str = "HelloWorld";
  System.out.println(str.toUpperCase());//HELLOWORLD

String trim():去掉前后空白

	String str = "   HelloWorld   ";
  System.out.println(str.trim());//HelloWorld

boolean equals():比较字符串内容是否一致

	String str = "HelloWorld";
  String str2 = "helloworld";
  System.out.println(str.equals(str2));//false

boolean:equalsIgnoreCase()：比较字符串是否一致忽略大小写

	String str = "HelloWorld";
  String str2 = "helloworld";
  System.out.println(str.equalsIgnoreCase(str2));//true

String concat():在字符串后面+上数据

	String str = "HelloWorld";
  String str2 = "helloworld";
  System.out.println(str.concat(str2));//HelloWorldhelloworld

int compareTo()：比较两个字符串的大小，正数为大于，0相等，负数小于（从首字母开始比，不看长度）

	String str = "HelloWorld";
  String str2 = "helloworld";
  System.out.println(str.compareTo(str2));//-32

String substring(int beginIndex):返回一个字符串，从beginIndex开始截取，到最后

	String str = "HelloWorld";
  System.out.println(str.substring(1));//elloWorld

String substring(int beginIndex,int endIndex)：返回一个字符串，从beingIndex开始到endIndex-1结束

	String str = "HelloWorld";
  System.out.println(str.substring(1,6));//elloW

Boolean endsWith(String sufflx):判断字符串是否以sufflx结束

	String str = "HelloWorld";
   System.out.println(str.endsWith("ld"));//true

Boolean startsWith(String sufflx):判断字符串是否以sufflx开始

	String str = "HelloWorld";
   System.out.println(str.startsWith("Heq"));//false

Boolean startsWith(String sufflx,int toffset):判断字符串在toffset位置，是否以sufflx开始

	String str = "HelloWorld";
  System.out.println(str.startsWith("llo",2));//false

int indexOf(String s):判断字符串s从前开始检索第一次出现的位置，找不到返回-1

	String str = "HelloWorld";
  System.out.println(str.indexOf("He"));//0

int lastIndexOf(String s):判断字符串s从后开始检索第一次出现的位置，找不到返回-1

  String str = "HelloWorld";
  System.out.println(str.lastIndexOf("Hed"));//0

int indexOf(String s,int index):判断字符串s,从下表index之后从前开始检索第一次出现的位置，找不到返回-1

	String str = "HelloWorld";
  System.out.println(str.indexOf("He",1));//-1

int lastIndexOf(String s,intindex):判断字符串s,从下表index之后，从后开始检索第一次出现的位置，找不到返回-1

  String str = "HelloWorld";
  System.out.println(str.lastIndexOf("l",8));//8
  System.out.println(str.lastIndexOf("l",7));//3

boolean contains(charSequences s):判断字符串是否包含序列化的s，存在的话返回true

	String str = "HelloWorld";
  System.out.println(str.contains("llo"));//true

String replace(charSequences oldstr,charSequences newstr):将newstr替换原先里面oldstr

	String str = "HelloWorld";
  System.out.println(str.replace("l","dd"));//HeddddoWorddd

String replace(char oldc,char newc):将字符newc替换原先里面oldc

	String str = "HelloWorld";
  System.out.println(str.replace("l","d"));//HeddoWordd

String replaceAll(String ,String )//

	String str = "HelloWorld";
   System.out.println(str.replaceAll("el","edd"));//

String replaceFirst(String s,String str)//将第一个s替换为str

	String str = "HelloWorld";
  System.out.println(str.replaceFirst("l","edd"));//HeeddloWorld

Boolean matches(String regex)//判断字符串是否符合给定的正则表达式

	String str = "HelloWorld";
  System.out.println(str.matches(""));

String[] split(String regex)//根据正则表达式拆分数据
String[] split(String regex,int limit)//根据正则表达式拆分数据

String转换为基本数据类型以及包装类
基本数据类型 变量名 = 基本数据类型.Parse***(str);

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

将基本数据类型，包装类转换为String类型
String —>String.valueOf(***)

	int num = 223;
   String str = String.valueOf(num);

String 与 char[]之间的转换
String转换为char[] 调用toCharArray方法

	 String str = "abc123";
   char[] ch = str.toCharArray();

char[] 转换为String，调用String构造器

	char[] ch = new char[]{'a','b','c'};
  String str = new String(ch);
  System.out.println(str);

String与byte[]之间的转换
String转换为byte[]调用getBytes方法

	String str = "newyear";
  byte[] bt = str.getBytes()

将byte[]转换为String:通过构造器
new String()

StringBuffer，StringBuilder,String区别
String:不可变的字符序列
StringBuffer:可变的字符序列 线程安全的，效率低
StringBuilder:可变的字符序列 线程不安全的，效率高

效率而言：StringBuilder > StringBuffer >String

StringBuilder构造方法
StringBuilder()
StringBuilder(String)

StringBuilder 转换为String
StringBuilder sb;
sb.append(“11112”);
String str = sb.ToString();

StringBuffer常用方法
append(***); 字符串拼接
delete(int start,int end); 删除指定位置的数据
replace(int start,int end,String str); 将（start,end）位置的数据替换为str
insert（int offset,***） 在指定位置插入***
reverse() 将当前字符序列反转
int indexOf(str) //判断字符串s从前开始检索第一次出现的位置，找不到返回-1
String subString(int start,int end) 截取字符串
int length() 获取长度
char charAt(int index)获取指定位置的数据
setCharAt(int index,char ch) 将指定位置的数据设置为ch

部分实例：
1.将字符串"abcdefg"转换为"abfedcg"

public class StringTest {
    public static void main(String[] args) {
        String str = "abcdefg";
        StringTest st = new StringTest();
        str = st.reverse(str,2,5);
        System.out.println(str);

    }

    public String reverse(String str,int beginIndex,int endIndex){
        char[] arr = str.toCharArray();
        for(int x = beginIndex,y = endIndex;x<y;x++,y--){
            char temp = arr[x];
            arr[x] = arr[y];
            arr[y] = temp;
        }
        str = new String(arr);
        return str;
    }

	//StringBuilder写法
	public String reverse1(String str,int beginIndex,int endIndex){
        StringBuilder builder = new StringBuilder(str.length());
        builder.append(str.substring(0,beginIndex));
        for(int i =beginIndex;i<=endIndex;i++){
            builder.append(str.charAt(i));
        }
        builder.append(str.substring(endIndex+1));
        return new String(builder);
    }
}