1、　　集合的嵌套：

集合的用法其实和数组的用法有很多共同之处，在使用数组的时候，二维数组就是数组的嵌套；

那么在集合之中是否也可以这样呢？

当然也是可以的，例如对于最复杂的的map集合；

map<string, map<string,student>>;这样map中就嵌套了一个map集合；

其中对于map右边的<>尖括号是泛型的一种应用；

a、泛型

使用尖括号里面规定存入的类型，简单来说就是对于存入数据的一种限制，和数组比较像，只能够存入一种数据类型，如果有其它类型存入会发生报错；

例如：如果定义： list<string> 那么存入list集合中的所有类型都是string类型，

作用：安全性高，每次循环遍历时不需要进过object到规定类型的向下转型，操作便利；

对于泛型现在只会简单的操作，这里不做详细介绍；

b、举例说明集合嵌套：

有一个school，里面有n个班级（自己定义），每个班都有特定的班号，每个班级都有m个学生（不限），每个学生都有特定的学号，学生类有姓名，学号，分数；

存入学校的学生数据，计算每一个班级的学生总成绩，和平均分，最后计算学校的总成绩和平均分；

分析：这里有两个键值集合，一个是每个班级对应的有特定的班号，另一个是每个学生有对应学号，需要用到嵌套循环；

map<string,classroom>,map<string, student>;

实现代码如下：

学生类：

package jihe;
public class Student {
private String name;
private int num;
private double score;
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public int getNum() {
	return num;
}
public void setNum(int num) {
	this.num = num;
}
public double getScore() {
	return score;
}
public void setScore(double score) {
	this.score = score;
}
public Student() {
	super();
	// TODO Auto-generated constructor stub
}
public Student(String name, int num, double score) {
	super();
	this.name = name;
	this.num = num;
	this.score = score;
}
@Override
public String toString() {
	return "Student [name=" + name + ", num=" + num + ", score=" + score + "]";
} 
}

班级类：

package jihe;
import java.util.Map;
public class Classroom {
private Map<Integer, Student> classroom;public Map<Integer, Student> getClassroom() {
	return classroom;
}public void setClassroom(Map<Integer, Student> classroom) {
	this.classroom = classroom;
}public Classroom() {
	super();
	// TODO Auto-generated constructor stub
}public Classroom(Map<Integer, Student> classroom) {
	super();
	this.classroom = classroom;
}}

测试类：

package jihe;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;public class test {
public static void main(String[] args) {
	Map<String, Classroom> school=new HashMap<>();
	Scanner sc = new Scanner(System.in);
	do {
		System.out.println("请输入班级编号：");
		String str1=sc.next();
		if (str1.equals("n")) {//输入n终止输入班级信息
			break;
		}
		Classroom newclass= new Classroom();	
		Map<Integer, Student> classroom=new HashMap<>();
		do {
			System.out.println("请输入学生姓名：");
			String name=sc.next();
			if (name.equals("n")) {//输入n终止输入这个班级的学生
				break;
			}
			System.out.println("请输入学生学号：");
			int num = sc.nextInt();
			System.out.println("请输入学生分数：");
			double score = sc.nextDouble();
			Student student = new Student(name, num, score);
			classroom.put(student.getNum(), student);
		} while (true);
		newclass.setClassroom(classroom);
		school.put(str1, newclass);
	} while (true);
	Set<String> keySet = school.keySet();
	double scores=0;
	int nums=0;
	for (String key : keySet) {
		Classroom cl=school.get(key);
		double score=0;
		Map<Integer, Student> map=cl.getClassroom();
		Set<Integer> key2 = map.keySet();
		for (Integer integer : key2) {
			score+=map.get(integer).getScore();
			System.out.println(integer+":"+map.get(key2));
		}
		System.out.println(key+"班级的总分是："+score+"平均分是："+score/key2.size());
		scores+=score;
		nums+=key2.size();
	}
	System.out.println("学校所有班级的总分是："+scores+"平均分是："+scores/nums);
}
}

上面的学校实例可以很好的实现集合的嵌套；

 

2、 递归算法

释义：方法调用自己本身；

例如，计算自然数的和除了运用for循环，还可以使用递归算法：

public static int add(int i){
	if(i==0){
		return 0;
	}
	return add(i-1)+i;
}