Java总结之容器[通俗易懂]

  Set中的数据对象没有顺序且不可反复
  List中的数据对象有顺序且可反复
Map接口定义了存储“键(key)-值(value)映射对”的方法。
【Collection接口】
Collection接口中所定义的方法：
int size();
boolean isEmpty();
void clear();
boolean contains(Object element);
boolean add(Object element);
boolean remove(Object element);
Iterator iterator();
boolean containsAll(Collection c);
boolean addAll(Collection c);
boolean removeAll(Collection c);
boolean retainAll(Collection c);
Object[] toArray();
容器类对象在调用remove、contains等方法时须要比較对象是否相等，这会涉及到对象类型的equals方法和hashCode方法。对于自己定义的类型，须要重写equals和hashCode方法以实现自己定义的对象相等规则。
  注意：相等的对象应该具有相等的hash codes。

添加Name类的equals和hashCode方法例如以下：

public boolean equals(Object obj) {
	if(obj instanceof Name) {
		Name name = (Name) obj;
		return (firstName.equals(name.firstName))
			&& (lastNmae.equals(name.lastName));
	}
	return super.equals(obj);
}
public int hashCode() {
	return firstName.hashCode();
}

【Iterator接口】

全部实现了Collection接口的容器类都有一个iterator方法用以返回一个实现了Iterator接口的对象。

Iterator对象称作迭代器，用以方便的实现对容器内元素的遍历操作。

Iterator接口定义了例如以下方法：

boolean hasNext(); //推断游标右边是否有元素

Object next(); //返回游标右边的元素并将游标移动到下一个位置

void ermove(); //删除游标左面的元素。在运行完next之后该操作仅仅能运行一次

Iterator对象的remove方法是在迭代过程中删除元素的唯一的安全方法。

【JDK1.5增强的for循环】

实例：

import java.util.*;
public class EnhancedFor {
	public static void main(String[] args) {
		int[] arr = {1,2,3,4,5};
		for(int i:arr) {
			System.out.println(i);
		}
		
		Collection<String> c = new ArrayList<String>();
		c.add(new String("aaa"));
		c.add(new String("bbb"));
		c.add(new String("ccc"));
		for(Object o : c) {
			System.out.println(o);
		}
	}
}

注：Java1.5之后使用了泛型。（如<String>规定了容器存放元素类型）

增强的for循环对于遍历array或Collection的时候相当简便

缺陷：

  数组:

    不能方便的訪问下标值

  集合：

    与使用Iterator相比，不能方便的删除集合中的内容

    在内部也是调用Iterator

总结：除了简单遍历并读出当中的内容外，不建议使用增强for

【Set接口】

Set接口是Collection的子接口。Set接口没有提供额外的方法。但实现Set接口的容器类中的元素是没有顺序的。并且不能够反复。

Set容器能够与数学中“集合”的概念相相应。

J2SDK API中 所提供的Set容器类有HashSet，TreeSet等。

【Set方法举例】

import java.util.*;
public class Test {
	public static void main(String[] args) {
		Set<String> s1 = new HashSet<String>();
		Set<String> s2 = new HashSet<String>();
		s1.add("a");s1.add("b");s1.add("c");
		s2.add("d");s2.add("a");s2.add("b");
		//Set和List容器类都具有Constructor(Collection c)
		//构造方法用于初始化容器类
		Set<String> sn = new HashSet<String>(s1);
		sn.retainAll(s2);
		Set<String> su = new HashSet<String>(s1);
		su.addAll(s2);
		System.out.println(sn);
		System.out.println(su);
	}
}

【List接口】

List接口是Collection的子接口。实现List接口的容器类中的元素有顺序的，并且能够反复。

List容器中的元素都相应一个整数型的序号记载其在容器中的位置。能够依据序号存取容器中的元素。
J2SDK所提供的List容器类有ArrayList,LinkedList等。

Object get(int index);
Object set(int index,Object element);
void add(int index,Object element);
Object remove(int index);
int indexOf(Object o);
int lastIndexOf(Object o);
【List经常使用算法】
类java.util.Collections提供了一些静态方法实现了基于List容器的一些经常使用算法。
void sort(List) 对List容器内的元素排序
void shuffle(List) 对List容器内的对象进行随机排序
void fill(List,Object) 用一个特定的对象重写整个List容器
void copy(List dest,List src) 将src List容器内容复制到dest List容器
int binarySearch(List,Object) 对于顺序的List容器，採用这般查找的方法查找特定对象
【List经常使用算法举例】

import java.util.*;
public class Test {
	public static void main(String[] args) {
		List<String> l1 = new LinkedList<String>();
		List<String> l2 = new LinkedList<String>();
		for(int i=0;i<=9;i++) { l1.add("a"+i); }
		System.out.println(l1);
		Collections.shuffle(l1); //随机排序
		System.out.println(l1);
		Collections.reverse(l1); //逆序
		System.out.println(l1);
		Collections.sort(l1); //排序
		System.out.println(l1);
		System.out.println(Collections.binarySearch(l1,"a5")); //折半查找
	}
}

【Comparable接口】

问题：上面的算法依据什么确定容器中对象的“大小”顺序？

全部能够“排序”的类都实现了java.lang.Comparable接口，Comparable接口中仅仅有一个方法

public int CompareTo(Object obj); 该方法：

 返回 0 表示 this == obj

 返回正数表示 this > obj

 返回负数表示 this < obj

实现了Comparable接口的类通过实现compareTo方法从而确定该类对象的排序方式。

【怎样选择数据结构】

衡量标准：读的效率和改的效率

  Array度快盖满

  Linked该快杜曼

  Hash两者之间

【Map接口】

实现Map接口的类用来存储 键-值 对。

Map接口的实现类有HashMap和TreeMap等。

Map类中存储的 键-值 对通过建来标识，所以键值不能反复。
Object put(Object key,Object value);
Object get(Object key);
Object remove(Object key);
boolean containsKey(Object key);
boolean containsValue(Object value);
int size();
boolean isEmpty();
void putAll(Map t);
void clear();
【Map方法举例】

import java.util.*;
public class Test {
	public static void main(String[] args) {
		Map<String,Integer> m1 = new HashMap<String,Integer>(); 
		Map<String,Integer> m2 = new TreeMap<String,Integer>();
		m1.put("one" , new Integer(1));
		m1.put("two" , new Integer(2));
		m1.put("three" , new Integer(3));
		m1.put("A" , new Integer(1));
		m2.put("B" , new Integer(2));
		System.out.println(m1.size());
		System.out.println(m1.containsKey("one"));
		System.out.println(m2.containsValue(new Integer(1)));
		if(m1.containsKey("two")) {
			int i = ((Integer)m1.get("two")).intValue();
			System.out.println(i);
		}
		Map<String,Integer> m3 = new HashMap<String,Integer>(m1);
		m3.putAll(m2);
		System.out.println(m3);
	}
}

【Auto-boxing/unboxing】

在合适的时机自己主动打包、捷豹

  自己主动将基础类型转换为对象

  自己主动将对象转换为基础类型

【JDK1.5泛型】

起因：

  JDK1.4曾经类型不明白：

    装入集合的类型都被当做Object对待。从而失去自己的实际类型。

    从集合中取出时往往须要转型，效率低，easy产生错误。

解决的方法：
  在定义集合的时候同一时候定义集合中对象的类型
    能够再定义Collection的时候指定
    也能够在循环时用iterator指定
优点：增强程序的可读性和稳定性。
【总结】
一个图；一个类Collections；三个知识点for,Generic,Auto-boxing/unboxing;六个接口