字符串

定义

字符串：由若干个字符构成的字符序列，每一个字符位置是固定的
在java中，提供了一个类来表示字符串：String
Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例【对象】。
因为String对象是不可变的，它们可以被共享。

思考

思考：
    1、同一个内容的字符串，为什么地址值也是一样的？ 因为都指向常量池中的同一个字符串地址值。
    2、String对象是不可变的，我们却可以修改字符串变量的值？ 字符串不可变指的是常量池中的字符串本身不能改变。
    3、为什么直接打印字符串对象名，获取的是字符串内容值，而不是地址值？String类中重写了toString()方法

例子

public class StringDemo1 {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "abc";

//        System.out.println(s1==s2);
        s1 = "hello";
        System.out.println(s1);
        System.out.println(s2);
    }
}

String

String介绍

1.概述:String 类代表字符串
2.特点:
  a.Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例(对象)实现
    凡是带双引号的,都是String的对象
    String s = "abc"
    "abc"就是对象;String就是对象的数据类型;s就是对象名
        
  b.字符串是常量,它们的值在创建之后不能更改
    String s = "hello"
    s+="world" -> 会产生新对象
        
  c.String 对象是不可变的，所以可以共享
    String s1 = "abc"
    String s2 = "abc"

String类中的构造方法：

String类中的构造方法：
        public String()
        public String(byte[] bytes)
        public String(byte[] bytes,int offset,int length)
        public String(char[] value)
        public String(char[] value,int offset,int count)
        public String(String original)

例子

public class StringDemo2 {
    public static void main(String[] args) {
        //public String()
        String s1 = new String();
        System.out.println("s1: "+s1);
        System.out.println("-----------------------");
        //public String(byte[] bytes)  将字节数组转成一个字符串
        byte[] bytes = {97,65,48,98,99};
        String s2 = new String(bytes);
        System.out.println("s2: "+s2);
        System.out.println("-----------------------");
        //public String(byte[] bytes,int index,int length)  截取字节数组一部分转成字符串
        String s3 = new String(bytes, 1, 3);
        System.out.println("s3: "+s3);
        System.out.println("-----------------------");
        //public String(char[] value) 将字符数组转成一个字符串
        char[] chars = {'我','爱','刘','亦','菲'};
        String s4 = new String(chars);
        System.out.println("s4: "+s4);
        System.out.println("-----------------------");
        //public String(char[] value,int offset,int count) 截取字符数组一部分转成字符串
        String s5 = new String(chars,2,3);
        System.out.println("s5: "+s5);
        System.out.println("-----------------------");
        //public String(String original)
        String s6 = new String("hello");
        System.out.println("s6: "+s6);
        System.out.println("-----------------------");
        String s = new String("hello");
        String s7 = "hello";
        System.out.println(s==s7);

    }
}

String类中的获取功能：

        int length()     -> 获取字符串长度
        char charAt(int index)   -> 根据索引获取对应的字符
        int indexOf(int ch)-> 获取指定字符串在大字符串中第一次出现的索引位置
        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)-> 截取字符串,从beginIndex开始到endIndex结束
            含头不含尾,返回新串儿

例子：

public class StringDemo4 {
    public static void main(String[] args) {
        String s1 = "hello";

        //int length() 获取字符串中的字符个数
        System.out.println(s1.length());

        //char charAt(int index) 根据索引获取对应位置上的字符
        System.out.println(s1.charAt(1));
//        System.out.println(s1.charAt(9));

        //int indexOf(int ch) 根据字符对应ASCII码数值获取对应字符的位置索引
        System.out.println(s1.indexOf(101));

        //int indexOf(String str) 获取大字符串中小字符串的第一个字符的位置,r若不包含返回-1
        String bigStr = "dwqsredhelloqjion";
        String smallStr = "world";
        System.out.println(bigStr.indexOf(smallStr));

        //int indexOf(int ch,int fromIndex) 从指定索引开始查找对应的字符
        String s2= "dwqrewqrffqewrfdwqqrfwqfwq";
        System.out.println(s2.indexOf(101,5));

        //int indexOf(String str,int fromIndex) 从指定索引开始查找对应的字符串
        //TODO:自己实验

        //String substring(int start) 从指定索引开始截取字符串到某尾
        String s3 = "数加科技欢迎大家的到来";
        String s4 = s3.substring(4);
        System.out.println("s3: "+s3);
        System.out.println("s4: "+s4);

        //String substring(int start,int end) 指定开始索引和结束索引截取字符串的一部分
        String s5 = s3.substring(4, 8);
        System.out.println("s5: "+s5);


    }
}

练习

遍历字符串

public class Demo05String {
    public static void main(String[] args) {
        String s = "abcdefg";
        for (int i = 0; i < s.length(); i++) {
            System.out.println(s.charAt(i));
        }
    }
}

String类中的转换功能：

        byte[] getBytes()-> 将字符串转成byte数组
        char[] toCharArray()-> 将字符串转成char数组
        static String valueOf(char[] chs)
        static String valueOf(int i)
        String toLowerCase()
        String toUpperCase()
        String concat(String str)

例子

public class StringDemo5 {
    public static void main(String[] args) {
        String s1 = "数加";

        // byte[] getBytes() 将字符串转成字节数组的形式【受编码的影响】
        byte[] bytes = s1.getBytes();
        printIntArray(bytes);

        // char[] toCharArray()
        char[] chars = s1.toCharArray(); // 将字符串转成字符数组的形式
        printIntArray(chars);

        //static String valueOf(char[] chs) // 将字符数组转字符串
        String s2 = String.valueOf(chars);
        System.out.println(s2);

        //static String valueOf(int i) // 将数值转成字符串
        String s3 = String.valueOf(10);
        System.out.println(s3); // "10"

        //String toLowerCase() 将字符串转小写
        String s4 = "HellO";
        String s5 = s4.toLowerCase();
        System.out.println(s5);

        //String toUpperCase() 将字符串转大写
        String s6 = s5.toUpperCase();
        System.out.println(s6);

        // String concat(String str) 字符串拼接
        String s7 = "shujia";
        String s8 = "keji";
        System.out.println(s7+s8);
        System.out.println(s7.concat(s8));


    }
    public static void printIntArray(char[] array) {
        for (int i = 0; i < array.length; i++) {
            if (i == 0) {
                System.out.print("[" + array[i] + ",");
            } else if (i == array.length - 1) {
                System.out.println(array[i] + "]");
            } else {
                System.out.print(array[i] + ",");
            }
        }
    }


    public static void printIntArray(byte[] array) {
        for (int i = 0; i < array.length; i++) {
            if (i == 0) {
                System.out.print("[" + array[i] + ",");
            } else if (i == array.length - 1) {
                System.out.println(array[i] + "]");
            } else {
                System.out.print(array[i] + ",");
            }
        }
    }
}

String类中的替换功能

 String replace(char old,char new)
        String replace(String old,String new)
     去除字符串两空格
        String trim()
    按字典顺序比较两个字符串【重要！！】
        int compareTo(String str) 按照字符串中的字符从左向右依次比较=，如果长度和内容都一样，返回0
        int compareToIgnoreCase(String str)

例子

public class StringDemo6 {
    public static void main(String[] args) {
        String s1 = "今天是20205年1月4日，hello今年是蛇年hellodsaqwwdq";
        //String replace(char old,char new) 使用新字符替换所有的旧字符
        String s2 = s1.replace('h', '_');
        System.out.println("s1: "+s1);
        System.out.println("s2: "+s2);

        System.out.println("--------------------");
        //String replace(String old,String new) 使用新的字符串替换旧字符串
        String s3 = s1.replace("hello", "flinkspark");
        System.out.println("s1: "+s1);
        System.out.println("s3: "+s3);

        System.out.println("--------------------");
        String s4 = "    hello world    ";
        System.out.println(s4.trim());
        System.out.println("--------------------");

        String s5 = "hello";
        String s6 = "world";
        String s7 = "hel";
        System.out.println(s5.compareTo(s6)); // -15
        System.out.println(s5.compareTo(s7)); // 2

        // "hello","apple","world","flink","hadoop"


    }
}


/*
    String类中的compareTo源码解释：
            //s5.compareTo(s6)
            public int compareTo(String anotherString) {
                int len1 = value.length; // 5
                int len2 = anotherString.value.length; // 3
                int lim = Math.min(len1, len2); // 3
                char[] v1 = value; // ['h','e','l','l','o']
                char[] v2 = anotherString.value; // ['h','e','l']
                int k = 0;

                while (k < lim) {
                    char c1 = v1[k]; // 'h'  'e'  'l'
                    char c2 = v2[k]; // 'h'  'e'  'l'
                    if (c1 != c2) {
                        return c1 - c2; // 104 - 119 = -15
                    }
                    k++;
                }
                return len1 - len2; // 2
            }
 

String练习

 把数组中的数据按照指定个格式拼接成一个字符串
    举例：int[] arr = {1,2,3};	输出结果：[1, 2, 3]

public class StringTest3 {
    public static void main(String[] args) {
        int[] arr = {1,354,56,2,125,12};
//        arr = null;
        System.out.println(arrToStr(arr));
    }

    public static String arrToStr(int[] array) {
        if(array==null){
            return null;
        }

        String res = "[";
        for (int i = 0; i < array.length; i++) {
            if (i == array.length - 1) {
                res = res + array[i] + "]";
                break;
            }
            res = res + array[i] + ",";
        }
        return res;
    }
}

 字符串反转
    举例：键盘录入”abc”		输出结果：”cba”

    方式1：将字符串转字符数组，数组逆序，再转成字符串
    方式2：将字符串转字符数组，倒着遍历，拼接成一个字符串
    方式3：先将字符串转StringBuffer,调用StringBuffer中的反转方法，再转成字符串

public class StringTest4 {
    public static void main(String[] args) {
        String s1 = "我爱莫提冯";
//        System.out.println(fun1(s1));

//        System.out.println(fun2(s1));
        System.out.println(fun3(s1));

    }

    public static String fun3(String s){
        // String -> StringBuffer
        StringBuffer sb = new StringBuffer(s);
        sb.reverse();
        // StringBuffer -> String
        return sb.toString();
    }

    public static String fun2(String s) {
        char[] chars = s.toCharArray();
        String res = "";
        for (int i = chars.length - 1; i >= 0; i--) {
            res+=chars[i];
        }

        return res;
    }

    public static String fun1(String s) {
        char[] chars = s.toCharArray();
        nuXu(chars);
        return new String(chars);
    }

    public static void nuXu(char[] chars) {
        for (int front = 0, end = chars.length - 1; front < end; front++, end--) {
            char tmp = chars[front];
            chars[front] = chars[end];
            chars[end] = tmp;
        }
    }
}

StringBuilder类

StringBuffer:
        线程安全，可变的字符序列。 字符串缓冲区就像一个String ，但可以修改。
        在任何时间点，它包含一些特定的字符序列，但可以通过某些方法调用来更改序列的长度和内容。
作用:主要是字符串拼接
    StringBuilder的特点:
  a.底层自带缓冲区,此缓冲区是没有被final修饰的byte数组,默认长度为16
  b.如果超出了数组长度,数组会自动扩容
    创建一个新长度的新数组,将老数组的元素复制到新数组中,然后将新数组的地址值重新赋值给老数组
  c.默认每次扩容老数组的2倍+2
    如果一次性添加的数据超出了默认的扩容数组长度(2倍+2),比如存了36个字符,超出了第一次扩容的34,就按照实际数据个数为准,就是以36扩容
    构造方法：
        public StringBuffer()
        public StringBuffer(int capacity)
        public StringBuffer(String str)

public class StringBufferDemo1 {
    public static void main(String[] args) {
        StringBuffer sb1 = new StringBuffer();
        System.out.println("sb1: " + sb1);

        // 获取StringBuffer容量大小
        System.out.println(sb1.capacity());
        // 获取实际的字符个数
        System.out.println(sb1.length());

        System.out.println("----------------");
        //public StringBuffer(int capacity) 指定容量大小
        StringBuffer sb2 = new StringBuffer(100);
        // 获取StringBuffer容量大小
        System.out.println(sb2.capacity());
        // 获取实际的字符个数
        System.out.println(sb2.length());
        System.out.println("----------------");
        //public StringBuffer(String str)  创建StringBuffer对象的时候，放入一个初始字符串
        StringBuffer sb3 = new StringBuffer("hello");
        System.out.println(sb3.capacity()); // 21
        // 获取实际的字符个数
        System.out.println(sb3.length());
        System.out.println("----------------");

    }
}

StringBuilder的使用功能

 添加功能
        public StringBuffer append(String str)
        public StringBuffer insert(int offset,String str)
    删除功能
        public StringBuffer deleteCharAt(int index)
        public StringBuffer delete(int start,int end)
    替换功能
        public StringBuffer replace(int start,int end,String str)
    反转功能
        public StringBuffer reverse()
    截取功能
        public String substring(int start)
        public String substring(int start,int end)

例子：

public class StringBufferDemo2 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();

        //public StringBuffer append(String str) 末尾处追加
        sb.append(10);
        sb.append(12.34);
        sb.append(true);
        sb.append("hello");
        sb.append('w');
        System.out.println("sb: "+sb);

        //1012.34truehellow
        //public StringBuffer insert(int offset,String str) 指定索引插入元素
        sb.insert(5,"java");
        System.out.println("sb: "+sb);

        //1012.java34truehellow
        //public StringBuffer deleteCharAt(int index) 根据索引删除元素
        sb.deleteCharAt(7);
        System.out.println("sb: "+sb);

        //1012.jaa34truehellow
        //public StringBuffer delete(int start,int end) 指定开始和结束索引删除一部分字符
        sb.delete(7,11);
        System.out.println("sb: "+sb);

        //1012.jaruehellow
        //public StringBuffer replace(int start,int end,String str)  替换StringBuffer一部分字符序列
        sb.replace(7,10,"flink");
        System.out.println("sb: "+sb);

        //public StringBuffer reverse() 将StringBuffer中的字符序列反转
        StringBuffer sb2 = new StringBuffer("hello");
        sb2.reverse();
        System.out.println("sb2: "+sb2);


        //public String substring(int start)
        StringBuffer sb3 = new StringBuffer("世界很大，我想去看看！");
        String s1 = sb3.substring(5);
        System.out.println("sb3: "+sb3);
        System.out.println("s1: "+s1);

        String s2 = sb3.substring(5,8);
        System.out.println("sb3: "+sb3);
        System.out.println("s1: "+s2);

    }
}

StringBuffer作为参数传递

public class StringBufferDemo4 {
    public static void main(String[] args) {
        StringBuffer sb1 = new StringBuffer("hello");
        StringBuffer sb2 = new StringBuffer("world");
        System.out.println("sb1: "+sb1+", sb2: "+sb2);// sb1: hello,sb2: world
        change(sb1,sb2);
        System.out.println("sb1: "+sb1+", sb2: "+sb2);// sb1: hello,sb2: worldworld
    }

    public static void change(StringBuffer sb1,StringBuffer sb2){
        System.out.println("sb1: "+sb1+", sb2: "+sb2);// sb1: hello,sb2: world
        sb1 = sb2;
        sb2.append(sb1);
        System.out.println("sb1: "+sb1+", sb2: "+sb2);// sb1: worldworld,sb2: worldworld
    }
}