Java——集合

一、集合接口和迭代器

在Java类库中，Collection接口是所有集合类的基本接口。这个接口有两个基本方法：add和iterator。

add方法用于向集合中添加元素。如果结果改变返回true，否则返回false。

iterator方法用于返回一个实现了Iterator接口的对象。

public interface Iterator{

     Boolean hasNext(); 
     Object next(); 
     void remove();     
}

通过反复调用next方法，可以遍历集合中每个元素。为了防止在到达集合末尾时抛出异常，我们需要在调用next之前调用hasNext方法，如果迭代器对象还有多个可访问的元素，则返回true，否则返回false。

public class Ergodic {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(5);
        list.add(2);
        list.add(3);

        java.util.Iterator<Integer> it = list.iterator();
        while (it.hasNext()) {
            int i = (Integer) it.next();
            System.out.println(i);
        }
}

当然，这里循环有更加简便的方法。

public class Ergodic {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(5);
        list.add(2);
        list.add(3);

        System.out.println("用iterator+while");
        java.util.Iterator<Integer> it = list.iterator();
        while (it.hasNext()) {
            int i = (Integer) it.next();
            System.out.println(i);
        }
        
        System.out.println("用for循环遍历");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        System.out.println("用增强for循环");
        for (Integer i : list) {
            System.out.println(i);
        }
      
        System.out.println("用iterator+for");
        for (java.util.Iterator<Integer> iter = list.iterator(); iter.hasNext();) {
            int i = (Integer) iter.next();
            System.out.println(i);
        }
    
    }
}

由此可见，用增强for循环可以更加简练的表示同样的操作，并且对于任意标准类库中的集合都可以使用“for each”循环。

 

二、具体集合

集合类存放于java.util包中。
集合类存放的都是对象的引用，而非对象本身，出于表达上的便利，我们称集合中的对象就是指集合中对象的引用（reference)。
集合类型主要有3种：set(集）、list(列表）和map(映射)。

 

集set （没有重复项目的集合）  

HashSet-构造一个散列集，用hashCode()方法返回这个对象的散列码。

TreeSet-构造一个有序树集  

public class TreeSetT {

    public static void main(String[] args) {
        SortedSet<String> set = new TreeSet<>();
        set.add("B");
        set.add("C");
        set.add("A");
        for(String s:set){
            System.out.println(s);
        }
    }
}

运行结果：ABC

对象的比较，这里使用compareTo,如果this位于other之前返回负值，如果两个对象在排列中处于相同的位置，返回0 ，否则返回正值。

LinkedHashSet-对集迭代时，按增加顺序返回元素 

 

列表List （描述一个有序的集合）

ArrayList(封装了一个动态再分配的对象数组)-类似于Vector。区别：

一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的。
二.数据增长:当需要增长时,Vector默认增长为原来一倍，而ArrayList却是原来的一半。

因此，在使用时代码要在同步上耗费大量时间，所以在不需要同步时，使用ArrayList。

LinkedList(链表)-是双向链表，每个节点都有两个指针指向上一节点和下一节点。 

用add()加入元素，将对象添加至链表的尾部。 remove()删除元素。 运行结果：[B, C]

public class LinkedListT {
    public static void main(String[] args) {
        List<String> list = new LinkedList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        java.util.Iterator<String> iter = list.iterator();
        iter.next();//返回第一个元素。
        iter.remove();   
        System.out.println(list);
    }
}

由于要将元素添加至链表的中间，子接口ListIterator用来反向遍历链表，与next方法一样，previous返回越过的对象。

下面是越过链表中第一个元素A并在第二个元素B之前添加元素a的一个例子。运行结果：[A, a, B, C]

public class LinkedListT {
    public static void main(String[] args) {
        List<String> list = new LinkedList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        java.util.ListIterator<String> iter = list.listIterator();
        iter.next();
        iter.add("a");   
        System.out.println(list);
    }
    
}

set()方法取代调用next或者previous返回的上一个元素。运行结果：[a, B, C][a, C]

public class LinkedListT {
    public static void main(String[] args) {
        List<String> list = new LinkedList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        java.util.ListIterator<String> iter = list.listIterator();
        iter.next();//返回第一个元素
        iter.set("a");
        System.out.println(list);
        iter.next();//返回下一个元素
        iter.remove();   
        System.out.println(list);
    }
}

 

映射表Map  (用于存放键/值对)

实现Map接口的两个类：

HashMap-散列表的通用映射表 

 Map<String, Integer> map = new HashMap<>();  
 map.put("key", 1); 

TreeMap-构造树映射表   

 

三个视图：

键集KeySet()  

值集合（不是集）values() 

键/值对集enrySet()

注意：KeySet既不是HashSet，也不是TreeSet，而是实现了Set接口的某个其他类的对象，Set扩展了Collection接口，因此可以与使用人任何集合一样使用KeySet。  

Set<Integer> keys = map.keySet();   
for (Integer key : keys) {
      System.out.println(key);             
} 

如果需要查看键与值，可用下面两种方法

public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<Integer, String>();  
        map.put(1, "a");  
        map.put(2, "b");  
        map.put(3, "c");        
        /* 
         * 第一种 
         */  
        Set<Entry<Integer, String>> set = map.entrySet();  
        java.util.Iterator<Entry<Integer, String>> itor = set.iterator();  
        while (itor.hasNext())  
        {  
            Entry<Integer, String> entry = itor.next();  
            System.out.println(entry.getKey() + "     " + entry.getValue());  
        }         
        /* 
         * 第二种 
         */  
        for (Entry<Integer, String> entry : map.entrySet())  
            System.out.println(entry.getKey() + "     " + entry.getValue());
    }

 

专用集与映射表类

WeakHashMap是一种改进的HashMap，它对key实行“弱引用”，如果一个key不再被外部所引用，那么该key可以被GC回收。

LinkedHashMap用来记住插入元素项的顺序。