java中的集合框架（Set、List、Map）及其实现类

Java中集合框架包括Collection接口、Set接口、List接口、Map接口，已经常用的它们的实现类，简单的JDK源码分析底层实现
集合框架：

Java语言的设计者对常用的数据结构和算法做了一些规范（接口）和实现（实现接口的类）。所有抽象出来的数据结构和操作（算法）统称为集合框架。

程序员在具体应用的时候，不必考虑数据结构和算法实现细节，只需要用这些类创建一些对象，然后直接应用就可以了，这样就大大提高了编程效率。

集合框架常用的内容有：

集合框架接口：
Collection：集合的根结点，元素是Object，没有实现类。存储的对象可以重复，但是没有顺序！
常用方法：

	 add(E e) ：向集合中添加一个元素，返回值类型为：boolean
	 contains(Object o)：判断集合中是否包含某个元素，返回值类型为：boolean
	 remove(Object o)： 移除某一个元素 ，返回值类型为：boolean
	 size() ：返回集合中的有效元素个数，返回值类型为：int

List接口：
元素有顺序有下标，内容可以重复。
常用方法：

	void add(int index, E element)：向指定位置处添加元素，无返回值类型
	get(int index):根据下标获取对应的元素，返回值类型为：Object
	indexOf(Object o)  ：返回指定元素对应的第一次出现下标，若没有返回-1，返回值类型为：int
	E remove(int index) ：移除指定下标处对应的元素
	E set(int index, E element)：向指定位置处添加元素并且覆盖原来的元素,更改

List接口的三个常用实现类：

		ArrayList      数组实现，查询快，增删慢 
			           jdk 1.2   线程不安全的，轻量级实现，运行效率高					   
		LinkedList     链表实现，查询慢，增删快	
		Vector         数组实现，查询快，增删慢
					   jdk1.0  线程安全的，重量级实现，运行效率低

下面看一下ArrayList的增删改查操作：

package test;
import java.util.ArrayList;
public class testArrayList {
	/**
	 * 集合框架
	 * 集合：一个对象，用来储存其他多个对象
	 *  ArrayList 能更好的代替数组
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayList<String> list = new ArrayList<String>();
		//新增
		list.add("今天周日");
		list.add("明天周一");
		list.add(0, "昨天周六");
		//修改
		list.set(1, "今天周日不上晚自习");
		System.out.println(list);
		//查找
		System.out.println(list.get(1));
		//删除
		System.out.println(list.remove(2));
		//遍历
		for (String string : list) {
			System.out.println(string);
		}
	}

}
 

linkedList和Vector的增删改查都是一样的
Set接口：
无序无下标，元素不可以重复
set接口的方法都是从Collection接口中继承而来，

		 add(E e) ：向集合中添加一个元素，返回值类型为：boolean
		 contains(Object o)：判断集合中是否包含某个元素，返回值类型为：boolean
		 remove(Object o)： 移除某一个元素 ，返回值类型为：boolean
		 size() ：返回集合中的有效元素个数，返回值类型为：int

HashSet实现类的简单增删改查以及常用方法：

package test;

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
public class test {
	/**
	 * Set 元素无顺序 内容不可重复
	 * 方法全部继承自Collection接口
	 * 遍历：迭代遍历或者for-each遍历  
	 */
	public static void main(String[] args) {
		//set中判断元素不重复值的是元素内容不重复
		//Set<String> set = new HashSet<>();
		Set<String> set = new LinkedHashSet<>();
		String s1 = new String("aaa");
		String s2 = new String("bbb");
		String s3 = new String("ccc");
		String s4 = new String("aaa");
		set.add(s1);
		set.add(s2);
		set.add(s3);
		set.add(s4);	
		//forEach遍历
		for (String string : set) {
			System.out.print(string+"\t");
		}
		System.out.println();
		//删除操作
		set.remove(s3);
		//看set中是否包含一个对象
		System.out.println(set.contains(s4));
		//再次添加
		System.out.println(set.add("aaa"));
		//迭代遍历
		Iterator<String> it = set.iterator();
		while(it.hasNext()){
			System.out.print(it.next()+"\t");
			/*Object o = it.next();
			System.out.println(o);*/	
		}	
	}
}

TreeSet：
对Set集合进行按照一定顺序进行从小到大排列：
比如说下面的程序，Set中放一个Worker对象，要想使他进行排列必须得先指定他按照什么顺序排列，先先给他一个排序规则这样JVM才知道要怎么做。也就是Worker类要实现 Comparable接口

package test;
import java.util.Set;
import java.util.TreeSet;
public class TestTreeMap2 {
	public static void main(String[] args) {
		Set<Worker> set = new TreeSet<Worker>();  //对元素进行升序排列
		set.add(new Worker("hansf",38,10.0));
		set.add(new Worker("awang",48,20.0));
		set.add(new Worker("kangkang",36,30.0));
		set.add(new Worker("make",58,40.0));
		set.add(new Worker("songtf",58,50.0));
		//遍历
		for(Worker worker:set){
			System.out.println(worker);
		}
	}
}
//要实现Comparable接口才可以进行按照规则排序！！！！！
public class Worker implements Comparable<Worker>{
	private String name;
	private int age;
	private double salary;
	public Worker(String name, int age, double salary) {
		super();
		this.name = name;
		this.age = age;
		this.salary = salary;
	}
	public Worker() {
		super();
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	
	public void work(){
		System.out.println(name+"work");
	}
	@Override
	public String toString() {
		return "Worker [name=" + name + ", age=" + age + ", salary=" + salary
				+ "]";
	}
		return false;
		} else if (!name.equals(other.name))
			return false;
		if (Double.doubleToLongBits(salary) != Double
				.doubleToLongBits(other.salary))
			return false;
		return true;
	}
	@Override
	public int compareTo(Worker o) {
//		比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。
		//以年龄为例
		if(this.age<o.getAge()){
			return -1;
		}else if(this.age==o.getAge()){
			if(this.salary<o.getSalary()){
				return -1;
			}else if(this.salary==o.getSalary()){
				return 0;
			}else{
				return 1;
			}
		}else{
			return 1;
		}
	}
}

Map集合

Map集合的一个元素是由一个键(key)和一个值(value)组成的
key不允许重复，value允许重复

Map集合常用方法：

		V put(K key, V value) ：向集合中添加一个元素，
		若集合中包含这个key，使用v覆盖掉，并且返回原来key所对应的value
		
		V remove(Object key)：根据key删除集合中元素，并且返回删除的value
 		size()：获取集合中有效的键值对个数		
		boolean containsKey(Object key) ：如果此集合包含指定键所对应的键值对，则返回 true。 
         
		boolean containsValue(Object value) ： 如果集合中包含对应的value 则返回true

遍历方式
①键遍历 能够获取到键和值
1.键遍历
获取所有的key对应的set集合 Set keySet()

Set<Integer> set = map.keySet();

循环遍历set集合 获取key 还可以根据key获取对应的value

    for(Integer key:set){
    			String value = map.get(key);  //根据键获取值
    			System.out.println(key+"----"+value);  //获取所有的key
    		}

2值遍历 只能够获取到值（value）
获取所有的value 存放在集合中

Collection<String> values = map.values();

遍历集合

		for(String value:values){
			System.out.println(value);
		}

键值对遍历 能够获取到键和值
将key和value 封装成一个对象Map.Entry<Integer,String>，把封装的对象存放在集合里面
entrySet() :能够获取 键值对对象 存放的集合

Set<Map.Entry<Integer, String>> set = map.entrySet();

遍历集合 获取对应键和值

    for(Map.Entry<Integer, String> entry:set){
    			Integer key = entry.getKey();
    			String value = entry.getValue();
    			System.out.println(key+"---"+value);
    		}
	

Map的常用方法示例：

package test;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class testMap {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Map<String, Integer> map = new HashMap<String, Integer>();
		//增
		map.put("a", 1);
		map.put("b", 2);
		map.put("c", 3);
		map.put("d", 4);
		map.put("e", 5);
		
		//查
		System.out.println(map.get("c"));
		//改
		map.put("c", 33);
		System.out.println(map.get("c"));
		//删
		map.remove("d");
		//遍历
		System.out.println(map);
		//查找map中是否包含指定的key
		System.out.println(map.containsKey("e"));
		//查找map中是否包含指定的value
		map.containsValue("5");
		//长度
		System.out.println(map.size());
		System.out.println();
		//遍历key
		System.out.println("遍历key");
		Set<String> set = map.keySet();
		for (String string : set) {
			Integer val = map.get(string);
			System.out.print(string+"\t"+val+"\n");
		}
		System.out.println();
		
		//遍历value
		System.out.println("遍历value：");
		Collection<Integer> values = map.values();
		for (Integer integer : values) {
			System.out.print(integer+"\t");
		}
		System.out.println();
		System.out.println("遍历键值对：");
		Set<Entry<String,Integer>> set2 = map.entrySet();
		for (Entry<String, Integer> entry : set2) {		
			System.out.println(entry);
		}	
	}
}

通过上面程序可以看到，元素的key值是可以进行排序的，可以通过TreeMap进行排序，和TreeSet的排序类似。就不多介绍了。
Map实现类 之间的区别、

HashMap JDk1.2 线程不安全 轻量级实现 运行效率高 允许key和value为null值
自定义的类型作为key时，必须重写hashCode和equals方法

LinkedHashMap JDK1.2
自定义的类型作为key时，必须重写hashCode和equals方法
保证遍历的顺序跟添加的顺序一致

TreeMap JDK1.2
保证遍历的顺序为key升序排列后的结果
自定义的类型作为key时，需要实现Comparable接口，以及实现compareTo方法

Propertis jdK 1.0
键和值都必须是String类型，通过用来读取配置文件时

HashTable jdK 1.0 线程安全 重量级实现 运行效率低 不允许key和value为null