第十三天
1. StringBuffer(掌握)
(1)说明：
用字符串做拼接，比较耗时并且也耗内存，而这种拼接操作又是比较常见的，
为了解决这个问题，Java就提供了
一个字符串缓冲区类。StringBuffer供我们使用。
为线程安全的可变字符序列
(2)StringBuffer的构造方法
A: public StringBuffer() ：无参构造方法（默认容量16个字符）
B: public StringBuffer(int capacity) ：指定容量的字符串缓冲区对象
C: public StringBuffer(String str) ：指定字符串内容的字符串缓冲区对象
（理论容量 = 字符串长度 + 默认容量16个字符）
(3)StringBuffer的常见功能
A:添加功能
public StringBuffer append(String str) :
可以把任意类型数据添加到字符串缓冲区里面，并返回字符串缓冲区本身
public StringBuffer insert(int offset, String str) :
在指定位置把任意类型的数据插入到字符串缓冲区里面，并返回字符串缓冲区本身
B:删除功能
public StringBuffer deleteCharAt(int index):
删除指定位置的字符（只删除一个字符），并返回缓冲区本身
public StringBuffer delete(int start, int end) ：
删除从指定位置开始到到指定结束位置的内容，并返回缓冲区本身
C:替换功能
public StringBuffer replace(int start, int end, String str):
从start 开始到end用 str 进行替换
D:反转功能
public StringBuffer reverse():字符串反转
E:截取功能(注意这个返回值)
注意：截取的子串返回给一个新串，原串没有被改变
public String substring(int start)
public String substring(int start, int end)
F:其他方法:
public int capacity() : 返回当前容量。理论值
public int length(): 返回长度（字符数）。实际值
(4)StringBuffer的练习(做一遍)
A:String和StringBuffer相互转换？
String -- > StringBuffer
方式1：通过构造方法
方式2：通过append方法
StringBuffer --> String
方式1：通过构造方法
方式2：通过 toString() 方法
/* * 为什么我们要讲解类之间的转换： * A -- B的转换 * 我们把A转换为B，其实是为了使用B的功能。 * B -- A的转换 * 我们可能要的结果是A类型，所以还得转回来。 * * String和StringBuffer的相互转换? */ public class MainDemo { public static void main(String[] args) { // String --- StringBuffer String s = "hello"; // 注意：不能把字符串的值直接赋值给StringBuffer // StringBuffer sb = "hello"; // StringBuffer sb = s; // 方式1:通过构造方法 StringBuffer sb = new StringBuffer(s); // 方式2：通过append()方法 StringBuffer sb2 = new StringBuffer(); sb2.append(s); 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); } } |
B:字符串的拼接
/* * 需求：把数组拼接成一个字符串 */ public class MainDemo { 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; } } |
C:把字符串反转
package cn.itcast01;
import java.util.Scanner; /* * 需求：把字符串反转 */ public class MainDemo { 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; } } |
D:判断一个字符串是否对称
import java.util.Scanner; /* * 需求：判断一个字符串是否是对称字符串 * 例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串 * * 分析： * 判断一个字符串是否是对称的字符串，我只需要把 * 第一个和最后一个比较 * 第二个和倒数第二个比较 * ... * 比较的次数是长度除以2。 */ public class MainDemo { 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);
// 用字符串缓冲区的反转功能 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; } } |
(5)面试题
小细节：
StringBuffer：同步的，线程安全的、数据安全，效率低。
StringBuilder：不同步的，数据不安全，效率高。
A:String,StringBuffer,StringBuilder的区别？
答：
1. String：长度和内容不可变
2. StringBuffer 和 StringBuilder 都是长度和内容可变的
3.String Buffer 是同步的，数据安全，效率低，；而StringBuilder是不同步的，数据不 安全，效率搞
B:StringBuffer和数组的区别?
答：
二者都可以看着是一个容器，都可以装其他的数据
但是呢，StringBuffer 的数据最终是一个字符串数据，
而数据可以放置多种数据，但必须都是同一种数据类型
(6)注意的问题：
1. String作为形式参数，效果和基本类型作为形式参数传递是一样的
形式参数的改变不影响实际参数
- StringBuffer作为形式参数。赋值不改变实际值，但是调用其方法进行的值更改，则
会改变实际值
2. 数组高级以及Arrays(掌握)
(1)排序
A:冒泡排序
相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处。
同理，其他的元素就可以排好。
注意：第一次比较完之后，下一次比较的时候，就会减少一个元素的比较
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++) { if (arr[y] > arr[y + 1]) { int temp = arr[y]; arr[y] = arr[y + 1]; arr[y + 1] = temp; } } } } |
B:选择排序
把0索引的元素，和索引1以后的元素都进行比较，第一次完毕，
最小值出现在了0索引。同理，其他的元素就可以排好。
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; } } } } |
(2)查找
A:基本查找
使用场景：针对数组无序的情况（从头找到尾）
public static int getIndex(int[] arr, int value) { int index = -1;
for (int x = 0; x < arr.length; x++) { if (arr[x] == value) { index = x; break; } } return index; } |
B:二分查找(折半查找)
应用场景：针对数组有序的情况
注意事项：针对无序的数组，进行先排序，后查找，是有问题的？
答：因为数组本身是无序的，所以这种情况下不能使用二分查找
所以你先排序了，但是你排序的时候已经改变了该数组最初是的元素索引
public static int binarySearch(int[] arr, int value) { // 定义最小索引 int min = 0; // 定义最大索引 int max = arr.length - 1; // 计算中间索引 int mid = (min + max) / 2; // 拿中间索引的值和被查找的值进行比较 while (arr[mid] != value) { // 如果中间索引的值 比 被查找的值大了 // 则最大索引 = 原中间索引 - 1 if (arr[mid] > value) { max = mid - 1; // 如果中间索引的值 比 被查找的值小了 // 则最小索引 = 中间索引 + 1 } else if (arr[mid] < value) { min = mid + 1; } // 加入判断（如果没有该值的处理） if (min > max) { return -1; }
mid = (min + max) / 2; }
return mid; } |
(3)Arrays工具类
A:是针对数组进行操作的工具类。包括排序和查找等功能。
B:要掌握的方法(自己补齐方法)
1：public static String toString(int[] a) : 把数组转成字符串
2：public static void sort(int[] a) : 对数组进行排序
3：public static int binarySearch(int[] a, int key)：二分查找，返回查找值的索引
- Arrays工具类的源码解析
Public static String toString(int[] a) 的源码分析
public static int binarySearch(int[] a, int key)源码分析
public static String toString(int[] a)源码分析
public static void sort(int[] a) 底层是快速排序，知道就可以了。有空看，有问题再问我
public static int binarySearch(int[] a,int key)
开发原则：
只要是对象，我们就要判断该对象是否为null。
int[] arr = { 24, 69, 80, 57, 13 };
System.out.println("排序前：" + Arrays.toString(arr));
// 这是源码
public static String toString(int[] a) {
// a -- arr -- { 24, 69, 80, 57, 13 }
if (a == null)
return "null"; // 说明数组对象不存在
int iMax = a.length - 1; // iMax=4;
if (iMax == -1)
return "[]"; // 说明数组存在,但是没有元素。
StringBuilder b = new StringBuilder();
b.append('['); // "["
for (int i = 0;; i++) {
b.append(a[i]); // "[24, 69, 80, 57, 13"
if (i == iMax)
// "[24, 69, 80, 57, 13]"
return b.append(']').toString();
b.append(", "); // "[24, 69, 80, 57, "
}
}
public static int binarySearch(int[] a, int key)源码分析
int[] arr = {13, 24, 57, 69, 80};
System.out.println("binarySearch:" + Arrays.binarySearch(arr, 577));
// 源码
public static int binarySearch(int[] a, int key) {
// a -- arr -- {13, 24, 57, 69, 80}
// key -- 577
return binarySearch0(a, 0, a.length, key);
}
private static int binarySearch0(int[] a, int fromIndex, int toIndex, int key) {
// a -- arr -- {13, 24, 57, 69, 80}
// fromIndex -- 0
// toIndex -- 5
// key -- 577
int low = fromIndex; // low=0
int high = toIndex - 1; // high=4
while (low <= high) {
int mid = (low + high) >>> 1; // mid=2,mid=3,mid=4
int midVal = a[mid]; // midVal=57,midVal=69,midVal=80
if (midVal < key)
low = mid + 1; // low=3,low=4,low=5
else if (midVal > key)
high = mid - 1;
else
return mid; // key found
}
return -(low + 1); // key not found.
}
(5)把字符串中的字符进行排序
举例：
"edacbgf"
得到结果
"abcdefg"
3. Integer(掌握)
(1)说明：
为了让基本类型的数据进行更多的操作，Java就为每种基本类型提供了对应的包装类类型
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
(2)Integer的构造方法
A: Integer i = new Integer(100);
B: Integer i = new Integer("100");
注意：这里的字符串必须是由数字字符组成
(3)String和int的相互转换
A:String --> int
Integer.parseInt("100");
B:int --> String
String.valueOf(100);
(4)其他的功能(了解)
一、进制转换
1：public static String toBinaryString(int i) :二进制
2：public static String toOctalString(int i) ：八进制
3：public static String toHexString(int i) ： 十六进制
- 进制数的范围：
范围：2 - 36
因为：只有 0 -9 和 a - z 共 36个数字和字母
三、十进制 到 其他进制
1: public static String toString(int i, int radix):
参数说明：i ：表示10进制值
Radix：表示进制
例如：Integer.toString(100, 8); 表示把 10进制的100 转成 8进制
Integer.toString(100, 16); 表示把 10进制的100 转成16进制
- 其他进制 到 十进制
1：public static int parseInt(String s, int radix)
例如： Integer.parseInt("100", 2); 表示把二进制的100转成10进制
Integer.parseInt("67", 8); 表示把8进制的67转成10进制
(5)JDK5的新特性
自动装箱 基本类型--包装类型
自动拆箱 包装类型--基本类型
注意一个小问题：
在使用，Integer x = null; 代码会出现 NullPointException异常
建议：先判断是否为 null， 然后再使用
把下面的这个代码理解即可：
Integer i = 100;
i += 200;
// 通过反编译后的代码
// Integer ii = Integer.valueOf(100); //自动装箱
// ii = Integer.valueOf(ii.intValue() + 200); //自动拆箱，再自动装箱
// System.out.println((new StringBuilder("ii:")).append(ii).toString());
(6)面试题
结论：对Integer类型的数据直接赋值的时候，如果在-128 到 127 之间的，
会直接从缓冲池里面获取数据，否则重新创建一个Integer对象并返回
/*
* 看程序写结果
*
* 注意：Integer的数据直接赋值，如果在-128到127之间，会直接从缓冲池里获取数据
*/
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1 == i2);//false
System.out.println(i1.equals(i2));//true
System.out.println("-----------");
Integer i3 = new Integer(128);
Integer i4 = new Integer(128);
System.out.println(i3 == i4);//false
System.out.println(i3.equals(i4));//true
System.out.println("-----------");
Integer i5 = 128;
Integer i6 = 128;
System.out.println(i5 == i6);//false
System.out.println(i5.equals(i6));//true
System.out.println("-----------");
Integer i7 = 127;
Integer i8 = 127;
System.out.println(i7 == i8);//true 关键点
System.out.println(i7.equals(i8));//false
// 通过查看源码，我们就知道了，针对-128到127之间的数据，做了一个数据缓冲池，如果数据是该范围内的，每次并不创建新的空间
// Integer ii = Integer.valueOf(127);
4. Character(了解)
(1)Character构造方法
Character ch = new Character('a');
(2)要掌握的方法：(自己补齐)
A:判断给定的字符是否是大写字符
public static boolean isUpperCase(char ch)
B:判断给定的字符是否是小写字符
public static boolean isLowerCase(char ch)
C:判断给定的字符是否是数字字符
public static boolean isDigit(char ch)
D:把给定的字符转成大写字符
public static char toUpperCase(char ch)
E:把给定的字符转成小写字符
public static char toLowerCase(char ch)
(3)案例：
统计字符串中大写，小写及数字字符出现的次数
import java.util.Scanner;
/*
* 统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。
(不考虑其他字符)
*
* 分析：
* A:定义三个统计变量。
* int bigCont=0;
* int smalCount=0;
* int numberCount=0;
* B:键盘录入一个字符串。
* C:把字符串转换为字符数组。
* D:遍历字符数组获取到每一个字符
* E:判断该字符是
* 大写 bigCount++;
* 小写 smalCount++;
* 数字 numberCount++;
* F:输出结果即可
*/
public class MainDemo {
public static void main(String[] args) {
// 定义三个统计变量。
int bigCount = 0;
int smallCount = 0;
int numberCount = 0;
// 键盘录入一个字符串。
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String line = sc.nextLine();
// 把字符串转换为字符数组。
char[] chs = line.toCharArray();
// 历字符数组获取到每一个字符
for (int x = 0; x < chs.length; x++) {
char ch = chs[x];
// 判断该字符
if (Character.isUpperCase(ch)) {
bigCount++;
} else if (Character.isLowerCase(ch)) {
smallCount++;
} else if (Character.isDigit(ch)) {
numberCount++;
}
}
// 输出结果即可
System.out.println("大写字母：" + bigCount + "个");
System.out.println("小写字母：" + smallCount + "个");
System.out.println("数字字符：" + numberCount + "个");
}
}