StringBuffer：
        概述：线程安全的可变字符序列。
        补充：String是一个不可变的字符序列。
        记忆：
                线程安全，效率就低，线程不安全，效率就高。

        构造方法：
                StringBuffer();  //用到的比较多，理论长度是：16
                StringBuffer(int capacity);
                StringBuffer(String str);

        成员方法：
                public int capacity(); 理论值，初始容量。   //一般不用
                public int length();   实际值，实际的字符个数。


          添加：
                        public StringBuffer append(String str);   可以把任意类型的数据添加到缓冲区中，并且返回缓冲区本身
                        public StringBuffer insert(int index,String str);

                注意：
                        StringBuffer是一个字符串缓冲区，当new的时候才回去堆中创建一个对象，其实底层它是一个长度为16的字符数组。当调用添加方法的时候，不会再创建StringBuffer对象，而是直接往缓冲区添加。

                应用示例：
                        StringBuffer  sb = new StringBuffer();
                        sb.append(132);
                        sb.append("zs");
                        sb.append(true);
          删除：
                public StringBuffer deleteCharAt(int index);   删除指定位置的元素，并返回缓冲区本身。
                public StringBuffer delete(int strat,int end);  包左不包右。

          替换和反转：
                public StringBuffer replace(int start,int end,String str); 把start到end之间的数据（包左不包右），用str来替换。

                public StringBuffer reverse();  反转。

          截取：
                public String substring(int start);   //从指定位置截取到末尾
                public String substring(int start,int end);   //截取指定区间的数据，包左不包右。
                注意：这两个方法返回的不在是StringBuffer本身了。

                练习：
                        1、创建一个StringBuffer对象，
                        2、往里边添加数据，分别添加：wo，ai，heima这三个元素。
                        3、然后从中截取出 hei 这个字符。


        String和StringBuffer的相互转换：
                String  ---》  StringBuffer
                        1、构造方法。       //比较常用
                        2、append()方法。
                StringBuffer --》 String
                        1、构造方法。
                        2、toString();   //比较常用。
                        3、substring();  //不常用


                练习：
                        已知数组：int[] arr = {1,2,3};
                        把数组转成如下格式：“[1, 2, 3]”，StringBuffer

                        做完的同学，思考：
                                键盘录入一个数据，然后反转输出，怎么实现？
                                示例：
                                        输入： abc   打印结果为： cba


数组高级：
        冒泡排序：
                数组：int[] arr = {24,69,80,57,13};
                自己写代码实现：最后打印的结果是：  13,24,57,69,80
                原理：相邻元素两两比较，大的往后走，第一次循环结束后，最大值就在最后（最大索引处）。
                        原值：24,69,80,57,13
                        第一：24,69,57,13,80     比较了：4次
                        第二：24,57,13,69,80     比较了：3次
                        第三：24,13,57,69,80         比较了：2次
                        第四：13,24,57,69,80     比较了：1

                方法名：bubbleSort
                        for(int i = 0; i<arr.length-1 ; i++ ){   //总共要比较的次数
                                //内循环控制每次比较需要比较的次数
                                for(int j=0; j<arr.length-1-i; j++){ // -1是为了防止索引越界，-i是提高效率
                                        //相邻元素两两比较，大的往后走
                                        if(arr[j] > arr[j+1]){    //arr[j]=80   arr[j+1]=57
                                                int temp = arr[j];
                                                arr[j] = arr[j+1];
                                                arr[j+1] = temp;
                                        }
                               
                                }

                        }


        选择排序：
                数组：int[] arr = {24,69,80,57,13};
                自己写代码实现：最后打印的结果是：  13,24,57,69,80
                原理：从最小索引处开始，那一个索引上的元素，依次与其他索引位置的元素比较，小的在前，大的在后。

        二分（折半）查找：
                前提条件：数组必须是有序的。

                无序数组可以使用二分查找吗？  不可以，原因是因为二分查找的前提条件是数组必须是有序的，即使你对无序数组进行排序，那么也很有可能，元素的位置发生改变。
                8   9  12  10  5    排序后：5  8  9  10 12   60

        Arrays：数组工具类
                public static String toString(int[] arr);
                public static void sort(int[] arr);
                public static int binarySearch(int[] arr,int key);   如果没找到，返回：-插入点-1

基本类型对应的包装类？

        为什么要有基本类型的包装类？
                大白话，把基本类型包装起来，包装成对象，那么它就可以来调用方法了。
        常用操作：
                在包装类和String之间做转换。（开发中常用的是：Integer类型和String类型之间的转换）

        Integer类：
                构造方法：
                        Integer(int i);
                        Integer(String str);
               
                String和int类型之间的相互转换：
                        String ---》 int
                                public static int parseInt(String s);
                                总结：
                                        基本类型的包装类有8种，其中7种都有parseXxx的方法（Character类除外），可以把这7种数据的字符串形式转成其基本类型。
                        int --->>> String
                                1、和""拼接。
                                2、public static String toString(int a);

                JDK1.5以后的新特性：
                        自动装箱：把基本类型转成其对应的包装类。
                        自动拆箱：把包装类转成其对应的基本类型。
                        注意：使用Integer i = null; 来调用方法或者进行自动拆箱的时候，会报一个异常：NullPointerException。

                Integer i1 = 127;
                Integer i2 = 127;
                System.out.println(i1==i2); 问：结果是什么？为什么？
                        答：true，-128~127之间的数据是byte的取值范围，如果在这个范围内做自动装箱，不会重新创建对象，而是去常量池（byte常量池）中找，超过这个范围，做自动装箱，会重新创建对象。

StringBuffer：
        概述：线程安全的可变字符序列。
        补充：String是一个不可变的字符序列。
        记忆：
                线程安全，效率就低，线程不安全，效率就高。

        构造方法：
                StringBuffer();  //用到的比较多，理论长度是：16
                StringBuffer(int capacity);
                StringBuffer(String str);

        成员方法：
                public int capacity(); 理论值，初始容量。   //一般不用
                public int length();   实际值，实际的字符个数。


          添加：
                        public StringBuffer append(String str);   可以把任意类型的数据添加到缓冲区中，并且返回缓冲区本身
                        public StringBuffer insert(int index,String str);

                注意：
                        StringBuffer是一个字符串缓冲区，当new的时候才回去堆中创建一个对象，其实底层它是一个长度为16的字符数组。当调用添加方法的时候，不会再创建StringBuffer对象，而是直接往缓冲区添加。

                应用示例：
                        StringBuffer  sb = new StringBuffer();
                        sb.append(132);
                        sb.append("zs");
                        sb.append(true);
          删除：
                public StringBuffer deleteCharAt(int index);   删除指定位置的元素，并返回缓冲区本身。
                public StringBuffer delete(int strat,int end);  包左不包右。

          替换和反转：
                public StringBuffer replace(int start,int end,String str); 把start到end之间的数据（包左不包右），用str来替换。

                public StringBuffer reverse();  反转。

          截取：
                public String substring(int start);   //从指定位置截取到末尾
                public String substring(int start,int end);   //截取指定区间的数据，包左不包右。
                注意：这两个方法返回的不在是StringBuffer本身了。

                练习：
                        1、创建一个StringBuffer对象，
                        2、往里边添加数据，分别添加：wo，ai，heima这三个元素。
                        3、然后从中截取出 hei 这个字符。


        String和StringBuffer的相互转换：
                String  ---》  StringBuffer
                        1、构造方法。       //比较常用
                        2、append()方法。
                StringBuffer --》 String
                        1、构造方法。
                        2、toString();   //比较常用。
                        3、substring();  //不常用


                练习：
                        已知数组：int[] arr = {1,2,3};
                        把数组转成如下格式：“[1, 2, 3]”，StringBuffer

                        做完的同学，思考：
                                键盘录入一个数据，然后反转输出，怎么实现？
                                示例：
                                        输入： abc   打印结果为： cba


数组高级：
        冒泡排序：
                数组：int[] arr = {24,69,80,57,13};
                自己写代码实现：最后打印的结果是：  13,24,57,69,80
                原理：相邻元素两两比较，大的往后走，第一次循环结束后，最大值就在最后（最大索引处）。
                        原值：24,69,80,57,13
                        第一：24,69,57,13,80     比较了：4次
                        第二：24,57,13,69,80     比较了：3次
                        第三：24,13,57,69,80         比较了：2次
                        第四：13,24,57,69,80     比较了：1

                方法名：bubbleSort
                        for(int i = 0; i<arr.length-1 ; i++ ){   //总共要比较的次数
                                //内循环控制每次比较需要比较的次数
                                for(int j=0; j<arr.length-1-i; j++){ // -1是为了防止索引越界，-i是提高效率
                                        //相邻元素两两比较，大的往后走
                                        if(arr[j] > arr[j+1]){    //arr[j]=80   arr[j+1]=57
                                                int temp = arr[j];
                                                arr[j] = arr[j+1];
                                                arr[j+1] = temp;
                                        }
                               
                                }

                        }


        选择排序：
                数组：int[] arr = {24,69,80,57,13};
                自己写代码实现：最后打印的结果是：  13,24,57,69,80
                原理：从最小索引处开始，那一个索引上的元素，依次与其他索引位置的元素比较，小的在前，大的在后。

        二分（折半）查找：
                前提条件：数组必须是有序的。

                无序数组可以使用二分查找吗？  不可以，原因是因为二分查找的前提条件是数组必须是有序的，即使你对无序数组进行排序，那么也很有可能，元素的位置发生改变。
                8   9  12  10  5    排序后：5  8  9  10 12   60

        Arrays：数组工具类
                public static String toString(int[] arr);
                public static void sort(int[] arr);
                public static int binarySearch(int[] arr,int key);   如果没找到，返回：-插入点-1

基本类型对应的包装类？

        为什么要有基本类型的包装类？
                大白话，把基本类型包装起来，包装成对象，那么它就可以来调用方法了。
        常用操作：
                在包装类和String之间做转换。（开发中常用的是：Integer类型和String类型之间的转换）

        Integer类：
                构造方法：
                        Integer(int i);
                        Integer(String str);
               
                String和int类型之间的相互转换：
                        String ---》 int
                                public static int parseInt(String s);
                                总结：
                                        基本类型的包装类有8种，其中7种都有parseXxx的方法（Character类除外），可以把这7种数据的字符串形式转成其基本类型。
                        int --->>> String
                                1、和""拼接。
                                2、public static String toString(int a);

                JDK1.5以后的新特性：
                        自动装箱：把基本类型转成其对应的包装类。
                        自动拆箱：把包装类转成其对应的基本类型。
                        注意：使用Integer i = null; 来调用方法或者进行自动拆箱的时候，会报一个异常：NullPointerException。

                Integer i1 = 127;
                Integer i2 = 127;
                System.out.println(i1==i2); 问：结果是什么？为什么？
                        答：true，-128~127之间的数据是byte的取值范围，如果在这个范围内做自动装箱，不会重新创建对象，而是去常量池（byte常量池）中找，超过这个范围，做自动装箱，会重新创建对象。