String类、StringBuilder类、StringBuffer类的常用方法

//字符串类----String类
//字符串是一个常量，一经定义就不能修改（值、长度）
public class StringLei {
    //如何产生一个字符串
    public void a(){
        //创建一个字符串str1，指向abc
        String str1="abc";
        //创建一个空字符串
        String str2=new String();
        //根据字符数组创建一个字符串
        char[] chr={'a','b','c'};
        String str3=new String(chr);
        //根据字节数组创建一个字符串
        byte[] bytes={97,98,99};
        String str4=new String(bytes);
        //创建了一个字符串，这个字符串是按照abc的副本创建的
        String str5=new String("abc");//两个对象，一个abc，一个str5
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
        System.out.println(str4);
        System.out.println(str5);
    }

    //非常用构造器
    public void b(){
        char[] chars={97,98,99,100,101,102};
        byte[] bytes={97,98,99,100,101,102};
        String str1=new String(chars,2,3);//从数组下标2开始，取3个元素
        String str2=new String(bytes,1,4);
        System.out.println(str1);
        System.out.println(str2);
    }

    //字符串是常量   这个常量就是那个对象，也就是下面的str  这个对象的值是abc
    public void d(){
        String str="abc";
        System.out.println(str);
        str="bcd";
        System.out.println(str);
    }

    //第一组String的方法
    public void e(){//char charAt（int index）返回下标为index的字符
        String str="abcahdfdhd";
        char chr=str.charAt(4);//返回下标为4的字符数组中的元素值
        System.out.println(chr);//h
        /*str.concat("888888");
        System.out.println(str);//和str一样，没有变化，因为String为常量*/

        //String concat(String xxx)，拼接字符串，产生新的字符串，原字符串没变化
        //将指定字符串拼接到目标字符串后，产生了一个新的字符串
        String str1=str.concat("888888");
        System.out.println(str1);

        //boolean endsWith(String xxx) 判断目标字符串是否以指定字符串结尾的，返回boolean类型结果
        boolean b1=str.endsWith("shd.j");
        System.out.println(b1);
        //boolean equals(String xxx) 判断目标字符串和指定字符串值是否相等，返回boolean类型结果
        boolean b2=str.equals("aasdsds");
        //boolean equalsIgnoreCase(String xxx)判断目标字符串和指定字符串值是否相等，返回boolean类型结果,不区分大小写
        boolean b3=str.equalsIgnoreCase("aasdsds");

        //get bytes()
        //将字符串转换成byte数组
        byte[] bytes1=str.getBytes();
        //将字符串按照指定编码集转换成byte数组
        //byte [] bytes2=str.getBytes("utf-8");
        //返回字符串对象在内存中的HashCode
        int hashCode=str.hashCode();
        System.out.println(Arrays.toString(bytes1));
        System.out.println(hashCode);

    }

    //第二组String的方法
    public void  f(){
        String str="sytfusdfaef";
        //在目标字符串中找到字符'a'第一次出现的位置，如果不存在，返回-1
        int index1=str.indexOf('a');
        //从目标字符串中的第六个开始找到字符'a'第一次出现的位置，如果不存在，返回-1
        int index2=str.indexOf('a',5);
        //在目标字符串中找到字符串“ab”第一次出现的位置，如果不存在，返回-1
        int index3=str.indexOf("ab");
        //从目标字符串的第六个开始找到字符串“ab”第一次出现的位置，如果不存在，返回-1
        int index4=str.indexOf("ab",3);
        //找到目标字符串中指定的字符串或者字符串出现的最后一次位置，如果不存在，返回-1
        int index5=str.lastIndexOf('a');
        int index6=str.lastIndexOf('a',4);
        int index7=str.lastIndexOf("af");
        int index8=str.lastIndexOf("af",3);
        System.out.println(index1);
        System.out.println(index2);
        System.out.println(index3);
        System.out.println(index4);
        System.out.println(index5);
        System.out.println(index6);
        System.out.println(index7);
        System.out.println(index8);
    }
    //练习：用户输入邮箱号，判断邮箱是否是合法邮箱
    private Scanner in=new Scanner(System.in);
    public void  test1(){
        System.out.println("请输入邮箱号：");
        String email=in.next();
        int index1=email.indexOf("@");
        int index2=email.indexOf(".");
        if(index1>0&&index1<index2){
            System.out.println("合法邮箱");
        }
        else {
            System.out.println("请输入合法邮箱");
        }
    }

    //第三组String的方法
    public void g(){
        String str1="abc";
        String str2="abc";
        String str3=new String("abc");
        String str4=new String("abc");
        //String intern()  在字符串池中查找有没有，有的话直接得到，没有的话，先放进去，然后再得到
        //本例自始至终，常量池只有一个abc，放入abc时不是放副本
        String str11=str1.intern();
        String str21=str2.intern();
        String str31=str3.intern();
        String str41=str4.intern();
        System.out.println(str1==str2);
        System.out.println(str1==str3);
        System.out.println(str3==str4);
        System.out.println(str11==str21);
        System.out.println(str11==str31);
        System.out.println(str31==str41);
        System.out.println("-----------------");
        System.out.println(str11=="abc".intern());
        System.out.println(str11=="abc");
    }

    //第四组String的方法
    public void h(){
        String str ="asdfhuashdfasd";
        //判断字符串是否为空，等同于判断字符串长度为0
        boolean b1=str.isEmpty();
        //返回字符串的长度个数
        int len = str.length();
        //返回目标字符串去掉前后空格后的形式
        String str1=str.trim();
        //返回目标字符串的全大写和全小写形式
        String str2 = str.toUpperCase();
        String str3 = str.toLowerCase();
        //将目标字符串中的f替换成8，生成一个新字符串
        String str4 = str.replace("f","8");
        System.out.println(b1);
        System.out.println(len);
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
        System.out.println(str4);
    }

    //第五组String的方法
    public void i(){
        String str = "sfd%fuh%dfjk";
        //将目标字符串按照%分隔成一个字符串数组
        String[] arr1 = str.split("%");
        //将目标字符串转换成一个字符数组
        char[] arr2 = str.toCharArray();
        //从目标字符串的第六个开始截取，产生一个新的字符串
        String str1 = str.substring(5);
        //从目标字符串的第四个开始，截取到第七个结束，产生一个新的字符串，从1开始计数，左闭右开
        String str2 = str.substring(3,7);
        System.out.println(Arrays.toString(arr1));
        System.out.println(arr2);
        System.out.println(str1);
        System.out.println(str2);
    }


    public static void main(String[] args){
        new StringLei().i();
        /*new StringLei().a();
        new StringLei().b();
        new StringLei().e();
        String str1="abc";
        String str2="abc";
        String str3=new String("abc");
        String str4="ABC";
        System.out.println(str1==str2);//true
        System.out.println(str3==str1);//false
        System.out.println(str1==str4);//false*/
    }
}

package xzy0629;
//字符串----StringBuilder：一个线程不安全可变长度的字符序列，但不保证同步
public class StringBuilderLei {
    // 如何产生一个StringBuilder
    public void a(){
        // 空的字符序列
        StringBuilder str1 = new StringBuilder();
        // 值为abc的字符串
        StringBuilder str2 = new StringBuilder("abc");
        System.out.println(str1);
        System.out.println(str2);
    }
    // StringBuilder的常用方法
    public void b(){
        StringBuilder str = new StringBuilder("sgfsjdgff");
        str.append("aa");// 将aa字符串追加到目标字符串的结尾
        //str.insert(3,"yy");// 将yy字符串插入到目标字符串的指定位置
        //str.delete(3,6);// 删除目标字符串中第四个到第六个的内容,左闭右开
        str.reverse(); //反转目标字符串
        System.out.println(str);
        String str1 = str.toString();//将StringBuilder--->String
    }
    public static void main(String[] args) {
        new StringBuilderLei().b();

        String str1 = "";
        String str2 = null;
        String str3;
        String str4 = new String();
        String str5 = " ";
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
        System.out.println(str4);
    }

/*StringBuffer---线程安全的可变字符串
StringBuilder有的StringBuffer都有，它线程安全是因为它加了一把同步锁
当一个人对字符串操作时，它不会被其他人操作
*/