day13-StringBuffer和数组排序查找

13.01_常见对象(StringBuffer类的概述)

• A:StringBuffer类概述
  • public final class StringBuffer extends Object
  • 线程安全的可变字符序列
• B:StringBuffer和String的区别
  • String是一个不可变的字符序列
  • StringBuffer是一个可变的字符序列

13.02_常见对象(StringBuffer类的构造方法)

• A:StringBuffer的构造方法：
  • public StringBuffer():无参构造方法
  • public StringBuffer(int capacity):指定容量的字符串缓冲区对象
  • public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
• B:StringBuffer的方法：
  • public int capacity()：返回当前容量，默认初始容量是16
  • public int length():返回长度（字符数）。 实际值

StringBuffer sb = new StringBuffer("XXOO");
System.out.println(sb.length());  //字符串长度，结果4
System.out.println(sb.capacity()); //结果20 ，字符串length + 初始容量

13.03_常见对象(StringBuffer的添加功能)

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

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

StringBuffer sb = new StringBuffer("1234");
sb.insert(3, "xxoo");   // 指定位置添加，注意这里可能出现越界情况
System.out.println(sb); // 123xxoo4

13.04_StringBuffer的删除功能

• public StringBuffer deleteCharAt(int index):
  删除指定位置的字符，并返回本身（有越界情况）

• public StringBuffer delete(int start,int end):
  删除从指定位置开始指定位置结束的内容，并返回本身，包含头不包含尾（开闭区间），
  System.out.println(sb.capacity()); //结果20 ，字符串length + 初始容量

• 清空缓存区： sb.delete(0, sb.length());

13.05_StringBuffer的替换和反转功能

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

13.06_StringBuffer的截取功能及注意事项

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

13.07_StringBuffer和String的相互转换

• A:String --> StringBuffer
  • a:通过构造方法
  • b:通过append()方法
• B:StringBuffer --> String
  • a:通过构造方法
  • b:通过toString()方法
  • c:通过subString(0,length);

13.10_StringBuffer和StringBuilder的区别

• A:StringBuilder的概述
  • 通过查看API了解一下StringBuilder类
• B:面试题

  • StringBuffer和StringBuilder的区别???

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

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

  • String和StringBuffer,StringBuilder的区别???

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

  • StringBuffer,StringBuilder是可变的字符序列

13.11_常见对象(String和StringBuffer分别作为参数传递)

• String类虽然是引用数据类型，但是它当参数传递时则和基本数据类型一样
• StringBuffer和StringBuilder做为参数传递时，却和其他普通引用数据类型一样，会被方法体内改变。

13.12_数组冒泡排序 和 选择排序

排序思想.png

冒泡排序是最基本的排序方法，必须会的。直接代码：

int[] array = {12,2,56,23,14,89,34,11};

// 外循环只需要比较 array.length - 1 次就可以了
for (int i = 0; i < array.length - 1; i++) {
    // -1为了防止越界，-i为了提高效率
    for (int j = 0; j < array.length - 1 - i; j++) { 
        if (array[j] > array[j+1]) {
            int temp = array[j];
            array[j] = array[j+1];
            array[j+1] = temp ;
        }
    }
}  //冒泡排序的写法不唯一，但是只要思路一样都是可以的。

13.14_选择排序

int[] arr = {9,6,3,7,1,4,0,2};

for (int i = 0; i < arr.length -1; i++) {
    for (int j = i+1 ; j < arr.length; j++) {
        if (arr[i] > arr[j]) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp ;
        }
    }
} //选择排序的写法不唯一，但是只要思路一样都是可以的。

13.16_数组高级二分查找

• 二分查找 --> 前提：数组元素有序。如果数据无序，就不能使用二分查找法！！！

二分查找图解.png

public static int getIndexFromArray(int[] arr, int value) { //二分查找方法
    if(arr.length == 0) return -1 ;
    
    int min = 0;
    int max = arr.length - 1 ;
    int mid = (int) ((min + max) * 0.5);
    
    while (arr[mid] != value) {
        
        if (arr[mid] < value) { // 1.中间值小于value的情况: 说明在mid右边
            min = mid + 1 ;
        }else { // 2.中间值大于value： 说明在mid左边
            max = mid - 1;
        }
        
        //min大于max就越界了，就是没找到的情况
        if (min > max)  return -1 ;

        mid = (int) ((min + max) * 0.5);
    }
    
    return mid;
}

13.18_常见对象(Arrays类的概述和方法使用)

• A:Arrays类概述
  • 针对数组进行操作的工具类（工具类是私有构造方法的，不能new对象）
  • 提供了排序，查找等功能，里面的功能非常多的，建议查看API

int[] arr = {11,66,22,99,33,22};
        
// 1.数组转字符串输出
System.out.println(Arrays.toString(arr));

// 2.数组排序(从小到大)
Arrays.sort(arr); //底层是快速排序法
System.out.println(Arrays.toString(arr));

// 3.二分查找（前提是有序数组）
System.out.println(Arrays.binarySearch(arr, 66));
System.out.println(Arrays.binarySearch(arr, 100)); //找不到，返回 -(插入点-1)

13.19_常见对象(基本类型包装类的概述)

• A:为什么会有基本类型包装类
  • 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
• B:常用操作
  • 常用的操作之一：用于基本数据类型与字符串之间的转换。
• C:基本类型和包装类的对应

•   byte            Byte
    short           Short
    int           Integer
    long             Long
    float           Float
    double          Double
    char              Character
    boolean         Boolean
  

八种基本数据类型包装类，其中其中都有parseXxx的方法，可以将这七种字符串转为为对应的基本数据类型(Character没有这个方法，字符串通过toCharArray()就可以转为字符数组)

13.20_Integer类的概述和构造方法

• A:Integer类概述
  • 通过JDK提供的API，查看Integer类的说明
  • Integer 类在对象中包装了一个基本类型 int 的值,
  • 该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，
  • 还提供了处理 int 类型时非常有用的其他一些常量和方法
• B:构造方法
  • public Integer(int value)
  • public Integer(String s)

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类的静态方法)
• B:String --> int
  • a:String --> Integer --> int
  • public static int parseInt(String s)

13.22_常见对象(JDK5的新特性自动装箱和拆箱)

• A:JDK5的新特性
  • 自动装箱：把基本类型转换为包装类类型
  • 自动拆箱：把包装类类型转换为基本类型

Integer ii = 100 ;  //自动装箱，不用new对象去创建了
ii ++ ;             //自动拆箱，不用intValue()去显示转int了
System.out.println(ii);

// 在使用时，Integer  x = null;代码就会出现NullPointerException。
// 建议先判断是否为null，然后再使用。

13.23_常见对象(Integer的面试题)

// ---- 面试题 ----
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("-----------1");

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("-----------2");

Integer i5 = 97;
Integer i6 = 97;
System.out.println(i5 == i6);  //true
System.out.println(i5.equals(i6)); //true
System.out.println("-----------3");

Integer i7 = 197;
Integer i8 = 197;
System.out.println(i7 == i8); //false
System.out.println(i7.equals(i8)); //true

//-128到127是byte的取值范围，如果在这个取值范围，自动装箱就不会
//新创建对象，而是从常量池中获取，如果超过了byte的范围，才会创建对象

END。
我是小侯爷。
在魔都艰苦奋斗，白天是上班族，晚上是知识服务工作者。
如果读完觉得有收获的话，记得关注和点赞哦。
非要打赏的话，我也是不会拒绝的。