1. 集合
- 1.1. 什么是集合
- 1.2. 集合和数组的区别
- 1.3. 集合的分类
- 1.4. 什么时候该使用什么样的集合
二. 集合类(Collection)
- 2.1. Collection接口的共性方法
  - 2.1.1. 增加：
  - 2.1.2. 删除：
- 2.1.3. 修改：
  - 2.1.4. 判断：
  - 2.1.5. 获取：
- 2.2. List
  - 2.2.1. List集合特有方法
    - 2.2.1.1. 增加
    - 2.2.1.2. 删除
    - 2.2.1.3. 修改：
    - 查找
    - 2.2.1.4. 查找
  - 2.2.2. ArrayList
  - 2.2.3. LinkedList
    - 特有方法
    - 基本方法
    - 迭代
    - 逆序迭代
  - 2.2.4. Vector
- 2.3. 迭代器
  - 2.3.1. Utterable
  - 2.3.2. Iterator
  - 2.3.3. 迭代器遍历
    - 1：while循环
    - 2：for循环
    - 3：使用迭代器清空集合
    - 4：迭代器原理
  - 2.3.4. List特有的迭代器ListIterator
    - 倒序遍历

1. 集合

1.1. 什么是集合

存储对象的容器，面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，存储对象，集合是存储对象最常用的一种方式。
集合的出现就是为了持有对象。集合中可以存储任意类型的对象, 而且长度可变。在程序中有可能无法预先知道需要多少个对象, 那么用数组来装对象的话, 长度不好定义, 而集合解决了这样的问题。

1.2. 集合和数组的区别

数组和集合类都是容器
数组长度是固定的，集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象数组中存储数据类型是单一的，集合中可以存储任意类型的对象。
集合类的特点
用于存储对象，长度是可变的，可以存储不同类型的对象。

1.3. 集合的分类

1.4. 什么时候该使用什么样的集合

二. 集合类(Collection)

2.1. Collection接口的共性方法

增加：1：add() 将指定对象存储到容器中add 方法的参数类型是Object 便于接收任意对象2：addAll() 将指定集合中的元素添加到调用该方法和集合中
删除：3：remove() 将指定的对象从集合中删除4：removeAll() 将指定集合中的元素删除
修改5：clear() 清空集合中的所有元素
判断6：isEmpty() 判断集合是否为空7：contains() 判断集合何中是否包含指定对象8：containsAll() 判断集合中是否包含指定集合使用equals()判断两个对象是否相等
获取:   9：int size()    返回集合容器的大小转成数组10： toArray()   集合转换数组

2.1.1. 增加：

public static void main(String[] args) {Collection list = new ArrayList();// 增加：add() 将指定对象存储到容器中list.add("计算机网络");list.add("现代操作系统");list.add("java编程思想");System.out.println(list);// [计算机网络, 现代操作系统, java编程思想]// 增加2 将list容器元素添加到list2容器中Collection list2 = new ArrayList();list2.add("java核心技术");list2.addAll(list);list2.add("java语言程序设计");System.out.println(list2);// [java核心技术, 计算机网络, 现代操作系统, java编程思想, java语言程序设计]}

2.1.2. 删除：

// 删除1 removeboolean remove = list2.remove("java核心技术");System.out.println(remove); // trueSystem.out.println(list2); ////删除2 removeAll() 将list中的元素删除boolean removeAll = list2.removeAll(list);System.out.println(removeAll);//trueSystem.out.println(list2);//[java语言程序设计]

2.1.3. 修改：

public static void main(String[] args) {Collection list = new ArrayList();// 增加：add() 将指定对象存储到容器中list.add("计算机网络");list.add("现代操作系统");list.add("java编程思想");list.add("java核心技术");list.add("java语言程序设计");System.out.println(list);// 修改 clear() 清空集合中的所有元素list.clear();System.out.println(list); //[] }

2.1.4. 判断：

public static void main(String[] args) {Collection list = new ArrayList();// 增加：add() 将指定对象存储到容器中list.add("计算机网络");list.add("现代操作系统");list.add("java编程思想");list.add("java核心技术");list.add("java语言程序设计");System.out.println(list);boolean empty = list.isEmpty();System.out.println(empty);// falseboolean contains = list.contains("java编程思想");System.out.println(contains);// trueCollection list2 = new ArrayList();list2.add("水许传");boolean containsAll = list.containsAll(list2);System.out.println(containsAll);// false}

2.1.5. 获取：

public static void main(String[] args) {Collection list = new ArrayList();// 增加：add() 将指定对象存储到容器中list.add("计算机网络");list.add("现代操作系统");list.add("java编程思想");list.add("java核心技术");list.add("java语言程序设计");System.out.println(list);// 获取  集合容器的大小 int size = list.size();System.out.println(size); }

2.2. List

---| Iterable     接口
          Iterator iterator()----| Collection     接口
        ------| List      接口 元素可以重复，允许在指定位置插入元素，并通过索
引来访问元素

2.2.1. List集合特有方法

1：增加void add(int index, E element) 指定位置添加元素            boolean addAll(int index, Collection c) 指定位置添加集合
2：删除
E remove(int index) 删除指定位置元素3：修改E set(int index, E element)    返回的是需要替换的集合中的元素
4：查找：E get(int index)             注意： IndexOutOfBoundsExceptionint indexOf(Object o)         // 找不到返回-1lastIndexOf(Object o)
5：求子集合List<E> subList(int fromIndex, int toIndex) // 不包含toIndex

2.2.1.1. 增加

public static void main(String[] args) {List list = new ArrayList();// 增加：add() 将指定对象存储到容器中list.add("计算机网络");list.add("现代操作系统");list.add("java编程思想");list.add("java核心技术");list.add("java语言程序设计");System.out.println(list);// add,在0角标位置添加一本书list.add(0, "舒克和贝塔");System.out.println(list);// 在list2集合的1角标位置添加list集合元素List list2 = new ArrayList();list2.add("史记");list2.add("资治通鉴");list2.add("全球通史");boolean addAll = list2.addAll(1, list);System.out.println(addAll); //true       System.out.println(list2);}

2.2.1.2. 删除

public static void main(String[] args) {List list = new ArrayList();// 增加：add() 将指定对象存储到容器中list.add("计算机网络");list.add("现代操作系统");list.add("java编程思想");list.add("java核心技术");list.add("java语言程序设计");System.out.println(list);// 删除0角标元素Object remove = list.remove(0);System.out.println(remove);}

2.2.1.3. 修改：

public static void main(String[] args) {List list = new ArrayList();// 增加：add() 将指定对象存储到容器中list.add("计算机网络");list.add("现代操作系统");list.add("java编程思想");list.add("java核心技术");list.add("java语言程序设计");System.out.println(list);// 修改2角标位置的书，返回的原来2角标位置的书Object set = list.set(2, "边城");System.out.println(set); //java编程思想System.out.println(list); }

查找

    List list = new ArrayList();// 增加：add() 将指定对象存储到容器中list.add("计算机网络");list.add("现代操作系统");list.add("java编程思想");list.add("java核心技术");list.add("java语言程序设计");System.out.println(list);// 查找： E get(int index)  注意角标越界Object set = list.get(list.size() - 1);System.out.println(set); // java语言程序设计System.out.println(list);
list.get(list.size()); //IndexOutOfBoundsException}

2.2.1.4. 查找

public static void main(String[] args) {List list = new ArrayList();// 增加：add() 将指定对象存储到容器中list.add("计算机网络");list.add("现代操作系统");list.add("java编程思想");list.add("java核心技术");list.add("java语言程序设计");list.add("java编程思想");System.out.println(list);// 查找： E get(int index) 注意角标越界Object set = list.get(list.size() - 1);System.out.println(set); // java语言程序设计System.out.println(list);// list.get(list.size()); //IndexOutOfBoundsException// indexOf(Object o) 返回第一次出现的指定元素的角标int indexOf = list.indexOf("java编程思想");System.out.println(indexOf); // 2// 没有找到，返回-1int indexOf2 = list.indexOf("三国志");System.out.println(indexOf2); // -1// lastIndexOf 返回最后出现的指定元素的角标int lastIndexOf = list.lastIndexOf("java编程思想");System.out.println(lastIndexOf); // 5}

2.2.2. ArrayList

--| Iterable
              ----| Collection
                 ------| List
                      ---------| ArrayList  底层采用数组实现，默认10。每次增长
60%,（(oldCapacity * 3)/2 + 1） 查询快，增删慢。---------| LinkedList

ArrayList:实现原理：

数组实现, 查找快, 增删慢数组为什么是查询快?因为数组的内存空间地址是连续的. ArrayList底层维护了一个Object[]
用于存储对象，默认数组的长度是10。可以通过 new ArrayList(20)显式的指定用于存储对象的数组的长度。
当默认的或者指定的容量不够存储对象的时候，容量自动增长为原来的容量的1.5倍。由于ArrayList是数组实现,
在增和删的时候会牵扯到数组增容, 以及拷贝元素. 所以慢。数组是可以直接按索引查找, 所以查找时较快
可以考虑,假设向数组的0角标未知添加元素,那么原来的角标位置的元素需要整体往后移,并且数组可能还要增容,一旦增容,就需要要将老数组的内容拷贝到新数组中.所以数组的增删的效率是很低的.

练习：去除ArrayList集合中重复元素1：存入字符串元素2：存入自定义对象元素（如Perosn对象）
原理：循环遍历该集合，每取出一个放置在新的集合中，放置之前先判断新的集合是否以包含了新的元素。
思路:存入人的对象.1先定义person 类2将该类的实例存入集合3 将对象元素进行操作. 注意:自定义对象要进行复写toString 和 equals 方法.为什么? 因为object 是person 的父类,object 中的toString 返回的是哈希值,object 类中equals方法比较的是对象的地址值.思路1存入字符串对象 2存入自定义对象 如person2创建容器,用于存储非重复元素3对原容器进行遍历,在遍历过程中进行判断遍历到的元素是否在容器中存在.(contains)4如果存在,就不存入,否则存入.5 返回新容器

public class Demo6 {public static void main(String[] args) {ArrayList arr = new ArrayList();Person p1 = new Person("jack", 20);Person p2 = new Person("rose", 18);Person p3 = new Person("rose", 18);arr.add(p1);arr.add(p2);arr.add(p3);System.out.println(arr);ArrayList arr2 = new ArrayList();for (int i = 0; i < arr.size(); i++) {Object obj = arr.get(i);Person p = (Person) obj;if (!(arr2.contains(p))) {arr2.add(p);}}System.out.println(arr2);}
}class Person {private String name;private int age;public Person() {}public Person(String name, int age) {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;}@Overridepublic int hashCode() {return this.name.hashCode() + age * 37;}@Overridepublic boolean equals(Object obj) {if (!(obj instanceof Person)) {return false;}Person p = (Person) obj;return this.name.equals(p.name) && this.age == p.age;}@Overridepublic String toString() {return "Person@name:" + this.name + " age:" + this.age;}}在实际的开发中ArrayList是使用频率最高的一个集合。

2.2.3. LinkedList

--| Iterable
              ----| Collection
                 ------| List
                      ---------| ArrayList  底层采用数组实现，默认10。每次增长
60%,（(oldCapacity * 3)/2 + 1） 查询快，增删慢。---------| LinkedList  底层采用链表实现，增删快，查询慢。
LinkedList:链表实现, 增删快, 查找慢

由于LinkedList:在内存中的地址不连续,需要让上一个元素记住下一个元素.所以每个元素中保存的有下一个元素的位置.虽然也有角标,但是查找的时候,需要从头往下找,显然是没有数组查找快的.但是,链表在插入新元素的时候,只需要让前一个元素记住新元素,让新元素记住下一个元素就可以了.所以插入很快.
由于链表实现, 增加时只要让前一个元素记住自己就可以, 删除时让前一个元素记住后一个元素, 后一个元素记住前一个元素. 这样的增删效率较高。
但查询时需要一个一个的遍历, 所以效率较低。

特有方法

1：方法介绍addFirst(E e)
addLast(E e)
getFirst()
getLast()
removeFirst()
removeLast()
如果集合中没有元素，获取或者删除元
素抛：NoSuchElementException
2：数据结构1：栈 （1.6）先进后出push() pop()2：队列（双端队列1.5）先进先出offer()poll()
3：返回逆序的迭代器对象
descendingIterator()   返回逆序的迭代器对象

基本方法

import java.util.Iterator;
import java.util.LinkedList;public class Demo3 {public static void main(String[] args) {LinkedList list = new LinkedList();list.add("西游记");list.add("三国演义");list.add("石头记");list.add("水浒传");list.add("全球通史");list.addFirst("史记");list.addLast("呐喊");// list.addFirst(null);// list.addLast(null);System.out.println(list);// 获取指定位置处的元素。String str = (String) list.get(0);// 返回此列表的第一个元素。String str2 = (String) list.getFirst();System.out.println(str.equals(str2));// 获取指定位置处的元素。String str3 = (String) list.get(list.size() - 1);// 返回此列表的最后一个元素。String str4 = (String) list.getLast();System.out.println(str3.equals(str4));// 获取但不移除此列表的头（第一个元素）。Object element = list.element();System.out.println(element);int size = list.size();System.out.println(size);
}

迭代

mport java.util.Iterator;
import java.util.LinkedList;public class Demo3 {public static void main(String[] args) {LinkedList list = new LinkedList();list.add("西游记");list.add("三国演义");list.add("石头记");list.add("水浒传");list.add("全球通史");Iterator it = list.iterator();while (it.hasNext()) {String next = (String) it.next();System.out.println(next);}}
}

逆序迭代

import java.util.Iterator;
import java.util.LinkedList;public class Demo6 {public static void main(String[] args) {LinkedList list = new LinkedList();list.add("aa");list.add("bb");list.add("cc");Iterator dit = list.descendingIterator();while (dit.hasNext()) {System.out.println(dit.next());}}
}

注意：可以使用该集合去模拟出队列(先进先出) 或者堆栈(后进先出) 数据结构。堆栈(后进先出) //堆栈(后进先出) 数据结构

public class Demo3 {public static void main(String[] args) {LinkedList list = new LinkedList();// 压栈，先进后出list.push("西游记");list.push("三国演义");list.push("石头记");list.push("水浒传");System.out.println(list);// 弹栈String str1 = (String) list.pop();System.out.println(str1);String str2 = (String) list.pop();System.out.println(str2);String str3 = (String) list.pop();System.out.println(str3);String str4 = (String) list.pop();System.out.println(str4);System.out.println(list.size());// 0System.out.println(list); //[]}
}

队列，先进先出

import java.util.LinkedList;public class Demo3 {public static void main(String[] args) {LinkedList list = new LinkedList();// 队列，先进先出list.offer("西游记");list.offer("三国演义");list.offer("石头记");list.offer("水浒传");System.out.println(list);// 出队列System.out.println(list.poll());System.out.println(list.poll());System.out.println(list.poll());System.out.println(list.poll());System.out.println(list.size());System.out.println(list.peek()); // 获取队列的头元素，但是不删除System.out.println(list.peekFirst()); // 获取队列的头元素，但是不删除System.out.println(list.peekLast()); // 获取队列的最后一个元素但是不删除}
}

ArrayList 和 LinkedList的存储查找的优缺点：
1、ArrayList是采用动态数组来存储元素的，它允许直接用下标号来直接查找对应的元素。但是，但是插入元素要涉及数组元素移动及内存的操作。总结：查找速度快，插入操作慢。
2、LinkedList是采用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快
问题：有一批数据要存储，要求存储这批数据不能出现重复数据，ArrayList、LinkedList都没法满足需求。解决办法：使用 set集合。

2.2.4. Vector

Vector: 描述的是一个线程安全的ArrayList。

ArrayList：单线程效率高
Vector ：多线程安全的，所以效率低
特有的方法：

 void addElement(E obj)  在集合末尾添加元素E elementAt( int index) 返回指定角标的元素Enumeration elements()  返回集合中的所有元素，封装到Enumeration对象中

Enumeration 接口：

boolean hasMoreElements()
测试此枚举是否包含更多的元素。
E nextElement()
如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。

public static void main(String[] args) {Vector v = new Vector();v.addElement("aaa");v.addElement("bbb");v.addElement("ccc");System.out.println( v );System.out.println( v.elementAt(2) );   // ccc// 遍历Vector遍历Enumeration ens = v.elements();while ( ens.hasMoreElements() ){System.out.println( ens.nextElement() );}}

2.3. 迭代器

    为了方便的处理集合中的元素,Java中出现了一个对象,该对象提供了一些方法专门处理集合中的元素.例如删除和获取集合中的元素.该对象就叫做迭代器(Iterator).对 Collection 进行迭代的类，称其为迭代器。还是面向对象的思想，专业对象做专业的事情，迭代器就是专门取出集合元素的对象。但是该对象比较特殊，不能直接创建对象（通过new），该对象是以内部类的形式存在于每个集合类的内部。如何获取迭代器？Collection接口中定义了获取集合类迭代器的方法（iterator（）），所以所有的Collection体系集合都可以获取自身的迭代器。正是由于每一个容器都有取出元素的功能。这些功能定义都一样，只不过实现的具体方式不同（因为每一个容器的数据结构不一样）所以对共性的取出功能进行了抽取，从而出现了Iterator接口。而每一个容器都在其内部对该接口进行了内部类的实现。也就是将取出方式的细节进行封装。

2.3.1. Utterable

    Jdk1.5之后添加的新接口, Collection的父接口. 实现了Iterable的类就是可迭代的.并且支持增强for循环。该接口只有一个方法即获取迭代器的方法iterator（）可以获取每个容器自身的迭代器Iterator。（Collection）集合容器都需要获取迭代器（Iterator）于是在5.0后又进行了抽取将获取容器迭代器的iterator（）方法放入到了Iterable接口中。Collection接口进程了Iterable，所以Collection体系都具备获取自身迭代器的方法，只不过每个子类集合都进行了重写（因为数据结构不同）

2.3.2. Iterator

    Iterator iterator() 返回该集合的迭代器对象
该类主要用于遍历集合对象，该类描述了遍历集合的常见方法1：java.lang. Itreable  ---| Itreable      接口 实现该接口可以使用增强for循环
                ---| Collection     描述所有集合共性的接口
                    ---| List接口     可以有重复元素的集合
                    ---| Set接口      不可以有重复元素的集合

public interface Iterable
Itreable 该接口仅有一个方法，用于返回集合迭代器对象。
1： Iterator iterator() 返回集合的迭代器对象

Iterator接口定义的方法

Itreator    该接口是集合的迭代器接口类，定义了常见的迭代方法1：boolean hasNext() 判断集合中是否有元素，如果有元素可以迭代，就返回true。2： E next()  返回迭代的下一个元素，注意： 如果没有下一个元素时，调用
next元素会抛出NoSuchElementException3： void remove()从迭代器指向的集合中移除迭代器返回的最后一个元素（可选操
作）。

思考：为什么next方法的返回类型是Object的呢？为了可以接收任意类型的对象,那么返回的时候,不知道是什么类型的就定义为object

2.3.3. 迭代器遍历

1：while循环

public static void main(String[] args) {ArrayList list = new ArrayList();// 增加：add() 将指定对象存储到容器中list.add("计算机网络");list.add("现代操作系统");list.add("java编程思想");list.add("java核心技术");list.add("java语言程序设计");System.out.println(list);Iterator it = list.iterator();while (it.hasNext()) {String next = (String) it.next();System.out.println(next);}}

2：for循环

import java.util.ArrayList;
import java.util.Iterator;public class Demo2 {public static void main(String[] args) {ArrayList list = new ArrayList();// 增加：add() 将指定对象存储到容器中list.add("计算机网络");list.add("现代操作系统");list.add("java编程思想");list.add("java核心技术");list.add("java语言程序设计");System.out.println(list);for (Iterator it = list.iterator(); it.hasNext();) {//迭代器的next方法返回值类型是Object，所以要记得类型转换。String next = (String) it.next();System.out.println(next);}}
}

需要取出所有元素时，可以通过循环，java 建议使用for 循环。因为可以对内存进行一下优化。

3：使用迭代器清空集合

public class Demo1 {public static void main(String[] args) {Collection coll = new ArrayList();coll.add("aaa");coll.add("bbb");coll.add("ccc");coll.add("ddd");System.out.println(coll);Iterator it = coll.iterator();while (it.hasNext()) {it.next();it.remove();}System.out.println(coll);}
}

细节一：
如果迭代器的指针已经指向了集合的末尾，那么如果再调用next()会返回NoSuchElementException异常

import java.util.ArrayList;
import java.util.Iterator;public class Demo2 {public static void main(String[] args) {ArrayList list = new ArrayList();// 增加：add() 将指定对象存储到容器中list.add("计算机网络");list.add("现代操作系统");list.add("java编程思想");list.add("java核心技术");list.add("java语言程序设计");System.out.println(list);Iterator it = list.iterator();while (it.hasNext()) {String next = (String) it.next();System.out.println(next);}// 迭代器的指针已经指向了集合的末尾// String next = (String) it.next();// java.util.NoSuchElementException}
}

细节二：
如果调用remove之前没有调用next是不合法的，会抛出IllegalStateException

import java.util.ArrayList;
import java.util.Iterator;public class Demo2 {public static void main(String[] args) {ArrayList list = new ArrayList();// 增加：add() 将指定对象存储到容器中list.add("计算机网络");list.add("现代操作系统");list.add("java编程思想");list.add("java核心技术");list.add("java语言程序设计");System.out.println(list);Iterator it = list.iterator();while (it.hasNext()) {// 调用remove之前没有调用next是不合法的// it.remove();// java.lang.IllegalStateExceptionString next = (String) it.next();System.out.println(next);}}
}

4：迭代器原理

查看ArrayList源码

private class Itr implements Iterator<E> {int cursor = 0;int lastRet = -1;int expectedModCount = modCount;public boolean hasNext() {return cursor != size();}public E next() {checkForComodification();try {E next = get(cursor);lastRet = cursor++;return next;} catch (IndexOutOfBoundsException e) {checkForComodification();throw new NoSuchElementException();}}public void remove() {if (lastRet == -1)throw new IllegalStateException();checkForComodification();try {AbstractList.this.remove(lastRet);if (lastRet < cursor)cursor--;lastRet = -1;expectedModCount = modCount;} catch (IndexOutOfBoundsException e) {throw new ConcurrentModificationException();}}}

5：注意在对集合进行迭代过程中，不允许出现迭代器以外的对元素的操作，因为这样会产生安全隐患，java会抛出异常并发修改异常（ConcurrentModificationException），普通迭代器只支持在迭代过程中的删除动作。

注意： ConcurrentModificationException:
当一个集合在循环中即使用引用变量操作集合又使用迭代器操作集合对象，会抛出该异常。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo1 {public static void main(String[] args) {Collection coll = new ArrayList();coll.add("aaa");coll.add("bbb");coll.add("ccc");coll.add("ddd");System.out.println(coll);Iterator it = coll.iterator();while (it.hasNext()) {it.next();it.remove();coll.add("abc"); // 出现了迭代器以外的对元素的操作}System.out.println(coll);}
}

如果是List集合，想要在迭代中操作元素可以使用List集合的特有迭代器ListIterator，该迭代器支持在迭代过程中，添加元素和修改元素。

2.3.4. List特有的迭代器ListIterator

public interface ListIterator extends IteratorListIterator<E> listIterator()
---| IteratorhasNext()next()remove()------| ListIterator Iterator子接口 List专属的迭代器add(E e)    将指定的元素插入列表（可选操作）。该元素直接插入到 next 返回的下一个元素的前面（如果有）void set(E o)   用指定元素替换 next 或 previous 返回的最后一个元素hasPrevious()    逆向遍历列表，列表迭代器有多个元素，则返回 true。previous()       返回列表中的前一个元素。

Iterator在迭代时，只能对元素进行获取(next())和删除(remove())的操作。对于 Iterator
的子接口ListIterator 在迭代list 集合时，还可以对元素进行添加 (add(obj))，修改set(obj)的操作。

import java.util.ArrayList;
import java.util.ListIterator;public class Demo2 {public static void main(String[] args) {ArrayList list = new ArrayList();// 增加：add() 将指定对象存储到容器中list.add("计算机网络");list.add("现代操作系统");list.add("java编程思想");list.add("java核心技术");list.add("java语言程序设计");System.out.println(list);// 获取List专属的迭代器ListIterator lit = list.listIterator();while (lit.hasNext()) {String next = (String) lit.next();System.out.println(next);}}
}

倒序遍历

import java.util.ArrayList;
import java.util.ListIterator;public class Demo2 {public static void main(String[] args) {ArrayList list = new ArrayList();// 增加：add() 将指定对象存储到容器中list.add("计算机网络");list.add("现代操作系统");list.add("java编程思想");list.add("java核心技术");list.add("java语言程序设计");System.out.println(list);// 获取List专属的迭代器ListIterator lit = list.listIterator();while (lit.hasNext()) {String next = (String) lit.next();System.out.println(next);}System.out.println("***************");while (lit.hasPrevious()) {String next = (String) lit.previous();System.out.println(next);}}
}

Set方法：用指定元素替换 next 或 previous 返回的最后一个元素

import java.util.ArrayList;
import java.util.ListIterator;public class Demo2 {public static void main(String[] args) {ArrayList list = new ArrayList();// 增加：add() 将指定对象存储到容器中list.add("计算机网络");list.add("现代操作系统");list.add("java编程思想");list.add("java核心技术");list.add("java语言程序设计");System.out.println(list);ListIterator lit = list.listIterator();lit.next(); // 计算机网络lit.next(); // 现代操作系统System.out.println(lit.next()); // java编程思想//用指定元素替换 next 或 previous 返回的最后一个元素lit.set("平凡的世界");// 将java编程思想替换为平凡的世界System.out.println(list);}
}

add方法将指定的元素插入列表，该元素直接插入到 next 返回的元素的后

public class Demo2 {public static void main(String[] args) {ArrayList list = new ArrayList();// 增加：add() 将指定对象存储到容器中list.add("计算机网络");list.add("现代操作系统");list.add("java编程思想");list.add("java核心技术");list.add("java语言程序设计");System.out.println(list);ListIterator lit = list.listIterator();lit.next(); // 计算机网络lit.next(); // 现代操作系统System.out.println(lit.next()); // java编程思想// 将指定的元素插入列表，该元素直接插入到 next 返回的元素的后lit.add("平凡的世界");// 在java编程思想后添加平凡的世界System.out.println(list);}
}

List-ArrayList 与LinkedList、Vector以及迭代器详解相关推荐

Java中Iterator迭代器详解
目录一.Java中Iterator迭代器详解 1.为什么需要迭代器 2.迭代器长什么样子 3.如何使用迭代器使用步骤: 代码演示: 迭代器可以简化为增强型for循环: 4.Iterator与Lis ...
c/c++ 标准库插入迭代器详解
标准库插入迭代器详解插入迭代器作用:copy等函数不能改变容器的大小,所以有时copy先容器是个空的容器,如果不使用插入迭代器,是无法使用copy等函数的. 例如下面的代码就是错误的: list ...
c++中vector的用法详解
c++中vector的用法详解 vector(向量): C++中的一种数据结构,确切的说是一个类.它相当于一个动态的数组,当程序员无法知道自己需要的数组的规模多大时,用其来解决问题可以达到最大节约空间 ...
java linkedlist实例_Java Linkedlist原理及实例详解
这篇文章主要介绍了Java Linkedlist原理及实例详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下定义:linkedlist属于链表结构 ...
Vector的使用详解
Java中 Vector的使用详解 Vector 可实现自动增长的对象数组. java.util.vector提供了向量类(Vector)以实现类似动态数组的功能. 创建了一个向量类的对象后,可以 ...
Java LinkedList的实现原理详解
LinkedList是Java List类型的集合类的一种实现,此外,LinkedList还实现了Deque接口.本文基于Java1.8,对于LinkedList的实现原理做一下详细讲解. (Java ...
Vector和Stack详解
一.学习Vector和Stack之前先学习ArrayList ArrayList详解_Allence的博客-CSDN博客一.介绍ArrayList是以什么数据结构实现的ArrayList底层的数据结构 ...
【C++】迭代器、反向迭代器详解
参考: http://c.biancheng.net/view/338.html https://blog.csdn.net/kjing/article/details/6936325 https:/ ...
vector容器用法详解
vector类称作向量类,它实现了动态数组,用于元素数量变化的对象数组.像数组一样,vector类也用从0开始的下标表示元素的位置:但和数组不同的是,当vector对象创建后,数组的元素个数会随着ve ...

List-ArrayList 与LinkedList、Vector以及迭代器详解