标签：java stringbuffer integer character
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
SringBuffer：线程安全的可变字符串。跟String相比，使用StringBuffer做字符串的拼接不会浪费太多资源。
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());
}
} 运行结果：
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);
}
} 运行结果：
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);
}
} 运行结果：
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);
}
} 运行结果：
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);
}
} 运行结果：
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);
}
} 运行结果：
练习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);
}
}
运行结果：
面试题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作为参数传递时，调用方法时情况和引用类型是一样的，但是赋值时和基本数据类型是一样的。
Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。
此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。
/*
* 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);
}
} 运行结果：
/*
* 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);
}
} 运行结果：
/*
* 常用的基本进制转换
* 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));
}
} 运行结果：
自动装箱：把基本类型自动转换为包装类类型
自动拆箱：把包装类类型自动转换为基本类型
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之间的数据，做了一个数据缓冲池，如果数据是该范围内的，每次并不创建新的空间，即地址值相同。
Character 类在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段。
此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然。
/* <pre name="code" class="java" style="font-size: 18px;">* 构造方法：<span style="font-family: Arial, Helvetica, sans-serif;">Character(char value)：构造一个新分配的 Character 对象，用以表示指定的 char 值。 </span>*/public class CharacterDemo {public static void main(String[] args) {// 创建对象Character ch = new Character(‘a‘);System.out.println("ch:" + ch);}} 运行结果：
/*
* 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'));
}
} 运行结果：
版权声明：本文为博主原创文章，未经博主允许不得转载。
黑马程序员（Java）----API之常用类（StringBuffer、Integer、Character）
标签：java stringbuffer integer character
原文地址：http://blog.csdn.net/xw_classmate/article/details/47421337
