Java String类笔记

String 类代表字符串，每个双引号里面的字符串都是一个String类的对象，例如"abc"是一个字符串对象。

字符串最大的特点：

    一旦被初始化就不可以被改变

String类适用于描述字符串事物

那么它提供了许多个方法对字符串进行操作

常见的操作有哪些？

1.获取

    1）字符串中包含的字符数，也就是字符串的长度

          int length(); 获取长度

    2）根据位置获取位置上某个字符

          char charAt(int index);

    3）根据字符获取该字符在字符串中位置

          int indexOf(int ch);返回的是ch在字符串中第一次出现的位置，ch是ASCII值

          int indexOf(int ch, int fromIndex);从fromIndex指定位置开始，获取ch在字符串中出现的位置

          int indexOf(String str);返回的是str在字符串中第一次出现的位置

          int indexOf(String str, int fromIndex);从fromIndex指定位置开始，获取str在字符串中出现的位置

          int lastIndexOf(int ch); 反向索引字符出现的位置，正向索引和反向索引得到的角标值一样

2.判断

    1）字符串中是否包含某一个字符

         boolean contains(charSequence s);String是charSequence的实现类

         特殊之处：int indexOf(String str);可以索引str第一次出现的位置，如果返回-1，表示str不在字符串中存在。
         所以，也可以用户于对指定字符串判断是否包含。

         if(str.indexOf("aa") != -1)  

         该方法既可以判断，又可以获取出现的位置

    2）字符串中是否有内容

          boolean isEmpty();原理就是判断长度是否为0.

    3）字符串是否是以指定内容开头

          boolean startsWith(String str);

    4）字符串是否是以指定内容结尾

          boolean endsWith(String str);

    5） 判断字符串内容是否相同，覆写了Object类中的equals方法

          boolean equals(Object anObject);

    6） 判断内容是否相同，并忽略大小写

          boolean equalsIgnoreCase(String anotherString);

3.转换

    1）将字符数组转成字符串

          构造函数：

                String(char[] value);

                String(char[] value, int offset, int count);将字符数组中一部分封装成字符串

          静态方法：

                 static String copyValueOf(char[] data);

                 static String copyValueOf(char[] data, int offset, int count);

                 static String valueOf(char[] data);

     2）将字符串转成字符数组 

          char[] toCharArray();

     3）将字节数组转成字符串 

          String(byte[] value);

          String(byte[] value, int offset, int count);将字节数组中一 部分封装成字符串    

     4）将字符串转成字节数组

          byte[] getBytes();

     5）将基本数据类型转换成字符串

          static String valueOf(int data);

          static String valueOf(double data);

          6+""; 等同于 String.valueOf(6);

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

4.替换

          String replace(char oldChar, char newChar);

          String replace(CharSequence target, CharSequence replacement);

5.切割

          String[] split(String regex);   

6.子串，获取字串中的一部分

          String substring(int beginIndex);

          String substring(int beginIndex, int endIndex);

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

     1）将字符串转成大写或者小写

          String toUpperCase();

          String toLowerCase();

     2）将字符串两端的多个空格去除

          String trim();

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

          int compareTo(String str);

示例：

       public static void method_7(){
		String s = "   Hello World  ";
		sop(s.toUpperCase());   //转换成大写
		sop(s.toLowerCase());   //转换成小写
		sop(s.trim());   //去空格
		String s1 = "abc";
		String s2 = "aaa";
		sop(s1.compareTo(s2)); //比较
	}
	public static void method_sub(){  //截取子串
		String s ="abcdef";
		sop(s.substring(2));//从指定位置开始到结尾。如果角标不存在，会出现字符串角标越界
		sop(s.substring(2, 4));//包含开头，不包含结尾。s.substring(0, s.length());
	}
	public static void method_split(){  //切割
		String s = "zhangsanmmlisimmwangwu";
		String[] arr = s.split("mm");
		for(int i=0; i<arr.length; i++){
			sop(arr[i]);
		}
	}
	public static void method_replace(){   //替换
		String s = "hello java";
		String s1 = s.replace('a', 'n');//如果要替换的字符不存在，返回的是原串
		String s2 = s.replace("java", "txt");
		sop("s="+s);
		sop("s1="+s1);
		sop("s2="+s2);
	}
	public static void method_trans(){//转换
		char[] arr = {'a', 'b', 'c', 'd', 'e', 'f'};
		String str = new String(arr);
		sop("str="+str);
		String str2 = new String(arr, 2, 2);
		sop("str2="+str2);
		char[] chs = str.toCharArray();
		for(int i=0; i<chs.length; i++){
			sop(chs[i]+"");
		}
	}
	public static void method_get(){    //获取
		String str = "abcdeaef";
		//长度
		sop(str.length());
		//根据索引获取字符
		sop(str.charAt(4));//当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException
		//根据字符获取索引
		sop(str.indexOf('a',3));//如果没有找到，返回-1
		//反向索引一个字符出现位置
		sop(str.lastIndexOf('a'));
	}
	public static void method_is(){    //判断
		String str = "ArrayDemo.java";
		//判断文件名称是否是Array单词开头
		sop(str.startsWith("Array"));
		//判断文件名称是否是.java的文件
		sop(str.endsWith(".java"));
		//判断文件中收费包含Demo
		sop(str.contains("Demo"));
		
	}
        public static void sop(Object obj){
            System.out.println(obj);
        }

字符串练习示例代码

public class StringTest {

	public static void main(String[] args) {
		System.out.println(getMaxSameSubString("skfkdhellodkie", "iejikehellohd"));
		System.out.println(getCountString("heleokkhdidkkddkkdsse", "kk"));
		System.out.println(reverseString("hello"));
		String str = "        kjkidd   ";
		System.out.println("<"+str+">");
		System.out.println("<"+myTrim(str)+">");
	}
	//获取两个字符串中最大相同子串
	public static String getMaxSameSubString(String str1, String str2){
		String max = "", min = "";
		max = (str1.length() > str2.length())?str1:str2;
		min = (max == str1)?str2:str1;
		for(int i=0; i<min.length();i++){
			for(int start=0, end=min.length()-i; end!=min.length()+1; start++, end++){
				if(max.contains(min.substring(start, end)))
					return min.substring(start, end);
			}
		}
		return null;
	}
	//获取一个字符串在另一个字符串中出现的次数
	public static int getCountString(String str, String key){
		int index = 0, count = 0;
		while((index = str.indexOf(key, index)) != -1){
			System.out.println("index="+index);
			count++;
			index = index + key.length();
		}
		return count;
	}
	
	//反转字符串
	public static String reverseString(String str, int start , int end){
		char[] arr = str.toCharArray();
		reverseCharArray(arr, start, end);
		return new String(arr);
	}
        //反转字符串的重载
        public static String reverseString(String str){
		return reverseString(str, 0, str.length());
	}
	//反转字符数组
	private static void reverseCharArray(char[] arr, int start, int end){
		for(int s=start, z=end-1; s<z; s++, z--){
			swap(arr, s, z);
		}
	}
	//交换字符数组中的两个字符
	private static void swap(char[] arr, int a, int b){
		char temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}
	//去除字符串两端的空格
	public static String myTrim(String str){
		char[] arr = str.toCharArray();
		int start=0, end=arr.length-1;
		while(start<=end && arr[start++]==' ');
		while(start<end && arr[end--]==' ');
		return str.substring(start, end+1);
	}
}

StringBuffer是字符串缓冲区
 是一个容器
 特点：
 1.长度是可变化的
 2.可以字节操作多个数据类型
 3.最终会通过toString方法变成字符串
 
 C create
 U update
 R read
 D delete
1.存储
     StringBuffer append(基本数据类型，字符数组，String，StringBuffer， Object);将指定数据作为参数添加到已有数据结尾
     StringBuffer insert(index, 数据);可以将数据出插入到指定index位置

2.删除
     StringBuffer delete(int start, int end);删除缓冲区中的数据，包含start，不包含end
     StringBuffer deleteCharAt(int index);删除指定位置的数据
     
3.获取
    char charAt(int index);
    int length();
    int indexOf(String str);
    int lastIndexOf(String str);
    String substring(int start, int end); 返回值为String
    
4.修改
    StringBuffer replace(start, end, string);
    void setCharAt(int index, char ch);  注意：返回值为空
    
5.反转
    StringBuffer reverse();
    
6.将缓冲区中指定数据存储早指定字符数组中
    void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin);

示例代码：

public class StringBufferDemo {
	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer();
		sb.append(new int[]{1,2,3,4});  //将数组添加到StringBuffer中
		System.out.println(sb);
		//将缓冲区中指定数据存储早指定字符数组中
		sb.replace(0,sb.length(), "abcdef");
		char[] dst = new char[8];
		sb.getChars(1, 4, dst, 1);
		for(int i=0; i<dst.length; i++){
			sop("dst["+i+"]="+dst[i]);
		}
	}
	public static void method_update(){
		StringBuffer sb = new StringBuffer("abcdef");
		sb.replace(1, 3, "QQ");
		sb.setCharAt(5, 'H');  //替换一个字符，返回值为空
		sop(sb);
	}
	//删除
	public static void method_delete(){
		StringBuffer sb = new StringBuffer("haha");
		sb.delete(1, 3);
		//清空缓冲区
		sb.delete(0, sb.length());
		sb.delete(1, 2);//删除下标为1的字符
		sb.deleteCharAt(1);//删除下标为1的字符
		sop(sb);
	}
	//存储
	public static void method_add(){
		StringBuffer sb = new StringBuffer();
		sb.append("abc").append(467).append(false);//添加
		sb.insert(3, "qq"); //插入
		
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

JDK 1.5 版本之后出现了StringBuilder
StringBuffer是线程同步的
StringBuilder是线程不同步的
以后开发，建议使用StringBuilder

升级的三个因素:
    1.提高效率
    2.简化书写
    3.提高安全性

基本数据类型对象包装类
 
byte     Byte
short    Short
int      Integer
long     Long
char     Character
float    Float
double   Double
boolean  Boolean

基本数据类型对象包装类的最常见作用，
就是用于基本数据类型和字符串类型之间做转换

基本数据类型转成字符串
    1.基本数据类型+""
    2.基本数据类型.toString(基本数据类型值);
    3.String.valueOf(基本数据类型);
    
    如： Integer.toString(45); //将34整数变成"45"
    
字符串转成基本数据类型
    方法一：转换成基本数据类型
        xxx a = Xxx.parseXxx(String);
        int a = Integer.parseInt("34");  //必须是数字格式的字符串
        boolean b = Boolean.parseBoolean("true");
        注意：Character类没有这个方法
        Integer a = new Integer("43");
        int num = a.intValue();
    方法二：转换成基本数据类型的包装类对象
        Xxx a = Xxx.valueOf(String);
        Integer a = Integer.valueOf("78");  //必须是数字格式的字符串
        Boolean b = Boolean.valueOf("true");
        注意：Character类没有 Xxx.valueOf(String)这个方法
        Xxx Xxx.valueOf(xxx);主要用来将基本数据类型封装成包装类对象

十进制转成其他进制
    Xxx.toBinaryString();
    Xxx.toHexString();
    Xxx .toOctalString();
   注意： Xxx只能是Integer和Long，
                但是有 Float.toHexString(float);和 Double.toHexString(double);
其他进制转成十进制
    方法一：parseInt(String, radix);
    方法二：valueOf(String, radix);

JDK1.5版本以后出现的新特性
自动装箱
    Integer a = 4;
自动拆箱
    int num = a + 69; 等同于  int num = a.intValue() + 69;
    注意：Integer 比 int 多一个值 null，自动拆箱时应注意判断

一个小例子
        Integer m = 128;
        Integer n = 128;
        System.out.println("m==n:"+(m==n)); //结果为false
        Integer a = 127;
        Integer b = 127;
        System.out.println("a==b:"+(a==b)); //结果为true，因为a和b指向同一个Integer对象
                                           //因为当数值在byte范围内容，对于新特性，如果该值已存在，则不会开辟新的空间