4.4 StringBuffer
4.4.1 了解StringBuffer
SringBuffer:线程安全的可变字符串。跟String相比,使用StringBuffer做字符串的拼接不会浪费太多资源。
4.4.2 构造方法
public StringBuffer():无参构造方法
public StringBuffer(int capacity):指定容量的字符串缓冲区对象
public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
两个常见的方法:
public int capacity():返回当前容量。理论值
public int length():返回长度(字符数)。 实际值
public class StringBufferDemo {
public static void main(String[] args) {
// public StringBuffer():无参构造方法
StringBuffer sb = new StringBuffer();
System.out.println("sb:" + sb);
System.out.println("sb.length():" + sb.length());
System.out.println("sb.capacity():" + sb.capacity());
System.out.println("-----------------");
//public StringBuffer(int capacity):指定容量的字符串缓冲区对象
StringBuffer sb2 = new StringBuffer(50);
System.out.println("sb2:" + sb2);
System.out.println("sb2.length():" + sb2.length());
System.out.println("sb2.capacity():" + sb2.capacity());
System.out.println("-----------------");
//public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
StringBuffer sb3 = new StringBuffer("hello");
System.out.println("sb3:" + sb3);
System.out.println("sb3.length():" + sb3.length());
System.out.println("sb3.capacity():" + sb3.capacity());
}
}
运行结果:
4.4.3 部分方法
1、添加功能
public StringBuffer append(String str):可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身,这里用String类型举例
public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身,这里用String类型举例
public class StringDemo {
public static void main(String[] args) {
// 创建字符串缓冲区对象
StringBuffer sb = new StringBuffer();
// public StringBuffer append(String str)
// StringBuffer sb2 = sb.append("hello");
// System.out.println("sb:" + sb);
// System.out.println("sb2:" + sb2);
/*
* sb.append("hello");
* sb.append(true);
* sb.append(123);
*/
// 链式编程
sb.append("hello").append(true).append(123);
System.out.println("sb:" + sb);
// public StringBuffer insert(int offset,String
// str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身,这里用String类型举例
sb.insert(5, "world");
System.out.println("sb:" + sb);
}
}
运行结果:
2、删除功能
public StringBuffer deleteCharAt(int index):删除指定位置的字符,并返回本身
public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容,并返回本身。包含上边界,不包含下边界
public class StringDemo {
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);
System.out.println("sb:" + sb);
//public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容,并返回本身
//包含上边界,不包含下边界。
//需求:我要删除“world”这个字符串
sb.delete(4, 9);
System.out.println("sb:" + sb);
}
}
运行结果:
3、替换功能
public StringBuffer replace(int start,int end,String str):从start开始到end用str替换
public class StringDemo {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
// 添加数据
sb.append("hello").append("world").append("java");
System.out.println("sb:" + sb);
// public StringBuffer replace(int start,int end,String
// str):从start开始到end用str替换
// 需求:把“world”替换为“节日快乐”
sb.replace(5, 10, "节日快乐");
System.out.println("sb:" + sb);
}
}
运行结果:
4、反转功能
public StringBuffer reverse()
public class StringDemo {
public static void main(String[] args) {
// 创建字符串缓冲区对象
StringBuffer sb = new StringBuffer();
// 添加数据
sb.append("我爱avaJ");
System.out.println("sb:" + sb);
sb.reverse();
System.out.println("sb:" + sb);
}
}
运行结果:
5、截取功能
public String substring(int start)
public String substring(int start,int end)
public class StringDemo {
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);
}
}
运行结果:
6、StringBuffer练习题
练习1:String和StringBuffer的互相转换
public class StringBufferTest {
public static void main(String[] args) {
// 将String转为StringBuffer
String s = "hello";
// 方式1:通过构造方法
StringBuffer sb = new StringBuffer(s);
System.out.println("sb:" + sb);
// 方式2:通过append()方法
StringBuffer sb2 = new StringBuffer();
sb2.append(s);
System.out.println("sb2:" + sb2);
System.out.println("------------");
// 将StringBuffer转为String
StringBuffer buffer = new StringBuffer("java");
// 方式1:通过构造方法
String str = new String(buffer);
System.out.println("str:" + str);
// 方式2:通过toString()方法
String str2 = buffer.toString();
System.out.println("str2:" + str2);
}
}
运行结果:
练习2:把数组拼接成一个字符串
public class StringBufferTest2 {
public static void main(String[] args) {
// 定义一个数组
int[] arr = { 44, 33, 22, 11 };
// 定义功能
// 方式1:用String拼接的方法
String s1 = arrayToString(arr);
System.out.println("s1:" + s1);
// 方式2:用StringBuffer拼接的方法
StringBuffer s2 = arrayToStringBuffer(arr);
System.out.println("s2:" + s2);
}
// 用StringBuffer做拼接
public static StringBuffer arrayToStringBuffer(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]).append("]");
} else {
sb.append(arr[x]).append(", ");
}
}
return sb;
}
// 用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];
s += "]";
} else {
s += arr[x];
s += ", ";
}
}
return s;
}
}
运行结果:
练习3:字符串反转
public class StringTest3 {
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做反转
String s2 = myReverse2(s);
System.out.println("s2:"+s2);
}
//用StringBuffer做反转
public static String myReverse2(String 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 str = "";
char[] chs = s.toCharArray();
for (int x = chs.length - 1; x >= 0; x--) {
str+=chs[x];
}
return str;
}
}
运行结果:
练习4:判断一个字符串是否对称
/*
* 判断一个字符串是否是对称字符串
* 例如"abc"不是对称字符串,"aba"、"abba"、"aaa"、"mnanm"是对称字符串
*
* 分析:
* 判断一个字符串是否是对称的字符串,我只需要把
* 第一个和最后一个比较
* 第二个和倒数第二个比较
* ...
* 比较的次数是长度除以2。
*/
import java.util.Scanner;
public class StringBufferTest4 {
public static void main(String[] args) {
// 创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入需要判断的字符串:");
String s = sc.nextLine();
boolean b1 = isSym(s);
System.out.println("b1:" + b1);
boolean b2 = isSym(s);
System.out.println("b2:" + b2);
boolean b3 = isSym(s);
System.out.println("b3:" + b3);
}
public static boolean isSym(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 isSym2(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 boolean isSym3(String s){
return new StringBuffer(s).reverse().toString().equals(s);
}
}
运行结果:
7、面试题
面试题1:String,StringBuffer,StringBuilder的区别
1)String是内容不可变的,而StringBuffer,StringBuilder都是内容可变的。
2)StringBuffer是同步的,数据安全,效率低;StringBuilder是不同步的,数据不安全,效率高
面试题2:StringBuffer和数组的区别
1)二者都可以看出是一个容器,装其他的数据。
2)StringBuffer的数据最终是一个字符串数据;而数组可以放置多种数据,但必须是同一种数据类型的。
面试题3:String作为参数传递,StringBuffer作为参数传递
看程序,写结果
public class StringBufferDemo {
public static void main(String[] args) {
String s1 = "hello";
String s2 = "world";
System.out.println(s1 + "---" + s2);
change(s1, s2);
System.out.println(s1 + "---" + s2);
StringBuffer sb1 = new StringBuffer("hello");
StringBuffer sb2 = new StringBuffer("world");
System.out.println(sb1 + "---" + sb2);
change(sb1, sb2);
System.out.println(sb1 + "---" + sb2);
}
public static void change(StringBuffer sb1, StringBuffer sb2) {
sb1 = sb2;
sb2.append(sb1);
}
public static void change(String s1, String s2) {
s1 = s2;
s2 = s1 + s2;
}
}
运行结果:
分析:形式参数为基本数据类型时,形式参数的改变不影响实际参数;为引用类型数据时,形式参数的改变直接影响实际参数。String是引用类型,但是它作为参数传递时,效果和基本数据类型是一样的。StringBuffer作为参数传递时,调用方法时情况和引用类型是一样的,但是赋值时和基本数据类型是一样的。
4.5 Integer
Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。
此外,该类提供了多个方法,能在 int 类型和 String 类型之间互相转换,还提供了处理 int 类型时非常有用的其他一些常量和方法。
4.5.1 构造方法
/*
* public Integer(int value)
* public Integer(String s)
* 注意:这个字符串必须是由数字字符组成
*/
public class IntegerDemo {
public static void main(String[] args) {
// 方式1:
int i = 100;
Integer ii = new Integer(i);
System.out.println("ii:" + ii);
//方式2:
String s = "100";
Integer iii = new Integer(s);
System.out.println("iii:"+iii);
}
}
运行结果:
4.5.2 部分成员方法
1、int类型和String类型的互相转换
/*
* int类型和String类型的相互转换
*
* int -- String
* String.valueOf(number)
*
* String -- int
* Integer.parseInt(s)
*/
public class IntegerDemo {
public static void main(String[] args) {
// int --> String
int number = 100;
// 方式1
String s1 = "" + number;
System.out.println("s1:" + s1);
// 方式2
String s2 = String.valueOf(number);
System.out.println("s2:" + s2);
// 方式3
// int --> Integer --> String
Integer i = new Integer(number);
String s3 = i.toString();
System.out.println("s3:" + s3);
// 方式4
// public static String toString(int i)
String s4 = Integer.toString(number);
System.out.println("s4:" + s4);
System.out.println("-------------");
//String --> int
String s = "100";
//方式1
//String --> Integer --> Int
Integer ii = new Integer(s);
//public int intValue()
int x1 = ii.intValue();
System.out.println("x1:"+x1);
//方式2
int x2 = Integer.parseInt(s);
System.out.println("x2:"+x2);
}
}
运行结果:
2、十进制和其他进制之间的互相转换
/*
* 常用的基本进制转换
* public static String toBinaryString(int i)
* public static String toOctalString(int i)
* public static String toHexString(int i)
*
* 十进制到其他进制
* public static String toString(int i,int radix)
* 由这个我们也看到了进制的范围:2-36
* 为什么呢?0,...9,a...z
*
* 其他进制到十进制
* public static int parseInt(String s,int radix)
*/
public class IntegerDemo {
public static void main(String[] args) {
// 十进制到二进制,八进制,十六进制
System.out.println(Integer.toBinaryString(100));
System.out.println(Integer.toOctalString(100));
System.out.println(Integer.toHexString(100));
System.out.println("-------------------------");
// 十进制到其他进制
System.out.println(Integer.toString(100, 5));
System.out.println(Integer.toString(100, 37));
System.out.println(Integer.toString(100, 36));
System.out.println("-------------------------");
// 其他进制到十进制
System.out.println(Integer.parseInt("100", 10));
System.out.println(Integer.parseInt("100", 2));
System.out.println(Integer.parseInt("100", 8));
System.out.println(Integer.parseInt("100", 16));
System.out.println(Integer.parseInt("100", 23));
}
}
运行结果:
4.5.3 JDK1.5新特性:自动装箱和拆箱
自动装箱:把基本类型自动转换为包装类类型
自动拆箱:把包装类类型自动转换为基本类型
public class IntegerDemo {
public static void main(String[] args) {
// 定义了一个int类型的包装类类型变量i
// Integer i = new Integer(100);
Integer ii = 100;
ii += 200;
System.out.println("ii:" + ii);
}
}
运行结果:
为什么将基本数据类型100赋值给引用数据类型ii不报错呢?还有,将200和ii相加后赋值给ii,为啥也不报错呢?
因为在JDK1.5以后,出现了自动装箱和自动拆箱的功能。反编译上面的class文件,得到:
Integer ii = Integer.valueOf(100); //自动装箱
ii = Integer.valueOf(ii.intValue() + 200); //自动拆箱,再自动装箱
System.out.println((new StringBuilder("ii:")).append(ii).toString());
对比源代码和反编译出来的代码,可以看出来编译器对代码进行了自动装箱和自动拆箱。
注意:在使用时,Integer x = null;代码就会出现NullPointerException。建议先判断是否为null,然后再使用。
面试题:看程序写结果
/*
* 注意:Integer的数据直接赋值,如果在-128到127之间,会直接从缓冲池里获取数据
*/
public class IntegerDemo {
public static void main(String[] args) {
Integer i1 = 128;
Integer i2 = 128;
System.out.println(i1 == i2);
System.out.println(i1.equals(i2));
System.out.println("-----------");
Integer i3 = 127;
Integer i4 = 127;
System.out.println(i3 == i4);
System.out.println(i3.equals(i4));
}
}
运行结果:
原因分析:Integer类复写了equals()方法,使其用来比较字面值。但是 == 用来比较地址值,为什么将128和127赋值给Integer类的对象时,情况不一样呢?由于在使用Integer i = 127和Integer i = 127时,编译器会自动装箱,即调用Integer类的valueOf(int i)方法,通过查看valueOf(int i)的源码,知道了Java针对-128到127之间的数据,做了一个数据缓冲池,如果数据是该范围内的,每次并不创建新的空间,即地址值相同。
4.6 Character
Character 类在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段。
此外,该类提供了几种方法,以确定字符的类别(小写字母,数字,等等),并将字符从大写转换成小写,反之亦然。
1、构造方法
Character(char value):构造一个新分配的 Character 对象,用以表示指定的 char 值。
public class CharacterDemo {
public static void main(String[] args) {
// 创建对象
Character ch = new Character('a');
System.out.println("ch:" + ch);
}
}
运行结果:
2、部分常用方法
/*
* public static boolean isUpperCase(char ch):判断给定的字符是否是大写字符
* public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符
* public static boolean isDigit(char ch):判断给定的字符是否是数字字符
* public static char toUpperCase(char ch):把给定的字符转换为大写字符
* public static char toLowerCase(char ch):把给定的字符转换为小写字符
*/
public class CharacterDemo {
public static void main(String[] args) {
//public static boolean isUpperCase(char ch):判断给定的字符是否是大写字符
System.out.println("isUpperCase:"+Character.isUpperCase('A'));
//public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符
System.out.println("isLowerCase:"+Character.isLowerCase('a'));
//public static boolean isDigit(char ch):判断给定的字符是否是数字字符
System.out.println("isDigit:"+Character.isDigit('0'));
System.out.println("--------------");
//public static char toUpperCase(char ch):把给定的字符转换为大写字符
System.out.println("toUpperCase:"+Character.toUpperCase('a'));
//public static char toLowerCase(char ch):把给定的字符转换为小写字符
System.out.println("toUpperCase:"+Character.toLowerCase('A'));
}
}
运行结果: