Java语言基础常用对象API（一）String、StringBuffer

String类-常见功能

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

package cn.itcast.p1.stirng.demo;

public class StringDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {

        /*
         * String类的特点
         * 字符串对象一旦被初始化就不会被改变
         */
        stringDemo2();
    }

    private static void stringDemo2() {
        String s="abc";//在常量池中创建了"abc"字符串
        String s1=new String("abc");//创建两个对象，一个new，一个子字符串，在堆内存中
//        System.out.println("s="+s);
//        System.out.println("s="+s1);
        System.out.println(s==s1);//false，地址不同
        System.out.println(s.equals(s1));//true,String类覆写了Object类中的equals方法
                                        //字符串的equals比较的是内容
    }

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

按面向对象的思想对字符串进行功能分类
1.获取：
    1.1 获取字符串中字符的个数（长度）；
            int length();
    1.2 根据位置获取字符；
            char charAt(int index);
    1.3 根据字符，获取在字符串中第一次出现的位置;
            int indexOf(int ch);
            int indexOf(int ch,int fromIndex);//从指定位置进行查找ch第一次出现的位置，如果未出现该字符则返回-1
            int indexOf(String str);int indexOf(String str,int fromIndex);
           
            int lastIndexOf(int ch); // 返回指定字符在此字符串中最后一次出现处的索引
            int lastIndexOf(int ch,int fromIndex);//返回指定字符在此字符串中最后一次出现处的索引，
                                                //从指定的索引处开始进行反向搜索
            int lastIndexOf(String str);int lastIndexOfndexOf(String str,int fromIndex);
    1.4 获取字符串中的一部分字符串，也叫子串
            String substring(int beginIndex, int endIndex);//从beginIndex开始到endIndex-1，包含begin而不包含end
            String substring(int beginIndex);
            示例：
           

private static void stringMethodDemo_1() {
            String s="abcdae";
            System.out.println("length="+s.length());//6
            System.out.println("char="+s.charAt(2));//c
            System.out.println("index="+s.indexOf('a'));//0
            System.out.println("index="+s.indexOf('k'));//-1,可以根据-1来判断字符或者字符串是否存在
            System.out.println("lastIndex="+s.lastIndexOf('a'));//4
            System.out.println("substring="+s.substring(2,4));//cd
        }

2.转换：
    2.1 将字符串转成字符串数组（字符串的切割）；
            String[] split(String regex);//涉及到正则表达式
    2.2 将字符串转成字符数组；
            char[] toCharArray();
    2.3 将字符串转成字节数组；
            byte[] bytes=s.getBytes();
    2.4 将字符串中的字母转换大小写；
            String toUpperCase();//转为大写
            例：System.out.println("abc".toUpperCase());
            String toLowerCase();//转为小写
    2.5 将字符串中的内容进行替换；
            String  replace(char oldChar,char newChar);
            例：System.out.println("java".replace('a','o'));
            如果替换失败，则返回原字符串（地址不变）
            String  replace(String s1,String s2);
    2.6 将字符串两端的空格去除
            String trim();//返回字符串的副本，忽略前导空白和尾部空白
            例：System.out.println("-"+"  a  b  c  ".trim()+"-");//-a  b  c-
    2.7 将字符串进行连接
            String concat(string);
            例：System.out.println("abc".concat("kk"));

private static void stringMethodDemo_2() {
        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]);
        }
    }

3 判断
    3.1 两个字符串内容是否相同
            boolean equals(Object obj);
            booleam equalsIgnoreCase(string str);//忽略大小写比较字符串内容是否相同
            例：System.out.println(s.equalsIgnoreCase("ABC"));
    3.2 字符串中是否包含指定字符串
            boolean contains(string str);
            例：System.out.println(s.contains("ab"));
    3.3 字符串是否以指定字符串开头，是否以指定字符串结尾
            boolean startsWith(string);
            boolean endsWith(string);
            例：String str="ArrayDemo.java";
                        System.out.println(str.startsWith("Array"));//true
                        System.out.println(str.endsWith(".java"));//true

4 比较
    int compareTo(string);
    例：System.out.println("a".compareTo("c"));//-2

        intern方法
        intern():对字符串池进行操作、

String类练习

package cn.itcast.p1.stirng.demo;
/*
 * 1.给定一个字符串数组，按照字典书序进行从小到大的排序
 * {"nba","abc","cba","zz","qq","haha"}
 * 思路：
 * 1.对数组排序。可以用选择、冒泡法等排序。
 * 2.for嵌套、比较以及换位
 * 3.对象中提供了用于字符串比较的功能
 */
public class StringTest1 {
    public static void main(String[] args) {
        String[] arr = { "nba", "abc", "cba", "zz", "qq", "haha" };
        printArray(arr);
        sortString(arr);
        printArray(arr);
    }

    public static void printArray(String[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i != arr.length - 1)
                System.out.print(arr[i] + ",");
            else
                System.out.println(arr[i] + "]");
        }
    }

    public static void sortString(String[] 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)//字符串比较用compareTo方法
                    swap(arr,i,j);
            }
        }
    }

    private static void swap(String[] arr, int i, int j) {
        String temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}
/*
 *输出结果
 *[nba,abc,cba,zz,qq,haha]
 *[abc,cba,haha,nba,qq,zz]
 */

 

package cn.itcast.p1.stirng.demo;
/*
 * 2.一个子串在整串中出现的次数
 * "nbaernbatynbauinbaopnba"
 * 思路：
 * 1.获取要找的子串是否存在，如果存在，获取其出现的位置 ，这个可以使用indexOf()完成
 * 2.如果找到了，那么记录出现的位置并在剩余的字符串中继续查找该子串，
 * 剩余字符串的起始位置为出现位置+子串长度
 * 3.以此类推，通过循环完成查找，如果找不到就是-1，并在每次找到时用计数器count记录
 */
public class StringTest2 {

    public static void main(String[] args) {
        String str = "nbaernbatynbauinbaopnba";
        String key = "nba";
//        int count = getKeyStringCount(str, key);
        int count = getKeyStringCount_2(str, key);
        System.out.println("count=" + count);
    }

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

    /**
     * 获取子串在整串中出现的次数
     * @param str
     * @param key
     * @return
     */
    private static int getKeyStringCount(String str, String key) {
        // 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 cn.itcast.p1.stirng.demo;
/*
 * 3.两个字符串中最大相同的子串
 * "qwerabcdtyuiop"
 * "xcabcdxbn"
 * 思路：
 * 1.取的是最大子串，先看短的字符串是否是长字符串的子串；
 * 2.如果存在，则短串就是最大子串；
 * 3.如果不是，则将短串以递减的方式取子串，去长串中是否存在；
 * 4.如果存在，就已找到最大子串，否则重复3。
 */
public class StringTest3 {
    public static void main(String[] args) {
        String s1="qwerabcdtyuiop";
        String s2="xcabcdxbn";
        String s=getMaxSubString(s1,s2);
        System.out.println("s="+s);
    }
    /**
     * 获取最大子串
     * @param s1
     * @param s2
     * @return
     */
    private static String getMaxSubString(String s1, String s2) {
        String max=null,min=null;
        max=(s1.length()>s2.length()?s1:s2);
        min=max.equals(s1)?s2:s1;
        for(int x=0;x<min.length();x++){
            for(int y=0,z=min.length()-x;z!=min.length()+1;y++,z++){
                String sub=min.substring(y,z);
//                System.out.println(sub);
                if(max.contains(sub))
                    return sub;
            }
        }
        return null;
    }
}

package cn.itcast.p1.stirng.demo;

/*
 * 4.模拟一个trim功能一致的方法，去除字符串两端的空白
 *     1.定义两个变量，一个变量作为从头开始判断字符串空格的下标(++)；
 *     另一个从尾开始判断(--)；
 *     2.判断到不是空格为止，取首尾之间的子串即可；
 */
public class StringTest4 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        String s = "      ab    c     ";
        s = myTrim(s);
        System.out.println("-" + s + "-");
    }

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

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

既然是容器对象，则应具有什么方法？
1.添加；
        StringBuffer append(data);
        StringBuffer insert(index,data);
2.删除；
        StringBuffer delete(start,end);// 包含头，不包含尾
        StringBuffer deleteAt(int indxe);//删除指定位置元素   
        s.delete(0,s.length());//清空缓冲区
3.查找
        char charAt(index);
        int indexOf(string);
        int lastIndexOf(string);
4.修改
        StringBuffer replace(start,end);//包含头，不包含尾
        void setCharAt(index,char);
        void setLength(int newLength) //设置字符序列的长度
        StringBuffer reverse();// 将此字符序列用其反转形式取代

StringBuffer示例：

public class StringBuilderTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int[] arr={3,1,5,3,8};
        String s=arrayToString_2(arr);
        System.out.println(s);
    }
    /**
     * 将一个int数组变成字符串
     */
    public static String arrayToString_2(int[] arr){
        StringBuilder sb=new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if(i!=arr.length-1)
                sb.append(arr[i]+",");
            else
                sb.append(arr[i]+"]");
        }
        return sb.toString();
    }
    public static String arrayToString(int[] arr){
        String str="[";
        for (int i = 0; i < arr.length; i++) {
            if(i!=arr.length-1)
                str+=arr[i]+",";
            else
                str+=arr[i]+"]";
        }
        return str;
    }

}