java零碎

最新推荐文章于 2022-08-24 09:10:56 发布

子衿_青青

最新推荐文章于 2022-08-24 09:10:56 发布

阅读量813

点赞数 2

分类专栏： java复习文章标签： java零碎

本文链接：https://blog.csdn.net/qq_18433441/article/details/75271211

版权

java复习专栏收录该内容

8 篇文章 1 订阅

订阅专栏

快捷搜索：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");
}

不能。原因：每删除掉一个元素，后面的元素会自动向前移动，size也会减一（一直变化）

那怎么办呢？倒着删除。。

for (int i=list.size()-1; i>=0; i--)

这样size只用到了一次，管它后面变不变化。。再一个，我本来就是从后往前删除的，后面元素的自动移动反而不会有影响

7.5）下面代码为什么是错的

ArrayList<Double> list = new ArrayList<>();
list.add(1)

因为参数不匹配，不会进行自动转换的。。即使你是Integer也不会。。。因为他们没有继承关系嘛

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;

等价于 boolean even = number % 2 == 0;

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); //输出b

28）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); //输出-12

29）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)); //输出a

30）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.46

30.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()); // 0

31）控制台格式化输出

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

34.4）数组的复制

		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}, };// 直接创建和赋值一起的，最后一个逗号可要可不要

38.2）二维数组实际上是一个数组，它的每个元素是一维数组

注意：和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

再来看看我们的C语言，没有对比就没有伤害

    //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));//第三个一维数组的长度，5

39）在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; //而这个可以

44.5）一些常用的转换

		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