StringBuffer-数组处理类
目录
StringBuffer类
-
StringBuffer类的概述：
- 线程安全的可变字符序列
-
StringBuffer和String的区别：
- String是一个不可变的字符序列
- StringBuffer是一个可变的字符序列
-
StringBuffer的构造方法：
-
public StringBuffer():无参构造方法
StringBuffer sb = new StringBuffer(); System.out.println(sb.length()); //容器的字符个数，实际值 System.out.println(sb.capacity()); //容器的初始容量，理论值 输出结果：0 16 -
public StringBuffer(int capacity):指定容量的字符串缓冲区对象
StringBuffer sb2 = new StringBuffer(10); System.out.println(sb2.length()); //容器的字符个数，实际值 System.out.println(sb2.capacity()); //容器的初始容量，理论值 输出结果：0 10 -
public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
StringBuffer sb3 = new StringBuffer("heima"); System.out.println(sb3.length()); //容器的字符个数，实际值 System.out.println(sb3.capacity()); //字符串的length + 初始容量 输出结果：5 21
-
StringBuffer的添加功能
-
public StringBuffer append(String str):可以把任意类型数据添加到字符串缓冲区里面，并返回字符串缓冲区本身
StringBuffer sb = new StringBuffer(); StringBuffer sb2 = sb.append(true); StringBuffer sb3 = sb.append("heima"); StringBuffer sb4 = sb.append(100); System.out.println(sb.toString()); //StringBuffer类中重写了toString方法，显示的是对象中的属性值 System.out.println(sb2.toString()); System.out.println(sb3.toString()); System.out.println(sb4.toString()); 输出结果：trueheima100 trueheima100 trueheima100 trueheima100 解释：StringBuffer是字符串缓冲区，当new的时候是在堆内存创建了一个对象，底层是一个长度为16的字符数组， 当调用添加的方法时，不会再重新创建对象，在不断向原缓冲区添加字符 StringBuffer sb = new StringBuffer(); System.out.println(sb.toString()); StringBuffer sb2 = sb.append(true); System.out.println(sb2.toString()); StringBuffer sb3 = sb.append("heima"); System.out.println(sb3.toString()); StringBuffer sb4 = sb.append(100); System.out.println(sb4.toString()); 输出结果： true trueheima trueheima100 -
public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面，并返回字符串缓冲区本身
StringBuffer sb = new StringBuffer("1234"); sb.insert(3,"heima"); //在指定位置添加元素，如果没有指定位置，就会报错（指定位置要在字符串中） System.out.println(sb); 输出结果：123heima4
StringBuffer的删除功能
-
public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身
StringBuffer sb = new StringBuffer(); //sb.deleteCharAt(5); //当缓冲区中没有这个索引上没有元素的时候，运行就会报错 sb.append("heima"); sb.deleteCharAt(4); //根据索引删除掉索引位置上对应的字符 System.out.println(sb); 输出结果：heim -
public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身
StringBuffer sb = new StringBuffer(); sb.append("heima"); sb.delete(0,2); //删除的时候是包含头，不包含尾 输出结果：ima sb.delete(0,sb.length()); //清空缓冲区 sb = new StringBuffer(); //不要用这种方式清空缓冲区，原来的会变成垃圾，浪费内存 System.out.println(sb);
StringBuffer的替换和反转功能
-
StringBuffer的替换功能
-
public StringBuffer replace (int start,int end, String str):从start开始到end用str替换
StringBuffer sb = new StringBuffer("heima"); sb.replace(0,3,"bai"); System.out.println(sb); 输出结果：baima
-
-
StringBuffer的反转功能
-
public StringBuffer reverse():字符串反转
StringBuffer sb = new StringBuffer("我爱总复习"); sb.reverse(); System.out.println(sb); 输出结果：习复总爱我
-
StringBuffer的截取功能及注意事项
-
StringBuffer的截取功能
-
public String substring(int start):从指定位置截取到末尾
StringBuffer sb = new StringBuffer("woaiheima"); String str = sb.substring(4); System.out.println(str); System.out.println(sb); 输出结果：heima woaiheima -
public String substring(int start,int end):截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
StringBuffer sb = new StringBuffer("woaiheima"); String str3 = sb.substring(4,7); System.out.println(str3); 输出结果：hei
-
-
注意事项：返回值类型不再是StringBuffer本身
StringBuffer和String的互相转换
-
String ----> StringBuffer
-
1、通过构造方法
-
2、通过append()方法
public static void main(String[] args) { StringBuffer sb1 = new StringBuffer("heima"); //通过构造方法将字符转换为StringBuffer对象 System.out.println(sb1); StringBuffer sb2 = new StringBuffer(); sb2.append("heima"); //通过append方法将字符串转换为StringBuffer对象 System.out.println(sb2); } 输出结果：heima heima
-
-
StringBuffer ----> String
-
1、通过构造方法
-
2、通过toString()方法 (推荐使用)
-
3、通过subString(0,length);
public static void main(String[] args) { StringBuffer sb = new StringBuffer("heima"); String s1 = new String(sb); //通过构造将StringBuffer转换为String System.out.println(s1); String s2 = sb.toString(); //通过toString方法将StringBuffer转换为String System.out.println(s2); //可以直接写出System.out.println(sb.toString()); String s3 = sb.substring(0,sb.length()); //通过截取子字符串将StringBuffer转换为String System.out.println(s3); }
-
练习
-
需求：把数组中的数据按照指定格式拼接成一个字符串
-
如：int [] arr = {1,2,3};
-
输出:[1,2,3];
public static void main(String[] args) { int [] arr = {1,2,3}; System.out.println(arrayToString(arr)); } public static String arrayToString(int [] arr) { StringBuffer sb = new STringBUffer(); //创建字符串缓冲区对象 sb.append("["); //将[添加到缓冲区 for(int i = 0;i < arr.length;i ++) { if(i == arr.length - 1) { sb.append(arr[i].append("]")); }else { sb.append(arr[i]).append(","); } } return sb.toString(); } 输出结果：[1,2,3]
-
-
字符串反转
import java.util.Scanner; class test { public static void main(String [] args) { Scanner sc = new Scanner(System.in); //创建键盘录入对象 String line = sc.nextLine(); //将键盘录入的字符串存储在line中 StringBuffer sb = new StringBuffer(line); //将字符串转换为StringBuffer对象 sb.reverse(); //将缓冲区的内容反转 System.out.println(sb.toString()); } } 输出结果:abc cba
面试题（String、StringBuffer和StringBuilder的区别）
-
StringBuffer和StringBuilder的区别
- StringBuffer是jdk1.0版本的，是线程安全的（同步），效率低
- StringBuilder是jdk1.5版本的，是线程不安全的（不同步），效率高
-
String、StringBuffer和StringBuilder的区别
- String是一个不可变的字符序列
- StringBUffer，StringBuilder是可变的字符序列
String和StringBuffer分别作为参数传递
-
基本数据类型的值传递，不改变其值
-
引用数据类型的值传递，改变其值
public static void main(String[] args) { String s = "heima"; System.out.println(s); change(s); System.out.println(s); } public static void change(String s) { //执行完该方法后，s = heimaitcast //但是，方法执行完事要弹栈的，对于主方法的S来说，S是没有发生改变的 s += "itcast"; } 输出结果：heima heima 解释：String类虽然是引用类型，但是他当作参数传递时和基本数据类型是一样的 /**************************************/ public static void main(String[] args) { StringBuffer sb = new StringBuffer(); sb.append("heima"); System.out.println(sb); change(sb); System.out.println(sb); } public static void change(StringBuffer sb) { sb.append("itcast"); } 输出结果：heima heimaitcast
数组高级冒泡排序代码实现
public static void main(String[] args) {
int[] arr = {24,69,80,57,13};
bubbleSort(arr);
print(arr);
}
public static void bubbleSort(int[] arr) {
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;
}
}
}
}
public static void print(int[] arr) {
for(int i = 0; i < arr.length; i ++) {
System.out.println(arr[i] + " ");
}
}
输出结果：13 24 57 69 80
数组高级选择排序
public static void main(String[] args) {
int[] arr = {24,69,80,57,13};
selectSort(arr);
print(arr);
}
public static void selectSort(int[] arr) {
for(int i = 0; i < arr.length - 1 ; i++) { // 外循环只需比较arr.length-1 次就可以了
for(int j = i + 1; j < arr.length; j ++) { // -1为了防止索引越界，-i为了提高效率
if(arr[i] > arr[j]) {
int temp = arr[j];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
public static void print(int[] arr) {
for(int i = 0; i < arr.length; i ++) {
System.out.println(arr[i] + " ");
}
}
输出结果：13 24 57 69 80
数组高级二分查找
public static void main(String[] args) {
int[] arr = {11,22,33,44,55,66,77};
System.out.println(getIndex(arr,22));
System.out.println(getIndex(arr,66));
System.out.println(getIndex(arr,88));
}
public static int getIndex(int [] arr,int value) {
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
}
}
}
输出结果：1
5
-1
Arrays类的概述和方法使用
import java.util.Arrays;
public class Demo_Arrays {
public static void main(String[] args) {
int[] arr = {33,22,11,44,66,55};
System.out.println(Arrays.toString(arr)); //数组转字符串
Arrays.sort(arr); //排序
System.out.println(Arrays.toString(arr));
int[] arr2 = {11,22,33,44,55,66};
System.out.println(Arrays.binarySearch(arr2,22));
System.out.println(Arrays.binarySearch(arr2,66));
System.out.println(Arrays.binarySearch(arr2,88)); //-（插入点的值）-1
}
}
输出结果：[33,22,11,44,66,55]
[11,22,33,44,55,66]
1
5
-2
基本类型包装类的概述
-
基本类型和包装类的对应
byte Byte short Short int Integer long Long float Float double Double char Character boolean Boolean public static void main(String[] args) { System.out.println(Integer.toBinaryString(60)); //把60转成二进制 System.out.println(Integer.toOctalString(60)); //把60转成八进制 System.out.println(Integer.toHexString(60)); //把60转成十六进制 } 输出结果：111100 74 3c
Integer类的概述和构造方法
- 构造方法
-
public Integer(int value)
-
public Integer(String s)
Integer i1 = new Integer(100); System.out.println(i1); 输出结果：100 Integer i2 = new Integer("100"); System.out.println(i2); 输出结果：100 Integer i3 = new Integer("abc"); //运行报错！ 因为abc不是数字字符串，所以转换会报错 System.out.println(i3); 输出结果：报错！数字格式异常
-
String与int的相互转换
-
int ----> String
-
1、和""进行拼接 (推荐使用)
int i = 100; String s1 = i + ""; System.out.println(s1); 输出结果：100 (这是一个数字字符串) -
2、public static String valueOf(int i)（推荐使用）
int i = 100; String s2 = String.valueOf(i); System.out.println(s1); 输出结果：100 (这是一个数字字符串) -
3、int -- Integer -- String(Integer类的toString()方法)
int i = 100; Integer i2 = new Integer(i); String s3 = i2.toString(); System.out.println(s3); 输出结果：100 (这是一个数字字符串) -
4、public static String toString(int i)(Integer类的静态方法)
int i = 100; String s4 = Integer.toString(i); System.out.println(s4); 输出结果：100 (这是一个数字字符串)
-
-
String ----> int
-
public static String toString(String s)(推荐使用)
String i = "200"; int i1 = Integer.parseInt(i); System.out.println(i1); 输出结果：200 (这是一个int型数据) /******************************************************/ 注意：基本数据类型包装类有八种，其中七钟都有parseXxx的方法， 可以将这七钟的字符串表现形式转换成基本数据类型 String s1 = "true"; boolean b = Boolean.parseBoolean(s1); System.out.println(b); 输出结果：true String s2 = "abc"; char c = Character.parsechar(s2); //运行报错！char的包装类Character中没有pareseXxx的方法 字符串到字符的转换通过toCharArray()就可以把字符串转换成字符数组 -
String -- Integer -- int
String s = "200"; Integer i3 = new Integer(s); int i4 = i3.intValue(); System.out.println(i4); 输出结果：200 (这是一个int型数据)
-
JDK5的新特性自动装箱和拆箱
public static void main(String[] args) {
/*以前的写法
int x = 100;
Integer i1 = new Integer(x);//装箱
int y = i1.intValue();//拆箱
*/
Integer i2 = 100;//将基本数据类型包装成对象，自动装箱
int z = i2 + 200;//将对象装换为基本数据类型，自动拆箱
System.out.println(z);
}
输出结果：300
Integer面试题
public static void main(String[] args) {
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 = 97;
Integer i6 = 97;
System.out.println(i5 == i6); //true
System.out.println(i5.equals(i6)); //true
System.out.println("-----------------");
Integer i7 = 197;
Integer i8 = 197;
System.out.println(i7 == i8); //false
System.out.println(i7.equals(i8)); //true
System.out.println("-----------------");
Integer a = 127;
Integer b = 127;
System.out.println(a == b); // true
System.out.println(a.equals(b)); //true
System.out.println("-----------------");
Integer a1 = 128;
Integer b1 = 128;
System.out.println(a1 == b1); //false
System.out.println(a1.equals(b1)); //true
System.out.println("-----------------");
}
注意：-128到127是byte的取值范围，如果在这个取值范围内，
自动装箱就不会新创建对象，而是从常量池中获取。
如果超过了byte取值范围就会再创建新对象。
