Day28：chp10集合框架的练习题

编程入门行业动态更新时间:2024-10-09 18:26:09

Day28：chp10集合框架的<a href=https://www.elefans.com/category/jswz/34/1768594.html style= 练习题"/>

Day28：chp10集合框架的练习题

Chp10 集合框架
Key Point
Collection 接口、Set 接口、List 接口基本操作 List 接口及其实现类 Set 接口及其实现类迭代遍历
Hash 算法与 hashCode 方法
Comparable 接口
Map 接口及其实现类遍历 Map 泛型
练习

填空
Collection 接口的特点是元素是_对象_______；
List 接口的特点是元素___有__（有|无）顺序，可以__（可以|不可以）重复；
Set 接口的特点是元素__无___（有|无）顺序，不可以__（可以|不可以）重复；
Map 接口的特点是元素是__键值对<key,value>________，其中__值value___可以重复，__键key______不可以重复。
（List）有如下代码 import java.util.*;
public class TestList{
public static void main(String args[]){ List list = new ArrayList(); list.add(“Hello”); list.add(“World”); list.add(1, “Learn”); list.add(1, “Java”); printList(list);
}
public static void printList(List list){
//1
}
}
要求：

把//1 处的代码补充完整，要求输出 list 中所有元素的内容
for (Object object : list) {
System.out.println(object);
}
写出程序执行的结果
Hello
Java
Learn
World
如果要把实现类由 ArrayList 换为 LinkedList，应该改哪里？
List list = new LinkedList();
ArrayList 和 LinkedList 使用上有什么区别？
ArrayList是实现了长度可变的数组；LinkedList则是采用链表存储方式。
实现上有什么区别？
ArrayList遍历元素和随机访问元素的效率比较高，插入元素后会影响后边的元素；
LinkedList插入、删除元素时效率比较高，插入元素后只会影响左右元素。
如果要把实现类由 ArrayList 换为 Vector，应该改哪里？ArrayList 和 Vector 使用上有什么区？实现上有什么区？
Vector和ArrayList在使用上非常相似,都可用来表示一组数量可变的对象应用的集合,并且可以随机地访问其中的元素。
1 Vector的方法都是同步的(Synchronized),是线程安全的(thread-safe)，而ArrayList的方法不是，由于线程的同步必然要影响性能，因此,ArrayList的性能比Vector好。
2 当Vector或ArrayList中的元素超过它的初始大小时,Vector会将它的容量翻倍,而ArrayList只增加50%的大小，这样,ArrayList就有利于节约内存空间。

（List）写出下面程序的运行结果
import java.util.*; public class TestList{
public static void main(String args[]){ List list = new ArrayList(); list.add(“Hello”); list.add(“World”); list.add(“Hello”); list.add(“Learn”); list.remove(“Hello”); list.remove(0);
for(int i = 0; i<list.size(); i++){
System.out.println(list.get(i));
}
}
}
Hello
Learn
（Set，List） import java.util.*; public class TestListSet{
public static void main(String args[]){ List list = new ArrayList(); list.add(“Hello”); list.add(“Learn”); list.add(“Hello”); list.add(“Welcome”); Set set = new HashSet(); set.addAll(list);
System.out.println(set.size());
}
}
选择正确答案
A．编译不通过
B．编译通过，运行时异常
C．编译运行都正常，输出3 D．编译运行都正常，输出4
（List）已知有一个 Worker 类如下： public class Worker {
private int age;
private String name; private double salary; public Worker (){}
public Worker (String name, int age, double salary){ this.name = name; this.age = age; this.salary = salary;
}
public int getAge() { return age;
}
public void setAge(int age) { this.age = age;
}
public String getName() { return name;
}
public void setName(String name) { this.name = name;
}

public double getSalary(){ return salary;
}

public void setSalary(double salary){ this.salary = salary;
}
public void work(){
System.out.println(name + “ work”);
}
}
完成下面的要求

创建一个 List，在 List 中增加三个工人，基本信息如下：姓名年龄工资 zhang3 18 3000 li4 25 3500 wang5 22 3200
在 li4 之前插入一个工人，信息为：姓名：zhao6，年龄：24，工资 3300
删除 wang5 的信息
利用 for 循环遍历，打印 List 中所有工人的信息
利用迭代遍历，对 List 中所有的工人调用 work 方法。
ArrayList list = new ArrayList();
list.add(new Worker(“zhang3”, 18, 3000));
list.add(new Worker(“li4”, 25, 3500));
list.add(new Worker(“wang5”, 18, 3200));
list.add(1, new Worker(“zhao6”, 24, 3300)); list.remove(3);
for (Worker worker : list) {
System.out.println(worker.getName() + “–” + worker.getAge() + “–” + worker.getSalary());
}
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
iterator.next().work();
}
为 Worker 类添加 equals 方法
public boolean equals(Worker w) {
if (w.name == name && w.salary == salary && w.age == age) {
return true;
} else
return false;
}

（Set，Hash 算法）为上一题的 Worker 类，在添加完 equals 方法的基础上，添加一个 hashCode 方法。
public int hashCode(){
//1
}
有几种写法：
1） return 0;
2） int result = 0;
if (name != null) result = name.hashCode(); return result + age;
3） return super.hashCode();
现在要把 Worker 类放入 HashSet 中，并希望在 HashSet 中没有重复元素，则下面说法正确的是： A. 三种写法都正确
B. 1), 2)写法正确，2)效率更高
C. 2)写法正确，1),3)写法都不正确
（Set，Hash 算法，方法覆盖）代码改错
import java.util.*; class Worker{ String name; int age; double salary;

public Worker(){}
public Worker(String name, int age, double salary){ this.name = name; this.age = age; this.salary = salary;
}

public int hashCode(){
return (int)name.hashCode() + age + salary;
}

public boolean equals(Worker w){
if (w.name == name && w.salary == salary && w.age == age){ return true;
}else return false;
}
}
public class TestWorker{
public static void main(String args[]){ Set set = new HashSet(); set.add(new Worker(“tom”, 18, 2000)); set.add(new Worker(“tom”, 18, 2000)); set.add(0, new Worker(“jerry”, 18, 2000));
System.out.println(set.size());
}
}

（Set，Hash 算法）在前面的 Worker 类基础上，为 Worker 类增加相应的方法，使得 Worker 放入 HashSet 中时，Set 中没有重复元素。并编写相应的测试代码。
public class Worker {
private int age;
private String name;
private double salary;

public int hashCode() {
return (int)(name.hashCode() + age + salary);
}

public boolean equals(Worker w) {
if (w.name == name && w.salary == salary && w.age == age) {
return true;
} else
return false;
}

public Worker() {
}

public Worker(String name, int age, double salary) {
this.name = name;
this.age = age;
this.salary = salary;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public double getSalary() {
return salary;
}

public void setSalary(double salary) {
this.salary = salary;
}

public void work() {
System.out.println(name + “work”);
}
}
（Set，Comparable 接口）在前面的 Worker 类基础上，为 Worker 类添加相应的代码，使得 Worker 对象能正确放入 TreeSet 中。并编写相应的测试代码。
注：比较时，先比较工人年龄大小，年龄小的排在前面。如果两个工人年龄相同，则再比较其收入，收入少的排前面。如果年龄和收入都相同，则根据字典顺序比较工人姓名。例如：有三个工人，基本信息如下：
姓名年龄工资
zhang3 18 1500
li4 18 1500
wang5 18 1600
zhao6 17 2000
放入 TreeSet 排序后结果为： zhao6 li4 zhang3 wang5
import java.text.Collator;
import java.util.Locale;

public class Worker implements Comparable {
private int age;
private String name;
private double salary;

@Override
public int compareTo(Worker o) {if(o.getAge() != this.getAge()) {return this.getAge()-o.getAge();}else if (o.getSalary() != this.getSalary()) {return (int)(this.getSalary()-o.getSalary());}else {Collator instance = Collator.getInstance(Locale.CHINA);return instancepare(this.getName(), o.getName());}
}public String toString() {return name;
}public int hashCode() {return (int)(name.hashCode() + age + salary);
}public boolean equals(Worker w) {if (w.name == name && w.salary == salary && w.age == age) {return true;} elsereturn false;
}public Worker() {
}public Worker(String name, int age, double salary) {this.name = name;this.age = age;this.salary = salary;
}public int getAge() {return age;
}public void setAge(int age) {this.age = age;
}public String getName() {return name;
}public void setName(String name) {this.name = name;
}public double getSalary() {return salary;
}public void setSalary(double salary) {this.salary = salary;
}public void work() {System.out.println(name + "work");
}

}

public static void main(String[] args) {

// Comparator comparator = new Comparator() {
//
// @Override
// public int compare(Worker o1, Worker o2) {
// if(o1.getAge() != o2.getAge()) {
// return o1.getAge()-o2.getAge();
// }else if (o1.getSalary() != o2.getSalary()) {
// return (int)(o1.getSalary()-o2.getSalary());
// }else {
// Collator instance = Collator.getInstance(Locale.CHINA);
// return instancepare(o1.getName(), o2.getName());
// }
// }
// };
//
//
// TreeSet hs = new TreeSet(comparator);//实现比较器
TreeSet hs = new TreeSet();//实现接口
// HashSet hs = new HashSet();//无序，不能比较
hs.add(new Worker(“zhang3”, 18, 1500));
hs.add(new Worker(“li4”, 18, 1500));
hs.add(new Worker(“wang5”, 18, 1600));
hs.add(new Worker(“zhao6”, 17, 2000));

	System.out.println(hs.size());System.out.println(hs);
}

（Map）关于下列 Map 接口中常见的方法 put 方法表示放入一个键值对，如果键已存在则___新值替换旧值_____，如果键不存在则
增加一个键值对______。
remove 方法接受_一__个参数，表示__从映射中移除其映射关系的键__。
get 方法表示____返回指定键所映射的值___，get 方法的参数表示___移除的其映射关系的键___，返回值表示__与key关联的值___。要想获得 Map 中所有的键，应该使用方法__keySet____，该方法返回值类型为_Set集合__。要想获得 Map 中所有的值，应该使用方法__get__，该方法返回值类型为_指定键所映射的值__。要想获得 Map 中所有的键值对的集合，应该使用方法_entrySet__，该方法返回一个
__Map.Entry__类型所组成的 Set。
（Map）利用 Map，完成下面的功能：
从命令行读入一个字符串，表示一个年份，输出该年的世界杯冠军是哪支球队。如果该年没有举办世界杯，则输出：没有举办世界杯。
附：世界杯冠军以及对应的夺冠年份，请参考本章录。
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Order11 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String year = sc.next();

	Map<String, String> map =new HashMap<String, String>();map.put("2002", "巴西");map.put("2006", "意大利");map.put("2010", "南非");if(map.containsKey(year)) {System.out.println(map.get(year));}else {System.out.println("没有举办世界杯~");}
}

}
12. （Map）已知某学校的教学课程内容安排如下：
老师课程
Tom CoreJava
John Oracle
Susan Oracle
Jerry JDBC
Jim Unix
Kevin JSP
Lucy JSP
完成下列要求：
1）使用一个 Map，以老师的名字作为键，以老师教授的课程名作为值，表示上述课程安排。
2）增加了一位新老师 Allen 教 JDBC
3） Lucy 改为教 CoreJava
4）遍历 Map，输出所有的老师及老师教授的课程
5） *利用 Map，输出所有教 JSP 的老师。
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Order12 {
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put(“Tom” , “CoreJava” );
map.put(“John” , “Oracle” );
map.put(“Susan” , “Oracle” );
map.put(“Jerry” , “JDBC” );
map.put(“Jim” , “Unix” );
map.put(“Kevin” , “JSP” );
map.put(“Lucy” , “JSP” );
map.size();

	map.put( "Allen","JDBC");map.size();map.remove("Lucy");map.put("Lucy" ,	"CoreJava" );Set<String> set = map.keySet();for (String string : set) {System.out.println(string + "--" +map.get(string));}for (String string : set) {if(map.get(string).equals("JSP")) {System.out.println("教JSP的老师有：" + string);}}
}

}
13. （泛型）使用泛型，改写第 5 题
见上边第五题
14. （泛型）使用泛型和 Map.Entry 接口，改写第 12 题的前 4 问
Set<Entry<String, String>> entrySet = map.entrySet();
for (Entry<String, String> entry : entrySet) {
System.out.println(entry);
}
15. （List）写出下面程序的输出结果
import java.util.; class MyClass{ int value; public MyClass(){}
public MyClass(int value){ this.value = value; } public String toString(){ return “”+value;
}
}
public class TestList{
public static void main(String args[]){ MyClass mc1 = new MyClass(10);
MyClass mc2 = new MyClass(20);
MyClass mc3 = new MyClass(30); List list = new ArrayList(); list.add(mc1); list.add(mc2); list.add(mc3);
MyClass mc4 = (MyClass) list.get(1); mc4.value = 50;
for(int i = 0; i<list.size(); i++){
System.out.println(list.get(i));
}
}
}
10
50
30
16. （Set，HashSet，空指针）有下面代码 import java.util.; class Student { int age; String name; public Student(){}
public Student(String name, int age){ this.name = name; this.age = age;
}
public int hashCode(){ return name.hashCode() + age;
}
public boolean equals(Object o){ if (o == null) return false; if (o == this) return true;
if (o.getClass() != this.getClass()) return false; Student stu = (Student) o;
if (stu.name.equals(name) && stu.age == age) return true; else return false;
}
}
public class TestHashSet{
public static void main(String args[]){
Set set = new HashSet();
Student stu1 = new Student();
Student stu2 = new Student(“Tom”, 18); Student stu3 = new Student(“Tom”, 18); set.add(stu1); set.add(stu2); set.add(stu3);
System.out.println(set.size()); }
}

下列说法正确的是：
A. 编译错误
B. 编译正确，运行时异常
java.lang.NullPointerException
C. 编译运行都正确，输出结果为3
D. 编译运行都正确，输出结果为2

*（Set）有如下两个类（只写了类的属性，请自行添加相应的构造方法和 get/set 方法）

Worker
name : String age : int salary : double address : Address

Address
addressName : String zipCode : String

要求，完善 Worker 和 Address 类，使得 Worker 对象能够正确放入 HashSet 中：即将 Worker 放入 HashSet 中时不会出现重复元素。并编写相应测试代码。
import java.util.HashSet;

public class Order17 {
private String name;
private int age;
private double salary;
private Address address;

public Order17() {super();
}
public Order17(String name, int age, double salary, Address address) {super();this.name = name;this.age = age;this.salary = salary;this.address = address;
}
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 double getSalary() {return salary;
}
public void setSalary(double salary) {this.salary = salary;
}
public Address getAddress() {return address;
}
public void setAddress(Address address) {this.address = address;
}@Override
public int hashCode() {return (int)(name.hashCode() + age + salary);
}
@Override
public boolean equals(Object obj) {Order17 worker = (Order17)obj;if (worker.name == name && worker.salary == salary && worker.age == age) {return true;} else {return false;}
}
public static void main(String[] args) {HashSet<Order17> worker = new HashSet<Order17>();Address address1 = new Address("北京故宫", "000000");worker.add(new Order17("张三", 18, 8000, address1));Address address2 = new Address("北京故宫", "000000");worker.add(new Order17("张三", 18, 8000, address2));System.out.println(worker.size());
}

}

class Address{
private String addressName;
private String zipCode;

public Address() {super();
}
public Address(String addressName, String zipCode) {super();this.addressName = addressName;this.zipCode = zipCode;
}
public String getAddressName() {return addressName;
}
public void setAddressName(String addressName) {this.addressName = addressName;
}
public String getZipCode() {return zipCode;
}
public void setZipCode(String zipCode) {this.zipCode = zipCode;
}

}
18. *（Map）在原有世界杯 Map 的基础上，增加如下功能：读入一支球队的名字，输出该球队夺冠的年份列表。
例如，读入“巴西”，应当输出
1958 1962 1970 1994 2002
读入“荷兰”，应当输出没有获得过世界杯
String country = sc.next();
boolean flag = false;
for (Entry<String, String> entry : map.entrySet()) {
if(entry.getValue().equals(country)) {
flag = true;
System.out.println(entry.getKey());
}
}
if(!flag) {
System.out.println(“没有举办世界杯~”);
}
19. *（Map）设计 Account 对象如下：
Account
id : Long balance : double password : String

要求完善设计，使得该 Account 对象能够自动分配 id。

给定一个 List 如下：
List list = new ArrayList(); list.add(new Account(10.00, “1234”)); list.add(new Account(15.00, “5678”)); list.add(new Account(0, “1010”)); 要求把 List 中的内容放到一个 Map 中，该 Map 的键为 id，值为相应的 Account 对象。
最后遍历这个 Map，打印所有 Account 对象的 id 和余额。
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.Set;

public class Order19 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(new Account(10.00, “1234”));
list.add(new Account(15.00, “5678”));
list.add(new Account(0, “1010”));
Map<Long, Account> map = new HashMap<Long, Account>();
for(int i=0; i<list.size(); i++) {
Account account = (Account)list.get(i);
map.put(account.getId(), account);
}
Set<Map.Entry<Long, Account>> set = map.entrySet();
for (Map.Entry<Long, Account> entry : set) {
System.out.println(entry.getKey() + “–>” + entry.getValue().getBalance());
}
}
}

class Account{
private long id;
private double balance;
private String password;

public Account() {
}
public Account(double balance, String password) {this.id = new Random().nextLong();this.balance = balance;this.password = password;
}
public long getId() {return id;
}
public void setId(long id) {this.id = id;
}
public double getBalance() {return balance;
}
public void setBalance(double balance) {this.balance = balance;
}
public String getPassword() {return password;
}
public void setPassword(String password) {this.password = password;
}

}
20. *（List）写一个函数 reverseList，该函数能够接受一个 List，然后把该 List 倒序排列。
例如：
List list = new ArrayList(); list.add(“Hello”); list.add(“World”);
list.add(“Learn”); //此时list为Hello World Learn reverseList(list);
//调用reverseList方法之后，list为Learn World Hello
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Order20 {
public static void main(String[] args) {
List list = new ArrayList();
list.add(“Hello”);
list.add(“World”);
list.add(“Learn”);

	Order20 test = new Order20();test.reverseList(list);}
public void reverseList(List<String> list) {Collections.reverse(list);for (String string : list) {System.out.println(string);}
}

}
21. **（Map，Hash 算法）有如下代码：
import java.util.*;
class MyKey{ int keyValue; public MyKey(){}
public MyKey(int value){this.keyValue = value;}
} class MyValue{ String value; public MyValue(){}
public MyValue(String value){this.value = value;} public String toString(){return value;}
}
public class TestMap{
public static void main(String args[]){
Map map = new HashMap(); MyKey key1 = new MyKey(10); map.put(key1, new MyValue(“abc”)); map.put(new MyKey(10), new MyValue(“cde”));
System.out.println(map.get(key1));
System.out.println(map.size());
}
} 写出该代码的输出果。
abc
2

**（Id，hashCode，equals）为 Worker 类增加 id 属性，用来唯一标识一个员工。即：如果员工的 id 不同，则不管其姓名、年龄、工资是否相同，都认为是不同的员工。部分代码如下：
class Worker{ private final Long id; private String name; private double salary; private int age;
//构造方法…

//get/set方法…

public boolean equals(Object obj){
//1此处仅判断id是否相同
}

public int hashCode(){
//2此处返回hashCode
}
}
要求：
1）完善构造方法和 get/set 方法。要求自动分配 Worker 的 id
2）完善 equals 方法。要求仅判断 id 是否相同
3） //2 处，如果写成
return (int)(name.hashCode() + id.hashCode() + age + salary); 是否正确？为什么？
import java.util.HashSet;

public class Order22 {
public static void main(String[] args) {
HashSet hs = new HashSet();//实现接口
hs.add(new Worker22(“zhang3”, 1500, 18));
hs.add(new Worker22(“zhang3”, 1500, 18));
hs.add(new Worker22(“wang5”, 1600, 18));
hs.add(new Worker22(“zhao6”, 2000, 17));

	System.out.println(hs.size());System.out.println(hs);
}

}

class Worker22{
private final Long id = 0L;
static Long Number = 1L;
private String name;
private double salary;
private int age;

@Override
public String toString() {return "Worker22 [id=" + getId() + ", name=" + name + ", salary=" + salary + ", age=" + age + "]" + "\n";
}public boolean equals(Worker22 w){if (w.getId() == getId()) {return true;} else {return false;}
}public int hashCode(){ return (int) (name.hashCode() + /* id.hashCode() + */age + salary);
}public Worker22() {
}
public Worker22(String name, double salary, int age) {this.name = name;this.salary = salary;this.age = age;
}
public String getName() {return name;
}
public void setName(String name) {this.name = name;
}
public double getSalary() {return salary;
}
public void setSalary(double salary) {this.salary = salary;
}
public int getAge() {return age;
}
public void setAge(int age) {this.age = age;
}
public Long getId() {return id + Number++;
}

}

**（综合）有如下 Student 对象
Student
name : String age : int score : double classNum : String

其中，classNum 表示学生的班号，例如“class05”。
有如下 List
List list = new ArrayList();
list.add(new Student(“Tom”, 18, 100, “class05”)); list.add(new Student(“Jerry”, 22, 70, “class04”)); list.add(new Student(“Owen”, 25, 90, “class05”)); list.add(new Student(“Jim”, 30,80 , “class05”)); list.add(new Student(“Steve”, 28, 66, “class06”)); list.add(new Student(“Kevin”, 24, 100, “class04”));

在这个 list 的基础上，完成下列要求： 1）计算所有学生的平均年龄
2）计算各个班级的平均分
import java.util.ArrayList;
import java.util.List;

public class Order23 {
public static void main(String[] args) {
List list = new ArrayList();
list.add(new Student23(“Tom”, 18, 100, “class05”));
list.add(new Student23(“Jerry”, 22, 70, “class04”));
list.add(new Student23(“Owen”, 25, 90, “class05”));
list.add(new Student23(“Jim”, 30, 80, “class05”));
list.add(new Student23(“Steve”, 28, 66, “class06”));
list.add(new Student23(“Kevin”, 24, 100, “class04”));

	double sum = 0;for (Student23 student23 : list) {sum += student23.getScore();}System.out.println("所有学生平均分为：" + sum/list.size());double sum04 = 0;int num04 = 0;double sum05 = 0;int num05 = 0;double sum06 = 0;int num06 = 0;for (Student23 student23 : list) {if(student23.getClassNum().equals("class04")) {sum04 += student23.getScore();num04++;}else if (student23.getClassNum().equals("class05")) {sum05 += student23.getScore();num05++;}else if (student23.getClassNum().equals("class06")) {sum06 += student23.getScore();num06++;}}System.out.println("class04学生平均分为：" + sum04/num04);System.out.println("class05学生平均分为：" + sum05/num05);System.out.println("class06学生平均分为：" + sum06/num06);
}

}

class Student23 {
private String name;
private int age;
private double score;
private String classNum;

public Student23() {
}public Student23(String name, int age, double score, String classNum) {this.name = name;this.age = age;this.score = score;this.classNum = classNum;
}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 double getScore() {return score;
}public void setScore(double score) {this.score = score;
}public String getClassNum() {return classNum;
}public void setClassNum(String classNum) {this.classNum = classNum;
}

}
24. **（综合）已知有十六支男子足球队参加 2008 北京奥运会。写一个程序，把这 16 支球队随机分为 4 个小组。注：参赛球队列表见附录注 2：使用 Math.random 来产生随机数。

**（综合）写一个 MyStack 类，表示“栈”这种数据结构。
栈在表示上，就如同一个单向开口的盒子，每当有新数据进入时，都是进入栈顶。其基本操作为 push 和 pop。push 表示把一个元素加入栈顶，pop 表示把栈顶元素弹出。
示意图如下：
栈的特点：先进后出。
栈的基本操作：
1） push(Object o)：表示把元素放入栈
2） Object pop()：返回栈顶元素，并把该元素从栈中删除。如果栈为空，则返回
null 值
3） Object peek()：返回栈顶元素，但不把该元素删除。如果栈为空，则返回 null 值。
4） boolean isEmpty()：判断该栈是否为空
5） int size()：返回该栈中元素的数量要求：
1）利用 List，实现栈。
2）讨论：应当用 ArrayList 作为实现类还是用 LinkedList？为什么？

附录

截止到 2009 年为止，历届世界杯冠军
届数年份冠军
18 2006 意大利
17 2002 巴西
16 1998 法国
15 1994 巴西
14 1990 德国
13 1986 阿根廷
12 1982 意大利
11 1978 阿根廷
10 1974 德国
9 1970 巴西
8 1966 英格兰
7 1962 巴西
6 1958 巴西
5 1954 德国
4 1950 乌拉圭
3 1938 意大利
2 1934 意大利
1 1930 乌拉圭
2008 北京奥运会男足参赛国家：
科特迪瓦，阿根廷，澳大利亚，塞尔维亚，荷兰，尼日利亚、日本，美国，中国，新西兰，巴西，比利时，韩国，喀麦隆，洪都拉斯，意大利