JAVA中StringBuffer类，数组排序算法，以及基本类型封装类

StringBuffer类

概述

我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。
而StringBuffer就可以解决这个问题

方法

1.构造方法
public StringBuffer(): 无参构造方法
public StringBuffer(int capacity): 指定容量的字符串缓冲区对象
public StringBuffer(String str): 指定字符串内容的字符串缓冲区对象
2.方法
public int capacity()：返回当前容量。 理论值
public int length():返回长度（字符数）。 实际值

添加功能

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

删除功能

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

替换和反转功能

1.替换：
public StringBuffer replace(int start,int end,String str): 从start开始到end用str替换
2.反转：
public StringBuffer reverse(): 字符串反转

检索功能

int indexOf(String str) 返回第一次出现的指定子字符串在该字符串中的索引。

int indexOf(String str, int fromIndex) 从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
int lastIndexOf(String str) 返回最右边出现的指定子字符串在此字符串中的索引。

int lastIndexOf(String str, int fromIndex) 返回最后一次出现的指定子字符串在此字符串中的索引。

截取功能及其注意事项

public String substring(int start): 从指定位置截取到末尾
public String substring(int start,int end): 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
注意事项：
返回值类型不是StringBuffer，而是String类型

StringBuffer和String的相互转换

A:String – StringBuffer
a:通过构造方法
b:通过append()方法
B:StringBuffer – String
a: 使用substring方法
b:通过构造方法
c:通过toString()方法
例：把数组转为字符串

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

            }else {
                stringBuffer.append(arr[i]+",");
            }
        }
        System.out.println(stringBuffer);
    }

StringBuffer和StringBuilder的区别

StringBuffer是可变类，和线程安全的字符串操作类，任何对它指向的字符串的操作都不会产生新的对象。每个StringBuffer对象都有一定的缓冲区容量，当字符串大小没有超过容量时，不会分配新的容量，当字符串大小超过容量时，会自动增加容量
StringBuilder也是可变类
StringBuffer线程安全，StringBuiler线程不安全
String执行速度慢，而StringBuilder执行速度快

数组排序

冒泡排序

前一个和后一个进行比较，把大的那一个放在后面，然后直到整个数组中的元素有序

   int []arr={2,6,4,5,66,33,23,55,-112};
        for (int i = 0; i < arr.length; i++) {
            for (int j=0; j< arr.length - 1-i; j++) {
                if (arr[j] > arr[j+ 1]) {
                    int tp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tp;


                }

选择排序

选一个数把它当作这个数组中最小的元素，然后让它和后一个比较，只要后一个比它小，就将后一个的索引给这个，然后经过几轮，使得数组有序

 int[]arr ={12,-1,-67,23,56,77,45};
        for (int i = 0; i < arr.length-1; i++) {
            int min = i;
            for (int j = i+1; j < arr.length; j++) {
                if (arr[min]>arr[j]){
                    min=j;
                }
            }
            int temp= arr[min];
            arr[min] =arr[i];
            arr[i]=temp;
            System.out.println(Arrays.toString(arr));
        }

归并排序

代码：

 public static void main(String[] args) {
        int []arr={122,33,22,34,54,32,12,32};
        chaifen(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));


    }

    private static void chaifen(int[] arr, int startindex, int endindex) {
        int centerindex=(startindex+endindex)/2;
        if (startindex<endindex){
            chaifen(arr,startindex,centerindex);
            chaifen(arr,centerindex+1,endindex);
            gui(arr,startindex,centerindex,endindex);
        }
    }

    private static void gui(int[] arr, int startindex, int centerindex, int endindex) {
        int []tempArry=new int[endindex-startindex+1];
        int index=0;
        int x=centerindex+1;
        int y=startindex;
       while (y<=centerindex&&x<=endindex){
           if (arr[y]<=arr[x]){
               tempArry[index]=arr[y];
               y++;
           }else {
               tempArry[index]=arr[x];
               x++;
           }
           index++;
       }
       while (y<=centerindex){
           tempArry[index]=arr[y];
           y++;
           index++;
       }
       while (x<=endindex){
           tempArry[index]=arr[x];
           x++;
           index++;
       }
       for (int a = 0; a < tempArry.length; a++) {
           arr[a+startindex]=tempArry[a];
       }

    }

快速排序

1.从数组中选一个数作为基准数
2.将比这个数大的数放在右边，小的放在右边
3，分区，继续排序，直到一个区里只有一个元素

 public static void main(String[] args) {
        int[] arr = {5, 2, 7, 3, 0, 25, 16, 9, 99,45,32,21,32,-9,-23,-67};
        quicksort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }

    public static void quicksort(int[] arr, int start, int end) {
        if (start < end) {
            int left = start;
            int right = end;
            int standard = arr[start];
            while (left < right) {
                while (left < right && standard <= arr[right]) {
                    right--;
                }
                arr[left] = arr[right];

                while (left < right && standard >= arr[left]) {
                    left++;
                }
                arr[right] = arr[left];

            }
            arr[left] = standard;
            quicksort(arr,start,right);
            quicksort(arr,right+1,end);


        }
    }

Arrays类

Arrays类的概述和方法使用

A:Arrays类概述
针对数组进行操作的工具类。
提供了排序，查找等功能。
B:成员方法
public static String toString(int[] a)
public static void sort(int[] a)
public static int binarySearch(int[] a,int key)

基本类型包装类

概述

为了对基本数据类型进行更多的操作,更方便的操作,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)

String和int类型的相互转换

A:int – String
a:和""进行拼接
b:public static String valueOf(int i)
c:int – Integer – String
d:public static String toString(int i)
B:String – int
a:String – Integer – intValue();
b:public static int parseInt(String s)

关于integer对象：
当存储的数没有超过一个字节，即在-128-127之间时，在方法区常量池存在，但是超过这个范围就会new一个心得integer对象