String类

String类

是引用数据类型，不属于基本数据类型。

（一）. 特点

1）长度不可改变
2）一个“abd”，是一个对象
3）String s1 = “abc”; String s2 = new String(“abc”);
//s1和s2的区别：s1在内存中有一个对象，s2在内存中有两个对象。
4）System.out.println(s1.equals(s2)); 结果为true
//String覆写了equals方法，用来比较字符串内容是否相同，如果没有覆写则比较的是地址是否相同。

public static void main(String args[])    {        String s = new String();        String s = "";        String s1 = "abc";        String s2 = new String("abc");        //s1和s2的区别：s1在内存中有一个对象，s2在内存中有两个对象。        System.out.println((s1==s2));        System.out.println(s1.equals(s2));//String覆写了equals方法，用来比较字符串内容是否相同，如果没有覆写则比较的是地址是否相同。    }

（二）. 获取方法：

1）int length（）：获取字符串长度
2）char charAt（int index）：根据位置获取某个字符
3）int indexOf（int ch）：返回的是ch在字符串中第一次出现的位置
int indexOf（int ch，int fromIndex）：从指定位置开始，获取ch在字符串出现的位置
int indexOf（String str）：返回的是str在字符串中第一次出现的位置
int indexOf（String str，int fromIndex）：从指定位置开始，获取str在字符串出现的位置
int lastIndexOf（int ch）：返回的是，从后往前数，ch在字符串中第一次（即最后一次）出现的位置。
int lastIndexOf（String str）：返回的是，从后往前数，str在字符串中第一次（即最后一次）出现的位置。

public static void method_get()    {        String str = "abcdefskp";        sop(str.length());        sop(str.charAt(3));//当访问字符串中不存在的脚标时，会发生脚标越界的异常        sop(str.indexOf('m'));//如果不存在，则返回-1        sop(str.indexOf('a',3));        sop(str.lastIndexOf('a'));    }

（三）. 判断：

1）boolean contains（str）：字符串中是否包含某一个子串
int indexOf（String str）：此方法可以返回字符串所在位置，如果返回-1，则表示字符串不存在。
2）boolean isEmpty（）：判断字符串是否为空，原理是判断长度是否为0
3）boolean startsWith（str）：字符串是否是以指定内容开头
4）boolean endsWith（str）：字符串是否是以指定内容结尾
5）boolean equals（str）：字符串内容是否相等
6）boolean equalsIgnoreCase（）：忽略大小写判断字符串内容是否相等。

public static void method_is()    {        String str = "ArrayDemo.java";        sop(str.startsWith("Array"));        sop(str.endsWith(".java"));        sop(str.contains("Demo"));    }

（四）. 转换

1）将字符数组转成字符串
构造函数：String（char[]）
String（char[]，offset，count）将字符数组的一部分转成字符串
静态方法：static String copyValueOf（char[]）;
static String copyValueOf（char[] data，int offset，int count）
static String valueOf（char[]）

2）将字符串转成字符数组
char[] toCharArray（）：
3）将字节数组转成字符串
String（byte[]）
String（byte[]，offset，count）：将字节数组的一部分变成字符串。
4）将字符串转成字节数组
byte[] getBytes（）；
5）将基本数据类型转成字符串
static String valueOf（int）
static String valueOf（double）
3+“”；String.valueOf（3）；
6）将字符串转换成基本数据类型
int Integer.parseInt（String）；
float Float.parseFloat（String）；

public static void method_trans()    {        char[] arr = {'a','b','c','d','e','f'};        String s = new String(arr,1,3);        sop("s="+s);        String s1 = "zxdcbnm";        char[] chs = s1.toCharArray();        for(int x =0;x<chs.length;x++)        {            sop("ch="+chs[x]);        }    }

（五）. 替换

：String replace（oldchar，newchar）

public static void method_replace()    {        String s = "hello java";        String s1 = s.replace('q','n');//如果替换的字符不存在，返回的是原来的字符串。        String s1 = s.replace("java","world");        sop("s="+s);        sop("s1="+s1);    }

（六）. 切割

：String[] split（regex）

public static void method_split()    {        String s = "zhangsan,lisi,wangwu";        String[] arr = s.split(",");        for(int x=0;x<arr.length;x++)        {            sop(arr[x]);        }    }

（七）. 截取子串，获取字符串的一部分

String substring（begin）：从指定位置开始到结尾
String substring（begin，end）：包含头，不包含尾部的截取。

public static void method_sub()    {        String s = "abcdef";        sop(s.substring(2));        sop(s.substring(2,4));    }

（八）. 转换大小写：

String toUpperCase（）；
String toLowerCase（）；

（九）. 将字符串两端的多个空格去除

String trim（）；

（十）. 对两个字符串进行自然顺序的比较

int compareTo（String）

public static void method_()    {        String s = "       hello  Java     ";        sop(s.toUpperCase());        sop(s.toLowerCase());        sop(s.trim());        String s1= "a1c";        String s2 = "aaa";        sop(s1.compareTo(s2));    }

练习1：

模拟一个trim方法，去除字符串两端的空格

class StringTest1{    public static vid main(String args[])    {        String s= "    ab cd    ";        sop(s);        s = myTrim(s);        sop(s);    }    public static String myTrim(String str)    {        int start = 0; end = str.length()-1;        while(start<=end&&str.charAt(start)==' ')            start++;        while(start<=end&&str.charAt(end)==' ')            end--;        return str.substring(start,end+1);    }}

练习2：

将一个字符串进行反转，将字符串中指定部分进行反转

public static vid main(String args[])    {        String s= "    ab cd    ";        sop(s);        s = reverseString(s);        sop(s);    }    public static String reverseString(String s)    {        char[] chs = s.toCharArray();        reverse(chs);        return new String(chs);    }    private static void reverse(char[] arr)    {        for(int start=0,end=arr.length-1;start<end;start++,end--)        {            swap(arr,start,end);        }    }    private static void swap(char[] arr,int x,int y)    {        char temp = arr[x];        arr[x] = arr[y];        arr[y] = temp;    }

练习2加强版：将字符串的一部分进行反转：

public static vid main(String args[])    {        String s= "    ab cd    ";        sop(s);        s = reverseString(s);        sop(s);    }    public static String reverseString(String s,int start,int end)    {        char[] chs = s.toCharArray();        reverse(chs,start,end);        return new String(chs);    }    private static void reverse(char[] arr,int x,int y)    {        for(int start=x,end=y-1;start<end;start++,end--)        {            swap(arr,start,end);        }    }    private static void swap(char[] arr,int x,int y)    {        char temp = arr[x];        arr[x] = arr[y];        arr[y] = temp;    }

练习3：

获取一个字符串在另一个字符串中出现的次数

方法1：

public static int getSubCount(String str,String key)    {        int count = 0;        int index = 0;        while((index=str.indexOf(key))!=-1)        {            sop("str="+str);            str = str.substring(index+key.length());            count++;        }        return count;    }

方法2：

public static int getSubCount(String str,String key)    {        int count = 0;        int index = 0;        while((index=str.indexOf(key,index))!=-1)        {            index = index+key.length());            count++;        }        return count;    }

练习4：获取两个字符串中最大相同子串
练习4太难了。

StringBuffer

是字符缓冲区

特点及方法：
1）是一个容器
2）长度可以变化，可以操作多个数据类型，最终通过toString方法变成字符串
3）存储：
3.1）StringBuffer append（）：将指定数据作为参数添加到字符串末尾。
3.2）StringBuffer insert（index，数据）：将数据插入指定脚标位置

{        StringBuffer sb = new StringBuffer();        sb.append("abd").append(true).append(32);        sb.insert(1,"qq");        sop(sb.toString());    }

4）删除：
StringBuffer delete（start，end）：删除缓冲区的部分
StringBuffer deleteCharAt（index）：删除指定位置上的字符

{        StringBuffer sb = new StringBuffer("abcde");        sb.delete(1,3);        sb.delete(0,sb.length());//清空缓存区        sb.delete(2,3);        sb.deleteCharAt(2);        sop(sb.toString());    }

5）获取：
char charAt（int index）
int indexOf（String str）
int lastIndexOf（String str）
int length（）
String substring（int start，int end）

6）修改：
StringBuffer replace（start，end，string）
void setCharAt（int index，char ch）

{        StringBuffer sb = new StringBuffer("abcde");        sb.replace(1,4,"java");        sb.setCharAt(2,'k');        sop(sb.toString());    }

7）反转：
StringBuffer reverse（）

8）将缓冲区中指定数据存储在指定字符数组中。
void getChars（int srcBegin，int srcEnd，char[] dst，int dstBegin）

{        StringBuffer sb = new StringBuffer("abcde");        char[] chs = new char[4];        sb.getChars(1,4,chs,1);        for(int x=0;x<chs.length;x++)        {            sop("chs["+x+"]::"+chs[x]);        }}

9）StringBuilder是JDK1.5之后出现的：
9.1）StringBuffer是线程同步，而StringBuilder是线程不同步
9.2）以后开发，建议使用StringBuilder，提供效率。