第二单元 常用类 --- StringBuffffer，数组操作
知识点概述
三、本单元教学目标
（Ⅰ）重点知识目标
（Ⅱ）能力目标
1.常见API有哪些
2.Scanner构造方法和成员方法
3.String有哪些常用功能
1.StringBuffer常用功能
2.StringButter与String的转换
3.冒泡排序
4.选择排序
5.了解二分查找四、本单元知识详讲
2.1 StringBuffffer概述
线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点
上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容
2.1.1 什么是StringBuffffer ★★
StringBuffffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。
每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区
中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。线程安
全的可变字符序列。
2.1.2 为什么提供StringBuffffer★★★
我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空
间。而StringBuffffer就可以解决这个问题。
2.2 StringBuffffer特点
2.2.1 StringBuffffer特点介绍★★★
StringBuffffer是使用缓冲区的，本身也是操作字符串的，但与String类不同，String类中的内容一旦
声明之后不可改变，改变的只是其内存地址的指向，而StringBuffffer中的内容是可以改变的。
对于StringBuffffer而言，本身是一个具体的操作类，所以不能像String那样采用直接赋值的方式进
行对象实例化，必须通过构造方法完成。
2.2.2 StringBuffffer和String区别★★★
1. 前者长度内容可变;后者不可变。
2. 如果使用前者做字符串的拼接，不会浪费太多的资源。
3. StringBuffffer构造方法：
演示代码如下：
1.了解StringBuffer概念与特点
2.掌握StringBuffer常用功能
3.掌握StringButter与String的转换
4.掌握数组高级的基本应用
//构造方法有很多，但是我们常用的为以下三个：
//无参构造方法
public StringBuffer()
//指定容量的字符串缓冲区对象(容器的大小)
public StringBuffer(int capacity)
//指定字符串内容的字符串缓冲区对象(字符串)
public StringBuffer(String str)
public static void main(String[] args) {
// public StringBuffer():无参构造方法运行结果：
2.3 StringBuffffer功能方法
2.3.1 添加功能★★★
演示代码如下：
StringBuffer sb = new StringBuffer();
System.out.println("sb:" + sb);
System.out.println("sb.capacity():" + sb.capacity());
System.out.println("sb.length():" + sb.length());
System.out.println("--------------------------");
// public StringBuffer(int capacity):指定容量的字符串缓冲区对象
StringBuffer sb2 = new StringBuffer(50);
System.out.println("sb2:" + sb2);
System.out.println("sb2.capacity():" + sb2.capacity());
System.out.println("sb2.length():" + sb2.length());
System.out.println("--------------------------");
// public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
StringBuffer sb3 = new StringBuffer("hello");
System.out.println("sb3:" + sb3);
System.out.println("sb3.capacity():" + sb3.capacity());
System.out.println("sb3.length():" + sb3.length());
}
//1.可以把任意类型的数据添加到字符串缓冲区里面，并返回字符串缓冲区本身。
//参数：str 拼接的字符串
public StringBuffer append(String str)
//2.在指定位置把任意类型的数据插入到字符串缓冲区里面，并返回字符串缓冲区本身。
//参数1：offset 开始位置
//参数2：str 拼接的字符串
public StringBuffer insert(int offset,String str)
public static void main(String[] args) {运行效果：
2.3.2 删除功能★★★
演示代码如下：
// 创建字符串缓冲区对象
StringBuffer sb = new StringBuffer();
// public StringBuffer append(String str)
// StringBuffer sb2 = sb.append("hello");
// System.out.println("sb:" + sb);
// System.out.println("sb2:" + sb2);
// System.out.println(sb == sb2); // true
// 一步一步的添加数据
// sb.append("hello");
// sb.append(true);
// sb.append(12);
// sb.append(34.56);
// 链式编程
sb.append("hello").append(true).append(12).append(34.56);
System.out.println("sb:" + sb);
// public StringBuffer insert(int offset,String
// str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
sb.insert(5, "world");
System.out.println("sb:" + sb);
}
//1.删除指定位置的字符，并返回本身
//参数：index 删除开始位置
public StringBuffer deleteCharAt(int index)
//2.删除从指定位置开始指定位置结束的内容，并返回本身
//参数1：start 删除开始位置
//参数2：end 删除结束位置
public StringBuffer delete(int start,int end)
public static void main(String[] args) {
// 创建对象
StringBuffer sb = new StringBuffer();
// 添加功能
sb.append("hello").append("world").append("java");
System.out.println("sb:" + sb);
// 删除指定位置的字符，并返回本身
// public StringBuffer deleteCharAt(int index)
// 需求：我要删除e这个字符，肿么办?
sb.deleteCharAt(1);
// 需求:我要删除第一个l这个字符，肿么办?运行效果：
2.3.3 替换功能★★★
演示代码如下：
运行效果：
2.3.4 反转功能★★★
sb.deleteCharAt(1);
// 删除从指定位置开始指定位置结束的内容，并返回本身
// public StringBuffer delete(int start,intend)
// 需求：我要删除world这个字符串，肿么办?
sb.delete(5, 10);
// 需求:我要删除所有的数据
sb.delete(0, sb.length());
System.out.println("sb:" + sb);
}
//替换功能
//参数1：start 开始位置
//参数2：start 结束位置
//参数3：str 替换新的字符串
public StringBuffer replace(int start, int end, String str)
public static void main(String[] args) {
// 创建字符串缓冲区对象
StringBuffer sb = new StringBuffer();
// 添加数据
sb.append("hello");
sb.append("world");
sb.append("java");
System.out.println("sb:" + sb);
// public StringBuffer replace(int start,int end,Stringstr):从start开始到end用
str替换
// 需求：我要把world这个数据替换为"节日快乐"
sb.replace(5, 10, "节日快乐");
System.out.println("sb:" + sb);
}
//反转功能
public StringBuffer reverse()演示代码如下：
运行效果：
2.3.5 截取功能★★★
演示代码如下：
运行效果：
public static void main(String[] args) {
// 创建字符串缓冲区对象
StringBuffer sb = new StringBuffer();
// 添加数据
sb.append("霞青林爱我");
System.out.println("sb:" + sb);
// public StringBuffer reverse()
sb.reverse();
System.out.println("sb:" + sb);
}
//1.截取第几个索引值之后的
//参数：start 开始位置
public String substring(int start)
//2.截取第几个索引和第几个索引之间的
//参数1：start 开始位置
//参数2：start 结束位置
public String substring(int start,int end)
public static void main(String[] args) {
// 创建字符串缓冲区对象
StringBuffer sb = new StringBuffer();
// 添加元素
sb.append("hello").append("world").append("java");
System.out.println("sb:" + sb);
// 截取功能
// public String substring(int start)
String s = sb.substring(5);
System.out.println("s:" + s);
System.out.println("sb:" + sb);
// public String substring(int start,int end)
String ss = sb.substring(5, 10);
System.out.println("ss:" + ss);
System.out.println("sb:" + sb);
}2.4 StringBuffffer和String的转换
2.4.1 StringBuffffer和String的转换★★★
为什么我们要讲解类之间的转换：
A --> B的转换：我们把A转换为B，其实是为了使用B的功能。
B --> A的转换：我们可能要的结果是A类型，所以还得转回来。
运行效果：
StringBuffffer练习：
1、把数组拼接成一个字符串
public static void main(String[] args) {
// String -- StringBuffer
String name = "hello";
// 注意：不能把字符串的值直接赋值给StringBuffer
// StringBuffer sb = "hello";
// StringBuffer sb = name;
// 方式1:通过构造方法
StringBuffer sb = new StringBuffer(name);
// 方式2：通过append()方法
StringBuffer sb2 = new StringBuffer();
sb2.append(name);
System.out.println("sb:" + sb);
System.out.println("sb2:" + sb2);
System.out.println("---------------");
// StringBuffer -- String
StringBuffer buffer = new StringBuffer("java");
// String(StringBuffer buffer)
// 方式1:通过构造方法
String str = new String(buffer);
// 方式2：通过toString()方法
String str2 = buffer.toString();
System.out.println("str:" + str);
System.out.println("str2:" + str2);
}public static void main(String[] args) {
// 定义一个数组
int[] arr = { 44, 33, 55, 11, 22 };
// 定义功能
// 方式1：用String做拼接的方式
String s1 = arrayToString(arr);
System.out.println("s1:" + s1);
// 方式2:用StringBuffer做拼接的方式
String s2 = arrayToString2(arr);
System.out.println("s2:" + s2);
}
// 用StringBuffer做拼接的方式
public static String arrayToString2(int[] arr) {
StringBuffer sb = new StringBuffer();
sb.append("[");
for (int x = 0; x < arr.length; x++) {
if (x == arr.length - 1) {
sb.append(arr[x]);
} else {
sb.append(arr[x]).append(", ");
}
}
sb.append("]");
return sb.toString();
}
// 用String做拼接的方式
public static String arrayToString(int[] arr) {
String s = "";
s += "[";
for (int x = 0; x < arr.length; x++) {
if (x == arr.length - 1) {
s += arr[x];
} else {
s += arr[x];
s += ", ";
}
}
s += "]";
return s;
}
2、把字符串反转
public static void main(String[] args) {
// 键盘录入数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入数据：");
String s = sc.nextLine();// 方式1：用String做拼接
String s1 = myReverse(s);
System.out.println("s1:" + s1);
// 方式2：用StringBuffer的reverse()功能
String s2 = myReverse2(s);
System.out.println("s2:" + s2);
}
// 用StringBuffer的reverse()功能
public static String myReverse2(String s) {
// StringBuffer sb = new StringBuffer();
// sb.append(s);
// StringBuffer sb = new StringBuffer(s);
// sb.reverse();
// return sb.toString();
// 简易版
return new StringBuffer(s).reverse().toString();
}
// 用String做拼接
public static String myReverse(String s) {
String result = "";
char[] chs = s.toCharArray();
for (int x = chs.length - 1; x >= 0; x--) {
// char ch = chs[x];
// result += ch;
result += chs[x];
}
return result;
}
3. 判断一个字符串是否是对称字符串
例如:
"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串
分析：
判断一个字符串是否是对称的字符串，我只需要把
第一个和最后一个比较
第二个和倒数第二个比较
...
比较的次数是长度除以2。
代码：
public static void main(String[] args) {
// 创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String s = sc.nextLine();
// 一个一个的比较
boolean b = isSame(s);
System.out.println("b:" + b);2.5 数组的操作
2.5.1 冒泡排序★★★★
相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处
//用字符串缓冲区的反转功能
boolean b2 = isSame2(s);
System.out.println("b2:"+b2);
}
public static boolean isSame2(String s) {
return new StringBuffer(s).reverse().toString().equals(s);
}
public static boolean isSame(String s) {
// 把字符串转成字符数组
char[] chs = s.toCharArray();
for (int start = 0, end = chs.length - 1; start <= end; start++, end--) {
if (chs[start] != chs[end]) {
return false;
}
}
return true;
}
public static boolean isSame(String s) {
boolean flag = true;
// 把字符串转成字符数组
char[] chs = s.toCharArray();
for (int start = 0, end = chs.length - 1; start <= end; start++, end--) {
if (chs[start] != chs[end]) {
flag = false;
break;
}
}
return flag;
}
public static void main(String[] args) {
// 定义一个数组
int[] arr = { 24, 69, 80, 57, 13 };
System.out.println("排序前：");
printArray(arr);
//由于我可能有多个数组要排序，所以我要写成方法
bubbleSort(arr);
System.out.println("排序后：");
printArray(arr);
}
//冒泡排序代码
public static void bubbleSort(int[] arr){
for (int x = 0; x < arr.length - 1; x++) {
for (int y = 0; y < arr.length - 1 - x; y++) {运行效果：
原理图：
2.5.2 选择排序★★★★
从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处
if (arr[y] > arr[y + 1]) {
int temp = arr[y];
arr[y] = arr[y + 1];
arr[y + 1] = temp;
}
}
}
}
// 遍历功能
public static void printArray(int[] arr) {
System.out.print("[");
for (int x = 0; x < arr.length; x++) {
if (x == arr.length - 1) {
System.out.print(arr[x]);
} else {
System.out.print(arr[x] + ", ");
}
}
System.out.println("]");
}
public static void main(String[] args) {
// 定义一个数组
int[] arr = { 24, 69, 80, 57, 13 };运行效果：
原理图：
2.5.3 了解二分查找★★★★
System.out.println("排序前：");
printArray(arr);
selectSort(arr);
System.out.println("排序后：");
printArray(arr);
}
public static void selectSort(int[] arr){
for(int x=0; x<arr.length-1; x++){
for(int y=x+1; y<arr.length; y++){
if(arr[y] <arr[x]){
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}
// 遍历功能
public static void printArray(int[] arr) {
System.out.print("[");
for (int x = 0; x < arr.length; x++) {
if (x == arr.length - 1) {
System.out.print(arr[x]);
} else {
System.out.print(arr[x] + ", ");
}
}
System.out.println("]");
}1. 查找：
首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相
等，则查找成功；否则利用中间位置录记录将表分成前、后两个子表，如果中间位置记录的关键字
大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满
足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
2. 分析：
A:定义最大索引，最小索引
B:计算出中间索引
C:拿中间索引的值和要查找的值进行比较
相等：就返回当前的中间索引
不相等：
大 左边找
小 右边找
D:重新计算出中间索引
大 左边找
max = mid - 1;
小 右边找
min = mid + 1;
E:回到B
3. 代码：
public static void main(String[] args) {
//定义一个数组
int[] arr = {11, 22, 33, 44, 55, 66, 77};
//写功能实现
int index = getIndex(arr, 33);
System.out.println("index:" + index);
//假如这个元素不存在后有什么现象呢?
index = getIndex(arr, 333);
System.out.println("index:" + index);
}
/*
* 两个明确：
* 返回值类型：int
* 参数列表：int[] arr,int value
*/
public static int getIndex(int[] arr, int value) {
//定义最大索引，最小索引
int max = arr.length - 1;
int min = 0;
//计算出中间索引
int mid = (max + min) / 2;
//拿中间索引的值和要查找的值进行比较
while (arr[mid] != value) {
if (arr[mid] > value) {
max = mid - 1;
} else if (arr[mid] < value) {
min = mid + 1;
}
//加入判断
if (min > max) {
return -1;
}4. 运行效果：
5. 原理图：
mid = (max + min) / 2;
}
return mid;
}
1.StringBuffer常用功能
添加功能
删除功能
替换功能
反转功能
截取功能
2.StringButter与String的转换
3.冒泡排序
4.选择排序
5.了解二分查找（Ⅰ）课后作业
