黑马程序员-集合工具类

 

---------------------- android培训、java培训、期待与您交流！ ----------------------

 

 

集合工具类

 

 

集合框架的工具类。

Collections:集合框架的工具类。里面定义的都是静态方法。

 

Collections和Collection有什么区别？

Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。

它有两个常用的子接口，

List：对元素都有定义索引。有序的。可以重复元素。

Set：不可以重复元素。无序。

 

Collections是集合框架中的一个工具类。该类中的方法都是静态的

提供的方法中有可以对list集合进行排序，二分查找等方法。

通常常用的集合都是线程不安全的。因为要提高效率。

如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

 

 

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

	}
	public static void binarySearchDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");
		Collections.sort(list,new StrLenComparator());// 根据元素的自然顺序 对指定列表按升序进行排序。

		sop(list);

		int index = Collections.binarySearch(list,"aaaa");//使用二分搜索法搜索指定列表，以获得指定对象。

		sop("index="+index);
	}
	public static void maxDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");
		Collections.sort(list);// 根据元素的自然顺序 对指定列表按升序进行排序。
		sop(list);
		// 根据元素的自然顺序，返回给定 collection 的最大元素。也可以使用自己指定的比较器。
		String max = Collections.max(list/*,new StrLenComparator()*/);
		sop("max="+max);
	}

	public static void sortDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");
		
		sop(list);

		//Collections.sort(list);// 根据元素的自然顺序 对指定列表按升序进行排序。
		//使用自己指定的比较器对集合进行排序。
		Collections.sort(list,new StrLenComparator());
		//Collections.swap(list,1,2);//交换集合中两个元素的位置。
		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;
		if(s1.length()<s2.length())
			return -1;
		return s1.compareTo(s2);
	}
}

 

 

import java.util.*;
//按照与自然顺序相反的顺序进行比较。reseveOrder方法底层实现原理。
class StrComparator implements Comparator<String>
{
	public int compare(String s1,String s2)
	{
		return s2.compareTo(s1);
	}
}
//按照字符串的长度进行比较。
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);
	}
}
class CollectionsDemo2 
{
	public static void main(String[] args) 
	{
		shuffleDemo();
	}
	public static void shuffleDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");

		sop(list);
		Collections.shuffle(list);//对集合元素的顺序进行随机置换。
		sop(list);
	}
	public static void orderDemo()
	{
		//对不具备比较性的元素或者不是需求比较方法的元素可以指定一个比较器对集合中元素进行比较。
		//使用reveseOrder方法进行反转以后得到一个反转比较方法后的比较器，作为参数传递进去。
		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));
		//Collections.reverseOrder()可以返回一个与自然顺序相反的比较器。
		//TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());
		ts.add("abcde");
		ts.add("aaa");
		ts.add("k");
		ts.add("cc");

		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}

	public static void replaceAllDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");

		sop(list);
		//使用另一个值替换列表中出现的所有某一指定值。
		Collections.replaceAll(list,"aaa","pp");

		sop(list);
		Collections.reverse(list);//反转指定列表中元素的顺序。

		sop(list);
	}

	public static void fillDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		
		sop(list);
		Collections.fill(list,"pp");//使用指定元素替换指定列表中的所有元素。
		sop(list);

	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

 

 

集合变数组。

Collection接口中的toArray方法。

<T> T[]  toArray(T[] a) 

 返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。 

 

1,指定类型的数组到底要定义多长呢？

当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。

当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。

所以创建一个刚刚好的数组最优。

 

2,为什么要将集合变数组？

为了限定对元素的操作。不需要进行增删了。

 

import java.util.*;
class  CollectionToArray
{
	public static void main(String[] args) 
	{
		ArrayList<String> al = new ArrayList<String>();

		al.add("abc1");
		al.add("abc2");
		al.add("abc3");
		//将集合中的元素存入数组中去。
		String[] arr = al.toArray(new String[al.size()]);
		System.out.println(Arrays.toString(arr));
	}
}

 

 

Arrays:用于操作数组的工具类。

里面都是静态方法。

 

asList:将数组变成list集合

1.把数组变成list集合有什么好处？

可以使用集合的思想和方法来操作数组中的元素。

 

注意：

1.将数组变成集合，不可以使用集合的增删方法。

因为数组的长度是固定。只可以使用一下等不涉及增删的方法。

contains。

get

indexOf()

subList();

 

如果你增删。那么会反生UnsupportedOperationException,

 

如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。

如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

 

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

		String[] arr = {"abc","cc","kkkk"};

		List<String> list = Arrays.asList(arr);
		sop("contains:"+list.contains("cc"));//集合中判断是否包含某个元素。
		//list.add("qq");//向转换后的集合中添加元素会出现UnsupportedOperationException,

		sop(list);

		//int[] num1 = {2,4,5};
		//List<int[]> li = Arrays.asList(nums);会将该数组作为集合中的元素存在。

		Integer[] nums = {2,4,5};	//将数组中元素作为集合中元素存在。
		List<Integer> li = Arrays.asList(nums);

		sop(li);
	}
	//如果想要知道数组中是否包含一个元素，需要将数组遍历逐个比较，较为麻烦，
	//将数组转换为集合，可以使用集合中的操作方法，较为方便。
	public static boolean myContains(String[] arr,String key)
	{
		for(int x=0;x<arr.length; x++)
		{
			if(arr[x].equals(key))
				return true;
		}
		return false;
	}
	
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

}

 

 

 

 

---------------------- android培训、java培训、期待与您交流！ ----------------------