Java编程基础14——常见对象_StringBuffer&数组排序&包装类

摘要：提供了排序，查找等功能。常用操作常用的操作之一用于基本数据类型与字符串之间的转换。

A:StringBuffer类概述

通过JDK提供的API，查看StringBuffer类的说明

线程安全的可变字符序列 (一个类似于 String 的字符串缓冲区，但不能修改 : 不能像String那样用 + 连接来修改String)

B:StringBuffer和String的区别

String是一个不可变的字符序列

StringBuffer是一个可变的字符序列

"线程安全的"的简单理解:线程安全的,是同步的,效率低

A:StringBuffer的构造方法：

public StringBuffer():无参构造方法

public StringBuffer(int capacity):指定容量的字符串缓冲区对象

public StringBuffer(String str):指定字符串内容的字符串缓冲区对象

B:StringBuffer的方法：

public int capacity()：返回当前容量。 理论值(不掌握)

public int length(): 返回长度（容器中的字符个数）。 实际值

C:案例演示

构造方法和长度方法的使用

</>复制代码 
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        System.out.println(sb.length());            //容器中的字符个数
        System.out.println(sb.capacity());            //容器的初始容量，理论值
        
        StringBuffer sb2 = new StringBuffer(10);
        System.out.println(sb2.length());            
        System.out.println(sb2.capacity());    
        StringBuffer sb3 = new StringBuffer("allidea");
        System.out.println(sb3.length());            //实际字符的个数
        System.out.println(sb3.capacity());            //字符串的length + 初始容量    
    }

A:StringBuffer的添加功能

public StringBuffer append(String str):

可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身

StringBuffer是字符串缓冲区,当new的时候是在堆内存创建了一个对象,底层是一个长度为16的字符数组
当调用添加的方法时,不会再重新创建对象,而是在不断向原缓冲区添加字符

public StringBuffer insert(int offset,String str):

在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

StringBuffer是字符串缓冲区，当new的时候是在堆内存创建了一个对象，底层是一个长度为16的字符数组，当调用添加的方法时，不会重新创建对象，在不断的向原缓冲区加字符

</>复制代码 
public class StringBuffer_2 {
    public static void main(String[] args) {
//        demo1();
        StringBuffer sb = new StringBuffer("1234");
        sb.insert(3,"allidea");        //在指定位置添加元素，如果没有指定位置的索引，就会报索引越界异常
        System.out.println(sb);
    }
    private static void demo1() {
        StringBuffer sb = new StringBuffer();
        System.out.println(sb.toString());
        StringBuffer sb2 = sb.append(true);
        System.out.println(sb2.toString());
        StringBuffer sb3 = sb.append("allidea");
        System.out.println(sb3.toString());
        StringBuffer sb4 = sb.append(100);
        System.out.println(sb4.toString());
    }
}

A:StringBuffer的删除功能

public StringBuffer deleteCharAt(int index):

删除指定位置的字符，并返回本身

public StringBuffer delete(int start,int end):

删除从指定位置开始指定位置结束的内容，并返回本身

</>复制代码 
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
//        sb.deleteCharAt(5);            //当缓冲区这个索引上没有元素时就会报StringIndexOutOfBoundsException
        sb.append("allidea");
//        sb.deleteCharAt(4);            //根据索引删除索引位置上对应的字符
//        sb.delete(0, 3);            //删除的时候是包含头不包含尾
//        System.out.println(sb);
//        sb.delete(0, sb.length());    //清空缓冲区
//        System.out.println(sb);
        
        sb = new StringBuffer();    //不要用这种方式清空内存，原来的会变成垃圾，浪费内存。
        System.out.println(sb);
    }

A:StringBuffer的替换功能

public StringBuffer replace(int start,int end,String str):

从start开始到end用str替换

B:StringBuffer的反转功能

public StringBuffer reverse():

字符串反转

</>复制代码 
        StringBuffer sb = new StringBuffer("我爱java");
//        sb.replace(0, 3, "ALL");        //替换
//        System.out.println(sb);
        
        sb.reverse();
        System.out.println(sb);            //反转

A:StringBuffer的截取功能

public String substring(int start):

从指定位置截取到末尾

public String substring(int start,int end):

截取从指定位置开始到结束位置，包括开始位置，不包括结束位置

B:注意事项

注意:返回值类型不再是StringBuffer本身

</>复制代码 
        StringBuffer sb = new StringBuffer("我爱java");
//        String str = sb.substring(2);
//        System.out.println(str);
        
        String str2 = sb.substring(2,sb.length());
        System.out.println(str2);

A:String -- StringBuffer

a:通过构造方法

b:通过append()方法

B:StringBuffer -- String

a:通过构造方法

b:通过toString()方法

c:通过subString(0,length);

</>复制代码 
    public static void main(String[] args) {
//        demo1();
        StringBuffer sb = new StringBuffer("allidea");
        
        String s1 = new String(sb);            //通过构造将StringBuffer转换为String
        System.out.print(s1);
        
        String s2 = sb.toString();            //通过toString将StringBuffer转换为String
        System.out.println(s2);
        
        String s3 = sb.substring(0,sb.length());//通过截取字符串将StringBuffer转换为String
        System.out.println(s3);
    }
    private static void demo1() {
        StringBuffer sb1 = new StringBuffer("allidea");        //通过构造方法将字符串转换为StringBuffer对象
        System.out.println(sb1);
        
        StringBuffer sb2 = new StringBuffer();
        sb2.append("allidea");                                //通过append方法转换为StringBuffer对象
        System.out.println(sb2);
    }

A:案例演示-需求：把数组中的数据按照指定个格式拼接成一个字符串
举例：

</>复制代码 
int[] arr = {1,2,3};    

输出结果：

</>复制代码 
"[1, 2, 3]"

用StringBuffer的功能实现

</>复制代码 
public class StringBuffer_test_7 {            
    public static void main(String[] args) {
        int[] arr = {1,2,3};    
        System.out.println(arrayToString(arr));
    }
    /*将数组转换为字符串
     * 1.返回值类型String
     * 2.参数列表int[]
     * 
     * arrayToString 将数组转换为字符串
     * dom4j  domForJ
     * */
    public static String arrayToString(int[] arr) {
        StringBuffer sb = new StringBuffer();            //创建字符串缓冲区对象
        sb.append("[");                                    //将[添加到缓冲区
        
        for (int i = 0; i < arr.length; i++) {            //遍历数组
//            sb.append(arr[i] + ", ");                    //没有]
            if (i != arr.length - 1) {
                sb.append(arr[i]).append(",");
            } else {
                sb.append(arr[i]).append("]");
            }
        }
        return sb.toString();
    }
}

A:案例演示-需求：把字符串反转

</>复制代码 
举例：键盘录入"abc"    输出结果："cba

用StringBuffer的功能实现

</>复制代码 
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        
//        StringBuffer sb = new StringBuffer(line);    //将字符串转换为StringBuffer对象
//        sb.reverse();                                //将缓冲区内容反转
//        System.out.println(sb.toString());
        
        System.out.println(revString(line));
    }
    
/*    将字符串反转
    1.返回值类型string
    2.参数列表string line*/
    
    public static String revString(String line) {    
        StringBuffer sb = new StringBuffer(line);    //将字符串转换为StringBuffer对象
        sb.reverse();    
        return sb.toString();
    }

A:StringBuilder的概述

通过查看API了解一下StringBuilder类

B:面试题

String,StringBuffer,StringBuilder的区别

StringBuffer和StringBuilder的区别

StringBuffer是jdk1.0版本的,是线程安全的,效率低

StringBuilder是jdk1.5版本的,是线程不安全的,效率高

String和StringBuffer,StringBuilder的区别

String是一个不可变的字符序列

StringBuffer,StringBuilder是可变的字符序列

A:形式参数问题

String作为参数传递

StringBuffer作为参数传递

B:案例演示

String和StringBuffer分别作为参数传递问题

</>复制代码 
    基本数据类型的值传递,不改变其值
    引用数据类型的值传递,改变其值
    String类虽然是引用数据类型,但是他当作参数传递时和基本数据类型是一样的(因为String类一旦被初始化,就不会被改变决定的)
     
    public static void main(String[] args) {
        String s = "allidea";
        System.out.println(s);
        change(s);
        System.out.println(s);
        
        StringBuffer sb = new StringBuffer();
        sb.append("allidea");
        System.out.println(sb);
        change(sb);
        System.out.println(sb);
    }
    public static void change(String s) {
        s += "net";
    }
    public static void change(StringBuffer sb) {
        sb.append("net");
    }

A:原理图解-画图演示

</>复制代码 
需求：
    数组元素：{24, 69, 80, 57, 13}
    请对数组元素进行排序。
    冒泡排序
        相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处

B:代码实现-案例演示

数组高级冒泡排序代码

</>复制代码 
public class Array_1 {
    //高级冒泡排序
    public static void main(String[] args) {
        int[] arr = {24, 69, 80, 57, 13};
        bubbleSort(arr);
        print(arr);
    }
/*    冒泡排序方法：
    1.返回类型，void
    2.参数列表，int[] arr
        第一次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3],arr[3]与arr[4]比较4次
        第二次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3]比较3次
        第三次:arr[0]与arr[1],arr[1]与arr[2]比较2次
        第四次:arr[0]与arr[1]比较1次
    */
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {//外循环只需要比较arr.length-1次就行了
            for (int j = 0; j < arr.length - 1 - i; j++) {//-1防止索引越界,-i为了提高效率
                if(arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    //swap(arr,j,j+1);
                }
            }
        }
    }
/*    打印数组
    1.返回值类型void
    2.参数列表，int[] arr*/
    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}    

A:原理图解-画图演示：

数组元素：{24, 69, 80, 57, 13}

请对数组元素进行排序。

选择排序

从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处

用一个索引位置上的元素，依次与其他索引位置上的元素比较，小的在前，大的在后

B:代码实现-案例演示

数组高级选择排序代码

</>复制代码 
public class Array_2 {
    //高级选择排序
    public static void main(String[] args) {
        int[] arr = {24, 69, 80, 57, 13};
//        bubbleSort(arr);
        selectSort(arr);
        print(arr);
    }
/*    打印数组
    1.返回值类型void
    2.参数列表，int[] arr*/
    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
    
/*    选择排序
    1.返回值类型void
    2.参数列表int[] arr
        第一次:arr[0]分别与arr[1-4]比较,比较4次
        第二次:arr[1]分别与arr[2-4]比较,比较3次
        第三次:arr[2]分别与arr[3-4]比较,比较2次
        第四次:arr[3]与arr[4]比较,比较1次
    */
    public static void selectSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {//字需要比较arr.length-1次
            for (int j = i + 1; j < arr.length; j++) {
                if(arr[i] > arr[j]) {
                    swap(arr,i,j);
                }
            }
        }
    }
    
/*    换位操作
    1.返回值类型：void
    2.参数列表：int[],arr.int i,int j
    如果某个方法，只针对本类使用，不想让其他类使用就可以定义成私有的
    */
    
    ublic static void swap(int[] arr,int i,int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

A:原理图解-画图演示

二分查找: 查找元素对应的索引

前提：数组元素有序

B:代码实现-案例演示

数组高级二分查找代码

C:注意事项

如果数组无序，就不能使用二分查找。

因为如果你排序了，但是你排序的时候已经改变了我最原始的元素索引。

</>复制代码 
public class Array_3 {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55,66,77,88,99};
        System.out.println(getIndex(arr, 22));
        System.out.println(getIndex(arr, 99));
    }
/*    二分查询
    1.返回值类型：int
    2.参数列表int[] arr,int value*/
    public static int getIndex(int[] arr,int value) {
        int min = 0;
        int max = arr.length - 1;
        int mid = (min + max) / 2;
        
        while(arr[mid] != value) {            //当中间值不等于要找的值，就开始循环查找
            if(arr[mid] < value) {            //当中间值小于了要找的值
                min = mid + 1;                //最小的索引改变
            }else if(arr[mid] > value) {    //当中间值大雨了要找的值
                max = mid - 1;                //最大的索引改变
            }
            mid = (min + max) / 2;            //无论最大还是最小改变，中间索引都会随之改变
            
            if(min > max) {                    //如果最小索引大于了最大索引，就没有查找的可能性了，返回-1
                return -1;
            }
        }
        return mid;
    }
}

A:Arrays类概述

针对数组进行操作的工具类。

提供了排序，查找等功能。

B:成员方法

public static String toString(int[] a)

public static void sort(int[] a)

public static int binarySearch(int[] a,int key)

</>复制代码 
import java.util.Arrays;
public class Array_4 {
    public static void main(String[] args) {
        int[] arr = {33,22,11,44,55,66,99,77};
        System.out.println(Arrays.toString(arr));//数组转字符串
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));//排序
        int [] arr2 = {11,22,33,44,55,66,77,88,99};
        System.out.println(Arrays.binarySearch(arr2, 22));
        System.out.println(Arrays.binarySearch(arr2, 55));
        System.out.println(Arrays.binarySearch(arr2, 15));//负的插入点减一
    }
}

C:两个方法分析

</>复制代码 
    public static String toString(int[] a) {
        if (a == null)                                //如果传入的数组是null
            return "null";                            //返回null
        int iMax = a.length - 1;                    //iMax最大索引
        if (iMax == -1)                                //如果数组中没有元素
            return "[]";                            //返回[]
        StringBuilder b = new StringBuilder();        //线程不安全,效率高
        b.append("[");                                //将[添加到字符串缓冲区中
        for (int i = 0; ; i++) {                    //遍历数组,判断语句没有写默认是true
            b.append(a[i]);                            //把第一个元素添加进字符串缓冲区
            if (i == iMax)                            //如果索引等于了最大索引值
                return b.append("]").toString();    //将]添加到字符串缓冲区,再转换成字符串并返回
            b.append(", ");                            //如果不等于最大索引就将", "添加到缓冲区
        }
    }

</>复制代码 
    public static int binarySearch(int[] a, int key) {
        return binarySearch0(a, 0, a.length, key);
    }
    private static int binarySearch0(int[] a, int fromIndex, int toIndex, int key) {
        int low = fromIndex;                //最小索引0
        int high = toIndex - 1;                //最大索引数组长度-1
        while (low <= high) {                //最小索引小于等于最大索引可以循环判断
            int mid = (low + high) >>> 1;    //求出中间索引值,(最小+最大)/2
            int midVal = a[mid];            //通过中间索引获取中间值
            if (midVal < key)                //中间索引对应的值小于查找的值
                low = mid + 1;                //最小索引变化
            else if (midVal > key)            //中间索引对应的值大于查找的值
                high = mid - 1;                //最大索引变化
            else
                return mid; // key found    //既不大也不小:找到了
        }
        return -(low + 1);  // key not found.//-插入点 - 1
    }

A:为什么会有基本类型包装类

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。

B:常用操作

常用的操作之一：用于基本数据类型与字符串之间的转换。

C:基本类型和包装类的对应

</>复制代码 
byte             Byte
short            Short
int              Integer
long             Long
float            Float
double           Double
char             Character
boolean          Boolean

</>复制代码 
    public static void main(String[] args) {
        System.out.println(Integer.toBinaryString(60));
        System.out.println(Integer.toOctalString(60));
        System.out.println(Integer.toHexString(60));
    }

A:Integer类概述

通过JDK提供的API，查看Integer类的说明

Integer 类在对象中包装了一个基本类型 int 的值,

该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，

还提供了处理 int 类型时非常有用的其他一些常量和方法

B:构造方法

public Integer(int value)

public Integer(String s)

C:案例演示

使用构造方法创建对象

</>复制代码 
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        
        Integer i1 = new Integer(100);
        System.out.println(i1);
        
        Integer i2 = new Integer("abc");//java.lang.NumberFormatException数字格式异常
        System.out.println(i2);            //因为abc不是数字字符串，所以会报错。
    }

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类的静态方法)

B:String -- int

a:String -- Integer -- int

int intValue() 以 int 类型返回该 Integer 的值。

public static int parseInt(String s)

基本数据类型包装类有八种,其中七种都有parseXxx的方法,可以将这七种的字符串表现形式转换成基本数据类型*

</>复制代码 
public class Wrap_3 {
    private static String s;
    public static void main(String[] args) {
//        demo1();
        String s = "true";
        boolean b = Boolean.parseBoolean(s);
        System.out.println(b);
        
//        String s2 = "abc";
//        char c = Character.        //char的包装类Character中没有pareseXxx的方法：char c 只能接收一个字符
                                //字符串到字符的转换通过toCharArray()就可以把字符串转换为字符数组
    }
    private static void demo1() {
        //int转换成String
        int i = 100;
        String s1 = i + "";            //推荐用第一和第二种
        String s2 = String.valueOf(i);
        
        Integer i2 = new Integer(i);
        String s3 = i2.toString();
        
        String s4 = Integer.toString(i);
        
        System.out.println(s1);
        System.out.println(s2);
        
        //String转换成int
        String s = "200";
        Integer i3 = new Integer(s);
        int i4 = i3.intValue();            //将Integer转换成了int    
        int i5 = Integer.parseInt(s);    //将String转换为int,推荐用这种
    }
}

A:JDK5的新特性

自动装箱：把基本类型转换为包装类类型

自动拆箱：把包装类类型转换为基本类型

B:案例演示

JDK5的新特性自动装箱和拆箱

</>复制代码 
int x = 100;
Integer i1 = new Integer(x);        //将基本数据类型包装成对象:装箱
int y = i1.intValue();                //将对象转换为基本数据类型:拆箱
Integer i2 = 100;                        //自动装箱,把基本数据类型转换成对象
int z = i2 + 200;                        //自动拆箱,把对象转换为基本数据类型
System.out.println(z);
Integer i3 = null;
int a = i3 + 100;                        //底层用i3调用intValue,但是i3是null,null调用方法就会出现
System.out.println(a);                    //空指针异常java.lang.NullPointerException

C:注意事项

在使用时，Integer x = null;代码就会出现NullPointerException。

建议先判断是否为null，然后再使用。

</>复制代码 
public class Wrap_JDK5_4 {
    public static void main(String[] args) {
        int x = 100;
        Integer i1 = new Integer(x);        //将基本数据类型包装成对象，手动装箱
        int y = i1.intValue();                //将对象转换成基本数据类型，拆箱
    
        Integer i2 = 100;                    //自动装箱，把基本数据类型转换成对象
        int z = i2 + 200;                    //自动拆箱，把对象转换为基本数据类型
        System.out.println(z);
        
        Integer i3 = 50;
        int a = i3 + 100;                    //底层用i3调用intValue,但是i3是null，出现空指针异常
        System.out.println(a);
    }
}

A:Integer的面试题-看程序写结果

</>复制代码 
public class Wrap_Integer_5 {
    public static void main(String[] args) {
        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 = 127;
        Integer i6 = 127;
        System.out.println(i5 == i6);//true
        System.out.println(i5.equals(i6));//true
        System.out.println("-----------");
    
        Integer i7 = 128;
        Integer i8 = 128;
        System.out.println(i7 == i8);//false
        System.out.println(i7.equals(i8));//true
        /*
         * -128到127是byte的取值范围,如果在这个取值范围内,自动装箱就不会新创建对象,而是从常量池中获取
         * 如果超过了byte取值范围就会再新创建对象
         * 
         * public static Integer valueOf(int i) {
                if (i >= IntegerCache.low && i <= IntegerCache.high)    //i>= -128 && i <= 127
                    return IntegerCache.cache[i + (-IntegerCache.low)]; //[索引:0-255] 如果传入127,索引就变成127+(-(-128)),即最大索引255
                else {
                     return new Integer(i);    
                }
            }
         */
    }
}