017_常用API_String类和StringBuffer类

Posted 2020-10-21 lydbky

1.String类

　　(1)字符串对象

　　　　  ①字符串是一个特殊的对象，字符串一旦初始化就不可以被改变。

                ②字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享

                ③String类中的equals()方法复写了Object类中的内容，其实就是比较字符串内容，而不是比较对象引用。　

public class StringDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        stringDemo2();
        stringDemo1();
    }

    /**
     * 演示定义字符串的第二种方式
     */
    private static void stringDemo2() {
        // TODO Auto-generated method stub
        String s="abc";//创建一个字符串对象在常量池中
        
        String s1=new String("abc");//创建两个对象，一个new一个在堆内存中
        
        System.out.println(s==s1);
        
        System.out.println(s.equals(s));
    }

    /**
     * 演示定义字符串的第一种方式
     */
    private static void stringDemo1() {
        String s="abc";
        
        String s1="abc";
            
        System.out.println(s==s1);
    }
}

　　(2)构造函数

　　　　String(byte[] bytes)
　　　　　　通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。

　　　　String(int[] codePoints, int offset, int count)
　　　　　　分配一个新的 String，它包含 Unicode 代码点数组参数一个子数组的字符

public class StringConstructorDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        stringConstructorDemo1();
    }

    private static void stringConstructorDemo1() {
        // TODO Auto-generated method stub
        char[] arr= {‘a‘,‘b‘,‘c‘,‘d‘};
        
        String s=new String(arr,1,3);
        System.out.println("s1="+s);
    }

    public static void stringConstructorDemo() {
        // TODO Auto-generated method stub
        String s=new String();//不等于String s=null;
        
        byte[] arr= {65,66,67};
        
        String s1=new String(arr);
        System.out.println("s1="+s1);
    }
}

　　(3)String类常用方法　　　　

　　　　①获取
　　　　　　1.1 获取字符串长度 int length()

　　　　　　1.2 根据位置获取字符 char charAt(int index)

　　　　　　1.3 根据字符获取第一次出现的位置
　　　　　　　　　　int indexOf(int ch)

　　　　　　　　从指定位置开始获取第一次出现的位置
　　　　　　　　　　int indexOf(int ch,int fromIndex)
　　　　　　　　返回指定子字符串在此字符串中第一次出现处的索引。 
　　　　　　　　　　indexOf(String str)
　　　　　　　　返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始 
　　　　　　　　　　int indexOf(String str, int fromIndex)

　　　　　　　　返回指定字符在此字符串中最后一次出现处的索引。 

　　　　　　　　　　int lastIndexOf(int ch)

　　　　　　　　返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。 
　　　　　　　　　　int lastIndexOf(int ch, int fromIndex)

　　　　　　　　返回指定子字符串在此字符串中最右边出现处的索引。
　　　　　　　　　　int lastIndexOf(String str)
　　　　　　　　返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
　　　　　　　　　　int lastIndexOf(String str, int fromIndex)

　　　　　　　　注意:可以根据-1判断字符或者字符串是否存在

　　　　　　1.4 获取字符串的子串
　　　　　　　　　　String substring(int beginIndex)
　　　　　　　　　　　　返回一个新的字符串，它是此字符串的一个子字符串。
　　　　　　　　　　String substring(int beginIndex, int endIndex)
　　　　　　　　　　　　返回一个新字符串，它是此字符串的一个子字符串。
　　　　②转换
　　　　　　2.1将字符串切割成字符串数组
　　　　　　　　String[] split(String regex)
　　　　　　　根据给定正则表达式的匹配拆分此字符串。
　　　　　　　　String[] split(String regex, int limit)
　　　　　　　根据匹配给定的正则表达式来拆分此字符串
　　　　　　2.2将字符串变成字符数组
　　　　　　　　char[] toCharArray()
　　　　　　2.3将字符串变成字节数组
　　　　　　　　byte[] getBytes()
　　　　　　2.4将字符串中的字母转换成大写
　　　　　　　　　String toUpperCase()

　　　　　　2.5将字符串中的内容进行替换
　　　　　　　　　String replace(char oldChar, char newChar)

　　　　　　2.6将字符串两端空格消除
　　　　　　　　　String trim();
　　　　　　2.7将字符串进行连接
　　　　　　　　　String concat();
　　　　③判断
　　　　　　3.1两个字符串内容是否相同？
　　　　　　　　boolean equals(Object anObject)
　　　　　　　 将此 String 与另一个 String 比较，不考虑大小写
　　　　　　　　boolean equalsIgnoreCase(String anotherString)
　　　　　　3.2字符串中是否包含某一字符串？
　　　　　　　　boolean contains(CharSequence s)
　　　　　　3.3字符串是否都以指定字符串开头或结尾
　　　　　　　　boolean startsWith(String prefix)
　　　　　　　　boolean endsWith(String suffix)
　　　　④比较
　　　　　　　　int compareTo(String anotherString)
　　　　　　　　　　按字典顺序比较两个字符串。
　　　　　　　　int compareToIgnoreCase(String str)
　　　　　　　　　　按字典顺序比较两个字符串，不考虑大小写

2.StringBuffer类

　　StringBuffer：字符缓冲区，用于存储数据的容器

　　(1)特点

　　　　①长度可变
　　　　②可以存储不同类型的数据
　　　　③最终要转成字符串进行使用
　　　　④可以对字符串进行修改

　　(2)功能

　　　　①添加

　　　　　　StringBuffer append(data);
　　　　②插入
　　　　　　StringBuffer insert(index,data);
　　　　③删除
　　　　　　StringBuffer delete(start,end);//包含头，不包含尾
　　　　　　StringBuffer deleteCharAt(int index);
　　　　④查找
　　　　　　char charAt(index)
　　　　　　int indexOf(String)
　　　　　　int lastIndexOf(String)
　　　　⑤修改
　　　　　　StringBuffer replace(start,end,String)
　　　　　　void setCharAt(index,char)

3.StringBuilder类　　

　　　　(1)StringBuilder是线程不同步的。通常用于单线程，效率高。
　　　　(2)StringBuffer是线程同步的。通常用于多线程。

4.String类练习

/*1.给定一个字符串数组，按字典顺序进行从小到大的排序。
 * 
 *2.一个子串在整串中出现的个数。
 *
 *3.两个字串中最大的相同子串。
 * 
 *4.模拟一个trim功能一致的方法。
*/

public class StringTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //1.给定一个字符串数组，按字典顺序进行从小到大的排序。
        String[] arr= {"nba","abc","cba","zz","qq","haha"};
        sort(arr);
        
        //2.一个子串在整串中出现的个数。
        String str="nbaernbatynbauinbaopnba";
        String key="nba";
        System.out.println("count=="+getKeyStringCount(str,key));
        
        //3.两个字串中最大的相同子串。
        String maxSub=getMaxSubString("qwerabcdeyuion","qwerabcde");
        System.out.println("maxSub="+maxSub);
        
        //4.模拟一个trim功能一致的方法
        String s="    abc abc   ";
        System.out.println("trimSub="+myTrim(s));
    }

    public static void printArr(String[] arr) {
        // TODO Auto-generated method stub
        for(int i=0;i<arr.length;i++)
        {
            System.out.print(arr[i]+",");
        }
    }

    public static void sort(String[] arr)
    {
        System.out.println("排序前:");
        printArr(arr);
        
        for(int i=0;i<arr.length-1;i++)
        {
            for(int j=i+1;j<arr.length;j++)
            {
                if(arr[i].compareTo(arr[j])>0)
                {
                    swap(i,j,arr);
                }
            }
        }
        
        System.out.println();
        System.out.println("排序后:");
        printArr(arr);
        System.out.println();
    }

    public static void swap(int i, int j, String[] arr) {
        // TODO Auto-generated method stub
        String temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }

    public static int getKeyStringCount(String str,String key)
    {
        int count=0;
        int index=0;
        
        while((index=str.indexOf(key,index))!=-1)
        {
            index=index+key.length();
            count++;
        }
        return count;
    }

    public static String getMaxSubString(String s1,String s2)
    {
        String max=(s1.length()>s2.length())?s1:s2;
        String min=(max.equals(s1))?s2:s1;
        
        System.out.println("max="+max);
        System.out.println("min="+min);
        
        /*
         *abcdefg 7-0
         *abcdef bcdefg 7-1
         *abcde bcdef cdefg 7-2
         *.........................
        */
        for(int i=min.length();i>0;i--)
        {
            for(int j=0;j<=min.length()-i;j++)
            {
                
                String sub=min.substring(j, j+i);          
                if(max.contains(sub))
                    return sub;
            }
        }
        return null;
    }

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