String练习

易错

    @Test
    public void test_start() throws ParseException {
        String str = null;
        System.out.println(str);  //null

        StringBuilder s = new StringBuilder();
        /*
            public AbstractStringBuilder append(String str) {
                 if (str == null)
                     return appendNull();
                ****
            }
        private AbstractStringBuilder appendNull() {
            int c = count;
            ensureCapacityInternal(c + 4);
            final char[] value = this.value;
            value[c++] = 'n';
            value[c++] = 'u';
            value[c++] = 'l';
            value[c++] = 'l';
            count = c;
            return this;
        }
        */
        s.append(str);

        System.out.println(s.length());
        System.out.println(s);  // "null"

        /*
        public StringBuilder(String str) {
            super(str.length() + 16);
            append(str);
         }
        */
        StringBuilder s1 = new StringBuilder(str); // java.lang.NullPointerException
        s.append(s1);


    }

String s = new String(“xyz”)，创建了几个对象

• 两个，一个字符对象，一个字符引用对象

Math.round(11.5)等于多少? Math.round(-11.5)等于多少

Math.round(11.5)12;Math.round(-11.5)-11;round方法返回与参数最接近的长整数，参数加1/2后求其floor

String VS StringBuffer VS StringBuilder

• String的值是不可变的，这导致了每次对String的操作都会生成新的String对象，这样不仅效率低下，而且造成了大量的内存浪费
• 因此，当需要修改字符串时，最好用StringBuffer或者StringBuilder
• StringBuffer或者StringBuilder类的对象能够被多次修改，并且不产生新的未使用对象
• StringBuilder类在Java5的时候提出，和StringBuffer之间的最大不同在于StringBuilder的方法不是线程安全的，但是StringBuilder速度更快，所以在不要求线程安全的情况下,StringBuilder更常使用。

模拟一个trim方法，去除字符串两端的空格。

public String trim(String str){
        char[] arr = str.toCharArray();
        int start = 0;
        int end = str.length();


        while (start < end &&  arr[start] == ' ' ){
            start++;
        }

        while (start < end &&  arr[end - 1] == ' ' ){
            end--;
        }


        return start < end ? str.substring(start, end) : str;
    }

    @Test
    public void test_start(){
        String Str1 = new String("   abcdefgww");

        System.out.println("--:" + trim(Str1) + " ");
        System.out.println("--:" + Str1 + " ");

        String Str2 = new String("   abcdefgww");
        System.out.println("--:" + Str2.trim() + " ");
        System.out.println("--:" + Str2 + " ");
    }

将一个字符串进行反转。将字符串中指定部分进行反转。比如“abcdefg”反转为”abfedcg”

方法1：

public String reverse(String str,int startIndex,int endIndex){
        if (str == null || str.length() == 0){
            return str;
        }

        if ( endIndex >= str.length()){
            System.out.println("endIndex超出索引范围");
            return str;
        }

        if (startIndex > endIndex){
            System.out.println("开始索引必须小于或者等于结束索引");
            return str;
        }

        char[] arr = str.toCharArray();
        for (int i = startIndex, j = endIndex; i < j; i++, j--){
            char t = arr[i];
            arr[i] = arr[j];
            arr[j] = t;
        }

        return new String(arr);
    }

    public String reverse(String str,int startIndex,int endIndex){
        if (str == null || str.length() == 0){
            return str;
        }

        if ( endIndex >= str.length()){
            System.out.println("endIndex超出索引范围");
            return str;
        }

        if (startIndex > endIndex){
            System.out.println("开始索引必须小于或者等于结束索引");
            return str;
        }

        StringBuilder t = new StringBuilder(str.substring(0, startIndex));
        for (int i = endIndex; i > startIndex - 1; i--){
            t.append(str.charAt(i));
        }

        t.append(str.substring(endIndex + 1));



        return t.toString();
    }

    @Test
    public void test_start(){
        String Str1 = new String("abcdefgww");

        System.out.println("--:" + reverse(Str1, 2, 5) + " ");
        System.out.println("--:" + Str1 + " ");

    }

获取一个字符串在另一个字符串中出现的次数

比如：获取“ ab”在 “abkkcadkabkebfkabkskab” 中出现的次数

public int getCount(String mainStr,String subStr){
        int mainlen = mainStr.length();
        int sublen = subStr.length();
        int count = 0;
        if (sublen > mainlen){
            return count;
        }

        while (true){
            int  index = mainStr.indexOf(subStr);
            if (index == -1){
                break;
            }else{
                count++;
                mainStr = mainStr.substring(index + sublen);
            }
        }

        return count;
    }

对字符串中字符进行自然顺序排序

public String orderString(String str){
        char[] arr = str.toCharArray();
        Arrays.sort(arr);
        return new String(arr);
    }

获取两个字符串中最大相同子串

分析：

查找的方法就是把两个字符串中较短的那个依次减小,然后按照该长度在短的字符串中获取所有子串依次判断该子串是否存在于长的字符串中.

str1 = “eysdfghjkl”;
str2 = “cxbghjp”;
需要找出这里两个字符串中最大的字符子串,这里就是**“ghj”**.
1、上面的那两个字符串短的是str2,长度为7,即str2.leng() == 7.这个没有异议吧.
然后依次减小,先从7开始,str2长度为7的子串只有一个吧,就是str2本身.那判断str2是否是str1的子串.很明显不是.那我们就把上面黑体字部分的定义为第一轮

2、那我们开始第二轮,str2的长度依次减小,上一轮的长度为7,那这一轮就是6,那我们就找长度为6的str2的子串,只有两个:
(1) “cxbghj”
(2) “xbghjp”

3、然后判断上面这两个字符串的是否是str1的子串,也不是.
继续开始第三轮,第三轮的长度为5,str2长度的子串有3个:
(1) “cxbgh”
(2) “xbghj”
(3) “bghjp”

4、判断这三个字符串是否是str1的子串.不是.
第四轮,长度为4,四个str2的子串
(1) “cxbg”
(2) “xbgh”
(3) “bghj”
(4) “ghjp”
也没有是str1的子串.

5、第5轮长度为3,5个str的子串.
(1) “cxb”
(2) “xbg”
(3) “bgh”
(4) “ghj”
(5) “hjp”
在这一轮对比到(4)的时候判断(4)是str1的子串.就马上退出,就找到了这两个字符串的子串

实现代码如下:

public String getMaxSameString(String str1 ,String str2){
        if (str1 == null || str2 == null){
            return null;
        }

        String maxStr = str1.length() >= str2.length() ? str1 : str2;
        String minStr = str1.equals(maxStr) ? str2 : str1;

        for (int i = 0; i < minStr.length(); i++){
            int len = minStr.length() - i;
            for (int a = 0; a + len <= minStr.length(); a++){
                // ------------ end = a + len
                // [0, minStr.length)
                // [0, minStr.length - 1) , [1, minStr.length)
                // [0, minStr.length - 2 ) , [1, minStr.length - 1) [2, minStr.length)
                String con = minStr.substring(a, a + len);
                if (maxStr.contains(con)){
                    return con;
                }
            }
        }

        return null;
    }

public String getMaxSameString(String str1 ,String str2){
        if (str1 == null || str2 == null){
            return null;
        }

        String maxStr = str1.length() >= str2.length() ? str1 : str2;
        String minStr = str1.equals(maxStr) ? str2 : str1;

        for (int i = 0; i < minStr.length(); i++){
            for (int a = 0, b =  minStr.length() - i; b <= minStr.length(); a++, b++){
                // ------------ end = a + len
                // [0, minStr.length)
                // [0, minStr.length - 1) , [1, minStr.length)
                // [0, minStr.length - 2 ) , [1, minStr.length - 1) [2, minStr.length)
                String con = minStr.substring(a, b);
                if (maxStr.contains(con)){
                    return con;
                }
            }
        }

        return null;
    }