Java常用类库（二）

Java常用类库（二）

-----------------------

Math与Random类

Math类表示数学操作类，在Math类中的方未予都是静态方法，直接使用“类.方法名称（）”形式调用即可。

实例：

[java]  view plain copy

1. public class MathDemo01{  
2.     public static void main(String args[]){  
3.         // Math类中的方法都是静态方法，直接使用“类.方法名称()”的形式调用即可  
4.         System.out.println("求平方根：" + Math.sqrt(9.0)) ;  
5.         System.out.println("求两数的最大值：" + Math.max(10,30)) ;  
6.         System.out.println("求两数的最小值：" + Math.min(10,30)) ;  
7.         System.out.println("2的3次方：" + Math.pow(2,3)) ;  
8.         System.out.println("四舍五入：" + Math.round(33.6)) ;  
9.     }  
10. };  

Random类

Random类主要是产生随机数，可以产生一个指定范围的随机数，Random类是定义在java.util包中的类。

实例：

[java]  view plain copy

1. import java.util.Random ;  
2. public class RandomDemo01{  
3.     public static void main(String args[]){  
4.         Random r = new Random() ;       // 实例化Random对象  
5.         for(int i=0;i<10;i++){  
6.             System.out.print(r.nextInt(100) + "\t") ;  
7.         }  
8.     }  
9. };  

NumberFormat类

NuberFormat的基本使用：此类主要完成数字的格式化显示。

实例：

[java]  view plain copy

1. import java.text.* ;  
2. public class NumberFormatDemo01{  
3.     public static void main(String args[]){  
4.         NumberFormat nf = null ;        // 声明一个NumberFormat对象  
5.         nf = NumberFormat.getInstance() ;   // 得到默认的数字格式化显示  
6.         System.out.println("格式化之后的数字：" + nf.format(10000000)) ;  
7.         System.out.println("格式化之后的数字：" + nf.format(1000.345)) ;  
8.     }  
9. };  

DecimalFormat的基本使用：DecimalFormat也是Format的一个子类，主要的作用是用来格式化数字使用，当然，在格式化数字的时候要比直接使用NumberFormat更加方便，因为可以直接指按用户自定义的方式进行格式化操作，与之前SimpleDateFormat类似。

实例：

[java]  view plain copy

1. import java.text.* ;  
2. class FormatDemo{  
3.     public void format1(String pattern,double value){   // 此方法专门用于完成数字的格式化显示  
4.         DecimalFormat df = null ;           // 声明一个DecimalFormat类的对象  
5.         df = new DecimalFormat(pattern) ;   // 实例化对象，传入模板  
6.         String str = df.format(value) ;     // 格式化数字  
7.         System.out.println("使用" + pattern  
8.             + "格式化数字" + value + "：" + str) ;  
9.     }  
10. };  
11. public class NumberFormatDemo02{  
12.     public static void main(String args[]){  
13.         FormatDemo demo = new FormatDemo() ;    // 格式化对象的类  
14.         demo.format1("###,###.###",111222.34567) ;  
15.         demo.format1("000,000.000",11222.34567) ;  
16.         demo.format1("###,###.###￥",111222.34567) ;  
17.         demo.format1("000,000.000￥",11222.34567) ;  
18.         demo.format1("##.###%",0.345678) ;  
19.         demo.format1("00.###%",0.0345678) ;  
20.         demo.format1("###.###\u2030",0.345678) ;  
21.     }  
22. };  

大数操作类（BigInter、BigDecimal）

大数操作，一般是指在超出long、double类型能够存放的范围时使用。

                    操作整型：BigInteger

                    操作小数：BigDecimal

BigDecimal实例：

 

[java]  view plain copy

1. import java.math.* ;  
2. class MyMath{  
3.     public static double add(double d1,double d2){      // 进行加法计算  
4.         BigDecimal b1 = new BigDecimal(d1) ;  
5.         BigDecimal b2 = new BigDecimal(d2) ;  
6.         return b1.add(b2).doubleValue() ;  
7.     }  
8.     public static double sub(double d1,double d2){      // 进行减法计算  
9.         BigDecimal b1 = new BigDecimal(d1) ;  
10.         BigDecimal b2 = new BigDecimal(d2) ;  
11.         return b1.subtract(b2).doubleValue() ;  
12.     }  
13.     public static double mul(double d1,double d2){      // 进行乘法计算  
14.         BigDecimal b1 = new BigDecimal(d1) ;  
15.         BigDecimal b2 = new BigDecimal(d2) ;  
16.         return b1.multiply(b2).doubleValue() ;  
17.     }  
18.     public static double div(double d1,double d2,int len){      // 进行乘法计算  
19.         BigDecimal b1 = new BigDecimal(d1) ;  
20.         BigDecimal b2 = new BigDecimal(d2) ;  
21.         return b1.divide(b2,len,BigDecimal.ROUND_HALF_UP).doubleValue() ;  
22.     }  
23.     public static double round(double d,int len){   // 进行四舍五入  
24.         BigDecimal b1 = new BigDecimal(d) ;  
25.         BigDecimal b2 = new BigDecimal(1) ;  
26.         return b1.divide(b2,len,BigDecimal.ROUND_HALF_UP).doubleValue() ;  
27.     }  
28. };  
29.   
30. public class BigDecimalDemo01{  
31.     public static void main(String args[]){  
32.         System.out.println("加法运算：" + MyMath.round(MyMath.add(10.345,3.333),1)) ;  
33.         System.out.println("减法运算：" + MyMath.round(MyMath.sub(10.345,3.333),3)) ;  
34.         System.out.println("乘法运算：" + MyMath.round(MyMath.mul(10.345,3.333),2)) ;  
35.         System.out.println("除法运算：" + MyMath.div(10.345,3.333,3)) ;  
36.     }  
37. };  

BigInteger实例：

[java]  view plain copy

1. import java.math.BigInteger ;  
2. public class BigIntegerDemo01{  
3.     public static void main(String args[]){  
4.         BigInteger bi1 = new BigInteger("123456789") ;  // 声明BigInteger对象  
5.         BigInteger bi2 = new BigInteger("987654321") ;  // 声明BigInteger对象  
6.         System.out.println("加法操作：" + bi2.add(bi1)) ;    // 加法操作  
7.         System.out.println("减法操作：" + bi2.subtract(bi1)) ;   // 减法操作  
8.         System.out.println("乘法操作：" + bi2.multiply(bi1)) ;   // 乘法操作  
9.         System.out.println("除法操作：" + bi2.divide(bi1)) ; // 除法操作  
10.         System.out.println("最大数：" + bi2.max(bi1)) ;  // 求出最大数  
11.         System.out.println("最小数：" + bi2.min(bi1)) ;  // 求出最小数  
12.         BigInteger result[] = bi2.divideAndRemainder(bi1) ; // 求出余数的除法操作  
13.         System.out.println("商是：" + result[0] +   
14.             "；余数是：" + result[1]) ;  
15.     }  
16. };  

对象克隆技术
对象克隆：将对象完整的复制成另一个对象，必须依靠Object类

实例：

[java]  view plain copy

1. class Person implements Cloneable{  // 实现Cloneable接口表示可以被克隆   
2.     private String name ;  
3.     public Person(String name){  
4.         this.name = name ;  
5.     }  
6.     public void setName(String name){  
7.         this.name = name ;  
8.     }  
9.     public String getName(){  
10.         return this.name ;  
11.     }  
12.     public String toString(){  
13.         return "姓名：" + this.name ;  
14.     }  
15.     public Object clone()  
16.                 throws CloneNotSupportedException  
17.     {  
18.         return super.clone() ;  // 具体的克隆操作由父类完成  
19.     }  
20. };  
21. public class CloneDemo01{  
22.     public static void main(String args[]) throws Exception{  
23.         Person p1 = new Person("张三") ;  
24.         Person p2 = (Person)p1.clone() ;  
25.         p2.setName("李四") ;  
26.         System.out.println("原始对象：" + p1) ;  
27.         System.out.println("克隆之后的对象：" + p2) ;  
28.     }  
29. };  

比较器

Comparable接口的作用

之前Arrays类中存在sort()方法，此方法可以直接对对象数组进行排序

Coparable接口可以直接使用java.util.Arrays类进行数组的排序操作，但对象所在的类必须实现Comparable接口，用于指定排序接口。

实例：要求：定义一个学生类，里面有姓名、年龄、成绩三个属性，要求按成绩排序，如果成绩相等，则按照年龄由低到高排序

代码：

[java]  view plain copy

1. class Student implements Comparable<Student> {    // 指定类型为Student  
2.     private String name ;  
3.     private int age ;  
4.     private float score ;  
5.     public Student(String name,int age,float score){  
6.         this.name = name ;  
7.         this.age = age ;  
8.         this.score = score ;  
9.     }  
10.     public String toString(){  
11.         return name + "\t\t" + this.age + "\t\t" + this.score ;  
12.     }  
13.     public int compareTo(Student stu){  // 覆写compareTo()方法，实现排序规则的应用  
14.         if(this.score>stu.score){  
15.             return -1 ;  
16.         }else if(this.score<stu.score){  
17.             return 1 ;  
18.         }else{  
19.             if(this.age>stu.age){  
20.                 return 1 ;  
21.             }else if(this.age<stu.age){  
22.                 return -1 ;  
23.             }else{  
24.                 return 0 ;  
25.             }  
26.         }     
27.     }  
28. };  
29. public class ComparableDemo01{  
30.     public static void main(String args[]){  
31.         Student stu[] = {new Student("张三",20,90.0f),  
32.             new Student("李四",22,90.0f),new Student("王五",20,99.0f),  
33.             new Student("赵六",20,70.0f),new Student("孙七",22,100.0f)} ;  
34.         java.util.Arrays.sort(stu) ;    // 进行排序操作  
35.         for(int i=0;i<stu.length;i++){   // 循环输出数组中的内容  
36.             System.out.println(stu[i]) ;  
37.         }  
38.     }  
39. };  

实际上比较器的排序原理 就是二叉树的排序算法。

基本原里：使用第一个元素作为根节点，之后如果后面的内容比根节点要小，则放在左子树如果内容比根节点内容大，则放在右子树

手动完成二叉树算法：

[java]  view plain copy

1. class BinaryTree{  
2.     class Node{         // 声明一个节点类  
3.         private Comparable data ;   // 保存具体的内容  
4.         private Node left ;         // 保存左子树  
5.         private Node right ;        // 保存右子树  
6.         public Node(Comparable data){  
7.             this.data = data ;  
8.         }  
9.         public void addNode(Node newNode){  
10.             // 确定是放在左子树还是右子树  
11.             if(newNode.data.compareTo(this.data)<0){ // 内容小，放在左子树  
12.                 if(this.left==null){  
13.                     this.left = newNode ;   // 直接将新的节点设置成左子树  
14.                 }else{  
15.                     this.left.addNode(newNode) ;    // 继续向下判断  
16.                 }  
17.             }  
18.             if(newNode.data.compareTo(this.data)>=0){    // 放在右子树  
19.                 if(this.right==null){  
20.                     this.right = newNode ;  // 没有右子树则将此节点设置成右子树  
21.                 }else{  
22.                     this.right.addNode(newNode) ;   // 继续向下判断  
23.                 }  
24.             }  
25.         }  
26.         public void printNode(){    // 输出的时候采用中序遍历  
27.             if(this.left!=null){  
28.                 this.left.printNode() ; // 输出左子树  
29.             }  
30.             System.out.print(this.data + "\t") ;  
31.             if(this.right!=null){  
32.                 this.right.printNode() ;  
33.             }  
34.         }  
35.     };  
36.     private Node root ;     // 根元素  
37.     public void add(Comparable data){   // 加入元素  
38.         Node newNode = new Node(data) ; // 定义新的节点  
39.         if(root==null){ // 没有根节点  
40.             root = newNode ;    // 第一个元素作为根节点  
41.         }else{  
42.             root.addNode(newNode) ; // 确定是放在左子树还是放在右子树  
43.         }  
44.     }  
45.     public void print(){  
46.         this.root.printNode() ; // 通过根节点输出  
47.     }  
48. };  
49. public class ComparableDemo03{  
50.     public static void main(String args[]){  
51.         BinaryTree bt = new BinaryTree() ;  
52.         bt.add(8) ;  
53.         bt.add(3) ;  
54.         bt.add(3) ;  
55.         bt.add(10) ;  
56.         bt.add(9) ;  
57.         bt.add(1) ;  
58.         bt.add(5) ;  
59.         bt.add(5) ;  
60.         System.out.println("排序之后的结果：") ;  
61.         bt.print() ;  
62.     }  
63. };  

另一种比较器：Comparator

如果一个类已经开发完成，但是在此类建立的初期并没有实现Comparable接口，此时肯定是无法进行对象排序操作的，所以为了解决这样的问题，java又定义了另一具比较器的操作接口——Comparator。

实例：

[java]  view plain copy

1. import java.util.* ;  
2. class Student{  // 指定类型为Student  
3.     private String name ;  
4.     private int age ;  
5.     public Student(String name,int age){  
6.         this.name = name ;  
7.         this.age = age ;  
8.     }  
9.     public boolean equals(Object obj){  // 覆写equals方法  
10.         if(this==obj){  
11.             return true ;  
12.         }  
13.         if(!(obj instanceof Student)){  
14.             return false ;  
15.         }  
16.         Student stu = (Student) obj ;  
17.         if(stu.name.equals(this.name)&&stu.age==this.age){  
18.             return true ;  
19.         }else{  
20.             return false ;  
21.         }  
22.     }  
23.     public void setName(String name){  
24.         this.name = name ;  
25.     }  
26.     public void setAge(int age){  
27.         this.age = age ;  
28.     }  
29.     public String getName(){  
30.         return this.name ;  
31.     }  
32.     public int getAge(){  
33.         return this.age ;  
34.     }  
35.     public String toString(){  
36.         return name + "\t\t" + this.age  ;  
37.     }  
38. };  
39.   
40. class StudentComparator implements Comparator<Student>{   // 实现比较器  
41.     // 因为Object类中本身已经有了equals()方法  
42.     public int compare(Student s1,Student s2){  
43.         if(s1.equals(s2)){  
44.             return 0 ;  
45.         }else if(s1.getAge()<s2.getAge()){   // 按年龄比较  
46.             return 1 ;  
47.         }else{  
48.             return -1 ;  
49.         }  
50.     }  
51. };  
52.   
53. public class ComparatorDemo{  
54.     public static void main(String args[]){  
55.         Student stu[] = {new Student("张三",20),  
56.             new Student("李四",22),new Student("王五",20),  
57.             new Student("赵六",20),new Student("孙七",22)} ;  
58.         java.util.Arrays.sort(stu,new StudentComparator()) ;    // 进行排序操作  
59.         for(int i=0;i<stu.length;i++){   // 循环输出数组中的内容  
60.             System.out.println(stu[i]) ;  
61.         }  
62.     }  
63. };  

观察者设计模式

以购房者观注房价为例，结合java.util包中提供的Obeservable类和Observer接口实现。

代码：

[java]  view plain copy

1. import java.util.* ;  
2. class House extends Observable{ // 表示房子可以被观察  
3.     private float price ;// 价钱  
4.     public House(float price){  
5.         this.price = price ;  
6.     }  
7.     public float getPrice(){  
8.         return this.price ;  
9.     }  
10.     public void setPrice(float price){  
11.         // 每一次修改的时候都应该引起观察者的注意  
12.         super.setChanged() ;    // 设置变化点  
13.         super.notifyObservers(price) ;// 价格被改变  
14.         this.price = price ;  
15.     }  
16.     public String toString(){  
17.         return "房子价格为：" + this.price ;  
18.     }  
19. };   
20. class HousePriceObserver implements Observer{  
21.     private String name ;  
22.     public HousePriceObserver(String name){ // 设置每一个购房者的名字  
23.         this.name = name ;  
24.     }  
25.     public void update(Observable o,Object arg){  
26.         if(arg instanceof Float){  
27.             System.out.print(this.name + "观察到价格更改为：") ;  
28.             System.out.println(((Float)arg).floatValue()) ;  
29.         }  
30.     }  
31. };  
32. public class ObserDemo01{  
33.     public static void main(String args[]){  
34.         House h = new House(1000000) ;  
35.         HousePriceObserver hpo1 = new HousePriceObserver("购房者A") ;  
36.         HousePriceObserver hpo2 = new HousePriceObserver("购房者B") ;  
37.         HousePriceObserver hpo3 = new HousePriceObserver("购房者C") ;  
38.         h.addObserver(hpo1) ;  
39.         h.addObserver(hpo2) ;  
40.         h.addObserver(hpo3) ;  
41.         System.out.println(h) ; // 输出房子价格  
42.         h.setPrice(666666) ;    // 修改房子价格  
43.         System.out.println(h) ; // 输出房子价格  
44.     }  
45. };  

正则表达式

利用两段代码观察使用正则表达式的好处

不使用正则：

[java]  view plain copy

1. public class RegexDemo01{  
2.     public static void main(String args[]){  
3.         String str = "1234567890" ;     // 此字符串由数字组成  
4.         boolean flag = true ;           // 定义一个标记变量  
5.         // 要先将字符串拆分成字符数组，之后依次判断  
6.         char c[] = str.toCharArray() ;  // 将字符串变为字符数组  
7.         for(int i=0;i<c.length;i++){ // 循环依次判断  
8.             if(c[i]<'0'||c[i]>'9'){       // 如果满足条件，则表示不是数字  
9.                 flag = false ;          // 做个标记  
10.                 break ;                 // 程序不再向下继续执行  
11.             }  
12.         }  
13.         if(flag){  
14.             System.out.println("是由数字组成！") ;  
15.         }else{  
16.             System.out.println("不是由数字组成！") ;  
17.         }  
18.     }  
19. };  

基本思路就是将字符串拆分，之后一个个进行比较验证，但是这样比较麻烦

使用正则表达式：

[java]  view plain copy

1. import java.util.regex.Pattern ;  
2. public class RegexDemo02{  
3.     public static void main(String args[]){  
4.         String str = "1234567890" ;     // 此字符串由数字组成  
5.         if(Pattern.compile("[0-9]+").matcher(str).matches()){   // 使用正则  
6.             System.out.println("是由数字组成！") ;  
7.         }else{  
8.             System.out.println("不是由数字组成！") ;  
9.         }  
10.     }  
11. };  

Pattern、Matcher类

这两个类为正则的核心操作类，这两个类都定义在java.util.regex包中

Pattern为的主要作用是进行正则规范的编写。

而Matcher类主要是执行规范，验证一个字符串是否符合其规范。

实例：

[java]  view plain copy

1. import java.util.regex.Pattern ;  
2. import java.util.regex.Matcher ;  
3. public class RegexDemo03{  
4.     public static void main(String args[]){  
5.         String str = "1983-07-27" ;     // 指定好一个日期格式的字符串  
6.         String pat = "\\d{4}-\\d{2}-\\d{2}" ;   // 指定好正则表达式  
7.         Pattern p = Pattern.compile(pat) ;  // 实例化Pattern类  
8.         Matcher m = p.matcher(str) ;    // 实例化Matcher类  
9.         if(m.matches()){        // 进行验证的匹配，使用正则  
10.             System.out.println("日期格式合法！") ;  
11.         }else{  
12.             System.out.println("日期格式不合法！") ;  
13.         }  
14.     }  
15. };  

String类对正则的支持

String对正则主要有三种支持方法：字符串匹配、字符串替换、字符串拆分

实例：

[java]  view plain copy

1. import java.util.regex.Pattern ;  
2. import java.util.regex.Matcher ;  
3. public class RegexDemo06{  
4.     public static void main(String args[]){  
5.         String str1 = "A1B22C333D4444E55555F".replaceAll("\\d+","_") ;  
6.         boolean temp = "1983-07-27".matches("\\d{4}-\\d{2}-\\d{2}") ;  
7.         String s[] = "A1B22C333D4444E55555F".split("\\d+") ;  
8.         System.out.println("字符串替换操作：" + str1) ;  
9.         System.out.println("字符串验证：" + temp) ;  
10.         System.out.print("字符串的拆分：") ;  
11.         for(int x=0;x<s.length;x++){  
12.             System.out.print(s[x] + "\t") ;  
13.         }  
14.     }  
15. };  

定时调度

每当一段时间，程序会自动执行，称为定时调度。如果要使用定时调度，则必须保证程序始终运行着才可以，也就是说相当于定时调度是在程序之外又启动了一个新的线程。

Timer和TimerTask两个类完成定时调度

具体实例：

[java]  view plain copy

1. // 完成具体的任务操作   
2. import java.util.TimerTask ;  
3. import java.util.Date ;  
4. import java.text.SimpleDateFormat ;  
5. class MyTask extends TimerTask{ // 任务调度类都要继承TimerTask  
6.     public void run(){  
7.         SimpleDateFormat sdf = null ;  
8.         sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS") ;  
9.         System.out.println("当前系统时间为：" + sdf.format(new Date())) ;  
10.     }  
11. };  

 

[java]  view plain copy

1. import java.util.Timer ;  
2. public class TestTask{  
3.     public static void main(String args[]){  
4.         Timer t = new Timer() ; // 建立Timer类对象  
5.         MyTask mytask = new MyTask() ;  // 定义任务  
6.         t.schedule(mytask,1000,2000) ;  // 设置任务的执行，1秒后开始，每2秒重复  
7.     }  
8. };