String,StringBuffer和StringBuilder

 

（1）String类用于描述字符串事物。它提供很多方法对字符串进行操作。String对象是不可变的。在String类中每一个看起来会修改String值的方法，实际上都是创建了一个全新的String对象，以包含修改后的字符串的内容。而最初的String对象则丝毫未动。请看下面代码：

 

public class Immutable {
   // 对于一个方法而言，参数是为该方法提供信息的，而不是让方法改变自己
    public static String upcase(String s) {
        return s.toUpperCase();
    }

    public static void main(String[] args) {
        String q = "android";
        System.out.println(q);
        // 传递给upcase的实际是引用的一个拷贝
        String qq = upcase(q);
        System.out.println(q);
        System.out.println(qq);
    }
}
/*
    输出：
           android
           android
           ANDROID
*/

 

1. 获取

   1.1 字符串的长度，即字符串中包含的字符数。

       int length():获取长度。

   1.2 根据指定索引该获取上的某个字符。

       char charAt(int index)

   1.3 根据指定字符获取该字符在字符串中的索引。

       int indexOf(int ch):返回ch在字符串中第一次出现的索引。

       int indexOf(in ch, int fromIndex):从fromIndex指定索引开始，获取ch在字符串中第一次出现的索引。   

  

  int indexOf(String str):返回的是str在字符串中第一次出现的索引。

  int indexOf(String str, int fromIndex)

  

  int lastIndexOf(int ch):返回ch在字符串中最后一次出现的索引。显然，它还有几个重载方法。

2. 判断

   2.1 字符串中是否包含某一个子串。

        boolean contains(CharSequence s):String,StringBuffer等实现CharSequence接口。

特殊之处：indexOf(str):可以索引str第一次出现的位置，如果返回-1，表示str不在字符串中存在。

所以也可以用于判断指定字符串时候被该字符串包含。该方法既可以判断，又可以获取出现的位置。

   2.2 字符中是否有内容。

        boolean isEmpty()

   2.3 字符串是否以指定内容开始。

        boolean startsWith(str)

   2.4 字符串是否以指定内容结尾。

        boolean endsWith(str)

3. 转换

   3.1 将字符数组转换成字符串。

       构造函数：String(char[])

            String(char[], int offset, int count)

  静态方法：static String copyVauleOf(char[])

                 static String copyVauleOf(char[], int offset, int count)

                 static String vauleOf(char[]):这个方法除了此功能外，可将基本数据类型转换成字符串。 

   3.2 将字符串转换成字符数组**。

        char[] toCharArray()

   3.3 将字节数组转换成字符串。

        String(byte[])

String(char[], int offset, int count)

   3.4 将字符串转换成字节数组。

        byte[] getBytes()

字符串和字节数组在转换过程中，是可以指定编码表的。

4. 替换

    String replace(char oldchar, char newchar):如果替换的字符不存在，就返回原串。

5. 切割

    String[] split(regex):regex——正则表达式 

6. 子串。获取字符串的一部分。

    String substring(int begin)：如果下标不存在，会出现字符串下标越界异常。

    String substring(int begin, int end):包含头（begin）,不包含尾（end）。s.subString(0, s.length()):获取整个字符串。

7. 变换，去除空格，比较。

   7.1 将字符串转成大写或者小写。

       String toUpperCase();

  String toLowerCase();

   7.2 将字符串两端的多个空格去除。

       String trim();

   7.3 对两个字符串进行自然顺序的比较。

       int compareTo(String);   

 

/*
	 练习一：模拟一个trim()方法:去除字符串两端的空格
	*/

	public static String myTrim(String str) {
	   int start = 0;
	   int end = str.length() - 1;
	   while (start <= end && (str.charAt(start) == ' ')) {
		   start++;
		}
		while (start <= end && str.charAt(end) == ' ') {
			end--;
		}
				
		return str.substring(start, end+1);
	}

	/*
	 练习二：将一个字符串进行反转或将字符串中指定部分进行反转。 
	*/
	/* 将字符串指定部分进行反转，包含start,不包含end */
	public static String reverseString(String str, int startIndex, int endIndex) {
	   /* 将字符串转换成字符数组 */
		char[] chs = str.toCharArray();
		/* 将字符数组中指定部分反转 */
		reverse(chs, startIndex, endIndex);
		/* 将字符数组转换成字符串 */
		
		return new String(chs);
	}
	
	/* 将一个字符串进行反转 */
	public static String reverseString(String str) {
	   return reverseString(str, 0, str.length());
	}
	
	/* 反转字符数组的指定部分 */
	private static void reverse(char[] chs, int startIndex, int endIndex) {
		int begin, last;
	   for (begin = startIndex, last = endIndex-1; begin<last; begin++, last--) {
		    char temp = chs[begin];
			chs[begin] = chs[last];
			chs[last] = temp;
		}
	}

	/* 练习三：获取一个字符串在另
	 * 一个字符串中出现的次数，例如
	 * "abkkcdkkedkkskk"中"kk"出现
	 * 的次数 */
	public static int getSubCount(String str, String key) {
		int count = 0;
		int index = 0;
		
		while ((index = str.indexOf(key, index)) != -1) {
			count++;
			index += key.length();
		}
		return count;
	}
	
	/* 练习四：获取两个字符串中最大相同子串。
	 * 思路：1. 将短的那个子串按照长度递减的
	 * 方式获取到。2. 将每获取到的子串去长的
	 * 那个字符串中判断是否包含，如果包含，已经
	 * 找到。 */
	
	public static String getMaxSubstring(String str1, String str2) {
		String max, min;
		max = (str1.length() > str2.length()) ? str1 : str2;
		min = (max.length() == str1.length()) ? str2 : str1;
		
		for (int i=0; i<min.length(); i++) {
			for (int j=0, k=min.length()-i; k <= min.length(); j++, k++) {
				String temp = min.substring(j, k);
				if (max.contains(temp)) {
					return temp;
				}
			}
		}
		return "";
	}

 (2) StringBuffer是字符串缓冲区，线程安全的可变字符序列。

     是一个容器，长度是可变化的，可以直接操作多个数据类型，最后通过toString()方法变成字符串。

   C create U update R read D delete

  它应该具有一下功能：

  1. 存储

     StringBuffer append():将指定的数据作为参数添加到已有数据的结尾处。

StringBuffer insert(int index,数据)：可以将数据插入到指定index处。

  2. 删除

     StringBuffer delete(start, end)：删除缓冲区的数据，包含start,不包含end。

StringBuffer deleteCharAt(index):删除指定位置的的字符。

  3. 获取

     char charAt(index)

int indexOf(String str)

int lastIndexOf(String str)

int length()

String substring(int start, int end)

  4. 修改

     StringBuffer replace(start, end, str)

void setCharAt(index, ch)

  5. 反转

     StringBuffer reverse()

 

 

(3) StringBuilder是一个可变的字符序列。此类提供一个与StringBuffer兼容的API,但不保证同步。推荐使用StringBuilder

 

#当你为一个类编写toString()方法时，如果你要在toString()方法中使用循环，那么最好自己创建一个StringBuilder对象，用它来构造最终的结果。请看代码：

public class WhitherStringBuilder {
    public String implicit(String[] fields) {
        String result = "";
        for (int i = 0; i < fields.length; i++) {
            result += fields[i];
        }
         return result；
    }

    public String explicit(String[] fields) {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < fields.length; i++)  {
            result.append(fields[i]);
        }
        return result.toString();
    }
}

 

 JDK升级的三个因素：（1）效率（2）简化书写（3）提高安全性