java集合框架

集合的由来

对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定，就使用集合容器进行存储。

集合特点：
1，用于存储对象的容器。
2，集合的长度是可变的。
3，集合中不可以存储基本数据类型值。 

集合容器因为内部的数据结构不同，有多种具体容器。不断的向上抽取，就形成了集合框架，框架的顶层Collection接口。

Collection
|--List：有序(存入和取出的顺序一致),元素都有索引(角标)，元素可以重复。
|--Set：元素不能重复,无序。

List集合

List:特有的常见方法：有一个共性特点就是都可以操作角标。

list集合是可以完成对元素的增删改查。
List:
|--Vector:内部是数组数据结构，是同步的。增删，查询都很慢！
|--ArrayList:内部是数组数据结构，是不同步的。替代了Vector。查询的速度快。
|--LinkedList:内部是链表数据结构，是不同步的。增删元素的速度很快。

LinkedList:
addFirst();
addLast():
jdk1.6
offerFirst();
offetLast();

getFirst();.//获取但不移除，如果链表为空，抛出NoSuchElementException.
getLast();
jdk1.6
peekFirst();//获取但不移除，如果链表为空，返回null.
peekLast():

removeFirst();//获取并移除，如果链表为空，抛出NoSuchElementException.
removeLast();
jdk1.6
pollFirst();//获取并移除，如果链表为空，返回null.
pollLast();

Set集合

Set:元素不可以重复，是无序。
Set接口中的方法和Collection一致。
|--HashSet: 内部数据结构是哈希表 ，是不同步的。
如何保证该集合的元素唯一性呢？
是通过对象的hashCode和equals方法来完成对象唯一性的。
如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。 
如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。

记住：如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。
一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法。
建立对象判断是否相同的依据。

|--TreeSet:可以对Set集合中的元素进行排序。是不同步的。 
判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。 
TreeSet对元素进行排序的方式一：
让元素自身具备比较功能，元就需要实现Comparable接口。覆盖compareTo方法。
如果不要按照对象中具备的自然顺序进行排序。如果对象中不具备自然顺序。怎么办？
可以使用TreeSet集合第二种排序方式二：
让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。
将该类对象作为参数传递给TreeSet集合的构造函数。

示例

Person类：

package CollectionDemo;

public class Person implements Comparable{
	String name;
	int age;
	@Override   //Object类中equals比较的是地址是否相同  所以在这要覆写
	public boolean equals(Object obj) {
		// TODO Auto-generated method stub
		System.out.println(this+".......equals");
		Person p=(Person)obj;
		return this.name.equals(p.name)&&this.age==p.age;
	}
	
	@Override
	public int hashCode() {
		// TODO Auto-generated method stub
		System.out.println(this+".....hashCode");
		return name.hashCode()+age*27;
	}
	
	
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
	@Override   //TreeSet要覆写comparable的compareTo方法
	public int compareTo(Object o){
		
		Person p=(Person)o;
		int temp=this.age-p.age;       //按年龄排序
		return temp==0?this.name.compareTo(p.name):temp;
		
	//	int temp=this.name.compareTo(p.name);   //按姓名排序
	//	return temp==0?this.age-p.age:temp;
	}
	
	
	
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	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;
	}

}

HashSet：

package CollectionDemo;

import java.util.HashSet;
import java.util.Iterator;

public class HashSetTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		HashSet hs=new HashSet();
		
		hs.add(new Person("mike",27));
		hs.add(new Person("lily",22));
		hs.add(new Person("Manifest",22));
		hs.add(new Person("Martin",18));
		hs.add(new Person("mike",27));
//		hs.add(new Person("123", 31));
		for(Iterator it=hs.iterator();it.hasNext();)
		{
			Person p = (Person)it.next();
			System.out.println(p.getName()+"....."+p.getAge());
		}
		
	}

}

输出

Person [name=mike, age=27].....hashCode
Person [name=lily, age=22].....hashCode
Person [name=Manifest, age=22].....hashCode
Person [name=Martin, age=18].....hashCode
Person [name=mike, age=27].....hashCode
Person [name=mike, age=27].......equals
Martin.....18
Manifest.....22
mike.....27
lily.....22

TreeSet

package CollectionDemo;

import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TreeSet ts =new TreeSet();
		ts.add(new Person("zhangsan",23));
		ts.add(new Person("wangwu",22));
		ts.add(new Person("lisi",28));
		ts.add(new Person("zhaoliu",22));
		ts.add(new Person("zhaoliu",22));
		
//		TreeSet ts1=new TreeSet(new ComparatorByLength());
//		ts1.add("zxcv");
//		ts1.add("asdf");
//		ts1.add("qwertyuu");
//		for(Iterator it=ts1.iterator();it.hasNext();)
//		{
//			String s=(String)it.next();
//			System.out.println(s);
//		}
		
		for(Iterator it=ts.iterator();it.hasNext();)
		{
			Person p=(Person)it.next();
			System.out.println(p.getName()+":"+p.getAge());
		}
		
	}

}

输出

wangwu:22
zhaoliu:22
zhangsan:23
lisi:28

用了比较器后

package CollectionDemo;

import java.util.Comparator;

public class ComparatorByName implements Comparator {

	@Override
	public int compare(Object o1, Object o2) {
		// TODO Auto-generated method stub
		Person p1=(Person)o1;
		Person p2=(Person)o2;
		int temp=p1.getName().compareTo(p2.getName());
		return temp==0?p1.getAge()-p2.getAge():temp;

//		int m=(temp==0?p1.getAge()-p2.getAge():temp);
//		if(m!=0){
//			return 1;                //有序输出
//		}
//		else
//			return 0;
		
	}

}

输出

lisi:28
wangwu:22
zhangsan:23
zhaoliu:22

Map集合

Map：一次添加一对元素。Collection 一次添加一个元素。Map也称为双列集合，Collection集合称为单列集合。其实map集合中存储的就是键值对。 map集合中必须保证键的唯一性。 

Map常用的子类：
|--Hashtable :内部结构是哈希表，是同步的。不允许null作为键，null作为值。
|--Properties：用来存储键值对型的配置文件的信息，可以和IO技术相结合。
|--HashMap : 内部结构是哈希表，不是同步的。允许null作为键，null作为值。
|--TreeMap : 内部结构是二叉树，不是同步的。可以对Map集合中的键进行排序。 

Map示例

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

public class MapDemo {

	public static void main(String[] args) {
		
		Map<Integer,String> map = new HashMap<Integer,String>();
		method_2(map);
	}
	
	public static void method_2(Map<Integer,String> map){
		
		map.put(8,"zhaoliu");
		map.put(2,"zhaoliu");
		map.put(7,"xiaoqiang");
		map.put(6,"wangcai");
		
		
		Collection<String> values = map.values();
		
		Iterator<String> it2 = values.iterator();
		while(it2.hasNext()){
			System.out.println(it2.next());
		}
		
		
		
		/*
		 * 通过Map转成set就可以迭代。
		 * 找到了另一个方法。entrySet。
		 * 该方法将键和值的映射关系作为对象存储到了Set集合中，而这个映射关系的类型就是Map.Entry类型(结婚证)
		 * 
		 * 
		 */
		Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
		
		Iterator<Map.Entry<Integer, String>> it = entrySet.iterator();
		
		while(it.hasNext()){
			Map.Entry<Integer, String> me = it.next();
			Integer key = me.getKey();
			String value = me.getValue();
			System.out.println(key+"::::"+value);
			
		}
		
		
		
		
		
		//取出map中的所有元素。
		//原理，通过keySet方法获取map中所有的键所在的Set集合，在通过Set的迭代器获取到每一个键，
		//在对每一个键通过map集合的get方法获取其对应的值即可。
		/*
		Set<Integer> keySet = map.keySet();
		Iterator<Integer> it = keySet.iterator();
		
		while(it.hasNext()){
			Integer key = it.next();
			String value = map.get(key);
			System.out.println(key+":"+value);
			
		}
		*/
		
		
		
	}
	
	
	
	
	
	
	public static void method(Map<Integer,String> map){//学号和姓名
		
		
		// 添加元素。
		System.out.println(map.put(8, "wangcai"));//null
		System.out.println(map.put(8, "xiaoqiang"));//wangcai 存相同键，值会覆盖。
		map.put(2,"zhangsan");
		map.put(7,"zhaoliu");
		
		
		//删除。
//		System.out.println("remove:"+map.remove(2));
		
		//判断。
//		System.out.println("containskey:"+map.containsKey(7));
		
		//获取。 
		System.out.println("get:"+map.get(6));
		
		
		System.out.println(map);
		
		Outer.Inner.show();
	}
	
}

interface MyMap{
	public static interface MyEntry{//内部接口
		void get();
	}
}

class MyDemo implements MyMap.MyEntry{
	public void get(){}
}

class Outer{
	static class Inner{
		static void show(){}
	}
}