JAVA基础笔记——String

String：用于描述字符串
特点：是被final修饰的，一旦被初始化不能被改变

String s1 =”abc”;
String s2 = new String(“abc”);
区别：s1在内存中只有一个对象，s2在内存中有两个对象

常用方法：

比较：
equals():String复写了此方法，用来比较字符串是否相同
equalsIgnoreCase(str):忽略大小写比较
compareTo():按照子典比较两个字符串

获取：
char charAt(int dex):获取摸个位置的字符
indexOf(int ch):返回ch在字符串第一次出现的位置，也可以判断是否包含
indexOf(String str):返回str.…
startsWith(String str),endsWith(str):字符串以..开头、结尾
contains(str):判断是否包含子串

转换：
将字符串<—->字符数组
char[] tocharArry():
new String(char[])
将字符串<—->字节数组(可指定编码表)
byte[] getBytes();
new String(byte[])
其他类型<—->字符串
copyValueOf(char[] c)
valueOf(…):

替换：
repalce(char,char);
repalce(str,str);

切割：
Split();
subString(int ):从指定位置到结尾
subString(int,int):包含头不包含结尾

转换大小写：
toUpperCase(),toLowerCase()

StringBuffer:字符串缓冲区，是一个容器
长度是可以变化的，
可以操作多个数据类型，
最终通过toString()变成字符串

常用方法：

1.增：
Append():将指定的数据加入到数据结尾处
Insert(index,str)：将数据插入到指定的位置

2.删：
Delete(start,end)：删除缓冲区的数据,包含头不包含尾

3.查：
charAt():
indexOf(str)
String subString(start,end)

4.改：
StringBuffer replace(start,end,str):
setCharAt(int,char)
5.反转：
StringBuffer reverse();

(JDK1.5以后)StringBuilder:一个可变的字符序列，但不保证同步，一般用于单线程，效率更高。

StringBuffer与StringBuilder:

StringBuffer:线程同步，（由于多线程时要判断锁），效率低
StringBuilder：线程不同步，多线程会带来安全问题，效率高。建议使用StringBuilder

进制转换：

十进制转换为其他进制：
toBinaryString
toHexString
toOctalString

其他进制转换为十进制：
parseInt(String s, int radix)

自动装箱拆箱：

Integer m = 137;
Integer n = 137;
Syso(m==n); //false

Integer m = 127;
Integer n = 127;
Syso(m==n); //true

原因：当数值处于byte的范围时，对于新特性，如果该数值已经存在，则不会再开辟空间

几个小练习：

1.去除字符串两端的空格：trim()

public class TrimString {

    /** 练习：去除字符串两端的空格
     *思路：
     *1.定义两个变量，依次递增递减
     *2.判断相应位置的字符
     *3.返回子串
     *
     **/
    public static void main(String[] args) {
        String str = "       ";
        System.out.println(trim(str));
    }
    public static String trim(String str) {
        int start = 0;
        int end = str.length()-1;

            while(start<end&&str.charAt(start)==' ') {
                start++;
            }

            while(start<end&&str.charAt(end)==' ') {
                end--;
            }

        return str.substring(start, end+1);
    }
}

2.统计一个字符串str1在另外一个字符串str2出现的次数

public class StringCount {
    /*统计一个字符串str1在另外一个字符串str2出现的次数
     * 思路：
     * 1.定义一个变量，通过indexOf()，索引相应字符串str1在str2中出现的位置
     * 2.变量自增str1的长度
     * 3.循环终止条件，indexOf()返回-1
     * 
     * */

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        stringCount("kk","kkkkgfkkkk");
    }



    public static void stringCount(String kk,String str) {
        int count = 0;

        int i = 0;
        while((i=str.indexOf(kk,i))!=-1) {

            i = i + kk.length();
            count++;
        }
        System.out.println(count);
    }


}

3.求出两个字符串的最大子串

public class MaxSubString {

    /**  求两个字符串的最大子串
     * 思路：
     * 1.将长度较短的字符串按照长度递减的方式获取到
     * 2.判断取到的字符串是否包含在大子串中
     * 3.如果包含，返回子串
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str = "sdfajjhellohjhfjgh";
        String str1 = "dhgfhdfelsdgsdfghgflohgf";
        System.out.println("最大子串为："+getMaxSubString(str,str1));
    }

    public static String getMaxSubString(String str,String str1) {
        /*判断连个字符串的长度，取到短的字符串，
         * 对短的字符串进行操作，这样可以减少遍历次数，
         * 可以提高效率
        */
        String max = "";
        String min = "";
        max = str.length()>str1.length()?str:str1;
        min = max==str?str1:str;

        //按字符串长度进行遍历
        for(int i=0;i<min.length()-1;i++) {

            //每次循环end减少1，循环i次减少i
            for(int start=0,end=min.length()-i;start<end&&end!=min.length();start++,end++) {

                //判断包含，可以替换为if(max.indexOf(min.substring(start,end))!=-1)
                if(max.contains(min.substring(start, end)))
                    return min.substring(start, end);
            }
        }

        return null;
    }

}