java集合遍历的几种方式总结及详细比较

集合类的通用遍历方式, 用迭代器迭代:

Iterator it = list.iterator();
while(it.hasNext()) {
  Object obj = it.next();
}

Map遍历方式:

1、通过获取所有的key按照key来遍历

//Set<Integer> set = map.keySet(); //得到所有key的集合
for (Integer in : map.keySet()) {
  String str = map.get(in);//得到每个key多对用value的值
}

2、通过Map.entrySet使用iterator遍历key和value

Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();
while (it.hasNext()) {
   Map.Entry<Integer, String> entry = it.next();
    System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}

3、通过Map.entrySet遍历key和value,推荐,尤其是容量大时

for (Map.Entry<Integer, String> entry : map.entrySet()) {
  //Map.entry<Integer,String> 映射项(键-值对) 有几个方法:用上面的名字entry
  //entry.getKey() ;entry.getValue(); entry.setValue();
  //map.entrySet() 返回此映射中包含的映射关系的 Set视图。
  System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}

4、通过Map.values()遍历所有的value,但不能遍历key

for (String v : map.values()) {
  System.out.println("value= " + v);
}

List遍历方式:

第一种:

for(Iterator iterator = list.iterator();iterator.hasNext();){
  int i = (Integer) iterator.next();
  System.out.println(i);
}

第二种:

Iterator iterator = list.iterator();
while(iterator.hasNext()){
  int i = (Integer) iterator.next();
  System.out.println(i);
}

第三种:

for (Object object : list) {
  System.out.println(object);
}

第四种:

for(int i = 0 ;i<list.size();i++) {
  int j= (Integer) list.get(i);
  System.out.println(j);
}

数据元素是怎样在内存中存放的?

主要有2种存储方式:

1、顺序存储,Random Access(Direct Access):

这种方式,相邻的数据元素存放于相邻的内存地址中,整块内存地址是连续的。可以根据元素的位置直接计算出内存地址,直接进行读取。读取一个特定位置元素的平均时间复杂度为O(1)。正常来说,只有基于数组实现的集合,才有这种特性。Java中以ArrayList为代表。

2、链式存储,Sequential Access:

这种方式,每一个数据元素,在内存中都不要求处于相邻的位置,每个数据元素包含它下一个元素的内存地址。不可以根据元素的位置直接计算出内存地址,只能按顺序读取元素。读取一个特定位置元素的平均时间复杂度为O(n)。主要以链表为代表。Java中以LinkedList为代表。

每个遍历方法的实现原理是什么?

1、传统的for循环遍历,基于计数器的:

遍历者自己在集合外部维护一个计数器,然后依次读取每一个位置的元素,当读取到最后一个元素后,停止。主要就是需要按元素的位置来读取元素。

2、迭代器遍历,Iterator:

每一个具体实现的数据集合,一般都需要提供相应的Iterator。相比于传统for循环,Iterator取缔了显式的遍历计数器。所以基于顺序存储集合的Iterator可以直接按位置访问数据。而基于链式存储集合的Iterator,正常的实现,都是需要保存当前遍历的位置。然后根据当前位置来向前或者向后移动指针。

3、foreach循环遍历:

根据反编译的字节码可以发现,foreach内部也是采用了Iterator的方式实现,只不过Java编译器帮我们生成了这些代码。

各遍历方式对于不同的存储方式,性能如何?

1、传统的for循环遍历,基于计数器的:

因为是基于元素的位置,按位置读取。所以我们可以知道,对于顺序存储,因为读取特定位置元素的平均时间复杂度是O(1),所以遍历整个集合的平均时间复杂度为O(n)。而对于链式存储,因为读取特定位置元素的平均时间复杂度是O(n),所以遍历整个集合的平均时间复杂度为O(n2)(n的平方)。

ArrayList按位置读取的代码:直接按元素位置读取。

transient Object[] elementData;

public E get(int index) {
  rangeCheck(index);
  return elementData(index);
}

E elementData(int index) {
  return (E) elementData[index];
}

LinkedList按位置读取的代码:每次都需要从第0个元素开始向后读取。其实它内部也做了小小的优化。

transient int size = 0;
transient Node<E> first;
transient Node<E> last;

public E get(int index) {
  checkElementIndex(index);
  return node(index).item;
}

Node<E> node(int index) {
  if (index < (size >> 1)) {  //查询位置在链表前半部分,从链表头开始查找
    Node<E> x = first;
    for (int i = 0; i < index; i++)
      x = x.next;
    return x;
  } else {           //查询位置在链表后半部分,从链表尾开始查找
    Node<E> x = last;
    for (int i = size - 1; i > index; i--)
      x = x.prev;
    return x;
  }
}

2、迭代器遍历,Iterator:

那么对于RandomAccess类型的集合来说,没有太多意义,反而因为一些额外的操作,还会增加额外的运行时间。但是对于Sequential Access的集合来说,就有很重大的意义了,因为Iterator内部维护了当前遍历的位置,所以每次遍历,读取下一个位置并不需要从集合的第一个元素开始查找,只要把指针向后移一位就行了,这样一来,遍历整个集合的时间复杂度就降低为O(n);
(这里只用LinkedList做例子)LinkedList的迭代器,内部实现,就是维护当前遍历的位置,然后操作指针移动就可以了:

代码:

public E next() {
  checkForComodification();
  if (!hasNext())
    throw new NoSuchElementException();

  lastReturned = next;
  next = next.next;
  nextIndex++;
  return lastReturned.item;
}

public E previous() {
  checkForComodification();
  if (!hasPrevious())
    throw new NoSuchElementException();

  lastReturned = next = (next == null) ? last : next.prev;
  nextIndex--;
  return lastReturned.item;
}

3、foreach循环遍历:

分析Java字节码可知,foreach内部实现原理,也是通过Iterator实现的,只不过这个Iterator是Java编译器帮我们生成的,所以我们不需要再手动去编写。但是因为每次都要做类型转换检查,所以花费的时间比Iterator略长。时间复杂度和Iterator一样。

Iterator和foreach字节码如下:

//使用Iterator的字节码:
  Code:
    0: new      #16         // class java/util/ArrayList
    3: dup
    4: invokespecial #18         // Method java/util/ArrayList."<init>":()V
    7: astore_1
    8: aload_1
    9: invokeinterface #19, 1      // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;
   14: astore_2
   15: goto     25
   18: aload_2
   19: invokeinterface #25, 1      // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
   24: pop
   25: aload_2
   26: invokeinterface #31, 1      // InterfaceMethod java/util/Iterator.hasNext:()Z
   31: ifne     18
   34: return

//使用foreach的字节码:
  Code:
    0: new      #16         // class java/util/ArrayList
    3: dup
    4: invokespecial #18         // Method java/util/ArrayList."<init>":()V
    7: astore_1
    8: aload_1
    9: invokeinterface #19, 1      // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;
   14: astore_3
   15: goto     28
   18: aload_3
   19: invokeinterface #25, 1      // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
   24: checkcast   #31         // class loop/Model
   27: astore_2
   28: aload_3
   29: invokeinterface #33, 1      // InterfaceMethod java/util/Iterator.hasNext:()Z
   34: ifne     18
   37: return

各遍历方式的适用于什么场合?

1、传统的for循环遍历,基于计数器的:

顺序存储:读取性能比较高。适用于遍历顺序存储集合。

链式存储:时间复杂度太大,不适用于遍历链式存储的集合。

2、迭代器遍历,Iterator:

顺序存储:如果不是太在意时间,推荐选择此方式,毕竟代码更加简洁,也防止了Off-By-One的问题。

链式存储:意义就重大了,平均时间复杂度降为O(n),还是挺诱人的,所以推荐此种遍历方式。

3、foreach循环遍历:

foreach只是让代码更加简洁了,但是他有一些缺点,就是遍历过程中不能操作数据集合(删除等),所以有些场合不使用。而且它本身就是基于Iterator实现的,但是由于类型转换的问题,所以会比直接使用Iterator慢一点,但是还好,时间复杂度都是一样的。所以怎么选择,参考上面两种方式,做一个折中的选择。

Java的最佳实践是什么?

Java数据集合框架中,提供了一个RandomAccess接口,该接口没有方法,只是一个标记。通常被List接口的实现使用,用来标记该List的实现是否支持Random Access。

一个数据集合实现了该接口,就意味着它支持Random Access,按位置读取元素的平均时间复杂度为O(1)。比如ArrayList。

而没有实现该接口的,就表示不支持Random Access。比如LinkedList。

所以看来JDK开发者也是注意到这个问题的,那么推荐的做法就是,如果想要遍历一个List,那么先判断是否支持Random Access,也就是 list instanceof RandomAccess。

比如:

if (list instanceof RandomAccess) {
  //使用传统的for循环遍历。
} else {
  //使用Iterator或者foreach。
}

以上这篇java集合遍历的几种方式总结及详细比较就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • Lua中遍历数组和table的4种方法

    方法一,可以用for来遍历: 复制代码 代码如下: do      table_week = {      "w",      "e",      "r",      "t",      "y",      "u",      "i",      }        for i = 1, #table_week do          print(table_week[

  • list的4种遍历方式(实例讲解)

    废话不多说,直接上代码: import java.util.ArrayList; import java.util.Iterator; import java.util.List; import com.hbut.domain.Person; public class TestList { /** * * List 代表一个元素有序.且可重复的集合,集合中的每个元素都有其对应的顺序索引 * List 允许使用重复元素,可以通过索引来访问指定位置的集合元素. * List 默认按元素的添加顺序设置

  • java中List集合及其遍历详解

    1. 首先List<E>集合继承与Collection<E>,是一个接口. ①  Collection (集合框架是JDK1.2版本出现的) ②   list:是有序的,元素可以重复,以为该集合体系有索引.    经常用到的是实现该接口的ArrayList和LinkedList类 ③   Arraylist:  底层的数据结构使用的是数组结构, 特点: 查询速度很快,但是增删稍慢.线程不同步 LinkedList: 底层使用的是链表数据结构. 特点: 增删速度很快,查询稍慢. Ve

  • Java中四种遍历List的方法总结(推荐)

    实例如下: package com.ietree.basic.collection.loop; import java.util.ArrayList; import java.util.Iterator; import java.util.List; /** * List遍历 * * @author Dylan */ public class ListLoop { public static void main(String[] args) { // 初始化一个长度为10的ArrayList L

  • java集合遍历的几种方式总结及详细比较

    集合类的通用遍历方式, 用迭代器迭代: Iterator it = list.iterator(); while(it.hasNext()) { Object obj = it.next(); } Map遍历方式: 1.通过获取所有的key按照key来遍历 //Set<Integer> set = map.keySet(); //得到所有key的集合 for (Integer in : map.keySet()) { String str = map.get(in);//得到每个key多对用v

  • Java实现Map集合遍历的四种常见方式与用法分析

    本文实例讲述了Java实现Map集合遍历的四种常见方式与用法.分享给大家供大家参考,具体如下: ~Map集合是键值对形式存储值的,所以遍历Map集合无非就是获取键和值,根据实际需求,进行获取键和值 1. 无非就是通过map.keySet()获取到值,然后根据键获取到值 for(String s:map.keySet()){ System.out.println("key : "+s+" value : "+map.get(s)); } 2. 通过Map.Entry(

  • Java sort集合排序的两种方式解析

    这篇文章主要介绍了Java sort集合排序的两种方式解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 Comparable和Comparator public static <T> void sort(List<T> list); 将集合中的数据按照默认规则进行排序 (我们在自己的类里面实现Comparabl接口方法compareTo) public static <T> void sort(List<T&g

  • Java遍历Map四种方式讲解

    Java中遍历Map的四种方式 在java中所有的map都实现了Map接口,因此所有的Map(如HashMap, TreeMap, LinkedHashMap, Hashtable等)都可以用以下的方式去遍历. 方法一:在for循环中使用entries实现Map的遍历: /** * 最常见也是大多数情况下用的最多的,一般在键值对都需要使用 */ Map <String,String>map = new HashMap<String,String>(); map.put("

  • Java 切割字符串的几种方式集合

    目录 Java 切割字符串的几种方式 1.StringTokenizer切割 2...split("*")分割 3.调用String自己的api subString() java优雅的切割字符串 切割字符串 使用方法 Java 切割字符串的几种方式 //以data 为案例参数. String data = "2019-01-08 21:55 136 \n2019-01-08 22:00 86 \n2019-01-08 22:04 136 \n2019-01-08 22:09

  • java arrayList遍历的四种方法及Java中ArrayList类的用法

    java arrayList遍历的四种方法及Java中ArrayList类的用法 package com.test; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class ArrayListDemo { public static void main(String args[]){ List<String> list = new ArrayList<String

  • Java线程创建的四种方式总结

    多线程的创建,方式一:继承于Thread类 1.创建一个继承于Thread类的子类 2.重写Thread类的run()--->将此线程执行的操作声明在run()中 3.创建Thread类的子类的对象 4.通过此对象调用start(): start()方法的两个作用: A.启动当前线程 B.调用当前线程的run() 创建过程中的两个问题: 问题一:我们不能通过直接调用run()的方式启动线程 问题二:在启动一个线程,遍历偶数,不可以让已经start()的线程去执行,会报异常:正确的方式是重新创建一

  • Java解析XML(4种方式)案例详解

    目录 1.DOM方式 2.SAX方式 3.JDOM方式 4.DOM4J方式 总结 xml文件 <?xml version="1.0" encoding="utf-8" ?> <class> <student> <firstname>cxx1</firstname> <lastname>Bob1</lastname> <nickname>stars1</nicknam

  • Java解析XML的四种方式

    xml文件 <?xml version="1.0" encoding="utf-8" ?> <class> <student> <firstname>cxx1</firstname> <lastname>Bob1</lastname> <nickname>stars1</nickname> <marks>85</marks> </

  • python df遍历的N种方式(小结)

    目录 for…in 迭代循环 iterrows()生成器方式 apply()循环方式 矢量化遍历方式 总结 for…in 迭代循环 首先介绍Python中最常用的for…in循环遍历的方式.for…in循环结构用于遍历列表.元组.字典.字符串.集合.文件等.其实for和in是两个独立的语法,for语句是Python内置的迭代器工具,用于从可迭代容器对象(如列表.元组.字典.字符串.集合.文件等)中逐个读取元素,直到容器中没有更多元素为止,工具和对象之间只要遵循可迭代协议即可进行迭代操作.in的存

随机推荐