Java_String、StringBuffer、StringBuiler

提纲：
1． String概述
2． String类的构造方法
3． String类的判断功能
4． String类的获取功能
5． String类的转换功能
6． String练习
7． String类的常见面试题
8． StringBuffer类
9． StringBuilder类
10． 基本数据类型对象包装类

一、String概述

1、字符串是一个特殊的对象
2、一旦初始化不能被改变
如：String s = “abc”;
s = “ddd”;
System.out.println(s);
结果为：ddd
注：但不能证明字符串被改变，改变的只是地址，原先s指向“abc”，现在指向“ddd”
3、String str = “abc”与String str = new String(“abc”)有什么区别
他俩是一个意思，查看API可知String有带参数的构造函数。前者更简单一些

二、String类的构造方法

1．常见的构造方法
Public String():空构造//空字符序列
public String(byte[] bytes):把字节数组转成字符串//byte[] b = {98,93,101};
//String s = new String(b);
public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
public String(char[] value):把字符数组转成字符串//char[] ch = {‘a’,’c’,’d’};
//String s = new String(ch);
public String(char[] value,int index,int count):把字符数组的一部分转成字符串
public String(String original):把字符串常量值转成字符串//String s = new String(“orginal”);

三、String类的判断功能

boolean equals(Object obj)//:比较字符串的内容是否相同,区分大小写
boolean equalsIgnoreCase(String str)//:比较字符串的内容是否相同,忽略大小写
boolean contains(String str)//:判断大字符串中是否包含小字符串
boolean startsWith(String str)//:判断字符串是否以某个指定的字符串开头
boolean endsWith(String str)//:判断字符串是否以某个指定的字符串结尾
boolean isEmpty()//:判断字符串是否为空。

四、String的获取功能

int length()//:获取字符串的长度。
char charAt(int index)//:获取指定索引位置的字符
int indexOf(int ch)//:返回指定字符在此字符串中第一次出现处的索引。
int indexOf(String str)//:返回指定字符串在此字符串中第一次出现处的索引。
int indexOf(int ch,int fromIndex)//:返回指定字符在此字符串中从指定位置后第一次出现处的索引。
int indexOf(String str,int fromIndex)//:返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
lastIndexOf
String substring(int start)//:从指定位置开始截取字符串,默认到末尾。
String substring(int start,int end)//:从指定位置开始到指定位置结束截取字符串。

五、String类的转换功能

byte[] getBytes()//:把字符串转换为字节数组。
char[] toCharArray()//:把字符串转换为字符数组。
static String valueOf(char[] chs)//:把字符数组转成字符串。
static String valueOf(int i)//:把int类型的数据转成字符串。

注意：String类的valueOf方法可以把任意类型的数据转成字符串。
String toLowerCase()//:把字符串转成小写。

String toUpperCase()//:把字符串转成大写。
String concat(String str)//:把字符串拼接。

六、String类的简单练习

通过对以上内容的学习，利用上面的知识作如下的练习加以巩固。
1. 练习一，去除字符串两端空格
代码：

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);

    }

1. 练习二：将字符串反转
   代码：

/*
    1 将字符串变成数组
    2 对数组反转
    3 将数组变化层字符串
    */
    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;
    }

1. 练习三：获取一个字符串在另一个字符串中出现的次数
   代码：

    思路：
    1，定义一个计数器
    2，获取kk第一次出现的位置
    3，从第一次出现位置后剩余的字符串中继续获取kk出现的位置
        每获取一次就计数一次
    4，当获取不到indexOf返回-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_2(String str,String key)
    {
        int count = 0;
        int index = 0;
        while((index=str.indexOf(key,index))!=-1)
        {
            sop("index="+index);
            index = index+key.length();
            count++;
        }
        return count;
    }
第二种方式利用int indexOf(int ch,int fromIndex)方法，获取查找位置，就不用获取子串了，更简单高效

1. 练习四：获取两个字符串中最大相同子串。
   代码：

思路：
        1，将短的那个子串按照长度递减的方式获取到
        2，将每获取到的子串中判断是否包含，如果包含，找到！
    public static String getMaxSubString(String s1,String s2)
    {
        String max = "",min = "";
        max = (s1.length()>s2.length())?s1:s2;
        min = (max==s1)?s2:s1;
        sop("max="+max+".....");
        sop("min="+min+".....");
        for(int x=0; x<min.length(); x++)
        {
            for(int y=0,z=min.length()-x; z!=min.length()+1; y++,z++)
            {
                String temp = min.substring(y,z);
                if(max.contains(temp))
                    return temp;
            }
        }
        return "";
    }

七、String类的常见面试题

1.判断定义为String类型的s1和s2是否相等
String s1 = “abc”;
String s2 = “abc”;
System.out.println(s1 == s2); //true
System.out.println(s1.equals(s2)); //true
2.下面这句话在内存中创建了几个对象?
String s1 = new String(“abc”); //2
3.判断定义为String类型的s1和s2是否相等
String s1 = new String(“abc”);
String s2 = “abc”;
System.out.println(s1 == s2); //false
System.out.println(s1.equals(s2)); //true
4.判断定义为String类型的s1和s2是否相等
String s1 = “a” + “b” + “c”;//常量运算,编译时已经确定
String s2 = “abc”;
System.out.println(s1 == s2); //true
System.out.println(s1.equals(s2)); //true
5.判断定义为String类型的s1和s2是否相等
String s1 = “ab”;
String s2 = “abc”;
String s3 = s1 + “c”;//变量运算,运行时动态分配,从而是新的abc 不是s2指向的
System.out.println(s3 == s2);//false
System.out.println(s3.equals(s2)); //true

八、StringBuffer类

1. StringBuffer类是字符串缓冲区，是一个容器。
   缓冲区的特点：
   (1).长度是可变化的
   (2).可以字节操作多个数据类型
   (3).最终会通过toString方法变成字符窜
   (4).修改后返回同一个对象，并不新建对象
   什么时候用缓冲区：当数据类型不确定，数据个数也不确定，最后要得到字符串的时候，用缓冲区，比数组方便。
   2.StringBuffer具有的方法
   构造函数：
   StringBuffer()初始容量为16字符
   StringBuffer(int capacity)指定初始容量
   StringBuffer(String str)初始化内容
   （1）存储方法：
   StringBuffer append()函数：支持基本数据类型的添加（除了byte和short），将指定数据作为 添加到已有数据的结尾处
   例：
   StringBuffer sb = new StringBuffer();
   sb.append(“abc”).append(true).append(34);//方法调用链
   （2）插入方法
   StringBuffer insert(index,数据)将数据插入到指定位置，可以传入多种数据类型
   （3）删除方法
   StringBuffer delete(int start,int end)：删除缓冲区中的数据，包含start，不包含end
   StringBuffer deleteCharAt()：删除指定位置字符
   （4）修改方法
   StringBuffer replace(int start,int end,String str)将指定子串替换掉
   void setCharAt(int index,char ch)替换指定位置的字符，无返回值
   （5）反转方法
   StringBuffer reverse();
   （6）转存到数组
   void getChars(int srcBegin,int scEnd,char[] dst,int dstBegin)
   //获取缓冲区的指定数据并按字符存入指定数组的指定位置，这类方法都要注意角标越界异常

九、StringBuilder类

与StringBuffer的区别：StringBuffer是线程同步，StringBuildr是线程不同步，由于简化同步操作，后者效率更高。多线程建议使用StringBuffer，单线程建议使用StringBuilder。

十、基本数据类型对象包装类

1.基本数据类型和它们对应的包装类如下：
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

将基本数据类型包装后能提供更多的方法，实现更强大的功能。最常见的作用：用于基本数据类型和字符串类型之间做转换。
基本数据类型转换成字符串：
基本数据类型+””
基本数据类型.toString(基本数据类型值)
字符串转成基本数据类型：
X a = X.parseX(String):X代表基本数据类型的包装类
若字符串书写格式不是基本数据，会报数据格式异常

2.重要的方法
十进制转换
Integer.toBinaryString();转换成二进制
Integer.toHexString();转换成十六进制
Integer.toOctalString();转换成八进制
其他进制转换成十进制
parseInt(String s,int radix)接收指定进制的数字字符串，转换成十进制
Integer()构造方法
Integer(String s)接收数字字符串
Integer.intValue();基本数据包装类转换成基本数据类型
3. 1.5版本新特性 基本数据类型自动装箱
Integer x=4；数值自动装箱变成对象
x=x+2；这个语句先进行自动拆箱，变成int类型，加法运算后，再自动装箱
注意：若x=null，会抛空指针异常
下面代码：
Integer a=128；
Integer b=128；
System.out.println(a==b);//打印结果为false

                   Integer a=127；
                   Integer b=127；
                   System.out.println(a==b);//打印结果为true

当数值在byte范围内时，对于新特性，不会开辟新的空间