Java容器

泛型

容器用来容纳和管理数据，容器，也叫集合(Collection)。以下是容器的接口层次结构图：

泛型是JDK1.5以后增加的，它可以帮助我们建立类型安全的集合。在使用了泛型的集合中，遍历时不必进行强制类型转换。JDK提供了支持泛型的编译器，将运行时的类型检查提前到了编译时执行，提高了代码可读性和安全性。

泛型的本质就是“数据类型的参数化”。 我们可以把“泛型”理解为数据类型的一个占位符(形式参数)，即告诉编译器，在调用泛型时必须传入实际类型。

容器相关类都定义了泛型，我们在开发和工作中，在使用容器类时都要使用泛型。这样，在容器的存储数据、读取数据时都避免了大量的类型判断，非常便捷。

泛型类的声明

在类的声明处增加泛型列表，如：<T,E,V>。此处，字符可以是任何标识符，一般采用这3个字母。

class MyCollection<E> {// E:表示泛型;
    Object[] objs = new Object[5];
 
    public E get(int index) {// E:表示泛型;
        return (E) objs[index];
    }
    public void set(E e, int index) {// E:表示泛型;
        objs[index] = e;
    }
}

泛型类的使用

public class TestGenerics {
    public static void main(String[] args) {
        // 这里的”String”就是实际传入的数据类型；
        MyCollection<String> mc = new MyCollection<String>();
        mc.set("aaa", 0);
        mc.set("bbb", 1);
        String str = mc.get(1); //加了泛型，直接返回String类型，不用强制转换;
        System.out.println(str);
    }
}

Collection接口

Collection 表示一组对象，它是集中、收集的意思。Collection接口的两个子接口是List、Set接口。Collection接口中定义的方法：

• 增加元素到容器：boolean add(Object element)
• 从容器中移除元素：boolean remove(Object element)
• 容器中是否包含该元素：boolean contains(Object element)
• 容器中元素的数量：int size()
• 容器是否为空：boolean isEmpty()
• 清空容器中所有元素：void clear()
• 获得迭代器，用于遍历所有元素：Iterator iterator()
• 本容器是否包含c容器中的所有元素：boolean containsAll(Collection c)
• 将容器c中所有元素增加到本容器：boolean addAll(Collection c)
• 移除本容器和容器c中都包含的元素：boolean removeAll(Collection c)
• 取本容器和容器c中都包含的元素，移除非交集元素：boolean retainAll(Collection c)
• 转化成Object数组：Object[] toArray()

List接口

List是有序、可重复的容器

• List中每个元素都有索引标记。可以根据元素的索引标记(在List中的位置)访问元素，从而精确控制这些元素。
• List允许加入重复的元素。更确切地讲，List通常允许满足 e1.equals(e2) 的元素重复加入容器。

除了Collection接口中的方法，List多了一些跟顺序(索引)有关的方法：

• 在指定位置插入元素，以前元素全部后移一位：void add(int index, Object element)
• 修改指定位置的元素：Object set (int index,Object element)
• 返回指定位置的元素：Object get(int index)
• 删除指定位置的元素，后面元素全部前移一位：Object remove(int index)
• 返回第一个匹配元素的索引，如果没有该元素，返回-1：int indexOf(Object o)
• 返回最后一个匹配元素的索引，如果没有该元素，返回-1：int lastindexOf(Object o)

List接口常用的实现类有3个：

• ArrayList：ArrayList底层是用数组实现的存储。 特点：查询效率高，增删效率低，线程不安全。我们一般使用它。ArrayList底层使用Object数组来存储元素数据。所有的方法，都围绕这个核心的Object数组来开展。ArrayList本质上就是通过定义新的更大的数组，将旧数组中的内容拷贝到新数组，来实现扩容。
• LinkedList：底层用双向链表实现的存储。特点：查询效率低，增删效率高，线程不安全。
• Vector： Vector底层是用数组实现的List，相关的方法都加了同步检查，因此“线程安全,效率低”。 比如，indexOf方法就增加了synchronized同步标记。

Map接口

Map就是用来存储“键(key)-值(value) 对”的。 Map类中存储的“键值对”通过键来标识，所以“键对象”不能重复。

Map接口中常用的方法：

• 存放键值对：Object put(Object key,Object value)
• 通过键对象查找得到值对象：Object get(Object key)
• 删除键对象对应的键值对：Object remove(Object key)
• Map容器中是否包含键对象对应的键值对：boolean containsKey(Object key)
• Map容器中是否包含值对象对应的键值对：boolean containsValue(Object value)
• 包含键值对的数量：int size()
• Map是否为空：boolean isEmpty()
• 将t的所有键值对存放到本map对象：void putAll(Map t)
• 清空本map对象所有键值对：void clear()

Map 接口的实现类有有HashMap、TreeMap、HashTable、Properties等。

• HashMap：HashMap采用哈希算法实现，是Map接口最常用的实现类。 由于底层采用了哈希表存储数据，我们要求键不能重复，如果发生重复，新的键值对会替换旧的键值对。 HashMap在查找、删除、修改方面都有非常高的效率。允许key或value为null。
• HashTabl：和HashMap用法、底层实现几乎一样， 只不过HashTable的方法添加了synchronized关键字确保线程同步检查，安全性高，效率较低。不允许key或value为null。

Set接口

Set接口继承自Collection，Set接口中没有新增方法，方法和Collection保持完全一致。 Set容器特点：

• 无序：Set中的元素没有索引，我们只能遍历查找
• 不可重复：不允许加入重复的元素。

Set常用的实现类有：HashSet、TreeSet等，我们一般使用HashSet：

public class Test {
    public static void main(String[] args) {
        Set<String> s = new HashSet<String>();
        s.add("hello");
        s.add("world");
        System.out.println(s);
        s.add("hello"); //相同的元素不会被加入
        System.out.println(s);
        s.add(null);
        System.out.println(s);
        s.add(null);
        System.out.println(s);
    }
}

迭代器

迭代器为我们提供了统一的遍历容器的方式，参见以下示例代码：

public class Test {
    public static void main(String[] args) {
        List<String> aList = new ArrayList<String>();
        for (int i = 0; i < 5; i++) {
            aList.add("a" + i);
        }
        System.out.println(aList);
        for (Iterator<String> iter = aList.iterator(); iter.hasNext();) {
            String temp = iter.next();
            System.out.print(temp + "\t");
            if (temp.endsWith("3")) {// 删除3结尾的字符串
                iter.remove();
            }
        }
        System.out.println();
        System.out.println(aList);
    }
}

如果遇到遍历容器时，判断删除元素的情况，使用迭代器遍历。

遍历示例合辑：

//普通遍历
for(int i=0;i<list.size();i++){//list为集合的对象名
    String temp = (String)list.get(i);
    System.out.println(temp);
}
//增强for循环
for (String temp : list) {
System.out.println(temp);
}
//使用迭代器
for(Iterator iter= list.iterator();iter.hasNext();){
    String temp = (String)iter.next();
    System.out.println(temp);
}
//使用迭代器
Iterator  iter =list.iterator();
while(iter.hasNext()){
    Object  obj =  iter.next();
    iter.remove();//如果要遍历时，删除集合中的元素，建议使用这种方式！
    System.out.println(obj);
}
//增强for循环
for(String temp:set){
System.out.println(temp);
}
//使用迭代器
for(Iterator iter = set.iterator();iter.hasNext();){
    String temp = (String)iter.next();
    System.out.println(temp);
}
//根据key获取value
Map<Integer, Man> maps = new HashMap<Integer, Man>();
Set<Integer>  keySet =  maps.keySet();
for(Integer id : keySet){
System.out.println(maps.get(id).name);
}
//使用enteySet
Set<Entry<Integer, Man>>  ss = maps.entrySet();
for (Iterator iterator = ss.iterator(); iterator.hasNext();) {
    Entry e = (Entry) iterator.next(); 
    System.out.println(e.getKey()+"--"+e.getValue());

Collections工具类

类 java.util.Collections 提供了对Set、List、Map进行排序、填充、查找元素的辅助方法。

常用方法：

• 顺序排序：void sort(List)
• 随机排列：void shuffle(List)
• 逆序排序：void reverse(List)
• 重写容器：void fill(List, Object)
• 折半查找：int binarySearch(List, Object)

public class Test {
    public static void main(String[] args) {
        List<String> aList = new ArrayList<String>();
        for (int i = 0; i < 5; i++){
            aList.add("a" + i);
        }
        System.out.println(aList);
        Collections.shuffle(aList); // 随机排列
        System.out.println(aList);
        Collections.reverse(aList); // 逆续
        System.out.println(aList);
        Collections.sort(aList); // 排序
        System.out.println(aList);
        System.out.println(Collections.binarySearch(aList, "a2")); 
        Collections.fill(aList, "hello");
        System.out.println(aList);
    }
}