map和list遍历基础

本文属原创，转载请注明出处：http://www.cnblogs.com/robinjava77/p/5456085.html (Robin)

Map

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

/**
 * Created by robin on 2016/4/12.
 *
 * @author robin
 */
public class MapTest {

    public static void main(String args[]){
        traversalKey();
    }

    /**
     * 在不知道map keys 的情况下 遍历map的key和value
     *
     * 总结
     *  1.仅需要键(keys) map.keySet()
     *  2.仅需要值(values) map.values()
     *  3.使用的语言版本低于java 5，或是打算在遍历时删除entries，必须使用方法三
     *  4.键值都要使用方法二。
     */
    public static void traversalKey(){
        Map<String,String> map = new HashMap<String, String>();
        map.put("1","a");
        map.put("2","b");
        map.put("3","c");
        map.put("4","d");
        map.put("5","e");
        map.put("6","e");
        /**第一种方法：keySet() 获取key值，通过key值get Value 效率最低！由key get value 耗时*/
        for (String key:map.keySet()){
            System.out.println("key:"+key+"--value:"+map.get(key));
        }
        /**第二种方法：Map.Entry 效率高于第一种，一般推荐这种写法*/
        for(Map.Entry<String,String> entry:map.entrySet()){
            System.out.println("key:"+entry.getKey()+"--value:"+entry.getValue());
        }
       /**第三种方法：Iterator遍历 这种遍历方法新旧java版本皆通用，在遍历删除map的key-value时，这是唯一可选择的方法*/
        Iterator<Map.Entry<String, String>> entries = map.entrySet().iterator();
        while (entries.hasNext()) {
            Map.Entry<String, String> entry = entries.next();
            System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
        }
        /**扩展 直接获取map的所有value值*/
        for(String value:map.values()){
            System.out.println(value);
        }

    }
}

List

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

/**
 * Created by robin on 2016/4/13.
 * 关于list遍历有三种办法：①普通方法；②增强for循环；③iterator
 * 效率 ①>③>②
 *
 * ①内部不锁定, 效率最高, 但是当写多线程时要考虑并发操作的问题
 * ②内部实现是使用了③
 * ③执行过程中会进行数据锁定, 性能稍差
 *
 * list遍历删除数据建议采用方法③，若采用方法①，请使用倒序遍历删除，详情参考：ordinaryDelDesc；
 * 不可使用②进行遍历删除，会产生bug
 * @author robin
 */
public class ListTest {

    public static void main(String args[]){
        List<Student> stuList = initList();
        /**
         * 普通遍历方法
         */
        for(int i= 0;i< stuList.size();i++){
            Student stuShow = stuList.get(i);
//            System.out.println("stuId:"+stuShow.getStuId()+"----stuName:"+stuShow.getName());
        }

        System.out.println("----普通遍历方法----");

        /**
         * 增强for循环遍历
         */
        for (Student stu:stuList){
//            System.out.println("stuId:"+stu.getStuId()+"----stuName:"+stu.getName());
        }
        System.out.println("----增强for循环遍历----");
        /**
         * Iterator 遍历
         */
        Iterator<Student> iterator = stuList.iterator();
        while (iterator.hasNext()){
            Student stuShow = iterator.next();
//            System.out.println("stuId:"+stuShow.getStuId()+"----stuName:"+stuShow.getName());
        }
        System.out.println("----Iterator循环遍历----");

        //list中删除元素方法
        ordinaryDelAsc(initList());
        System.out.println("----普通遍历正序删除----");
        ordinaryDelDesc(initList());
        System.out.println("----普通遍历倒序删除----");
//        heighten(stuList);
        iteratorDel(initList());
        System.out.println("----Iterator循环遍历删除----");
    }

    public static List<Student> initList(){
        List<Student> stuList = new ArrayList<Student>();
        Student stuA = new Student("10001","路飞");
        stuList.add(stuA);
        Student stuB = new Student("10002","索隆");
        stuList.add(stuB);
        Student stuC = new Student("10003","山治");
        stuList.add(stuC);
        Student stuD = new Student("10004","娜美");
        stuList.add(stuD);
        Student stuE = new Student("10005","罗宾");
        stuList.add(stuE);
        Student stuF = new Student("10006","乌索普--1号");
        stuList.add(stuF);
        Student stuJ = new Student("10007","弗兰奇");
        stuList.add(stuJ);
        Student stuH = new Student("10006","乌索普--2号");
        stuList.add(stuH);
        Student stuK = new Student("10008","乔巴");
        stuList.add(stuK);
        Student stuI = new Student("10006","乌索普--3号");
        stuList.add(stuI);
        Student stuM = new Student("10006","乌索普--4号");
        stuList.add(stuM);
        Student stuL = new Student("10009","布鲁克");
        stuList.add(stuL);
        return stuList;
    }

    /**
     * 普通遍历方法 正序 删除预期数据
     * 这种方法存在bug:删除元素时涉及到数组元素的移动,遍历下标n的元素。
     * 当前元素符合条件，执行删除操作，当前n位置的元素被删除，n+1位置的元素，移动到n位置上。
     * 搜索光标却还是n，并未n-1，下次循环搜索时，会从下标n+1开始检索。
     * 此时n+1位置的元素，原本是n+2的元素，那么此次循环遍历检索就会遗漏n+1位置的元素检查。
     * 倘若n+1位置的元素符合删除条件，那么程序就将出现bug。
     * 因为建议多用iterator进行遍历删除，如果非得使用普通循环遍历方法删除元素，请采用倒序的办法，详见ordinaryDesc
     * @param stuList
     */
    public static void ordinaryDelAsc(List<Student> stuList){
        for(int i= 0;i< stuList.size();i++){
            Student stuShow = stuList.get(i);
            if(stuShow.getStuId().equals("10006")){
                stuList.remove(stuShow);
            }
        }
        System.out.println(listToString(stuList));
    }
    /**
     * 普通遍历方法 倒序 删除预期数据
     * @param stuList
     */
    public static void ordinaryDelDesc(List<Student> stuList){
        for(int i= stuList.size()-1;i>0 ;i--){
            Student stuShow = stuList.get(i);
            if(stuShow.getStuId().equals("10006")){
                stuList.remove(stuShow);
            }
        }
        System.out.println(listToString(stuList));
    }

    /**
     * 增强for循环遍历删除预期数据
     * @param stuList
     */
    public static void heighten(List<Student> stuList){
        for (Student stu:stuList){
            if(stu.getStuId().equals("10006")){
                stuList.remove(stu);
            }
        }
        System.out.println(listToString(stuList));
    }

    /**
     * Iterator 循环遍历删除预期数据
     * @param stuList
     * @return
     */
    public static void iteratorDel(List<Student> stuList){
        Iterator<Student> iterator = stuList.iterator();
        while (iterator.hasNext()){
            Student stuShow = iterator.next();
            if(stuShow.getStuId().equals("10006")){
                iterator.remove();
            }
        }
        System.out.println(listToString(stuList));
    }

    private static String listToString(List<Student> list){
        StringBuilder sb = new StringBuilder("");
        for (Student s:list){
            sb.append("[stuId:"+s.getStuId()+"---name:"+s.getName()+"] 
");
        }
        return sb.toString();
    }


}

class Student{

    public Student(String stuId,String name){
        this.stuId =stuId;
        this.name = name;
    }

    private String stuId;

    private String name;

    public void setStuId(String stuId){
        this.stuId = stuId;
    }

    public String getStuId(){
        return  this.stuId;
    }

    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return this.name;
    }
}