Java StringBuffer与StringBuilder，数组的排序，包装类型

StringBuffer类与StringBuilder

因为String创建的对象都是常量，在对字符串进行拼接操作，每次拼接都会构建String对象，效率低，也耗费内存。而StringBuffer类和StringBuilder类解
决了这个问题，因为StringBuffer类和StringBuilder类会在原始的对象上进行操作，节省内存空间。
StringBuffer实际上是构造一个不带字符的字符缓冲区，这个缓冲区有容量，可以向字符缓冲区添加字符串，字符串的长度可变。
StringBuider与StringBuffer一样，但是StringBuilder效率高，线程不安全，而StringBuffer效率低线程安全。
一般字符串数据少的话，就用String创建对象，数据多单线程使用StringBuilder，数据多多线程使用StringBuffer。
StringBuffer构造方法：
	public StringBuffer():				无参构造方法
	public StringBuffer(int capacity):	指定容量的字符串缓冲区对象
 	public StringBuffer(String str):		指定字符串内容的字符串缓冲区对象
StringBuffer的方法：
	public int capacity()：返回当前容量。	理论值
	public int length():返回长度（字符数）。 实际值

public static void main(String[] args) {
       StringBuffer buffer=new StringBuffer(16);
        System.out.println(buffer.append("abbc"));
        System.out.println(buffer.length());
        System.out.println(buffer.capacity());
    }

StringBuffer的添加功能
	public StringBuffer append(String str):			可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
	public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

public static void main(String[] args) {
       StringBuffer buffer=new StringBuffer(16);
        System.out.println(buffer.append("abbc"));
        System.out.println(buffer.length());
        System.out.println(buffer.capacity());
        System.out.println(buffer.insert(1,"ee"));//输出结果：aeebbc，在字符串索引为1处插入ee；
    }

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

public static void main(String[] args) {
       StringBuffer buffer=new StringBuffer("zhaorunfa");
        System.out.println(buffer.deleteCharAt(8));//zhaorunf
        System.out.println(buffer.delete(1,7));//zf
    }

StringBuffer的替换功能
	public StringBuffer replace(int start,int end,String str):	从start开始到end用str替换
StringBuffer的反转功能
	public StringBuffer reverse():							字符串反转

public static void main(String[] args) {
       StringBuffer buffer=new StringBuffer("zhaorunfa");
        System.out.println(buffer.replace(1,3,"ee"));//输出zeerunfa
        System.out.println(buffer.reverse());//输出结果afnuroeez,因为对字符串缓冲区进行操作会改变字符串缓冲区本身，上一步已经对字符串缓冲区进行了替换操作。
    }

StringBuffer的截取功能
	public String substring(int start):			从指定位置截取到末尾
	public String substring(int start,int end):	截取从指定位置开始到结束位置，包括开始位置，不包括结束位置

public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer("zhaorunfa");
        System.out.println(buffer.substring(4));//runfa,开始的索引字符会被截取到
        System.out.println(buffer.substring(0,4));//zhao结束的索引字符不会被截取到
    }

Sting类与StringBuffer相互转换
	String转换StringBuffer
		通过构造方法
		通过append()方法
	StringBuffer转换String
		通过substring()方法
		通过构造方法
		通过toString()方法

 public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer("zhaorunfa");
        String s=buffer.toString();
        System.out.println(s);//zhaorunfa
        StringBuffer buffer1=buffer.append(s);
        System.out.println(buffer1);//zhaorunfazhaorunfa
    }

数组排序

冒泡排序
	数组中的元素两两进行比较，大的往后放，一轮比较后，最大就会在最后，循环即可。

 int arr[] = {15, 24, 25, 521, 5544};
        for (int j = 0; j < arr.length; j++) {
            for (int i = 0; i < arr.length - 1 - j; i++) {
                if (arr[i] < arr[i + 1]) {
                    int t = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = t;
                }
            }
        }

选择排序
	从0索引开始，用元素依次与后面的元素比较，一轮比较后，最小的元素就在最前面。

 for (int index = 0; index < arr.length-1; index++) {
            for (int i = index+1; i < arr.length-1; i++) {
                if (arr[index] < arr[i]) {
                    int t = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = t;
                }
            }
        }

快速排序

 public void quicksort(int arr[],int start,int end){
        if(start<end){
            //获取分区索引
            int index=getIndex(arr,start,end);
            //对左右两个分区  再递归调用
            quicksort(arr, start, index-1);//左半部分
            quicksort(arr, index+1, end);//右半部分
        }
    }

    public int getIndex(int[] arr, int start, int end) {
        int i=start;
        int j=end;
        int x=arr[i];
        while (i<j){
            while (i<j&&arr[i]>=x){
                j--;
            }
            if(i<j){
                arr[i]=arr[j];
                i++;
            }
            while (i<j&&arr[i]<x){
                i++;
            }
            if(i<j){
                arr[j]=arr[i];
                j--;
            }
        }
        arr[i]=x;
        return i;
    }

直接插入排序

int ar[]={12,65,34,298,79,-24,45};
        for (int i = 1; i <ar.length-1 ; i++) {
            int j=i;
            while (j>0&&ar[j]<ar[j-1]){//进行判断如果j>0且后面元素比前面小，就会进行换位；
                int t=ar[j-1];
                ar[j-1]=ar[j];
                ar[j]=t;
                j--;//控制j索引值，使j表示的是要比的变量
            }
        }

二分查找
	有序数组中查找，每次将数组从中间索引一分为二，看查找的数与中间索引的数是否相等，若是不等，比较中间索引数的大小，大的话在中间索引后部重复以上操作，小的话在中间索引前部重复以上操作。

private static int getIndex2(int[] arr, int num2) {
        //定义三个索引；
        int minIndex=0;
        int maxIndex=arr.length-1;
        int midIndex=(minIndex+maxIndex)/2;
        while (minIndex<=maxIndex){//当数组判断的剩一个数时，最小索引和最大索引重合，还需要在判断一次。
            if(num2==arr[midIndex]){
                return midIndex;
            }else if(num2<arr[midIndex]){
                maxIndex=midIndex-1;
            }else if(num2>arr[midIndex]){
                minIndex=midIndex+1;
            }
            //需要重新计算中间索引；
            midIndex=(minIndex+maxIndex)/2;
        }
        return -1;//没有找到返回-1
    }

包装类

为了对基本类型有更多的操作，java为每一种基本类型提供了对应的类类型。
基本类型和包装类的对应
	byte 				Byte
	short				Short
	int			   		Integer
	long				Long
	float				Float
	double		    	Double
	char				Character
	boolean		        Boolean
Integer类
	Integer 类在对象中包装了一个基本类型 int 的值,
	该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，
	还提供了处理 int 类型时非常有用的其他一些常量和方法
构造方法
	public Integer(int value)
	public Integer(String s)//形参是一个字面上是数字的字符串，不然会出现数字格式化异常

public static void main(String[] args) {
       Integer integer=new Integer(45);
        System.out.println(integer);
       String s="123";
       Integer integer1=new Integer(s);
        System.out.println(integer1);
    }

String类与int类相互转换
	int--->String
		通过拼接""；
		通过toString方法
		通过包装类型
		通过valueOf方法

 public static void main(String[] args) {
       int i=15;
       String s=i+"";
       int[] ints=new int[]{15,20};
        System.out.println(ints.toString());
        Integer integer=new Integer(i);
        System.out.println(integer.toString());
        System.out.println(integer.valueOf(25).toString());
    }

	String-->int
		通过pareInt()方法
		通过包装类型中的intValue方法

 public static void main(String[] args) {
       String a="123";
       Integer integer=new Integer(a);
        System.out.println(integer.parseInt(a));
    }

自动拆箱与自动装箱
	自动装箱：把基本类型转换为包装类型
	自动拆箱：把包装类型转换为基本类型
	当包装类型的数据在进行基本运算的时候，包装类型会自动转换为基本类型参加运算，运算结束后，又会自动转换为包装类型。
	对于Integer字符串缓冲区中已经创建好-128-127的对象，当我们对Integer类型赋值时，如果在这个范围内，他会直接去取用字符缓冲区已经创好的对象，如果不在范围内，就会重新创建对象。

public static void main(String[] args) {
       Integer i=127;
       Integer i1=127;
        System.out.println(i==i1);//true
        Integer i2=128;
        Integer i3=128;
        System.out.println(i2==i3);//false
    }