黑马程序员——Java基础---String类和StringBuffer

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

一、概述

java中用String类进行描述，对字符串进行了对象的封装。这样的好处是可以对字符串这种常见数据进行方便的操作。对象封装后，可以定义N多属性和行为。String类是final类型。
String类的一般创建方法有如下俩种:

String s1 = "abc";
String s2 = new String("abc");
System.out.print((s1==s2)+"/"+(s1.equals(s2)));
1
2
3

输出结果false/true;
俩种方式虽然内容一样，但是内存地址是不一样的。程序在执行创建s1时，会在内存中建立一块区域存放”abc”，并将s1指向这块区域的地址；在创建s2时，会在内存中创建两个区域，但是”abc”区域已经存在，不会再次创建了；

当然String还有其他的构造方法:
String new String(char[]);//将字符数组转成字符串。
String new String(char[],offset,count);//将字符数组中的一部分转成字符串。

二、一般方法

1. 获取功能:
   int length();// 获取字符串的长度。
   char charAt(int index);//获取字符index下标位置的字符。
   int indexOf(int ch);//获取字符串中第一次出现ch的位置，没有找到返回-1。
   int indexOf(int ch, int fromIndex);//从fromIndex位置开始获取ch的位置（这时的位置还是从头开始算的），没有找到返回-1。
   int indexOf(String str);//获取字符串中第一次出现str的位置，没有找到返回-1。
   int lastIndexOf(int ch);//获取最后一次出现ch的位置，没有找到返回-1。
   int lastIndexOf(int ch, int fromIndex);//从fromIndex位置开始获取ch最后一次出现的位置（这时的位置还是从头开始算的），没有找到返回-1。
   int lastIndexOf(String str);//获取字符串中最后一次出现str的位置，没找到返回-1。
   String substring(int begin);//获取begin位置开始到末尾的字符串子串。
   String substring(int begin, int end);//获取[begin, end)端的字符串子串。
   String substring(0,str.length());//获取整串

2. 判断
   boolean contains(CharSequence chs);//判断字符串中包含指定的字符串
   boolean isEmpty();//判断是否为空
   boolean startsWith(String str);//是否以str开头。
   boolean endsWith(String str);//是否以str结尾。
   boolean equals(String str);//是否和str内容相同。
   boolean equalsIgnoreCase(String str);//忽略大小写判断是否内容相同。

3. 转换
   new String(char[] chs);//构造函数，将char数组chs装换为字符串。
   new String(char[] chs, int offset, int count);//构造函数，将char数组chs中从下标offset开始的count个字符转换为字符串。
   char[] toCharArray();//是字符串转换为字符数组。
   byte[] getBytes();//将字符串转换为字节数组。
   String toUpperCase();//转换为大写字符串。
   String toLowerCase();//转换为小写字符串。
   String[] split(string s);//根据s的分割字符串
   static String copyValueOf(char[] chs);//功能是根据char数组chs返回转换后的字符串。
   static String copyValueOf(char[] chs, int offset, int count);//功能是根据char数组chs中从下标offset开始的count个字符转换为字符串。
   static String valueOf(char[] chs)和copyValueOf(char[] chs);//功能一样。,根据char数组chs返回转换后的字符串。
   static String valueOf(int v)/static String valueOf(long v);//将其他类型变量转换为字符串类型。
   String replace(char oldChar, char newChar);//将oldChar替换为newChar然后返回替换过的字符串。
   String replace(CharSequence target, CharSequence replacement);//将target替换为replacement并返回替换过的字符串。

4. 其他常用方法
   String trim();//去除首尾多余空格。
   int compareTo(String str);//和str比较，如果小于返回负数，如果等于返回0，如果大于返回正数。字符串的大小是按照字典序标准。

三、StringBuffer类

构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。为了解决String的不可改变的弊端。
它的主要特点为:
1：可以对字符串内容进行修改。
2：是一个容器。
3：是可变长度的。
4：缓冲区中可以存储任意类型的数据。
5：最终需要变成字符串。

StringBuffer类 的常用方法如下:
添加功能:
1.StringBuffer append(data);//在缓冲区中追加数据。追加到尾部。
2.StringBuffer insert(index,data);//可以在指定位置插入数据。
查找功能。
1.int indexOf(string); //返回指定子字符串在此字符串中第一次出现处的索引。
2.int indexOf(string,int fromIndex);//从指定位置开始查找字符串
3.int lastIndexOf(string); //返回指定子字符串在此字符串中最右边出现处的索引。
4.int lastIndexOf(string,int fromIndex); //从指定的索引开始反向搜索
删除功能:
1.StringBuffer delete(start,end);//删除从[start,end)范围的元素
2.StringBuffer deleteCharAt(index);//删除指定位置的元素
delete(0,sb.length());//清空缓冲区。
修改功能:
1.StringBuffer replace(start,end,string);替换[start, end)段的字符内容。
2.void setCharAt(index,char);//替换指定位置的字符
3.void setLength(len);//将原字符串置为指定长度的字符串
获取子串:
1.string substring(start);//返回start到结尾的子串
2.string substring(start,end);//返回[start,end)的子串
反转功能:StringBuffer reverse();//字符串反转

四、StringBuilder类

构造一个其中不带字符的字符串生成器，初始容量为 16 个字符。该类被设计用作 StringBuffer 的一个简易替换,常用方法也和StringBuffer一样。
区别:StringBuffer线程不安全，而StringBuilder线程安全。
下面是一个用StringBuilder 来取出一个字符串中字母出现的次数：

public static void main(String[] args)
    {
        String str = "abcdekka27qoq";
        String str1 = charactCnt(str);
        System.out.println(str1);

    }
    public static String charactCnt(String str)//转换成字符数组，遍历字符,不断添加
    {
        char[] chs = str.toCharArray();
        TreeMap<Character,Integer> tm = new TreeMap();
        int count = 0;
        for(char ch:chs)
        {
            if(!((ch<='z'&&ch>='a')||(ch>='Z')&&(ch<='A')))
                continue;

            if(tm.get(ch)!=null)
            {
                count=(int)tm.get(ch);
                count++;
                tm.put(ch,count);
            }
            else
                tm.put(ch,1);
        }
        StringBuilder sb = new StringBuilder();

        Set<Map.Entry<Character,Integer>> mapentry = tm.entrySet();
        Iterator<Map.Entry<Character,Integer>> it = mapentry.iterator();
        while(it.hasNext())
        {
            Map.Entry<Character,Integer> map =it.next();
            char ch1 = map.getKey();
            int num = map.getValue();
            sb.append(ch1+"("+num+")");
        }
        return sb.toString();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40