集合框架-工具類(java基礎)

Collections：集合框架的工具類

集合框架的工具類：
    |--Collections:工具類，裏面的方法是靜態的。他是對集合進行操作的工具類，他可以對list集合進行排序。

    |--Arrays：工具類，對數組進行操作的工具類。

1、Collections工具類

示例代碼1：

package Container_expend;
import java.util.*;

public class CollectionsDemo
{
	public static void main(String[] args)
	{
//		sortDemo();
//		maxDemo();
//		binarySearchDemo();
//		fillDemo();
		repalceAllDemo();
	}
	
	
	public static void repalceAllDemo()//repalceAllDemo演示
	{
		List<String> list = new ArrayList<>();
		list.add("ab");
		list.add("aaaa");
		list.add("bb");
		list.add("ccccccc");
		sop(list);
		Collections.replaceAll(list, "bb", "pp");//將List中bb的元素替換成pp
		Collections.reverse(list);//反轉
		sop(list);
		
	}
	public static void fillDemo()//fillDemo演示
	{
		List<String> list = new ArrayList<>();
		list.add("ab");
		list.add("aaaa");
		list.add("bb");
		list.add("ccccccc");
		sop(list);
		Collections.fill(list, "ooo");//將集合中所有元素替換成ooo元素
		sop(list);
	}
	public static void binarySearchDemo()//binarySearch演示
	{
		List<String> list = new ArrayList<>();
		list.add("ab");
		list.add("aaaa");
		list.add("bb");
		list.add("ccccccc");
		Collections.sort(list);
		sop(list);
		int index = Collections.binarySearch(list, "aaaa");
		sop("index--"+index);
	}
	public static void maxDemo()//演示max方法
	{
		List<String> list = new ArrayList<>();
		list.add("ab");
		list.add("aaaa");
		list.add("bb");
		list.add("ccccccc");
		String max = Collections.max(list);
		sop(max);
		
	}
	public static void sortDemo()//演示sort方法,排序的對象必須是可比較的對象
	{
		List<String> list = new ArrayList<>();
		list.add("ab");
		list.add("aaaa");
		list.add("bb");
		list.add("ccccccc");
		sop(list);
//		Collections.sort(list);//自然排序；注意：不能用於set排序。可以使用比較器
		Collections.sort(list,new StrLenComparator());//傳入比較器比較
		sop(list);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

class StrLenComparator implements Comparator<String>//比較器，比較長度。如果長度相同，按自然順序排序
{
	public int compare(String s1,String s2)
	{
		if(s1.length()>s2.length()) return 1;
		else if(s1.length() < s2.length()) return -1;
		else return s1.compareTo(s2);//自然順序排序
		
	}
}

reverseOrder用法：

package Container_expend;


/*
 * reverseOrder()可以強行反轉比較器。用法：
 * 		Collections.reverseOrder(比較器);示例：Collections.reverseOrder(new StrComparator());
 */
import java.util.*;


class StrComparator implements Comparator<String>//比較器，反轉,Collections.reverseOrder()的原理
{
	public int compare(String s1,String s2)
	{
		return s2.compareTo(s1);
	}
}
public class OderDemo
{
	public static void sop(Object obj)//輸出
	{
		System.out.println(obj);
	}
	public static void main(String[] args)
	{
		orderDemo();
	}
	public static void orderDemo()
	{
		TreeSet<String> ts = new TreeSet<>(Collections.reverseOrder());//reverseOrder用法
		ts.add("aa");
		ts.add("asdas");
		ts.add("ddd");
		ts.add("vv");
		ts.add("bbbe");
		for(Iterator<String> it = ts.iterator();it.hasNext();)
		{
			sop(it.next().toString());
		}
	}
}

練習：

題目：定義一個list集合，用工具類中的方法替換集合中的一部分元素。
分析：
    1.將List中一部分元素取出放入一個新的集合內，並移除原集合中這部分元素。
    2.用fill方法替換新的集合中的元素。
    3.將替換後的集合與之前的集合進行結合。
*/

package Container_expend;
import java.util.*;


/*
題目：定義一個list集合，用工具類中的方法替換集合中的一部分元素。
分析：
	1.將List中一部分元素取出放入一個新的集合內，並移除原集合中這部分元素。
	2.用fill方法替換新的集合中的元素。
	3.將替換後的集合與之前的集合進行結合。
*/
public class fillDemo
{

	public static void sop(Object obj)//輸出
	{
		System.out.println(obj);
	}
	public static void main(String[] args)
	{
		List<String> list = new ArrayList<>();//泛型定義一個集合
		list.add("ab");
		list.add("aaaa");
		list.add("bb");
		list.add("ccccccc");
		sop(list);
		int start = list.indexOf("aaaa");
		int end = list.indexOf("ccccccc");
		try
		{
			
			fillSome(list,start,end,"replace");
		}
		catch(InputException e)
		{
			sop(e.toString());
		}
		sop(list);
	}
	public static void fillSome(List<String> list,int start,int end,String s)throws InputException 
	{ 
		if(start > end) throw new InputException("沒有需要替換的元素");//如果輸入的開始序號大於結束序號,拋出異常
		//定義一個新集合
		List<String> li = new ArrayList<>();
		//講要替換的元素存入新集合，並從老集合中移除。
		for(int i=start, j=start; j<=end ; j++)//定義i，j。其中i控制替換的元素，j控制循環次數。
		{
			li.add(list.get(i));//將需要替換的元素放到新集合
			list.remove(list.get(i));//移除需要替換的元素
		}
		Collections.fill(li, s);//替換需要替換的元素
		list.addAll(start,li);//將兩個集合合併
	}
}
//自定義異常
class  InputException extends Exception
{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	InputException(String Message)
	{
		super(Message);
	}
}

2、Arrays工具類

集合轉數組：

1. 傳入的數組的長度最優是多少呢？
         *    當指定類型的數組長度小於集合的size，那麼該方法內部會創建一個新的數組，長度爲集合的size。
         *    當指定類型的數組長度大於集合的size，那麼就不會創建新的數組，而是使用傳遞進來的數組。
         *    所以創建一個長度等於size的數組爲最優。
2. 爲什麼要將集合變成數組？
         *    爲了限定對元素的操作。

public static void to_Array()//集合轉數組
	{
		ArrayList<String> al = new ArrayList<>();
		al.add("abc1");
		al.add("abc2");
		al.add("abc3");
		
		String [] arr =  al.toArray(new String[3]);
		sop(Arrays.toString(arr));
	}

其他：

package Container_expend;

import java.util.*;

public class ArraysDemo1
{
	public static void sop(Object obj)// 輸出
	{
		System.out.println(obj);
	}

	public static void main(String[] args)
	{
		//asListDemo();
		to_Array();
	}

	public static void to_String()// 數組轉字符串
	{
		int[] arr ={ 1, 2, 3 };
		System.out.println(Arrays.toString(arr));// toString 方法
	}

	public static void asListDemo()//數組轉集合
	{
		// 將數組轉化爲集合的好處是：可以用集合的思想和方法操數組元素。
		// 注意：將數組轉化成的list集合不支持增刪元素。如果增刪了會出現不支持操作異常。
		String[] arr = { "aa", "bb", "cc", "dd" };
		List<String> list = Arrays.asList(arr);// 將數組轉換成List集合。
		sop(list);
		// list.add("aaaa");//UnsupportedOperationException
		//當整形時候，需要用Integer封裝，或者用泛型寫。
		int [] num = {11,12,13,14};
		List<int[]> li_num = Arrays.asList(num);
		sop(li_num);//結果爲地址[I@263c8db9
		
		
		Integer [] nums =  {1,2,3,4};
		List<Integer> li = Arrays.asList(nums);
		sop(li);
		/*
		 * 如果數組中的元素都是對象， 那麼變成集合時候。數組中的元素直接轉成集合中的元素。
		 * 如果數組中的元素是基本數據類型，那麼會將該數組作爲集合中的元素存在。
		 */
	}
//	public static void 

}

Foreach循環:

高級for循環。
 * 格式：
 *       for(數據類型   變量名:被遍歷的數組或集合。)
 *         {
 *         }
 *           缺陷：只能進行獲取元素操作，不能進行其他操作。
 *    迭代器：可以進行remove動作。如果使用ListIterator，還可以在操作過程中進行增刪改查的操作。
 *    
 *    傳統for和高級for的區別？
 *    高級for的侷限性是：必須有被遍歷的目標。
 *    建議：在遍歷數組時候建議使用傳統for，因爲傳統for可以定於腳標。

public class ForEachDemo
{

	public static void sop(Object obj)//輸出
	{
		System.out.println(obj);
	}
	public static void main(String[] args)
	{
		ArrayList<String> al = new ArrayList<>();
		al.add("abc1");
		al.add("abc2");
		al.add("abc3");
		
		for(String s:al)
		{
			sop(s);
		}
		
		
		HashMap<Integer,String> hm = new HashMap<>();
		hm.put(1, "aa");
		hm.put(2, "bb");
		hm.put(3, "cc");
		hm.put(4, "dd");
		//keyset遍歷方式
		Set<Integer> keyset = hm.keySet();
		for(Integer i : keyset)
		{
			sop(i+"::"+hm.get(i));
		}
		//Entry遍歷方式
		for(Map.Entry<Integer, String> me:hm.entrySet())
		{
			sop(me.getKey()+"---------"+me.getValue());
		}
		
	}

}

可變參數:
 * 其實是數組參數的簡寫形式，不用每一次都手動的建立數組對象，只要將要操作的元素作爲參數傳遞就行。
 * 隱式將這些元素封裝成數組
 * 方法的可變參數。在使用的時候注意：可變參數一定要定義在參數列表的最後面
 */

public class paramMethodDemo
{

	public static void main(String[] args)
	{
		show(1,2,3,4);
		show(1,2,3);
		show("str",1,2,3,4);

	}
	public static void show(int...arr)//只有一種數據類型
	{
		System.out.println(arr.length);
	}
	public static void show(String s,int...arr)//兩種數據類型。注意：單一的變量必須放在前面，因爲後面的可變參數會將從此處開始往後的所有元素都封裝成數組
	{
		System.out.println(s+"-----"+arr.length);
	}

}

 靜態導入：
 * 格式：import static java.util.Arrays;

 *

import java.util.*;
import static java.util.Arrays.*;//靜態導入
import static java.lang.System.*;
public class StaticImportDemo extends Object//這裏先繼承Object。即extends Object
{

	public static void main(String[] args)
	{
		 int [] arr = {1,2,3};
		 sort(arr);//因爲有靜態導入，所有Arrays可以不寫。
		 out.println(Arrays.toString(arr));//這裏面的Arrays不能省略，因爲Object類中也有一個toString方法
	}

}