Day13 --StringBuffer 字符串反转 冒泡排序二分查找 Arrays类 Integer类 JDK5新特性自动拆装箱

 a.
    StringBuffer类
        概述
            * 通过API查询StringBuffer类的说明；
            * 是线程安全，[执行效率低，速度慢]的可变字符序列。
                * 注意：
                    * 线程安全？ 
                        * 例如：厕所有门，有门就要去关，所以安全，但是呢关起来很慢，所以说执行效率低，速度慢，整体执行效率低。
                    * 线程不安全？
                        * 例如：厕所没有门，没有门，就不安全，但很快方便做事，所以说执行效率高，速度快，整体执行顺序要快。
            
        String和StringBuffer的区别
            * String是一个可变的字符串序列，通过+号进行字符串连接从而形成一个新的字符串对象，操作的是不同的对象。  
            * StringBuffer是一个不可变的字符串序列，通过一些方法来改变字符串的长度和内容，操作的是同一个对象。
                * 注意：StringBuffer是字符串缓冲区， 当new的时候，会在堆内存中创建一个对象，底层是一个长度为16的字符数组。 不会重复的创建新的对象，而是在原字符串缓冲区中添加元素。所以说StringBuffer操作的都是一个对象。

b.
    StringBuffer的构造方法
        * public StringBuffer(); 构造一个不带字符的字符串缓冲区，初始容量为16个字符
        * public StringBuffer(CharSequence seq); 构造一个字符串缓冲区，它包含与指定的 CharSequence 相同的字符。  
        * public StringBuffer(int capacity); 构造一个不带字符，但具有指定初始容量16的字符串缓冲区。
        * public StringBuffer(String str); 构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。
            
    StringBuffer的方法
        * public int length();    返回字符的个数，实际值
        * public int capacity()； 返回当前容器默认初始化值16， 理论值


c.
    StringBuffer的添加功能
        * public StringBuffer append(String str);    可将任意数据类型添加到字符串缓冲区中，并返回字符串缓冲区本身。
        * public StringBuffer insert(int offset, String str); 在指定位置插入任意数据类型的数据到字符串缓冲区中，并返回字符串缓冲区本身。
            * 注意：
                * 【在指定索引的位置上添加，而不是位置后面去添加。如果没有在指定的索引上添加，就会报 索引越界异常】
                    * 如：    StringBuffer s1 = new StringBuffer("123456");
                            System.out.println(s1.insert(4, "哈哈")); // 1234哈哈56 【在4的位置上 不是位置后面添加。】
    
                * 不能在空的字符串缓冲区中插入数据，否则会报 索引越界异常 
                    * 如：    StringBuffer s = new StringBuffer();
                          System.out.println(s.insert(3, "haha")); // 异常：StringIndexOutOfBoundsException 当字符串缓冲区中没有字符的时候，执行insert()方法 会出现异常，该异常是 索引越界异常。
        * 二者区别：
            * append() 默认添加到末尾 
            * insert() 指定位置的插入  在空字符串缓冲区中使用 insert方法 和 在索引不存在的位置上添加 都会报：StringIndexOutOfBoundsException 索引越界异常。



    StringBuffer的删除功能
        * public StringBuffer deleteCharAt(int index); 删除指定索引上的字符，并返回字符串缓冲区本身。
            * 注意： 当删除字符串缓冲区中这个索引上没有的元素 或 整个字符串缓冲区为空时删除，就会报 StringIndexOutOfBoundsException 索引越界异常。
        * public StringBuffer delete(int start, int end); 删除指定索引位置开始到指定位置结束的字符，并返回字符串缓冲区本身。
            * 注意： 删除也是 含头不含尾的，即 end-start
                * 如: StringBuffer s3 = new StringBuffer("worlds");
                      System.out.println(s3.delete(2, 4)); //wods  删除也是 含头不含尾的，end-start 的
        * 注意：
            * sb.deleteCharAt(5); 删除5索引位置上的字符。
            * sb.delete(4,7); 指定位置的删除，记住，这样的删除都是 含头不含尾 的。API中大多数的删除方法都是这样的。
            * sb.delete(0, sb.length); 清除字符串缓冲区 即删除所有数据。字符串长度：length()-1 因为delete是删除含头不含尾，所以无需-1



    StringBuffer的 替换 和 反转功能
        * public StringBuffer replace(int start, int end, String str); 指定位置上的替换，将其替换成str。
        * public StringBuffer reverse(); 字符串的反转    


​    
    StringBuffer的截取功能及注意事项
        * public String subString(int start); 截取，会产生一个新的字符串，从指定位置截取到末尾。
        * public String subString(int start, int end); 从指定位置开始到指定位置结束的截取，同样会生成一个新的字符串，也是 含头不含尾 的。拿到的截取的数据。
            * 如：StringBuffer s2 = new StringBuffer("xixihehe");
                  System.out.println(s2.substring(4,6)); //he 拿到的是截取的字符串


    String和StringBuffer的互相转换
        * String --- StringBuffer
            * 通过构造
            * 通过append()方法
        * StringBuffer --- String
            * 通过构造
            * 通过toString()方法
            * 通过s.subString(0, s.length()); 截取一个新字符串



d.
    案例1
        把数组转成字符串
             需求：把数组中的数据按照指定个格式拼接成一个字符串
                举例：
                    int[] arr = {1,2,3};    
                输出结果：
                    "[1, 2, 3]"
                    
                用StringBuffer的功能实现
    路径：G:\CSDN_Android_\Code/Day13_StringBuffer对象_字符串反转_冒泡排序选择排序二分查找_Arrays类_Integer类_JDK5新特性自动拆装箱/src/com/day13/b/test/StringBuffer/Test01_把数组转成字符串.java
    
    案例2
        字符串反转
            需求：把字符串反转
                举例：键盘录入"abc"        
                输出结果："cba"
                
            用StringBuffer的功能实现    
    路径：G:\CSDN_Android_\Code/Day13_StringBuffer对象_字符串反转_冒泡排序选择排序二分查找_Arrays类_Integer类_JDK5新特性自动拆装箱/src/com/day13/b/test/StringBuffer/Test02_将字符串反转.java


e.
    StringBuffer 和 StringBuilder 的区别
        * 通过API来查询比较。
* 面试题：
* StringBuffer 和 Sstringbuilder 的区别
  1） 首先都是在java.lang包下的及使用的方法都是一样的。
  2） StringBuffer是jdk1.0的时候提出的，线程安全而且同步，但执行效率低。
  3） StringBuilder是jdk1.5的时候提供提出的，线程不安全，而且不同步，但执行效率高。
* String 和 StringBuffer，StringBuilder的区别
  1） String是不可变的字符序列
  2） StringBuffer，StringBuilder都是可变的字符序列



f.
    String 和 StringBuffer 分别作为参数传递
        A:形式参数问题
            * String作为参数传递
            * StringBuffer作为参数传递 
            
        B:案例演示
            * String和StringBuffer分别作为参数传递问题
    
    分析：        
        基本数据类型的值传递，不改变其值
        引用数据类型的值传递，改变其值         
        
        String 虽然是引用数据类型，但作为参数值传递时和基本数据类型是一样的。
            * 因为随着方法执行完毕，就会弹栈，该方法中 参数String记录的值就会变成垃圾，即还是原来的值，且String还是用final 来修饰的，其值一旦被初始化，就不能被改变。
        
        而 StringBuffer 和 String不同，他是通过append 方法进行添加元素，会最终改变其值。


h.
    冒泡排序 选择排序 和 二分查找
    --冒泡排序
            * 冒泡排序 --- 轻的上浮，沉的下沉。
            * 原理图解
                * 相邻元素进行两两比较，如果前面元素大于后面元素就换位， 第一次比较完毕后，最大值就出现了在最后的索引位置上。
                * 简单记：相邻两个元素做比较，前者大于后者，就换位置。
                * 根据轻者上浮，重者下沉的原则分析出以下规则，根据元素个数是length-1的规则来得出，如元素共5个，即比较的次数就是5-1，即4次：
                *         第一轮：比较了4次   arr[0]和arr[1]   arr[1]和arr[2]  arr[2]和arr[3]  arr[3]和arr[4]        第一轮比较完后，第一个最大值出现，所以第二轮比较就无需参加。
                *         第二轮：比较了3次   arr[0]和arr[1]   arr[1]和arr[2]  arr[2]和arr[3]  第二轮比较完后，第二个最大值出现，所以第三轮比较也就不用参加。
                *         第三轮：比较了2次   arr[0]和arr[1]   arr[1]和arr[2] 第 三轮比较完后，第三个最大值出现，所以第四轮也无需参加了。
                *         第四轮：比较了1次  arr[0]和arr[1]  最后一次比较，最小值和第四个最大值出现。
                  这样的比较，类似 倒三角 的for循环嵌套规则。
            * 代码实现
            *         分析：
            *             1）返回值类型，因为是对原数组进行操作，所以返回值类型是 void
            *             2)  参数列表：字符数组即 int[] arr
            *             3) 打印冒泡排序后的字符数组 




    --选择排序
            * 选择排序 --- 轻者依次前靠
                选择排序
                int[] arr = {24, 69, 80, 57, 13}
                对该字符数组进行 选择排序，所以要了解 选择排序 的规则：
                索引为0的元素，依次与其他索引位置上的元素作比较，如果前者 > 后者，就将前者放前面。
                根据以上规则，可分析出具体的执行流程：以一个字符数组总长度为5作为例子，他的比较轮数就是 length-1，即4，具体如下：
                    第一轮：arr[0] 分别于 arr[1~4]的元素进行比较，每轮比较都会出现最小值且在最小索引位置上，所以每轮出现的最小值即索引，都无需参与下一次的比较
                    第二轮：arr[1] 分别于 arr[2~4]的元素进行比较，
                    第三轮：arr[2] 分别于 arr[3~4]的元素进行比较，
                    第四轮：arr[3] 于 arr[4] 的元素进行比较。
                根据以上 比较规矩，分析出跟 倒三角的 for循环嵌套有类似，所以得出以下代码流程
            
            * 代码实现    
                1） 因为是对原字符数组进行操作，所以返回的还是其本身，但是要用StringBuffer来做，要将其变成字符串，所以返回值类型就是String。
                2）参数列表 是字符数组
                3）先遍历原字符数组，将其结果给 选择排序后使用，不然选择排序结果还是原字符数组的结果。



    --二分查找
            二分查找 --- 折半查找，查找元素中对应的索引，即中间值。
            * 原理图解
            *         前提：数组元素有序，折半查找
            *         查找元素中的中间值。
            *         int min = 0    // 0索引即开头索引
            *         int max = arr.length-1     // 最大索引
            *         int mid = (min+max)/2    // 中间值，即要查找的值
            *     折半查找存在4中情况：如：int[] arr = {11,    22,    33,    44,    55,    66,    77};
            *                                                                 0        1        2        3        4        5         6    
            *                                                               min                    mid                   max
            *     1）比如要查找的值是22，当mid > 22
            *              arr[mid] = 44>22
            *             max = mid-1
            *             mid = (min+max)/2 = (0+2)    =2/2=1，即1索引的位置上的数就是我们要找的值。        
            * 
            *     2）比如要查找的值是66，当mid < 22
            *             arr[mid] = 44 < 66
            *             min  = mid+1
            *             mid = (min+max)/2 = (4+6)/2=6，即索引6的位置上的数就是我们要找的值。
            *     3）要查找的值 不存在于  数组中的某个元素 88
            *             arr[mid] = 44<88
            *             mid = mid+1=4
            *             mid = (min+max)/2 = (4+6)/2=5     即5索引上的值就是66
            *             arr[mid] = 66<88
            *             mid = mid+1=6
            *             mid = (min+max)/2 = (6+6)/2=6    即6索引上的值就是66
            *             arr[mid] = 77 < 88
            *             mid = mid + 1 =7 
            *             min > max 即 7 > 6 说明数组中并没有该值的存在，即直接返回-1即可。
            *  4）比如要查找的值是44 即就是中间值，也就是我们要查找的值，就直接返回该索引即可 。
            *   
            *     根据以上分析，得出 如果猜到的值==mid就直接返回， 如果小于就采用1）的方
            *     法，如果大于就采用2）的方法，如果不存在，就采用3）的方法。
            *             
            * 代码实现
            *         分析
            *         1） 因为操作的是这个数组，要将数组中的某个元素的索引给返回，所以返回值类型是 int
            *         2)   参数列表：字符数组，和 要查找的那个数 所以是 int[] arr, int num


i.
    常见对象 Arrays类
        概述
            * 在java.util 包下。
            * 是对数组进行操作的类。
        功能
            * 提供了排序和查找等功能。
        成员方法
            * public static String toString(int[] arr);    将数组转换成字符串。
            * public static void sort(int[] arr);  排序，底层使用的是快速排序的方法，是一个升序的过程。
            * public static void int binarySearch(int[] arr, int value);    二分查找，最好对有序的数组进行排序,如果没有被排序，就先排序后查找即使用Arrays.sort方法。如果不存在就，就是 负的插入的-1，然后对 负的插入的-1 取正，就是该数在数组中想要插入的索引位置数了。



    常见对象 基本类型包装类
        为什么会出现基本类型包装类？
            * 将基本类型封装成对象的好处在于可以使用这个对象中更多的功能方法来操作该数据。
        常见操作？
            * 用于基本数据类型和字符串之间的相互转化。
        基本数据类型和包装类的一一对应关系：
            byte     Byte
            short    Short
            int        Integer
            long    Long
            float    Float
            double    Double
            char    Character
            boolean    Boolean        



    常见对象 Integer类
        概述
            * 通过API查询Integer的用法。
            * Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。 
            * 此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。 
        构造方法
            * public Integer(int value); 构造一个新分配的 Integer 对象，它表示指定的 int 值。
            * public Integer(String s);    构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值，该String必须是一个int类型的值。




    常见对象 String和int类型的相互转换
        int --- String
            * 和""直接使用，就会变成String类型。【推荐使用】
            * public static String valueOf(int a); 将int类型转成String类型。 【推荐使用】
            * int > Integer > String     使用的是Integer中的toString方法。    
            * public static String toString(int a); 通过Integer的静态方法将int类型变成字符串。
        String --- int
            * String > Integer > int  且String只能是int类型的数据。 
            * public static int parseInt(String s); Integer中的方法，将字符串参数作为有十进制整数进行解析。 【推荐使用】
        基本数据类型包装类有8种，其中有七种可以使用 parseXXX()的方式可以将这7种的字符串表现形式转换成基本数据类型，而Character不可以，因为字符用''扩起来，只能每次括一个。



    常见对象 JDK5的新特性自动装箱和拆箱
        * 自动装箱？
            * 将基本数据类型转换成包装类类型。
                * 将基本数据类型直接给包装类即可，如 Integer a =33;
        * 自动拆箱？
            * 将包装类型转换成基本数据类型。
                * 将基本数据类型 和 包装类直接相加，如：Integer a =33, int result = a +55; 
        注意：            
            Integer ab = null; // 将基本数据类型null直接给包装类Integer ，这样的过程叫做 自动装箱。
            int ss = ab+65; // 将基本数据类型65和包装类Integer ab一起使用，这叫自动拆箱。
            System.out.println(ss); //会出现空指针异常，因为底层ab使用的是intValue的方法，但ab的值是null，所以会
                                            //报异常，建议使用之前先判断Integer的值是否为null。
    
    常见对象 Integer的面试题


        看程序写结果

        Integer i1 = new Integer(97);
        Integer i2 = new Integer(97);
        System.out.println(i1 == i2); // false，因为==号比较的是引用数据类型的地址值，这两个地址值不同
        System.out.println(i1.equals(i2)); // true, equals比较的是对象的属性值，属性值相同，所以是true
        System.out.println("-----------");
    
        Integer i3 = new Integer(197);
        Integer i4 = new Integer(197);
        System.out.println(i3 == i4); // false    创建了不同对象，即不同的地址值。
        System.out.println(i3.equals(i4)); // true
        System.out.println("-----------");
    
        Integer i5 = 97;
        Integer i6 = 97;
        System.out.println(i5 == i6);        //true，因为在byte -127到128的取值范围之间，如果在这个范围内，自动装箱就不会创建对象，而是在常量中获取，即是同一个对象，如果超出这个范围，就会重新创建对象。
        System.out.println(i5.equals(i6)); // true
        System.out.println("-----------");
    
        Integer i7 = 197;
        Integer i8 = 197;
        System.out.println(i7 == i8); //false 因为超出了byte的取值范围，重新创建了对象，即存在了两个不同地址值的对象，所以为false 。
        System.out.println(i7.equals(i8)); // true