java零碎
快捷搜索：Ctrl + F
1）字符串常量不能跨行
例如： System.out.println("Introduction to Java Programming,
by AAA");会出现编译错误，可以改为：
System.out.println("Introduction to Java Programming, ” +
“by AAA");
2）从控制台读取输入
Scanner input = new Scanner(System.in); double radius = input.nextDouble();
3）标识符是由字母、数字、下划线（_）、美元符号（$）构成的字符序列，但是不能以数字开头
4）常量
4.1）常量的定义：final datatype CONSTANTNAME = value;
例如： final double PI = 3.1415926; 常量必须在同一条语句中声明和赋值。
4.2）使用常量的好处
不必重复输入同一个值
如果必须修改常量值，只需要修改一个地方
给常量赋一个描述性名字会提高程序易读性
4.3）常量的命名：大写所有字符，两个单词用下划线连接，例如MAX_VALUE
5）java中long是64位，C语言中long是32位
6）取模操作符%
通常用于正整数上，可以用于负整数和浮点值。
只有当被除数是负数时，余数才为负。
例如： -7%3结果为-1 -12%4结果为0 -26%-8结果是-2 20%-13结果是7
7）ArrayList
7.1） ArrayList<int> 为什么会出错，因为int不是对象。。。改为 ArrayList<Integer>
7.2）从数组创建列表
String[] array = {"Dallas", "Dallas", "Houston", "Dallas"};
ArrayList<String> list = new ArrayList<>(Arrays.asList(array));
7.3）从列表创建数组
String[] array1 = new String[list.size()];
list.toArray(array1);7.4）下面例子能否删除所有的"Dallas"
String[] array = {"Dallas", "Dallas", "Houston", "Dallas"};
ArrayList<String> list = new ArrayList<>(Arrays.asList(array));
for (int i=0; i < list.size(); i++){
list.remove("Dallas");
}那怎么办呢？ 倒着删除。。
for (int i=list.size()-1; i>=0; i--)7.5）下面代码为什么是错的
ArrayList<Double> list = new ArrayList<>();
list.add(1)8）整型直接量（常量）
默认情况，是个十进制数
表示二进制时，用0b或0B（零B）开头，例如0B1111，是15
表示八进制时，用0（零）开头，例如07777，是4095
表示十六进制时，用0x或0X开头，例如0XFFFF，是65535
9）浮点型直接量
浮点型直接量带小数点，默认是double型，如5.0被认为是double型，不是float型。。不想默认的话就5.0f
float型有7~8位小数位
double型有15~17位小数位
所以double型更精确
10）允许下划线在两个数字之间，为了可读性
如：long ssn = 232_45_55;
但是45_和_45是不正确的，下划线必须置于两个数字间
11）拓宽类型
将小范围类型变量转换成大范围类型的变量。Java会自动扩宽类型
例子： long a = 333; float b; b = a; 这是可以的，因为float的范围比long大
12）缩窄类型
将大范围类型变量转换成小范围类型的变量。必须显式完成
例子： int i = 1; byte b = i; 这就会出错了。。应该 byte b = (byte) i;
特殊情况： x1 op= x2 等效于 x1 = (T) (x1 op x2)，也就是说本身就自带了强制类型转换
例子：
short a=1, b=2;
a += b; //可行,因为自带了强制类型转换
a = a + b; //不可行，因为 a+b的结果是int型（为什么是int? 去看数据类型自动转换规则），
//没有强制类型转换的话，不能转成范围更小的short
a = (short) (a + b); 13）java数据类型的获取
public class Test {
public static void main(String[] args) {
long a = 333;
float b;
b = a;
System.out.println(getType(b));//输出class java.lang.Float
System.out.println(getType(b+a));//输出class java.lang.Float（C语言的话是Double）
}
public static String getType(Object o){
return o.getClass().toString();
}
}14）常见的错误
14.1）溢出，当一个变量被赋予超过存储大小的值。例如： int value = 214748367 + 1;
14.2）取整错误，涉及浮点数的计算都是近似的。例如 1.0 - 0.9结果可能是0.0999999999，而不是0.1
15）Math.random() 能够取大于等于0，小于1的随机数（双精度）
16）System.exit(status) 能够终止程序。status为0时，表示正常结束；为1时，表示非正常结束
17）boolean与其它数据类型不能相互转换。
例子： int i = 1; boolean b = (boolean) i; 错的
例子： boolean b = true; int i = (int) b; 错的
18）boolean类型的赋值，有时候可以简化
例如：
if(number % 2 == 0){
even = true;
}else
even = false;19） p1 ^ p2 （异或）等价于 p1 != p2。。。p1,p2代表的是true或者false的布尔表达式，不能是算术、数值
例子： number % 2 == 0 ^ number > 20 这种行的
例子： a + b ^ a - b 放心，编译器不会让你过的
20） switch
swtich(switch表达式){
case 值1： 语句（组）1；
break;
case 值1： 语句（组）2；
break;
。。。
case 值N： 语句（组）N；
break;
default: 默认情况下执行的语句（组）
}
注意：
switch表达式的值是byte、char、short、int或者String型的值
别忘了break
21）除开赋值操作符的所有二元操作符都是左结合的；赋值操作符是右结合的
22）Math类的三角函数方法
22.1）toRadians(degree) 度转弧度 例子： toRadians(30) 返回 0.5236 （π / 6）
22.2）toDegree(radians) 弧度转度 例子：toDegree(Math.PI / 2) 返回的是90.0
22.3）sin(radians) 参数是弧度 例子：sin(Math.toRadians(270)) 返回的是-1
22.4）asin(a) 返回的是弧度 例子：asin(0.5) 返回 0.5236 （π / 6）
……
23）Math类的取整方法
23.1）ceil(x) 向上取整，返回是双精度的数 例子：ceil(2.1) 返回3.0
23.2）floor(x) 向下取整，返回是双精度的数 例子：floor(2.8) 返回2.0
23.3）rint(x) 取最接近的整数，如果与两个整数距离相等，则返回偶数的那个，也是双精度返回。
例子：rint(2.5) 返回2.0 rint(2.8)返回3.0
23.4）round(x) 四舍五入。若x是单精度，等效于(int)Math.floor(x+0.5)；若x是双精度，等效于(long)Math.floor(x+0.5)
例子： round(-2.6f) 返回-3 //int型 round(-2.4) 返回-2 //long型
24）Math 不需要导入，因为它在java.lang包中，这个包中的所有类都是隐式导入的
25）Unicode码
Unicode标准有1 112 064个字符，但是一般用到的只是16位的Unicode码，也就是\u0000 ~ \uFFFF，刚好一个char类型
26）ASCII码
8位，从\u0000 ~ \u007F，被Unicde码包括
几个需要记住的ASCII码：
'0' 对应48； 'A' 对应65； 'a' 对应97
27）所有数值类型的操作都可以用在char类型上
int i = '2' + '3'; // 50 + 51
System.out.println(i); //输出101
int j = 2 + 'a'; // 2 + 97
System.out.println(j);
char ch = 'a';
System.out.println(++ch); //输出b28）char类型与数值型数据的转换（说白了就是Unicode码的转换）
char ch = (char)0XAB0041;//只保留后16位,因为char只有16位
System.out.println(ch); //输出A，也就是0X0041
ch = (char) 65.25;
System.out.println(ch); //输出A
int i = 'A';
System.out.println(i); //输出65
byte ba = 'a'; // ‘a’的ASCLL码是 97， 在byte的范围内，所以不用显式转换
System.out.println(ba); //输出97
byte cc = (byte)'\uFFF4'; // \uFFF4 不在byte的范围内，所以要用显式转换
System.out.println(cc); //输出-1229）Character类的一些方法
isDigit(ch)，判断字符是不是数字 。例子： isDigit('0') 返回true
isLetter(ch)，判断字符是不是字母
isLetterOrDigit(ch)，字母或数字
isLowerCase(ch)， 是不是小写字母
isUpperCase(ch)，是不是大写字母
toLowerCase(ch)，大写字母转成小写，不是大写怎么办呢
toUpperCase(ch)，小写字母转成大写
char ch = '1';
System.out.println(Character.toLowerCase(ch)); // 输出1
ch = 'A';
System.out.println(Character.toLowerCase(ch)); //输出a
ch = 'a';
System.out.println(Character.toLowerCase(ch)); //输出a30）String类型
301.）String对象的一些简单方法
String s1 = "Welcome to Java!";
String s2 = "we are 人";
String s3 = "\t Good night! ";
System.out.println(s1.length()); // 字符串长度，此处是16
System.out.println(s2.length()); // 8
System.out.println(s3.length()); // 14
System.out.println(s1.charAt(7)); // 字符串指定位置的字符， 此处是t
System.out.println(s1.concat(s2)); // 连接两个字符串，返回新字符串
System.out.println(s1 + s2); // 也是连接两个字符串
System.out.println(s1 + 2); // 连接一个字符串和一个数字
System.out.println(s1 + 'B'); // 连接一个字符串和字符
System.out.println(s1.toLowerCase()); //字符串中所有字母小写，返回新字符串
System.out.println(s2.toUpperCase()); //字符串中所有字母大写
System.out.println(s3.trim()); //去除两端的空格30.2）从控制台中读取字符串
canner input = new Scanner(System.in);
String s1 = input.next(); // 以空白字符结尾 （' ', '\t', '\f', '\r', '\n'）;
String s2 = input.nextLine(); //以 回车（\n) 结尾30.3）字符串之间的比较
String s1 = "java";
String s2 = "java";
String s3 = new String("java");
String s4 = "C++";
String s5 = "c++";
System.out.println(s1 == s3); // false，因为 == 只能判断是否指向同一个对象，也就是说比较的是地址
System.out.println(s1 == s2); // true，s1,s2都是指向“java”这个字符串常量，
//而不像new String("java")，又给一个新的"java"分配地址空间
System.out.println(s1.equals(s3)); // true, 这才是字符串内容的比较
System.out.println(s4.equalsIgnoreCase(s5)); //true， 忽略大小写比较
System.out.println(s4.compareTo(s5)); // 返回小于0的数，表示s4小于s5。按从第一个字符开始比较，Unicode的大小比较
System.out.println(s4.compareToIgnoreCase(s5)); // 返回0 ，表示s4等于s5
System.out.println(s1.startsWith("ja")); // true, 以...为前缀
System.out.println(s1.endsWith("va")); // true, 以....为后缀
System.out.println(s4.contains("++")); // true.包含....30.4）获取字符串的字符或子串
String s1 = "Welcome to Java!";
System.out.println(s1.substring(2)); // 返回 lcome to Java!
System.out.println(s1.substring(2, 14)); //返回 lcome to Jav 也就是说不包括第14位
System.out.println(s1.indexOf('a')); //返回字符串中第一个a的下标，没有则-1。。此处是12
System.out.println(s1.indexOf('a', 13)); //返回字符串中，从下标13开始（包括13）往后，第一个a的下标。。此处是14
System.out.println(s1.lastIndexOf('a')); //返回字符串中从后往前数第一个a的下标
System.out.println(s1.lastIndexOf('a', 13)); // 下标13之前的，从后往前数的第一个
System.out.println(s1.indexOf("to")); //返回字符串中第一个to的下标
System.out.println(s1.indexOf("to", 2));
System.out.println(s1.lastIndexOf("com"));
System.out.println(s1.lastIndexOf("com", 10));30.5）字符串和数字间的转换
//字符串转数值
int intValue = Integer.parseInt("123");
double doubleValue = Double.parseDouble("123.45");
//数值转字符串
String s1 = 123 + "";
String s2 = String.valueOf(123);
//格式化字符串
String s3 = String.format("x=%5d", 10); // s3是 x= 10;
String s4 = String.format("%.2f", 123.4567); // s4是123.4630.6）字符串的替换和分割
String s1 = "Welcome to java";
String s2;
// replace 和 replaceAll的效果一样
//替换字符
s2 = s1.replace('e', 'A');//WAlcomA to java
//替换字符串
s2 = s1.replace("e", "AB"); //WABlcomAB to java
//替换首个字符串
s2 = s1.replaceFirst("e", "AB");//WABlcome to java
//字符串的分割
String[] tokens = "java#HTML#Perl".split("#");
for(int i=0; i < tokens.length; i++){
System.out.print(tokens[i] + " "); //java HTML Perl
}30.7）字符串与数组之间的转换
//char数组转字符串
char[] chars = {'G', 'o', 'o', 'd', ' ', 'D', 'a', 'y'};
String s = new String(chars); // Good Day
//等价于 String s = String.valueOf(chars);
//字符串转数组
char[] cs = s.toCharArray(); //整个转换
//部分转换 getChars(srcBegin, srcEnd, dst, dstBegin);
char[] cs2 = new char[5];
s.getChars(1, 6, cs2, 0);// {'o', 'o', 'd', ' ', 'D'}30.8）其他
String s = new String();
System.out.println(s.length()); // 031）控制台格式化输出
31.1）常用格式标识符
%b 布尔值，也就是true或者false； %c 字符； %d 十进制数； %f 浮点数； %e 科学计数法; %s 字符串
31.2）指定宽度，总宽度不够自动增加
System.out.printf("%3d#%2s#%4.2f#%5.2e\n", 1234, "Java", 51.6653, 12345.465); //1234#Java#51.67#1.23e+04
/*解释
* %3d 指定int的宽度为3, 但是要完全显示1234，必须4位，所以自动增加
* %2s 指定String的宽度为2，但是为了完全显示"Java"，也自动增加了
* %4.2f 指定包括小数点共4位，其中小数点后有2位。。但是51.67有5位，所以也自动增加
* %5.2e 指定包括小数点共5位，其中小数点后有2位。。但是1.23e+04有8位，所以。。
* */
31.3）注意，格式标识符是严格匹配的
System.out.printf("%f\n", 40.0); //这个可以
System.out.printf("%f\n", 40); //这个会运行时报错32）循环
注意：循环控制中，不要使用浮点值来比较是否相等，因为浮点值都是近似的。
double item = 1;
double sum = 0;
while(item != 0){ //循环看起来没问题，但是实际上是个无限循环，因为item是近似值，所以不能保证会变成0
sum += item;
item -= 0.1;
}33）方法
注意：实参和形参在类型上的匹配，是指不一定是同一类型，只要能自动类型转换，转成相应的类型，就可以
34）数组
34.1）创建数组， 例子： double[] myList = new double[10];
34.2）数组一旦创建，就不能修改它的大小。。数值型元素的默认值为0，char型默认值为'\u0000'，boolean型默认值为false
34.3）对于char类型的数组，可以使用一条语句打印
char[] lalla = {'D', 'a', 'y'};
System.out.println(lalla); //输出Day
int[] list1 = {1,2,3,4};
int[] list2 = new int[10];
int[] list3;
list2 = list1; //并不是真的复制，只是list2指向list1，导致list2原先指向的数组没用了，被JVM自动回收
//方法一，循环复制。。。不举例
//方法二，System.arraycopy(src, srcPos, dest, destPos, length);
System.arraycopy(list1, 0, list2, 0, list2.length);//这里虽然list2的长度超过了list1，但也只能复制list1的那么多了
// 方法三，clone方法，也能复制
list3 = list1.clone();
//方法二，方法三的差别在于要不要创建数组。。方法二需要创建数组，方法三不需要35）可变长参数列表
35.1）具有相同类型的可变长度的参数可以传递给方法，并将作为数组对待
35.2）方法中参数的声明格式： typeName...parameterName
例子：public void printMax(double...numbers){//}; 可以printMax(32,32,3,6)调用，也可以printMax(new double[]{1,23,4} );这样调用。。。作为数组对待，也就是说可以用numbers[i]遍历
35.3）注意，可变长参数必须是最后一个参数。
例子： printee(String string, int...numbers)这种可以
printee(String...strings, int number)就不行了
36）二分查找
36.1） (low+high) / 2可能溢出，可以改为 low + (high - low) / 2
36.2） 时间复杂度 logn + 1; 原因是每次减半，假设k次下来，剩下一个没查找，那么k = logn，剩下的一个还要找一次，所以logn + 1
37）Arrays类的一些静态方法
double[] numbers = {6.0, 4.4, 1.9, 2.9, 3.4, 3.5};
char[] chars = {'a', 'e', 'e'};
//排序，可对字符型或数值型数组进行升序排序
Arrays.sort(numbers);
Arrays.sort(numbers, 1, 3);// 对下标为1 到 3-1的进行排序
//数组的二分查找，要求数组提前升序排好了
Arrays.binarySearch(chars, 'e');
//两个数组比较是否相等
double[] numbers2 = {1,2,3,4.0};
Arrays.equals(numbers, numbers2);
//填充整个数组或部分数组
Arrays.fill(numbers, 5); //整个数组将全是5
Arrays.fill(numbers, 1, 5, 8); // 下标1到5-1 之间全是8
Arrays.toString(numbers); //将返回一个字符串， [6.0, 4.4, 1.9, 2.9, 3.4, 3.5]38）二维数组
38.1）二维数组的声明和创建
例子：
double[][] a = new double[4][3]; //最基本的形式
int[][] n = new int[7][]; //不指定列长度的创建
int[][] m = {{1,2}, {2,3,4}, };// 直接创建和赋值一起的，最后一个逗号可要可不要注意：和C语言中的二维数组的差别在于C语言的二维数组的一维数组的长度都要是相同的，也就是取最大的；而JAVA中二维数组的一维数组，长度可以不同
int[][] m = {{1,2,3,4,5}, {2,3,4,5}, {3,4,5}};
System.out.println(m.length); //二维数组的长度，3
System.out.println(m[0].length); //第一个一维数组的长度，5
System.out.println(m[1].length); //第二个一维数组的长度，4
System.out.println(m[2].length); //第三个一维数组的长度，3
//int a[4][3]; //C语言中二维数组的定义
int m[][5] = {{1,2,3,4,5}, {2,3,4,5},{3,4,5}};//C语言不能省略列长度
printf("%d\n", sizeof(m) / sizeof(m[0])); //二维数组m的长度,3
printf("%d\n", sizeof(m[0]) / sizeof(int));//第一个一维数组的长度，5
printf("%d\n", sizeof(m[1]) / sizeof(int));//第二个一维数组的长度，5
printf("%d\n", sizeof(m[2]) / sizeof(int));//第三个一维数组的长度，539）在Java中，数组被看成是对象。数组是用new操作符创建的。一个数组变量实际上是一个包含数组引用的变量
40）引用类型（类、数组、String等）数据域的默认值是null，数值类型的数据域的默认值是0，boolean类型数据域的默认值是false，char类型的数据域默认值是'\u0000'
但是java中没有给方法中的局部变量赋默认值
41）Random
41.1）一些常用的实例方法
Random() 以当前时间为种子，创建一个Random对象
Random(long seed) 以一个特定值多为种子创建一个Random对象
nextInt() 返回一个随机的int值
nextInt(n:int) 返回一个0~n（不包括n）的随机int值
nextDouble() 返回一个0.0~1.0（不包括1.0）的随机double值，等价于Math.random()
nextFloat() 返回一个0.0F~1.0F（不包括1.0F）的随机float值
nextBoolean() 返回一个随机的boolean值
41.2）如果两个Random对象有相同的种子，那它们将产生相同的数列
Random random1 = new Random();
System.out.print("From random1:");
for(int i = 0; i < 10; i++){
System.out.print(random1.nextInt(1000) + " ");
}
Random random2 = new Random();
System.out.print("\nFrom random2:");
for(int i = 0; i < 10; i++){
System.out.print(random2.nextInt(1000) + " ");
}42）private只能用在类的成员（方法、数据域）上，不能用在类上。修饰符public可以应用在类或类的成员上。它们都不能用在局部变量上
如果一个类没有被定义为公共类，那么它只能在同一个包内被访问。
例子： 类C1和C2在同一个包中，C3不载
package p1;
class C1{
...
} package p1;
public class C2{
can access C1
} package p2;
public class C3{
can not access C1
}43）不可变类
43.1）定义：一个对象创建后内容就不能改变的对象成为不可变对象，它的类就是不可变类
43.2）必须满足三个要求：所有数据域都是私有的；没有修改器方法；没有一个返回指向可变数据域的引用的访问器方法
43.3）例子：
public class Student {
private int id;
private String name;
private Date dateCreated;
public Student(int id, String name){
this.id = id;
this.name = name;
this.dateCreated = new Date();
}
public int getId(){
return id;
}
public String getName(){
return name;
}
public Date getDateCreated(){//这是一个访问器，返回了可变数据域的引用
return dateCreated;
}
}public class Test {
public static void main(String[] args) {
Student student = new Student(123, "张三");
Date dateCreated = student.getDateCreated();
//before
System.out.println(dateCreated);
//改变
dateCreated.setTime(200000); //这里就改变了student的数据域dateCreated，
//因为dateCreated是个引用类型Date
//after
System.out.println(student.getDateCreated());//可以看到值确实改变了
//before
String name = student.getName();
System.out.println(name);
//改变
name = new String("java");//但是String不也是引用类型吗？是啊。
//第一，String类本身就是不可变的。
//第二，这条语句实际上是name这个引用变量指向了其它字符串，
//跟原先的字符串没关系了
//after
System.out.println(student.getName()); //可以看到值并没有变
}
}44）将基本数据类型转换成对象处理
44.1）基本数据类型值不是一个对象，可以以使用包装类在包装成一个对象
44.2）包装类：Boolean、Byte、Character、Short、Integer、Double、Float、Long
44.3）包装类没有无参构造。 Double d = new Double();是不允许的。
44.4）基本类型和包装类型之间的自动转换
//基本类型转换成包装类型，称为装箱
Integer intObjct = new Integer(2); //装箱
//Integer intObjct = 2 //自动装箱
//自动装箱，如果一个基本类型值出现在需要对象的环境中，会自动装箱
//开箱
int a = 3 + new Integer(3); //加法需要的是数组，所以会自动开箱
Integer b = 3 + new Integer(3); //自动开箱，再自动装箱
Double x = 3.0;
//Double x = 3; //编译器不给过
//double y = 3; //而这个可以
String s = "102";
Integer a = Integer.valueOf(s); //返回的是Integer类型，默认当成10进制来转
int b = Integer.valueOf(s); //Integer自动开箱为int型
//等价于 int b = Integer.parseInt(s);
int c = Integer.valueOf(s, 16); //当成16进制来转，返回的是10进制
//等价于 int c = Integer.parseInt(s,16);
// int m = Integer.parseInt("12",2);会出错，因为2超过了2进制
// int m = Integer.parseInt("1A",16)； 返回26
double d = a.doubleValue(); // 除了boolean, ***value都有
String s2 = a.toString(); //转成字符串
String s3 = String.valueOf(a);
String s4 = String.format("x=%5x", a); //格式化控制45）BigInteger和BigDecimal
45.1）BigInteger表示任意大小的整数
45.2）BigDecimal表示任意精度的小数
45.3）常用方法：add、subtract、multiple、divide、remainder
45.4）例子：
BigInteger a = new BigInteger("1223456666213");
BigInteger b = new BigInteger("2");
BigInteger c = a.multiply(b); // 计算 a * b
System.out.println(c);
//其他计算同理
//但是，有一个要注意，就是BigDecimal的精度
BigDecimal d = new BigDecimal("1.0");
BigDecimal e = new BigDecimal("3");
//BigDecimal f = d.divide(e); //由于结果是个无限循环小数，
//而BigDecimal的精度是任意的，
//所以会不停地算下去，于是会抛出异常
BigDecimal f = d.divide(e, 20, BigDecimal.ROUND_UP); //20表示小数点后的位数
//BigDecimal.ROUND_UP，是一种保留策略
//比较
BigDecimal d2 = new BigDecimal("1");
d2.equals(d);//返回false，因为既比较大小，也计较精度
d2.compareTo(d); //返回0.因为这个只比较大小更多解释请看：BigDecimal的用法详解
46）StringBuilder和StringBuffer
46.1）String不能更改内容，但是StringBuilder和StringBuffer可以
46.2）StringBuffer修改缓冲区的方法是同步的，所以并发时用StringBuffer，不用StringBuilder，就这点不同
46.3）用法
//新建
StringBuilder sb = new StringBuilder(); //默认容量为16
//添加
sb.append("welcome");//welcome
sb.append(' ');//welcome
sb.append("to ");//welcome to
sb.append("java");//welcome to java
//删除
sb.delete(8, 11); //welcome java
//插入
sb.insert(8, "HTML");//welcome HTML java
//替换
sb.replace(8, 12, "to ");//welcome to java
//倒置
sb.reverse();//avaj ot emoclew
//替换字符
sb.setCharAt(0, 'm');//mvaj ot emoclew
//找索引位置的字符
char ce = sb.charAt(3); //j
//返回字符串
String s = sb.toString();
//返回子串
s = sb.substring(0, 9); //mvaj ot e
//设置字符串构建器长度，太长则加空字符('\u0000')，这个不是空格，是nul；太短则截断
sb.setLength(6);//mvaj o
sb = new StringBuilder(30);
sb.append("Welcom to java");
System.out.println(sb.length());// 14
System.out.println(sb.capacity());// 30
//去除多余的容量
sb.trimToSize();
System.out.println(sb.length());// 14
System.out.println(sb.capacity());// 14
//但是
sb.setLength(30);//这时，length为30有点长，也就是说加了空字符
System.out.println(sb.length());// 30
System.out.println(sb.capacity());// 30