一起学Java_StringBuffer和Arrays类的使用

###13.01_常见对象(StringBuffer类的概述)
* A:StringBuffer类概述
      线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。 
      可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。 
* B:StringBuffer和String的区别
    * String是一个不可变的字符序列
    * StringBuffer是一个可变的字符序列 
    * 无参构造方法，Sting为空字符初始容量为0，StringBuffer初始容量为16

###13.02_常见对象(StringBuffer类的构造方法)
* A:StringBuffer的构造方法：
    * public StringBuffer():无参构造方法，初始容量为16
    * public StringBuffer(int capacity):指定容量的字符串缓冲区对象
    * public StringBuffer(String str):指定字符串内容的字符串缓冲区对象，指定字符串不占有初始容量，容量为str.length+16
* B:StringBuffer的方法：
    * public int capacity()：返回当前容量。    理论值(不掌握)
    * public int length():返回长度（字符数）。 实际值
* C:案例演示
    * 构造方法和长度方法的使用
        
    `package wbl.test;

public class StringBuffer_Test
{
    public static void main(String[] args)
    {
        StringBuffer sb=new StringBuffer();
        System.out.println(sb.length());//获取的是实际存储字符的长度
        System.out.println(sb.capacity());//获取的是实际的容量
        StringBuffer sb1=new StringBuffer("asd");//该构造方法不占用初始容量
        System.out.println(sb1.capacity());
        StringBuffer sb2=new StringBuffer(50);//设定初始容量
        System.out.println(sb2.capacity());
        sb1.append("asdhjgfkfhaklsjdfl;kas");//在字符串后面添加内容，可以是任意类型
        System.out.println(sb1);
        //超出字符串容量，新的容量为：当前容量*2+2=19*2+2
        System.out.println(sb1.capacity());
        sb1.insert(5, "sdaad");//在第5个字符前面插入字符串
        System.out.println(sb1);
        /**
         * append()方法可以添加任何数据类型的数据，因为StringBuffer是将字符串放在字符串缓冲区的
         * ，append返回的是缓冲区本身，无论调用多少次都是返回同一个缓冲区
         * new 一个对象就会分配一个字符串缓冲区
         */
        StringBuffer stringBuffer=new StringBuffer();
        StringBuffer stringBuffer2=stringBuffer.append(true);
        //stringBuffer2.append(true);
        StringBuffer stringBuffer3=stringBuffer.append('A');
        StringBuffer stringBuffer4=stringBuffer.append("nihao");
        System.out.println(stringBuffer);
        System.out.println(stringBuffer2);
        System.out.println(stringBuffer3);
        System.out.println(stringBuffer4);
        stringBuffer.deleteCharAt(5);//删除第几个字符
        stringBuffer.delete(0, 1);//删除指定范围的字符
        System.out.println(stringBuffer);
        System.out.println(stringBuffer2);
        char c2 =stringBuffer.charAt(2);//获取字符串第几个字符
        System.out.println(c2);
    }

}
`
    

###13.03_常见对象(StringBuffer的添加功能)
* A:StringBuffer的添加功能
    * public StringBuffer append(String str):
        * 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身,把字符串插入到末尾，如果超出初始容量，会自动扩容为：当前容量*2+2
    * public StringBuffer insert(int offset,String str):
        * 在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身，在字符串第几个字符前插入字符串

###13.04_常见对象(StringBuffer的删除功能)
* A:StringBuffer的删除功能
    * public StringBuffer deleteCharAt(int index):
        * 删除指定位置的字符，并返回本身
    * public StringBuffer delete(int start,int end):
        * 删除从指定位置开始指定位置结束的内容，并返回本身

###13.05_常见对象(StringBuffer的替换和反转功能)
* A:StringBuffer的替换功能
    * public StringBuffer replace(int start,int end,String str):
        * 从start开始到end用str替换
        StringBuffer sb6=new StringBuffer("asdfgjkasd");
        sb6.replace(1,3,"nihao");
        System.out.println(sb6);
* B:StringBuffer的反转功能
    * public StringBuffer reverse():
        * 字符串反转
        sb6.reverse();
        System.out.println(sb6);


###13.06_常见对象(StringBuffer的截取功能及注意事项)
* A:StringBuffer的截取功能
    * public String substring(int start):
        * 从指定位置截取到末尾
    * public String substring(int start,int end):
        * 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
* B:注意事项
    * 注意:返回值类型不再是StringBuffer本身
        String sb7=sb6.substring(6);//从指定位置截取到末尾,sb6不发生改变，返回值类型为String
        System.out.println(sb7);

###13.07_常见对象(StringBuffer和String的相互转换)
* A:String -- StringBuffer
    * a:通过构造方法
    * b:通过append()方法
        //创建一个String对象
        String string="nihao";
        System.out.println(string);
        //方式一：构造方法
        StringBuffer stringBuffer5=new StringBuffer(string);
        System.out.println(stringBuffer5);
        //方式二：通过append方法
        StringBuffer stringBuffer6=new StringBuffer();
        stringBuffer6.append(string);
        System.out.println(stringBuffer6);
* B:StringBuffer -- String
    * a:通过构造方法
    * b:通过toString()方法
    * c:通过subString(0,length);
        //创建一个StringBuffer对象
        StringBuffer stringBuffer7=new StringBuffer("world");
        System.out.println(stringBuffer7);
        //方式一：通过构造方法
        String string2=new String(stringBuffer7);
        System.out.println(string2);
        //方式二：通过toString方法
        String string3=stringBuffer7.toString();
        System.out.println(string3);
        //方式三：通过subString(0,length);
        String string4=stringBuffer7.substring(0, stringBuffer7.length());
        System.out.println(string4);

###13.08_常见对象(把数组转成字符串)
* A:案例演示
    * 需求：把数组中的数据按照指定个格式拼接成一个字符串(Arrays.toString(arr))
    * 
            举例：
                int[] arr = {1,2,3};    
            输出结果：
                "[1, 2, 3]"
                
            用StringBuffer的功能实现
package wbl.test;

public class StringBuffer_Test3
{
    public static void main(String[] args)
    {
        int[] arr = {1,2,3};    
        StringBuffer stringBuffer=new StringBuffer();
        for (int i = 0; i < arr.length; i++)
        {
            if(i==0)
                stringBuffer.append("[");
            stringBuffer.append(arr[i]);
            if(i<arr.length -1)
                stringBuffer.append(",");
            if(i==arr.length-1)
                stringBuffer.append("]");
        }
        System.out.println(stringBuffer);
    }
}


###13.09_常见对象(字符串反转)
* A:案例演示
* 
        需求：把字符串反转
            举例：键盘录入"abc"        
            输出结果："cba"
            
        用StringBuffer的功能实现    
package wbl.test;
import java.util.Scanner;
public class fanzhuan
{
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        String str=sc.nextLine();
        StringBuffer sBuffer=new StringBuffer(str);
        StringBuffer sBuffer2=sBuffer.reverse();
        System.out.println(sBuffer2);        
    }
}


###13.10_常见对象(StringBuffer和StringBuilder的区别)
* A:StringBuilder的概述
    * 一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。 


* B:面试题
    * String,StringBuffer,StringBuilder的区别
    * StringBuffer和StringBuilder的区别
    * StringBuffer是jdk1.0版本的,是线程安全的,效率低
    * StringBuilder是jdk1.5版本的,是线程不安全的,效率高

    * String和StringBuffer,StringBuilder的区别
    * String是一个不可变的字符序列
    * StringBuffer,StringBuilder是可变的字符序列

###13.11_常见对象(String和StringBuffer分别作为参数传递)
* A:形式参数问题
    * String作为参数传递:传递的是参数的地址，随着方法的结束该地址被回收，原来的对象指向的地址不发生改变，但是方法中的对象指向的地址发生了改变
    * StringBuffer作为参数传递 ：append方法是根据对象的地址来修改值，不再创建新的对象，因此指向的地址都是一样的，改地址的值被永久的修改
* B:案例演示
    * String和StringBuffer分别作为参数传递问题
package wbl.test;

public class StringAndStringBuffer_qubie
{

    public static void main(String[] args)
    {
        String str1="nihao";
        System.out.println("String作为参数传递前："+str1);
        change(str1, "world");
        System.out.println("String作为参数传递后："+str1);
        
        StringBuffer sb1=new StringBuffer("world");
        System.out.println("StringBuffer作为参数传递前："+sb1);
        change(sb1, sb1);
        System.out.println("StringBuffer作为参数传递后："+sb1);
        

    }
    public static void change(String string,String string2)
    {
        string=string2;
        System.out.println("方法中的值为："+string);
    }
    public static void change(StringBuffer sb1,StringBuffer sb2)
    {
        sb1=sb1.append(sb2);
        System.out.println("方法中的值为："+sb1);
    }

}

结果：
String作为参数传递前：nihao
方法中的值为：world
String作为参数传递后：nihao
StringBuffer作为参数传递前：world
方法中的值为：worldworld
StringBuffer作为参数传递后：worldworld

package wbl.test;

public class StringBuffer_Test11
{
    public static void main(String[] args)
    {
        test("word");
        StringBuffer stringBuffer=new StringBuffer("nihao");
        StringBuffer stringBuffer2=new StringBuffer("shijie");
        test1(stringBuffer,stringBuffer2);
        System.out.println(stringBuffer+" , "+stringBuffer2 );
    }
    public static void test(String string )
    {
        System.out.println(string);
        string="niaho";
        System.out.println(string);
        
    }
    /**
     * 方法中stringBuffer=stringBuffer2;stringBuffer指向的是stringBuffer2的地址，
     * 所以stringBuffer=shijie;stringBuffer2修改是根据他的地址修改的值，所以该地址的值被永久
     * 的修改，方法结束后，stringBuffer不再指向stringBuffer2的地址，而是本身的地址，没有改变，
     * stringBuffer发生了改变为：shijieshijie
     * @param stringBuffer
     * @param stringBuffer2
     */
    public static void test1(StringBuffer stringBuffer ,StringBuffer stringBuffer2)
    {
        stringBuffer=stringBuffer2;
        stringBuffer2=stringBuffer2.append(stringBuffer);
        System.out.println(stringBuffer+" , "+stringBuffer2 );     
    }
}

执行结果：
word
niaho
shijieshijie , shijieshijie
nihao , shijieshijie


###13.12_常见对象(数组高级冒泡排序原理图解)
* A:画图演示
* 
        需求：
            数组元素：{24, 69, 80, 57, 13}
            请对数组元素进行排序。
            
            冒泡排序
                相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处


###13.13_常见对象(数组高级冒泡排序代码实现)
* A:案例演示
    * 数组高级冒泡排序代码
    * 
    public static void main(String[] args)
    {
        int[] arr={123,456,987,6546,2324687,9,54,6789};
        maopao(arr);
    }

    /**
     * 冒泡排序，相邻两个数字比较，大的放在右边，一次循环后最右边数的不参与下一次循环
     */
    private static void maopao(int[] arr)
    {    
        int temp=0;
        int num=0;
        for (int i = 0; i < arr.length-1; i++) {    
            for (int j = 0; j < arr.length-i-1; j++) {
                if(arr[j]>arr[j+1])
                {
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
                num++;
            }
        }
        System.out.println("冒泡排序结果：");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("循环次数："+num);
    }

###13.14_常见对象(数组高级选择排序原理图解)
* A:画图演示
    * 需求：
        * 数组元素：{24, 69, 80, 57, 13}
        * 请对数组元素进行排序。
        
        * 选择排序
            * 从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处


###13.15_常见对象(数组高级选择排序代码实现)
* A:案例演示
    * 数组高级选择排序代码
    public static void main(String[] args)
    {
        xuanze();    
    }

    /**
     * 选择排序，数组第一个逐个与后面的比较，最小的放在第一位，结束本次循环，下次循环
     * 从第二个数开始，依次循环
     */
    private static void xuanze()
    {
        int[] arr={123,456,987,6546,2324687,9,54,6789};
        int temp=0;
        int num=0;
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = i+1; j < arr.length; j++) {
                if(arr[i]>arr[j])
                {
                    temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
                num++;
            }
        }
        System.out.println("选择排序结果：");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("循环次数："+num);
    }

###13.16_常见对象(数组高级二分查找原理图解)
* A:画图演示
    * 二分查找  
    * 前提：数组元素有序

###13.17_常见对象(数组高级二分查找代码实现及注意事项)
* A:案例演示
    * 数组高级二分查找代码
    
    public static void main(String[] args)
    {
        int[] arr={12,23,45,50,56,78,89,156,489,789,4568};
        erfenfa(arr,123);
    }

    /**
     * 二分法查找
     */
    private static void erfenfa(int[] arr,int search)
    {
        int max=arr.length;
        int min=0;
        int mid=(min+max)/2;
        int num=0;
        int temp=-1;
        while(min<max)
        {
            if(arr[mid]>search)
            {
                max=max-1;
                mid=mid/2;
            }
            if(arr[mid]<search)
            {
                min=min+1;
                mid=(mid+max)/2;
            }else if(arr[mid]==search)
            {
                temp=mid;
                break;
            }
            num++;
        }
        System.out.println(search+"在数组的第"+temp+"位");
        System.out.println("循环次数："+num);
    }
* B:注意事项
    * 如果数组无序，就不能使用二分查找。
        * 因为如果你排序了，但是你排序的时候已经改变了我最原始的元素索引。

###13.18_常见对象(Arrays类的概述和方法使用)
* A:Arrays类概述
    * 针对数组进行操作的工具类。
    * 提供了排序，查找等功能。
* B:成员方法
    * public static String toString(int[] a)
    * public static void sort(int[] a)
    * public static int binarySearch(int[] a,int key)
package wbl.test;

import java.util.Arrays;

public class Arrays_Test
{
    public static void main(String[] args)
    {
        int[] arr={12,456,123,46,13,6,9,6};
        //打印数组[1,2,3,4]
        String src=Arrays.toString(arr);
        System.out.println(src);
        //数组排序(升序)
        Arrays.sort(arr);
        for (int i = 0; i < arr.length; i++)
        {
            System.out.println(arr[i]);
        }
        //数组二分法查找，如果找不到想要找的key,那么他会根据当前的值去找最后一个比他小的
        //数，然后将该出的索引取负值再-1-1；
        int x=Arrays.binarySearch(arr, 14);//-4-1-1=-6
        System.out.println(x);
        /**
         * copyof: 根据一个原始数组和一个长度来拷贝一个数组
         * copyof拷贝的时候没有自己去拷贝而是调用
         * System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
           arraycopy()
                   第一个参数: 原始的数组
                   第二个参数：原始数组的第0个位置开始拷贝
                   第三个参数: 拷贝到哪里
                   第四个参数: 拷贝到的数组的存放的起始位置
                   第五个参数: 拷贝的长度
         */
        //数组的拷贝，超出拷贝数组的部分补0
        int[] arr1 = Arrays.copyOf(arr, arr.length+5);
        System.out.println(Arrays.toString(arr1));
        
        /**
         * 拷贝一定范围的数组
         * copyOfRange
         *     第一个参数：原始数组
         *  第二个参数： 拷贝的起始位置(包含该位置)
         *  第三个参数: 拷贝的结束位置(不包含该位置)
         * [13, 24, 57, 69, 80]
         */
        int[] arr2 = Arrays.copyOfRange(arr, 1, 3);
        System.out.println(Arrays.toString(arr2));
    }

}


###13.19_常见对象(基本类型包装类的概述)
* A:为什么会有基本类型包装类
    * 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
* B:常用操作
    * 常用的操作之一：用于基本数据类型与字符串之间的转换。
* C:基本类型和包装类的对应
* 
        byte             Byte
        short            Short
        int                Integer
        long            Long
        float            Float
        double            Double
        char            Character
        boolean            Boolean

###13.20_常见对象(Integer类的概述和构造方法)
* A:Integer类概述
    * 通过JDK提供的API，查看Integer类的说明

    * Integer 类在对象中包装了一个基本类型 int 的值,
    * 该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，
    * 还提供了处理 int 类型时非常有用的其他一些常量和方法
* B:构造方法
    * public Integer(int value)
    * public Integer(String s)
* C:案例演示
    * 使用构造方法创建对象
public class Integer_Test1
{
    public static void main(String[] args)
    {
        Integer integer=new Integer(52);
        System.out.println(integer);
        String string=10+"";//字符组只能是数字，否则报错
        Integer integer2=new Integer(string);
        System.out.println(integer2);
    }
}

###13.21_常见对象(String和int类型的相互转换)
* A:int -- String
    * a:和""进行拼接
    * b:public static String valueOf(int i)
    * c:int -- Integer -- String(Integer类的toString方法())
    * d:public static String toString(int i)(Integer类的静态方法)
        //int -- String
        int i=10;//方法一：和""进行拼接
        String string2=i+"";
        System.out.println(string2);
        Integer integer=i;//方法二：int -- Integer -- String(Integer类的toString方法())
        String string3=integer.toString();
        System.out.println(integer);
* B:String -- int
    * a:String -- Integer -- int
    * public static int parseInt(String s)
            //String--int
        Integer integer2=Integer.parseInt(string3);
        int j=integer2;
        System.out.println(j);
###13.22_常见对象(JDK5的新特性自动装箱和拆箱)
* A:JDK5的新特性
    * 自动装箱：把基本类型转换为包装类类型
    * 自动拆箱：把包装类类型转换为基本类型
* B:案例演示
    * JDK5的新特性自动装箱和拆箱
    
    * Integer ii = 100;
    * ii += 200;
        int i=10;
        Integer in=i;//自动装箱
        int j=in;//自动拆箱
        int x=in+j;
        Integer y=in+j;
        System.out.println(x);
        System.out.println(y);
* C:注意事项
    * 在使用时，Integer  x = null;代码就会出现NullPointerException。
    * 建议先判断是否为null，然后再使用。

###13.23_常见对象(Integer的面试题)
* A:Integer的面试题
* / **
         * Integer有自己缓存区，存放-128——127之间的数，如果在这个范围内，直接赋值那么不需要
         * 创建对象，直接将地址传给j,k，超出范围就要重新创建对象，值相等，但是地址不相等，如果是用构造方法赋值，
         * 不管在不在范围内都要创建对象，不同的对象地址是不同的
         * 
         */
* 
        看程序写结果
        
        Integer i1 = new Integer(97);
        Integer i2 = new Integer(97);
        System.out.println(i1 == i2);//false
        System.out.println(i1.equals(i2));//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，缓存区范围内为同一个对象
        System.out.println(i5.equals(i6));//true
        System.out.println("-----------");
    
        Integer i7 = 197;
        Integer i8 = 197;
        System.out.println(i7 == i8);//false，超过缓存区范围，就是两个不同的对象，
        System.out.println(i7.equals(i8));//ture