黑马程序员——java编程那些事儿____集合框架工具类

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

 

 

（一）Collections类（操作集合）

(1)此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。

(2)静态方法摘要：

static <T> boolean addAll(Collection<? super T> c, T... elements) 

                                 将所有指定元素添加到指定 collection 中。

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() 

                                  返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的 自然顺序           

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

                                  返回一个比较器，它强行逆转指定比较器的顺序。

import java.util.*;

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  CollectionsDemo
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		//shuffleDemo();
		//reverseOrderdemo();
		//replaceAllDemo();
		//fillDemo();
		//binarySearchDemo();
		//sortDemo();
		maxDemo();
	}
	
	public static void shuffleDemo()// 使用默认随机源对指定列表进行置换。
	{
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("acd");
		list.add("z");
		list.add("qq");

		sop(list);
		Collections.shuffle(list);
		sop(list);
	}
	public static void reverseOrderdemo()//返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序
	{
		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()))
		ts.add("ac");
		ts.add("aaaaa");
		ts.add("k");
		ts.add("ccc");
		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			sop(it.next());
		}
	}
	public static void replaceAllDemo()// 使用另一个值替换列表中出现的所有某一指定值
	{
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("acd");
		list.add("z");
		list.add("qq");

		sop(list);
		Collections.replaceAll(list,"acd","pp");
		sop(list);
		Collections.reverse(list);// 反转指定列表中元素的顺序。
		sop(list);
	}
	public static void fillDemo()//使用指定元素替换指定列表中的所有元素。
	{
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("acd");
		list.add("z");
		list.add("qq");

		sop(list);
		Collections.fill(list,"pp");
		sop(list);
	}
	public static void binarySearchDemo()
	{
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("acd");
		list.add("z");
		list.add("qq");
		list.add("qq");
		
		Collections.sort(list,new StrLenComparator());//先排序了一下,按长度排
		sop(list);

		int index = Collections.binarySearch(list,"aaa");//使用二分搜索法搜索指定列表，以获得指定对象。
		//int index = halfSearch(list,"cc");//binarySearch的原理 折半查找法
		//int index = halfSearch2(list,"abc",new StrLenComparator());//若元素自身没有比较性，则定义比较器
		sop("index="+index);//打印插入点的位置
	}

	
	public static int halfSearch(List<String> list,String key)
	{
		int min = 0,max = list.size()-1,mid;
		while(min<=max)
		{
			mid = (max+min)>>1;

			String str = list.get(mid);		//
			int num = str.compareTo(key);	//就是mid和key比较

			if(num>0)
				max = mid -1;
			else if(num<0)
				min = mid +1;
			else
				return mid;
		}
		return min;
	}
	
	public static int halfSearch2(List<String> list,String key,Comparator<String> cmp)
	{
		int min = 0,max = list.size()-1,mid;
		while(min<=max)
		{
			mid = (max+min)>>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;
	}
	public static void maxDemo()
	{
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("acd");
		list.add("z");
		list.add("qq");
		list.add("qq");
		
		Collections.sort(list);//根据元素的自然顺序 对指定列表按升序进行排序。
		sop(list);	
		//String max = Collections.max(list);//根据元素的自然顺序，返回给定collection的最大元素。
		String max = Collections.max(list,new StrLenComparator());//根据指定比较器产生的顺序，
                                                     //返回给定 collection 的最大元素。	
		sop("max1="+max);
	}
	public static void sortDemo()
	{
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("acd");
		list.add("z");
		list.add("qq");
		list.add("qq");//同样能排序，因为是数组结构

		sop(list);
		Collections.sort(list,new StrLenComparator());//根据指定比较器产生的顺序对指定列表进行排序。
		Collections.swap(list,1,2);//在指定列表的指定位置处交换元素。reverse的原理。
		sop(list);
	}
}

 

(3)Collections类特牛的方法：

集合有一个共同的缺点，那就是线程不安全，被多线程操作时，容易出现问题，虽然可以自己加锁

但是麻烦。Collections提供特牛的方法，就是给它一个不同步的集合，它返回一个同步的安全的集合

static <T> Collection<T> synchronizedCollection(Collection<T> c) 

                             返回指定 collection 支持的同步（线程安全的）collection。 

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

                            返回指定列表支持的同步（线程安全的）列表。 

static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) 

                            返回由指定映射支持的同步（线程安全的）映射。 

static <T> Set<T> synchronizedSet(Set<T> s) 

                           返回指定 set 支持的同步（线程安全的）set。 

static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)

                           返回指定有序映射支持的同步（线程安全的）有序映射。 

static <T> SortedSet<T>  synchronizedSortedSet(SortedSet<T> s)

                          返回指定有序 set 支持的同步（线程安全的）有序 set。 

 

（二）Arrays类（操作数组）

 (1)此类包含用来操作数组（比如排序和搜索）的各种方法。里面都是静态方法。

      如果指定数组引用为 null，则此类中的方法都会抛出 NullPointerException。

 (2)静态方法摘要：

static String toString(boolean[] a)

             返回指定数组内容的字符串表示形式

static <T> List<T> asList(T... a)

            返回一个受指定数组支持的固定大小的列表。

注意：

A:该方法将一个数组变成集合后，不可以使用集合的增删方法，因为数组的长度是固定的！

          如果增删，则发生UnsupportedOprationException(不支持操作异常)

B:如果数组中的元素都是基本数据类型，则该数组变成集合时，会将该数组作为集合的一个

  元素出入集合

C:如果数组中的元素都是对象，如String，那么数组变成集合后，数组中的元素就直接转成

  集合中的元素

import java.util.*;
class  ArraysDemo
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		/*
		int[] arr = {2,4,5};		
		sop(Arrays.toString(arr));//将数组变成字符串
		*/


		String[] arr = {"abc","cc","kkkk"};
		List<String> list = Arrays.asList(arr);//数组变list集合
		sop(list);
		sop("contains:"+list.contains("cc"));//判断该数组是否存在cc元素（将数组转化成了集合才可以这样做）
			
		/*	
		结论：
		如果数组中的元素是对象，那么变成集合时，数组中的元素就直接转化成集合中的元素
		    Integer[] nums = {2,4,5};
			List<Integer> li = Arrays.asList(nums);
			sop(li);


	    如果数组中的元素都是基本数据类型，变成集合时，那么会将该数组作为集合中的元素存在。
			int[] nums = {2,4,5};
			List<int[]> li = Arrays.asList(nums);
		*/	
	}
}

 

（三）Collection中的toArray

数组变集合以及集合变数组的对比：

(1)数组变集合：

方法：static <T> List<T> asList(T... a) 返回一个受指定数组支持的固定大小的列表。

好处：可以使用集合的思想和方法操作数组中的元素，数组是一个对象，但是数组中的功能很少

(2)集合变数组：

方法：Collction中的toArray方法

好处：可以限定对集合元素的操作，防止对集合的元素进行增删，因为数组长度是固定的。

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));//将数组装化为字符串
	}
}

 

（四）Collections类和Arrays类的使用。(重点)

A:Collections

排序

二分查找

发转

B:Arrays

把数组变成字符串输出

排序

二分查找

 

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