java基础---集合框架

一、集合与数组 区别

        数组（可以存储基本数据类型）是用来存现对象的一种容器，但是数组的长度固定，不适合在对象数量未知的情况下使用。
      集合（只能存储对象，对象类型可以不一样）的长度可变，可在多数情况下使用。
二、集合类结构
　　Java中的集合包含多种数据结构，如链表、队列、哈希表等。从类的继承结构来说，可以分为两大类，一类是继承自Collection接口，这类集合包含List、Set和Queue等集合类。另一类是继承自Map接口，这主要包        含了哈希表相关的集合类。下面我们看一下这两大类的继承结构图：

 图中的绿色的虚线代表实现，绿色实线代表接口之间的继承，蓝色实线代表类之间的继承。

 三、集合详解

 collection接口是集合类的根接口，Java中没有提供这个接口的直接的实现类。但是却让其被继承产生了两个接口，就是Set和List。Set中不能包含重复的元素。List是一个有序的集合，可以包含重复的元素，提供了                       按索 引访问的方式。

List接口
　　List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。
和下面要提到的Set不同，List允许有相同的元素。
　 　除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个 ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素， 还能向前或向后遍历。
　　实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。

LinkedList类
　 　LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在 LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。
　　注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：
　　　　List list = Collections.synchronizedList(new LinkedList(...));

ArrayList类
　　ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。
size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
　 　每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并 没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
　　和LinkedList一样，ArrayList也是非同步的（unsynchronized）。

Vector类
　 　Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的 Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例 如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该 异常。

Stack 类
　　 Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方 法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

自定义的集合arraylist

package cn.bjsxt.collection;


/**
 * 自己实现一个ArrayList，帮助我们更好的理解ArrayList类的底层结构！
 *
 */
public class SxtArrayList /*implements List*/ {
    
    private Object[] elementData;
    private int size;
    
    
    public int size(){
        return size;
    }
    
    public boolean isEmpty(){
        return size==0;
    }
    
    public SxtArrayList(){
        this(10);
    }
    
    public SxtArrayList(int initialCapacity){
        if(initialCapacity<0){
            try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        elementData = new Object[initialCapacity];
    }
    
    public void add(Object obj){
        //数组扩容和数据的拷贝
        if(size==elementData.length){
            Object[] newArray = new Object[size*2+1];
            System.arraycopy(elementData, 0, newArray, 0, elementData.length);
//            for(int i=0;i<elementData.length;i++){
//                newArray[i] = elementData[i];
//            }
            elementData = newArray;
        }
        
        elementData[size++]=obj;
//        size++;
    }
    
    public Object get(int index){
        rangeCheck(index);
        
        return elementData[index];
    }
    
    public void remove(int index){
        rangeCheck(index);
        //删除指定位置的对象
        //a b d e
        int numMoved = size - index - 1;
        if (numMoved > 0){
            System.arraycopy(elementData, index+1, elementData, index,
                    numMoved);
        }
        elementData[--size] = null; // Let gc do its work
    }

    public void remove(Object obj){
        for(int i=0;i<size;i++){
            if(get(i).equals(obj)){  //注意：底层调用的equals方法而不是==.
                remove(i);
            }
        }
    }
    
    public Object set(int index,Object obj){
        rangeCheck(index);

        Object oldValue =  elementData[index];
        elementData[index] = obj;
        return oldValue;
    }
    
    public void add(int index,Object obj){
        rangeCheck(index);
        
        ensureCapacity();  //数组扩容
        
        System.arraycopy(elementData, index, elementData, index + 1,
                 size - index);
        elementData[index] = obj;
        size++;
    }
    
    private void ensureCapacity(){
        //数组扩容和数据的拷贝
                if(size==elementData.length){
                    Object[] newArray = new Object[size*2+1];
                    System.arraycopy(elementData, 0, newArray, 0, elementData.length);
//                            for(int i=0;i<elementData.length;i++){
//                                newArray[i] = elementData[i];
//                            }
                    elementData = newArray;
                }
    }
    
    
    private void rangeCheck(int index){
        if(index<0||index>=size){
            try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    
    public static void main(String[] args) {
        SxtArrayList list = new SxtArrayList(3);
        list.add("333");
        list.add("444");
        list.add("5");
        list.add("344433");
        list.add("333");
        list.add("333");
        System.out.println(list.size()); 
//        System.out.println(list.get(6));
        list.remove("444");
        System.out.println(list.size());
    }

}

自定义linkedlist

package com.bdqn;


//用来表示一个节点
public class Node {
     Node previous;   //上一个节点
     Object obj;
     Node next;        //下一个节点
    
    public Node() {
    }
    
    public Node(Node previous, Object obj, Node next) {
        super();
        this.previous = previous;
        this.obj = obj;
        this.next = next;
    }

    public Node getPrevious() {
        return previous;
    }

    public void setPrevious(Node previous) {
        this.previous = previous;
    }

    public Object getObj() {
        return obj;
    }

    public void setObj(Object obj) {
        this.obj = obj;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
    
    
    
}

package com.bdqn;
import java.util.LinkedList;


public class SxtLinkedList /*implements List*/ {
    private Node first;
    private Node last;
    
    private int size;
    
    public void add(Object obj){
        Node n = new Node();
    
        if(first==null){
            n.setPrevious(null);
            n.setObj(obj);
            n.setNext(null);
            
            first = n;
            last = n;
        }else{
            //直接往last节点后增加新的节点
            n.setPrevious(last);
            n.setObj(obj);
            n.setNext(null);
            
            last.setNext(n);
            
            last = n;
        }
        size++;
    }
    
    public int size(){
        return size;
    }
    
    private void rangeCheck(int index){
        if(index<0||index>=size){
            try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    public Object get(int index){   //2
        rangeCheck(index);
        
        // 0 1 2 3 4
        Node temp = node(index);
        if(temp!=null){
            return temp.obj;
        }
        return null;
    }
    
    public Node node(int index){
        Node temp = null;
        if(first!=null){
            temp = first;
            for(int i=0;i<index;i++){
                temp = temp.next;
            }
        }
        LinkedList l;
        return temp;
    }
    
    
    public void remove(int index){
        Node temp = node(index);
        
        if(temp!=null){
            Node up = temp.previous;
            Node down = temp.next;
            up.next = down;
            down.previous = up;
            size--;
        }
        
    }
    
    public void add(int index,Object obj){
        Node temp = node(index);
        
        Node newNode = new Node();
        newNode.obj = obj;
        
        if(temp!=null){
            Node up = temp.previous;
            up.next = newNode;
            newNode.previous = up;
            
            newNode.next = temp;
            temp.previous = newNode;
            
            size++;
        }
    }
    
    
    
    
    
    public static void main(String[] args) {
        SxtLinkedList list = new SxtLinkedList();
        list.add("aaa");
        list.add("bbb");
        list.add(1,"BBBB");
        list.add("ccc");
//        list.remove(1);
        System.out.println(list.get(1)); 
    }
    

}

Set接口
　　Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。
　　很明显，Set的构造函数有一个约束条件，传入的Collection参数不能包含重复的元素。
　　请注意：必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。

HashSet
HashSet有以下特点
 不能保证元素的排列顺序，顺序有可能发生变化
 不是同步的
 集合元素可以是null,但只能放入一个null
当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据 hashCode值来决定该对象在HashSet中存储位置。
简单的说，HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等，并且两个对象的hashCode()方法返回值相 等
注意，如果要把一个对象放入HashSet中，重写该对象对应类的equals方法，也应该重写其hashCode()方法。其规则是如果两个对 象通过equals方法比较返回true时，其hashCode也应该相同。另外，对象中用作equals比较标准的属性，都应该用来计算 hashCode的值。

TreeSet类
TreeSet是SortedSet接口的唯一实现类，TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式，自然排序 和定制排序，其中自然排序为默认的排序方式。向TreeSet中加入的应该是同一个类的对象。
TreeSet判断两个对象不相等的方式是两个对象通过equals方法返回false，或者通过CompareTo方法比较没有返回0
自然排序
自然排序使用要排序元素的CompareTo（Object obj）方法来比较元素之间大小关系，然后将元素按照升序排列。
Java提供了一个Comparable接口，该接口里定义了一个compareTo(Object obj)方法，该方法返回一个整数值，实现了该接口的对象就可以比较大小。
obj1.compareTo(obj2)方法如果返回0，则说明被比较的两个对象相等，如果返回一个正数，则表明obj1大于obj2，如果是 负数，则表明obj1小于obj2。
如果我们将两个对象的equals方法总是返回true，则这两个对象的compareTo方法返回应该返回0
定制排序
自然排序是根据集合元素的大小，以升序排列，如果要定制排序，应该使用Comparator接口，实现 int compare(T o1,T o2)方法。

最重要：

1、TreeSet 是二差树实现的,Treeset中的数据是自动排好序的，不允许放入null值。 

2、HashSet 是哈希表实现的,HashSet中的数据是无序的，可以放入null，但只能放入一个null，两者中的值都不能重复，就如数据库中唯一约束。 

3、HashSet要求放入的对象必须实现HashCode()方法，放入的对象，是以hashcode码作为标识的，而具有相同内容的 String对象，hashcode是一样，所以放入的内容不能重复。但是同一个类的对象可以放入不同的实例 。

自定义hashset

package cn.bjsxt.collection;

import java.util.HashMap;

/**
 * 自定义自己的HashSet
 * @author Administrator
 *
 */
public class SxtHashSet {

    HashMap map;
    private static final Object PRESENT = new Object();

    public SxtHashSet(){
        map = new HashMap();
    }
    
    public int size(){
        return map.size();
    }
    
    public void add(Object o){
        map.put(o, PRESENT);   //set的不可重复就是利用了map里面键对象的不可重复！
    }
    
    public static void main(String[] args) {
        SxtHashSet s = new SxtHashSet();
        s.add("aaa");
        s.add(new String("aaa"));
        System.out.println(s.size());
    }

}

hashSet使用

package com.zwj.set;
public class Food {
    private String name;
    private double price;
    
    public Food() {
        // TODO Auto-generated constructor stub
    }
    
    
    
    public Food(String name, double price) {
        super();
        this.name = name;
        this.price = price;
    }



    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }



    



    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        long temp;
        temp = Double.doubleToLongBits(price);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        return result;
    }



    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Food other = (Food) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (Double.doubleToLongBits(price) != Double
                .doubleToLongBits(other.price))
            return false;
        return true;
    }
    
    
    
    
    
}

package com.zwj.set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/**
 * 默认的hashcode时地址转换码，需要重写
 * 先比较hashcode 
 * 再比较equals
 * 
 * @author Administrator
 *
 */
public class SetDemo01 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Food food1 = new Food("瓜子",5);
        Food food2 = new Food("糖果",10);
        Food food3 = new Food("瓜子",5);
        Food food4 = new Food("瓜子2",5);
        Set<Food> set = new HashSet<Food>();
        set.add(food1);
        set.add(food1);
        set.add(food2);
        set.add(food3);
        set.add(food4);
        System.out.println(set.size());
        
        
        
        System.out.println("===foreach=====");
        for(Food temp:set){
            System.out.println(temp.getPrice()+"-->"+temp.getName());
        }
        System.out.println("======iterator=========");
        Iterator<Food> it =set.iterator();
        while(it.hasNext()){ //判断，不会移动游标 |指针 
            Food temp =it.next(); //一次移动一个游标 不能移动多次
            //System.out.println(it.next().getPrice()+"-->"+it.next().getName()); 
            System.out.println(temp.getPrice()+"-->"+temp.getName());
        }
        
        
    }

}
/*
 3
===foreach=====
10.0-->糖果
5.0-->瓜子2
5.0-->瓜子
======iterator=========
10.0-->糖果
5.0-->瓜子2
5.0-->瓜子
*/

使用自定义类型 接收签名:从界面上接收 到会人员的名单 放入 HashSet中点名:遍历输出名单

package com.zwj.set;


import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;
/**
 * 使用自定义类型 接收签名:从界面上接收 到会人员的名单 放入 HashSet中
    点名:遍历输出名单

 * @author Administrator
 *
 */
public class SetDemo04 {
    private Scanner sc ;
    private Set<Member> members;
    SetDemo04(){
        sc = new Scanner(System.in);
        members= new HashSet<Member>();
    }
    public String getStringFromConsole(){
        return sc.nextLine();
    }    
    
    //签名:
    public void addMemeber(Member mem){
        members.add(mem);
    }
    //点名:遍历输出名单
    public void showMemeber(){
        Iterator<Member> it = members.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        SetDemo04 demo = new SetDemo04();
        System.out.println("====签名======");
        while(true){
            String name =demo.getStringFromConsole();
            if(name.equalsIgnoreCase("over")){
                break;
            }
            Member m =new Member(name);
            demo.addMemeber(m);
        }
        System.out.println("=========参会人员有====");
        demo.showMemeber();
        /*====签名======
in
am
me
over
=========参会人员有====
名单:me,签名时间:2017-11-18 18:00:39
名单:am,签名时间:2017-11-18 18:00:36
名单:in,签名时间:2017-11-18 18:00:33
*/
    }

}


class Member{
    private String name;
    private Date attendTime;
    public Member() {
        attendTime = new Date();
    }    
    
    public Member(String name) {
        this();
        this.name = name;    
    }



    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Date getAttendTime() {
        return attendTime;
    }
    public void setAttendTime(Date attendTime) {
        this.attendTime = attendTime;
    }

    

    
    
    public Member(String name, Date attendTime) {
        super();
        this.name = name;
        this.attendTime = attendTime;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;        
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Member other = (Member) obj;        
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    @Override
    public String toString() {
        return "名单:"+name+",签名时间:"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(attendTime);
    }
    
    
}

Map接口
　 　请注意，Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个 value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。

Hashtable类
　　Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象都可作为key或者value。
　　添加数据使用put(key, value)，取出数据使用get(key)，这两个基本操作的时间开销为常数。
Hashtable 通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大，这会影响像get和put这样的操作。
使用Hashtable的简单示例如下，将1，2，3放到Hashtable中，他们的key分别是”one”，”two”，”three”：
　　　　Hashtable numbers = new Hashtable();
　　　　numbers.put(“one”, new Integer(1));
　　　　numbers.put(“two”, new Integer(2));
　　　　numbers.put(“three”, new Integer(3));
　　要取出一个数，比如2，用相应的key：
　　　　Integer n = (Integer)numbers.get(“two”);
　　　　System.out.println(“two = ” + n);
　 　由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置，因此任何作为key的对象都必须实现hashCode和equals方 法。hashCode和equals方法继承自根类Object，如果你用自定义的类当作key的话，要相当小心，按照散列函数的定义，如果两个对象相 同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的hashCode不一定不同，如 果两个不同对象的hashCode相同，这种现象称为冲突，冲突会导致操作哈希表的时间开销增大，所以尽量定义好的hashCode()方法，能加快哈希 表的操作。
　　如果相同的对象有不同的hashCode，对哈希表的操作会出现意想不到的结果（期待的get方法返回null），要避免这种问题，只需要牢记一条：要同时复写equals方法和hashCode方法，而不要只写其中一个。
　　Hashtable是同步的。

HashMap类
　 　HashMap和Hashtable类似，不同之处在于HashMap是非同步的，并且允许null，即null value和null key。，但是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操作时间开销和HashMap 的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。

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

总结
　　如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。
　　如果程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑非同步的类，其效率较高，如果多个线程可能同时操作一个类，应该使用同步的类。
　　要特别注意对哈希表的操作，作为key的对象要正确复写equals和hashCode方法。
　　尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对抽象编程。

自定义集合sxtHashMap

package com.bdqn;


import java.util.LinkedList;

/**
 * 自定义Map的升级版：
 * 1. 提高查询的效率
 *
 *
 */
public class SxtMap002 {

    LinkedList[]  arr  = new LinkedList[9]; //Map的底层结构就是：数组+链表!
    int size;
    
    public void put(Object key,Object value){
        SxtEntry  e = new SxtEntry(key,value);
        
        int a = key.hashCode()%arr.length;
        if(arr[a]==null){
            LinkedList list = new LinkedList();
            arr[a] = list;
            list.add(e);
        }else{
            LinkedList list = arr[a];
            for(int i=0;i<list.size();i++){
                SxtEntry e2 = (SxtEntry) list.get(i);
                if(e2.key.equals(key)){
                    e2.value = value;  //键值重复直接覆盖！
                    return;
                }
            }
            
            arr[a].add(e);
        }
        //a:1000-->1   b:10000-->13
    }

    public Object get(Object key){
        int a = key.hashCode()%arr.length;
        if(arr[a]!=null){
            LinkedList list = arr[a];
            for(int i=0;i<list.size();i++){
                SxtEntry e = (SxtEntry) list.get(i);
                if(e.key.equals(key)){
                    return e.value;
                }
            }
        }
        
        return null;
    }
    
    public static void main(String[] args) {
        SxtMap002 m = new SxtMap002();
        m.put("高琪", new Wife("杨幂"));
        m.put("高琪", new Wife("李四"));
        Wife w = (Wife) m.get("高琪");
        System.out.println(w.name); 
    }

}
class  SxtEntry {
    Object key;
    Object value;
    
    public SxtEntry(Object key, Object value) {
        super();
        this.key = key;
        this.value = value;
    }    
}
class Wife{
    public static String name;
     
    public Wife(String name) {
        this.name = name;
    }

    public Wife() {}
}

四、遍历

 在类集中提供了以下四种的常见输出方式：

1）Iterator：迭代输出，是使用最多的输出方式。

2）ListIterator：是Iterator的子接口，专门用于输出List中的内容。

3）foreach输出：JDK1.5之后提供的新功能，可以输出数组或集合。

4）for循环

代码示例如下：

 for的形式：for（int i=0;i<arr.size();i++）{...}

 foreach的形式： for（int　i：arr）{...}

 iterator的形式：
Iterator it = arr.iterator();
while(it.hasNext()){ object o =it.next(); ...}

package com.bdqn;

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

public class Dmeo {
public static void main(String[] args) {
    List<String> list = new ArrayList<String>();
    list.add("aaa");
    list.add("bbb");
    list.add("ccc");   
    //第一种遍历list 集合
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
    //第二种遍历list集合
    for (String  str : list) {
        System.out.println(str);
    }
    
    //第三种遍历list集合
    
    Iterator<String> stu=list.iterator();
    while (stu.hasNext()) {
        //String string = (String) stu.next();
        System.out.println( stu.next());
    }
}        
}

package com.bdqn;

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



public class Dmeo {
public static void main(String[] args) {
    Set<String>   set=new HashSet<String>();
    set.add("a");
    set.add("b");
    set.add("c");
    set.add("d");
    //iterrator 迭代
    Iterator<String> iterator=set.iterator();
    while (iterator.hasNext()) {
        String string = (String) iterator.next();
        System.out.println(string);
    }
    //用增强for循环去遍历
    for (String string1 : set) {
        System.out.println(string1);
    }    
 }        
}

package com.bdqn;

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



public class Dmeo {
public static void main(String[] args) {
     Map<Integer, String> map = new HashMap<Integer, String>();
            map.put(1, "a");
            map.put(2, "b");
            map.put(3, "c");
            map.put(4, "d");
            map.put(5, "e");
       
       System.out.println("第一种遍历map集合    ");
       Iterator<Integer> iterator=map.keySet().iterator();       
         while (iterator.hasNext()) {
            Integer integer = (Integer) iterator.next();
            System.out.println(integer+":"+map.get(integer));
        } 
         
      System.out.println("第二种for循环遍历  前兩中都是先得到key的集合，在得到values");
       for (Integer integer : map.keySet()) {
           System.out.println(integer+":"+map.get(integer));
       } 
       
       System.out.println("第三种遍历的方式 iterraotr直接得到key values集合");
       Iterator<Map.Entry<Integer, String>> iterator2=map.entrySet().iterator();
       while (iterator2.hasNext()) {
        Map.Entry<java.lang.Integer, java.lang.String> entry = (Map.Entry<java.lang.Integer, java.lang.String>) iterator2
                .next();
        System.out.println(entry.getKey()+":"+entry.getValue());
    }
       
       System.out.println("第四种遍历的方式 for直接得到key values集合");
       for (Map.Entry<Integer, String> entry2 : map.entrySet()) {
           System.out.println(entry2.getKey()+":"+entry2.getValue());
        
    }  
 }        
}

五、主要实现类区别

Vector和ArrayList
1，vector是线程同步的，所以它也是线程安全的，而arraylist是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用arraylist效率比较高。
2，如果集合中的元素的数目大于目前集合数组的长度时，vector增长率为目前数组长度的100%，而arraylist增长率为目前数组长度的50%。如果在集合中使用数据量比较大的数据，用vector有一定的优势。
3，如果查找一个指定位置的数据，vector和arraylist使用的时间是相同的，如果频繁的访问数据，这个时候使用vector和arraylist都可以。而如果移动一个指定位置会导致后面的元素都发生移动，这个时候就应该考虑到使用linklist,因为它移动一个指定位置的数据时其它元素不移动。
ArrayList 和Vector是采用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，都允许直接序号索引元素，但是插入数据要涉及到数组元素移动等内存操作，所以索引数据快，插入数据慢，Vector由于使用了synchronized方法（线程安全）所以性能上比ArrayList要差，LinkedList使用双向链表实现存储，按序号索引数据需要进行向前或向后遍历，但是插入数据时只需要记录本项的前后项即可，所以插入数度较快。

arraylist和linkedlist
1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。 这一点要看实际情况的。若只对单条数据插入或删除，ArrayList的速度反而优于LinkedList。但若是批量随机的插入删除数据，LinkedList的速度大大优于ArrayList. 因为ArrayList每插入一条数据，要移动插入点及之后的所有数据。

HashMap与TreeMap
1、 HashMap通过hashcode对其内容进行快速查找，而TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定的）。
2、在Map 中插入、删除和定位元素，HashMap是最好的选择。但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。使用HashMap要求添加的键类明确定义了hashCode()和 equals()的实现。
两个map中的元素一样，但顺序不一样，导致hashCode()不一样。
同样做测试：
在HashMap中，同样的值的map,顺序不同，equals时，false;
而在treeMap中，同样的值的map,顺序不同,equals时，true，说明，treeMap在equals()时是整理了顺序了的。

HashTable与HashMap
1、同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的。
2、HashMap允许存在一个为null的key，多个为null的value 。
3、hashtable的key和value都不允许为null。