java 常用类之String-StringBuffer

一.String类：

String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。 字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享。

1.String类常用的构造方法:

    String():表示一个空字符序列。    public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数    public String(byte[] bytes,int index,int length):将部分字节数组构造成一个字符串    public String(char[] value):将字符数组构造成一个字符串    public String(char[] value,int index,int length):将部分的字符数组构造成一个字符串    public String(String original):通过字符串常量构造一个字符串对象获取字符串的长度功能:                public int length()

面试题:

    数组中有没有length(),字符串(字符串缓冲区:StringBuffer)中没有length(),集合中有没有length()(集合后面讲)?        数组没有length(),length属性        字符串中有length()        集合中没有length(),获取集合中元素数量:size()

编码和解码:

一定要保证编码格式一致    编码:        把能看懂的东西转换成一个看不懂的东西:String----->byte[]:public byte[] getBytes(String charsetName)    解码:        把当前的byte[]转成能看懂的东西(String):byte[]----->String  :public String(byte[] bytes,CharsetName ch)

举例:
谍战片:
今天老地方见:

        编码:"今"----->字节数组:byte[]---->字节类型:形成一种二进制数据        解码:二进制数据---->十进制进制数据----->String:"今"

public class StringDemo {    public static void main(String[] args) throws UnsupportedEncodingException {        //创建一个String对象        String s1 = new String() ;        System.out.println("s1.length():"+s1.length());        System.out.println("s1:"+s1);        System.out.println("----------------------");        //public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数        //创建一个字节数组        byte[] bys = {97, 98, 99, 100, 101} ;         String s2 = new String(bys) ;//字节的值要找它对应的ASCII码表中的字符        System.out.println("s2:"+s2);        //abcde        System.out.println("s2.length():"+s2.length());//5        System.out.println("----------------------");        /**         * 编码和解码         */        //定义一个字符串:        String s = "你好" ;        //[-60, -29, -70, -61]  :GBK        //[-28, -67, -96, -27, -91, -67]:utf-8//      byte[] bys2 = s.getBytes("utf-8") ;//编码:以:GBK格式编码     utf-8:一个中文:对应三个字节        byte[] bys2 = s.getBytes() ;//      System.out.println(bys2);        //Arrays:数组工具类:toString(byte[] bys)        System.out.println(Arrays.toString(bys2));        System.out.println("-------");//      String str = new String(bys2, "utf-8") ;        String str = new String(bys2) ;        System.out.println("str:"+str);        System.out.println("------------------");        //public String(char[] value):将字符数组构造成一个字符串        //定义一个字符数组        char[] chs = {'我','爱','高','圆','圆'} ;        String s3 = new String(chs) ;        System.out.println("s3.length():"+s3.length());        System.out.println("s3:"+s3);        System.out.println("--------------------");        String s4 = new String(chs, 1, 4) ;        System.out.println("s4:"+s4);        System.out.println("s4.length():"+s4.length());        System.out.println("--------------------");        //public String(String original):通过字符串常量构造一个字符串对象        String s5 = new String("hello") ;        System.out.println("s5:"+s5);        System.out.println("s5.length():"+s5.length());        String s6 = "hello" ;        System.out.println("s6:"+s6);        System.out.println("s6.length():"+s6.length());    }}

2.String类的中常用的判断功能:

    boolean equals(Object obj):当前该对象是否obj这个对象是否相等;    boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写    boolean contains(String str):判断str这个字符串是否包含在当前字符串中    boolean startsWith(String str):是否以str子字符串开头    boolean endsWith(String str):判断是否以str子字符串结尾    boolean isEmpty():判断字符串是否为空    String s = ""    ;空字符    String s = " " ;字符串"空格"    String s = null ;当前字符串对象为空

public class StringDemo {    public static void main(String[] args) {        //定义一个字符串        String s1 = "helloworld" ;        String s2 = "HelloWorld" ;//      boolean equals(Object obj):当前该对象是否obj这个对象是否相等;String重写equals(),比较的是两个字符串的内容是否相同        System.out.println("equals:"+s1.equals(s2));        //boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写        System.out.println("equalsIgnoreCase:"+s1.equalsIgnoreCase(s2));        //boolean contains(String str):判断str这个字符串是否包含在当前字符串中        System.out.println("contains:"+s1.contains("owo"));        System.out.println("contains:"+s1.contains("ak47"));        //boolean startsWith(String str):是否以str子字符串开头        System.out.println("starsWith:"+s1.startsWith("hel"));        //boolean endsWith(String str):判断是否以str子字符串结尾  自己测试        //boolean isEmpty():判断字符串是否为空        System.out.println("isEmpty:"+s1.isEmpty());    }}

3.String类的获取功能:

    int length()        :获取字符串长度功能    char charAt(int index):返回的是索引处对应的字符    int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引            为什么这里的字符用int来定义:        97      'a'    int indexOf(String str):返回指定子字符串在此字符串中第一次出现的索引    int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。    int indexOf(String str,int fromIndex):返回在此字符串中第一次出现指定字符串处的索引，从指定的索引开始搜索    String substring(int start):从指定位置开始截取字符串,默认截取到末尾    String substring(int start,int end):从指定位置开始截取到指定位置结束,包前(start索引)不包后(end索引)

public class StringDemo {    public static void main(String[] args) {        //定义一个字符串:        String str = "helloworld" ;        //int length()  :获取字符串长度功能        System.out.println("length:"+str.length());        //char charAt(int index):返回的是索引处对应的字符        System.out.println("charAt:"+str.charAt(1));        System.out.println("charAt:"+str.charAt(8));        System.out.println("-------------------------------");        //int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引        System.out.println("indexof:"+str.indexOf('l'));        System.out.println("indexof:"+str.indexOf('k'));//-1        //int indexOf(String str):返回指定子字符串在此字符串中第一次出现的索引        System.out.println("indexOf:"+str.indexOf("owo"));        System.out.println("-------------------------------");        //int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。        System.out.println("indexOf:"+str.indexOf('l', 4));        //int indexOf(String str,int fromIndex):返回在此字符串中第一次出现指定字符串处的索引，从指定的索引开始搜索 (自己测试)        //String substring(int start):从指定位置开始截取字符串,默认截取到末尾(返回一个新的字符串,不再是字符串本身!)        System.out.println("substring:"+str.substring(5));        //String substring(int start,int end):从指定位置开始截取到指定位置结束,包前(start索引)不包后(end索引)        System.out.println("substring:"+str.substring(4, 8));//owor    }}

4.String类的转换功能(重点)

byte[] getBytes():将字符串转换字节数组char[] toCharArray():将字符串转换成 字符数组 (开发中经常使用)static String valueOf(char[] chs):将字符数组转换成字符串static String valueOf(int i):将一个int类型的数据转换成字符串

注意:String类中的valueOf()可以将任何数据类型转换成字符串

String toLowerCase():将字符串全部转成小写String toUpperCase():将字符串全部转换成大写String concat(String str):字符串拼接方法

public class StringDemo {    //构造方法:    //构造方法不能使用递归    /*public StringDemo(){        StringDemo();    }*/    public static void main(String[] args) {        //定义一个字符串        String s = "JavaSE" ;        //byte[] getBytes():将字符串转换字节数组        byte[] bys = s.getBytes() ;        //遍历字节数组        for(int x = 0 ; x < bys.length ; x++){            System.out.println(bys[x]);        }        System.out.println("---------------------");        //char[] toCharArray():将字符串转换成 字符数组        char[] chs = s.toCharArray() ;        for (int x = 0; x < chs.length; x++) {            System.out.println(chs[x]);        }        System.out.println("---------------------");        //static String valueOf(char[] chs):将字符数组转换成字符串        String s2 = String.valueOf(chs) ;        System.out.println("s2:"+s2);        //static String valueOf(int i):将一个int类型的数据转换成字符串        String s3 = String.valueOf(100) ;        System.out.println("s3:"+s3);        //String toLowerCase():将字符串全部转成小写        System.out.println("toLowerCase:"+s.toLowerCase());        //String toUpperCase():将字符串全部转换成大写        System.out.println("toUpperCase:"+s.toUpperCase());        //String concat(String str):字符串拼接方法        String s4 = "hello" ;        String s5 = "world" ;        System.out.println("contact:"+s4.concat(s5));        String s6 = "java" ;        s6 += "web" ;        System.out.println("s6:"+s6);        }

二.StringBuffer类

线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。 可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。 StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。 例如，如果 z 引用一个当前内容为 "start" 的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含 "startle"，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含 "starlet"。 通常，如果 sb 引用 StringBuilder 的一个实例，则 sb.append(x) 和 sb.insert(sb.length(), x) 具有相同的效果。 

面试题:

StringBuffer和String 的区别?StringBuffer会构造一个字符串缓冲区,从内存角度考虑,一般情况使用StringBuffer比较多(在单线程程序中使用StringBulider替代StringBuffer:线程不安全,单线程单纯为了提供执行效率!)String:普通的一个字符串,从内存角度考虑,耗费空间!

StringBuffer的构造方法(三种初始化方式):

public StringBuffer()说明：构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符public StringBuffer(int capacity)说明：构造一个不带字符，但具有指定初始容量的字符串缓冲区public StringBuffer(String str)说明：构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容；该字符串的初始容量为 16 加上字符串参数的长度。

常用的功能:

    public int length():获取字符串长度数    public int capacity():获取当前字符串缓冲区的容量

    public class StringBufferDemo {    public static void main(String[] args) {      /* public StringBuffer()       * 构造方法说明：构造一个其中不带字符的字符串缓冲区，其初始容量为 16个字符       * 创建一个字符串缓冲区对象：       * sb.length()：查看字符缓冲区字符长度       * sb.capacity():查看字符缓冲区容量(看出默认的容量)        */        StringBuffer sb = new StringBuffer() ;        System.out.println("sb.length:"+sb.length());           System.out.println("sb.capacity:"+sb.capacity());        System.out.println("----------------------------");        /*public StringBuffer(int capacity)         *构造方法说明：构造一个不带字符，但具有指定初始容量的字符串缓冲区         *          * */        StringBuffer sb2 = new StringBuffer(50) ;        System.out.println("sb2.length:"+sb2.length());        System.out.println("sb2.capacity:"+sb2.capacity());//50        System.out.println("----------------------------");        /* public StringBuffer(String str)         * 说明：构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容；         * 该字符串的初始容量为 16 加上字符串参数的长度         * */        StringBuffer sb3 = new StringBuffer("hello") ;        System.out.println("sb3.length:"+sb3.length());        System.out.println("sb3.capacity:"+sb3.capacity());//默认:初始容量16 + 当前字符串长度    }}

1.StringBuffer中的和添加有关的方法

public StringBuffer append(int/String/char/boolean/double/float....)  功能:当前这个方法追加,给缓冲中追加数据,返回字符串缓冲区本身(经常使用的)public StringBuffer insert(int offset,String str)  功能:在某一个位置处(索引)去插入str这个字符串,返回字符串缓冲区本身

public class StringBufferDemo2 {    public static void main(String[] args) {        //创建一个字符串缓冲区对象        StringBuffer sb = new StringBuffer() ;        //追加数据        sb.append("hello") ;        sb.append(true) ;        sb.append(13.45) ;        sb.append('A') ;        sb.append(12.56F);        System.out.println(sb);        /* 对append说明：         * 只是创建了一个对象(未开辟新的对象)，在原来对象的内容里添加新的内容         * 对print()说明：重写了Object类toString方法         * StringBuffer类中toString()方法         * 说明：将字符缓冲区转换成String类型         * */        //链式编程sb.append("hello").append(true).append(13.45).append('A').append(12.56F);        /*public StringBuffer insert(int offset,String str)         *说明:在某一个位置处去插入str这个字符串,返回字符串缓冲区本身         *内存情况(理解)         **/            sb.insert(5, "world") ;        System.out.println("sb:"+sb);    }}

2 . StringBuffer的删除功能:

    public StringBuffer deleteCharAt(int index)    说明:删除指定位置处的字符,返回的是字符串缓冲区本身!    public StringBuffer delete(int start,int end)    说明:删除从指定位置开始到指定位置结束的字符,返回的是字符串缓冲区本身!

public class StringBufferDemo3 {    public static void main(String[] args) {        //创建字符串缓冲区对象        StringBuffer sb = new StringBuffer() ;        //给缓冲区追加数据        sb.append("hello") ;        sb.append("world") ;        sb.append("java!!") ;        /*public StringBuffer deleteCharAt(int index)         *需求:要删除当前缓冲区中对应索引的字符         */        sb.deleteCharAt(14);        sb.deleteCharAt(14);        System.out.println("sb:"+sb);        /*public StringBuffer delete(int start,int end)         *从当前索引(star)开始,到(end-1)索引结束         */        sb.delete(5, 9);//删除制定位置字符        System.out.println("sb:"+sb);    }}

3.StringBuffer的反转功能(重点掌握):

public StringBuffer reverse()返回值类型：StringBuffer 功能:将此字符串中的字符序列直接反转

public class StringBufferDemo4 {    public static void main(String[] args) {        //创建键盘录入对象        Scanner sc = new Scanner(System.in) ;        //录入并接收数据        System.out.println("请您输入一个字符串:");        String line = sc.nextLine() ;        //可以创建字符串缓冲区对象        StringBuffer sb = new StringBuffer(line) ;        /*         * public String toString()         * 说明：StirngBuffer类型的toString()方法         * 将StringBuffer类型转换成String类型         */        String result = sb.reverse().toString() ;        System.out.println("result:"+result);    }}

5.StringBuffer的替换功能:

public StringBuffer replace(int start, int end,String str)功能：从指定位置开始到指定位置(包前不包后)结束的字符用str子字符串去替代返回值类型：StringBuffer

public class StringBufferDemo5 {    public static void main(String[] args) {        //创建字符串缓冲区对象        StringBuffer sb = new StringBuffer() ;        //给缓冲添加数据        sb.append("hello") ;        sb.append("world") ;        sb.append("java") ;        sb.replace(5, 10, "节日快乐") ;         System.out.println("sb:"+sb);    }}

6.StringBuffer的截取功能(得到字符串):

    public String substring(int start)  功能:从指定位置默认截取到末尾,返回值是一个新的字符串  返回值类型：String ******************************************    public String substring(int start,int end)  功能:从指定位置开始截取到指定位置结束,包前不包后,返回一个新的字符串  返回值类型：String

public class StringBufferDemo6 {    public static void main(String[] args) {        //创建字符串缓冲区对象        StringBuffer sb = new StringBuffer() ;        //添加        sb.append("hello") ;        sb.append("world") ;        sb.append("java") ;        //截取形成新的字符串(创建了一个新的对象)              String s1 = sb.substring(5) ;        System.out.println("s1:"+s1);        //此时字符串缓冲区内容(可以看到上述操作并未对缓冲区内容进行操作,原因？)        System.out.println("sb:"+sb);        //截取形成新的字符串(创建了一个新的对象)        String s2 = sb.substring(5,10) ;        System.out.println("s2:"+s2);        //此时字符串缓冲区内容(可以看到上述操作并未对缓冲区内容进行操作)        System.out.println("sb:"+sb);    }}

补充：

String,StringBuffer,StringBuilder的区别?
从可变性：
String:一个不可变的字符序列,
StringBuffer和StringBuilder是可变的字符序列,在单个线程时候的时候(优先采用StringBuilder)
从线程角度考虑:
StringBuilder线程不安全,不同步,执行效率高!它比StringBuffer要快!

String和StringBuffer作为形式参数

String类型作为形式参数和基本数据类型作为形式参数的效果一样!

public class StringBufferDemo7 {    public static void main(String[] args) {        //定义两个字符串        String s1 = "hello" ;        String s2 = "world" ;        System.out.println(s1+"---"+s2);        change(s1,s2);//自己定义方法        System.out.println(s1+"---"+s2);        System.out.println("---------------------");         //定义两个字符串缓冲区对象        StringBuffer sb1 = new StringBuffer("hello") ;        StringBuffer sb2 = new StringBuffer("world") ;        System.out.println(sb1+"---"+sb2);//hello---world        change(sb1,sb2);//调用方法        System.out.println(sb1+"---"+sb2);//hello---worldworld        //缓冲区是不变()    }    public static void change(StringBuffer sb1 ,StringBuffer sb2){        sb1 = sb2 ;  //缓冲区不变"world"        /**         * 形参其实是与实参指向同一个对象的不同引用(堆和方法(形参)区);         * 在方法区也有一个sb1和sb2，将对象(引用)分别辅给sb1,sb2；         * 此时将sb2指向sb1，此时理解为(方法区)这两个引用指向同一个对象("world");         * 此时再sb2.append(sb1);就是在sb2的缓冲区内继续添加内容，sb1不变         * 自己可以画个内存形式图：         * */        sb2.append(sb1) ;//worldworld    }    public static void change(String s1,String s2){        s1 = s2 ;        s2 = s1 + s2 ;    }}