集合的遍历 List Set TreeSet LinkedList Map（1）

package listdamo;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeSet;

public class listdamo1 {

    /**
     * 迭代器也就是将集合的数据放到一个容器中并排成一排，iterator有一个游标，最初的时候，
     * 游标在第一个元素前面，调用Iterator.next()
     * 是将游标往后移一位，Iterator.hasNext()是判断游标后面还没有可以迭代的元素。
     * 
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //listIteat();// list集合
        //setIterat();// set集合
        //mapIterat();// map集合
        treeSet();// tree集合
        linkList();//linklist集合
    }

    // 迭代器遍历集合list
    public static void listIteat() {
        // 迭代器遍历集合

        List<String> list1 = new ArrayList<String>();
        list1.add("qq");
        list1.add("ooo");
        Iterator<String> iterator1 = list1.iterator();
        while (iterator1.hasNext()) {
            String next = iterator1.next();
            System.out.println(next);
        }
    }

    // 迭代器遍历集合set
    public static void setIterat() {
     
        Set<String> set1 = new HashSet<String>();
        set1.add("eeee");
        set1.add("rrrrrrrrrrr");
        Iterator<String> iteratorSet1 = set1.iterator();
        while (iteratorSet1.hasNext()) {
            String next = iteratorSet1.next();
            System.out.println(next);
        }
    }

/*
     * 遍历Map,Map是存放键值对的，与集合不一样， 集合只能存放单一元素，所以我们先得将Map看成一个单一元素，
     * 放到Set集合中去，而JDk中Map有一个方法entrySet() 就是将Map放到一个Set集合中去
     */
    public static void mapIterat() {
        System.out.println("------方法1-------------------");
        Map<Integer, String> map0 = new HashMap<Integer, String>();
        map0.put(1, "eertrty");
        map0.put(2, "tyytytyyt");
        Set<Map.Entry<Integer, String>> entries = map0.entrySet();
        Iterator<Map.Entry<Integer, String>> iteratorMap = entries.iterator();
        while (iteratorMap.hasNext()) {
            Map.Entry<Integer, String> next = iteratorMap.next();
            System.out.println(next);
            System.out.println("------------------------");
            System.out.println(next.getKey() + ":" + next.getValue());
            System.out.println("------------------------");
        }

        System.out.println("--------方法1end----------------");

        

        System.out.println("--------方法2----- 取出map元素 ----- 两种-----------");
        // 使用类型安全的Map -- 因为map是一个键值对结构，执行两个类型泛型
        Map<String, String> map = new HashMap<String, String>();
        map.put("111","aaa");
        map.put("222","bbb");
        // 因为使用了泛型，所以key和value类型都必须为String

        // 取出map元素 ----- 两种
        // 第一种 通过 Map 的 keySet进行遍历
        Set<String> keys = map.keySet(); // 获得key集合
        for (String key : keys) {
            System.out.println(key + ":" + map.get(key));
        }
        System.out.println("-------------------------");

        // 第二种 通过 map的 entrySet ---- 获得每一个键值对
        Set<Map.Entry<String, String>> entrySet = map.entrySet(); // 每一个元素
        // 就是一个键值对
        for (Entry<String, String> entry : entrySet) {
            // 通过 entry的 getKey和getValue获得每一个键和值
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
    }

 //treeSet集合
    public static void treeSet() {
         // 使用类型安全Set
        Set<String> set = new TreeSet<String>();

        set.add("asd");
        set.add("fdf");
        set.add("bxc");
        // 因为使用泛型 只能添加String类型元素

        // 取出Set元素 --- 两种 因为Set是无序的，所以比List少一种遍历方法
        System.out.println("----treeSet---第一种 继承 Collection ----------------");
        // 第一种 继承 Collection 所以使用 Iterator 遍历
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            String s = iterator.next();
            System.out.println(s);
        }
        System.out.println("-------treeSet----第二种 JDK5 引入 foreach 可以使用foreach 遍历 Set------------");
        // 第二种 JDK5 引入 foreach 可以使用foreach 遍历 Set
        for (String s : set) {
            System.out.println(s);
        }

    }

 //linkedlist集合
    public static void linkList() {
         // 使用类型安全List
        List<String> list = new LinkedList<String>();

        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        // 因为使用泛型，只能将list添加 String类型 元素

        // 遍历List --- 三种

        System.out.println("------linklist----第一种 因为List是有序的（存入顺序和取出顺序一样） 通过 size 和 get方法进行遍历---");
        // 第一种 因为List是有序的（存入顺序和取出顺序一样） 通过 size 和 get方法进行遍历
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }

        System.out.println("-------linklist---第二种 因为List 继承 Collection 接口-------------");
        // 第二种 因为List 继承 Collection 接口 ，通过 Collection的iterator进行遍历
        Iterator<String> iterator = list.iterator();
        // 遍历iterator 通过 迭代器 hasNext 和 next 方法进行遍历
        while (iterator.hasNext()) {
            String s = iterator.next();
            System.out.println(s);
        }

        System.out.println("----linklist--第三种 JDK5 引入 foreach循环 结构 --------");

    // 第三种 JDK5 引入 foreach循环 结构 ，通过foreach结构 遍历 list
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("----------------------------------------------");    

    }

    // end class
}