黑马程序员---集合一

集合一

----------- android培训、java培训、java学习型技术博客期待与您交流！ ------------

1.集合概述

1.1 概念

存储对象的容器。

1.2 集合出现的原因

1）面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，存储对象，集合是存储对象的最常用的一种方式。

2）集合之前有数组，但数组的长度是固定的，不方便操作。

3）而集合就是可以持有任意量的对象，长度可变。

1.3 集合与数组的异同

1）数组和集合类都是容器。

2）数组的长度是固定的，集合的长度是可变的。数组中可以存储基本数据类型，集合只能只能存储对象。

3）数组中存储的数据类型是单一的，集合中可以存储任意类型的对象。

1.3.1 集合类的特点

存储对象，长变可变，可存储不同类型的对象。

1.4 集合的分类（集合能做什么）

1）将对象添加到集合

2）从集合中删除对象

3）从集合中查找一个对象

4）从集合中修改一个对象

注：集合和数组中存放的都是对象的引用而非对象本身。

1.5 集合框架体系

文字概念如

---|Collection: 单列集合
---|List: 有存储顺序, 可重复
---|ArrayList:  数组实现, 查找快, 增删慢
由于是数组实现, 在增和删的时候会牵扯到数组
增容, 以及拷贝元素. 所以慢。数组是可以直接
按索引查找, 所以查找时较快
---|LinkedList: 链表实现, 增删快, 查找慢
由于链表实现, 增加时只要让前一个元素记住自
己就可以, 删除时让前一个元素记住后一个元
素, 后一个元素记住前一个元素. 这样的增删效
率较高但查询时需要一个一个的遍历, 所以效率
较低
---|Vector: 和ArrayList原理相同, 但线程安全, 效率略低
和ArrayList实现方式相同, 但考虑了线程安全问
题, 所以效率略低
---|Set: 无存储顺序, 不可重复
---|HashSet
---|TreeSet
---|LinkedHashSet
---| Map: 键值对
---|HashMap
---|TreeMap
---|HashTable
---|LinkedHashMap

为什么要出现这么多的集合容器，因为每一个容器对数据的存储方式不同，这种存储方式称之为数据结构（data structure）

1.6 什么时候使用什么的集合

1）我们需要保存若干个对象的时候使用集合。 2）如果我们需要保留存储顺序，并且保留重复的元素，使用List. 1. 如果查询较多，使用ArrayList 2. 如果存储较多，使用LinkedList 3. 如果需要线程安全，使用Vector 3）如果我们不需要存储顺序，并且需要去掉重复的元素，使用Set 1. 如果我们需要将元素排序，那么使用TreeSet 2. 如果不需要排序，使用HashSet 3. 如果我们需要保留存储顺序，又要过滤重复元素，那么使用LinkedHashSet

2. 集合类（Collection）

2.1 概念

集合共有的功能

Collection有两个子接口

1）List(链表|线性表)—可存放重复的元素，元素存取是无序的。

2）Set（集） --不可以存放重复元素，元素的存取是无序的。

如图示

2.2 Collection接口共有的方法

代码案例 ：

2.2.1 增加

import java.util.ArrayList;
import java.util.Collection;
public class AddDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//新建对象
Collection list = new ArrayList();
//添加元素
list.add("计算机网络");
list.add("现代系统技术");
list.add("JSP技术开发详解");
list.add("Java编程思想");
//输出
System.out.println(list);
Collection list2 = new ArrayList();
list2.add("Java入门到精通");
//将list的所有添加到list2
list2.addAll(list);
list2.add("Java与模式");
//输出
System.out.println(list2);
}
}
输出结果：
[计算机网络, 现代系统技术, JSP技术开发详解, Java编程思想]
[Java入门到精通, 计算机网络, 现代系统技术, JSP技术开发详解, Java编程思想, Java与模式]

2.2.2 删除

import java.util.ArrayList;
import java.util.Collection;
public class AddDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//新建对象
Collection list = new ArrayList();
//添加元素
list.add("计算机网络");
list.add("现代系统技术");
list.add("JSP技术开发详解");
list.add("Java编程思想");
//输出
System.out.println(list);
Collection list2 = new ArrayList();
list2.add("Java入门到精通");
//将list的所有添加到list2
list2.addAll(list);
list2.add("Java与模式");
//输出
System.out.println(list2);
//删除list2中的元素
boolean remove = list2.remove("计算机网络");
System.out.println("是否已经删除《计算机网络》：" + remove);
System.out.println(list2);
//删除list2中list集合
remove = list2.removeAll(list);
System.out.println("是否已经删除list集合中的东西：" + remove);
System.out.println(list2);
}
}
效果：
[计算机网络, 现代系统技术, JSP技术开发详解, Java编程思想]
[Java入门到精通, 计算机网络, 现代系统技术, JSP技术开发详解, Java编程思想, Java与模式]
是否已经删除《计算机网络》：true
[Java入门到精通, 现代系统技术, JSP技术开发详解, Java编程思想, Java与模式]
是否已经删除list集合中的东西：true
[Java入门到精通, Java与模式]

2.2.3 修改

import java.util.ArrayList;
import java.util.Collection;
public class AddDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//新建对象
Collection list = new ArrayList();
//添加元素
list.add("计算机网络");
list.add("现代系统技术");
list.add("JSP技术开发详解");
list.add("Java编程思想");
//输出
System.out.println("集合中的内容" + list);
//清空了
list.clear();
System.out.println("集合中的内容" + list);
}
}
效果：
集合中的内容[计算机网络, 现代系统技术, JSP技术开发详解, Java编程思想]
集合中的内容[]

2.2.4 判断

import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//新建对象
Collection list = new ArrayList();
Collection list2 = new ArrayList();
//添加元素
list.add("计算机网络");
list.add("现代系统技术");
list.add("JSP技术开发详解");
list.add("Java编程思想");
//输出
System.out.println("集合中的内容" + list);
boolean empty = list.isEmpty();
//判断
System.out.println("集合list是空的吗：" + empty);
System.out.println("集合list2是空的吗：" + list2.isEmpty());
boolean containers  = list.contains("Java编程思想");
//判断
System.out.println("集合list中有Java编程思想吗：" + containers);
//为list2添加元素
list2.add("Java编程300例");
boolean containersAll = list.containsAll(list2);
//判断
System.out.println("集合list中包含所有集合list2的元素吗？" + containersAll);
}
}
效果：
集合中的内容[计算机网络, 现代系统技术, JSP技术开发详解, Java编程思想]
集合list是空的吗：false
集合list2是空的吗：true
集合list中有Java编程思想吗：true
集合list中包含所有集合list2的元素吗？false

2.2.5 获取

import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//新建对象
Collection list = new ArrayList();
//添加元素
list.add("计算机网络");
list.add("现代系统技术");
list.add("JSP技术开发详解");
list.add("Java编程思想");
//输出
System.out.println("集合中的内容" + list);
int size = list.size();
//获取长度
System.out.println("集合list中的元素有" + size + "个");
}
}
效果：
集合中的内容[计算机网络, 现代系统技术, JSP技术开发详解, Java编程思想]
集合list中的元素有4个

练习：集合中添加自定义元素

1）

import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo2 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Person p1 = new Person("张三",18);
Person p2 = new Person("李四",20);
Person p3 = new Person("五五",25);
//创建集合
Collection coll = new ArrayList();
//添加元素
coll.add(p1);
coll.add(p2);
coll.add(p3);
boolean isEmpty = coll.isEmpty();
//判断集合是否为空
System.out.println("容器coll里有元素吗：" + isEmpty);
int size = coll.size();
//查看集合元素数
System.out.println("容器里有多少个元素：" + size);
boolean containers = coll.contains(p1);
//判断某元素是否存在
System.out.println("容器里有P1吗：" + containers);
boolean isDelete = coll.remove(p1);
//判断某元素是否已删除
System.out.println("删除p1成功吗：" + isDelete);
System.out.println(coll);
//清空容器里的元素
coll.clear();
System.out.println("容器里还有多个元素：" + coll.size());
}
}
//集合的元素
class Person{
private String name;
private int 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;
}
public Person(String name, int age) {
super();
this.name = name;
this.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;
}
public Person() {
super();
// TODO Auto-generated constructor stub
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
@Override
public String toString() {
return "Person [age=" + age + ", name=" + name + "]";
}
}
效果：
容器coll里有元素吗：false
容器里有多少个元素：3
容器里有P1吗：true
删除p1成功吗：true
[Person [age=20, name=李四], Person [age=25, name=五五]]
容器里还有多个元素：0

2）

import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo3 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Collection coll = new ArrayList();
coll.add(new Book("java编程思想",100));
coll.add(new Book("JSP开发技术",69));
System.out.println(coll);
}
}
class Book{
private String name;
private double price;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public Book() {
super();
// TODO Auto-generated constructor stub
}
public Book(String name, double price) {
super();
this.name = name;
this.price = price;
}
@Override
public String toString() {
return "Book [name=" + name + ", price=" + price + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
long temp;
temp = Double.doubleToLongBits(price);
result = prime * result + (int) (temp ^ (temp >>> 32));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Book other = (Book) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (Double.doubleToLongBits(price) != Double
.doubleToLongBits(other.price))
return false;
return true;
}
}
效果：
[Book [name=java编程思想, price=100.0], Book [name=JSP开发技术, price=69.0]]

2.3 List

2.3.1 List特有方法

2.3.2 代码实例

增加

import java.util.ArrayList;
import java.util.List;
public class ListAdd {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//新建集合
List list = new ArrayList();
List list2 = new ArrayList();
//向集合1添加元素
list.add("计算机网络");
list.add("Java编程思想");
list.add("JSP开发技术详解");
list.add("Java与模式");
//输出
System.out.println("集合里的元素：" + list);
//在集合1指定位置添加元素
list.add(0,"Java从入门到精通");
System.out.println("集合里的元素：" + list);
//往集合2添加元素
list2.add("HTML技术详解");
list2.add("JavaScript开发");
//把集合1插到集合2指定位置
boolean addAll = list2.addAll(1,list);
System.out.println("添加集合list成功：" + addAll);
//输出
System.out.println(list2);
}
}
效果：
集合里的元素：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
集合里的元素：[Java从入门到精通, 计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
添加集合list成功：true
[HTML技术详解, Java从入门到精通, 计算机网络, Java编程思想, JSP开发技术详解, Java与模式, JavaScript开发]

删除

import java.util.ArrayList;
import java.util.List;
public class ListDelete {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//新建集合
List list = new ArrayList();
//向集合1添加元素
list.add("计算机网络");
list.add("Java编程思想");
list.add("JSP开发技术详解");
list.add("Java与模式");
//输出
System.out.println("集合里的元素：" + list);
//删除下标为1的元素
Object o = list.remove(1);
//返回删除的元素
System.out.println(o);
//输出
System.out.println("集合里的元素：" + list);
}
}
效果：
集合里的元素：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
Java编程思想
集合里的元素：[计算机网络, JSP开发技术详解, Java与模式]

修改

import java.util.ArrayList;
import java.util.List;
public class ListUpdate {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//新建集合
List list = new ArrayList();
//向集合1添加元素
list.add("计算机网络");
list.add("Java编程思想");
list.add("JSP开发技术详解");
list.add("Java与模式");
//输出
System.out.println("集合里的元素：" + list);
//返回被替代的元素
Object o = list.set(2, "Java项目开发");
//打印被替代的元素
System.out.println(o);
//输出
System.out.println("集合中的元素：" + list);
}
}
效果：
集合里的元素：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
JSP开发技术详解
集合中的元素：[计算机网络, Java编程思想, Java项目开发, Java与模式]

查找

import java.util.ArrayList;
import java.util.List;
public class ListSearch {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//新建集合
List list = new ArrayList();
//向集合1添加元素
list.add("计算机网络");
list.add("Java编程思想");
list.add("JSP开发技术详解");
list.add("Java与模式");
//输出
System.out.println("集合里的元素有：" + list);
Object o = list.get(list.size() -1);
System.out.println("查找的元素是：" + o);
System.out.println("集合里的元素有：" + list);
int lastIndex = list.lastIndexOf("Java与模式");
System.out.println("java与模式的下标为：" + lastIndex);
int index = list.indexOf("Java从入门到精通");
if(index != -1){
System.out.println("Java从入门到精通的下标是：" + index);
}else{
System.out.println("集合中没有Java从入门到精通这本书");
}
}
}
效果：
集合里的元素有：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
查找的元素是：Java与模式
集合里的元素有：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
java与模式的下标为：3
集合中没有Java从入门到精通这本书

求子集合

import java.util.ArrayList;
import java.util.List;
public class ListSub {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//新建集合
List list = new ArrayList();
//向集合1添加元素
list.add("计算机网络");
list.add("Java编程思想");
list.add("JSP开发技术详解");
list.add("Java与模式");
//输出
System.out.println("集合里的元素有：" + list);
int formIndex = 1 ;
//不包括下标为3的元素
int toIndex = 3;
//返回子集合
List subList = list.subList(formIndex,toIndex);
System.out.println("集合list下标从" + formIndex + "到" + toIndex + "的子集合是：" + subList);
}
}
效果：
集合里的元素有：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
集合list下标从1到3的子集合是：[Java编程思想, JSP开发技术详解]

2.4 ArrayList

2.4.1 实现原理

数组实现，查找快，增删慢

ArrayList是数组实现的，在增和删时会涉及到数组扩容，以及拷贝元素，所以会比较慢，但是数组可以直接按索引查找，所以查找时较快。

练习：去除ArrayList集合中重复的元素

import java.util.ArrayList;
public class ArrayListDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//新建集合
ArrayList arr = new ArrayList();
//往集合arr中添加元素
arr.add(new Person("小明",20));
arr.add(new Person("小东",40));
arr.add(new Person("小方",10));
arr.add(new Person("小圆",30));
arr.add(new Person("小明",20));
//输出集合的元素
System.out.println("集合arr中的元素有：" + arr);
//新建集合
ArrayList list = new ArrayList();
for(int i = 0 ; i < arr.size(); i ++){
Object o = arr.get(i);
Person p = (Person)o;
//若重复则不添加
if(!(list.contains(p))){
list.add(p);
}
}
System.out.println("集合list中的元素：" + list);
}
}
//集合对象
class Person{
private String name;
private int 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;
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Person() {
super();
// TODO Auto-generated constructor stub
}
@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 == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
@Override
public String toString() {
return "Person [age=" + age + ", name=" + name + "]";
}
}
效果：
集合arr中的元素有：[Person [age=20, name=小明], Person [age=40, name=小东], Person [age=10, name=小方], Person [age=30, name=小圆], Person [age=20, name=小明]]
集合list中的元素：[Person [age=20, name=小明], Person [age=40, name=小东], Person [age=10, name=小方], Person [age=30, name=小圆]]

注：在实际开发中ArrayList是使用频率最高的一种集合

2.5 LinkedList

因为LinkedList的底层是链表实现的，增加时只要让前一个元素记住自己即可，删除时让前一个元素记住后一个，但查询时需要一个一个遍历，所以效率低。

2.5.1 LiskedList特有方法

2.5.2 ArrayList和LinkedList的存储查找的优缺点

1）ArrayList是采用动态数组来存储元素的，它允许直接用下标来直接查找对应的元素，但是，插入元素涉及数据元素移动及内存的操作。总结：查找速度快，插入操作慢。

2）LinkedList是采用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度快。

2.6 Vector

相关：

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

ArrayList : 单线程效率高。

Vector : 多线程安全的，所以效率低。

特有方法

2.6.1 Enumeration接口

实现 Enumeration 接口的对象，它生成一系列元素，一次生成一个。连续调用

nextElement

方法将返回一系列的连续元素。

主要方法



代码实现

import java.util.Enumeration;
import java.util.Vector;
public class VectorDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Vector v = new Vector();
v.addElement("Java入门与精通");
v.addElement("Java编程思想");
v.addElement("Java与模式");
System.out.println("集合v中的元素有：" + v);
System.out.println("集合v下标为2的元素是：" + v.elementAt(2));
Enumeration e = v.elements();
while(e.hasMoreElements()){
System.out.println(e.nextElement());
}
}
}
效果：
集合v中的元素有：[Java入门与精通, Java编程思想, Java与模式]
集合v下标为2的元素是：Java与模式
Java入门与精通
Java编程思想
Java与模式

2.7 迭代器

为了方便处理集合中的元素，Java中出现了一个对象，该对象提供了一些方法专门处理集合中的元素---就是迭代器。

Collection接口中定义了获取集合类的迭代器方法（iterator()），所有Collection体系集合都可以获取自身的迭代器。

2.8 Iterable

Collection的父接口，实现了Iteratable的类就可迭代的，并且支持增强for循环。该接口只有一个方法即获取迭代器的方法Iterator()可以获取每个容器自身的迭代器Iterator。(Collection)集合容器都需要获取迭代器（Iterator）.

Collection接口都继承了Iterable，所以Collection体系都具备获取自身迭代器的方法。

该接口仅有一个方法，用于返回集合迭代对象。

2.8.1 Iterator

Iterator iterator()返回集合的迭代器对象。



Iterator接口定义的方法



迭代遍历

代码实例

1）while循环

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class WhileDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//新建集合
ArrayList list = new ArrayList();
//向集合1添加元素
list.add("计算机网络");
list.add("Java编程思想");
list.add("JSP开发技术详解");
list.add("Java与模式");
//输出
System.out.println("集合里的元素：" + list);
//新建迭代器
Iterator it = list.iterator();
//判断集合是否有元素
while(it.hasNext()){
//输出集合中的元素
System.out.println(it.next());
}
}
}
输出:
集合里的元素：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
计算机网络
Java编程思想
JSP开发技术详解
Java与模式

2）for循环

import java.util.ArrayList;
import java.util.Iterator;
public class ForDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//新建集合
ArrayList list = new ArrayList();
//向集合1添加元素
list.add("计算机网络");
list.add("Java编程思想");
list.add("JSP开发技术详解");
list.add("Java与模式");
//输出
System.out.println("集合里的元素：" + list);
//实在说我没有看明白这个循环
for(Iterator it = list.iterator();it.hasNext();){
System.out.println(it.next());
}
}
}
输出：
集合里的元素：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
计算机网络
Java编程思想
JSP开发技术详解
Java与模式

3）使用迭代器清空集合

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class RemoveDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Collection list = new ArrayList();
//向集合1添加元素
list.add("计算机网络");
list.add("Java编程思想");
list.add("JSP开发技术详解");
list.add("Java与模式");
//输出
System.out.println("集合里的元素：" + list);
Iterator it = list.iterator();
while(it.hasNext()){
it.next();
it.remove();
}
System.out.println("集合里的元素：" + list);//输出
}
}
输出：
集合里的元素：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
集合里的元素：[]
注：
1）如果迭代器的指针已经指向了集合的末尾，那么再调用next()会返回NoSuchElementException异常；
2）如果调用remove之前没有调用next()是不合法的，会抛出IllegalStateException异常
3）对集合进行迭代过程中，不允许出现迭代器以外的对元素的操作，因为这样会产生安全隐患，java会抛出异常并发修改异常（ConcurrentModificationException），普通迭代器只支持在迭代过程中删除动作。

2.8.2 List特有的迭代器ListIterator

ListIterator接口的方法



ListIterator在它的父类的基础上增加了（add(obj)）和修改（set(obj)）的操作。

List在迭代时，可以进行此两项操作。

倒序遍历

import java.util.ArrayList;
import java.util.ListIterator;
public class PreviousDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList list = new ArrayList();
list.add("计算机网络");                     //向集合1添加元素
list.add("Java编程思想");
list.add("JSP开发技术详解");
list.add("Java与模式");
System.out.println("集合里的元素：" + list);//输出
ListIterator lil = list.listIterator();                      //使用ListIterator使用迭代对象
while(lil.hasNext()){                                 //用next的方法输出元素
System.out.println(lil.next());
}
System.out.println("*************************************");
while(lil.hasPrevious()){                                 //用previous的方法输出元素
System.out.println(lil.previous());
}
}
}
输出：
集合里的元素：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
计算机网络
Java编程思想
JSP开发技术详解
Java与模式
*************************************
Java与模式
JSP开发技术详解
Java编程思想
计算机网络

Set方法

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

import java.util.ArrayList;
import java.util.ListIterator;
public class SetDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList list = new ArrayList();
//向集合1添加元素
list.add("计算机网络");
list.add("Java编程思想");
list.add("JSP开发技术详解");
list.add("Java与模式");
//输出
System.out.println("集合里的元素：" + list);
//使用ListIterator使用迭代对象
ListIterator lil = list.listIterator();
System.out.println(lil.next());
//将上一个next()输出的元素替换掉
lil.set("如何快速学Java");
//输出
System.out.println("集合里的元素：" + list);
}
}
输出：
集合里的元素：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
计算机网络
集合里的元素：[如何快速学Java, Java编程思想, JSP开发技术详解, Java与模式]

Add方法
将指定元素插入列表，该元素直接插入到next()返回的元素的后面。

import java.util.ArrayList;
import java.util.ListIterator;
public class AddDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList list = new ArrayList();
//向集合1添加元素
list.add("计算机网络");
list.add("Java编程思想");
list.add("JSP开发技术详解");
list.add("Java与模式");
//输出
System.out.println("集合里的元素：" + list);
//使用ListIterator使用迭代对象
ListIterator lil = list.listIterator();
System.out.println(lil.next());
//在计算机网络后插入了元素
lil.add("21天学通C语言");
//输出
System.out.println("集合里的元素：" + list);
}
}
输出：
集合里的元素：[计算机网络, Java编程思想, JSP开发技术详解, Java与模式]
计算机网络
集合里的元素：[计算机网络, 21天学通C语言, Java编程思想, JSP开发技术详解, Java与模式]

----------- android培训、java培训、java学习型技术博客期待与您交流！ ------------