Java_String对象的特点等

问：String类占多少字节？

输入接收char类型的方法：

 Scanner in = new Scanner(System.in);
        char line = in.next().charAt(0);

特点1：

  char[] s1= {'1','2','3','4','5'};
        String s2 = new String(s1);
        String s3 = new String(s1);
                System.out.println(s3==s2);
//        输出：fault

        String s4="12345";
        String s5="12345";
                System.out.println(s4==s5);
//        输出：true

//        java中，“”内，只要字符序列大小写相同，代码中无论出现几次，都只会
        建立一个String对象，并在字符串池中维护

字符串比较：

        使用==做比较：

                                基本类型：比较的是数据值是否相同

                                引用类型：比较的是地址值是否相同

        字符串比较：  

                                 字符串比较通过equal（）来实现      

                       

     System.out.println(s1.equal(s2));
     System.out.println(s1.equal(s2));
     System.out.println(s1.equal(s2));
//输出：ture

字符串遍历：

                   获取长度：名.length()

                   表示元素：名.charAt（i）

                  

public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String line = in.nextLine();
        for (int i = 0; i < line.length(); i++) {

            System.out.print(line.charAt(i)+" ");

        }
    }

//输入：123
//输出：1 2 3

反转：

   return new StringBuilder(arr).reverse().toString();

截取：

String substring ( int beginindex, int endindex)   截取

//注意，包头不包尾，包左不包右

String substring ( int beginindex)   截取到末尾

字符串连接：

  拼接1（low） ：    

  （以下每次拼接都会创造一个新的String对象，耗时，浪费内存，很low）

    public static void main(String[] args) {
        char[] arr={'a','p','p'};
        String arr1= new String(arr);
        System.out.println(arr1);
        String arr2= "le";
        System.out.println(arr2);

        for (int i = 0; i < arr2.length(); i++) {
            arr1+=arr2.charAt(i);
        }
        System.out.println(arr1);
    }

//输出：apple

可变字符串对象StringBuilder：

  public static void main(String[] args) {
        //创立一个空白可变字符串对象，不含有任何内容
        StringBuilder sb = new StringBuilder();

            System.out.println("sb:"+sb);
            System.out.println("sb.length():"+sb.length());
            //输出：sb:
            //     sb.length():0

        StringBuilder sb2 = new StringBuilder("hello");
            System.out.println("sb2:"+sb2);
            System.out.println("sb2.length():"+sb2.length());
            //输出：sb2:hello
            //     sb2.length():5
    }

apend添加 和 reverse反转： 

          //public StringBuilder append（任意类型），添加数据，并返回对象本身
          //public StringBuilder reverse（），返回相反的字符序列

        StringBuilder sbb = new StringBuilder();
        sbb.append("hello");//直接添加
        sbb.append(" world");
                //等同于（链式编程）： sbb.append("hello").append(" world");
            System.out.println(sbb);

        sbb.reverse();//反转
            System.out.println(sbb);

String 和 StringBuilder相互转换：

  （String要添加时，先把String转成StringBuilder，添加完，再把StringBuilder转成String）

 //相互转换
        //String 转 StringBuilder :
        String sb3 = "apple";
        StringBuilder sb4 = new StringBuilder(sb3);
        System.out.println(sb4);

        //StringBuilder 转 String:
        String s = sb4.toString();
        System.out.println(s);

拼接2（high）：

    public static void main(String[] args) {
        int[] arr = {1,2,3};
        String sb = lianjie(arr);
        System.out.println(sb);
    }
    public static String lianjie(int[] arr){
        StringBuilder sb = new StringBuilder();
            sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if(i==arr.length-1)
                    sb.append(arr[i]);
            else
                sb.append(arr[i]).append(",");
        }
            sb.append("]");
        String s = sb.toString();
        return s;
    }

StringJoiner可变字符串（指定间隔、开始、结束符号）：

        public  StringJoiner(间隔符号)

        public  StringJoiner(间隔符号， 开始符号，结束符号)‘

成员方法：

拼接底层原理（jdk7），略：

一个加号，堆中存俩对象，效率不高

后