JAVA常用类库_使用java的哪些类库，完成什么任务-CSDN博客

本文链接：https://blog.csdn.net/singit/article/details/47685667

Java常用类库（一）

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

认识StringBuffer

StringBuffer是使用缓冲区的，本身也是操作字符串的，但是与String类不同，String类的内容一旦声明之后则不可改变，改变的只是其内存地址的指赂，而StringBuffer中的内容是可以改变的。对StringBufffer而言，本身是一个具体的操作类，所以不能像String那样采用直接赋值的方式进行对象的实例化，必须通过构造方法完成

StringBuffer连接字符操作：

String用“+”连接 “Hello” + “ ” + “World”

StringBuffer用append “Hello” append “ ” append “World”

实例操作：字符串连接

[java]view plaincopy 
   
 
   
 public class StringBufferDemo01{  
       public static void main(String args[]){  
             StringBuffer buf = new StringBuffer() ;      // 声明StringBuffer对象   
               buf.append("Hello ") ;                               // 向StringBuffer中添加内容  
               buf.append("World").append("!!!") ;           // 可以连续调用append()方法  
               buf.append("\n") ;                                     // 添加一个转义字符  
               buf.append("数字 = ").append(1).append("\n") ; // 添加数字  
               buf.append("字符 = ").append('C').append("\n");       // 添加字符  
               buf.append("布尔 = ").append(true) ;  // 添加布尔值  
               System.out.println(buf) ;                     // 直接输出对象，调用toString()  
        }  
 };  

实例二：在任意位置处为StringBuffer添加内容，可直接使用inster()方法

[java]view plaincopy 
   
 
   
 public class StringBufferDemo03{  
        public static void main(String args[]){  
             StringBuffer buf = new StringBuffer() ;      // 声明StringBuffer对象   
               buf.append("World!!") ;        // 添加内容  
               buf.insert(0,"Hello ") ;          // 在第一个内容之前添加内容  
               System.out.println(buf) ;  

[java]view plaincopy 
   
      buf.insert(buf.length(),"MLDN~") ;     // 在最后添加内容  
        System.out.println(buf) ;  
 }

实例三：字符吕反转操作，可直接使用reverse()方法就可以完成反转的功能

[java]view plaincopy 
   
 
   
 public class StringBufferDemo04{  
        public static void main(String args[]){  
             StringBuffer buf = new StringBuffer() ;      // 声明StringBuffer对象   
               buf.append("World!!") ;        // 添加内容  
               buf.insert(0,"Hello ") ;          // 在第一个内容之前添加内容  
               String str = buf.reverse().toString() ;    // 将内容反转后变为String类型  
               System.out.println(str) ;        // 将内容输出  
        }  
 };  

实例四：替换指定范围的内容：可直接使用replace()方法

[java]view plaincopy 
   
 
   
 public class StringBufferDemo05{  
        public static void main(String args[]){  
             StringBuffer buf = new StringBuffer() ;      // 声明StringBuffer对象   
               buf.append("Hello ").append("World!!") ;          // 向StringBuffer添加内容  
               buf.replace(6,11,"LiXingHua") ;          // 将world的内容替换  
               System.out.println("内容替换之后的结果：" + buf) ;       // 输出内容  

[java]view plaincopy 
   
 }

实例五：字符串截取，可直接使用substring()方法

[java]view plaincopy 
   
 
   
 public class StringBufferDemo06{  
        public static void main(String args[]){  
             StringBuffer buf = new StringBuffer() ;      // 声明StringBuffer对象   
               buf.append("Hello ").append("World!!") ;          // 向StringBuffer添加内容  
               buf.replace(6,11,"LiXingHua") ;          // 将world的内容替换  
               String str = buf.substring(6,15) ;   // 截取指定范围的内容  
               System.out.println("内容替换之后的结果：" + str) ; // 输出内容  
        }  
 };  

实例六：字符删除，可直接使用delete()方法

[java]view plaincopy 
   
 
   
 public class StringBufferDemo07{  
        public static void main(String args[]){  
             StringBuffer buf = new StringBuffer() ;      // 声明StringBuffer对象   
               buf.append("Hello ").append("World!!") ;          // 向StringBuffer添加内容  
               buf.replace(6,11,"LiXingHua") ;          // 将world的内容替换  
               String str = buf.delete(6,15).toString() ;      // 删除指定范围中的内容  
               System.out.println("删除之后的结果：" + str) ; // 输出内容  

[java]view plaincopy 
   
 }

实例七：查找指定内容是否存在

[java]view plaincopy 
   
 
   
 public class StringBufferDemo08{  
        public static void main(String args[]){  
               StringBuffer buf = new StringBuffer() ;      // 声明StringBuffer对象   
               buf.append("Hello ").append("World!!") ;          // 向StringBuffer添加内容  
               if(buf.indexOf("Hello")==-1){  
                      System.out.println("没有查找到指定的内容") ;  
               }else{     // 不为01表示查找到内容  
                      System.out.println("可以查找到指定的内容") ;  
               }  
        }  
 };  

Runtime类

Runtime运行时，是一个封装了JVM进程的类，每一个JAVA程序实际上都是启动了一个JVM进程，那么每一个JVM进程都是对应这一个Runtime实例，此实例是由JVM为其实例化的。本类的定义中根本就没有构造方法，本类的构造方法被私有化了，则在此类中肯定有一个方法可以返回本类的实例化对象。public static Runtime getRuntime()

实例：利用Runtime得到JVM信息

[java]view plaincopy 
   
 
   
 public class RuntimeDemo01{  
        public static void main(String args[]){  
               Runtime run = Runtime.getRuntime();  // 通过Runtime类的静态方法进行实例化操作  
               System.out.println("JVM最大内存量：" + run.maxMemory()) ;     // 观察最大的内存，根据机器的不同，环境也会有所不同  
               System.out.println("JVM空闲内存量：" + run.freeMemory()) ;      // 取得程序运行的空闲内存  
               String str = "Hello " + "World" + "!!!"   
                             +"\t" + "Welcome " + "To " + "MLDN" + "~" ;  
               System.out.println(str) ;  
               for(int x=0;x<1000;x++){  
                      str += x ;               // 循环修改内容，会产生多个垃圾  
               }  
               System.out.println("操作String之后的,JVM空闲内存量：" + run.freeMemory()) ;  
               run.gc() ;        // 进行垃圾收集，释放空间  
               System.out.println("垃圾回收之后的,JVM空闲内存量：" + run.freeMemory()) ;  
        }  
 };  

Runtime与Process类

除了观察内存使用量外，也可以直接使用Runtime类运行本机的可执行程序，例如调用记事本。public Process exec(String command) throws IOException，并可以通过deestroy()方法销毁一个进程。

[java]view plaincopy 
   
 
   
 public class RuntimeDemo03{  
        public static void main(String args[]){  
               Runtime run = Runtime.getRuntime() ; // 取得Runtime类的实例化对象  
               Process p = null ;   // 定义进程变量  
               try{  
                      p = run.exec("notepad.exe") ;       // 调用本机程序，此方法需要异常处理  
               }catch(Exception e){  
                      e.printStackTrace() ;      // 打印异常信息  
                      // System.out.println(e) ;  
               }  
               try{  
                      Thread.sleep(5000) ;      // 让此线程存活5秒  
               }catch(Exception e){  
               }  
               p.destroy() ;    // 结束此进程  
        }  
 };  

国际化程序

国际化程序就是指一个程序可以同时适应多门语言，即：如果现在程序使用者是中国人，则会以中文为显示文字，如果现在程序的使用者是英国人，则会以英语为显示的文字，也就是说可以通过国际化操作，让一个程序适应各个国家的语言要求。

国际化程序实现支持的类

n java.util.Locale：用于表示一个国家语言的类。

n java.util.ResourceBundle：用于访问资源文件。

n java.text.MessageFormat：格式化资源文件的占位字符串。

Locale类

Locale表示本地，实际上使用的是一个ISO编码的封装类，对于各个国家来说都存在一个唯一的编码，那么这种编码就称为ISO编码，使用Locale可以指定好一个具体的国家编码。

例：汉语：zh-CN 英语：en-US 法语：fr-FR

ResourceBundle类

此类是专门完成属性文件读取操作的，读取的时候直接指定文件名称即可，可以根据Locale所指定的区域码来自动选择所需要的资源文件。

JAVA国际化程序实现

可以根据国家不同，输出不同国家的你好：

汉语：你好！

英语：Hello!

法语：Bonjour!

分别定义在不同的资源文件中。

汉语：Message_zh_CN.properties

英语：Message_en_US.properties

法语：Message_fr_FR.properties

实例：

[java]view plaincopy 
   
 
   
 import java.util.ResourceBundle ;  
   
 import java.util.Locale ;  
   
 public class InterDemo02{  
        public static void main(String args[]){  
               Locale zhLoc = new Locale("zh","CN") ;            // 表示中国地区  
               Locale enLoc = new Locale("en","US") ;            // 表示美国地区  
               Locale frLoc = new Locale("fr","FR") ;              // 表示法国地区  
               // 找到汉语的属性文件，需要指定中文的Locale对象  
               ResourceBundle zhrb = ResourceBundle.getBundle("Message",zhLoc) ;  
               // 找到英语的属性文件，需要指定英文的Locale对象  
               ResourceBundle enrb = ResourceBundle.getBundle("Message",enLoc) ;  
               // 找到法语的属性文件，需要指定法文的Locale对象  
               ResourceBundle frrb = ResourceBundle.getBundle("Message",frLoc) ;  
               // 依次读取各个属性文件的内容，通过键值读取，此时的键值名称统一为info  
               System.out.println("汉语" + zhrb.getString("info")) ;  
               System.out.println("英语：" + enrb.getString("info")) ;  
               System.out.println("法语：" + frrb.getString("info")) ;  
        }  
 };  
   
 处理动态文本  

之前的资源文件中的所有内容实际上都是固定的，而如果现在有些内容，“你好！XXX”。那么此时就必须在资原文件中进行一些动态文本的配置，设置占位符，这些符号中的内容暂时不固定，而是在程序执行的时候由程序进行设置的，而要想实现这样的功能，则必须使用MessageForm类。此类是在java.text包中定义的。

占位符使用{数字}表示

实例：

[java]view plaincopy 
   
 
   
 import java.util.ResourceBundle ;  
   
 import java.util.Locale ;  
   
 import java.text.* ;  
   
 public class InterDemo03{  
        public static void main(String args[]){  
               Locale zhLoc = new Locale("zh","CN") ;            // 表示中国地区  
               Locale enLoc = new Locale("en","US") ;            // 表示美国地区  
               Locale frLoc = new Locale("fr","FR") ;              // 表示法国地区  
               // 找到中文的属性文件，需要指定中文的Locale对象  
               ResourceBundle zhrb = ResourceBundle.getBundle("Message",zhLoc) ;  
               // 找到英文的属性文件，需要指定英文的Locale对象  
               ResourceBundle enrb = ResourceBundle.getBundle("Message",enLoc) ;  
               // 找到法文的属性文件，需要指定法文的Locale对象  
               ResourceBundle frrb = ResourceBundle.getBundle("Message",frLoc) ;  
               // 依次读取各个属性文件的内容，通过键值读取，此时的键值名称统一为info  
               String str1 = zhrb.getString("info") ;  
               String str2 = enrb.getString("info") ;  
               String str3 = frrb.getString("info") ;  
               System.out.println("中文：" + MessageFormat.format(str1,"李兴华")) ;  
               System.out.println("英语：" + MessageFormat.format(str2,"LiXingHua")) ;  
               System.out.println("法语：" + MessageFormat.format(str3,"LiXingHua")) ;  
        }  
 };  

JAVA新特性——可变参数

实例：

[java]view plaincopy 
   
 
   
 public class InterDemo04{  
        public static void main(String args[]){  
               System.out.print("第一次运行：") ;  
               fun("LXH","Li","李兴华") ; // 传入三个参数  
               System.out.print("\n第二次运行：") ;  
               fun("MLDN") ;                           // 传入一个参数  
        }  
        public static void fun(Object...args){    // 固定语法，输入任意多个数据，使用数组表示  
               for(int i=0;i<args.length;i++){  
                      System.out.print(args[i] + "、") ;  
               }  
        }  
 };  

System类

System.out.println()本身就是一个系统提供好的类，而且out.println()方法也是经常使用到的。

System类是一些与系统相关的属性和方法的集合在System类中所有的属性都是静态的

实例：利用System获取一个操作的运行时间

[java]view plaincopy 
   
 
   
 public class SystemDemo01{  
        public static void main(String args[]){  
             long startTime = System.currentTimeMillis() ;    // 取得开始计算之前的时间  
               int sum = 0 ;                 // 声明变量  
               for(int i=0;i<30000000;i++){       // 执行累加操作  
                      sum += i ;  
               }  
               long endTime = System.currentTimeMillis() ;     // 取得计算之后的时间  
               // 结束时间减去开始时间  
               System.out.println("计算所花费的时间：" + (endTime-startTime) +"毫秒") ;  
        }  
 };  

实例：列出本机的全部系统属性

[java]view plaincopy 
   
 
   
 public class SystemDemo02{  
        public static void main(String args[]){  
               System.getProperties().list(System.out) ;     // 列出系统的全部属性  
        }  
 };  

如果只想要其中几个属性的话：

[java]view plaincopy 
   
 
   
 public class SystemDemo03{  
        public static void main(String args[]){  
               System.out.println("系统版本：" + System.getProperty("os.name")  
                      + System.getProperty("os.version")  
                      + System.getProperty("os.arch")) ;  
               System.out.println("系统用户：" + System.getProperty("user.name")) ;  
               System.out.println("当前用户目录：" + System.getProperty("user.home")) ;  
               System.out.println("当前用户工作目录：" + System.getProperty("user.dir")) ;  
        }  
 };  

垃圾对象的回收

一个对象如果不使用，则肯定要等待进行垃圾收集，垃圾收集可以自动调用也可以手工调用，手工调用的时候就是调用System.gc()或者Runtime.getRuntime().gc()。但是如量一个地象在回收之前需要做一些收尾工作，则就必须覆写Object类中的：

protected void finalize() throws Throwable

实例：

[java]view plaincopy 
   
 
   
 class Person{  
        private String name ;  
        private int age ;  
        public Person(String name,int age){  
               this.name = name ;  
               this.age = age;  
        }  
        public String toString(){       // 覆写toString()方法  
               return "姓名：" + this.name + "，年龄：" + this.age ;  
        }  
        public void finalize() throws Throwable{     // 对象释放空间时默认调用此方法  
               System.out.println("对象被释放 --> " + this) ;  
        }  
 };  
   
 public class SystemDemo04{  
        public static void main(String args[]){  
               Person per = new Person("张三",30) ;  
               per = null ;     // 断开引用  
               System.gc() ;         // 强制性释放空间  
        }  
 };  

日期操作类（Date、Calendar）

Date类是一个较为常用的类，但是其操作的日期格式会有一些不符合个人的要求，而如果想进一步取得一些自己需要的时间，则可以使用Calendar类。

Date类

在java.util包中定义了Date类，Date类本身使用非常简单，直接输出其实例化对象即可。

[java]view plaincopy 
   
 
   
 import java.util.Date ;  
 public class DateDemo01{  
        public static void main(String args[]){  
               Date date = new Date() ;       // 直接实例化Date对象  
               System.out.println("当前日期为：" + date) ;  
        }  
 };  

Calendar类

使用此类可以直接将日期精确到毫秒

Calendar类是一个抽象类，既然是一个抽象类则肯定无法直接使用，此时就要利用对象多态性的概念，通过向上转型关系实例化本类对象

实例：

[java]view plaincopy 
   
 
   
 import java.util.* ;  
 public class DateDemo02{  
        public static void main(String args[]){  
               Calendar calendar = new GregorianCalendar();    // 实例化Calendar类对象  
               System.out.println("YEAR: " + calendar.get(Calendar.YEAR));  
               System.out.println("MONTH: " + (calendar.get(Calendar.MONTH) + 1));  
               System.out.println("DAY_OF_MONTH: " + calendar.get(Calendar.DAY_OF_MONTH));  
               System.out.println("HOUR_OF_DAY: " + calendar.get(Calendar.HOUR_OF_DAY));  
               System.out.println("MINUTE: " + calendar.get(Calendar.MINUTE));  
               System.out.println("SECOND: " + calendar.get(Calendar.SECOND));  
               System.out.println("MILLISECOND: " + calendar.get(Calendar.MILLISECOND));  
        }  
 };  

日期操作类(DateFormat、SimpleDateFormat)

DateFormat类

此类是一个日期的格式化类，专门格式化日期的操作，因为java.util.Date类本身就已经包含了完整的期，所以只需要将此日期按照一些格式格式化显示即可。

实例：

[java]view plaincopy 
   
 
   
 import java.text.DateFormat ;  
 import java.util.Date ;  
 public class DateDemo03{  
        public static void main(String args[]){  
               DateFormat df1 = null ;        // 声明一个DateFormat  
               DateFormat df2 = null ;        // 声明一个DateFormat  
               df1 = DateFormat.getDateInstance() ;   // 得到日期的DateFormat对象  
               df2 = DateFormat.getDateTimeInstance() ;   // 得到日期时间的DateFormat对象  
               System.out.println("DATE：" + df1.format(new Date())) ; // 按照日期格式化  
               System.out.println("DATETIME：" + df2.format(new Date())) ;      // 按照日期时间格式化  
        }  
 };  

SimpleDateFormat类

此类的功能是完成日期的显示格式化。如果想要实现转换则必须先准备好一个模板，通过此模板进行日期数字的提取工作。

实例：

[java]view plaincopy 
   
 
   
 import java.text.* ;  
 import java.util.* ;  
 public class DateDemo05{  
        public static void main(String args[]){  
               String strDate = "2008-10-19 10:11:30.345" ;  
               // 准备第一个模板，从字符串中提取出日期数字  
               String pat1 = "yyyy-MM-dd HH:mm:ss.SSS" ;  
               // 准备第二个模板，将提取后的日期数字变为指定的格式  
               String pat2 = "yyyy年MM月dd日 HH时mm分ss秒SSS毫秒" ;  
               SimpleDateFormat sdf1 = new SimpleDateFormat(pat1) ;         // 实例化模板对象  
               SimpleDateFormat sdf2 = new SimpleDateFormat(pat2) ;         // 实例化模板对象  
               Date d = null ;  
               try{  
                      d = sdf1.parse(strDate) ; // 将给定的字符串中的日期提取出来  
               }catch(Exception e){                   // 如果提供的字符串格式有错误，则进行异常处理  
                      e.printStackTrace() ;             // 打印异常信息  
               }  
               System.out.println(sdf2.format(d)) ;     // 将日期变为新的格式  
        }  
 };  

实例操作：取得当前日期

基于Calendar类操作：

[java]view plaincopy 
   
 
   
 import java.util.* ; // 导入需要的工具包  
 class DateTime{            // 以后直接通过此类就可以取得日期时间  
        private Calendar calendar = null ;         // 声明一个Calendar对象，取得时间  
        public DateTime(){                                          // 构造方法中直接实例化对象  
               this.calendar = new GregorianCalendar() ;     
        }  
        public String getDate(){        // 得到的是一个日期：格式为：yyyy-MM-dd HH:mm:ss.SSS  
               // 考虑到程序要频繁修改字符串，所以使用StringBuffer提升性能  
               StringBuffer buf = new StringBuffer() ;  
               buf.append(calendar.get(Calendar.YEAR)).append("-") ;    // 增加年  
               buf.append(this.addZero(calendar.get(Calendar.MONTH)+1,2)).append("-") ;   // 增加月  
               buf.append(this.addZero(calendar.get(Calendar.DAY_OF_MONTH),2)).append(" ") ;     // 取得日  
               buf.append(this.addZero(calendar.get(Calendar.HOUR_OF_DAY),2)).append(":") ; // 取得时  
               buf.append(this.addZero(calendar.get(Calendar.MINUTE),2)).append(":") ;  
               buf.append(this.addZero(calendar.get(Calendar.SECOND),2)).append(".") ;  
               buf.append(this.addZero(calendar.get(Calendar.MILLISECOND),3)) ;  
               return buf.toString() ;  
        }  
        public String getDateComplete(){        // 得到的是一个日期：格式为：yyyy年MM月dd日 HH时mm分ss秒SSS毫秒  
               // 考虑到程序要频繁修改字符串，所以使用StringBuffer提升性能  
               StringBuffer buf = new StringBuffer() ;  
               buf.append(calendar.get(Calendar.YEAR)).append("年") ;  // 增加年  
               buf.append(this.addZero(calendar.get(Calendar.MONTH)+1,2)).append("月") ;       // 增加月  
               buf.append(this.addZero(calendar.get(Calendar.DAY_OF_MONTH),2)).append("日") ;   // 取得日  
               buf.append(this.addZero(calendar.get(Calendar.HOUR_OF_DAY),2)).append("时") ;      // 取得时  
               buf.append(this.addZero(calendar.get(Calendar.MINUTE),2)).append("分") ;          // 取得分  
               buf.append(this.addZero(calendar.get(Calendar.SECOND),2)).append("秒") ;          // 取得秒  
               buf.append(this.addZero(calendar.get(Calendar.MILLISECOND),3)).append("毫秒") ;    // 取得毫秒  
               return buf.toString() ;  
        }  
        public String getTimeStamp(){            // 得到的是一个时间戳  
               // 考虑到程序要频繁修改字符串，所以使用StringBuffer提升性能  
               StringBuffer buf = new StringBuffer() ;  
               buf.append(calendar.get(Calendar.YEAR)) ; // 增加年  
               buf.append(this.addZero(calendar.get(Calendar.MONTH)+1,2)) ;      // 增加月  
               buf.append(this.addZero(calendar.get(Calendar.DAY_OF_MONTH),2)) ;  // 取得日  
               buf.append(this.addZero(calendar.get(Calendar.HOUR_OF_DAY),2)) ;     // 取得时  
               buf.append(this.addZero(calendar.get(Calendar.MINUTE),2)) ;         // 取得分  
               buf.append(this.addZero(calendar.get(Calendar.SECOND),2));          // 取得秒  
               buf.append(this.addZero(calendar.get(Calendar.MILLISECOND),3)) ;      // 取得毫秒  
               return buf.toString() ;  
        }  
        // 考虑到日期中存在前导0，所以在此处加上补零的方法  
        private String addZero(int num,int len){  
               StringBuffer s = new StringBuffer() ;  
               s.append(num) ;  
               while(s.length()<len){   // 如果长度不足，则继续补0  
                      s.insert(0,"0") ;      // 在第一个位置处补0  
               }  
               return s.toString() ;  
        }  
 };  
 public class DateDemo06{  
        public static void main(String args[]){  
               DateTime dt = new DateTime() ;  
               System.out.println("系统日期："+dt.getDate()) ;  
               System.out.println("中文日期："+dt.getDateComplete()) ;  
               System.out.println("时间戳："+dt.getTimeStamp()) ;  
        }  
 };  

基于SimpleDateFormat类操作：

实例：

[java]view plaincopy

import java.util.* ; // 导入需要的工具包
import java.text.* ; // 导入SimpleDateFormat所在的包
class DateTime{ // 以后直接通过此类就可以取得日期时间
private SimpleDateFormat sdf = null ; // 声明SimpleDateFormat对象
public String getDate(){ // 得到的是一个日期：格式为：yyyy-MM-dd HH:mm:ss.SSS
this.sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS") ;
return this.sdf.format(new Date()) ;// 将当前日期进行格式化操作
}
public String getDateComplete(){ // 得到的是一个日期：格式为：yyyy年MM月dd日 HH时mm分ss秒SSS毫秒
this.sdf = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒SSS毫秒") ;
return this.sdf.format(new Date()) ;// 将当前日期进行格式化操作
}
public String getTimeStamp(){ // 得到的是一个时间戳
this.sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS") ;
return this.sdf.format(new Date()) ;// 将当前日期进行格式化操作
}
};
public class DateDemo07{
public static void main(String args[]){
DateTime dt = new DateTime() ;
System.out.println("系统日期："+dt.getDate()) ;
System.out.println("中文日期："+dt.getDateComplete()) ;
System.out.println("时间戳："+dt.getTimeStamp()) ;
}

};

Java常用类库（二）

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

Math与Random类

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

实例：

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

Random类

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

实例：

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

NumberFormat类

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

实例：

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

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

实例：

[java]view plaincopy 
   
 
   
 import java.text.* ;  
 class FormatDemo{  
     public void format1(String pattern,double value){   // 此方法专门用于完成数字的格式化显示  
         DecimalFormat df = null ;           // 声明一个DecimalFormat类的对象  
         df = new DecimalFormat(pattern) ;   // 实例化对象，传入模板  
         String str = df.format(value) ;     // 格式化数字  
         System.out.println("使用" + pattern  
             + "格式化数字" + value + "：" + str) ;  
     }  
 };  
 public class NumberFormatDemo02{  
     public static void main(String args[]){  
         FormatDemo demo = new FormatDemo() ;    // 格式化对象的类  
         demo.format1("###,###.###",111222.34567) ;  
         demo.format1("000,000.000",11222.34567) ;  
         demo.format1("###,###.###￥",111222.34567) ;  
         demo.format1("000,000.000￥",11222.34567) ;  
         demo.format1("##.###%",0.345678) ;  
         demo.format1("00.###%",0.0345678) ;  
         demo.format1("###.###\u2030",0.345678) ;  
     }  
 };  

大数操作类（BigInter、BigDecimal）

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

操作整型：BigInteger

操作小数：BigDecimal

BigDecimal实例：

[java]view plaincopy 
   
 
   
 import java.math.* ;  
 class MyMath{  
     public static double add(double d1,double d2){      // 进行加法计算  
         BigDecimal b1 = new BigDecimal(d1) ;  
         BigDecimal b2 = new BigDecimal(d2) ;  
         return b1.add(b2).doubleValue() ;  
     }  
     public static double sub(double d1,double d2){      // 进行减法计算  
         BigDecimal b1 = new BigDecimal(d1) ;  
         BigDecimal b2 = new BigDecimal(d2) ;  
         return b1.subtract(b2).doubleValue() ;  
     }  
     public static double mul(double d1,double d2){      // 进行乘法计算  
         BigDecimal b1 = new BigDecimal(d1) ;  
         BigDecimal b2 = new BigDecimal(d2) ;  
         return b1.multiply(b2).doubleValue() ;  
     }  
     public static double div(double d1,double d2,int len){      // 进行乘法计算  
         BigDecimal b1 = new BigDecimal(d1) ;  
         BigDecimal b2 = new BigDecimal(d2) ;  
         return b1.divide(b2,len,BigDecimal.ROUND_HALF_UP).doubleValue() ;  
     }  
     public static double round(double d,int len){   // 进行四舍五入  
         BigDecimal b1 = new BigDecimal(d) ;  
         BigDecimal b2 = new BigDecimal(1) ;  
         return b1.divide(b2,len,BigDecimal.ROUND_HALF_UP).doubleValue() ;  
     }  
 };  
   
 public class BigDecimalDemo01{  
     public static void main(String args[]){  
         System.out.println("加法运算：" + MyMath.round(MyMath.add(10.345,3.333),1)) ;  
         System.out.println("减法运算：" + MyMath.round(MyMath.sub(10.345,3.333),3)) ;  
         System.out.println("乘法运算：" + MyMath.round(MyMath.mul(10.345,3.333),2)) ;  
         System.out.println("除法运算：" + MyMath.div(10.345,3.333,3)) ;  
     }  
 };  

BigInteger实例：

[java]view plaincopy 
   
 
   
 import java.math.BigInteger ;  
 public class BigIntegerDemo01{  
     public static void main(String args[]){  
         BigInteger bi1 = new BigInteger("123456789") ;  // 声明BigInteger对象  
         BigInteger bi2 = new BigInteger("987654321") ;  // 声明BigInteger对象  
         System.out.println("加法操作：" + bi2.add(bi1)) ;    // 加法操作  
         System.out.println("减法操作：" + bi2.subtract(bi1)) ;   // 减法操作  
         System.out.println("乘法操作：" + bi2.multiply(bi1)) ;   // 乘法操作  
         System.out.println("除法操作：" + bi2.divide(bi1)) ; // 除法操作  
         System.out.println("最大数：" + bi2.max(bi1)) ;  // 求出最大数  
         System.out.println("最小数：" + bi2.min(bi1)) ;  // 求出最小数  
         BigInteger result[] = bi2.divideAndRemainder(bi1) ; // 求出余数的除法操作  
         System.out.println("商是：" + result[0] +   
             "；余数是：" + result[1]) ;  
     }  
 };  

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

实例：

[java]view plaincopy 
   
 
   
 class Person implements Cloneable{  // 实现Cloneable接口表示可以被克隆   
     private String name ;  
     public Person(String name){  
         this.name = name ;  
     }  
     public void setName(String name){  
         this.name = name ;  
     }  
     public String getName(){  
         return this.name ;  
     }  
     public String toString(){  
         return "姓名：" + this.name ;  
     }  
     public Object clone()  
                 throws CloneNotSupportedException  
     {  
         return super.clone() ;  // 具体的克隆操作由父类完成  
     }  
 };  
 public class CloneDemo01{  
     public static void main(String args[]) throws Exception{  
         Person p1 = new Person("张三") ;  
         Person p2 = (Person)p1.clone() ;  
         p2.setName("李四") ;  
         System.out.println("原始对象：" + p1) ;  
         System.out.println("克隆之后的对象：" + p2) ;  
     }  
 };  

比较器

Comparable接口的作用

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

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

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

代码：

[java]view plaincopy 
   
 
   
 class Student implements Comparable<Student> {    // 指定类型为Student  
     private String name ;  
     private int age ;  
     private float score ;  
     public Student(String name,int age,float score){  
         this.name = name ;  
         this.age = age ;  
         this.score = score ;  
     }  
     public String toString(){  
         return name + "\t\t" + this.age + "\t\t" + this.score ;  
     }  
     public int compareTo(Student stu){  // 覆写compareTo()方法，实现排序规则的应用  
         if(this.score>stu.score){  
             return -1 ;  
         }else if(this.score<stu.score){  
             return 1 ;  
         }else{  
             if(this.age>stu.age){  
                 return 1 ;  
             }else if(this.age<stu.age){  
                 return -1 ;  
             }else{  
                 return 0 ;  
             }  
         }     
     }  
 };  
 public class ComparableDemo01{  
     public static void main(String args[]){  
         Student stu[] = {new Student("张三",20,90.0f),  
             new Student("李四",22,90.0f),new Student("王五",20,99.0f),  
             new Student("赵六",20,70.0f),new Student("孙七",22,100.0f)} ;  
         java.util.Arrays.sort(stu) ;    // 进行排序操作  
         for(int i=0;i<stu.length;i++){   // 循环输出数组中的内容  
             System.out.println(stu[i]) ;  
         }  
     }  
 };  

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

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

手动完成二叉树算法：

[java]view plaincopy 
   
 
   
 class BinaryTree{  
     class Node{         // 声明一个节点类  
         private Comparable data ;   // 保存具体的内容  
         private Node left ;         // 保存左子树  
         private Node right ;        // 保存右子树  
         public Node(Comparable data){  
             this.data = data ;  
         }  
         public void addNode(Node newNode){  
             // 确定是放在左子树还是右子树  
             if(newNode.data.compareTo(this.data)<0){ // 内容小，放在左子树  
                 if(this.left==null){  
                     this.left = newNode ;   // 直接将新的节点设置成左子树  
                 }else{  
                     this.left.addNode(newNode) ;    // 继续向下判断  
                 }  
             }  
             if(newNode.data.compareTo(this.data)>=0){    // 放在右子树  
                 if(this.right==null){  
                     this.right = newNode ;  // 没有右子树则将此节点设置成右子树  
                 }else{  
                     this.right.addNode(newNode) ;   // 继续向下判断  
                 }  
             }  
         }  
         public void printNode(){    // 输出的时候采用中序遍历  
             if(this.left!=null){  
                 this.left.printNode() ; // 输出左子树  
             }  
             System.out.print(this.data + "\t") ;  
             if(this.right!=null){  
                 this.right.printNode() ;  
             }  
         }  
     };  
     private Node root ;     // 根元素  
     public void add(Comparable data){   // 加入元素  
         Node newNode = new Node(data) ; // 定义新的节点  
         if(root==null){ // 没有根节点  
             root = newNode ;    // 第一个元素作为根节点  
         }else{  
             root.addNode(newNode) ; // 确定是放在左子树还是放在右子树  
         }  
     }  
     public void print(){  
         this.root.printNode() ; // 通过根节点输出  
     }  
 };  
 public class ComparableDemo03{  
     public static void main(String args[]){  
         BinaryTree bt = new BinaryTree() ;  
         bt.add(8) ;  
         bt.add(3) ;  
         bt.add(3) ;  
         bt.add(10) ;  
         bt.add(9) ;  
         bt.add(1) ;  
         bt.add(5) ;  
         bt.add(5) ;  
         System.out.println("排序之后的结果：") ;  
         bt.print() ;  
     }  
 };  

另一种比较器：Comparator

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

实例：

[java]view plaincopy 
   
 
   
 import java.util.* ;  
 class Student{  // 指定类型为Student  
     private String name ;  
     private int age ;  
     public Student(String name,int age){  
         this.name = name ;  
         this.age = age ;  
     }  
     public boolean equals(Object obj){  // 覆写equals方法  
         if(this==obj){  
             return true ;  
         }  
         if(!(obj instanceof Student)){  
             return false ;  
         }  
         Student stu = (Student) obj ;  
         if(stu.name.equals(this.name)&&stu.age==this.age){  
             return true ;  
         }else{  
             return false ;  
         }  
     }  
     public void setName(String name){  
         this.name = name ;  
     }  
     public void setAge(int age){  
         this.age = age ;  
     }  
     public String getName(){  
         return this.name ;  
     }  
     public int getAge(){  
         return this.age ;  
     }  
     public String toString(){  
         return name + "\t\t" + this.age  ;  
     }  
 };  
   
 class StudentComparator implements Comparator<Student>{   // 实现比较器  
     // 因为Object类中本身已经有了equals()方法  
     public int compare(Student s1,Student s2){  
         if(s1.equals(s2)){  
             return 0 ;  
         }else if(s1.getAge()<s2.getAge()){   // 按年龄比较  
             return 1 ;  
         }else{  
             return -1 ;  
         }  
     }  
 };  
   
 public class ComparatorDemo{  
     public static void main(String args[]){  
         Student stu[] = {new Student("张三",20),  
             new Student("李四",22),new Student("王五",20),  
             new Student("赵六",20),new Student("孙七",22)} ;  
         java.util.Arrays.sort(stu,new StudentComparator()) ;    // 进行排序操作  
         for(int i=0;i<stu.length;i++){   // 循环输出数组中的内容  
             System.out.println(stu[i]) ;  
         }  
     }  
 };  

观察者设计模式

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

代码：

[java]view plaincopy 
   
 
   
 import java.util.* ;  
 class House extends Observable{ // 表示房子可以被观察  
     private float price ;// 价钱  
     public House(float price){  
         this.price = price ;  
     }  
     public float getPrice(){  
         return this.price ;  
     }  
     public void setPrice(float price){  
         // 每一次修改的时候都应该引起观察者的注意  
         super.setChanged() ;    // 设置变化点  
         super.notifyObservers(price) ;// 价格被改变  
         this.price = price ;  
     }  
     public String toString(){  
         return "房子价格为：" + this.price ;  
     }  
 };   
 class HousePriceObserver implements Observer{  
     private String name ;  
     public HousePriceObserver(String name){ // 设置每一个购房者的名字  
         this.name = name ;  
     }  
     public void update(Observable o,Object arg){  
         if(arg instanceof Float){  
             System.out.print(this.name + "观察到价格更改为：") ;  
             System.out.println(((Float)arg).floatValue()) ;  
         }  
     }  
 };  
 public class ObserDemo01{  
     public static void main(String args[]){  
         House h = new House(1000000) ;  
         HousePriceObserver hpo1 = new HousePriceObserver("购房者A") ;  
         HousePriceObserver hpo2 = new HousePriceObserver("购房者B") ;  
         HousePriceObserver hpo3 = new HousePriceObserver("购房者C") ;  
         h.addObserver(hpo1) ;  
         h.addObserver(hpo2) ;  
         h.addObserver(hpo3) ;  
         System.out.println(h) ; // 输出房子价格  
         h.setPrice(666666) ;    // 修改房子价格  
         System.out.println(h) ; // 输出房子价格  
     }  
 };  

正则表达式

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

不使用正则：

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

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

使用正则表达式：

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

Pattern、Matcher类

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

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

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

实例：

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

String类对正则的支持

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

实例：

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

定时调度

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

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

具体实例：

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

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