map是键值对的集合接口,它的实现类主要包括:HashMap,TreeMap,Hashtable以及LinkedHashMap等。其中这四者的区别如下(简单介绍):

HashMap:我们最常用的Map,它根据key的HashCode 值来存储数据,根据key可以直接获取它的Value,同时它具有很快的访问速度。HashMap最多只允许一条记录的key值为Null(多条会覆盖);允许多条记录的Value为 Null。非同步的。

TreeMap: 能够把它保存的记录根据key排序,默认是按升序排序,也可以指定排序的比较器,当用Iterator 遍历TreeMap时,得到的记录是排过序的。TreeMap不允许key的值为null。非同步的。

Hashtable: 与 HashMap类似,不同的是:key和value的值均不允许为null;它支持线程的同步,即任一时刻只有一个线程能写Hashtable,因此也导致了Hashtale在写入时会比较慢。

LinkedHashMap: 保存了记录的插入顺序,在用Iterator遍历LinkedHashMap时,先得到的记录肯定是先插入的.在遍历的时候会比HashMap慢。key和value均允许为空,非同步的。

第1章 List接口

看List的介绍。有序的 collection(也称为序列)。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引(在列表中的位置)访问元素,并搜索列表中的元素。与 set 不同,列表通常允许重复的元素。

List接口:

l 它是一个元素存取有序的集合。例如,存元素的顺序是11、22、33。那么集合中,元素的存储就是按照11、22、33的顺序完成的)。

l 它是一个带有索引的集合,通过索引就可以精确的操作集合中的元素(与数组的索引是一个道理)。

l 集合中可以有重复的元素,通过元素的equals方法,来比较是否为重复的元素。

在迭代过程中,使用了集合的方法对元素进行操作。导致迭代器并不知道集合中的变化,容易引发数据的不确定性。

并发修改异常解决办法:在迭代时,不要使用集合的方法操作元素。

那么想要在迭代时对元素操作咋办?通过ListIterator迭代器操作元素是可以的,ListIterator的出现,解决了使用Iterator迭代过程中可能会发生的错误情况。

集合在迭代过程中能否添加、删除或修改元素

2017年06月29日 01:41:44 小明的代码世界 阅读数:3647
 
 版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/cmder1000/article/details/73865815

//方法一:迭代器迭代元素,迭代器修改元素
//由于Iterator迭代器没有添加功能,所以使用其子类ListIterator
// ListIterator lit = list.listIterator();
// while(lit.hasNext()) {
// String s = (String)lit.next();
// if ("music".equals(s)) {
// lit.add("hhaha");
// }
// }
// System.out.println("list:"+list);

1.使用 for 循环

List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.size());
if ("1".equals(list.get(i))){
list.add("4");
list.remove("1");
}
}

2.使用 foreach 遍历

List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
for (String s : list){
if ("1".equals(s)){
list.add("4");
list.remove("1");
}
}

3.使用 Iterator 迭代器

List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
if ("1".equals(iterator.next())) {
iterator.remove();
list.add("4");
list.remove("1");
}
}
  • 1

在第一种情况下编译和运行都是可以的,第二种和第三种则会抛出 java.util.ConcurrentModificationException 的异常,这是为什么呢? 
下面一段是来自百度知道的解释: 
逻辑上讲,迭代时可以添加元素,但是一旦开放这个功能,很有可能造成很多意想不到的情况。 
比如你在迭代一个 ArrayList,迭代器的工作方式是依次返回给你第0个元素,第1个元素,等等,假设当你迭代到第5个元素的时候,你突然在ArrayList的头部插入了一个元素,使得你所有的元素都往后移动,于是你当前访问的第5个元素就会被重复访问。 
java 认为在迭代过程中,容器应当保持不变。因此,java 容器中通常保留了一个域称为 modCount,每次你对容器修改,这个值就会加1。当你调用 iterator 方法时,返回的迭代器会记住当前的 modCount,随后迭代过程中会检查这个值,一旦发现这个值发生变化,就说明你对容器做了修改,就会抛异常。 
我们先看第三种情况,即使用 Iterator 迭代器对集合进行遍历,我们以 AbstractList 为例。 
首先来看一下AbstractList是如何创建Iterator的,AbstractList有一个内部类:

private class Itr implements Iterator<E> {
...
}
  • 1
  • 2
  • 3

而创建Iterator需要调用iterator()方法:

public Iterator<E> iterator() {
return new Itr();
}

1

  • 2
  • 3

所以在调用集合的iterator方法之后实际上返回了一个内部类的实例。 
我们看一下Itr这个类的next()方法是如何实现的:

public E next() {
checkForComodification();
try {
int i = cursor;
E next = get(i);
lastRet = i;
cursor = i + 1;
return next;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}

checkForComodification()方法的实现如下:

final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}

modCount表示集合的元素被修改的次数,每次增加或删除一个元素的时候,modCount都会加一,而expectedModCount用于记录在集合遍历之前的modCount,检查这两者是否相等就是为了检查集合在迭代遍历的过程中有没有被修改,如果被修改了,就会在运行时抛出ConcurrentModificationException这个RuntimeException,以提醒开发者集合已经被修改。 
这就说明了为什么集合在使用Iterator进行遍历的时候不能使用集合本身的add或者remove方法来增减元素。但是使用Iterator的remove方法是可以的,至于原因可以看一下这个方法的实现:

public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification(); try {
AbstractList.this.remove(lastRet);
if (lastRet < cursor)
cursor--;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}

可以看到,在集合的元素被remove之后,expectedModCount被重新赋值,是的modCount总是等于expectedModCount,所以不会抛出ConcurrentModificationException异常。

而上面提到的第二种使用foreach来对集合进行遍历本质上和第三种情况是一样的,因为根据Oracle提供的文档,foreach内部的实现机制其实就是使用的Iterator。

第一种使用for循环进行遍历时内部使用的就是集合本身的遍历方法,这里不做讨论。

List集合存储数据的结构

List接口下有很多个集合,它们存储元素所采用的结构方式是不同的,这样就导致了这些集合有它们各自的特点,供给我们在不同的环境下进行使用。数据存储的常用结构有:堆栈、队列、数组、链表。我们分别来了解一下:

l 堆栈,采用该结构的集合,对元素的存取有如下的特点:

l 先进后出(即,存进去的元素,要在后它后面的元素依次取出后,才能取出该元素)。例如,子弹压进弹夹,先压进去的子弹在下面,后压进去的子弹在上面,当开枪时,先弹出上面的子弹,然后才能弹出下面的子弹。

l 栈的入口、出口的都是栈的顶端位置

l 压栈:就是存元素。即,把元素存储到栈的顶端位置,栈中已有元素依次向栈底方向移动一个位置。

l 弹栈:就是取元素。即,把栈的顶端位置元素取出,栈中已有元素依次向栈顶方向移动一个位置。

l 队列,采用该结构的集合,对元素的存取有如下的特点:

l 先进先出(即,存进去的元素,要在后它前面的元素依次取出后,才能取出该元素)。例如,安检。排成一列,每个人依次检查,只有前面的人全部检查完毕后,才能排到当前的人进行检查。

l 队列的入口、出口各占一侧。例如,下图中的左侧为入口,右侧为出口。

l 数组,采用该结构的集合,对元素的存取有如下的特点:

l 查找元素快:通过索引,可以快速访问指定位置的元素

l 增删元素慢:

指定索引位置增加元素:需要创建一个新数组,将指定新元素存储在指定索引位置,再把原数组元素根据索引,复制到新数组对应索引的位置。如下图

指定索引位置删除元素:需要创建一个新数组,把原数组元素根据索引,复制到新数组对应索引的位置,原数组中指定索引位置元素不复制到新数组中。如下图

l 链表,采用该结构的集合,对元素的存取有如下的特点:

l 多个节点之间,通过地址进行连接。例如,多个人手拉手,每个人使用自己的右手拉住下个人的左手,依次类推,这样多个人就连在一起了。

l 查找元素慢:想查找某个元素,需要通过连接的节点,依次向后查找指定元素

l 增删元素快:

l 增加元素:操作如左图,只需要修改连接下个元素的地址即可。

l 删除元素:操作如右图,只需要修改连接下个元素的地址即可。

1.4 ArrayList集合

ArrayList集合数据存储的结构是数组结构。元素增删慢,查找快,由于日常开发中使用最多的功能为查询数据、遍历数据,所以ArrayList是最常用的集合。

1.5 LinkedList集合

LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。实际开发中对一个集合元素的添加与删除经常涉及到首尾操作,而LinkedList提供了大量首尾操作的方法。如下图

LinkedList是List的子类,List中的方法LinkedList都是可以使用,这里就不做详细介绍,我们只需要了解LinkedList的特有方法即可。在开发时,LinkedList集合也可以作为堆栈,队列的结构使用。

方法演示:

LinkedList<String> link = new LinkedList<String>();

//添加元素

link.addFirst("abc1");

link.addFirst("abc2");

link.addFirst("abc3");

//获取元素

System.out.println(link.getFirst());

System.out.println(link.getLast());

//删除元素

System.out.println(link.removeFirst());

System.out.println(link.removeLast());

while(!link.isEmpty()){ //判断集合是否为空

System.out.println(link.pop()); //弹出集合中的栈顶元素

}

第2章 Set接口

学习Collection接口时,记得Collection中可以存放重复元素,也可以不存放重复元素,那么我们知道List中是可以存放重复元素的。那么不重复元素给哪里存放呢?那就是Set接口,它里面的集合,所存储的元素就是不重复的。

2.2 HashSet集合介绍

查阅HashSet集合的API介绍:此类实现Set接口,由哈希表支持(实际上是一个 HashMap集合)。HashSet集合不能保证的迭代顺序与元素存储顺序相同。

HashSet集合,采用哈希表结构存储数据,保证元素唯一性的方式依赖于:hashCode()与equals()方法。

2.3 HashSet集合存储数据的结构(哈希表)

什么是哈希表呢?

哈希表底层使用的也是数组机制,数组中也存放对象,而这些对象往数组中存放时的位置比较特殊,当需要把这些对象给数组中存放时,那么会根据这些对象的特有数据结合相应的算法,计算出这个对象在数组中的位置,然后把这个对象存放在数组中。而这样的数组就称为哈希数组,即就是哈希表。

当向哈希表中存放元素时,需要根据元素的特有数据结合相应的算法,这个算法其实就是Object类中的hashCode方法。由于任何对象都是Object类的子类,所以任何对象有拥有这个方法。即就是在给哈希表中存放对象时,会调用对象的hashCode方法,算出对象在表中的存放位置,这里需要注意,如果两个对象hashCode方法算出结果一样,这样现象称为哈希冲突,这时会调用对象的equals方法,比较这两个对象是不是同一个对象,如果equals方法返回的是true,那么就不会把第二个对象存放在哈希表中,如果返回的是false,就会把这个值存放在哈希表中。

总结:保证HashSet集合元素的唯一,其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象,那么保证其唯一,就必须复写hashCode和equals方法建立属于当前对象的比较方式。

2.4 HashSet存储JavaAPI中的类型元素

给HashSet中存储JavaAPI中提供的类型元素时,不需要重写元素的hashCode和equals方法,因为这两个方法,在JavaAPI的每个类中已经重写完毕,如String类、Integer类等。

2.5 HashSet存储自定义类型元素

给HashSet中存放自定义类型元素时,需要重写对象中的hashCode和equals方法,建立自己的比较方式,才能保证HashSet集合中的对象唯一

l 创建自定义对象Student

public class Student {

private String name;

private int age;

public Student(String name, int age) {

super();

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

@Override

public String toString() {

return "Student [name=" + name + ", age=" + age + "]";

}

@Override

public int hashCode() {

final int prime = 31;

int result = 1;

result = prime * result + age;

result = prime * result + ((name == null) ? 0 : name.hashCode());

return result;

}

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if(!(obj instanceof Student)){

System.out.println("类型错误");

return false;

}

Student other = (Student) obj;

return this.age ==  other.age && this.name.equals(other.name);

}

}

2.6 LinkedHashSet介绍

我们知道HashSet保证元素唯一,可是元素存放进去是没有顺序的,那么我们要保证有序,怎么办呢?

在HashSet下面有一个子类LinkedHashSet,它是链表和哈希表组合的一个数据存储结构。

第3章 判断集合元素唯一的原理

3.1 ArrayList的contains方法判断元素是否重复原理

ArrayList的contains方法会使用调用方法时,传入的元素的equals方法依次与集合中的旧元素所比较,从而根据返回的布尔值判断是否有重复元素。此时,当ArrayList存放自定义类型时,由于自定义类型在未重写equals方法前,判断是否重复的依据是地址值,所以如果想根据内容判断是否为重复元素,需要重写元素的equals方法。

3.2 HashSet的add/contains等方法判断元素是否重复原理

Set集合不能存放重复元素,其添加方法在添加时会判断是否有重复元素,有重复不添加,没重复则添加。

HashSet集合由于是无序的,其判断唯一的依据是元素类型的hashCode与equals方法的返回结果。规则如下:

先判断新元素与集合内已经有的旧元素的HashCode值

l 如果不同,说明是不同元素,添加到集合。

l 如果相同,再判断equals比较结果。返回true则相同元素;返回false则不同元素,添加到集合。

所以,使用HashSet存储自定义类型,如果没有重写该类的hashCode与equals方法,则判断重复时,使用的是地址值,如果想通过内容比较元素是否相同,需要重写该元素类的hashcode与equals方法。

第4章 总结

4.1 知识点总结

l List与Set集合的区别?

List:

它是一个有序的集合(元素存与取的顺序相同)

它可以存储重复的元素

Set:

它是一个无序的集合(元素存与取的顺序可能不同)

它不能存储重复的元素

l List集合中的特有方法

l void add(int index, Object element) 将指定的元素,添加到该集合中的指定位置上

l Object get(int index)返回集合中指定位置的元素。

l Object remove(int index) 移除列表中指定位置的元素, 返回的是被移除的元素

l Object set(int index, Object element)用指定元素替换集合中指定位置的元素,返回值的更新前的元素

l ArrayList:

底层数据结构是数组,查询快,增删慢

l LinkedList:

底层数据结构是链表,查询慢,增删快

l HashSet:

元素唯一,不能重复

底层结构是 哈希表结构

元素的存与取的顺序不能保证一致

如何保证元素的唯一的?

重写hashCode() 与 equals()方法

l LinkedHashSet:

元素唯一不能重复

底层结构是 哈希表结构 + 链表结构

元素的存与取的顺序一致

List特点:有序,元素都有索引,允许重复
ArrayList:底层是数组(动态数组,新增时数组不够会动态扩容),线程不同步
通过下标索引直接查找到指定位置的元素,因此查找、修改效率高,但每次插入或删除元素,就要大量地移动元素,因此插入删除元素的效率低。

LinkedList:底层是链表(其实就是一个双向循环链表),线程不同步,增删快,查询效率低

Queue:队列,先进先出,底层单向链表或数组

Stack:栈,后进先出, 底层单向链表或数组
操作有:建栈(建立空栈)、入栈、出栈、取栈顶元素

Set特点:只能通过迭代器Iterator取出
HashSet:底层是哈希表,线程不安全,无序,高效,元素唯一

LinkedHashSet:有序
TreeSet:底层是二叉树,有序,线程不安全

Map特点:Map一次存一对元素
Hashtable:底层是哈希表,线程安全(synchronized),键和值均不可为null

HashMap:底层是数组+链表(key-value保存在一个Entry中,Entry为单向链表结构,通过key算出hash值,hash值即数组下标可得Entry,如果Entry这个链表不止一个则遍历这个链表),使用哈希算法,线程不安全,键值可为null;多线程可使用ConcurrentHashMap 线程安全的
性能影响因素:初始容量(即HashMap数组的初始化容量大小)和加载因子(用以判断HashMap是否扩容,当前数组大小 >= 当前容量*加载因子)。加载因子默认0.75,过大则冲突增加,链表加长,查询效率降低;过小则空间浪费
PS:Hash地址的产生用位运算,这样效率较高

TreeMap:底层是二叉树,可排序

Android集合
ArrayMap:替代HashMap,使用Hash算法,底层是两个数组,mHash数组保存每个key的Hash值,mArray数组用连续的两个元素保存key-value。利用key的hash值计算其所在数组的下标index,如存在冲突则index往下移。key 不为null。
性能方面,查找使用二分法,增删时会对数据进行重新整理,清除数据后会自动收缩数据,释放空间。以时间换空间,消耗小,但效率没HashMap高

SparseArray:替代HashMap,SparseArray并不是用Hash算法来做的,底层采用两个数组来存储key-value,适用于数据量在千级以下。
性能方面,
key只能是int类型,避免了自动装箱
内部对数据还采取了压缩的方式来表示稀疏数组的数据
在存储和读取数据时候,使用的是二分查找法

遍历与排序
List和Map都可以用add/get来存储数据或者Iterator;Set只能用Iterator

List可以用Collections.sort来排序:
List E中有默认实现的compareTo,也可重写,调用Collections.sort(List list)即可排序;如果想重写定义排序规则也可以用Collections.sort(List list,Comparator c)

//按照价格排序
Collections.sort(list, new Comparator<Object>() {
@Override
public int compare(Object o1, Object o2) {
Book book1 = (Book)o1;
Book book2 = (Book)o3;
return book1.price.compareTo(book2.price);
}
});

Set和Map是无序的,部分底层是二叉树实现的可以是有序的,内部已经实现自动排序了。
---------------------
作者:xiaoru5127
来源:CSDN
原文:https://blog.csdn.net/xiaoru5127/article/details/81112820
版权声明:本文为博主原创文章,转载请附上博文链接!

基础常用的数据结构 Collection Map的更多相关文章

  1. java中常用的数据结构--Collection接口及其子类

    java中有几种常用的数据结构,主要分为Collection和map两个主要接口(接口只提供方法,并不提供实现),而程序中最终使用的数据结构是继承自这些接口的数据结构类. 一.集合和数组的区别 二.C ...

  2. Js基础知识7-Es6新增对象Map和set数据结构

    前言 JavaScript中对象的本质是键值对的集合,ES5中的数据结构,主要是用Array和Object,但是键只能是字符串.为了弥补这种缺憾,ES6带来了一种新的数据结构Map. Map也是键值对 ...

  3. Collection Map Java数据结构

    Collection Map 框架图 Collection          接口的接口   对象的集合 ├ List                   子接口      按进入先后有序保存   可 ...

  4. Java核心数据结构(List,Map,Set)原理与使用技巧

    JDK提供了一组主要的数据结构实现,如List.Map.Set等常用数据结构.这些数据都继承自 java.util.Collection 接口,并位于 java.util 包内. 1.List接口 最 ...

  5. linkin大话数据结构--Collection和Iterator

    linkin大话数据结构--Collection和Iterator Java 集合就像一种容器,可以把多个对象的引用放入容器中.Java 集合类可以用于存储数量不等的多个对象,还可用于保存具有映射关系 ...

  6. JS数据结构之 Map

    JS数据结构之 Map Map介绍 Map(映射)是ES6引入的一种数据结构.这是一种存储键值对列表很方便的方法,类似于其他编程语言的哈希表. HashMap(哈希表),也叫做散列表.是根据关键码值 ...

  7. Unity3D中常用的数据结构总结与分析

    来到周末,小匹夫终于有精力和时间来更新下博客了.前段时间小匹夫读过一份代码,对其中各种数据结构灵活的使用赞不绝口,同时也大大激发了小匹夫对各种数据结构进行梳理和总结的欲望.正好最近也拜读了若干大神的文 ...

  8. ES6 之 Set数据结构和Map数据结构 Iterator和for...of循环

    ECMAScript 6 入门 Set数据结构 基本用法 ES6提供了新的数据结构Set.它类似于数组,但是成员的值都是唯一的,没有重复的值. Set本身是一个构造函数,用来生成Set数据结构. va ...

  9. python 3.x 爬虫基础---常用第三方库(requests,BeautifulSoup4,selenium,lxml )

    python 3.x 爬虫基础 python 3.x 爬虫基础---http headers详解 python 3.x 爬虫基础---Urllib详解 python 3.x 爬虫基础---常用第三方库 ...

随机推荐

  1. Web获取客户端物理MAC地址(ocx插件)ActiveX控件

    主要是通过ActiveX控件 从本地获取到MAC地址,传入到浏览器打开的网页中,再提交到服务器. 具体详解与步骤看文档中: 文件实例包下载 DotNetFX 文件夹附件文件:(可能安装时需用) dot ...

  2. luogu P3235 [HNOI2014]江南乐

    传送门 这题又是我什么时候做的(挠头) 首先是个和SG函数有关的博弈论,SG=0则先手必败.显然一堆石子就是一个游戏,而若干堆石子的SG值就是每堆SG的异或和,所以算出每堆石子SG就能知道答案 然后怎 ...

  3. CF920E Connected Components?

    CF luogu 先讲两个靠谱的做法 1.首先因为有n个点,m条不存在的边,所以至少存在一个点,和m/n个点之间没边,所以把这个点找出来,连一下其他相连的点,这样还剩m/n个点没确定在哪个联通块,而这 ...

  4. Ubuntu18.04使用AndroidStudio3.2.1编译TensorFlow android demo【2018年12月】

    按照官方教程修改下面3处即可编译完成. 修改部分: 在build.gradle文件里修改以下部分: 1.原来: buildscript { repositories { jcenter() } dep ...

  5. Luogu P4479 [BJWC2018]第k大斜率

    一道清真简单的好写的题 Luogu P4479 题意 求点集两两连出的直线中斜率第$ k$大的直线 $ Solution$ 二分答案,设$x_j \geq x_i$ 若点$ (x_i,y_i)$和点$ ...

  6. npm 的 --save 和 --save-dev 的区别

    --save-dev 是作为开发依赖保存到 packsge.json 中的 devDependencies 中,即在开发环境中用到的依赖,如 webpack.babel 等用于开发打包的依赖,只是在执 ...

  7. LightOJ - 1245 Harmonic Number (II) 求同值区间的和

    题目大意:对下列代码进行优化 long long H( int n ) {    long long res = 0;    for( int i = 1; i <= n; i++ )      ...

  8. Centos7配置静态IP后无法ping通外部网络的问题(无法上网)

    打开ifcfg-ens33配置文件,注意下面标记部分 建议: (1)ifcfg-ens33 DNS 配置 DNS1=8.8.8.8 DNS2=8.8.4.4 (2)配置DNS解析才能够识别外部的IP域 ...

  9. 20165234 《Java程序设计》第九周学习总结

    第九周学习总结 教材内容学习 第十三章 Java 网络编程 URL 类 URL 类是 java.net 包中的一个重要的类,使用URL创建对象的应用程序称为客户端程序. 一个 URL 对象通常包含最基 ...

  10. python第一天,简单输出及基本运算符

    1.安装步骤网上很多详细的图文资料,这里就不一一赘述. 我的环境:win7 64bit +python-3.7.0b2 2.简单的输出(3.0之后和之前的版本略有不同) 1)打开控制台输入python ...