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方法，用来比较字符串内容是否相同，如果没有覆写则比较的是地址是否相同。

[code]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在字符串中第一次（即最后一次）出现的位置。

[code]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（）：忽略大小写判断字符串内容是否相等。

[code]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）；

[code]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）

[code]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）

[code]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）：包含头，不包含尾部的截取。

[code]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）

[code]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方法，去除字符串两端的空格

[code]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：

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

[code]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加强版：将字符串的一部分进行反转：

[code]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：

[code]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：

[code]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，数据）：将数据插入指定脚标位置

[code]{
        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）：删除指定位置上的字符

[code]{
        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）

[code]{
        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）

[code]{
        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，提供效率。