javaSE第十三天

第十三天 76

1. StringBuffer(掌握) 76

(1)说明： 77

(2)StringBuffer的构造方法 77

(3)StringBuffer的常见功能 77

(4)StringBuffer的练习(做一遍) 78

(5)面试题 82

(6)注意的问题： 83

2. 数组高级以及Arrays(掌握) 83

(3)String和int的相互转换 89

第十三天

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);

：通过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);

：通过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 };

// 定义功能

：用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();

：用String做拼接

String s1 = myReverse(s);

System.out.println("s1:" + s1);

：用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"是对称字符串

* 分析：

* 判断一个字符串是否是对称的字符串，我只需要把

* 第一个和最后一个比较

* 第二个和倒数第二个比较

* ...

。

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 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

之间的数据，做了一个数据缓冲池，如果数据是该范围内的，每次并不创建新的空间

// 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 + "个");

}