Java常用類庫有哪些

這篇文章給大家分享的是有關Java常用類庫有哪些的內容。小編覺得挺實用的，因此分享給大家做個參考，一起跟隨小編過來看看吧。

1）：StringBuffer類：

String、StringBuffer、StringBuilder的區別

1.String一旦聲明，不可改變，StringBuffer與StringBuilder聲明的內容可以改變

2.StringBuffer類中提供的方法都是同步方法，屬于安全的線程操作，而StringBuilder類中大的方法都是屬于異步方法，屬于非線程安全的操作。

2）：Runtime類

Runtime類是Java中與運行時環境有關的操作類，利用此類可以取得系統的內存信息，也可以利用此類產生新的操作系統進程對象。

Runtime類表示運行時操作類，是一個封裝了JVM進程的類，每一個JVM都對應著一個Runtime類的實例，此實例由JVM運行時為其實例化。

Runtime run = Runtime.getRuntime();

package library;
 
public class RuntimeDemo {
	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 i = 0; i < 100; i++) {//循環修改Sting，產生多個垃圾，會占用內存
			str+=i;
		}
		System.out.println("操作String之后的，JVM空閑內存量："+run.freeMemory());//觀察有多個垃圾空間產生之后的內存空閑量
		run.gc();//進行垃圾收集，釋放空間
		System.out.println("垃圾回收之后的，JVM空閑內存量："+run.freeMemory());//垃圾收集之后的內存空閑量。
	}
}

結果：

JVM最大內存量：66650112

JVM空閑內存量：4934616

HelloWorld!!!WelcomeToMLDN~

操作String之后的，JVM空閑內存量：4877968

垃圾回收之后的，JVM空閑內存量：5015840

1.GC（Garbage Collector，垃圾收集器）指的是釋放無用的內存空間。

2.GC會由系統不定期進行自動回收，或者調用Runtime類中的gc()方法手工回收。

Runtime類與Process類

調用本機可執行程序

package library;
 
import java.io.IOException;
 
/**
 * 調用本機可以執行程序
 * 讓記事本進程5s后消失
 */
public class RuntimeDemo2 {
	public static void main(String[] args) {
		Runtime run = Runtime.getRuntime();//通過Runtime類的靜態方法為其進行實例化操作
		Process pro = null;//聲明一個Process對象，接受啟動的進程
		try {
			pro = run.exec("notepad.exe");//調用本機程序，必須進行異常處理
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();//打印異常信息
		}
		try {
			Thread.sleep(5000);//讓此線程存活5s
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();//打印異常信息
		}
		pro.destroy();//結束此進程
	}
}

3）：國際化程序

國際化操作是指程序可以同時適應多門語言。

實現國際化光靠Locale類是不夠的，還需要屬性文件和ResourceBundle類的支持。屬性文件是指擴展名為.properties的文件，文件中的內容保存結構是一種“key=value”的形式，因為國際化的程序只顯示語言的不同，那么就可以根據不同的國家定義不同的屬性文件，屬性文件中保存真正要使用的文字信息，要訪問這些屬性文件，可以使用ResourceBundle類來完成。

實現java程序國際化操作必須通過一下3各類完成：

java.util.Local-----java.util.ResourceBundle---MessageFormat

通過Locale類所指定的區域碼，然后ResourceBundle根據Locale類所指定的區域碼找到相應的資源文件，如果資源文件（屬性文件）中存在動態文本，子使用MesssageFormat進行格式化。

屬性文件定義時，必須要按照“名稱_國家代碼”的形式命名，即所有的相關屬性文件的名稱全部一樣，只有國家的代碼不一樣，代碼如下

（處理動態文本：以中文為例是：”你好，xxx！“，其中“xxx”的內容是由程序動態設置的，那么就需要使用占位符清楚地表示出動態文本的位置，占位符使用“{編號}”的格式出現。使用占位符之后，程序可以使用MessageFormat對信息進行格式化。為占位符動態設置文本的內容。）

1.中文的屬性代碼文件：Message_zh_CN.propertiesinfo = \u4f60\u597d\uff01

以上信息就是中文：你好，{0}！

2.英語屬性文件：Message_en_US.properties

info = Hello，{0}!

3.法語屬性文件：Message_fr_FR.properties

info = Bonjour，{0}!

通過Locale類和ResourceBundle類讀取屬性文件的內容，代碼如下：

package library;
 
import java.text.MessageFormat;
import java.util.Locale;
import java.util.ResourceBundle;
 
public class InterDemo {
	public static void main(String[] args) {
		Locale zhLoc = new Locale("zh","CN");//表示中國地區
		Locale enLoc = new Locale("en","US");
		Locale frLoc = new Locale("fr","FR");
		ResourceBundle zhrb = ResourceBundle.getBundle("Message",zhLoc);//找到中文的屬性文件（.getBundle(文件名稱,區域碼)）
		ResourceBundle enrb = ResourceBundle.getBundle("Message",enLoc);
		ResourceBundle frrb = ResourceBundle.getBundle("Message",frLoc);
		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, "nihao"));
		System.out.println("法文："+MessageFormat.format(str3, "nihao"));
		
	}
}

結果：

中文：你好，你好！

英文：Hello,Hello!

法文：Bonjour，Hello!

多個占位符設置多個動態文本：

MessageFormat.format(str1,"你好"，“hello”,"hello")

info = Hello，{0}，{1}，{2}！

4）：System類、

System類是一些與系統相關的屬性和方法的集合，而且在System類中所有的書信給都是靜態的，要引用這些屬性和方法，直接使用System類調用即可。

System.gc()：垃圾對象的回收，如果在一個對象被回收之前要進行某些操作，那么該怎么辦呢，實際上，在Object類中有一個finalize()方法，此方法定義如下：

protected  void finalize() throws Throwable
package library.finalize;
 
public class Person {
	private String name; 
	private int age ;
	
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "年齡：age=" + age + ",姓名： name=" + name ;
	}
	public void finalize()throws Throwable{//對象釋放空間時默認調用此方法
		System.out.println("對象被釋放 -->"+this);//直接打印對象調用toString
	}
	
	public static void main(String[] args) {
		Person per = new Person("張三",30);
		per = null;//斷開引用釋放空間
		//以上代碼不會在顯示器顯示輸出
		System.gc();//強制性釋放空間，，會調用fianlize()方法
	}
	
}

結果：

對象被釋放 -->年齡：age=30,姓名： name=張三

5）：日期操作類

Date類：實例化對象  Date date = new Date();------輸出當前日期

Calendar類，可以將取得的時間精確到毫秒，但是他是一個抽象類，依靠其子類GregorianCalendar類。

Dateformat類

SimpleDateFormat類

6）Math類

7）：Random類

8）：NumberFormat類

9）：BigInteger類

10）：Bigdecimal類

11）：對象克隆技術

12）：Arrays類

package library;
 
import java.util.Arrays;
 
public class ArraysDemo {
	public static void main(String[] args) {
		int temp[] = {3,5,7,9,1,2,6,8};
		Arrays.sort(temp);	//數組排序
		System.out.println("排序后數組：");
		System.out.println(Arrays.toString(temp));//以字符串輸出數組
		int point = Arrays.binarySearch(temp, 3);//檢索數據位置
		System.out.println("元素3的位置在："+point);
		Arrays.fill(temp, 3);					//填充數組
		System.out.println("數組填充：");
		System.out.println(Arrays.toString(temp));//一字符串輸出數組
	}
}

結果：

排序后數組：

[1, 2, 3, 5, 6, 7, 8, 9]

元素3的位置在：2

數組填充：

[3, 3, 3, 3, 3, 3, 3, 3]

13）：Comparable接口

比較器主要是針對對象數組的操作

package library.comparabledemo;
 
import java.util.Arrays;
 
public class Student implements Comparable<Student> {
 
	private String name;
	private int age;
	private float score;
	
	public Student(String name, int age, float score) {
		super();
		this.name = name;
		this.age = age;
		this.score = score;
	}
 
	@Override
	public String toString() {
		return "Student [age=" + age + ", name=" + name + ", score=" + score
				+ "]";
	}
 
	@Override
	public int compareTo(Student o) {
		if (this.score>o.score) {
			return -1;
		}else if (this.score<o.score) {
			return 1;
		} else {
			if (this.age>o.age) {
				return 1;
			}else if (this.age<o.age) {
				return -1;
			}else {
				return 0;
			}
		}
	}
	public static void main(String[] args) {
		Student stu[] = {new Student("張三",20,90.0f),new Student("王五", 20, 99.0f),
				new Student("孫七", 22, 100.0f),new Student("李四", 22, 9.0f),
				new Student("趙六", 20, 70.0f),};
		Arrays.sort(stu);
		for (int i = 0; i < stu.length; i++) {
			System.out.println(stu[i]);
		}
	}
}

結果：

Student [age=22, name=孫七, score=100.0]

Student [age=20, name=王五, score=99.0]

Student [age=20, name=張三, score=90.0]

Student [age=20, name=趙六, score=70.0]

Student [age=22, name=李四, score=9.0]

分析比較器的排序原理

使用的是二叉樹排序方法，即通過二叉樹進行排序，然后利用中序遍歷的方式把內容依次讀取出來。

二叉樹排序的基本原理就是：將第1個內容作為根節點保持，如果后面的值比根節點的值小，則放在根節點的左子樹，如果后面的值比根節點的值大，則放在根節點的右子樹。

找這樣的思路，如果給出了一下數字：8、3、10、14、6、4、7、1、13

在根據中序遍歷的原理（左子樹---根節點---右子樹的方式），排序后的結果：1、3、4、6、7、8、10、13、14

package library.comparabledemo;
 
public class BinaryTree {
	class Node{											//申明一個節點類
		private Comparable data;						//保存具體類容
		private Node left;								//保存左子樹
		private Node right;								//保存右子樹
		
		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){						//如果左子樹有值，則遞歸調用該方法，該操作會將中序，root.data左邊的數字現輸出，而且時從小到大的順序
				this.left.printNode();
			}
			System.out.print(this.data+"\t");			//輸出root.data--->根節點
			if (this.right!=null) {						//如果右子樹有值，則遞歸調用該方法，該操作會將中序，root.data左邊的數字現輸出，而且時從小到大的順序
				this.right.printNode();
			}
		}
	}
	
	private Node root;									//根元素
	
	public void add(Comparable data){
		Node newNode = new Node();						//每傳入一個數值，就聲明一個新的根節點
		newNode.data = data;
		if (root == null) {
			root = newNode;								//如果是第1個元素，設置根節點
		}else {
			root.addNode(newNode);						//確定結點是放在左子樹還是右子樹
		}
	}
	
	public void print(){								//輸出節點
		this.root.printNode();
	}
	
	public static void main(String[] args) {
		BinaryTree bt = new BinaryTree();
		bt.add(8);
		bt.add(7);
		bt.add(14);
		bt.add(10);
		bt.add(4);
		bt.add(1);
		bt.add(13);
		bt.add(6);
		bt.add(3);
		System.out.println("排序后的結果：");
		bt.print();
	}
}

結果：

排序后的結果：

1 3 4 6 7 8 10 13 14

15）：Observable類和Observer接口

他們可實現觀察者模式

16）：正則表達式

常用正則規則

數量表示（X表示一組規范）

邏輯運算符（X、Y表示一組規范）

package library.regex;
 
public class RegexDemo1 {
 
	public static void main(String[] args) {
		String info = "LXH:98|MLDN:90|LI:100";
		String s[] = info.split("|");			//按照“|”拆分
		System.out.println("字符串的拆分：");
		for (int i = 0; i < s.length; i++) {
			System.out.print(s[i]+"、");
		}
	}
}

結果：

字符串的拆分：

、L、X、H、:、9、8、|、M、L、D、N、:、9、0、|、L、I、:、1、0、0、

package library.regex;
 
public class RegexDemo2 {
	public static void main(String[] args) {
		String info = "LXH:98|MLDN:90|LI:100";
		String s[] = info.split("\\|");			//按照“|”拆分,需要轉義
		System.out.println("字符串的拆分：");
		for (int i = 0; i < s.length; i++) {
			String s2[] = s[i].split(":");
			System.out.println("\t|--"+s2[0]+"\t"+s2[1]);
		}
	}
}

字符串的拆分：

|--LXH 98

|--MLDN 90

|--LI 100

17）：定時調度---Timer類、TimerTask類

Timer類是一個線程設施，可以用來實現在某一個時間或某一段時間后按排某一個任務執行一次或定期重復執行。該功能要與TimerTask配合使用。

package library.timer;
 
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimerTask;
 
public class MyTask extends TimerTask {			//任務調度類要繼承TimmerTask類
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		SimpleDateFormat sdf = null;
		sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSSS");
		System.out.println("當前系統時間："+sdf.format(new Date()));
	}
 
}

package library.timer;
 
import java.util.Timer;
 
public class TestTask {
	public static void main(String[] args) {
		Timer t = new Timer();				//建立Timer對象
		MyTask mt = new MyTask();			//定義任務
		t.schedule(mt, 1000,2000);			//設置任務的執行，1秒后開始，每2秒重復
	}
}

部分結果：

當前系統時間：2018-11-22 00:09:27:0842

當前系統時間：2018-11-22 00:09:29:0816

當前系統時間：2018-11-22 00:09:31:0826

當前系統時間：2018-11-22 00:09:33:0840

要點：

1. 字符串頻繁修改使用StringBuffer類，線程安全

2. Runtime表示運行時，在JVM中只有一個Runtime，所以想取得Runtime類的對象，直接使用Runtime類中提供的靜態方法getRuntime()即可

3. 國際化程序實現的基本原理：所有的語言信息已key-->value的形式保存在資源文件中，程序通過key找到相應的value，根據其所設置國家的Locale對象不同，找到的資源文件也不同，要想實現國際化必須依靠Locale、ResourceBundle兩類共同完成

4. System是系統類，可以取得系統的相關信息，使用System.gc()方法可以強制性進行垃圾回收操作，調用此方法實際上就是調用Runtime類中的gc()方法

5. Format類為格式操作類，主要的3個子類是Messageformat、NumberFormat、DateFormat。

6. 使用Date類可以方便的取得時間，但取得時間格式不符合低于的習慣，所有可以使用SimpleDateFormat類進行日期的格式化操作

7. 處理大數字可以使用BigInteger、BigDecimal，當需要精確小數點操作位數時，使用Bigdecimal類即可

8. 通過Random類可以取得指定范圍的隨機數字

9. 如果一個類的對象要箱被克隆，則此對象所在的類必須實現Cloneable接口

10. 要箱對一組對象進行排序，則必須使用比較器。比較器接口Comparable中定義了一個compareTo()的比較方法，用來設置比較規則。

11. 正則表達式是在開發中最常使用的一種驗證方法，String類中的replaceAll()、split()、matches()方法都是對正則有所支持

12. 可以使用Timer類和TimerTask類完成系統的定時操作。

感謝各位的閱讀！關于“Java常用類庫有哪些”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，讓大家可以學到更多知識，如果覺得文章不錯，可以把它分享出去讓更多的人看到吧！