Java基礎_集合(下)

集合(下)

五、工具類

5.1、Collections

Collections是一個操作集合的工具類，它沒有向外提供構造方法，不可以用new創建對象，並且向外提供的方法都是靜態的，所以可以直接用類名.方法()的方式使用。下面介紹幾個常用方法：

public static <T extends Comparable<? super T>> void sort(List<T> list)：

該方法用於給list集合進行排序；要進行排序，首先要元素具備比較性，那麼用泛型來限定。

public static <T> void sort(List<T> list, Comparator<? super T> c)：

傳入比較器的方式進行排序，元素不一定要具備比較性。

public static <T extends Object &Comparable<? super T>> T max(Collection<? extends T> coll)：

取最大值；首先要元素具備比較性，用泛型來限定。

public static <T> int binarySearch(List<? extendsComparable<? super T>> list, T key)：

對有序集合List集合的二分查找，元素必須具備比較性，用泛型限定。

public static <T> int binarySearch(List<?extends T> list, T key, Comparator<?super T> c)：

二分查找，傳入比較器，不一定要元素自身具備比較性。

static <T> void fill(List<? super T> list,T obj)：

使用指定元素替換指定列表中的所有元素。

static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)：

使用另一個值替換列表中出現的所有某一指定值。

static void reverse(List<?> list)：

反轉指定列表中元素的順序。

static <T> Comparator<T> reverseOrder(Comparator<T> cmp)：

返回一個比較器，它強行逆轉指定比較器的順序

static <T> List<T> synchronizedList(List<T> list)：

返回指定列表支持的同步（線程安全的）列表。映射，Set同理！

下面代碼演示：

1：

package itheima.day17;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class CollectionsDemo {

	public static void main(String[] args) {
		
		List<String> list = new ArrayList<String>();
//		添加元素
		list.add("abcv");
		list.add("cbcv");
		list.add("abdgfd");
		list.add("bav");
		list.add("ab");
		list.add("jhghk");	
		sop(list);
		
//		排序，按照字符串的默認形式
//		Collections.sort(list);
//		排序，傳進比較器
		Collections.sort(list,new StrLenComparator());
		sop(list);
		
//		取最大值，按照字符串的默認形式
//		String max = Collections.max(list);
//		取最大值，傳進比較器
		String max = Collections.max(list,new StrLenComparator());
		sop(max);
		
//		二分查找，默認方式
//		int index = Collections.binarySearch(list,"jhghk");
//		二分查找，傳入比較器
		int index = Collections.binarySearch(list,"jhghk",new StrLenComparator());
		sop(index);
		
//		int index1 = halfSearch(list,"jhghk");
		int index1 = halfSearch2(list,"jhghk",new StrLenComparator());
		sop(index);
	}
	
//	自定義的二分查找，沒比較器
	public static  int halfSearch(List<String> list,String key){
		
		int max,min,mid;
		max = list.size()-1;
		min =0;
		
		while(min<=max){
			mid = (min+max)>>1;
			String str = list.get(mid);
			int num = str.compareTo(key);
			
			if(num>0)
				max = mid-1;
			else if(num<0)
				min = mid+1;
			else
				return mid;
		}	
//		min就是元素的插入點
		return -min-1;
	}
	
//	自定義的二分查找，比較器
	public static  int halfSearch2(List<String> list,String key,Comparator<String> cmp){
		
		int max,min,mid;
		max = list.size()-1;
		min =0;
		
		while(min<=max){
			mid = (min+max)>>1;
			String str = list.get(mid);
//			用比較器比較
			int num = cmp.compare(str, key);
			
			if(num>0)
				max = mid-1;
			else if(num<0)
				min = mid+1;
			else
				return mid;
		}
		return -min-1;
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

//自定義的比較器，創建一個類實現Comparator，覆蓋compare(o1,o2)方法
class StrLenComparator implements Comparator<String>{
	@Override
	public int compare(String o1, String o2) {
//		按照字符串長度排序
		int num = o1.length()-o2.length();
		if(num == 0)
			return o1.compareTo(o2);
		return num;
	}
}

2：

package itheima.day17;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.TreeSet;

import itheima.day17.StrLenComparator;//導入比較器

public class CollectionsDemo2 {
	public static void main(String[] args) {

//		fillDemo();
		ReplaceAll();
//		orderDemo();
	}
	
//	練習：將list集合中部分元素替換成指定元素
	public static void fillDemo(){
		
		List<String> list = new ArrayList<String>();
		list.add("abc1");
		list.add("abc2");
		list.add("abc3");
		list.add("abc4");
		sop(list);
		
//		把list集合中所有的元素替代爲"abc"
		Collections.fill(list, "abc");
		sop(list);
	}
	
	public static void ReplaceAll(){
		
		List<String> list = new ArrayList<String>();
		list.add("abc1");
		list.add("abc2");
		list.add("abc3");
		list.add("abc4");
		sop(list);
		
//		替代"abc2"爲"123"
		Collections.replaceAll(list, "abc2", "123");
		sop(list);
		
//		反序
		Collections.reverse(list);
		sop(list);
		
//		交換兩個位置的數
		Collections.swap(list, 1, 2);
		sop(list);
		
//		使用默認隨機源對指定列表進行置換，隨機數！
		Collections.shuffle(list);
		sop(list);
	}

	public static void orderDemo(){
		
//		Collections.reverseOrder(new StrLenComparator())：  將原來的比較器反序
		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));
		ts.add("asdv1111");
		ts.add("bsdv111");
		ts.add("csdv1");
		ts.add("dsdv11");
		ts.add("esdv");
		
//		迭代器方式取出
		Iterator it = ts.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
	}
	
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

5.2、Arrays

Arrays是一個操作數組的工具類，同Collections一樣，不可創建對象，方法都是靜態的，所以用類名.方法的形式調用。

數組變集合：static <T> List<T> asList(T… a): 返回一個受指定數組支持的固定大小的列表。

數組變list集合的好處：數組功能比較少，集合功能多，可以用集合的思想和方法來操作數組中的元素。

注意：將數組變成集合，不可以使用集合的增刪方法，因爲數組的長度是固定的；如果數組中的元素都是對象，那麼變成集合時，數組中的元素就直接轉成集合中的元素；如果數組中的元素是基本數據類型，那麼會將該數組作爲集合中的元素存在。

集合變數組：Collection接口中的toArray()方法。

1、 Object[] toArray():返回包含此 collection 中所有元素的數組;

2、<T> T[] toArray(T[] a)：返回包含此 collection 中所有元素的數組；返回數組的運行時類型與指定數組的運行時類型相同。

注意：當指定類型的數組長度小於集合的size，那麼該方法內部會創建一個新的數組，長度爲集合的size；當大於時，不會創建新的數組，而是使用傳遞進來的數組，所以創建一個剛剛好的數組最優。

集合變數組的好處：爲了限定對元素的操作，不需要增刪，就變成數組。

Arrays工具類封裝了很多操作數組的靜態方法，比如：二分查找、排序、數組變成字符串等等，詳情請查閱API。

代碼演示：

package itheima.day17;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

//演示Arrays工具類
public class ArraysDemo {
	public static void main(String[] args) {
		
		int[] intArr = {2,3,4};
//		將各種數組變成字符串
		sop(Arrays.toString(intArr));
		
		String[] arr ={"abc","cc","dg"};
//		將數組轉成List集合
		List<String> list = Arrays.asList(arr);
		sop(list);
		
//		數組變集合後，不可用集合的增刪方法，因爲數組的長度是固定的
		sop("contains:::"+list.contains("cc"));
//		java.lang.UnsupportedOperationException
//		list.add("aa");
		
//		如果數組中元素是對象，那麼變成集合時，數組中元素就直接轉爲集合元素；
//		如果數組中元素是基本數據類型，那麼會將該數組作爲集合中的元素。
//		int[] num = {2,5,6};
//		List<int[]> li = Arrays.asList(num);
		Integer[] num = {2,5,6};
		List<Integer> li = Arrays.asList(num);
		sop(li);
		
		ListToArray();
	}
	public static void ListToArray(){
		
		ArrayList<String> al = new ArrayList<String>();
		al.add("abc1");
		al.add("abc2");
		al.add("abc3");
		al.add("abc4");
//		集合變數組
		String[] arr = al.toArray(new String[al.size()]);
//		數組變成字符串
		System.out.println(Arrays.toString(arr));
	}
	
	private static void sop(Object obj) {
		System.out.println(obj);
	}
}

六、特性

6.1、高級for循環

Collection在JDK1.5後出現的父接口public interface Iterable<T>,實現這個接口的對象可以允許成爲foreach語句的遍歷目標。

高級for循環格式：for(數據類型變量名:被遍歷的集合(Collection)或者數組){執行語句;}；其實底層原理還是迭代器，這個升級，簡化書寫。

注意：對集合進行遍歷，只能獲取，但不能對集合進行過多的操作；迭代器除了遍歷，還可以進行remove()集合中元素的動作；如果用ListIterator，還可以在遍歷的過程中進行增刪改查的操作。

與傳統for循環區別：高級for有一個侷限性，必須要有被遍歷的目標；遍歷數組時，還是希望是用傳統for，因爲傳統for可以定義角標。

6.2、可變參數

可變參數是JDK1.5版本以後出現的一個新特性；可變參數其實就是數組參數的簡寫形式，用三點表示，不用每一次都手動的建立數組對象，只要將要操作的元素作爲參數傳遞即可；隱式將這些參數封裝成了數組。

注意：可變參數一定要定義在參數列表的最後面。

6.3、靜態導入

靜態導入：import static；當類名重名時，需要指定具體的包名；當方法重名時，需指定具備所屬的對象或者類。

下面代碼演示：

package itheima.day17;

//靜態導入：這是一種很變態的做法！
import static java.lang.System.*;

public class ParamMethodDemo {

	public static void main(String[] args) {
		
//		int[] arr = {3,4};
		show(3,4);
//		int[] arr1 = {1,2,3,4,5};
		show(1,2,3,4,5);
	}
//	可變參數
	public static void show(int... arr){
		
		out.println("length:::::"+arr.length);
//		高級for循環
		for(int i:arr){
			out.print(i+"  ");
		}
		System.out.println();
	}
}

七、其他幾個類

在介紹這些類之前說明，記住這些類不是重點，重點是通過這些類的介紹熟悉該怎麼去查看API文檔。

7.1、System類

System是用來描述系統信息的一個工具類，該類包含一些有用的類字段和方法。它不能被實例化，說明沒有向外暴露構造函數，那麼方法一定是靜態的，用類名調用。

Out：標準輸出，默認是控制檯；in：標準輸入，默認是鍵盤。該集合中存儲的都是字符串，沒有定義泛型。

下面代碼演示：

package itheima.day18;

import java.util.Iterator;
import java.util.Properties;
import java.util.Set;

//演示System工具類
public class SystemDemo {
	public static void main(String[] args) {
		
		Properties pro = System.getProperties();
		
//		Set keySet = pro.keySet();
//		Iterator it = keySet.iterator();
//		while(it.hasNext()){
//			Object key = it.next();
//			Object value = pro.get(key);
//			System.out.println(key+":::"+value);
//		}
			
//		設置屬性
		System.setProperty("myKey","myvalue");
//		獲取屬性
		String value = System.getProperty("myKey");
		System.out.println("value = "+value);
//		獲取屬性
		String osName = System.getProperty("os.name");
		System.out.println("Operation System::::"+osName);
		
//		該集合中存儲的都是字符串，沒有定義泛型
//		for(Object obj:pro.keySet()){
//			String value = (String)pro.get(obj);
//			System.out.println(obj+":::"+value);
//		}
		
	}
}

7.2、Runtime

Runtime：每個 Java 應用程序都有一個 Runtime 類實例，使應用程序能夠與其運行的環境相連接。該類中的方法都是靜態的，採用的是單例設計模式。通過getRuntime()方法獲取運行時的對象。

下面代碼演示：

package itheima.day18;

import java.io.IOException;

//演示Runtime類
public class RuntimeDemo {
	public static void main(String[] args) throws IOException, InterruptedException {
		
//		獲取Runtime對象
		Runtime r = Runtime.getRuntime();
		Process p =	r.exec("C:\\Program Files\\Ludashi\\ComputerZ_CN.exe");
		Thread.sleep(5000);
		p.destroy();
	}
}

7.3、Date、Calendar

Date是一個日期類，但很多方法都過時了，參見DateFormat，但該類抽象，用SimpleDateFormat子類實現。

Calendar也是一個時間日期的類。

下面代碼演示：

1：日期類的格式化：

package itheima.day05;

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

public class DateDemo {
	
	public static void main(String[] args) {
		
		Date d = new Date();
//		打印的時間看不懂，希望有些格式
		System.out.println(d);
		
//		將模式封裝到SimpleDateformat對象中
//		其實封裝日期格式的類是DateFormat，但該類爲抽象類，SimpleDateFormat爲它的實現類
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日E  hh:mm:ss");
		
//		調用format方法讓模式格式化指定的Date對象
		String time = sdf.format(d);
		System.out.println("time = "+time);
	}
}

2：前面只是簡單的格式化日期，但獲取日期中的某個字段還是有Calendar比較優

package itheima.day05;

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

public class CalendarDemo {

	public static void main(String[] args) {
		
		Date d = new Date();
//		打印，可以獲取到的是日期的全部，可是現在的需求是僅僅獲取年
		System.out.println(d);
		
//		那就僅僅格式化年的字段，即可
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
		String year= sdf.format(d);
		System.out.println(year);
		
//		Calender類是一個抽象類，但有獲取對象的方法
		Calendar  c = Calendar.getInstance();
		
		System.out.println(c.get(Calendar.YEAR)+"年"+(c.get(Calendar.MONTH)+1)+"月"+c.get(Calendar.DAY_OF_MONTH)+"日");
		System.out.println("星期"+c.get(Calendar.DAY_OF_WEEK));
		
//		上面的方式太麻煩，可以使用查表法
		String[] mons ={"一月","二月","三月","四月",
				"五月","六月","七月","八月",
				"九月","十月","十一月","十二月"};
		String[] weeks ={"","星期日","星期一","星期二","星期三",
					"星期四","星期五","星期六"};

		int index = c.get(Calendar.MONTH);
		int index1 = c.get(Calendar.DAY_OF_WEEK);
		sop(mons[index]);
		sop(weeks[index1]);
	}
	
	private static void sop(Object obj) {
		System.out.println(obj);
	}
}

3：

package itheima.day18;

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

//練習1：獲取任意年的二月有多少天。
// 思路：根據指定年設定一個時間就是c.set(year,2,1)//某一年的3月1日
//      c.add(Calendar.DAY_OF_MONTH,-1)//往前推一天，獲取天數
//  2練習：獲取昨天的現在這個時刻？
// 		c.add(Calendar.DAY_OF_MONTH,-1)
public class CalendarTest {

	public static void main(String[] args) {
		test1();
		test2();
	}
	
	public static void test1(){
		
		Date d = new Date();
		Calendar c = Calendar.getInstance();
//		時間設爲2012年
		c.set(2012,2,1);
		c.add(Calendar.DAY_OF_MONTH, -1);
		int day =c.get(Calendar.DAY_OF_MONTH);
		System.out.println(day);
	}
	
	public static void test2(){
		
		Calendar c = Calendar.getInstance();
		c.add(Calendar.DAY_OF_MONTH,-1);
		
		Date d = new Date();
		d = c.getTime();
		
//		將模式封裝到SimpleDateFormat對象中
		SimpleDateFormat sdf = new SimpleDateFormat("YYYY年MM月dd日E hh:mm:ss");
//		調用format方法讓模式格式化指定Date對象。
		String time = sdf.format(d);
		System.out.println("time="+time);
	}
}

7.4、Math

Math 類包含用於執行基本數學運算的方法，如初等指數、對數、平方根和三角函數；其實用得最多的還是生成隨機數。

下面代碼演示：

1：基本演示：

package itheima.day18;

import java.util.Random;

public class MathDemo {

	public static void main(String[] args) {
		
//		通過Random類產生隨機數
		Random r = new Random();
		for(int x =0;x<10;x++){
//			int d =(int)(Math.random()*6+1);
			int d =r.nextInt(6);
			sop(d);
		}
//		show();
//		Test();
	}
	public static void show(){
//		進1
		double d = Math.ceil(15.2);
//		取整
		double d1 = Math.floor(12.35);
//		四捨五入
		long l = Math.round(14.23);
		sop("d="+d);
		sop("d1="+d1);
		sop("l="+l);
//		2的3次冪
		double d2 = Math.pow(2,3);
		sop("d2 = "+d2);
	}
//	給定一個小數，保留小數後的兩位
	public static void Test(){
		
//		獲取一個0--100之間的浮點數
		Random r = new Random();
		double d = r.nextDouble()*100;
		sop("d = "+d);
//		捨棄後面的小數
		int temp = (int)(d*100);
//		獲取
		d = temp/100.0;
		sop("d = "+d);
	}
	
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

2、練習一枚：

package itheima.day18;

//練習：給定一個小數，保留小數的後兩位
import java.util.Random;

public class MathTest {
	public static void main(String[] args){
		
//		產生一個隨機數
		Random r = new Random();
//		產生一個0--1.0之間的隨機數
		double d = r.nextDouble()*100;
		System.out.println("d = " + d);

//		前移兩位，轉成整數，去除後面的小數
		int temp = (int)(d * 100);
//		再轉成小數
		d = (double)temp / 100;
		System.out.println("d = " + d);
	}
}

Java基礎_集合(下)

高效率使用windows

JavaScript_HTML

JavaScript_JavaScript

JavaScript_css

Java基礎_面向對象(下)

Java基礎加強_類加載器、代理

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結