1.集合框架介绍

1.1 Collection接口
1.1.1 是集合框架的*接口
1.1.2 是Set和List接口的父接口
1.1.3 不是Map的父接口
如图所示:

1.2 List接口:
特点：有序、允许内容重复
子类有:
Vector:线程安全性，效率慢(因为方法含有锁旗标)
ArrayList:效率快，读取快，写入慢（因含有下标）
LinkedList:效率快，读取慢、写入快(因按链式排序)
List：初始的长度为10,每超过长度，就在其本身的基础上乘以1.5.
1.3 Set接口:
特点：无序，不允许内容重复
子类有:
hashset:
treeset(sortedset):按照一定规则排序、不重复、二种规则。
二种规则：
第一种: java.lang.Comparable 使用:
先实现Comparable
重写 CompareTo方法

package com.demo;

public class Person implements Comparable{
	
	private int pid;
	private String pname;
	
	public Person() {
	}
	public Person(int pid, String pname) {
		super();
		this.pid = pid;
		this.pname = pname;
	}
	public int getPid() {
		return pid;
	}
	public void setPid(int pid) {
		this.pid = pid;
	}
	public String getPname() {
		return pname;
	}
	public void setPname(String pname) {
		this.pname = pname;
	}
	@Override
	public int compareTo(Object o) {
		Person p=(Person)o;
	  int i=p.getPid()+p.getPname().hashCode();
	  int t=this.pid+this.pname.hashCode();
		return t-i;
	}

如上所示:将传过来的值强转为你定义的类型，hashCode是将字符转化为哈希码值点击了解哈希码值

第二种：Comparator 使用
实现Comparator :
重写 Compare方法:
package com.zy;

import java.util.Comparator;

public class Color implements Comparator{

private int cid;
private String cname;

public int getCid() {
	return cid;
}
public void setCid(int cid) {
	this.cid = cid;
}

public String getCname() {
	return cname;
}

public void setCname(String cname) {
	this.cname = cname;
}

@Override
public String toString() {
	return "Color [cid=" + cid + ", cname=" + cname + "]";
}

public Color(int cid, String cname) {
	super();
	this.cid = cid;
	this.cname = cname;
}

public Color() {
	super();
	// TODO Auto-generated constructor stub
}
@Override
public int compare(Object o1, Object o2) {
    Color c=(Color)o1;
    Color c1=(Color)o2;

  //第一种算法
//		int i=c1.getCid()+c1.getCname().hashCode();
//		int n=c.getCid()+c.getCname().hashCode();
//		return n-i;

    //第二种算法
    return c.getCname().equals(c1.getCname())?0:c1.getCid()-c.getCid();
}

}

Map 接口:
特点: 按照指定规则排序（根据键位排序），键位不允许重复（如果重复，后面的值会覆盖前面的值),值位可以重复。
子类有:
hashtable:安全性高、效率慢(值位不允许为空)。
hashmap:效率高。
Map嵌套（按理来说是可以无限嵌套下去的）。
以下代码是一个简单的嵌套以及解题思路:
Map嵌套构思好，然后从最外围开始拆集合，到最后反过来从最里面开始计算。

package com.demo;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class Demo {

	public static void main(String[] args) {
		//10组数据，每组8个人
		Map<Integer,List<Person<Integer, String>>> m=new    
		HashMap<Integer,List<Person<Integer, String>>>();
		
		for (int i = 0; i <10; i++) {
            List<Person<Integer, String>> l=new ArrayList<Person<Integer, String>>();
			for (int j = 0; j <8; j++) {
				Person<Integer, String> p=new Person<Integer, String>();
				p.setName("zs"+j);
				p.setAge(j);
				p.setHight(j+".5");
				l.add(p);
			}
			m.put(i,l);
		}
		
		Set<Entry<Integer, List<Person<Integer, String>>>> s = m.entrySet();
		 for (Entry<Integer, List<Person<Integer, String>>> e : s) {
			 Integer k = e.getKey();
			 List<Person<Integer, String>> v = e.getValue();
			 System.out.println("键位:"+k);
			 for (Person<Integer, String> p : v) {
				System.out.println("\t\t值位:"+p);
			}
		}
	}
}

今天的分享就到此结束，各位看官可以在下面评论出自己的看法，大家一起提升，谢谢各位！！！