Java基础之常见对象

StringBuffer

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

• A:StringBuffer类概述
  
  • 通过JDK提供的API，查看StringBuffer类的说明
  • 线程安全的可变字符序列
• B:StringBuffer和String的区别
  
  • String是一个不可变的字符序列
    *StringBuffer是一个可变的字符序列

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

• A:StringBuffer的构造方法：
  
  • public StringBuffer():无参构造方法
  • publicStringBuffer(int capacity):指定容量的字符串缓冲区对象
  • publicStringBuffer(String str):指定字符串内容的字符串缓冲区对象
• B:StringBuffer的方法：
  
  • public intcapacity()：返回当前容量。理论值(不掌握)
  • public intlength():返回长度（字符数）。 实际值
• C:案例演示
  
  • 构造方法和长度方法的使用

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

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

13.04_常见对象(StringBuffer的删除功能)

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

13.05_常见对象(StringBuffer的替换和反转功能)

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

13.06_常见对象(StringBuffer的截取功能及注意事项)

• A:StringBuffer的截取功能
  
  • publicString substring(int start):
    
    • 从指定位置截取到末尾
  • publicString 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:面试题
  *String,StringBuffer,StringBuilder的区别

  • StringBuffer和StringBuilder的区别
    *StringBuffer是jdk1.0版本的,是线程安全的,效率低
    *StringBuilder是jdk1.5版本的,是线程不安全的,效率高

  • String和StringBuffer,StringBuilder的区别

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

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

• A:形式参数问题
  
  • String作为参数传递
    *StringBuffer作为参数传递
• B:案例演示
  
  • String和StringBuffer分别作为参数传递问题

13.12_常见对象(数组高级冒泡排序原理图解)

• A:画图演示
  *
  需求：
  数组元素：{24,69, 80, 57, 13}
  请对数组元素进行排序。

      冒泡排序
          相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处
  

1
2
3
4
5
6
7
8
9
10
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);
}
}
}

13.14_常见对象(数组高级选择排序原理图解)

• A:画图演示

  • 需求：

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

    • 请对数组元素进行排序。

    • 选择排序

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

1
2
3
4
5
6
7
8
9
10
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]) {
/*int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;*/
swap(arr,i,j);
}
}
}

13.17_常见对象(数组高级二分查找代码实现及注意事项)

• A:案例演示
  
  • 数组高级二分查找代码
• B:注意事项
  
  • 如果数组无序，就不能使用二分查找。
    
    • 因为如果你排序了，但是你排序的时候已经改变了我最原始的元素索引。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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) {                          //如果最小索引大于了最大索引,就没有查找的可能性了
            return -1;                          //返回-1
        }
    }
    return mid;
}

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

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

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:构造方法
  
  • publicInteger(int value)
  • publicInteger(String s)
• C:案例演示
  
  • 使用构造方法创建对象

13.21_常见对象(String和int类型的相互转换)

• A:int – String
  
  • a:和”“进行拼接
  • b:publicstatic String valueOf(int i)
  • c:int –Integer – String(Integer类的toString方法())
  • d:publicstatic String toString(int i)(Integer类的静态方法)
• B:String – int
  
  • a:String –Integer – int
  • publicstatic int parseInt(String s)

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

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

• B:案例演示

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

  • Integer ii= 100;

  • ii += 200;
• C:注意事项
  
  • 在使用时，Integer x = null;代码就会出现NullPointerException。
  • 建议先判断是否为null，然后再使用。

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

• A:Integer的面试题
  *

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
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);
System.out.println(i7.equals(i8));          //true

/*
 * -128到127是byte的取值范围,如果在这个取值范围内,自动装箱就不会新创建对象,而是从常量池中获取
 * 如果超过了byte取值范围就会再新创建对象
 * 源码分析:
 * public static Integer valueOf(int i) {
        assert IntegerCache.high >= 127;
        if (i >= IntegerCache.low && i <= IntegerCache.high)          //i>= -128 && i <= 127
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
 */

}