集合的嵌套（泛型）和递归算法

Posted 2020-12-05 sw-123

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