【JavaSE学习笔记】集合_Collection,List

集合

Collection

1）概述

集合：按照一个规则，对一个数组进行排序，针对不同的需求，不同的做法

由于有不同的功能，并且他们的数据结构不同，他们集合之间有共性内容，向上抽取

就会形成----->集合继承体现图

Collection层次结构中的根接口，Collection表示一组对象，这些对象也称为collection的元素

一些collection允许有重复的元素，而另一些则不允许

一些 collection 是有序的，而另一些则是无序的

JDK不提供此接口的任何直接实现：它提供更具体的子接口（set,List等）实现

2）添加功能的相关方法

boolean add(Object obj)：添加一个元素（基本功能）

import java.util.ArrayList;
import java.util.Collection;

// 测试类
public class Demo01 {
public static void main(String[] args) {
// 创建集合对象
Collection c = new ArrayList();

//空集合
System.out.println(c);// []
// 返回值是boolean类型，添加即输出true
c.add("hello");
c.add("world");

System.out.println(c);// [hello, world]
}
}

boolean addAll(Collection c)：添加一个集合中的元素（高级功能）

import java.util.ArrayList;
import java.util.Collection;

public class Demo02 {
public static void main(String[] args) {
// 创建两个集合对象
Collection c1 = new ArrayList();
c1.add(1);
c1.add(2);
c1.add(3);
c1.add(4);

Collection c2 = new ArrayList();
c2.add(5);
c2.add(6);
c2.add(7);
c2.add(8);
System.out.println("原始数据：");
System.out.println("c1：" + c1);// [1, 2, 3, 4]
System.out.println("c2：" + c2);// [5, 6, 7, 8]
System.out.println("-----------------");

System.out.println("添加后的数据：");
c1.addAll(c2);
System.out.println("c1：" + c1);// c1：[1, 2, 3, 4, 5, 6, 7, 8]
}
}

3）删除功能的相关方法

boolean remove(Object o)：删除指定的元素

import java.util.ArrayList;
import java.util.Collection;

// 测试类
public class Demo01 {
public static void main(String[] args) {
// 创建集合对象
Collection c = new ArrayList();

c.add("hello");
c.add("world");
c.add("java");
// 原始数据
System.out.println("原始数据：");
System.out.println(c);// [hello, world, java]
System.out.println("----------------------");

c.remove("world");
System.out.println("删除后：");
System.out.println(c);// [hello, java]

}
}

boolean removeAll(Collection c)：删除一个集合中的元素

（思考：删除一个元素算是删除呢还是删除所有算是删除?）

import java.util.ArrayList;
import java.util.Collection;

public class Demo02 {
public static void main(String[] args) {
// 创建两个集合对象
Collection c1 = new ArrayList();
c1.add(1);
c1.add(2);
c1.add(3);
c1.add(4);
c1.add(5);
c1.add(6);
c1.add(7);
c1.add(8);

Collection c2 = new ArrayList();
c2.add(5);
c2.add(6);
c2.add(7);
c2.add(8);
System.out.println("原始数据：");
System.out.println("c1：" + c1);// c1：[1, 2, 3, 4, 5, 6, 7, 8]
System.out.println("c2：" + c2);// c2：[5, 6, 7, 8]
System.out.println("-----------------");

// 删除一个就算删除
System.out.println(c1.removeAll(c2));// true
System.out.println("删除后的数据：");
System.out.println("c1：" + c1);// c1：[1, 2, 3, 4]
}
}

void clear()：删除一个集合中的所有元素（不建议使用）

import java.util.ArrayList;
import java.util.Collection;

// 测试类
public class Demo01 {
public static void main(String[] args) {
// 创建集合对象
Collection c = new ArrayList();

c.add("hello");
c.add("world");
c.add("java");
// 原始数据
System.out.println("原始数据：");
System.out.println(c);// [hello, world, java]
System.out.println("----------------------");

c.clear();
System.out.println("删除后：");
System.out.println(c);// []
}
}

4）判断功能的相关方法

boolean contains(Object o)：判断该集合中是否包含指定的元素

import java.util.ArrayList;
import java.util.Collection;

// 测试类
public class Demo01 {
public static void main(String[] args) {
// 创建集合对象
Collection c = new ArrayList();

c.add("hello");
c.add("world");
c.add("java");
// 原始数据
System.out.println("原始数据：");
System.out.println(c);// [hello, world, java]
System.out.println("----------------------");

System.out.println(c.contains("web"));// false
System.out.println(c.contains("world"));// true
}
}

boolean containsAll(Collection o)：判断是否包含一个集合中的所有元素

(思考：包含一个算是包含,还是包含所有元素算术包含?)

import java.util.ArrayList;
import java.util.Collection;

public class Demo02 {
public static void main(String[] args) {
// 创建两个集合对象
Collection c1 = new ArrayList();
c1.add(1);
c1.add(2);
c1.add(3);
c1.add(4);
c1.add(5);
c1.add(6);
c1.add(7);
c1.add(8);

Collection c2 = new ArrayList();
c2.add(5);
c2.add(6);
c2.add(7);
c2.add(8);
System.out.println("原始数据：");
System.out.println("c1：" + c1);// c1：[1, 2, 3, 4, 5, 6, 7, 8]
System.out.println("c2：" + c2);// c2：[5, 6, 7, 8]
System.out.println("-----------------");

// 包含所有才算是包含
System.out.println(c1.containsAll(c2));// true
}
}

boolean isEmpty()：判断集合是否为空

import java.util.ArrayList;
import java.util.Collection;

// 测试类
public class Demo01 {
public static void main(String[] args) {
// 创建集合对象
Collection c = new ArrayList();

c.add("hello");
c.add("world");
c.add("java");
// 原始数据
System.out.println("原始数据：");
System.out.println(c);// [hello, world, java]
System.out.println("----------------------");

System.out.println(c.isEmpty());// false
}
}

5）长度功能：

int size()：集合长度

import java.util.ArrayList;
import java.util.Collection;

// 测试类
public class Demo01 {
public static void main(String[] args) {
// 创建集合对象
Collection c = new ArrayList();

c.add("hello");
c.add("world");
c.add("java");
// 原始数据
System.out.println("原始数据：");
System.out.println(c);// [hello, world, java]
System.out.println("----------------------");

System.out.println(c.size());// 3
}
}

面试题:

数组中有没有length()方法?String类有没有length()方法?集合中有没有length()方法?

数组：length属性

字符换String：length()

集合：size()

6）交集功能

boolean retainAll(Collection c)：对一个集合取交集

（思考：返回值类型表达的是什么意思?交集的元素去哪里?）

import java.util.ArrayList;
import java.util.Collection;

public class Demo02 {
public static void main(String[] args) {
// 创建两个集合对象
Collection c1 = new ArrayList();
c1.add(1);
c1.add(2);
c1.add(3);
c1.add(4);
c1.add(5);
c1.add(6);
c1.add(7);
c1.add(8);

Collection c2 = new ArrayList();
c2.add(5);
c2.add(6);
c2.add(7);
c2.add(8);
System.out.println("原始数据：");
System.out.println("c1：" + c1);// c1：[1, 2, 3, 4, 5, 6, 7, 8]
System.out.println("c2：" + c2);// c2：[5, 6, 7, 8]
System.out.println("-----------------");

/*
 *A集合对B集合取交集
 *交集的元素要去A集合中
 *返回值类型表达的意思是：A集合的元素发生改变，则为true 
 */
System.out.println("c1对c2取交集");
System.out.println(c1.retainAll(c2));// true
System.out.println("c1：" + c1);// c1：[5, 6, 7, 8]
System.out.println("c2：" + c2);// c2：[5, 6, 7, 8]
}
}

7）集合转换功能

Object[] toArray()：把集合转换成数组

import java.util.ArrayList;
import java.util.Collection;

// 测试类
public class Demo01 {
public static void main(String[] args) {
// 需求：使用集合存储字符串类型
Collection c = new ArrayList();

c.add("hello");
c.add("world");
c.add("java");

// 为了遍历集合中的元素：使用集合普通的方法：toArray()
Object[] obj = c.toArray();

// 得到数组，遍历数组
for (int i = 0; i < obj.length; i++) {
// 输出字符串本身和字符串长度
// Object代表任何类，String类是Object的一个子类，要使用子类的特有功能,向下转型
String s = (String) obj[i];// 向下转型
System.out.println(s + "---" + s.length());
/*
 * hello---5
 * world---5
 * java---4
 */
}
}
}

8）迭代器

Iterator iterator()：表示对集合中的元素进行迭代（遍历）

Iterator：接口

Object next()：返回迭代的下一个元素（获取元素）

boolean hasNext()：如果仍有元素可以迭代，返回true

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

// 测试类
public class Demo01 {
public static void main(String[] args) {
Collection c = new ArrayList();

c.add("hello");
c.add("world");
c.add("java");

// 获取迭代器对象
Iterator it = c.iterator();// 多态的形式：接口多态
while (it.hasNext()) {
String s = (String) it.next();
// 返回的类型是Object类型,想要得到字符串的长度:Obect转成String类型
System.out.println(s + "---" + s.length());
/*
 * hello---5 
 * world---5 
 * java---4
 */
}
}
}

问题:使用集合的迭代器方式进行遍历用的是while循环的方式,可以使用for循环吗?

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

// 测试类
public class Demo01 {
public static void main(String[] args) {
Collection c = new ArrayList();

c.add("hello");
c.add("world");
c.add("java");

// 获取迭代器对象
for (Iterator it = c.iterator(); it.hasNext();) {
// 先向下转型
String s = (String) it.next();
System.out.println(s + "---" + s.length());
}
}
}

9）细节：

it.next()不要多次使用!只使用一次即可(自定义引用类型)

多次使用会创建多个对象    NoSuchElementException:

10）迭代器的原码

interface Iterator{
boolean hasNext();
Object next();
}

public interface Iterable {
Iterator iterator();
}

public interface Collection extends Iterable{
 public Iterator<E> iterator() {
        return new Itr(); //Itr:类
    }

     //具体的类  :内部类的另一种形式
     private class Itr implements Iterator { //Itr是Iterator接口的子实现类

      public boolean hasNext() {//重写了hasNext()
            return cursor != size;
        }

     public Object next() {

     }
     }
}
collection c = new ArrayList();
c.add("hello");
c.add("world");
c.add("java");
Iterator it = c.iterator();//Iterator it = new Itr() ;//接口多态(开发中经常用)
while(it.hasNext){
String s = (String)it.next();
System.out.println(s);
}

11）面试题

集合和数组的区别？

1.长度的区别：

数组：长度是固定的

集合：可变的

2.存储数据类型的区别：

数组：基本/引用数据类型

集合：引用数据类型

3.存储类型的元素的区别：

数组：存储的是同一种数据类型的元素

集合：可存放多种类型的元素

List

1）概述

List集合是Collection集合的子接口，里面iterator()方法在List中也可用

接口与接口是继承的关系

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

// 测试类
public class Demo01 {
public static void main(String[] args) {
// 创建集合对象
List l = new ArrayList();

// 给集合中添加元素，添加功能都是Collection接口中的功能
l.add("hell");
l.add("world");
l.add("java");

// 获取迭代器
Iterator it = l.iterator();
// 遍历
while (it.hasNext()) {
String s = (String) it.next();
System.out.println(s);
/*
 * hell 
 * world 
 * java
 */
}
}
}

2）List集合是一个有序的集合，是可以有重复的元素

有序：指的是元素存储和取出是一致的

set集合：是另一个接口：元素不能重复

treeSet

hashSet

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

// 测试类
public class Demo01 {
public static void main(String[] args) {
// 创建集合对象
List l = new ArrayList();

// 给集合中添加元素，添加功能都是Collection接口中的功能
l.add("hell");
l.add("world");
l.add("java");
l.add("hell");
l.add("world");
l.add("java");

// 获取迭代器
Iterator it = l.iterator();
// 遍历
while (it.hasNext()) {
String s = (String) it.next();
System.out.println(s);
/*
 * hell 
 * world 
 * java 
 * hell 
 * world 
 * java
 */
}
System.out.println(l);// [hell, world, java, hell, world, java]
}
}

3）特有功能

void add(int index, Object element)：添加功能：在指定位置添加指定元素

import java.util.ArrayList;
import java.util.List;

// 测试类
public class Demo01 {
public static void main(String[] args) {
List l = new ArrayList();

l.add("hello");
l.add("world");
l.add("java");

System.out.println("原始数据：");
System.out.println(l);// [hello, world, java]
System.out.println("--------------------");

System.out.println("添加后的数据：");
l.add(1, "web");
System.out.println(l);// [hello, web, world, java]
// System.out.println(11, "web");//IndexOutOfBoundsException:角标越界
}
}

Object get(int index)：获取功能：获取指定位置的元素

import java.util.ArrayList;
import java.util.List;

// 测试类
public class Demo01 {
public static void main(String[] args) {
List l = new ArrayList();

l.add("hello");
l.add("world");
l.add("java");

System.out.println("原始数据：");
System.out.println(l);// [hello, world, java]
System.out.println("--------------------");

System.out.println(l.get(1));// world
}
}

Object remove(int index)：删除功能：删除指定位置的元素,返回的就是删除的元素

// 测试类
public class Demo01 {
public static void main(String[] args) {
List l = new ArrayList();

l.add("hello");
l.add("world");
l.add("java");

System.out.println("原始数据：");
System.out.println(l);// [hello, world, java]
System.out.println("--------------------");

System.out.println("删除数据：");
System.out.println(l.remove(1));// world
System.out.println("删除后的数据：");
System.out.println(l);// [hello, java]
}
}

Object set(int index, objict element)：将指定位置的元素用element该元素替代，返回的是需要被替代的元素

import java.util.ArrayList;
import java.util.List;

// 测试类
public class Demo01 {
public static void main(String[] args) {
List l = new ArrayList();

l.add("hello");
l.add("world");
l.add("java");

System.out.println("原始数据：");
System.out.println(l);// [hello, world, java]
System.out.println("--------------------");
System.out.println("替换后的数据：");
l.set(1, "web");
System.out.println(l);// [hello, web, java]
}
}

4）不用迭代器遍历集合

import java.util.ArrayList;
import java.util.List;

// 测试类
public class Demo01 {
public static void main(String[] args) {
List l = new ArrayList();

l.add("hello");
l.add("world");
l.add("java");

/*
 * 两种方式
 * 1)Iterator iterator()  （上面出现好多次，不再讲述）
 * 2)普通for循环
 * size() get()相结合
 */
//普通for循环
for (int i = 0; i < l.size(); i++) {
String s = (String) l.get(i);
System.out.println(s);
}
}
}

5）List集合专有迭代遍历方式

ListIterator listIterator();

ListIterator接口：

boolean hasNext()：表示正向遍历：是否有下一个可以迭代的元素

Object next()：获取下一个元素

boolean hasPrevious：表示逆向遍历：是否有上一个可以迭代的元素

Object previous()：返回列表中的前一个元素

有个顺序问题：要想使用逆向遍历，必须先正向遍历，否则没意义

List集合有3种便利方式：

迭代器遍历方式替代掉普通for(get()/size()相结合)

迭代器遍历

Iterator iterator()

ListIterator listiterator():列表迭代器

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

// 测试类
public class Demo01 {
public static void main(String[] args) {
List l = new ArrayList();

l.add("hello");
l.add("world");
l.add("java");

ListIterator li = l.listIterator();
//正向遍历
while (li.hasNext()) {
String s = (String) li.next();
System.out.println(s);
}
System.out.println("-------------------");

//逆向遍历
while (li.hasPrevious()) {
String s = (String) li.previous();
System.out.println(s);
}
}
}

6）需求

给List存储字符串,判断如果这个字符串是"world",然后给集合中添加一个新的 字符串"javaee"

java.util.ConcurrentModificationException:并发修改异常!
产生并发修改异常的原因是什么:
当我们给集合中添加了新的字符串,迭代器不知道集合中是否添加了一个新的元素,所以产生这个异常
描述：迭代器依赖于集合存在,给集合中添加元素,要么就是通过迭代器去做;要么就是通过集合遍历(普通for),通过集合添加

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

// 测试类
public class Demo01 {
public static void main(String[] args) {
List l = new ArrayList();

l.add("hello");
l.add("world");
l.add("java");

//遍历集合中的元素,使用迭代器遍历
//Iterator it = l.iterator() ;
//while(it.hasNext()){//迭代器遍历
//String s = (String) it.next() ;
//判断,如果worold字符串,给集合中添加"javaee"
//if(s.equals("world")){
//l.add("javaee") ;//集合去添加,迭代器并不知道
//}
//}
//System.out.println(l);

//两种解决并发修改异常的方式:
//1)使用迭代器遍历,迭代器添加,Iterator接口没有添加功能,所有使用列表迭代器:ListIterator
//获取列表迭代器
//ListIterator lit = l.listIterator() ;
//while(lit.hasNext()){
//String s = (String) lit.next() ;
////判断,迭代器添加
//if(s.equals("world")){
////列表迭代器的特有功能
//lit.add("javaee");//插入元素:在指定元素插入新的元素
//}
//}
//System.out.println("list:"+list);

//2)使用集合遍历,使用集合添加
for(int i = 0; i < l.size(); i ++){
String s = (String)l.get(i);
//判断有world,采用集合添加,在末尾添加
if (s.equals("world")) {
l.add("javaee");
}
}
System.out.println(l);// [hello, world, java, javaee]
}
}

7）List子类的特点

ArrayList

底层数据结构是数组，查询快，增删慢，线程不安全，不同步，效率高

vector

底层数据结构是数组，查询快，增删慢，线程安全，同步，效率低

LinkedList

底层数据结构是链表，查询慢，增删快，线程不安全，不同步，效率高

应用场景：ArrayList:开发中用的非常多。如果给一个需求,不知道使用谁的时候,都使用ArrayList

8）栈和队列的特点

9）ArrayList

a.List集合的子类遍历集合中的元素可以使用的任何迭代遍历方式

普通for循环，，，，iterator()

import java.util.ArrayList;
import java.util.Iterator;

// 测试类
public class Demo01 {
public static void main(String[] args) {
//创建ArrayList集合对象
ArrayList al = new ArrayList();

//给集合中添加元素
al.add("hello");
al.add("world");
al.add("java");

//使用普通for循环
for (int i = 0; i < al.size(); i++) {
String s = (String) al.get(i);
System.out.println(s);
}
System.out.println("----------------------");

//使用迭代器
Iterator i = al.iterator();
while (i.hasNext()) {
String s = (String) i.next();
System.out.println(s);
}
}
}

b.存储对象并遍历

//Student类（本章后面不再写此类，直接调用）

public class Student {
private String name;
private int age;

public Student() {
super();
// TODO Auto-generated constructor stub
}

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 + "]";
}

}

//测试类

import java.util.ArrayList;
import java.util.Iterator;

// 测试类
public class Demo01 {
public static void main(String[] args) {
ArrayList al = new ArrayList();

// 创建四个学生对
Student s1 = new Student("张三", 20);
Student s2 = new Student("李四", 21);
Student s3 = new Student("王五", 22);
Student s4 = new Student("程六", 23);

//给集合中添加元素
al.add(s1);
al.add(s2);
al.add(s3);
al.add(s4);

//使用迭代器遍历
Iterator i = al.iterator();
while (i.hasNext()) {
Student s = (Student) i.next();
System.out.println(s);
}
}
}

10）LinkedList集合特有功能

添加相关的方法

public void addFirst(Object e):添加此列表的第一个元素

public void addLast(Object e):添加此列表的最后一个元素

import java.util.LinkedList;

// 测试类
public class Demo01 {
public static void main(String[] args) {
LinkedList ll = new LinkedList();

ll.add("hello");
ll.add("world");
ll.add("java");

System.out.println("原始数据：" + ll);// [hello, world, java]
ll.addFirst("First");
ll.addLast("Last");
System.out.println("添加后：" + ll);// [First, hello, world, java, Last]
}
}

和获取相关的方法:

public Object getFirst()返回此列表的第一个元素

public Object getLast():返回此列表的最后一个元素

import java.util.LinkedList;

// 测试类
public class Demo01 {
public static void main(String[] args) {
LinkedList ll = new LinkedList();

ll.add("hello");
ll.add("world");
ll.add("java");

System.out.println("原始数据：" + ll);// [hello, world, java]
System.out.println("第一个数据：" + ll.getFirst());// hello
System.out.println("最后一个数据：" + ll.getLast());// java
}
}

和删除相关的方法:

public Object removeFirst():删除此列表的第一个元素

public Object removeLast():删除此列表的最后一个元素

import java.util.LinkedList;

// 测试类
public class Demo01 {
public static void main(String[] args) {
LinkedList ll = new LinkedList();

ll.add("hello");
ll.add("world");
ll.add("java");

System.out.println("原始数据：" + ll);// [hello, world, java]
ll.removeFirst();
ll.removeLast();
System.out.println("删除后的数据：" + ll);// [world]
}
}

11）Vector特有功能

public void addElement(Object obg):给Vector集合中添加元素

public  Object elementAt(int index):获取指定索引处的元素

public Enumeration elements():获取迭代器对象

boolean hasMoreElements():判断是否有下一个可以迭代的元素

Object nextElement():获取下一个迭代的元素

import java.util.Enumeration;
import java.util.Vector;

// 测试类
public class Demo01 {
public static void main(String[] args) {
Vector v = new Vector();

v.addElement("hello");
v.addElement("world");
v.addElement("java");

for (int i = 0; i < v.size(); i++) {
String s = (String) v.elementAt(i);
System.out.println(s);
}
System.out.println("-----------------");

Enumeration en = v.elements();
while (en.hasMoreElements()) {
String s = (String) en.nextElement();
System.out.println(s);
}
}
}

12）练习

ArrayList去除集合中字符串的重复值(字符串的内容相同)

1)创建一个集合对象
2)给集合中添加字符串元素.包括重复
3)创建新的集合对象
4)遍历旧集合
         获取每一个元素后,进行判断(判断新集合中是否包含这些元素)
         没有这些元素,说明不重复,添加到新集合
5)遍历新集合

import java.util.ArrayList;
import java.util.Iterator;

// 测试类
public class Demo01 {
public static void main(String[] args) {
ArrayList al = new ArrayList();

al.add("hello");
al.add("world");
al.add("java");
al.add("hello");
al.add("world");
al.add("java");
al.add("hello");
al.add("world");
al.add("java");

//创建新的集合对象
ArrayList al2 = new ArrayList();

//遍历旧集合
Iterator i = al.iterator();
while (i.hasNext()) {
String s = (String) i.next();
//判断新集合中是否包含这些元素
if (!al2.contains(s)) {
al2.add(s);
}
}
//遍历新集合
Iterator i2 = al2.iterator();
while (i2.hasNext()) {
String s = (String) i2.next();
System.out.println(s);
}
}
}

13）针对上一条，若不允许建立集合如何让去完成

import java.util.ArrayList;
import java.util.Iterator;

// 测试类
public class Demo01 {
public static void main(String[] args) {
ArrayList al = new ArrayList();

al.add("hello");
al.add("world");
al.add("java");
al.add("hello");
al.add("world");
al.add("java");
al.add("hello");
al.add("world");
al.add("java");

/*
 * 可以才排序的方式进行排序,用第一个索引和后面的依次比较 
 * 然后如果前面的索引对应的元素怒和后面的索引对应的元素相等,说明重复,那么删除
 */
for (int i = 0; i < al.size() - 1; i++) {
for (int j = i + 1; j < al.size(); j++) {
if (al.get(i).equals(al.get(j))) {
al.remove(j);
j--;
}
}
}
// 迭代器遍历
Iterator i = al.iterator();
while (i.hasNext()) {
String s = (String) i.next();
System.out.println(s);
}
}
}

14）练习

ArrayList去除集合Student对象的重复的成员信息(成员变量的值是一样)

首先在Student类中重写equals()

//重写

@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) 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;
}

//测试类

import java.util.ArrayList;
import java.util.Iterator;

// 测试类
public class Demo01 {
public static void main(String[] args) {
/*
 * 现在集合存储的是引用类型的对象,而一个类的对象,有一个equals()方法
 * 如果不重写,默认用Object中的equals()
 * 默认比较的是地址值;在Student类中重写equals方法,比较是内容是否相同
 */
ArrayList al = new ArrayList();

Student s1 = new Student("张三", 20);
Student s2 = new Student("张三", 20);
Student s3 = new Student("李四", 21);
Student s4 = new Student("李四", 22);
Student s5 = new Student("王五", 20);

al.add(s1);
al.add(s2);
al.add(s3);
al.add(s4);
al.add(s5);

ArrayList al2 = new ArrayList();

Iterator i = al.iterator();
while (i.hasNext()) {
Student s = (Student) i.next();
if (!al2.contains(s)) {
al2.add(s);
}
}

Iterator i2 = al2.iterator();
while (i2.hasNext()) {
Student s = (Student) i2.next();
System.out.println(s);
}
}
}