黑马程序员——Collection

最新推荐文章于 2015-10-11 15:49:29 发布

Synchronized_2015

最新推荐文章于 2015-10-11 15:49:29 发布

阅读量325

点赞数

分类专栏： java基础学习笔记

本文链接：https://blog.csdn.net/Synchronized_2015/article/details/47980885

版权

java基础学习笔记专栏收录该内容

10 篇文章 0 订阅

订阅专栏

------Java培训、Android培训、iOS培训、.Net培训学习型技术博客、期待与您交流！ -------

Collection

一. 概述:

1. Collection：是一个集合接口（集合类的一个顶级接口）。它提供了对集合对象进行基本操作的通用接口方法.

Collection 接口在Java 类库中有很多具体的实现，Collection接口的意义是为各种具体的集合提供了最大化的

统一操作方式，其直接继承接口有List与Set。

2. 集合的由来：java是一种面向对象语言，如果我们要针对多个对象进行操作，就必须对多个对象进行存储，

而对多个元素进行存储，前面我们学习过数组，数组的弊端，长度固定。这样，数组将不能满足变化的要求。

所以，java就提供了集合供我们使用.

二. Collection体系结构图：

三. Collection接口中的功能概述：

1、添加功能:

boolean add(Object obj): 向集合中添加一个元素。

boolean addAll(Collection c): 向集合中添加一个集合的元素。

2、删除功能

void clear():删除集合中所有的元素。

boolean remove(Object obj): 删除集合中指定的元素。

boolean removeAll(Collection c): 删除集合中指定的集合元素。只要有数据删除，则返回true。

3、判断功能

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

boolean contains(Object obj): 判断集合是否包含指定的元素。

boolean containsAll(Collection c): 判断集合是否包含指定的集合中的元素。只有所有数据包含了，才返回true。

4、遍历功能

Iterator iterator():迭代器。

hasNext（）: 判断是否还有元素

next(): 获取下一个元素

5、长度功能

int size():获得集合的元素个数。

6、交集功能

boolean retainAll(Collection c):判断集合中是否有相同的元素。

7、转换功能

Object[] toArray():把集合变成数组。

四. Collection功能小练习：

1、collection功能测试①：

package testdemo;

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

public class CollectionDemo {
	public static void main(String[] args) {
		// 创建对象
		// Collection c = new Collection();//接口不能被实例化,但是可以子类来实例化【多态】，<String> 先可以不写
		Collection<String> c = new ArrayList<String>();  
		
		// 1.添加元素
		// boolean add(Object obj):一个是添加，一个是返回添加是否成功。
		c.add("hello");
		c.add("world");
		c.add("java");
		
		// 2.判断功能
		//  boolean isEmpty() 判断集合是否为空
		System.out.println("isEmpty:" + c.isEmpty());
		// boolean contains(Object obj) 判断集合是否包含指定的元素。
		System.out.println("contains:" + c.contains("world"));
		System.out.println("contains:" + c.contains("wor"));
		
		// 3. 长度功能
		// int size()
		System.out.println("size:" + c.size());
		System.out.println("c:" + c);
		
		// 4. 把集合转换成数组
		//Object[] toArray(): 把集合变成数组
		Object[] strs=c.toArray();
		System.out.println(strs[0]);
		
		// 5. 删除功能
		// boolean remove(Object obj): 删除集合中指定的元素。
		// void clear()：删除集合中的所有元素。
		System.out.println("remove:" + c.remove("world"));
		System.out.println("remove:" + c.remove("wor"));
		c.clear();
		System.out.println("c.clear()删除之后:" + c);	
	}
}

运行结果如下:

2、collection功能测试②：

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

	/*
	 * 所有带All的方法：(不常用)
	 * boolean addAll(Collection c)：向集合中添加一个集合的元素。
	 * boolean removeAll(Collection c):从集合中删除一个指定的集合元素。 
	 * boolean containsAll(Collection c)：判断集合中是否存在指定的一个集合中的元素。
	 * boolean retainAll(Collection c):判断两个集合中是否有相同的元素。???
	 */
	public class CollectionDemo {
		public static void main(String[] args) {
			// 创建一个集合
			Collection<String> c1 = new ArrayList<String>();
			c1.add("abc1");
			c1.add("abc2");
			c1.add("abc3");
			c1.add("abc4");

			// 再创建一个集合
			Collection<String> c2 = new ArrayList<String>();
			c2.add("abc1");
			c2.add("abc2");
			c2.add("abc3");
			c2.add("abc4");
			c2.add("abc5");
			c2.add("abc6");
			c2.add("abc7");

			// boolean addAll(Collection c)：向集合中添加一个集合的元素。
			System.out.println("-------------");
			System.out.println("addAll:" + c1.addAll(c2));
			System.out.println("c1:"+c1);
			System.out.println("-------------");
			// boolean removeAll(Collection c):从集合中删除一个指定的集合元素。
			// 只要有数据被删除，则返回true。
			System.out.println("removeAll:" + c1.removeAll(c2));
			System.out.println("c1"+c1);
			System.out.println("-------------");
			// boolean containsAll(Collection c)：判断集合中是否存在指定的一个集合中的元素。
			// 只有所有数据包含了，才返回true
		    System.out.println("containsAll:" + c1.containsAll(c2));
		    System.out.println("-------------");
			// boolean retainAll(Collection c)
			/*
			 * 如果有两个集合A和B。
			 * A对B做交集。
			 * A集合保存的是交集元素。B集合不发生改变。
			 * 返回值表示的是A集合是否发生过改变。
			 */
			System.out.println("retainAll:" + c1.retainAll(c2));
			System.out.println("c1:" + c1);
			System.out.println("c2:" + c2);
			System.out.println("-------------");
		}
	}

运行结果如下：

五. Iterator 迭代器的使用步骤和案例：

1.Iterator的原理：

⑴. 迭代器：其实是集合的一种遍历（一个一个的获取元素）方法

⑵. 集合的使用步骤：

①. 创建集合对象

②. 创建元素对象

③. 把元素对象添加到集合对象中

④. 遍历集合对象

A：通过集合对象获取迭代器对象： Iterator it=c.iterator（）；

B:通过迭代器对象的hasNext（）方法进行判断；

C：通过迭代器对象的next（）方法进行获取；

2. Iterator小案例：

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

public class IteratorDemo {
	public static void main(String[] args) {
		// 创建对象
		Collection<String> c = new ArrayList<String>();

		// 添加元素
		c.add("hello");
		c.add("world");
		c.add("java");

		// 方式1
		Object[] objs = c.toArray();
		for (int x = 0; x < objs.length; x++) {
			String s = (String) objs[x];
			System.out.println(s);
		}
		System.out.println("------------------");
		// 方式2
		// Iterator iterator():就是用来获取集合中每一个元素。
		// 通过集合对象获取迭代器对象
		Iterator<String> it = c.iterator();// 这是返回的是Iterator的子类对象,多态
		while (it.hasNext()) { // it.hasNext():判断迭代器中是否还有元素。
		     String s = (String)it.next(); //it.next():获取元素,并自动移动到下一个位置等待获取
	         System.out.println(s);
		}
		System.out.println("------------------");
	}
}

运行结果如下:

List接口

一. List的介绍：

1. List：是Collection接口下的一个子接口

2. 特点：元素有序（指的是存储顺序和取出顺序是否一致），可重复

3. List的特有功能：

⑴. 添加功能：void add(int index,Object obj): 在指定位置添加元素。

⑵. 删除功能：Object remove(int index): 根据指定索引删除元素，并把删除的元素返回

⑶. 修改功能：Object set(int index,Object obj):把指定索引位置的元素修改为指定的值，返回修改前

的值。

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

②. int indexOf(Object obj): 返回指定元素在集合中第一次出现的索引。

③. ListIterator listIterator(): 列表迭代器

⑸. 截取功能：List subList( int fromIndex, int toIndex )截取集合。

4. List 功能练习:

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

class ListDemo {
	public static void main(String[] args) {
		// 创建集合对象    List接口 不能被实例化,但是可以子类来实例化【多态】，<String> 先可以不写
		List<String> list = new ArrayList<String>();

		// 1. 添加元素
		list.add("hello");
		list.add("world");
		list.add("java");

		// void add(int index, Object obj):在指定位置添加元素
		list.add(1, "javaEE");
		System.out.println("list:" + list);
		// IndexOutOfBoundsException 交表越界异常
		// list.add(14,"javaSE");

		//2. 删除元素
		// Object remove(int index):根据指定索引删除元素，并把删除的元素返回。
		System.out.println("remove:" + list.remove(1));
		System.out.println("list:" + list);
		System.out.println("-------------------");
		
		//3. 修改元素
		// Object set(int index, Object obj):把指定索引位置的元素修改为指定的值，返回修改前的值。
		System.out.println("set:" + list.set(1, "javaee"));
		System.out.println("list:" + list);
		System.out.println("-------------------");
		
        //4. 截取元素
		// List subList(int fromIndex, int toIndex)：截取集合。
		List list2 = list.subList(1, 2);
		System.out.println("list2:" + list2);
		System.out.println("-------------------");
		
		//5. 获取元素
		// int indexOf(Object o):返回指定元素在集合中第一次出现的索引
		System.out.println("indexOf--java:" + list.indexOf("java"));
		System.out.println("indexOf--java2:" + list.indexOf("java2"));
		System.out.println("list:" + list);
	}
}

运行结果如下:

5. ConcurrentModificationException并发修改异常【面试题】

ConcurrentModificationException : 这是个什么异常，怎么产生的，怎么解决的?

⑴. 怎么产生：

当我们通过迭代器迭代元素的过程中，又通过集合去添加了元素。这种情况是不允许的。
因为迭代器是依赖于集合存在的，如果集合发生改变，迭代器也应该相应的发生改变。
而我们目前看到的确实，迭代器没变，集合变了。所以，报出了一个并发修改异常。

⑵. 注意问题：

通过迭代器遍历集合的时候，是不能通过集合去操作(添加，删除)。

⑶. 解决方案：

A: 全部通过迭代器操作：元素是添加到刚遍历的那个元素后面。通过迭代器迭代的时候，可以通过迭代器对集合进行操作。

B: 全部通过集合操作：元素是添加到最后的。通过集合普通for遍历的时候，可以通过集合去操作。

⑷. 案例:

需求：请遍历集合，判断其中是否有"hello"这个元素，如果有，就再添加一个元素:"IOS"：

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

public class ListDemo {
	public static void main(String[] args) {
		// 创建集合对象
		List<String> list = new ArrayList<String>();

		// 添加元素
		list.add("hello");
		list.add("world");
		list.add("java");

		 //1. 完全通过集合实现
		 for (int x = 0; x < list.size(); x++) {
		 String s = (String) list.get(x);
		 if ("hello".equals(s)) {
		 list.add("IOS");
		 }
		 }
		 System.out.println("list:"+list);
		 System.out.println("-----------");

		// 2. 全部通过迭代器操
		ListIterator<String> lit = list.listIterator();
		while (lit.hasNext()) {
			String s = (String) lit.next();
			if ("hello".equals(s)) {
				lit.add("IOS");
			}
		}
		System.out.println("list:" + list);
	}
}

运行结果如下:

二. List的子类介绍：

1. List三个子类特点：

List
|--ArrayList
底层数据结构是数组，查询快，增删慢
线程不安全，效率高
|--Vector
底层数据结构是数组，查询快，增删慢
线程安全，效率低
|--LinkedList
底层数据结构是链表，查询慢，增删快
线程不安全，效率高

2. 案例：ArrayList存储自定义对象去重复
需求：ArrayList如果存储的是学生，那么，怎么去除重复元素呢？（如果学生的姓名和年龄相同，我就认为是同一个学生）

(1).ListDemo类:

package testdemo;

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

class ListDemo {
	public static void main(String[] args) {
		ArrayList<Student> array = new ArrayList<Student>();

		Student s1 = new Student("郑成功", 40);
		Student s2 = new Student("戚继光", 50);
		Student s3 = new Student("戚继光", 50);
		Student s4 = new Student("岳飞", 36);
		Student s5 = new Student("岳飞", 40);
		Student s6 = new Student("林则徐", 30);

		array.add(s1);
		array.add(s2);
		array.add(s3);
		array.add(s4);
		array.add(s5);
		array.add(s6);

		// 创建新集合
		ArrayList<Student> array2 = new ArrayList<Student>();

		// 遍历旧集合，获取到每一个元素
		Iterator<Student> it = array.iterator();
		while (it.hasNext()) {
			Student s = (Student) it.next();
			// 在新集合中判断，看是否存在这个元素
			if (!array2.contains(s)) {
				// 如果s不再array2中存在，就添加
				array2.add(s);
			}
		}

		// array2就是没有重复元素的集合。
		// 遍历array2
		for (int x = 0; x < array2.size(); x++) {
			Student s = (Student) array2.get(x);
			System.out.println(s.getName() + "***" + s.getAge());
		}
	}
}

(2).Student类:

package testdemo;

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

	public Student() {
		super();
	}

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

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

运行结果如下:

2. Vector的特有功能:

A：添加功能: void addElement( Object obj )

B：获取功能: (1). public Object elementAt( int index )

(2). public Enumeration elements()

(3). 类Enumeration里边有两个方法。（类似于迭代器）
boolean hasMoreElements()
Object nextElement()
(4). public int size()

C: 已经被ArrayList所代替,基本上很少用!

D：功能小练习：

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

	public class VectorDemo {
		public static void main(String[] args) {
			// 创建集合对象
			Vector<String> v = new Vector<String>();

			// 添加元素
			v.addElement("hello");
			v.addElement("world");
			v.addElement("java");

			// 遍历
			for (int x = 0; x < v.size(); x++) {
				String s = (String) v.elementAt(x);
				System.out.println(s);
			}
			
			System.out.println("----------------");
			
			//public Enumeration elements()
			Enumeration<String> en = v.elements();
			while(en.hasMoreElements()){
				String s = (String)en.nextElement();
				System.out.println(s);
			}
		}
	}

运行结果如下：

3. LinkedList的特有功能:

A：添加功能
void addFirst( Object o )：将指定元素插入此列表的开头。
void addLast( Object o )：将指定元素添加到此列表的结尾。
B：获取功能
Object getFirst()：获取列表第一个元素
Object getLast()：获取列表最后一个元素
C：删除功能
Object removeFirst()：删除列表第一个元素
Object removeLast()：删除列表最后一个元素

D：面试题：用LinkedList模拟栈数据结构

它的意思是说，你有一个LinkedList可以用，但是，你需要自己定义一个栈集合。
对外提供获取和添加功能。

（1）. 创建LinkedListTest类：

package testdemo;

public class LinkedListTest {
	public static void main(String[] args) {

		// 创建集合对象
		MyStack ms = new MyStack();

		// 创建并添加元素
		ms.add("hello");
		ms.add("world");
		ms.add("java");

		for (int x = 0; x < ms.size(); x++) {
			String s = (String) ms.get(x);
			System.out.println(s);
		}
	}
}

（2）. 创建LinkedListTest类：

package testdemo;

import java.util.LinkedList;

/*
 * 自定义栈集合。
 */
class MyStack {
	private LinkedList link;

	public MyStack() {
		link = new LinkedList();
	}

	public void add(Object obj) {
		link.addFirst(obj);
	}

	public Object get(int index) {
		return link.get(index);
	}

	public int size() {
		return link.size();
	}
}

运行结果如下：

Set接口

1. Set的特点:

元素无序，唯一。【注意和List的对比：元素有序（数据存储和取出顺序一致），可以重复】

注意：这里顺序是指存储和取出顺序。

2 HashSet:

(1). HashSet：不保证元素的迭代顺序。并且，不保证该顺序恒久不变。

(2). 怎么保证元素的唯一性?

--HashSet 底层数据结构是哈希表,它依赖两个方法：hashCode()、equals（）；

①. hashCode() ：首先，判断hashCode()值是否相同。【该值默认源码是和地址值相关的所以不

可能相同了，进而判断不了重复（因为都是new出来的对象）】为了提高效率【如果重写

hashcod 直接返回一个0，就必须挨个的比较每个对象的属性值效率低，而我们的hashcod

的本质是和成员的属性相关的，所以我的 hashcod值去所有元素的和字符串去 hashcod

的值。】比如： return this.name.hashcod+this.age*13+his.score*17; 而*13/17是为了

让hashcod的值更准确的不相同了.

②. 如果hashCode()的值相同了，继续走equals()方法，根据其返回值：来判断是否添加到集合。

--true：说明元素重复，不添加到集合。

--false：说明元素不重复，添加到集合。

③. 怎么重写hashCode()和equals()方法呢?
-- hashCode()：
把对象的所有成员变量值相加即可。如果是基本类型，就加值。如果是引用类型，就加哈希值。
public int hashCode()
{
return this.name.hashCode() + this.age*13 + this.sex*17 +this.score*21;
}
--equals()：
A：this==obj
B：!(obj instanceof Student)
C：所有成员变量的值比较。基本类型用==,引用类型用equals()。
④. 如果不会，eclipse()自动生成。

（3）. HashSet 存储自定义对象

--创建HashSetDemo2类：

package testdemo;

import java.util.HashSet;

public class HashSetDemo2 {
	public static void main(String[] args) {
		// 创建集合对象
		HashSet<Student> hs = new HashSet<Student>();

		// 创建元素对象
		Student s1 = new Student("林青霞", 26);
		Student s2 = new Student("张曼玉", 36);
		Student s3 = new Student("周慧敏", 20);
		Student s4 = new Student("林青霞", 26);
		Student s5 = new Student("林青霞", 66);
		Student s6 = new Student("林志玲", 16);

		// 添加元素
		hs.add(s1);
		hs.add(s2);
		hs.add(s3);
		hs.add(s4);
		hs.add(s5);
		hs.add(s6);

		// 遍历
		for (Student s : hs) {
			System.out.println(s.getName() + "***" + s.getAge());
		}
	}
}

--创建创建自定义类Student：

package testdemo;

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

	public Student() {
	}

	public Student(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;
	}

	@Override
	//重写hashCode()方法.
	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
	//重写equals()方法
	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;
	}

}

--运行结果如下：

3.TreeSet

（1）. 特点：

a、底层结构是二叉树。按照树节点进行存储和取出。

b、根据构造方法的不同，选择使用自然排序或者比较器排序。按照实际的需求，可以对元素进行排

序。并且保证唯一。

c、原理：二叉树保证元素唯一排序
①：第一个添加的数据作为根节点。
②：从第二个开始，每一个数据从根节点开始比较，如果大了，往右边放，如果小了，往左边

放，如果相同，替换。

③：原理图如下：

（2）. 两种实现方式：

①、自然排序：(元素具备比较性)-------对象所属类实现comparable接口重写了接口中的比较方法,

而具有了比较的功能,进而有了 "排序" 的功能。通过 TreeSet的无参构造，要求对象所属的

类实现 Comparable接口,重写comparable中的comparTo方法，定义自己的比较方法。

#重写compareTo（）方法：

#this.是将要判断存入的元素,s已经在集合中存在的元素 [负数往前方,整数往s的后面放,0不存放]
#由于对象有多个成员变量，你不能根据其中的某一个决定其他的。
#因此当某一个主要参数相同的时候，你还需要判断其他的是不是也是相同的。

public int compareTo( Studetn s )
{
// 需求：比较年龄
int num = this.age - s.age ;

//次要条件：
int num2 = ( num == 0 ) ? ( this.name.compareTo( s.name ) ) : num ;
return num2;
}

②、比较器排序：(集合具备比较性)----通过构造方法,传入构造器(实现了comparable接口的对象),

而具有了比较的功能,进而具备了排序的功能
#TreeSet的带参构造，要求构造方法接收一个实现了Comparator接口的对象。如下：
TreeSet<Student> ts = new TreeSet<Student> ( new Comparator<Student>
{
public int compare ( Student s1 , Student s2)
//其中s1是将要判断存入的元素,s2已经在集合中存在的元素[负数往前方,

整数往s2的后面放,0不存放]
{
//按照年龄排序，从小到大
int num = s1.getAge() - s2.getAge();
//次要条件
int num2 = ( num == 0 ) ? ( s1.getName().compareTo(s2.getName()) ) : num;
return num2;
}
} );

（3）. 案例：TreeSet存储自定义对象按照姓名长度排序：

①、自然排序：(元素具备比较性)-------对象所属类实现comparable接口重写compareTo（）

A：创建TreeSetDemo类：

package testdemo;
import java.util.TreeSet;

public class TreeSetDemo{
	public static void main(String[] args) {

		// 创建TreeSet集合 ts.
		TreeSet<Student> ts = new TreeSet<Student>();

		// 创建并添加元素
		ts.add(new Student("刘德华", 52));
		ts.add(new Student("成龙", 60));
		ts.add(new Student("周星驰", 44));
		ts.add(new Student("孙燕姿", 34));
		ts.add(new Student("林青霞", 26));
		ts.add(new Student("林青霞", 36));
		ts.add(new Student("林青", 26));
		ts.add(new Student("林青霞", 26));

		// 遍历
		for (Student s : ts) {
			System.out.println(s.getName() + "***" + s.getAge());
		}
	}
}

B：创建 Student 类：

package testdemo;

public class Student implements Comparable<Student> {
	private String name;
	private int age;

	public Student() {
	}

	public Student(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;
	}

	@Override
	public int compareTo(Student s) {
		// 姓名的长度
		int num = this.name.length() - s.name.length();
		// 很多时候，别人给我们的需求其实只是一个主要需要
		// 还有很多的次要需求是需要我们自己进行分析的。
		// 比较姓名的内容
		int num2 = (num == 0) ? (this.name.compareTo(s.name)) : num;
		// 继续分析，姓名长度和内容都相同的情况下，年龄还可能不一样呢?
		// 所以，当姓名长度和内容都相同的时候，我们在比较下年龄就好了
		int num3 = (num2 == 0) ? (this.age - s.age) : num2;
		return num3;
	}
}

C：运行结果如下：

②、比较器排序：(集合具备比较性)----通过构造方法,传入构造器(实现了comparable接口的对象)

A：创建TreeSetDemo类：

package testdemo;

import java.util.Comparator;
import java.util.TreeSet;

/*
 * 比较器接口 Comparator。带参构造。
 */
public class TreeSetDemo {
	public static void main(String[] args) {

		// 匿名内部类
		TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
			public int compare(Student s1, Student s2) {
				// 按年龄排序，从小到大
				int num = s1.getAge() - s2.getAge();
				// 次要条件
				int num2 = (num == 0) ? (s1.getName().compareTo(s2.getName())) : num;
				return num2;
			}
		});

		// 创建并添加元素对象
		ts.add(new Student("刘德华", 52));
		ts.add(new Student("成龙", 60));
		ts.add(new Student("周星驰", 44));
		ts.add(new Student("孙燕姿", 34));
		ts.add(new Student("林青霞", 26));
		ts.add(new Student("林青霞", 36));
		ts.add(new Student("林青", 26));
		ts.add(new Student("林青霞", 26));

		// 遍历
		for (Student s : ts) {
			System.out.println(s.getName() + "***" + s.getAge());
		}
	}
}

B：创建 Student 类：

package testdemo;

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

	public Student() {
	}

	public Student(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;
	}
}

C：运行结果如下：