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;    }}