List的遍历 Java

一、对List的遍历有三种方式   
    
   List<String>    list    =    new    ArrayList<String>();   
   list.add("testone");   
   list.add(“testtwo”);   
   ...   
    
   第一种:   
   for(Iterator<String>    it    =    list.iterator();    it.hasNext();    )    {   
       ....   
   }   
   这种方式在循环执行过程中会进行数据锁定,    性能稍差,    同时,如果你想在寻欢过程中去掉某个元素,只能调用it.remove方法,    不能使用list.remove方法,    否则一定出现并发访问的错误.

第二种:   
   for(String   data    :    list)    {   
       .....   
   }   
   内部调用第一种,    换汤不换药,  因此比Iterator 慢,这种循环方式还有其他限制, 不建议使用它。
    
   第三种:   
   for(int    i=0;    i<list.size();    i++)    {   
       A    a    =    list.get(i);   
       ...   
   }   
   内部不锁定,    效率最高,    但是当写多线程时要考虑并发操作的问题。

二、测试实例
package com.inspur.Test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

/**
 *@author WHD
 *2015-3-5
 */
@SuppressWarnings("unused")
public class MapTest {
    private static List<String> list= new ArrayList<String>();
    public static void main(String[]args){
        MapTest  mapTest = new  MapTest();
        mapTest.initList(list);
        mapTest.foreach(list);
        mapTest.forlist(list);
        mapTest.iteratorList(list);
    }
    
    //list 集合中添加10万条数据
    public List initList(List<String> list){
        int i=0;
        int num=6000000;
        for(i=0;i<num;i++){
            list.add("list"+i);
        }
        return list;
    }
    //list 集合遍历 foreach
    
    public void  foreach(List<String> list){
        long start= System.currentTimeMillis();
        for(String data:list){
            String value=data;
        }
        
        long end=System.currentTimeMillis();
        long count=end-start;
        System.out.println("foreach 循环时间"+count);
    }
    // list集合遍历  for
    public void forlist(List<String> list){
        long start=System.currentTimeMillis();
        int i=0;
        for( i=0;i<list.size();i++){
            String value=list.get(i);
        }
        long end=System.currentTimeMillis();
        long count=end-start;
        System.out.println("for list.size() 遍历时间"+count);
    }
    
    // Iterator 遍历循环
    public void iteratorList(List<String> list){
        long start= System.currentTimeMillis();
        for(Iterator<String>  it=list.iterator();it.hasNext();){
            String value=it.next();
        }
        long end=System.currentTimeMillis();
        long count=end-start;
        System.out.println("iterator 遍历时间"+count);
    }

}

三、测试结果:
(1)、第一次
foreach  遍历时间:55
for list.size()遍历时间:47
iterator 遍历时间:51
(2)、第二次
foreach  遍历时间:54
for list.size()遍历时间:44
iterator 遍历时间:50
(3)、第三次
foreach  遍历时间:48
for list.size()遍历时间:43
iterator 遍历时间:44
从测试的结果我们可以明显的看到效率了!

时间: 2024-10-07 12:08:17

List的遍历 Java的相关文章

非递归实现先序遍历 java leecode 提交

写完才知道自己学习都是似是而非啊,大家可以也在leecode上提交代码,纯手写,离开eclipse第一种方式:数据结构书上的,使用栈大概思路.1.不断将根节点的左孩子的左孩子直到为空,在这个过程入栈.2.因为栈顶的节点的左孩子为空,所以栈顶的的节点的左子树肯定访问完毕,所以出栈后直接指向右孩子.其实这里面有个思想迭代和递归的本质相同之处是什么?以后会写一篇我的思考. public class Solution { public List<Integer> preorderTraversal(T

后续遍历 java leecode

以前觉得后续遍历最难写,今天看了篇博客http://blog.csdn.net/sgbfblog/article/details/7773103,其实却是我们仔细比较后续遍历和先序遍历,其实后续遍历就是按照  根右左 的方式先序访问然后逆序就是答案了,会先序就会逆序了 leecode 的AC代码: public class Solution { public List<Integer> postorderTraversal(TreeNode root) { ArrayList<Integ

高效遍历Java容器

通过本文,你可以更深入的学习 Java 语言中 forEach 语法的知识,以及它和 C 语言形式的 for 循环. Steam API 的对比.简介Java 程序员经常使用容器,比如 ArrayList 和 HashSet.Java 8 中的 lambda 语法和 steaming API 可以让我们更方便的使用容器.大部分情况下,我们仅仅处理几千个元素,也不会去考虑性能问题.但是,在一些极端场景下,如果我们需要遍历上百万个元素,性能问题就凸显出来了.本文将采用 JMH 计算每块代码的运行时间

邻接矩阵的深度优先遍历(java版)

这是一个有向边带权的图 顶点数组:[v0, v1, v2, v3, v4] 边数组: v0 v1 v2 v3 v4 v0 6 v1 9 3 v2 2 5 v3 1 v4 package com.datastruct; import java.util.Scanner; public class MGraph { //定义图结构,使用邻接矩阵存储 private static class Graph{ final int MAXVEX = 10;//最大顶点数 final int INFINITY

二叉树遍历-JAVA实现

二叉树遍历分为前序.中序.后序递归和非递归遍历.还有层序遍历. 1 //二叉树节点 2 public class BinaryTreeNode { 3 private int data; 4 private BinaryTreeNode left; 5 private BinaryTreeNode right; 6 7 public BinaryTreeNode() {} 8 9 public BinaryTreeNode(int data, BinaryTreeNode left, Binar

LeetCode103 BinaryTreeZigzagLevelOrderTraversal(二叉树Z形层次遍历) Java题解

题目: Given a binary tree, return the zigzag level order traversal of its nodes' values. (ie, from left to right, then right to left for the next level and alternate between). For example: Given binary tree {3,9,20,#,#,15,7}, 3 / 9 20 / 15 7 return its

Freemarker遍历Java的Map

废话不说,看代码: Java Map<String, String> selectMap = new TreeMap<String, String>(); selectMap.put("platId", "平台ID"); selectMap.put("crawlerId", "爬虫ID"); request.setAttribute("selectMap", selectMap);

二叉树遍历Java实现

[仅贴代码及测试结果] -------------------BinaryTree.java------------------------------ class Tree<E>{ E element; Tree<E> lChild; Tree<E> rChild; public Tree(E e){ element = e; } } public class BinaryTree { /** * 树形如下: * 1 * / * 2 3 * \ / * 4 5 6 *

xposed 遍历java类和所有属性函数写法

package com.xiaojianbang.xposed; import android.util.Log; import de.robv.android.xposed.IXposedHookLoadPackage; import de.robv.android.xposed.XposedHelpers; import de.robv.android.xposed.callbacks.XC_LoadPackage.LoadPackageParam; import java.lang.ref