一、 List 子接口

主要使用ArrayList、Vector 子类进行操作。

★ . 特点 : 可以保存重复数据，而且增加的顺序就是保存的顺序。

Ⅰ. ArrayList :

├ . E get(int index) : 获取数据的方法 , index为数据在集合中的下标 .

├ . boolean remove(Object obj) : 删除数据的方法 .当List集合中存放的是自定义的类时 , 若想让remove()方法正常操作，必须要覆写Object 类中的equals()方法。

├ . boolean contains( Object o) : 集合中是否包含该对象 . 该方法也要覆写equals()方法 .

eg : 实现删除方法 :

package cn.demo;

import java.util.ArrayList;
import java.util.List;

class Book {
	private String title;
	private double price;

	public Book(String title, double price) {
		this.title = title;
		this.price = price;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj) {
			return true;
		}
		if (obj == null) {
			return false;
		}
		if (!(obj instanceof Book)) {
			return false;
		}
		Book b = (Book) obj;
		if (b.title.equals(this.title) && b.price == this.price) {
			return true;
		}
		return false;
	}

	@Override
	public String toString() {
		return "书名：" + this.title + " , 价格：" + this.price + "\n";
	}
}

public class TestDemo {
	public static void main(String[] args) {
		List<Book> all = new ArrayList<Book>();
		all.add(new Book("A", 7.8));
		all.add(new Book("B", 6.8));
		all.add(new Book("C", 8.8));
		all.remove(new Book("B", 6.8));
		System.out.println(all);
	}
<h2>}
</h2>

Ⅱ .Vector :

Vector 子类出现的时间是比较长的 , 自从 JDK1.0 就有了 .

Ⅲ . 比较 :

★ . ArrayList、Vector 的区别 :
① . · 这两个类都是List 接口的子类；
② . · Vector 类是在JDK 1.0 的时候提供的，里面所提供的操作方法都是同步方法，所以属于线程安全的操作类；
③ . · ArrayList 类是在JDK 1.2 的时候提供的，里面所提供的方法都是异步操作方法，所以属于非线程安全的操作类。

▲ . 如果日后在开发之中，90%的情况下考虑的都是ArrayList。

=====================================================================================================

二、Set 子接口

主要使用HashSet、TreeSet 两个子类操作。

★ . 特点 : Set 子接口不允许保存重复的数据。

HashSet 保存的数据是无序的，如果现在需要它变为有序，那么就使用TreeSet 子类。如果要想排序自定义的对象，那么对象所在的类一定要实现Comparable 接口，如果没有接口存在，那么我们无法区分大小关系。在TreeSet 类之中如果要进行排序，那么请将所有的属性都进行比较。也就是说，在TreeSet 类之中是依靠 compareTo()方法返回的是否为0 来判断是否是重复元素。

★ . 如果是HashSet 子类，那么其判断重复数据的方式不是依靠的Comparable 接口，依靠的是Object类之中的两个方法：
├ . · 取得对象的哈希码：hashCode()；

├ . · 对象比较：equals()。

★ . 总结 :

① . Set 里面不允许保存重复数据；

② . TreeSet 依靠的是Comparable 来区分重复数据；可在的数据是有序的；
③ . HashSet 依靠的是hashCode()、equals()来区分重复数据. 并且保存的数据是无序的 .

=======================================================================================================

三、集合输出

集合的四种输出方式 :

Ⅰ. 使用Iterator接口 :

├ . · Iterator<E> iterator() ：获取Iterator .

├ . · boolean hasNext() ：是否有数据

├ . · E next() ：取出数据

eg :

package cn.demo;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class TestDemo {
	public static void main(String[] args) {
		List<String> all = new ArrayList<String>();
		all.add("Hello");
		all.add("Hello");
		all.add("World");
		all.add("Java");
		Iterator<String> iter = all.iterator();
		while (iter.hasNext()) {
			String str = iter.next();
			System.out.println(str);
		}
	}
}

▲ . Iterator接口只能够实现由前向后的输出操作。不能够实现双向输出。

Ⅱ. 使用ListIterator接口 :

如果现在有双向输出的需求，就只能够使用ListIterator 接口实现了。它是Iterator 的子接口。如果要想实现由后向前的输出，那么首先必须之前由前向后的输出才可以。

但是Collection 接口里面并没有提供为ListIterator 接口实例化的方法。但是List 子接口有 :

public ListIterator<E> listIterator()

package cn.demo;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class TestDemo {
	public static void main(String[] args) {
		List<String> all = new ArrayList<String>();
		all.add("Hello");
		all.add("Hello");
		all.add("World");
		all.add("Java");
		ListIterator<String> iter = all.listIterator();
		System.out.print("由前向后输出:");
		while (iter.hasNext()) {
			String str = iter.next();
			System.out.print(str + " , ");
		}
		System.out.print("\n由后向前输出:");
		while (iter.hasPrevious()) {
			String str = iter.previous();
			System.out.print(str + " , ");
		}
	}
}

▲ . 一般而言，此接口的输出功能意义不大。

Ⅲ . 使用Enumeration 接口 :

这也是一个古老的接口。在此接口里面有两个方法：
├ . · 判断是否有下一个内容：
boolean hasMoreElements()
├ . · 取内容：
E nextElement()

Collection 接口里面并没有提供为Enumeration 接口实例化的操作方法，Vector 子类。

public Enumeration<E> elements()

package cn.demo;

import java.util.Enumeration;
import java.util.Vector;

public class TestDemo {
	public static void main(String[] args) {
		Vector<String> all = new Vector<String>();
		all.add("Hello");
		all.add("Hello");
		all.add("World");
		all.add("Java");
		Enumeration<String> enu = all.elements();
		while (enu.hasMoreElements()) {
			String str = enu.nextElement();
			System.out.println(str);
		}
	}
}

▲ . Enumeration 是除了Iterator 接口之外，使用最多的接口。

Ⅳ. 使用foreach()方法 :

package cn.demo;

import java.util.ArrayList;
import java.util.List;

public class TestDemo {
	public static void main(String[] args) {
		List<String> all = new ArrayList<String>();
		all.add("Hello");
		all.add("Hello");
		all.add("World");
		all.add("Java");
		for (String str : all) {
			System.out.println(str);
		}
	}
}

=======================================================================================================

四、Map 接口

Map 接口虽然也是集合的操作接口，但是它与Collection 没有直接的关系。

├ . · 数据的保存：
V put(K key,V value)
├ . · 根据key 查询数据：
V get(Object key)
├ . · 取得全部的key
Set<K> keySet()

★ . 在Map 之中保存的key 是不可能重复的。

在Map 里面还存在有两个常用的子类：HashMap、Hashtable。

eg : 利用keySet()方法 , 取得全部的key , 并且输出全部的数据 .

package cn.demo;

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

public class TestDemo {
	public static void main(String[] args) {
		Map<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "张三");
		map.put(2, "李四");
		map.put(2, "王五"); // key重复发生的是替换操作
		map.put(null, "赵六"); // key为null
		map.put(3, null); // value为null
		Set<Integer> set = map.keySet();
		Iterator<Integer> iter = set.iterator();
		while (iter.hasNext()) {
			Integer key = iter.next();
			System.out.println(key + " --> " + map.get(key));
		}
	}
}

可是到底该如何输出Map 集合呢？面对集合一直有明确要求，使用Iterator 接口输出，但是现在的问题是在Map 接口里面没有直接提供为Iterator 接口实例化的方法。如果要想利用Iterator 实现Map 集合的输出，必须首先清楚Map 数据的保存格式。

给出Map 集合的标准输出格式：
├ . · 利用Map 集合之中的entrySet()方法将Map 集合变为Set 集合：
Set<Map.Entry<K,V>> entrySet()
├ . · 利用Set 接口中的iterator()方法为Iterator 接口实例化；
├ . · 利用Iterator 接口取得每一个Map.Entry 对象，并且从里面取出key、value 内容。

package cn.demo;

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

public class TestDemo {
	public static void main(String[] args) {
		Map<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "张三");
		map.put(2, "李四");
		map.put(2, "王五"); // key重复发生的是替换操作
		map.put(null, "赵六"); // key为null
		map.put(3, null); // value为null
		Set<Map.Entry<Integer, String>> set = map.entrySet();
		Iterator<Map.Entry<Integer, String>> iter = set.iterator();
		while (iter.hasNext()) {
			Map.Entry<Integer, String> me = iter.next();
			System.out.println(me.getKey() + " --> " + me.getValue());
		}
	}
}

是通过一系列的代码可以发现，Map 集合的特点实际上并不在内容的输出上，它最大的特点在于数据的查找上，即：根据key 查询出value，所以如果日后有人问你，Collection 和Map 那里不同，应该说出以下两点：
① . · Collection 是保存单个数据的，而Map 是保存一对数据的；
② . · Collection 保存数据的目的是为了输出，而Map 保存数据的目的是为了查询使用。

在Map 接口下还有一个Hashtable 的子类。这个类和Vector、Enumeration 都是在JDK 1.0 的时候提供的。

package cn.demo;

import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class TestDemo {
	public static void main(String[] args) {
		Map<Integer, String> map = new Hashtable<Integer, String>();
		map.put(1, "张三");
		map.put(2, "李四");
		map.put(2, "王五"); // key重复发生的是替换操作
		
		//Hashtable中不允许有空值
		//map.put(null, "赵六") ; // key为null
		//map.put(3, null) ; // value为null
		
		Set<Map.Entry<Integer, String>> set = map.entrySet();
		Iterator<Map.Entry<Integer, String>> iter = set.iterator();
		while (iter.hasNext()) {
			Map.Entry<Integer, String> me = iter.next();
			System.out.println(me.getKey() + " --> " + me.getValue());
		}
	}
}

★ . HashMap 与Hashtable 的区别？
① . · HashMap 是在JDK 1.2 的时候提供的，异步处理方式，所以属于非线程安全的操作，同时在HashMap 之中可以保存null；
② . · Hashtable 是在JDK 1.0 的时候提供的，同步处理方式，所以属于线程安全的操作，但是在Hashtable 里面不能够保存null.

在实际的开发之中，HashMap 保存数据上由于没有限制，所以要更加方便一些，那么以后的开发之中大部分的情况下都会优先选择HashMap 子类操作。

Java基础回顾 : 集合类