Java基础——String API

1、初识String类

package on.itcase.p1.string.demo;

public class StringDemo {
    public static void main(String[] args)
    {
        /*
         * String 类的特点：
         * 字符串对象一旦被初始化就不会被改变
         */
        StringDemo2();
    }

    private static void StringDemo2() {
        // TODO Auto-generated method stub
        String s="abc";//创建一个字符串对象在常量池中
        String s1=new String("abc");//创建两个对象一个new一个字符串对象在堆内存中

        System.out.println(s==s1);//false
        //因为s是在常量池中创建的一个对象，可以被共享，而s1是在堆中创建的两个对象，是属于"abc"是属于s1对象的，它们地址不同
        System.out.println(s.equals(s1));//true，比较的是内容，String类中
        //的equals复写Object中的equals建立了String类自己的判断字符串对象是否相同的依据，其实就是比较字符串内容

        System.out.println("s="+s1);
        System.out.println("s1="+s1);
    }
    /**
    }
     * 演示字符串定义的第一种方式，并明确常量池的特点
     * 池中没有就建立，池中有就直接用
     */
    private static void StringDemo1() {
        String s="abc";//"abc"存储在字符串常量池中，如果有就不创建，没有就不创建
//      s="abc";
        String s1="abc";
        System.out.println(s==s1);//true
//      System.out.println("s="+s);
    }
}

2、String结构

package on.itcase.p1.string.demo;

public class StringConstructorDemo {
    public static void main(String[] args)
    {
         stringConstructorDemo();
         stringConstructorDemo2();
    }

    private static void stringConstructorDemo2() {
        // TODO Auto-generated method stub
        char[] arr= {'a','b','c','d','e'};
        String s=new String(arr,1,2);//将字符数组变成字符串，从角标1开始取2个
        System.out.println("s="+s); 

    }

    public static void stringConstructorDemo() {
        // TODO Auto-generated method stub
        String s=new String();//相当于String s="";不等效于String s=null;
        byte[] arr= {65,67,68};

        String s1=new String(arr);//将字节数组变成字符串
        System.out.println("s1="+s1);

    }
}

3、String方法

package on.itcase.p1.string.demo;

public class StringMethodDemo {
    public static void main(String[] args)
    {
        /*
         * 按照面向对象的思想对字符串进行功能分类
         * "abcd"
         * 
         * 1、获取：
         * 1.1获取字符串中字符的个数长度
         *      int length();
         * 1.2根据位置获取字符
         *      char charAt(int index);
         * 1.3根据字符获取在字符串中的第一次出现的位置
         *      int indexOf(int ch)
         *      int indexOf(int ch,int fromIndex);从指定位置进行ch的查找第一次出现的位置
         *      int indexOf(String str);获取子符串在字符串中第一出现的位置
         *      int indexOf(String str,int fromIndex);从指定位置进行某个字符串的查找第一次出现的位置
         *  
         *      根据字符获取在字符串中的第一次出现的位置，从后往前找
                int lastIndexOf(int ch)//
         *      int lastIndexOf(int ch,int fromIndex);从指定位置进行ch的查找第一次出现的位置
         *      int lastIndexOf(String str);获取子符串在字符串中第一出现的位置
         *      int lastIndexOf(String str,int fromIndex);从指定位置进行某个字符串的查找第一次出现的位置
         * 
         * 1.4获取字符串中的一部分字符串，也叫子串
         *      String substring(int beginIndex,int endIndex);//获取从beginIndex开始的位置到endIndex结束位置的子字符串，注意：是到endIndex-1的位置
         *      String substring(int beginIndex);//获取从beginIndex开始的位置到后面所有的字符的子符串
         * 
         * 2、转换
         *      2.1将字符串变成字符串数组（字符串的切割）
         *          String[] split(String regex);//regex表示切割规则，既可以是简单的规则也可以是正则表达式
         *      2.2将字符串变成字符数组
         *          char[] toCharArray();
         *      2.3将字符串变成字节数组
         *          byte[] getBytes();
         *      2.4将字符串中的字母转成大小写
         *          String toUpperCase();大写
         *          String toLowerCase();小写
         *      2.5将字符串中的内容进行替换
         *          String replace(char oldCh,char newCh); 
         *          String replace(String s1,String s2);
         *      2.6将字符串两端的空格去除
         *          String trim();
         *      2.7将字符串进行连接
         *          String concat(string);  
         * 3、判断
         *      3.1两个字符串内容是否相同
         *          boolean equals(Object obj);
         *          boolean equalsIgnoreCase(string str);忽略大小写比较内容
         *      3.2字符串中是否包含指定字符串
         *          boolean contains(string str);
         *      3.3字符串是否以指定字符串开头，是否以指定字符结尾
         *          boolean startswith(string str);
         *          boolean endswith(string str);
         * 4、比较
         *  
         *              
         * */
        stringMethoDemo_1();
        stringMethoDemo_2();
        stringMethoDemo_3();
        stringMethoDemo_4();
    }

    private static void stringMethoDemo_4() {
        // TODO Auto-generated method stub
        System.out.println("abc".compareTo("bcd"));//前面小于后面就是负数，一个一个比较，相同就比下一个，下一个有结果了就不再比较
    }

    private static void stringMethoDemo_3() {
        // TODO Auto-generated method stub
        String s="abc";
        System.out.println(s.equals("ABC".toLowerCase()));
        System.out.println(s.equalsIgnoreCase("ABC"));

        System.out.println(s.contains("bc"));

        String str="ArrayDemo.java";

        System.out.println(str.startsWith("Array"));
        System.out.println(str.endsWith(".java"));

    }

    private static void stringMethoDemo_2() {
        // TODO Auto-generated method stub
        String s="张三,李四,王五,";
        String[] arr=s.split(",");
        for (int i=0;i<arr.length;i++)
        {
            System.out.println(arr[i]);
        }

        char[] chs=s.toCharArray();
        for (int i=0;i<chs.length;i++)
        {
            System.out.println(chs[i]);
        }

        s="ab你";
        byte[] bytes=s.getBytes();
        for(int i=0;i<bytes.length;i++)
        {
            System.out.println(bytes[i]);
            /*结果：打印的是字节码，UTF-8一个汉字是三个字节
             *  97
                98
                -28
                -67
                -96
             * */
        }
        System.out.println("Abc".toUpperCase());
        System.out.println("abc".concat("kk"));
        System.out.println("-"+"   ab c    ".trim()+"-");//去除字符串两端的空格，不去除中间的
    }

    private static void stringMethoDemo_1() {
        // TODO Auto-generated method stub
        String s="abcdae";
        System.out.println("length:"+s.length());
        System.out.println("char:"+s.charAt(2));
        System.out.println("index:"+s.indexOf("a"));//我们可以根据-1来判断该字符或者字符串是否存在，如果等于-1则表示不存在
        System.out.println("lastIndex:"+s.lastIndexOf('a'));
        /*结果：
         * length:6
           char:c
           index:0
           lastIndex:4
         * 
         * */
        System.out.println("substring:"+s.substring(2,4));//结果：substring:cd
    }
}

package on.itcase.p1.string.demo;

public class StringObjectDemo {
    public static void main(String[] args)
    {
//      String s1="abc";
//      String s2="abc";

        //intern():对字符串池进行操作的
         String s1=new String("abc");
         String s2=s1.intern();

         System.out.println(s1==s2);//结果为：false，池中没有"abc"对象，所以进行创建并赋给s2，并添加到池中
    }
}

4、String的4个应用例子

package on.itcase.p1.string.demo;

/*1、给定一个字符串数组，按照字典顺序进行从小到大排序
 * 
 * 思路：
 * 1、对数组排序，可以用选择、冒泡都行
 * 2、for嵌套和比较以及换位
 * 3、
 * 
 * 
 * */



public class StringTest_1 {
    public static void main(String[] args)
    {
        String[] arr= {"nba","abc","cba","zz","qq","haha"};
        printArray(arr);
        sortArray(arr);
        printArray(arr);

    }

    private static void sortArray(String[] arr) {
        // TODO Auto-generated method stub
        for(int i=0;i<arr.length;i++)
        {
                for(int j=i+1;j<arr.length;j++)
                {
                    if(arr[i].compareTo(arr[j])>0)//字符串比較用compareTo方法
                        swap(arr,i,j);

                }
        }
    }

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

    private static void printArray(String[] arr) {
        // TODO Auto-generated method stub
        System.out.print("[");
        for (int i=0;i<arr.length;i++)
        {
            if(i!=arr.length-1)
                System.out.print(arr[i]+", ");
            else
                System.out.print(arr[i]+"]\n");
        }
    }
}

package on.itcase.p1.string.demo;
/*
 * 2、一个字串在整串中出现的次数
 * "nbaernbaynbauinbaopnba"
 * 思路：
 * 1、要找的字串是否存在，如果存在獲取其出現的位置，這個可以使用indexOf完成
 * 2、如果找到了，那麼就記錄出現的位置并在剩余字符串中查找该字串，而剩余字符串
 * 的起始位置是出现位置+字串的长度
 * 3、以此类推，通过循环完成查找，如果找不到就是-1，并对每次找到用计数器记录
 * 
 * */
public class StringTest_2 {
    public static void main(String[]args)
    {
        String str="nbaernbaynbauinbaopnba";
        String key="nba";

        int count=getKeyStringCount(str,key);
        int count1=getKeyStringCount2(str,key);
        System.out.println("Count="+count);
        System.out.println("Count1="+count1);



    }

    private static int getKeyStringCount2(String str, String key) {
        // TODO Auto-generated method stub
        int count=0;
        int index=0;
        while((index=str.indexOf(key,index))!=-1)
        {
            index=index+key.length();
            count++;
        }
        return count;
    }

    /*
     * 获取字串在整串中出现的次数
     * 
     * 
     * */
    private static int getKeyStringCount(String str, String key) {
        // TODO Auto-generated method stub
        //1、定义计数器
        int count=0;
        //2、定义变量key出现的位置
        int index=0;

        while((index=str.indexOf(key))!=-1)
        {
            str=str.substring(index+key.length());
            count++;
        }
        return count;
    }
}

package on.itcase.p1.string.demo;
/*
 * 3、两个字符串中最大相同的字串
 * "qwerabcdtyadf"
 * "xcabcdvbn"
 * 思路：
 * 1、既然取得是最大字串，先看短的哪个字符串是否在长的哪个字符串中，如果存在，短的哪个字符串
 * 就是最大字串
 * 2、如果不是，那么就将短的那个子串长度按递减的方式减去子串，看长串中是否存在
 * 如果存在就已找到，也就不同再找了
 * */
public class StringTest_3 {
    public static void main(String[] args)
    {
        String s1="qwerabcdtyadf";
        String s2="xcabcdvbn";

        String s=getMaxSubstring(s1,s2);
        System.out.println(s);
    }
    /*
     * 获取最大子串
     * 
     * */

    private static String getMaxSubstring(String s1, String s2) {
        // TODO Auto-generated method stub
        String max=null,min=null;
        max=(s1.length()>s2.length())?s1:s2;
        min=max.equals(s1)?s2:s1;
        for(int i=0;i<min.length();i++)
        {
            for(int a=0,b=min.length()-i;b!=min.length()+1;a++,b++)
            {
                String sub=min.substring(a, b);
            //  System.out.println("s="+s);
                if(max.contains(sub))
                    return sub;
            }

        }
        return null;

    }
}

package on.itcase.p1.string.demo;


/*
 * *4、模拟一个trim功能一致的方法,去除字符串两端的空白
 * 思路：
 * 1、定义两个变量
 * 一个变量作为从头开始判断字符串空格的角标
 * 一个变量作为从尾开始判断字符串空格的角标
 * 2、判断到不是空格位置，取头尾之间的字符串即可
 * 
 */
public class StringTest_4 {
    public static void main(String[]args)
    {
        String s="   ab  c    ";

        s=Mytrim(s);
        System.out.println("-"+s+"-");

    }

    public static String Mytrim(String s) {
        // TODO Auto-generated method stub
        int start=0;
        int end=s.length()-1;

        while(start<=end && s.charAt(start)==' ')
        {
            start++;
        }
        while(start<=end && s.charAt(end)==' ')
        {
            end--;
        }
        return s.substring(start, end+1);
    }
}

5、StringBuffer和StringBuilder
* StringBuffer就是字符串缓冲区，用于存储数据的容器
* 特点：
* 1、长度是可变的
* 2、可以存储不同类型的数据
* 3、最终要转成字符串进行使用
* 4、可以对字符串进行修改

package on.itcase.p2.stringbuffer.demo;

public class StringBufferDemo {
    public static void main(String[]args)
    {
        /*
         * StringBuffer就是字符串缓冲区，用于存储数据的容器
         * 特点：
         * 1、长度是可变的
         * 2、可以存储不同类型的数据
         * 3、最终要转成字符串进行使用
         * 4、可以对字符串进行修改
         * 
         * 既然是一个容器，具备以下功能：
         * 1、添加:
         *      StringBuffer append(data);
         *      StringBuffer append(index,data);
         * 2、删除
         *      StringBuffer delete(start,end);包含头不包含尾
         *      StringBuffer deleteCharAt(int,index);删除指定位置的元素
         * 3、查找
         *      和字符串的方法一样
         *      char charAt(index);
         *      int indexOf(string);
         *      int lastIndexOf(string);
         * 4、修改：
         *      StringBuffer replace(start,end,string); //从start的位置到end的位置由string替换
         *      void setCharAt(index,char);
         * */
        bufferMethodDemo();
        bufferMethodDemo1();
        bufferMethodDemo2();
    }
    private static void bufferMethodDemo2() {
        // TODO Auto-generated method stub
        StringBuffer sb=new StringBuffer("abce");

        sb.delete(1, 3);//结果:ae

        //清空缓冲区，即全删除
//      sb.delete(0, sb.length());
//      sb=new StringBuffer();//和上面一样的效果，清空缓冲区

//      sb.replace(1, 3, "nba");
//      sb.setCharAt(2, 'q');

        /*结果
         *  sb:
            len:0
         * 
         * */
        sb.setLength(0);
        System.out.println("sb:"+sb);
        System.out.println("len:"+sb.length());
    }
    private static void bufferMethodDemo1() {
        // TODO Auto-generated method stub
        StringBuffer sb=new StringBuffer("abcd");
//      sb.append("xixi");
        sb.insert(1, "qq");
        System.out.println(sb.toString());//实现了对字符串进行修改
    }
    public static void bufferMethodDemo() 
    {
        //创建缓冲区对象
        StringBuffer sb=new StringBuffer();

        StringBuffer s1=sb.append(4);
        sb.append(true);
        sb.insert(1, "haha");

        System.out.println(sb);//下面和这个打印的一样都是4,sb里面最终都将转换为字符串存储
        System.out.println(s1);//s1和sb指向同一个地址

    }
}

StringBuilder的介绍
* jdk1.5以后出现了功能和StringBuffer一模一样的对象，就是StringBuilder
*
* 不同的是：
* StringBuffer是线程同步的
* StringBuilder是线程不同步的，即速度更快，因为没加锁
* 单线程用StringBuilder,多线程用StringBuffer