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

最新推荐文章于 2025-07-22 20:35:27 发布

原创最新推荐文章于 2025-07-22 20:35:27 发布 · 387 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Collection #Iterator #List #ArrayList #Vector

JavaSE 专栏收录该内容

44 篇文章

订阅专栏

本文详细介绍了Java集合的基本概念、常用操作方法及其应用场景，包括添加、删除、判断、长度、交集等功能，同时对比了集合与数组的区别，深入探讨了List、Set等子接口的特点及其实现类的使用。

集合

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);
		}
	}
}