黑馬程序員java基礎之集合工具類

------- android培訓、java培訓、期待與您交流！ ----------

集合中的兩個工具類Collections和Arrays，是對集合進行操作的CC

Collections的方法：

sort(List list)方法可以對List集合進行自然排序，

sort(List list ,Comparator com)方法可以按照自己定義的比較器進行排序

max(List list)方法獲取最大值

binarySearch(List list，key)方法使用二分法查找指定元素，當該元素不存在集合中時，返回:(-插入點-1);注意此方法需要集合有序

fill(List list，key)方法將集合中所有元素替換成指定元素

replaceAll(List list,oldkey,newkey)方法將某一元素置換成另一元素

reverse(List list) 方法將集合元素反轉

reverseOrder()方法返回一個比較器，強行逆轉實現了comparable接口的對象，還可以傳入一個比較器，強行逆轉排序

shuffle(List)方法對集合中的元素重新進行隨機排序

import java.util.*;
class CollectionsDemo
{
	public static void main(String[] args)
	{
		replaceDemo();
	}

	public static void binarySearchDemo()
	{
		List<String> list=new ArrayList<String>();	//新建一個List集合
		
		//向集合中添加元素
		list.add("abcd");
		list.add("aaa");
		list.add("z");
		list.add("kkkkk");
		list.add("qq");

		Collections.sort(list);		//使用sort方法，對集合進行自然排序
		System.out.println(list);

		//int index=Collections.binarySearch(list,"e");	//獲取指定鍵的索引位置
		int index=BinarySearch(list,"aaaa");	//調用自定義binarySearch()方法
		System.out.println(index);
	
	}
	public static void replaceDemo()
	{
		List<String> list=new ArrayList<String>();	//新建一個List集合
		
		//向集合中添加元素
		list.add("abcd");
		list.add("aaa");
		list.add("z");
		list.add("kkkkk");
		list.add("qq");
		
		System.out.println(list);
		Collections.replaceAll(list,"aaa","bbb");	//將集合中原來的某個元素替換
		System.out.println(list);

		Collections.reverse(list);	//反轉集合中的元素
		System.out.println(list);
	}
	public static void fillDemo()
	{
		List<String> list=new ArrayList<String>();	//新建一個List集合
		
		//向集合中添加元素
		list.add("abcd");
		list.add("aaa");
		list.add("z");
		list.add("kkkkk");
		list.add("qq");
		
		System.out.println(list);
		Collections.fill(list,"bbb");	//將集合中所有元素替換成“bbb”
		System.out.println(list);
	}
	public static int BinarySearch(List<String> list,String key)	//binarySearch的原理
	{
		int max,min,mid;
		max=list.size()-1;
		min=0;
		while(min<=max)
		{
			mid=(max+min) >>1;	//右移一位相當於:/2
		
			String t=list.get(mid);	//獲取mid角標位的集合中的值
			int num=t.compareTo(key);	//將中間角標位的值與要查找的值比較
		
			if(num>0)
				max=mid-1;
			else if(num<0)
				min=mid+1;
			else
				return mid;
		}
		return -min-1;
	}
	public static void maxDemo()	//獲取最大值方法
	{
		List<String> list=new ArrayList<String>();	//新建一個List集合
		
		//向集合中添加元素
		list.add("abcd");
		list.add("aaa");
		list.add("z");
		list.add("kkkkk");
		list.add("qq");

		Collections.sort(list);		//使用sort方法，對集合進行自然排序
		System.out.println(list);

		String max=Collections.max(list);	//使用Collections中的獲取最大值方法
		System.out.println(max);
		
	}
	public static void sortDemo()	//sort排序方法
	{
		List<String> list=new ArrayList<String>();	//新建一個List集合
		
		//向集合中添加元素
		list.add("abcd");
		list.add("aaa");
		list.add("z");
		list.add("kkkkk");
		list.add("qq");

		System.out.println(list);

		//Collections.sort(list);		//使用sort方法，對集合進行自然排序

		String max=Collections.max(list);	//使用Collections中的獲取最大值方法
		System.out.println(max);
		
		Collections.sort(list,new StrLenComparator());		//傳入比較器，使用sort方法，按照比較器指定的方法進行排序
		System.out.println(list);
	}
}

class StrLenComparator implements Comparator<String>
{
	public int compare(String s1,String s2)
	{
		if(s1.length()>s2.length())
			return 1;
		if(s1.length()<s2.length())
			return -1;
		return s1.compareTo(s2);
		
	}
}

替換和反轉功能執行結果：

import java.util.*;
class CollectionsDemo2
{
	public static void main(String[] args)
	{
		shuffleDemo();
	}
	public static void orderDemo()
	{
		TreeSet<String> ts=new TreeSet<String>(Collections.reverseOrder(new StrComparator()));	//新建一個集合，使用reverOrder()強行逆轉原來的比較器，逆向排序
		
		//添加元素
		ts.add("abcd");
		ts.add("eft");
		ts.add("adkg");
		ts.add("s");

		Iterator<String> it=ts.iterator();	//使用迭代器，遍歷集合中元素
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}

	public static void shuffleDemo()
	{
		List<String> list=new ArrayList<String>();	//新建一個集合
		
		//添加元素
		list.add("abcd");
		list.add("eft");
		list.add("adkg");
		list.add("s");

		System.out.println(list);
		Collections.shuffle(list);	//該方法可以將集合中元素隨機排序
		System.out.println(list);
	}
}

class StrComparator implements Comparator<String>	//構造字符串比較器
{
	public int compare(String s1,String s2)
	{
		return s1.compareTo(s2);	//使用String類的compareTo比較方法
	}
}

shuffle方法對集合元素隨機排序執行結果：

Arrays:用於操作數組的工具類，裏面都是靜態方法

asList(arr)方法將數組變成list集合

將數組變成集合的好處：可以使用集合的方法操作數組中的元素；contains(),IndexOf();subList()

import java.util.*;
class ArraysDemo
{
	public static void main(String[] args)
	{
		Integer[] arr={2,3,4};
		List list=Arrays.asList(arr);	//將數組轉爲集合中的元素
		System.out.println(list);	
		/*
		String[] arr={"abc","ade","bd","cc","kkk"};
		List<String> list=Arrays.asList(arr);	//將數組轉爲List集合

		list.add("dgsad");
		System.out.println(list);
		System.out.println(list.contains("cc"));	//判斷元素是否存在
		*/
	}
}

注意：不能使用集合的增刪方法，因爲數組的長度固定。如果進行增刪，會發生UnsupportedOperationException異常

如果數組中的元素都是對象，那麼變成集合時，數組中的元素就直接轉爲

將集合變數組，使用Collection集合中的toArray方法

·· 當指定類型的數組長度小於集合的長度，那麼該方法內部會自動創建一個新的數組，長度爲集合長度，當數組長度大於集合長度，就不會新建數組，使用傳進來的數組，沒有有效元素的位置會返回null

import java.util.*;

class toArray
{
   public static void main(String[] args)
   {
      ArrayList<String> al=new ArrayList<String>();	//構造一個集合
	
	//添加元素
      al.add("java1");
      al.add("java2");
      al.add("java3");
     String[] arr=new String[al.size()];	//創建一個數組，長度爲集合的長度

     String[] str= al.toArray(arr);	//將集合轉爲數組

     System.out.println(Arrays.toString(str));	//返回數組元素的字符串打印
    }
}

將集合變數組的好處：限定對元素的操作，不需要進行增刪了

增強for循環

格式：for(數據類型 變量名：被遍歷的集合或數組)

import java.util.*;
class ForEachDemo
{
   public static void main(String[] args)
   {
      ArrayList<String> al=new  ArrayList<String>();	//新建數組
	//添加元素
       al.add("ndibnih");
       al.add("ndiih");
       al.add("nih");

      for(String s:al)
      {
	s="kkk";
          
       }

	System.out.println(al);
   }
}

發現在循環內修改元素無效，所以高級for循環只能獲取集合中的元素，不能對集合進行操作

而迭代器除了可以遍歷元素，還可以remove()集合中的元素；如果是ListLiterator，還可以對集合進行增刪改查的操作

傳統for和高級for循環的區別：高級for循環必須有被遍歷的目標

可變參數：實際上就是數組參數的間歇形式，不用每一次都手動建立數組對象，隱示將參數封裝爲數組

import java.util.*;
class ParamMethodDemo
{
	public static void main(String[] args)
	{
		show(2,4,6,6);
		show(1,3);		
	}
	
	public static void show(int... arr)<span style="white-space:pre">	</span>//注意可變參數的形式
	{
		System.out.println(arr.length);
	}
}

打印結果”

注意：使用可變參數一定要定義在參數列表最後面,如上面的例子show(String str,int...arr)

靜態導入

import java.util.*;
import static java.util.Arrays.*;	//導入Arrays中所有的靜態成員

import static java.lang.System.*;	//導入Systm中所有靜態成員
class StaticImport 
{
	public static void main(String[] args)
	{
		int[] arr={3,2,5};
		
		sort(arr);	//原型是Arrays.sort(arr),靜態導入後就可以省略Arrays.

		int index=binarySearch(arr,2);	//此處也是調用Arrays的二分查找法，省略了Arrays.

		System.out.println(Arrays.toString(arr));	//此處是爲了表明用的是Arrays的toString方法，所以不能省略
		out.println(index);	//已靜態導入，不用再寫System.
	}
}

當類名重名的時候，需要制定具體的包名，當方法名重名時，需要制定所屬對象或類