package com.ssm.controller.file;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import com.mysql.fabric.xmlrpc.base.Array;
/**
* JAVA培训考核
*
* @author
*
*/
public class Exam {
/**
* 主方法
*
* @param args 传入参数
*/
public static void main(String[] args) {
List<Person> list = new ArrayList<Person>();
list.add(new Person("A1", "A", "A"));
list.add(new Person("A2", "A", "A"));
list.add(new Person("A3", "A", "B"));
list.add(new Person("A4", "B", "B"));
list.add(new Person("A5", "B", "A"));
list.add(new Person("A6", "C", "B"));
list.add(new Person("A7", "C", "A"));
list.add(new Person("A8", "D", "A"));
list.add(new Person("A9", "E", "B"));
list.add(new Person("A10", "A", "B"));
list.add(new Person("A11", "A", "C"));
list.add(new Person("A12", "B", "C"));
list.add(new Person("A13", "B", "C"));
List<Ret> retList = test(list);
for (Ret ret : retList) {
System.out.println(new StringBuffer(ret.getGroup()).append(" A:").append(ret.getCountA()).append(", B:")
.append(ret.getCountB()).append(", C:").append(ret.getCountC()).append(", D:")
.append(ret.getCountD()).append(", E:").append(ret.getCountE()));
}
}
// ************ 答题区域开始 *****************
// ************ 答题区域结束 *****************
/**
* 按照组（班级）为单位，分别统计该组（班级）成绩为A/B/C/D/E的人数， 并按照A/B/C/D/E的人数来排序
*
* @param list 人员列表
* @return 分组排序后的结果
*/
private static List<Ret> test(List<Person> list) {
// ************ 答题区域开始 *****************
Map<String,Integer> resultA1 = new HashMap<>();
Map<String,Integer> resultB1 = new HashMap<>();
Map<String,Integer> resultC1 = new HashMap<>();
List<Ret> RelList = new ArrayList<>();
for (Person person :list) {
switch (person.getGroup()) {
case "A":
switch (person.getScoreLevel()) {
case "A":
if(null == resultA1.get("A")) {
resultA1.put("A", 1);
}else {
resultA1.put("A", resultA1.get("A")+1);
}
break;
case "B":
if(null == resultA1.get("B")) {
resultA1.put("B", 1);
}else {
resultA1.put("B", resultA1.get("B")+1);
}
break;
case "C":
if(null == resultA1.get("C")) {
resultA1.put("C", 1);
}else {
resultA1.put("C", resultA1.get("C")+1);
}
break;
case "D":
if(null == resultA1.get("D")) {
resultA1.put("D", 1);
}else {
resultA1.put("D", resultA1.get("D")+1);
}
break;
case "E":
if(null == resultA1.get("E")) {
resultA1.put("E", 1);
}else {
resultA1.put("E", resultA1.get("E")+1);
}
break;
}
break;
case "B":
switch (person.getScoreLevel()) {
case "A":
if(null == resultB1.get("A")) {
resultB1.put("A", 1);
}else {
resultB1.put("A", resultB1.get("A")+1);
}
break;
case "B":
if(null == resultB1.get("B")) {
resultB1.put("B", 1);
}else {
resultB1.put("B", resultB1.get("B")+1);
}
break;
case "C":
if(null == resultB1.get("C")) {
resultB1.put("C", 1);
}else {
resultB1.put("C", resultB1.get("C")+1);
}
break;
case "D":
if(null == resultB1.get("D")) {
resultB1.put("D", 1);
}else {
resultB1.put("D", resultB1.get("D")+1);
}
break;
case "E":
if(null == resultB1.get("E")) {
resultB1.put("E", 1);
}else {
resultB1.put("E", resultB1.get("E")+1);
}
break;
}
break;
case "C":
switch (person.getScoreLevel()) {
case "A":
if(null == resultC1.get("A")) {
resultC1.put("A", 1);
}else {
resultC1.put("A", resultC1.get("A")+1);
}
break;
case "B":
if(null == resultC1.get("B")) {
resultC1.put("B", 1);
}else {
resultC1.put("B", resultC1.get("B")+1);
}
break;
case "C":
if(null == resultC1.get("C")) {
resultC1.put("C", 1);
}else {
resultC1.put("C", resultC1.get("C")+1);
}
break;
case "D":
if(null == resultC1.get("D")) {
resultC1.put("D", 1);
}else {
resultC1.put("D", resultC1.get("D")+1);
}
break;
case "E":
if(null == resultC1.get("E")) {
resultC1.put("E", 1);
}else {
resultC1.put("E", resultC1.get("E")+1);
}
break;
}
break;
default:
break;
}
}
Ret Reta = new Ret();
Reta.setGroup("A");
Iterator<Entry<String, Integer>> it = resultA1.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, Integer> entry = it.next();
switch (entry.getKey()) {
case "A":
Reta.setCountA( entry.getValue());
break;
case "B":
Reta.setCountB( entry.getValue());
break;
case "C":
Reta.setCountC( entry.getValue());
break;
case "E":
Reta.setCountE( entry.getValue());
break;
case "D":
Reta.setCountD( entry.getValue());
break;
default:
break;
}
}
RelList.add(Reta);
Ret Retb = new Ret();
Retb.setGroup("B");
Iterator<Entry<String, Integer>> it1 = resultB1.entrySet().iterator();
while (it1.hasNext()) {
Map.Entry<String, Integer> entry = it1.next();
switch (entry.getKey()) {
case "A":
Retb.setCountA( entry.getValue());
break;
case "B":
Retb.setCountB( entry.getValue());
break;
case "C":
Retb.setCountC( entry.getValue());
break;
case "E":
Retb.setCountE( entry.getValue());
break;
case "D":
Retb.setCountD( entry.getValue());
break;
default:
break;
}
}
RelList.add(Retb);
Ret Retc = new Ret();
Retc.setGroup("C");
Iterator<Entry<String, Integer>> it2 = resultC1.entrySet().iterator();
while (it2.hasNext()) {
Map.Entry<String, Integer> entry = it2.next();
switch (entry.getKey()) {
case "A":
Retc.setCountA( entry.getValue());
break;
case "B":
Retc.setCountB( entry.getValue());
break;
case "C":
Retc.setCountC( entry.getValue());
break;
case "E":
Retc.setCountE( entry.getValue());
break;
case "D":
Retc.setCountD( entry.getValue());
break;
default:
break;
}
}
RelList.add(Retc);
return RelList;
// ************ 答题区域结束 *****************
}
}
// ************ 答题区域开始 *****************
// ************ 答题区域结束 *****************
/**
* 人
*/
class Person {
/** 姓名 */
private String name;
/** 成绩 */
private String scoreLevel;
/** 分组(班级) */
private String group;
/**
* 构造一个人
*/
public Person() {
}
/**
* 构造一个人
*
* @param name 姓名
* @param scoreLevel 成绩
* @param group 分组(班级)
*/
public Person(String name, String scoreLevel, String group) {
this.name = name;
this.scoreLevel = scoreLevel;
this.group = group;
}
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
/**
* @return the scoreLevel
*/
public String getScoreLevel() {
return scoreLevel;
}
/**
* @param scoreLevel the scoreLevel to set
*/
public void setScoreLevel(String scoreLevel) {
this.scoreLevel = scoreLevel;
}
/**
* @return the group
*/
public String getGroup() {
return group;
}
/**
* @param group the group to set
*/
public void setGroup(String group) {
this.group = group;
}
}
/**
* 第二题结果Class
*
* @author zhaodong
*
*/
class Ret {
/** 分组(班级) */
private String group;
/** 成绩为A的人数 */
private Integer countA;
/** 成绩为B的人数 */
private Integer countB;
/** 成绩为C的人数 */
private Integer countC;
/** 成绩为D的人数 */
private Integer countD;
/** 成绩为E的人数 */
private Integer countE;
/**
* 构造结果
*/
public Ret() {
this.countA = 0;
this.countB = 0;
this.countC = 0;
this.countD = 0;
this.countE = 0;
}
/**
* @return the group
*/
public String getGroup() {
return group;
}
/**
* @param group the group to set
*/
public void setGroup(String group) {
this.group = group;
}
/**
* @return the countA
*/
public Integer getCountA() {
return countA;
}
/**
* @param countA the countA to set
*/
public void setCountA(Integer countA) {
this.countA = countA;
}
/**
* @return the countB
*/
public Integer getCountB() {
return countB;
}
/**
* @param countB the countB to set
*/
public void setCountB(Integer countB) {
this.countB = countB;
}
/**
* @return the countC
*/
public Integer getCountC() {
return countC;
}
/**
* @param countC the countC to set
*/
public void setCountC(Integer countC) {
this.countC = countC;
}
/**
* @return the countD
*/
public Integer getCountD() {
return countD;
}
/**
* @param countD the countD to set
*/
public void setCountD(Integer countD) {
this.countD = countD;
}
/**
* @return the countE
*/
public Integer getCountE() {
return countE;
}
/**
* @param countE the countE to set
*/
public void setCountE(Integer countE) {
this.countE = countE;
}
}