黑马程序员——Java集合框架

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

Java集合框架

       Java集合框架主要介绍了List集合、Set集合、Map集合，操作集合的工具类Collections、操作数组的工具类Arrays。

       Java集合框架是Java语言重要组成部分，它包含了系统而完整的集合层次体系，封装了大量的数据结构的实现，深刻理解Java集合框架的组成结构及其中的实现类和算法，能很大程度提高程序员编码能力。

       集合框架有时称为容器，简单的说同它是一个对象，能将具有相同性质的多个元素汇聚成一个整体，集合框架被应用于存储、获取、操作、和传输聚合的数据。

       集合框架的核心接口为Collection、List（列表）、Set（集合）、Map（映射）。如下所示，就是Java集合框架：

      

    LInkedHashSet：ArrayList、LinkedList：->List->Collecton
                   HashSet、TreeSet：Set->Collection
    LinkedHashMap：HashMap，TreeMap->Map
    ListIterator：->Iterator

       定义Collection接口：public interface Collection<E> extends Iterator<E>;//定义Collection接口，E为任何类，Iterator迭代器。      

       Collection：

                        ----List  ：可存放重复元素，元素存取是有序的。

                                 -ArrayList

                                 -LinkedList

                                 -Vector

                        ----Set ：不可以存放重复元素，元素存取是无序的。

                                 -HashSet

                                -TreeSet

       List接口中常用类：

       Vector：线程安全，但速度慢，已被ArrayList替代。
    ArrayList：线程不安全，查询速度快。
    LinkedList：链表结构，增删速度快。
      取出LIst集合中元素的方式：
      get(int index)：通过脚标获取元素。
      iterator()：通过迭代方法获取迭代器对象。

      Iterator：迭代是取出集合中元素的一种方式。因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。

            用法：

for(Iterator iter = iterator();iter.hasNext();)
	for(Iterator iter = iterator();iter.hasNext();)
	{
		System.out.println(iter.next());
	}
Iterator iter = l.iterator();
(iter.hasNext())
{
	System.out.println(iter.next());
}

     Set接口中常用的类：HashSet：线程不安全，存取速度快。
 TreeSet： 线程不安全，可以对Set集合中的元素进行排序。

     Set集合元素唯一性的原因：HashSet：通过equals方法和hashCode方法来保证元素的唯一性。
       TreeSet：通过compareTo或者compare方法中的来保证元素的唯一性。元素是以二叉树的形式存放的。
      Map集合：

      Map与Collection不同：Map与Collection在集合框架中属并列存在；

      Map集合存储于取出元素的方式：Map存储的是键值对；

      Map集合的特点：Map存储元素使用put方法，Collection使用add方法，Map集合没有直接取出元素的方法，而是先转成Set集合，在通过迭代获取元素Map集合中键要保证唯一性；
      Map集合中常用类：Hashtable：线程安全，速度慢，不允许存放null键，null值，已被HashMap替代。
        HashMap：线程不安全，速度快，允许存放null键，null值。
        TreeMap：对键进行排序，排序原理与TreeSet相同。

/*
Map集合：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。
	1，添加。
		put(K key, V value) 
		putAll(Map<? extends K,? extends V> m) 

	2，删除。
		clear() 
		remove(Object key) 

	3，判断。
		containsValue(Object value) 
		containsKey(Object key) 
		isEmpty() 


	4，获取。
		get(Object key) 
		size() 
		values() 

		entrySet() 
		keySet() 

Map
	|--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。
	|--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代，jdk1.2.效率高。
	|--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。

和Set很像。
其实大家，Set底层就是使用了Map集合。
 */
import java.util.*;
class  MapDemo
{
	public static void main(String[] args) 
	{
		Map<String,String> map = new HashMap<String,String>();

		//添加元素,添加元素，如果出现添加时，相同的键。那么后添加的值会覆盖原有键对应值。
		//并put方法会返回被覆盖的值。
		System.out.println("put:"+map.put("01","zhangsan1"));
		System.out.println("put:"+map.put("01","wnagwu"));
		map.put("02","zhangsan2");
		map.put("03","zhangsan3");

		System.out.println("containsKey:"+map.containsKey("022"));
		//System.out.println("remove:"+map.remove("02"));

		System.out.println("get:"+map.get("023"));

		map.put("04",null);
		System.out.println("get:"+map.get("04"));
		//可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。

		//获取map集合中所有的值。
		Collection<String> coll = map.values();

		System.out.println(coll);
		System.out.println(map);


	}
}

/*
map集合的两种取出方式：
1，Set<k> keySet：将map中所有的键存入到Set集合。因为set具备迭代器。
	所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。
	Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。
2，Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到了set集合中，
				而这个关系的数据类型就是：Map.Entry

				Entry其实就是Map中的一个static内部接口。
				为什么要定义在内部呢？
				因为只有有了Map集合，有了键值对，才会有键值的映射关系。
				关系属于Map集合中的一个内部事物。
				而且该事物在直接访问Map集合中的元素。
 */
import java.util.*;
class MapDemo2 
{
	public static void main(String[] args) 
	{
		Map<String,String> map = new HashMap<String,String>();

		map.put("02","zhangsan2");
		map.put("03","zhangsan3");
		map.put("01","zhangsan1");
		map.put("04","zhangsan4");

		//将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();
			String value = me.getValue();

			System.out.println(key+":"+value);

		}

		/*
		//先获取map集合的所有键的Set集合,keySet();
		Set<String> keySet = map.keySet();

		//有了Set集合。就可以获取其迭代器。
		Iterator<String> it = keySet.iterator();

		while(it.hasNext())
		{
			String key = it.next();
			//有了键可以通过map集合的get方法获取其对应的值。
			String value  = map.get(key);
			System.out.println("key:"+key+",value:"+value);
		}

		 */

	}
}

/*
Map.Entry 其实Entry也是一个接口，它是Map接口中的一个内部接口。
interface Map
{
	public static interface Entry
	{
		public abstract Object getKey();
		public abstract Object getValue();

	}
}

class HashMap implements Map
{
	class Hahs implements Map.Entry
	{
		public  Object getKey(){}
		public  Object getValue(){}
	}

}
 */

/*
map扩展知识。

map集合被使用是因为具备映射关系。

"yureban"   Student("01" "zhangsan");

"yureban" Student("02" "lisi");

"jiuyeban" "01" "wangwu";
"jiuyeban" "02" "zhaoliu";

一个学校有多个教室。每一个教室都有名称。


 */
import java.util.*;

class Student
{
	private String id;
	private String name;
	Student(String id,String name)
	{
		this.id = id;
		this.name = name;
	}
	public String toString()
	{
		return id+":::"+name;
	}
}
class  MapDemo3
{

	public static void demo()
	{
		HashMap<String,List<Student>> czbk = new HashMap<String,List<Student>>();

		List<Student> reyu = new ArrayList<Student>();
		List<Student> jiuye = new ArrayList<Student>();

		czbk.put("yureban",reyu);
		czbk.put("jiuyeban",jiuye);

		reyu.add(new Student("01","zhagnsa"));
		reyu.add(new Student("04","wangwu"));
		jiuye.add(new Student("01","zhouqi"));
		jiuye.add(new Student("02","zhaoli"));

		Iterator<String> it = czbk.keySet().iterator();

		while(it.hasNext())
		{
			String roomName = it.next();
			List<Student> room = czbk.get(roomName);

			System.out.println(roomName);
			getInfos(room);
		}

	}
	public static void getInfos(List<Student> list)
	{
		Iterator<Student> it = list.iterator();
		while(it.hasNext())
		{
			Student s = it.next();
			System.out.println(s);
		}
	}

	public static void main(String[] args) 
	{
		demo();

		/*
		HashMap<String,List<Student>> czbk = new HashMap<String,List<Student>>();

		HashMap<String,String> yure = new HashMap<String,String>();

		HashMap<String,String> jiuye = new HashMap<String,String>();

		czbk.put("yureban",yure);
		czbk.put("jiuyeban",jiuye);


		yure.put("01","zhagnsan");
		yure.put("02","lisi");

		jiuye.put("01","zhaoliu");
		jiuye.put("02","wangwu");

		//遍历czbk集合。获取所有的教室。
		Iterator<String> it = czbk.keySet().iterator();

		while(it.hasNext())
		{
			String roomName = it.next();
			HashMap<String,String> room = czbk.get(roomName);

			System.out.println(roomName);
			getStudentInfo(room);
		}
//		getStudentInfo(jiuye);
//		getStudentInfo(yure);
		 */

	}
	public static void getStudentInfo(HashMap<String,String> roomMap)
	{
		Iterator<String> it = roomMap.keySet().iterator();

		while(it.hasNext())
		{
			String id = it.next();
			String name = roomMap.get(id);
			System.out.println(id+":"+name);
		}
	}
}

     集合框架中的工具类：Collections：

对集合进行查找

取出集合中的最大值，最小值

对List集合进行排序

……

Arrays：

将数组转成List集合

对数组进行排序

对数组进行二分查找

List集合：特有方法是：凡是可以操作角标的方法都是该体系特有的方法

增：boolean add(index,element); boolean addAll(index,collection);

删：E remove(index)

改：E set(index,elemet)

查：E get(index);

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