Day13-Java

文章目錄

Day13-Java
- - 1、執行緒池
  - - - 1.1 執行緒池概念
      - 1.2 執行緒池的實作
  - 2、StringBuffer類
  - - 面試題：請解釋String、StringBuffer、StringBuilder的區別?
  - 3、Runtime類
  - - 面試題：什么叫gc？如何處理
  - 4、System類
  - - 面試題：請解釋final、finally、finalize的區別？
  - 5、物件克隆
  - 6、Date類
  - - - 6.1 日期處理類—Date類
      - 6.2 日期格式化—SimpleDateFormat類（核心）
  - 7、數字操作類—Math類
  - - - 7.1 亂數—Random()
      - 7.2 大數字操作類
  - 8、Arrays類
  - 9、比較器—Comparable
  - - - 9.1 Comparable
      - 9.2 二叉樹( Binary Tree )
  - 10、國際化

1、執行緒池

執行緒池就是多個執行緒封裝在一起操作，

1.1 執行緒池概念

在生活中經常遇見，今天開發一個專案需要20個人一起開發

這個活很大，有多少人要多少人
這個活很大，但是要求10個人
這個活很大，但只要求1個人做

追加一個并發訪問的程式報：java.util.concurrent,對于此執行緒池的操作的核心類和介面就定義在之中，這里面有兩個核心的介面：

普通的執行執行緒池定義：Interface ExecutorService
調度執行緒池：Interface ScheduledExecutorService

如果要進行執行緒池的創建一般使用Class Executors這個類

創建無法小限制的執行緒池：public static ExecutorService newCachedThreadPool()
創建固定大小的執行緒池：public static ExecutorService newFixedThreadPool(int nThreads)
單執行緒池：public static ExecutorService newSingleThreadExecutor()
創建定時調度池：public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

1.2 執行緒池的實作

創建無限大小的執行緒池

package com.day13.demo;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class PoolDemo1 {

	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		//創建了一個執行緒池的模型，但是后面沒有執行緒
		ExecutorService executorService = Executors.newCachedThreadPool();
		for (int i = 0; i < 10; i++) {
			int index = i;
			Thread.sleep(200);
			executorService.submit(()-> {
				System.out.println(Thread.currentThread().getName() + ",i = " + index);
			});
		}
		executorService.shutdown();
	}
}

創建固定大小的執行緒池

package com.day13.demo;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class PoolDemo1 {

	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		//創建了一個執行緒池的模型，但是后面沒有執行緒
		ExecutorService executorService = Executors.newFixedThreadPool(3);
		for (int i = 0; i < 10; i++) {
			int index = i;
			Thread.sleep(200);
			executorService.submit(()-> {
				System.out.println(Thread.currentThread().getName() + ",i = " + index);
			});
		}
		executorService.shutdown();
	}
}

創建我們的單執行緒執行緒池

package com.day13.demo;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class PoolDemo1 {

	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		//創建了一個執行緒池的模型，但是后面沒有執行緒
		ExecutorService executorService = Executors.newSingleThreadExecutor();
		for (int i = 0; i < 10; i++) {
			int index = i;
			executorService.submit(()-> {
				System.out.println(Thread.currentThread().getName() + ",i = " + index);
			});
		}
		executorService.shutdown();
	}
}

定時調度池

package com.day13.demo;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class PoolDemo1 {

	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		//創建了一哥具備有三個執行緒大小的定時調度池
		ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);
		for (int i = 0; i < 10; i++) {
			//Thread.sleep(200);
			int index = i;
			executorService.scheduleAtFixedRate(new Runnable(){
				@Override
				public void run() {
					// TODO Auto-generated method stub
						System.out.println(Thread.currentThread().getName() + ",i = " + index);
				}
				
			}, 3, 2, TimeUnit.SECONDS);//使用的是一個秒的單位，表示3秒后開始執行，而后每過2秒執行一次
		}
	}
}

執行緒池給我們開發者帶來唯一好處的就是允許多個執行緒按照組的模式進行程式的處理，這樣在一個業務邏輯非常復雜的情況下，性能就會得到很好的提升，

2、StringBuffer類

對于類別庫的學習，不可能全學完，你所需要知道就是如何面對解決問題的方法，要學會查詢檔案，

StringBuffer類之前首先來簡單回顧一下String類的特點：

? String類的物件有兩種實體化方式，一種是直接賦值，只會開辟一塊堆記憶體空間，而且物件可以自動入池，另外一種方式使用構造方法完成，會開辟兩塊空間，有一塊空間將稱為垃圾，并且不會自動入池，但是可以通過intern()方法手工入池；

? 字串常亮一旦宣告則不能改變，而字串物件可以改變，但是改變的是其記憶體地址的指向；

通過以上的幾個特點就可以清楚的發現，String類是表示字串使用最多的類，但是其不合適于被頻繁修改的字串操作上，所以在這種情況下，往往可以使用StringBuffer類，即：StringBuffer類方便用戶進行內容的修改，在String類之中使用“+”作為資料庫的連接操作，而在StringBuffer類之中使用append()方法進行資料的連接，

使用StringBuffer操作，StringBuffer內容可以改變，

package com.day13.demo;

public class BufferDemo {
	public static void main(String[] args) {
		StringBuffer buf = new StringBuffer();
		buf.append("hello").append(",world!");
		fun(buf);//修改了buf的內容
		System.out.println(buf);
	}
	public static void fun(StringBuffer tem){
		tem.append("\n").append("zsr");
	}
}

String和StringBuffer最大的區別就是：String的內容無法修改，而StringBuffer的內容可以修改，但是在開發的選擇還是優先選擇String類，

現在學習的字串的操作類就有兩個了：String，StringBuffer，那么下面通過這兩個類的定義來研究一下關系：

String類：	StringBuffer類：
public final class String extends Object implements Serializable,Comparable,CharSequence	public final class StringBuffer extends Object implements Serializable, CharSequence

可以發現兩個類都是“CharSequence”介面的子類，這個介面描述的是字符集，所以串就屬于字符集的子類，如果以后看見CharSequence最簡單的聯想就是字串，但是有一個小小的問題需要注意一下就是String和StringBuffer兩個型別無法直接轉換，

利用StringBuffer：利用StringBuffer構造方法、append()方法

將String變為StringBuffer

1.直接利用StringBuffer類的構造方法，public StringBuffer(String str)

package com.day13.demo;

public class BufferTest{
	public static void main(String[] args) throws Exception {
		String str = "Hello World.";
		StringBuffer buf = new StringBuffer(str);
		fun(buf);
		System.out.println(buf);
}
	private static void fun(StringBuffer temp) {
		temp.append("\n").append("zsr");
	}
}

2.利用StringBuffer類的append()方法

package com.day13.demo;

public class BufferTest{
	public static void main(String[] args) throws Exception {
		String str = "Hello World.";
		StringBuffer buf = new StringBuffer();
		buf.append(str);
		fun(buf);
		System.out.println(sb);
	}
	private static void fun(StringBuffer temp) {
		temp.append("\n").append("zsr");
	}
}

將StringBuffer變成String，利用StringBuffer類的toString()方法完成

package com.day13.demo;

public class BufferTest{
	public static void main(String[] args) throws Exception {
		StringBuffer buf = new StringBuffer("hello,World!");
		String str = buf.toString();
		System.out.println(str);
	}
}

實際上StringBuffer還是有一些String類所沒有的特點的，

1.字串反轉操作，public StringBuffer reverse()

package com.day13.demo;

public class BufferTest{
	public static void main(String[] args) throws Exception {
		StringBuffer buf = new StringBuffer("hello,World!");
		System.out.println(buf.reverse());
	}
}

2.洗掉指定范圍內的資料，public StringBuffer delete(int start, int end)

package com.day13.demo;

public class BufferDemo {
	public static void main(String[] args) {
		StringBuffer buf = new StringBuffer("Hello,World!");
		System.out.println(buf.delete(5, 11));
    }
}

3.插入資料的方法， public StringBuffer insert(int offset, Object obj)

package com.day13.demo;

public class BufferDemo {
	public static void main(String[] args) {
		StringBuffer buf = new StringBuffer("Hello,World!");
		System.out.println(buf.delete(5,11).insert(0, "你好，"));
	}
}

面試題：請解釋String、StringBuffer、StringBuilder的區別?

String的內容不可以修改，StringBuffer與StringBuilder內容可以修改
StringBuffer采用同步處理屬于執行緒安全操作，StringBuilder采用異步處理屬于執行緒不安全操作，

3、Runtime類

在每一個JVM的行程中，都會存在一個運行時的操作類的物件，而這物件所屬的型別就是Runtime類，打開這個類的檔案，發現這個類之中并沒有構造方法的定義，可是按照之前所學，每個類至少有一個構造方法，而這個類的構造方法實際上存在只是不被外部看見而已，因為構造方法私有化了，這是一個標準的單例設計模式，既然是單例設計模式則在這個類之中一定會存在一個static型方法，可以取得本類的Runtime實體化物件：public static Runtime getRuntime()，

取得了Runtime類之后最主要的功能就是可以通過它來觀察當前的記憶體操作情況：

方法名稱	型別	描述
public long freeMemory()	普通	取得當前空余記憶體空間大小
public long totalMemory()	普通	取得當前可以使用總空間大小
public long maxMemory()	普通	取得最大的可用記憶體空間的大小
public native void gc()	普通	執行垃圾收集處理

觀察一下記憶體資訊的取得

package com.day13.demo;

public class RuntimeDemo {
	public static void main(String[] args) {
		Runtime run = Runtime.getRuntime();
		System.out.println("1、MAX=" + byteToM(run.maxMemory()));
		System.out.println("1、TOTAL=" +  byteToM(run.totalMemory()));
		System.out.println("1、FREE=" +  byteToM(run.freeMemory()));
	}
	public static double byteToM(long num){
		return (double) num / 1024 / 1024;
	}
}

gc垃圾回收

package com.day13.demo;

public class RuntimeDemo {
	public static void main(String[] args) {
		Runtime run = Runtime.getRuntime();
		System.out.println("1、MAX=" + byteToM(run.maxMemory()));
		System.out.println("1、TOTAL=" +  byteToM(run.totalMemory()));
		System.out.println("1、FREE=" +  byteToM(run.freeMemory()));
		String str = "";
		for (int i = 0; i < 2222; i++) {
			str += i;
		}
		System.out.println("2、MAX=" + byteToM(run.maxMemory()));
		System.out.println("2、TOTAL=" +  byteToM(run.totalMemory()));
		System.out.println("2、FREE=" +  byteToM(run.freeMemory()));
		run.gc();//垃圾收集
		System.out.println("3、MAX=" + byteToM(run.maxMemory()));
		System.out.println("3、TOTAL=" +  byteToM(run.totalMemory()));
		System.out.println("3、FREE=" +  byteToM(run.freeMemory()));
	}
	public static double byteToM(long num){
		return (double) num / 1024 / 1024;
	}
}

面試題：什么叫gc？如何處理

gc（Garbage Conllector）：垃圾收集器，用于釋放無用的記憶體空間
gc有兩種處理形式，一種是自動不定期呼叫，另外一種是使用Runtime的gc()方法手工處理呼叫，

4、System類

實際上在之前進行的陣列拷貝就是運用System類中的public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)

在這個類中提供有一個取得當前日期時間數的方法**public static long currentTimeMillis()；**通過此方法可以取得某一個操作花費的時間，

觀察currentTimeMillis()的使用

package com.day13.demo;

public class SystemDemo {
	public static void main(String[] args) {
		long start = System.currentTimeMillis();
		String str = "";
		for (int i = 0; i < 2222; i++) {
			str += i;
		}
		long end = System.currentTimeMillis();
		System.out.println("花費時間：" + (end - start) + "ms");
	}
}

可是在System類之中還存在了一個很有意思的方法：public static void gc()，但是這個gc()方法并不是一個新的gc()方法而是間接呼叫了一個Runtime類之中的gc()方法，不表示一個重寫的方法，

在之前一直強調過一個概念：一個類物件的創建一定要使用構造方法，那么一個物件不使用構造方法了，就一個被釋放，被釋放的時候一改也有一個方法進行支持才對，所以要想做這種收尾的操作，可以讓一個類去覆寫object中的finalize()方法，此方法由Object類定義：protected void finalize() throws Throwable，在物件回收之前有可能出現例外或者錯誤，但是即使出現了也不會影響程式的執行，即：不會因為例外而導致程式的中斷執行，

finalize()方法使用

package com.day13.demo;
class Person{
	public Person(){
		System.out.println("問啊娃娃，出來了！");
	}

	@Override
	protected void finalize() throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("我要下地獄了，下輩子不要當人了——");
		throw new Exception("繼續要活幾千年");
	}
	
}
public class FinalizeDemo {
	public static void main(String[] args) {
		Person person = new Person();
		person = null;
		System.out.println("已經轉世不為人了");
		System.gc();
	}
}

面試題：請解釋final、finally、finalize的區別？

final是一個關鍵字，用于定義不能夠被繼承的父類、不能夠覆寫的常量
finally是例外處理的統一出口
finalize是Object類中的方法，用于在物件回收前進行呼叫

5、物件克隆

克隆就是物件復制的一個概念，不過這種概念一般使用的比較少，因為很少有人去復制已經存在的物件，Object類本身就支持物件克隆方法，可以發現protected Object clone() throws CloneNotSupportedException；我們要想實作克隆，那么我們并不是所有類的物件可以隨便克隆，需要被克隆的物件所在類一定要實作Cloneable介面，而最關鍵的是該介面并沒有任何的抽象方法，所以該介面只是一個標識介面，表示一種能力，

物件克隆實作

package com.day13.demo;
class Per implements Cloneable{//必須實作此介面
	private String name;
	private int age;
	public Per(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 "Per [name=" + name + ", age=" + age + "]";
	}
	@Override
	//覆寫權限擴大  protected 擴大到 public
	public Object clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		return super.clone();//父類負責克隆
	}
}
public class CloneDemo {
	public static void main(String[] args) throws Exception{
		 Per perA = new Per("kaco",12);
		 //perA.clone();不能在這寫的原因是因為此方法是protected權限 只能在不同包的子類中實作此方法
		 Per perB = (Per) perA.clone();
		 perB.setAge(100);
		 System.out.println(perA);
		 System.out.println(perB);
	}
}

意義不大，需要清楚表示介面的作用，表示的是一個能力，

6、Date類

日期資料型別一定要重視，所有的開發必定要有日期，

6.1 日期處理類—Date類

java.util.data類是在整個程式處理之中唯一可以取得日期當前日期實體化物件的操作方法，也就是說我們要取出當前日期輸出Date類物件即可，

package com.day13.demo;

import java.util.Date;

public class DateDemo1 {
	public static void main(String[] args) {
		Date date = new Date();
        //Tue Aug 17 17:01:50 CST 2021
		System.out.println(date);
	}
}

在Date類中最需要關心的一個核心問題：long可以描述日期，看了一通過Date類中提供的方法來進行觀察，

方法名稱	型別	描述
public Date(long date)	普通	將long型別變為Date型別資料
public long getTime()	普通	將Date型別變為long型別資料

觀察轉化

package com.day13.demo;

import java.util.Date;

public class DateDemo1 {
	public static void main(String[] args) {
		long num = System.currentTimeMillis();
		System.out.println(new Date(num));
		System.out.println(new Date(num).getTime());
	}
}

這中簡單的轉換在以后的程式開發經常會使用，

6.2 日期格式化—SimpleDateFormat類（核心）

雖然Date可以取得當前的日期時間，但是取出的結構不是我們所喜歡的格式，這時候就需要我們進行格式的轉化，使用的是java.text包

但是日期格式里面需要設定一些日期標記：年(YYYY)、月(MM)、日(dd)、時(HH)、分(mm)、秒(ss)、毫秒(SS);

實作日期格式化處理（日期格式化之后是字串）

package com.day13.demo;

import java.text.SimpleDateFormat;
import java.util.Date;

public class DateDemo1 {
	public static void main(String[] args) {
		Date date = new Date();
		String str = "YYYY-MM-dd HH:mm:ss";
		SimpleDateFormat sdf = new SimpleDateFormat(str);
		String dateFromat = sdf.format(date);
		System.out.println(dateFromat);
	}
}

將字串變為Date型別

package com.day13.demo;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateDemo2 {
	public static void main(String[] args) throws ParseException{
		Date date = new Date();
		System.out.println(date);
		String str = "yyyy-MM-dd HH:mm:ss";
		SimpleDateFormat sdf = new SimpleDateFormat(str);
		//將Date型別轉化為字串型別
		String newdateStirng = sdf.format(date);
		System.out.println(newdateStirng);
		//將字串轉化為Date型別
		Date newdate = sdf.parse(newdateStirng);
		System.out.println(newdate);
	}
}

7、數字操作類—Math類

在Java.lang.Math類之中定義了所有的于數學有關的基本公式，在這個類之中所有的方法都是static型的方法，強調一個方法：round()，public static long round(double a)，表示四舍五入，

package com.day13.demo;

public class MathDemo {
	public static void main(String[] args) {
		System.out.println(Math.round(13.51));
		System.out.println(Math.round(13.5));
		//如果負數小數，沒大于0.5都不進位
		System.out.println(Math.round(-13.51));
		System.out.println(Math.round(-13.5));//-13
	}	
}

希望可以準確的保存小數位進行處理，

需要保留幾位小數

package com.day13.demo;
class MyMath{
	public static double round(double num, int scale){
		return Math.round(num * Math.pow(10, scale)) / Math.pow(10, scale);
	}
}
public class MathDemo {
	public static void main(String[] args) {
        //1234.457
		System.out.println(MyMath.round(1234.4567, 3));
	}	
}

7.1 亂數—Random()

Java .util.Random的主要主要作用就是產生亂數，下面通過一個代碼來觀察就行，

網站開發的隨機驗證碼

package com.day13.demo;

import java.util.Random;

public class RandomDemo {
	public static void main(String[] args) {
		char data [] = new char[]{'a','b','c','d','e'};
		for (int i = 0; i < 4; i++) {
			System.out.print(data[new Random().nextInt(data.length)]);
		}
	}
}

7.2 大數字操作類

如果說現在有兩個非常大的數字要進行數學操作，你們認為要怎么做？這個時候數字已經超過了double的范圍，那么只能利用字串來表示，取出每一個字串變為數字后進行數學計算，這種方式的難度較高，為了解決這種問題，在Java之中提供了兩個大數字操作類：java.math包中BigInteger,BigDecimal，而這兩個類是屬于Number的子類，

? 1.大整數操作類：BigIntegr

之前已經強調過了，如果數字較大，肯定按照String來處理，所以這一點可以通過Biginteger的構造方法來觀察：

? 構造：public BigInteger(String val)；

而且在BigInteger類之中定義了一些基本的數學計算：

? 加法：public BigInteger add(BigInteger val)；

? 減法：public BigInteger subtract(BigInteger val)；

? 乘法：public BigInteger multiply(BigInteger val)；

? 除法（不保存余數）：public BigInteger divide(BigInteger val)；

? 除法（保存余數）：public BigInteger divideAndRemainder(BigInteger val)

大數的四則運算

package com.day13.demo;

import java.math.BigInteger;

public class BigAddDemo {
	public static void main(String[] args) {
		BigInteger bigA = new BigInteger("123712487812974891274891274128947891");
		BigInteger bigB = new BigInteger("43895748395789347589347589398");
		System.out.println("加法計算：" + bigA.add(bigB));
		System.out.println("減法計算：" + bigA.subtract(bigB));
		System.out.println("乘法計算：" + bigA.multiply(bigB));
		System.out.println("除法計算：" + bigA.divide(bigB));
		BigInteger result[] = bigA.divideAndRemainder(bigB);
		System.out.println("除法計算：" + result[0] + "." + result[1]);
	}
}

? 2.大小數操作類：BigDcimal

BigDecimal類表示的是大小數操作類，但是這個類也具備了于之前同樣的基本計算方式，而在實際的作業之中，是用這個類最多的情況是進行準確位數的四舍五入操作，如果要完成這一操作需要關心BigDecimal類中的以下定義：

構造：public BigDecimal(double val)；

除法：public BigDecimal divide(BigDecimal divisor ,int scale ,int roundingMode)；

進位模式：public static final int ROUND_HALF_UP，

四舍五入進位操作

package com.day13.demo;

import java.math.BigDecimal;
//大數進位方法
class MyMath1{
	public static double round(double num, int scale){
		return new BigDecimal(num).divide(new BigDecimal(1), scale, BigDecimal.ROUND_HALF_DOWN).doubleValue();
	}
}
public class BigDecimalDemo {
	public static void main(String[] args) {
		System.out.println(MyMath1.round(2138845.4567, 3));
	}
}

8、Arrays類

排序操作：java.util.Arrays.sort（陣列名稱），對于Arrays類一直是進行陣列排序的操作，類一直進行陣列排序的操作，而Arrays類是定義在java.util包下的一個操作類，在這個類之中定義了所有的與陣列有關的基本操作：二分查找，拷貝操作，相等判斷，填充，變為字串輸出等，

package com.day13.demo;

import java.util.Arrays;

public class ArraysDemo {
	public static void main(String[] args) {
		int dataA[] = new int []{1,2,3,4,5,6};
		int dataB[] = new int []{1,2,3,4,5,6};
		//陣列輸出
		System.out.println(Arrays.toString(dataA));
		//兩個陣列進行比較
		System.out.println(Arrays.equals(dataA,dataB));
		//陣列二分法查找
		System.out.println(Arrays.binarySearch(dataA, 4)+1);
	}
}

9、比較器—Comparable

9.1 Comparable

物件陣列排序：public static void sort(Object[] a)

package com.day13.demo;

import java.util.Arrays;

class Pers{
	private String name;
	private int age;
	public Pers(String name, int age) {
		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 "Pers [name=" + name + ", age=" + age + "]";
	}
}
public class ComparableDemo {
	public static void main(String[] args) {
		Pers pers[] = new Pers[]{
			new Pers("張三",12),
			new Pers("李四",23),
			new Pers("劉武",54)//物件陣列
		};
		Arrays.sort(pers);//要進行物件陣列的排序處理
		System.out.println(Arrays.toString(pers));
	}
}

這個時候沒有任何的語法錯誤，即：程式的代碼是正確的，但是在程式執行的時候出現了以下的問題：

Exception in thread "main" java.lang.ClassCastException: com.day13.demo.Pers cannot be cast to java.lang.Comparable
	at java.util.ComparableTimSort.countRunAndMakeAscending(ComparableTimSort.java:320)
	at java.util.ComparableTimSort.sort(ComparableTimSort.java:188)
	at java.util.Arrays.sort(Arrays.java:1246)
	at com.day13.demo.ComparableDemo.main(ComparableDemo.java:36)

明確的告訴用戶現在發生了“ClassCaseException”，類轉換例外，Person類不能變為Comparables實體，

如果要為物件指定比較規則，那么物件所在的類必須實作Comparable介面，下面首先來看一下這個介面的定義：

public interface Comaparable<T>{
	public int compareTo（T o）
}

Stirng類中的compareTo()就屬于覆寫Comaparable介面所的來的方法，

實作物件陣列的排序

package com.day13.demo;

import java.util.Arrays;

class Pers implements Comparable<Pers>{
	private String name;
	private int age;
	public Pers(String name, int age) {
		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 "Pers [name=" + name + ", age=" + age + "]\n";
	}
	@Override
	public int compareTo(Pers o) {
		// TODO Auto-generated method stub
		//升序排序 如果降序排序將1 和 -1 進行位置調換
		if(this.age > o.age){
			return -1;
		}else if(this.age < o.age){
			return 1;
		}else{
			return 0;
		}
	}
}
public class ComparableDemo {
	public static void main(String[] args) {
		Pers pers[] = new Pers[]{
			new Pers("張三",12),
			new Pers("李四",23),
			new Pers("劉武",54)//物件陣列
		};
		Arrays.sort(pers);//要進行物件陣列的排序處理
		System.out.println(Arrays.toString(pers));
	}
}

只要是物件陣列排序，就必須有Comparable介面，

9.2 二叉樹( Binary Tree )

二叉樹是一種排序的基本的資料結構，而如果要想為多個物件進行排序，那么就必須可以區分出物件的大小，那么就必須依靠Comparable介面完成，

二叉樹的基本原理：取第一個元素作為根節點，之后每一個元素的排列要求：如果比根節點曉得資料放在左子樹，如果比根節點大的資料放在右子樹，在輸出的時候采用中序（左-根-右）遍歷的方式完成，

但是不管是何種方式操作，一定要記住，這種資料結構的實作永遠都需要依靠節點類，而這個時候的節點類要保存兩個節點：左，右，

10、國際化

在java.util.Locale可以找java提供國際化的相關資訊

Locale構造：public Locale(String language, String country)

觀察區域和語言代碼

package com.day13.demo;

import java.util.Locale;

public class LocalDemo {
	public static void main(String[] args) {
		System.out.println(Locale.CHINA);//zh_CN
		System.out.println(Locale.CHINESE);//zh
	}
}

中國Locale：public static final Locale CHINESE
美國Locale：public static final Locale US
取得當前的Locale物件：public static Locale getDefault()

當我們用eclipse打開Message.properties進行撰寫后不要慌，我們還有一個非常強大的工具在JDK中，CLASSPATH:C:\Program Files\Java\jdk1.8.0_241\bin 自己安裝JDK的環境目錄下有一個叫native2ascii.exe可以幫助我們進行轉碼，這種做法非常麻煩，如果要開發國際版本的軟體還是自己安裝一個編輯軟體比較好，

語言組態檔Message.properties

welcome.info = \u5317\u4EAC\u6B22\u8FCE\u4F60\uFF01

測驗檔案LocaleDemo.java

package com.day13.demo;

import java.util.ResourceBundle;

public class LocaleDemo {
	public static void main(String[] args) {
		//這個時候設定的baseName沒有后綴，而且一定要在CLASSPATH之中
		ResourceBundle res = ResourceBundle.getBundle("com.day13.msg.Message");
        //北京歡迎你！
		System.out.println(res.getString("welcome.info"));
	}
}

資源檔案的名稱就只是 包.名稱前綴

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/294697.html

標籤：java

上一篇：三年作業經驗的JAVA碼農社招的辛酸歷程（含阿里、位元組、美團、貨拉拉、微眾等）

下一篇：用代碼帶你“深入”理解90%的初學者都沒理解清楚的Java基礎知識

# Day13-Java基礎