1.第一题 （Map）利用Map，完成下面的功能：
从命令行读入一个字符串，表示一个年份，输出该年的世界杯冠军是哪支球队。如果该 年没有举办世界杯，则输出：没有举办世界杯。
历届世界杯冠军
届数 举办年份 举办地点 冠军
第一届 1930年 乌拉圭 乌拉圭
第二届 1934年 意大利 意大利
第三届 1938年 法国 意大利
第四届 1950年 巴西 乌拉圭
第五届 1954年 瑞士 西德
第六届 1958年 瑞典 巴西
第七届 1962年 智利 巴西
第八届 1966年 英格兰 英格兰
第九届 1970年 墨西哥 巴西
第十届 1974年 前西德 西德
第十一届 1978年 阿根廷 阿根廷
第十二届 1982年 西班牙 意大利
第十三届 1986年 墨西哥 阿根廷
第十四届 1990年 意大利 西德
第十五届 1994年 美国 巴西
第十六届 1998年 法国 法国
第十七届 2002年 韩日 巴西
第十八届 2006年 德国 意大利
第十九届 2010年 南非 西班牙
第二十届 2014年 巴西 德国
（Map）在原有世界杯Map 的基础上，增加如下功能： 读入一支球队的名字，输出该球队夺冠的年份列表。 例如，读入“巴西”，应当输出 1958 1962 1970 1994 2002 读入“荷兰”，应当输出 没有获得过世界杯
package List;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class ListTest01 {
public static void main(String[] args) {
//Map实例化
Map
//添加数据
m.put("1930","乌拉圭");
m.put("1934", "意大利");
m.put("1938","意大利");
m.put("1950","乌拉圭");
m.put("1954","西德");
m.put("1958","巴西");
m.put("1962","巴西");
m.put("1966","英格兰");
m.put("1970","巴西");
m.put("1974","西得");
m.put("1978","阿根廷");
m.put("1982","意大利");
m.put("1986","阿根廷");
m.put("1990","西得");
m.put("1994","巴西");
m.put("1998","法国");
m.put("2002","巴西");
m.put("2006","意大利");
m.put("2010","西班牙");
m.put("2014","德国");
System.out.println("请输入年份值：");
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
//判断key值是否等于输入的值
if(m.containsKey(str)==true)
{
System.out.println(m.get(str));
}
else
{
System.out.println("今年没有举办世界杯");
}
System.out.println("请输入世界杯夺冠的国家：");
String str2 = sc.nextLine();
if(m.containsValue(str2)==true)
{
System.out.println("该对获取冠军的年份值是：");
for(String temp: m.keySet())
{
if(m.get(temp).equals(str2))
{
System.out.println(" "+temp);
}
}
}
else
{
System.out.println( str2+"没有获得冠军！");
}
}
}
2.第二题 已知有十六支男子足球队参加2008 北京奥运会。写一个程序，把这16 支球队随机分为4 个组。采用List集合和随机数
2008 北京奥运会男足参赛国家：
科特迪瓦，阿根廷，澳大利亚，塞尔维亚，荷兰，尼日利亚、日本，美国，中国，新西 兰，巴西，比利时，韩国，喀麦隆，洪都拉斯，意大利
package List;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class ListTest02 {
public static void main(String[] args) {
//List集合
List
String ls1;
//添加数据
ls.add("科特迪瓦");
ls.add("阿根廷");
ls.add("澳大利亚");
ls.add("塞尔维亚");
ls.add("荷兰");
ls.add("尼日利亚");
ls.add("日本");
ls.add("美国");
ls.add("中国");
ls.add("新西兰");
ls.add("巴西");
ls.add("比利时");
ls.add("韩国");
ls.add("喀麦隆");
ls.add("洪都拉斯");
ls.add("意大利");
Random ran = new Random();
for(int i =1;i<=4;i++)
{
System.out.println("第"+i+"组");
for(int j=0;j < 4;j++)
{
ls1 =ls.get(ran.nextInt(ls.size()));
System.out.print(ls1+" ");
ls.remove(ls1);
}
System.out.println();
}
}
}
3.第三题 有如下Student 对象，
private String name;
private int age;
private int score;
private String classNum;
其中，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） 计算各个班级的平均分
package List;
import java.util.ArrayList;
import java.util.List;
public class ListTest03 {
public static void main(String[] args) {
//实例化集合
List
//添加数据
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"));
//遍历集合中年龄的数据，并进行计算
int sum=0;
for(int i=0;i}
内部内
内部类（innerclasses）
一般情况下，我们把类定义成为独立的单元。有些情况下，我们把一个类放在另一个类的内部定义，称为内部类。
内部类的作用：
1.内部类提供了更好的封装。只能让外部类直接访问，不允许同一个包中的其他类直接访问。
2.内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员。但外部类不能访问内部类的内部属性。
内部类的使用场合：
由于内部类提供了更好的封装特性，并且可以很方便的访问外部类的属性。所以，通常内部类只在为外部类提供服务的情况下优先使用。
内部类的分类：
1.成员内部类（可以使用private、protected、public 任意进行修饰。类文件：外部类$内部类.class）
a)非静态内部类（外部类里使用非静态内部类和平时使用其他类没什么不同）
i.非静态内部类必须寄存在一个外部类对象里。因此，如果有一个非静态内部类对象那么一定存在对应的外部类对象。非静态内部类对象单独属于外部类的某个对象。
ii.非静态内部类可以使用外部类的成员，但是外部类不能直接访问非静态内部类成员。
iii.非静态内部类不能有静态方法、静态属性、静态初始化快
iv.静态成员不能访问非静态成员：外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义变量，创建实例。
v.成员变量访问要点：
1.内部类里的方法的局部变量：变量名
2.内部类属性：this.变量名
3.外部类属性：外部类名.this变量名
vi.内部类的访问：
1.外部类中定义内部类：new innerClass()
2.外部类以外的地方使用非静态内部类：
b)静态内部类
i.定义方式：
Static class ClassName{
//类体
}
ii.使用要点：
1.当一个静态内部类对象存在，并不一定存在对应的外部类对象。因此，静态内部类的实例化方法不能直接访问外部类的实例方法。
2.静态内部类看做外部类的一个静态成员。因此外部类的方法中可以通过：静态内部类.名字 访问静态内部类的静态成员。通过new 静态内部类() 访问静态内部类的实例。
3.在外部类的外面创建静态内部类：
Face.Ear e = new Face.Ear();
e.listen();
2.匿名内部类
顾名思义，没有名字的内部类。表面上看起来它们似乎有名字，实际那不是它们的名字。适合那种只需要使用一次的类。
当程序中使用匿名内部类时，在定义匿名内部类的地方往往直接创建该类的一个对象。匿名内部类的声明格式如下：
1.new 父类构造器（参数列表）|实现接口（）
2.{
- //匿名内部类的类体部分
4.}
匿名内部类就是没有名字的内部类。什么情况下需要使用匿名内部类？如果满足下面的一些条件，使用匿名内部类是比较合适的：
·只用到类的一个实例 。
·类在定义后马上用到。
·类非常小（SUN推荐是在4行代码以下）
·给类命名并不会导致你的代码更容易被理解。
在使用匿名内部类时，要记住以下几个原则：
·匿名内部类不能有构造方法。
·匿名内部类不能定义任何静态成员、静态方法。
·匿名内部类不能是public,protected,private,static。
·只能创建匿名内部类的一个实例。
·一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
·因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。
*.但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口
例1：不使用匿名内部类来实现抽象方法
例2：匿名内部类的基本实现
例3：在接口上使用匿名内部类
3.局部内部类
a)定义在方法内部。作用域只限于本方法。用的很少。
package List;
public class Student {
private String name;
private int age;
private int score;
private String classNum;
public Student() {
// TODO Auto-generated constructor stub
}
public Student(String name, int age, int score, String classNum) {
super();
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 int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public String getClassNum() {
return classNum;
}
public void setClassNum(String classNum) {
this.classNum = classNum;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", score=" + score
+ ", classNum=" + classNum + "]";
}
public static void main(String[] args) {
Student s = new Student();
s.setName("zhangsan");
s.setAge(18);
s.setScore(100);
s.setClassNum("01班");
System.out.println(s);
}
}