黑马程序员——集合学习笔记（三）

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

Map集合：该集合存储键值对。一对一对往里存，而且要保证键的唯一性。

 

Map的方法：

添加：

         put(Kkey, V value);

         putAll(Map<?extends K, ? extends V> m);

删除

         clear();

         remove(Objectkey);

判断

         containsValue(Objectvalue);

         containsKey(Objectkey);

         isEmpty();

获取

         get(Objectkey);

         size();

         values();

         *entrySet();

         *keyset();

 

Map

         |--Hashtable：底层是哈希表数据结构，不可以存入null作为键、值的情况。该集合是线程同步的。JDK1.0，效率低

         |--HashMap：底层是哈希表数据结构，允许使用null键和值，还集合是不同步的。JDK1.2，效率高。

         |--TreeMap：底层是二叉树数据结构，线程不同步。可以用于给map集合中的键进行排序。

 

和Set很像，其实Set底层就是使用了Map集合。

常用方法示例：

class MapDemo{
	public static void main(String[] args){
		Map<String, String> map = new HashMap<String, String>();
		
		//添加元素
		map.put(“01”,”zhangsan”);//返回值：当存入相同键时，新的值会替换旧值，返回值为旧值，如果存入前没有重复键，返回值为null
		map.put(“02”,”zhangsan”);
		map.put(“03”,”zhangsan”);

		System.out.println(“containsKey:” + map.containsKey(“02”));//判断是否有key为”02”的映射。
		System.out.println(“get:” + map.get(“02”));//获取key为”02”的映射值，也可以用此方法来判断是否存在，不存在为null。
		//获取map集合中所有的值
		Collection<String> coll = map.values();

		//*获得所有键和值：
		//*keySet：将map中包含的所有键存入Set集合。因为Set具备迭代器，所以可以通过迭代方式取得所有的键，再通过get方法获得每一个键对应的值。
		Set<String> keyset = map.keySet();//获取所有键的Set
		Iterator<String> it = keyset.iterator();//获取其迭代器

		while(it.hasNext()){
			String key = it.next;
			System.out.println(“key : ” + key);
			String value = map.get(key);//获取键对应的值。
		}

		//map集合取出原理：将map集合转成set集合，再通过迭代器取出。

		//*entrySet：将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry

		//将Map集合中的映射关系取出，存入到Set集合中。
		Set<Map.Entry<String,String>> entrySet = map.entrySet();

		Iterator< Map.Entry<String,String>> it = entrySet.iterator();

		while(it.hasNext()){
			Map.Entry<String, String> me = it.next();
	
			String key = me.getKey();//取出key
			String value = me.getValue();//取出value
		}
	}
}

Map.Entry其实Entry也是一个接口，它是Map接口中的一个内部接口：

Interface Map{
	public static interface Entry{
		public abstract Object getKey();
		public abstract Object getValue();
	}
}

Collections:集合工具类，其所有方法全部为静态方法。

常用方法：

sort(List<T>list)://用来给List排序，满足既可以有重复元素，又可以排序的需求。

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

	public static void sortDemo(){//sort方法示例。
		List<String> list = new ArrayList<String>();
		list.add(“abcd”);
		list.add(“aaa”);
		list.add(“z”);
		list.add(“kkkkk”);
		list.add(“qq”);

		sop(list);
		Collections.sort(list);//使用sort方法进行自然排序。
		sop(list);
		collections.sort(list, new StrLenComparator());//用指定比较器排序。
	}

	public static void maxDemo(){//max方法示例
		List<String> list = new ArrayList<String>();
		list.add(“abcd”);
		list.add(“aaa”);
		list.add(“z”);
		list.add(“kkkkk”);
		list.add(“qq”);
	
		String max = Collections.max(list);//根据自然排序获得最大值

		String max2 = Collections.max(list, new StrLenComparator());//根据排序器规则获得最大值
	}

	public static void binarySearchDemo(){//二分法搜索获得元素索引
		List<String> list = new ArrayList<String>();
		list.add(“abcd”);
		list.add(“aaa”);
		list.add(“z”);
		list.add(“kkkkk”);
		list.add(“qq”);

		int index = Collections.binarySearch(list,”aaa”);//如果包含此元素，则返回此元素索引，如果不包含，则返回-(此元素插入在集合中的索引)-1
	sop(index);
	}

	public static void fillDemo(){//fill方法示例
		List<String> list = new ArrayList<String>();
		list.add(“abcd”);
		list.add(“aaa”);
		list.add(“z”);
		list.add(“kkkkk”);

		sop(list);
		//Collections.fill(list, “pp”);//将list中的所有元素替换成”pp”
	sop(list);
	}

	public static void replaceAllDemo(){//replaceAll方法示例
		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”);//将所有”aaa”元素替换成”pp”;

		Collections.reverse(list);//反转集合元素。

		Collections.swap(list, 1,2);//置换list集合里索引1和2的位置。

		Collections.shuffle(list);//重新随机排列list集合内元素。
	}

	public static void orderDemo(){//reverseOrder方法示例
		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());// reverseOrder可以返回一个与元素自然排序相反的比较器，实现了反向排序。
	
		//TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()))//reverseOrder()的重载方法，反转已有的比较器。
	
		ts.add(“abcde”);
		ts.add(“aaa”);
		ts.add(“kkk”);
		ts.add(“ccc”);

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

	//所有集合都有一个共同点：线程不同步，Collections提供了方法解决此问题：
	public static void synDemo(){
		List<String> list = new ArrayList<String>();
		Set<String> set = new HashSet<String>();
		Map<String,String> map = new HashMap<String,String>();
	
		Collections.synchronizedList(list);//返回一个线程同步的集合
		Collections.synchronizedSet(set);
		Collections.synchronizedMap(map);
	}
}

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{
		s1.compareTo(s2);
		}
	}
}

Arrays:用于操作数组的工具类。里面都是静态方法。

class ArraysDemo{
	public static void main(String[] args){
		int[] arr = {2,4,5};
		System.out.println(Arrays.toString(arr));//打印数组

		String[] arr2 = {“abc”, “cc”, “kkkk”};
		List<String> list = Arrays.asList(arr2);//将数组变成list集合
		//将数组变成集合的好处：可以使用集合的思想和方法来操作数组的元素。
		//*注意：将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的。（可以用contains、get、indexOf、subList等），如果增删，会发生UnsupportedOperationException。

		int[] nums = {2,4,5};
		Arrays.asList(nums);
		List li = Arrays.asList(nums);//此操作获得的list内实际只有一个元素，就是nums数组
		//总结：如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
	}
}

集合变数组：Collection接口中的toArray方法。

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

		al.add(“abc1”);
		al.add(“abc1”);
		al.add(“abc1”);
		al.add(“abc1”);

		/*
		1，指定类型的数组要定义的长度：
		当指定类型的数组长度小于了集合的size ,那么该方法内部会创建一个新的数组，长度为集合的size。
		当指定类型数组长度大于了集合的size，就不会创建一个新数组，而是使用传递进来的数组。
		所以创建一个刚刚好的数组最优。

		2，为什么要将集合变数组？
		为了限定对元素的操作。
		*/
		String[] arr = al.toArray(new String[al.size()]);//将数组参数传入一个与集合长度相同的数值。

		System.out.println(Arrays.toString(arr));
	}
}

*JDK1.5新特性：

1，可变参数

class ParamMethodDemo{
	public static void main(String[] args){
		show(1,2,3,4,5,6);
		show(3,4,5,2);
	}

	public static void show(int… arr){//传入可变参数
		System.out.println(arr.length);// arr相当于一个数组
		//*注意：可变参数一定要定义在参数列表的最后面。
	}
}

2，静态导入。

*注意：当类名重名时，需要指定具体的包名。当方法重名时，制定具备所属的对象或者类。

import static java.util.Arrays,*//静态导入，导入了所有Arrays类中的静态成员。
import static java.lang.System.*//导入了System中的所有静态成员。打印语句可以直接写out.println();了
class StaticImport{
	public static void main(String[] args){
		int[] arr = {3,1,6};

		sort(arr);//静态导入后，前面的”Arrays.”可以被省略
		System.out.println(Arrays.toString(arr));//由于StaticImport类本身包含toString的重名方法，所以此”Arrays.”不可被省略。
	}
}