title: java作业
author: charoneo
comments: true
typora-root-url: java作业
date: 2024-04-19 00:18:00
tags: java实验
description: 本文将从h08开始，介绍每一次作业的做法，其中h05是java程序设计lab1，h11是java程序设计lab2，这里就不做过多赘述了

public static int[] getPascalTriangle(int i) {
    int[] row = new int[i];
    Arrays.fill(row, 1);    //全部填充为1
    for(int r = 2;r <=i;r++) {
        for(int j = r-2;j >=1;j--) {
            row[j] = row[j] + row[j-1];
        }
    }
    return row;
}

public class LoginUtil{
	public void login(String a, String b)  throws InvalidUserException{
		if(a.equals("a") && b.equals("a")) {
			return;
		}else {
			throw new InvalidUserException();
		}
	}
}

public class InvalidUserException extends RuntimeException{
	public InvalidUserException() {
		super();
	}
	
	public InvalidUserException(String message, Throwable cause) {
		super(message,cause);
	}
	
	public InvalidUserException(String message) {
		super(message);
	}
	
	public InvalidUserException(Throwable cause) {
		super(cause);
	}
}

public interface  AgeCheckInterface {

	public void checkAge(int age)  ;

}

public class AgeCheck implements AgeCheckInterface{
	@Override
	public void checkAge(int age){
		if(age <0 || age >200) {
			throw new IllegalArgumentException();			//注意这里不能抛出Exception
		}
	}
}

public int getDistinctCharCount(String s) {
    Set<String> set = new HashSet<>();
    char[] charArray = s.toCharArray();
    String[] stringArray = new String[charArray.length];		//构造一个字符串数组
    for(int i = 0;i<charArray.length;i++) {
        stringArray[i] = String.valueOf(charArray[i]);
    }
    for(int i=0;i<s.length();i++) {
        set.add(stringArray[i]);
    }
    return set.size();
}

public char getFrequentChar(String s) {
    Map<Character, Integer> map = new HashMap<>();
    for(int i=0;i<s.length();i++) {
        if(map.containsKey(s.charAt(i))) {
            map.put(s.charAt(i), map.get(s.charAt(i))+1);
        }else {
            map.put(s.charAt(i), 1);
        }
    }
    char res = ' ';
    int maxCount = 0;
    for(Map.Entry<Character, Integer> entry: map.entrySet()) {			//使用entrySet遍历
        if(maxCount < entry.getValue()) {
            res = entry.getKey();
            maxCount = entry.getValue();
        }
    }
    return res;
}

map.put(s.CharAt(i),map.getOrDefault(s.charAt(i),0)+1))

public String getFrequentWord(String content){
    Map<String, Integer> map = new HashMap<>();
    for(int i = 0;i<content.length()-1;i++) {
        if(map.containsKey(content.substring(i, i+2))) {			//注意substring的字符之间是索引
            map.put(content.substring(i, i+2), map.get(content.substring(i, i+2))+1);
        }else {
            map.put(content.substring(i, i+2), 1);
        }
    }

    String res = null;
    int maxCount = 0;

    for(Map.Entry<String, Integer> entry: map.entrySet()) {
        if(maxCount < entry.getValue()) {
            res = entry.getKey();
            maxCount = entry.getValue();
        }
    }
    return res;
}

public void zipStringBufer(StringBuffer buf) {
    for(int i = 0;i<buf.length();i++) {
        if(buf.charAt(i) == ' ') {
            buf.deleteCharAt(i--);			//删了以后i也要减1
        }
    }
}

public class Home10 {
	public Home10() {
	} 
	/**
	 * 将一个字符串中字符按出现频率的高到低排序返回，如果两个字符出现的频率一样，则将最先出现的字符排在前面
	 * 例如：orderChar(“abcdefg”)返回 “abcdefg” 
	 * orderChar(“abcdefgg”)返回 “gabcdef”
	 * orderChar(“abcdefgge”)返回 “egabcdf”
	 * orderChar(“天津大学软件学院”)返回 “学天津大软件院”
	 * @param content
	 * @return
	 */
	public String orderChar(String content) {
		Map<Character, Integer> map = new TreeMap<>(new Comparator<Character>() {
			public int compare(Character c1, Character c2) {
				if(c1.equals(c2)) {			//不要忘记相等的情况，否则会出现g=1,g=1的情况；这里还必须用equals，否则用=会出现中文不支持
					return 0;
				}
				return content.indexOf(c1) < content.indexOf(c2) ? -1 :1;			//索引值小的放在前面
			}
		});
		
		for(int i = 0; i<content.length();i++) {
			if(map.containsKey(content.charAt(i))) {
				map.put(content.charAt(i), map.get(content.charAt(i))+1);
			}else {
				map.put(content.charAt(i), 1);
			}
		}
		
		String res = "";
		int maxCount = 0;
		
		for(Map.Entry<Character, Integer> entry: map.entrySet()) {
			if(maxCount < entry.getValue()) {				//先求出出现最多的次数
				maxCount = entry.getValue();
			}
		}
		for(int i = maxCount; i>0;i--) {			//这层循环在外面qaq
			for(Map.Entry<Character, Integer> entry: map.entrySet()) {
				if(entry.getValue()==i) {
					res += entry.getKey();			//拼接字符串直接用+即可
				}
			}
		}
		return res;
	}
	
}

public Set<String> getFrequentItem(String content,int n)  {
    String[] sessions = content.split(";");
    Map<Set<String>, Integer> allPairMap = new HashMap<>();
    for(String session : sessions) {
        String[] products = session.split(",");
        Set<String> uniqueProducts = new HashSet<>();
        for(String product: products) {
            uniqueProducts.add(product.trim());
        }
        if(uniqueProducts.size() >= n) {
            Set<Set<String>> combinations = generateCombinations(uniqueProducts, n);
            for(Set<String> combination : combinations) {
                allPairMap.put(combination,allPairMap.getOrDefault(combination, 0)+1);
            }
        }
    }
    Set<String> maxFrequent = null;
    int maxFrequentCount = 0;
    for(Map.Entry<Set<String>, Integer> entry : allPairMap.entrySet()) {
        if(maxFrequentCount < entry.getValue()) {
            maxFrequentCount = entry.getValue();
            maxFrequent = entry.getKey();
        }
    }
    return  maxFrequent;
}

private Set<Set<String>> generateCombinations(Set<String> products, int n){
    Set<Set<String>> result = new HashSet<>();
    generateCombinationsHelper(new ArrayList<>(products), n , 0, new LinkedHashSet<>(), result);
    return result;
}

private void generateCombinationsHelper(List<String> products, int n, int start, Set<String> current, Set<Set<String>> result) {
    if(current.size() == n) {
        result.add(new HashSet<>(current));
        return;
    }
    for(int i = start; i< products.size();i++) {
        current.add(products.get(i));
        generateCombinationsHelper(products, n,i+1,current,result);
        current.remove(products.get(i));
    }
}

public List<String> getTopNWords(  int n) throws Exception{
    String text = readFromTxt(this.filename);
    Map<String, Integer> FrequencyWord = new HashMap<>();

    for(int i = 0;i<text.length()-1;i++) {
        String word = text.substring(i,i+2);
        if(word.matches("[\\u4e00-\\u9fa5]{2}")) {		//确保是两个汉字
            FrequencyWord.put(word, FrequencyWord.getOrDefault(word, 0)+1);
        }
    }

    List<Map.Entry<String, Integer>> FrequentList = new ArrayList<>(FrequencyWord.entrySet());
    FrequentList.sort((a,b)->b.getValue().compareTo(a.getValue()));

    List<String> result = new ArrayList<>();
    for(int i=0;i<n && i <FrequentList.size();i++) {
        result.add(FrequentList.get(i).getKey());
    }
    return result;
}

private String[] splitContentToChapter(String content) {
    // 提示 使用 content.split(" 第[一,二,三,四,五,六,七,八,九,十,零]{1,5}回 ");正则表达拆分
    // 百度一下正则表达式
    String contents[] = content.split(" 第[一,二,三,四,五,六,七,八,九,十,零]{1,5}回 ");
    return Arrays.copyOfRange(contents, 1, contents.length);		//去除第一章节之前的非正式内容
}

private String readFromTxt(String filename) throws Exception {
    Reader reader = null;
    try {
        StringBuffer buf = new StringBuffer();
        char[] chars = new char[1024];
        // InputStream in=new FileInputStream(filename);

        reader = new InputStreamReader(new FileInputStream(filename), "UTF-8");
        int readed = reader.read(chars);
        while (readed != -1) {
            buf.append(chars, 0, readed);
            readed = reader.read(chars);
        }
        return buf.toString();
    } finally {
        close(reader);
    }
}

public int[] getStringFrequent(String str) throws Exception {
    int[] result = new int[120];
    String text = readFromTxt(this.filename);
    this.chapters = splitContentToChapter(text);
    int i = 0;
    for(String chapter : chapters) {
        int count = 0;
        int index = 0;
        while(index != -1) {
            index = chapter.indexOf(str, index);			//从index开始查找str，返回查找到的索引
            if(index != -1) {
                count++;
                index += str.length();
            }
        }
        result[i++] = count;
    }
    return result;
}

// 实际测试中，文件存放位置可能改变，学生数量也可能改变
// 其中每行为一个学生信息，包括学号、姓名、班级，以tab符号分割(\t)，
String studentListFileName="E:/EclipseWorkspace/hw1/src/com/huawei/classroom/student/h14/students.txt";
// 学生照片存放的目录，不会包含子目录，本目录的pic给出了存放图片的目录示例，实际测试中，pic 位置可能改变，其下面文件数量也会改变
String picDir="E:/EclipseWorkspace/hw1/src/com/huawei/classroom/student/h14/pic/";
String targetDir="E:/EclipseWorkspace/hw1/src/com/huawei/classroom/student/h14/target/";

public Set<String> copyToTargetDirAndReturnNoExist(String studentListFile,String srcDir,String target) throws Exception {
    Set<String> noPicIds = new HashSet<>();
    File dir = new File(target);
    if(!dir.exists()) {
        dir.mkdirs();
    }
    try(BufferedReader reader = new BufferedReader(new FileReader(studentListFile))){
        String line;
        while((line = reader.readLine()) != null) {
            String[] details = line.split("\t");
            String studentId = details[0];
            String StuName = details[1];
            String StuClass = details[2];

            File picFile = new File(srcDir + studentId + ".jpg");
            if(picFile.exists()) {
                File targetFile = new File(target + StuClass);
                if(!targetFile.exists()) {
                    targetFile.mkdirs();
                }
                Files.copy(Paths.get(picFile.getPath()), Paths.get(targetFile.getPath(),studentId +"_" + StuName + ".jpg"),StandardCopyOption.REPLACE_EXISTING);
            }else {
                noPicIds.add(studentId);
            }
        }
    }catch(IOException e) {
        throw new IOException("Error Handling File Operations",e);
    }

    return noPicIds;
}

public class ThreadUtil extends Thread{
	private StringBuffer buf;
	
	public ThreadUtil(StringBuffer buf) {
		this.buf = buf;
	}
	
	@Override
	public void run() {
		try {
			Thread.sleep(1000);
			buf.append("ok");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			System.out.println("Thread was Interrupted!");
		}
		
	}
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.Callable;

public class PrimeUtil {

    public List<Long> getPrimeList(long start, long end, int threadCount) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
        List<Future<List<Long>>> futures = new ArrayList<>();
        long blockSize = (end - start) / threadCount;

        for (int i = 0; i < threadCount; i++) {
            long localStart = start + i * blockSize;
            long localEnd = (i == threadCount - 1) ? end : localStart + blockSize;
            futures.add(executor.submit(new PrimeTask(localStart, localEnd)));
        }

        List<Long> primes = new ArrayList<>();
        for (Future<List<Long>> future : futures) {
            primes.addAll(future.get()); // Retrieve and combine results
        }
        executor.shutdown();

        Collections.sort(primes); // Ensure the primes are sorted
        return primes;
    }

    private static class PrimeTask implements Callable<List<Long>> {
        private long start, end;

        public PrimeTask(long start, long end) {
            this.start = start;
            this.end = end;
        }

        @Override
        public List<Long> call() throws Exception {
            List<Long> localPrimes = new ArrayList<>();
            for (long number = start; number < end; number++) {
                if (isPrime(number)) {
                    localPrimes.add(number);
                }
            }
            return localPrimes;
        }

        private boolean isPrime(long number) {
            if (number <= 1) return false;
            if (number <= 3) return true;
            if (number % 2 == 0 || number % 3 == 0) return false;
            for (long i = 5; i * i <= number; i += 6) {
                if (number % i == 0 || number % (i + 2) == 0) return false;
            }
            return true;
        }
    }
}

public static void main(String[] args) {
    // TODO Auto-generated method stub
    // 端口号测试的时候随机给
    int port = 8088;
    // 要求完成MyServer类
    new MyServer().startListen(port);
    Socket socket = null;
    PrintWriter out = null;
    BufferedReader in = null;
    try {
        socket = new Socket("127.0.0.1", port);
        out = new java.io.PrintWriter(socket.getOutputStream());
        // 获得输入流
        in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        // 随机测试向服务器端输入几句话，要求服务器端原封不动返回
        if (testEcho(in, out, "hellow")) {
            System.out.println("ok 1");
        }
        if (testEcho(in, out, "haha")) {
            System.out.println("ok 2");
        }
        // 向服务器端输入bye，断开表示断开连接
        out.write("bye" + "\r\n");
        out.close();
        in.close();
        socket.close();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } finally {
        close(in);
        close(out);
        close(socket);
    }
}

public class MyServer {
	public MyServer() {
		
	}
	
	public void startListen(int port) {
		Thread serverThread = new ServerThread(port);
		serverThread.start();
	}
}

package com.huawei.classroom.student.h16;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerThread extends Thread{
	private int port;
	private ServerSocket server;
	private Socket socket;
	private InputStream in;
	private OutputStream out;
	
	public ServerThread(int port) {
		server = null;
		socket = null;
		in = null;
		out = null;
		this.port = port;
	}
	
	@Override
	public void run() {
		try {
			server = new ServerSocket(port);
			socket = server.accept();
			in = socket.getInputStream();
			out = socket.getOutputStream();
			
			byte[] data = new byte[100];
			int readed = in.read(data);
			String line = new String(data, 0, readed);
			
			while(!("bye" + "\r\n").equals(line)) {
				out.write(line.getBytes());
				readed = in.read(data);
				line = new String(data, 0, readed);
			}
			
		}catch(IOException e) {
			e.printStackTrace();
		}finally {
			close(server);
			close(socket);
			close(in);
			close(out);
		}
	}
	
	public static void close(AutoCloseable closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

server = new ServerSocket(port);
socket = server.accept();
in = socket.getInputStream();
out = socket.getOutputStream();

byte[] data = new byte[100];
int readed = in.read(data);
String line = new String(data, 0, readed);

while(!("bye" + "\r\n").equals(line)) {
    out.write(line.getBytes());
    readed = in.read(data);
    line = new String(data, 0, readed);
}

package com.huawei.classroom.student.h17;

public enum EnumObjectType {
	base,
	health,
	strength,
	range,
	heavyTank,
	mediumTank,
	rifleSoldier,
	RPGSoldier,
	dog,
	barrack,
	warFactory
}

#测试的时候，属性的整数值可能会改变
base.health=1000 
base.range=0
base.strength=0

#重型坦克的属性
heavyTank.health=500
heavyTank.range=100
heavyTank.strength=100

package com.huawei.classroom.student.h17;

public class Param {
	public static int baseHealth =0;
	public static int baseRange = 0;
	public static int baseStrength = 0;
	
	public static int heavyTankHealth = 0;
	public static int heavyTankRange = 0;
	public static int heavyTankStrength = 0;
	
	public static int mediumTankHealth = 0;
	public static int mediumTankRange = 0;
	public static int mediumTankStrength = 0;
    ...

private static List<String[]> readLines(String filename){
    String line = "";
    Reader reader = null;
    List<String[]> results = new ArrayList<>();
    try {
        reader = new FileReader(filename);
    }catch(FileNotFoundException e) {
        e.printStackTrace();
    }
    if(reader == null) {
        return null;
    }
    LineNumberReader lineReader = new LineNumberReader(reader);
    try {
        while(true) {
            line = lineReader.readLine();
            if(line == null) {
                break;
            }
            if(line.trim().length()==0 || line.trim().startsWith("#")) {
                continue;
            }
            results.add(line.trim().split("\\.|="));		//注意反斜杠本身也要转义
        }
    }catch(IOException e) {
        e.printStackTrace();
    }
    return results;
}

try(BufferedReader reader = new BufferedReader(new FileReader(filename))){
    ...
}catch(IOException e){
    e.printStackTrace();
}

public static void setValue(String[] rules) {
    if(EnumObjectType.base.toString().equals(rules[0])) {
        if(EnumObjectType.health.toString().equals(rules[1])) {
            Param.baseHealth = Integer.parseInt(rules[2]);
        }else if(EnumObjectType.strength.toString().equals(rules[1])) {
            Param.baseStrength = Integer.parseInt(rules[2]);
        }else if(EnumObjectType.range.toString().equals(rules[1])) {
            Param.baseRange = Integer.parseInt(rules[2]);
        }
    }else if(EnumObjectType.heavyTank.toString().equals(rules[0])) {
        if(EnumObjectType.health.toString().equals(rules[1])) {
            Param.heavyTankHealth = Integer.parseInt(rules[2]);
        }else if(EnumObjectType.strength.toString().equals(rules[1])) {
            Param.heavyTankStrength = Integer.parseInt(rules[2]);
        }else if(EnumObjectType.range.toString().equals(rules[1])) {
            Param.heavyTankRange = Integer.parseInt(rules[2]);
        }
        ...

public static void init(String filename) {
    List<String[]> rules = readLines(filename);
    if(rules == null) {
        return;
    }
    for(String[] rule : rules) {
        setValue(rule);
    }
}

package com.huawei.classroom.student.h17;

import java.util.*;
import java.io.*;

public class BattleField {
	private static List<Player> players = new ArrayList<>();
	
	public BattleField() {
		players = null;
	}
    
    ...
        
    	public static void createPlayer(String playerName) {
		if(playerName == null) {
			return;
		}
		Player newPlayer = new Player(playerName);
		players.add(newPlayer);
	}
	
	public static GameBase createGameBase(Player p, int x, int y) {
		return new GameBase(p,x,y);
	}
	
	public static List<Player> getAllPlayer(){
		return players;
	}
}

package com.huawei.classroom.student.h17;

public class Player {
	private String name;
	public Player(String name) {
		this.name = name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public String getName() {
		return this.name;
	}
}

package com.huawei.classroom.student.h17;

import java.util.*;

public class GameObject {
	protected int x,y;
	protected int health;
	protected int strength;
	protected int range;
	protected Player player;
	protected static List<GameObject> gameObjects = new ArrayList<>();
	protected EnumObjectType objectType;		//定义这个属性是为了在打印时打印出类别
	public GameObject(Player p, int x, int y, int PH, int attackValue, int attackRange) {
		this.player = p;
		this.x = x;
		this.y = y;
		this.health = PH;
		this.strength = attackValue;
		this.range = attackRange;
		GameObject.gameObjects.add(this);
	}
	@Override
	public String toString() {			//在result.txt中打印
		return "["+player.getName()+"."+objectType+" live="+(!isDestroyed())+" x="+x+" y="+y+" health="+getHealth()+"]";
	}
	public void move(int dx, int dy) {		//building不能移动，所以在building中重写
		this.x += dx;
		this.y += dy;
	}
	public double getDistance(GameObject obj1, GameObject obj2) {
		return Math.sqrt(Math.pow(obj1.x-obj2.x, 2)+Math.pow(obj1.y-obj2.y, 2));
	}
	public void attack(GameObject B) {
		if(this.isDestroyed() || B.isDestroyed() || getDistance(this,B)>this.range) {
			return;
		}
		String debug = this + "攻击"+B;
		B.health -= this.strength;
		debug += "攻击后 health="+B.getHealth();
		System.out.println(debug);				//在result.txt中打印
	}
	public void attack() {
		double min = this.range;
		for(GameObject g: gameObjects) {
			if(g.isDestroyed() || this.isDestroyed()) {
				continue;
			}
			if(getDistance(this,g) < min) {
				min = getDistance(this,g);
			}
		}
		for(GameObject g: gameObjects) {
			if(g.isDestroyed() || this.isDestroyed()) {
				continue;
			}
			if(getDistance(this,g) - min < 0.000001) {
				attack(g);
			}
		}
	}
	public int getHealth() {
		return this.health;
	}
	public boolean isDestroyed() {
		return this.health<=0;
	}
	public void setObjectType(EnumObjectType type) {
		this.objectType = type;
	}
	public void dead() {
		//在Soldier类中重写
	}
}

package com.huawei.classroom.student.h17;

public class GameBase extends GameObject{
	public GameBase(Player p, int x, int y) {
		super(p,x,y,Param.baseHealth,Param.baseStrength,Param.baseRange);
		setObjectType(EnumObjectType.base);
	}
	
	public Building building(EnumObjectType type, int x, int y) {		//基地创建建筑物时可以指定x和y
		if(type == EnumObjectType.barrack) {
			return new Barrack(this.player, x, y);
		}else if(type == EnumObjectType.warFactory) {
			return new WarFactory(this.player, x, y);
		}else {
			return null;
		}
	}
}

public class Building extends GameObject{
	public Building(Player p, int x, int y, int PH, int attackValue, int attackRange) {
		super(p,x,y,PH,attackValue,attackRange);
	}
	
	@Override
	public void move(int dx, int dy) {
		
	}
}

public class Barrack extends Building{
	public Barrack(Player p, int x, int y) {
		super(p,x,y,Param.barrackHealth,Param.barrackStrengh,Param.barrackRange);
		setObjectType(EnumObjectType.barrack);
	}
	
	public GameObject traing(EnumObjectType type) {
		if(type == EnumObjectType.rifleSoldier) {
			return new RifleSoldier(this.player, this.x, this.y);
		}else if(type == EnumObjectType.RPGSoldier) {
			return new RPGSoldier(this.player, this.x, this.y);
		}else if(type == EnumObjectType.dog) {
			return new Dog(this.player, this.x, this.y);
		}else {
			return null;
		}
	}
}

public class Soldier extends GameObject{
	private static int livingSoldierCount = 0;
	private static int deadedSoldierCount = 0;
	
	public Soldier(Player p, int x, int y, int PH , int attackValue, int attackRange) {
		super(p,x,y,PH,attackValue,attackRange);
		livingSoldierCount++;
	}
	
	public int getLivingSoldierCount() {
		return livingSoldierCount;
	}
	
	public int getDeadedSoldierCount() {
		return deadedSoldierCount;
	}
	
	@Override
	public void dead() {
		livingSoldierCount--;
		deadedSoldierCount++;
	}
}

public class RifleSoldier extends Soldier{
	public RifleSoldier(Player p, int x, int y) {
		super(p,x,y,Param.rifleSoldierHealth,Param.rifleSoldierStrength,Param.rifleSoldierRange);
		setObjectType(EnumObjectType.rifleSoldier);
	}
}

public class RPGSoldier extends Soldier{
	public RPGSoldier(Player p, int x, int y) {
		super(p,x,y,Param.RPGSoldierHealth,Param.RPGSoldierStrength,Param.RPGSoldierRange);
		setObjectType(EnumObjectType.RPGSoldier);
	}
}

public class Dog extends GameObject{
	public Dog(Player p, int x, int y) {
		super(p,x,y,Param.dogHealth,Param.dogStrength,Param.dogRange);
		setObjectType(EnumObjectType.dog);
	}
}

public class WarFactory extends Building{
	public WarFactory(Player p, int x, int y) {
		super(p,x,y,Param.warFactoryHealth,Param.warFactoryStrengh,Param.warFactoryRange);
		setObjectType(EnumObjectType.warFactory);
	}
	
	public Tank building(EnumObjectType type) {
		if(type == EnumObjectType.heavyTank) {
			return new HeavyTank(this.player,this.x, this.y);
		}else if(type == EnumObjectType.mediumTank) {
			return new MediumTank(this.player, this.x, this.y);
		}else {
			return null;
		}
	}
}

public class HeavyTank extends Tank{
	public HeavyTank(Player p, int x, int y) {
		super(p,x,y,Param.heavyTankHealth,Param.heavyTankStrength,Param.heavyTankRange);
		setObjectType(EnumObjectType.heavyTank);
	}
}

public class MediumTank extends Tank{
	public MediumTank(Player p, int x, int y) {
		super(p,x,y,Param.mediumTankHealth,Param.mediumTankStrength,Param.mediumTankRange);
		setObjectType(EnumObjectType.mediumTank);
	}
}

package com.huawei.classroom.student.h18;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

public class MyClassFactory {
    private Map<String, Map<String, Object>> classConfigs = new HashMap<>();

    public MyClassFactory(String configFilePath) throws Exception {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(configFilePath), "UTF-8"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                line = line.trim();
                if (line.isEmpty() || line.startsWith("#")) {
                    continue; // 跳过空行和注释行
                }
                String[] parts = line.split("=");
                String key = parts[0].trim();
                String value = parts[1].trim().replaceAll("^\"|\"$", ""); // 去除开头和结尾的双引号
                String[] classAndProperty = key.split("\\.(?=[^\\.]+$)");
                String className = classAndProperty[0];			//类名
                String propertyName = classAndProperty[1];		//属性名

                // 根据值是否以引号包围来判断是否为字符串
                Object typedValue = parts[1].startsWith("\"") && parts[1].endsWith("\"") ? value : Integer.parseInt(value);

                classConfigs.computeIfAbsent(className, k -> new HashMap<>()).put(propertyName, typedValue);
            }
        }
    }

    public <T> T createInstance(Class<T> clazz) throws Exception {
        T instance = clazz.getDeclaredConstructor().newInstance();
        Map<String, Object> properties = classConfigs.get(clazz.getName());
        if (properties != null) {
            for (Map.Entry<String, Object> entry : properties.entrySet()) {
                String propName = entry.getKey();
                Object propValue = entry.getValue();
                String methodName = "set" + propName.substring(0, 1).toUpperCase() + propName.substring(1);		//例如setColor
                Method method = clazz.getMethod(methodName, propValue.getClass());
                method.invoke(instance, propValue);
            }
        }
        return instance;
    }
}

String[] classAndProperty = key.split("\\.(?=[^\\.]+$)");

classConfigs.computeIfAbsent(className, k -> new HashMap<>()).put(propertyName, typedValue);

T instance = clazz.getDeclaredConstructor().newInstance();

Map<String, Object> properties = classConfigs.get(clazz.getName());

Method method = clazz.getMethod(methodName, propValue.getClass());

method.invoke(instance, propValue);

public String removeDulpicatedChar(String string) {
    // TODO Auto-generated method stub
    Set<Character> UniqueEle = new LinkedHashSet<>();		//使用Linked保留原来的顺序
    for(int i=0;i<string.length();i++) {
        UniqueEle.add(string.charAt(i));
    }
    Iterator<Character> it = UniqueEle.iterator();
    String result = "";
    while(it.hasNext()) {
        result += it.next();
    }
    return result;
}

package com.huawei.classroom.student.h19.q05;

import java.io.*;
import java.util.*;

public class StudentUtil {
	private class Student{
		String name;
		int chineseScore;
		int mathScore;
		int engScore;
		int totalScore;
		
		public Student(String name) {
			this.name = name;
		}
		
		public void updateScore(String subject, int score) {
			if("语文".equals(subject)) {
				this.chineseScore += score;
			}else if("数学".equals(subject)) {
				this.mathScore += score;
			}else if("英语".equals(subject)) {
				this.engScore += score;
			}
			totalScore += score;
		}
	}
	public List<String> sort(String fileName){
		Map<String,Student> stu = new HashMap<>();		//建立学生姓名和学生之间的关系
		File file = new File(fileName);
		try (BufferedReader reader = new BufferedReader(new FileReader(file))){
			String line = "";
			while((line = reader.readLine()) != null) {
				String parts[] = line.split(",");
				if(parts.length == 3) {
					String name = parts[0].trim();
					String subject = parts[1].trim();
					int score = Integer.parseInt(parts[2].trim().substring(0,2));
					Student student = stu.getOrDefault(name, new Student(name));
					student.updateScore(subject, score);
					stu.put(name, student);			//相当于把更新后放到Map中
				}
			}
		}catch(IOException e){
			e.printStackTrace();
			return null;
		}
		
		List<Student> students = new ArrayList<>(stu.values());		//把Map中所有value构造List
		students.sort((a,b)->{
			if(a.totalScore != b.totalScore) {
				return Integer.compare(b.totalScore, a.totalScore);
			}else if(a.chineseScore != b.chineseScore) {
				return Integer.compare(b.chineseScore, a.chineseScore);
			}else if(a.mathScore != a.mathScore) {
				return Integer.compare(b.mathScore, a.mathScore);
			}else {
				return Integer.compare(b.engScore, a.engScore);
			}
		});
		
		List<String> result = new ArrayList<>();
		for(Student s : students) {
			result.add(s.name);
		}
		
		return result;
	}
}

public static void main(String[] args) {	
    A a = new D();
    C c = new D();
    D d = new D();

    System.out.println("pass 1");

    B b = c;
    System.out.println("pass 2");

    a = d;
    System.out.println("pass 3");

    c=new E();
    System.out.println("pass 4");

    a=new A();
    if (!(a instanceof B)) {
        System.out.println("pass 5");
    }

    if (!(c instanceof A)) {
        System.out.println("pass 6");
    }
    if (!(c instanceof D)) {
        System.out.println("pass 7");
    }

}

public class A {

}

public interface B {

}

public interface C extends B{

}

public class D extends A implements C {

}

public class E implements C{

}

public class Classq02 {
	private Set<Character> charSet = new HashSet<>(Arrays.asList('~', '!', '@', '#', '$', '%', '^', '&', '*'));

	public String findMaxDistinctCharWord(List<String> list) {
		int i, max;
		String ans = new String();
		Map<String, Integer> map = new HashMap<>();
		for (i = 0; i < list.size(); i++) {
			String str = list.get(i);
			if (!map.containsKey(str)) {
				map.put(str, getDistinctCharCount(str));
			}
		}
		max = 0;
		Set<String> stringSet = map.keySet();
		for (String str: stringSet) {
			if (max < map.get(str)) {
				max = map.get(str);
				ans = str;
			}
		}
		return ans;
	}
	
	public int getDistinctCharCount(String s) {
		Set<Character> set = new HashSet<>();
		char[] chars = s.toCharArray();
		for (char cha : chars) {
			if (charSet.contains(cha)) {
				set.add(cha);
			}
		}
		return set.size();
	}

}

File(String pathname);
File(File parent, String child);

public class Classq06 {
	private int count = 0;
	public Classq06() {
	}

	public int recursiveGetFileCount(String homeDir) {
		 // 
		File dir=new File(homeDir);
		ListFiles(dir);
		return count;
	}
	public void ListFiles(File dir) {
		if (!dir.exists() || !dir.isDirectory()) {		//dir不存在或dir不是目录
			return;
		}

		String[] files = dir.list();		//里面存放着每个文件名
		for (int i = 0; i < files.length; i++) {
			File file = new File(dir, files[i]);		//采用父级目录和文件名构造出路径
			if (file.isFile()) {
				count++;
			} else {		
				ListFiles(file); // 对于子目录,进行递归调用
			}
		}

	}
}

public class Item implements Comparable{
	private String name;
	private int amount;
	private int money;
	
	public Item(String name, int amount, int money) {
		this.name = name;
		this.amount = amount;
		this.money = money;
	}
	public String getName() {
		return name;
	}
	public Item(String name, String amount, String money) {
		this(name, Integer.valueOf(amount), Integer.valueOf(money));
	}

	public int compareTo(Object o) {
		// TODO Auto-generated method stub
		if (!(o instanceof Item)) {
            return -1;
        }
		if (this.amount > ((Item) o).amount) {
			return 1;
		} else if (this.amount == ((Item) o).amount) {		//升序排列
			if (this.money > ((Item) o).money) {
				return 1;
			} else if (this.money == ((Item) o).money) {
				return 0;
			} else {
				return -1;
			}
		} else {
			return -1;
		}
	}
	public int compareMTo(Object o) {
		// TODO Auto-generated method stub
		if (!(o instanceof Item)) {
            return -1;
        }
		if (this.money > ((Item) o).money) {
			return 1;
		} else if (this.money == ((Item) o).money) {		//升序排列
			if (this.amount > ((Item) o).amount) {
				return 1;
			} else if (this.amount == ((Item) o).amount) {
				return 0;
			} else {
				return -1;
			}
		} else {
			return -1;
		}
	}
}

public class ItemComparator implements Comparator<Item> {

private final int order;		//通过order是否为-1来决定到底是数值比较还是金钱比较
    
public ItemComparator(int order) 
{
        super();
        this.order = order;
}

    @Override
    public int compare(Item i1, Item i2) 
{
        int result = -i1.compareTo(i2);		//倒序排列
        int resultM=-i1.compareMTo(i2);
        if (this.order == -1) {
            return result;
        } else {
            return resultM;
        }
    }
}

public List<String> sortByAmount(String fileName) {
    //return sort(fileName);

    int i;
    List<String> result = new ArrayList<>();
    List<Item> scoreLists = initScoreLists(fileName);
    scoreLists.sort(new ItemComparator(-1));
    for (i = 0; i < scoreLists.size(); i++) {
        result.add(scoreLists.get(i).getName());
    }
    return result;
}

public List<String> sortByMoney(String fileName) {
    int i;
    List<String> result = new ArrayList<>();
    List<Item> scoreLists = initScoreLists(fileName);
    scoreLists.sort(new ItemComparator(1));
    for (i = 0; i < scoreLists.size(); i++) {
        result.add(scoreLists.get(i).getName());
    }
    return result;
}

public List<Item> initScoreLists(String filename) {
    int i, j;
    List<String[]> items = readLines(filename);		//自己定义的逐行读文件函数，有模板
    Set<String> nameSet = new HashSet<>();
    List<Item> itemList = new ArrayList<>();
    for (i = 0; i < items.size(); i++) {
        String name = "";
        int money = 0, amount = 0;
        List<String> itemLine = new ArrayList<>(Arrays.asList("", "0", "0"));
        line2list(items.get(i), itemLine);		//将String[]转化为List<String>
        name = itemLine.get(0);
        if (nameSet.contains(name)) {
            continue;		//注意是双重循环，所以要continue
        } else {
            nameSet.add(name);
        }
        money += Integer.parseInt(itemLine.get(2));
        amount += Integer.parseInt(itemLine.get(1));
        for (j = i + 1; j < items.size(); j++) {
            if (items.get(j)[0].equals(name)) {
                line2list(items.get(j), itemLine);
                money += Integer.parseInt(itemLine.get(2));
                amount += Integer.parseInt(itemLine.get(1));
            }
        }

        Item item = new Item(name, amount, money);
        itemList.add(item);
    }
    return itemList;
}

public void line2list(String[] itemLine, List<String> itemList) {
    String name = itemLine[0];
    String amount = itemLine[1];
    String money = itemLine[2];
    itemList.set(0, name);		//设定指定位置的值
    itemList.set(1, amount);
    itemList.set(2, money);
}

private static List<String[]> readLines(String filename) {
    String line = "";
    Reader reader = null;
    List<String[]> result = new ArrayList<>();
    try {
        reader = new FileReader(filename);
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    }
    if (reader == null) {
        return null;
    }
    LineNumberReader lineReader = new LineNumberReader(reader);

    try {
        while (true) {
            line = lineReader.readLine();
            if (line == null) {
                break;
            }
            if ("".equals(line) || line.charAt(0) == '#' || line.trim().length() == 0) {
                continue;
            }
            result.add(line.replace(" ", "").split(","));
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    return result;
}

//第一问  完成Classq11.extractComment(String line)方法，具体要求见 Classq11.extractComment(String line)
String line="String str=\"he;/*test*/\";";
//这行的Java代码对应如下：
//String str="he;/*test*/";
//System.out.println(util.extractComment(line));
if("".equals(util.extractComment(line))) {
    System.out.println("case 2 pass");
}


line="String str=\"he//\";//hi;";
//这行的Java代码对应如下：
//String str="he//";//hi;
//System.out.println(util.extractComment(line));
if("hi;".equals(util.extractComment(line))) {
    System.out.println("case 3 pass");
}

public String extractComment(String line) {
    // TODO Auto-generated constructor stub //{03e7c9a7b63b7c323243d92158ea746a}
    int head = 0, tail = 0, primePos = 0;
    int primePos1 = (line.indexOf("\"") == -1) ? 0 : line.indexOf("\"");
    primePos = (primePos1 == 0) ? 0 : line.indexOf("\"", primePos1+1);
    System.out.println(primePos);
    System.out.println(primePos1);
    if(line.indexOf("/*",primePos) != -1) {
        head = line.indexOf("/*",primePos)+2;
        tail = line.indexOf("*/",primePos)-1;
        return line.substring(head,tail);
    }else if(line.indexOf("//",primePos) != -1) {
        head = line.indexOf("//",primePos)+2;
        return line.substring(head);
    }else {
        return "";
    }
}

public double[] getHongbao(double total,int personCount) {
    double result[]=new double[personCount];

    if(personCount <= 0) {
        return result;
    }

    int totalCents = (int)Math.round(total*100);
    Random random = new Random();

    int remainCents = totalCents - personCount;

    //这里只分配两个人的
    for(int i = 0;i<personCount-1;i++) {
        int randomCents = random.nextInt(remainCents+1);	//[1,remainCents]
        result[i] = (randomCents+1)/100.0;				//这里包含了之前的1分钱
        remainCents -= randomCents;
    }

    result[personCount-1] = (remainCents+1)/100.0;

    return result;
}

public Set<Integer> decompose(int num) {
     Set<Integer> res = new HashSet<>();
     if(num <= 0) {
          return null;
     }else if(num == 1) {
          res.add(1);
     }else {
          int i = 2;
          while(i <= num) {
              if(num % i == 0) {
                  res.add(i);
                  num = num/i;			//把i这个因数去掉，剩下的因子构成num
                  i = 2;					//i每次从2开始
              }else {
                  i++;					//不可能出现不是质数的情况，因为因子已经从小到大考虑过了
              }
          }
     }
     return res;
}

public int getLivingRabbit(int startCount,int days) {
    List<Rabbit> rabbits = new ArrayList<>();
    for(int i = 0;i<startCount;i++) {
        rabbits.add(new Rabbit(0));
    }
    for(int day = 1; day <= days ;day++) {
        int initialSize = rabbits.size();
        for(int i = 0; i < initialSize;i++) {
            Rabbit r = rabbits.get(i);
            r.age++;
            if(r.age >= 180 && (r.age - 180) % 90 == 0) {
                rabbits.add(new Rabbit(0));
                rabbits.add(new Rabbit(0));
            }
            if(r.age > 700) {
                rabbits.remove(i);
                i--;
                initialSize--;
            }
        }

    }
    return rabbits.size();
}

public boolean isValidPassword(String password){
    Map<String, Integer> res = new HashMap<>();
    if(password.length() < 8) {
        return false;
    }
    res.put("number", 0);
    res.put("lowerCase", 0);
    res.put("upperCase",0);
    res.put("special", 0);
    String flag = new String("~!@#$%^&*()_+");
    for(int i = 0; i< password.length(); i++) {
        char c = password.charAt(i);
        if(c > '0' && c < '9') {
            res.put("number", res.getOrDefault("number", 0)+1);
        }else if(c > 'a' && c < 'z') {
            res.put("lowerCase", res.getOrDefault("lowerCase", 0)+1);
        }else if(c > 'A' && c < 'Z') {
            res.put("upperCase", res.getOrDefault("upperCase", 0)+1);
        }else if(flag.contains(c + "")) {			//将字符转为字符串
            res.put("special", res.getOrDefault("special", 0)+1);
        }
    }
    boolean isValid = true;
    for(Map.Entry<String, Integer> entry : res.entrySet()) {
        if(entry.getValue() == 0) {
            isValid = false;
        }
    }
    return isValid;

}

public void analysis(String pathFilename,String chars) {
    Map<String, Integer> res = new HashMap<>();
    File f = new File(pathFilename);
    String line = "";
    try {
        BufferedReader reader = new BufferedReader(new FileReader(f));
        while((line = reader.readLine()) != null) {
            for(int i = 0;i<line.length()-1;i++) {
                String word = line.substring(i,i+2);
                if(word.matches("[\\u4e00-\\u9fa5]{2}") && (chars.contains(word.substring(0, 1)) || chars.contains(word.substring(1, 2)))) {		//确保是两个汉字
                    res.put(word, res.getOrDefault(word, 0)+1);
                }
            }
        }
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    int maxCount = 0;
    for(Map.Entry<String, Integer> entry: res.entrySet()) {
        if(maxCount < entry.getValue()) {
            maxCount = entry.getValue();
        }
    }
    int counter = 0;
    for(int i = maxCount;i>0;i--) {
        for(Map.Entry<String, Integer> entry : res.entrySet()) {
            if(entry.getValue() == i) {
                System.out.println(entry.getKey() + " "+ entry.getValue());
                counter++;			//只有打印出来了，计数器才+1
                if(counter==10) {
                    break;
                }
            }
        }
        if(counter==10) {		//防止打印出排名并列的从而超过10个
            break;
        }
    }

}

public void listFiles(File dir) {
    if(!dir.exists() || !dir.isDirectory()) {
        return;
    }
    String[] files = dir.list();
    for(int i = 0; i< files.length ;i++) {
        File f = new File(dir,files[i]);		//这里要加上根目录
        if(f.isFile() && files[i].endsWith(".txt")) {
            res.add(f);
        }else {
            listFiles(f);
        }
    }
}

public void replaceTxtFileContent(String homeDir,String orgStr,String targetStr) {
    File dir = new File(homeDir);
    listFiles(dir);
    for(int i = 0;i<res.size();i++) {
        File f = res.get(i);
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(f),"UTF-8"));		//加入UTF-8防止乱码
            StringBuilder contents = new StringBuilder();
            String line = "";
            boolean firstLine = true;
            while((line = reader.readLine()) != null) {			//把所有内容都读出来然后替换
                if(firstLine) {
                    contents.append(line.replace(orgStr, targetStr));
                    firstLine = false;
                }else {
                    contents.append(System.lineSeparator()).append(line.replace(orgStr, targetStr));
                }
            }
            reader.close();

            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(f),"UTF-8"));
            writer.write(contents.toString());			//这里是覆盖写
            writer.close();

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

public static long sizeSum = 0;
	
public long recursiveCalcFileSize(String homeDir) {
    File dir = new File(homeDir);
    listFiles(dir);
    return sizeSum;
}

public void listFiles(File dir) {
    if(!dir.exists() || !dir.isDirectory()) {
        return;
    }
    String[] files = dir.list();
    for(int i = 0;i<files.length;i++) {
        File f = new File(dir, files[i]);
        if(f.isFile()) {
            sizeSum += f.length();			//返回文件的大小
        }else {
            listFiles(f);
        }
    }
}

package com.huawei.classroom.student.h58;

import java.text.*;
import java.util.Date;

public class Record implements Comparable{
	private Date time;
	private String id;
	private String name;		//候选人的名字
	private boolean isValid;
	
	public Record(String t, String id, String name) {
		DateFormat fmt = new SimpleDateFormat("yyyy-MM-DD HH:mm:ss");
		try {
			this.time = fmt.parse(t);
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		this.id = id;
		this.name = name;
		this.isValid = true;
	}
	
	public Date getDate() {			//由于getTime是系统的函数，这里改为getDate
		return this.time;
	}
	
	public String getId() {
		return this.id;
	}
	
	public String getName() {
		return this.name;
	}
	
	public void setValid(boolean flag) {
		this.isValid = flag;
	}
	
	public boolean getIsValid() {
		return this.isValid;
	}
	
	@Override
	public int compareTo(Object o) {
		if(! (o instanceof Record)) {
			return -1;
		}
		Record that = (Record)o;
		return this.time.compareTo(that.time);			//根据时间顺序排名记录
	}
}

package com.huawei.classroom.student.h58;

import java.io.Serializable;
import java.util.*;

public class Voter implements Serializable{
	private String id;		//不同投票者的区别是id不同
	private List<Record> records = new ArrayList<>();
	
	public Voter(String id) {
		this.id = id;
	}
	
	public void addRecord(Record record) {
		records.add(record);
	}
	
	public String getId() {
		return this.id;
	}
	
	public List<Record> getRecords(){
		return this.records;
	}
	
	public void removeInvalidRecords() {
		records.sort(Record:: compareTo);
		
		List<Record> buffer = new LinkedList<>();
		int next = 0;
		for(int i = 0; i < Math.min(5, records.size());i++) {
			buffer.add(records.get(next++));
		}
		
		while(next < records.size()){
			Date curTime = buffer.get(0).getDate();
			Date oneMinLater = new Date(curTime.getTime()+60000);
			Date tenMinLater = new Date(curTime.getTime()+600000);
			
			for(int i = 1; i < buffer.size() ;i++) {
				if(buffer.get(i).getDate().compareTo(oneMinLater) < 0) {	//在1min之内
					buffer.get(i).setValid(false);
					buffer.remove(i--);
					if(next < records.size()) {
						buffer.add(records.get(next++));
					}
				}
				oneMinLater = new Date(buffer.get(i).getDate().getTime()+60000);
			}
			
			for(int i = 1 ;i <buffer.size();i++) {
				if(buffer.get(i).getDate().compareTo(tenMinLater) >= 0) {		//在10min之后
					buffer.remove(0);
					if(next < records.size()) {
						buffer.add(records.get(next++));
					}
					if(buffer.size() != 5) {		//针对没有添加元素成功的情况
						i = buffer.size()-2;
					}else {
						i--;
					}
					tenMinLater = new Date(buffer.get(0).getDate().getTime()+600000);
				}
			}
			
			while(next < records.size()) {
				if(records.get(next).getDate().compareTo(tenMinLater) < 0) {		//如果buffer外下一条记录在10min之内
					records.get(next++).setValid(false);
				}else {
					break;
				}
			}
			
			if(next < records.size()) {
				buffer.remove(0);
				buffer.add(records.get(next++));
			}
			
		}
		//再次也是最后一次判断，防止最后一个元素不符合规范
		if(buffer.size() > 1) {
			Date curTime = buffer.get(0).getDate();
			Date oneMinLater = new Date(curTime.getTime()+60000);
			Date tenMinLater = new Date(curTime.getTime()+600000);
			for(int i = 1; i < buffer.size() ;i++) {
				if(buffer.get(i).getDate().compareTo(oneMinLater) < 0) {	//在1min之内
					buffer.get(i).setValid(false);
					buffer.remove(i--);
				}
				oneMinLater = new Date(buffer.get(i).getDate().getTime()+60000);
			}
		}
	}
	
	@Override
	public int hashCode() {
		return id.hashCode();
	}
	
	@Override
	public boolean equals(Object o) {
		if(!(o instanceof Voter)) {
			return false;
		}
		Voter that = (Voter) o;
		return this.id.equals(that.id);
	}
}

package com.huawei.classroom.student.h58;

import java.util.*;
import java.io.*;

public class VoteRecord {
	/**
	 * fileName是一个投票的明细记录，里面逐行存放了 投票的时间（yyyy-MM-dd HH:mm:ss 格式） +\t+投票的微信ID+\t+候选人
	 * 存放按时间递增（但是可能出现同一秒出现若干条记录的情况）
	 * 现在需要完成投票统计的过程，具体要求如下：
	 * 1个微信ID 1分钟内 最多投1票 多余的票数无效
	 * 1个微信ID 10分钟内 最多只能投5票 多余的票无效
	 * 其中微信ID不固定，候选人姓名不固定
	 * 测试的时候要求10万行记录处理时间不超过3秒 
	 * @param fileName
	 * @return 返回一个map，其中key是候选人名字，value的票数
	 */
	
	public List<Voter> voters = new ArrayList<>();
	
	public Map<String,Integer> calcRecording(String fileName){
		Map<String, Integer> res = new HashMap<>();
		List<Record> allRecords = new ArrayList<>();
		Set<String> voterIds = new HashSet<>();
		allRecords = readLines(fileName);
		for(Record rec : allRecords) {
			voterIds.add(rec.getId());
		}
		for(String voterId : voterIds) {
			Voter vo = new Voter(voterId);
			voters.add(vo);
		}
		for(Voter v : voters) {
			for(Record rec : allRecords) {
				if(rec.getId().equals(v.getId())) {
					v.addRecord(rec);
				}
			}
		}
		for(Voter v : voters) {
			v.removeInvalidRecords();
			for(Record r : v.getRecords()) {
				if(r.getIsValid()) {
					res.put(r.getName(), res.getOrDefault(r.getName(), 0)+1);
				}
			}
		}
		return res;
	}
	
	public List<Record> readLines(String path) {
		File f = new File(path);
		List<Record> res1 = new ArrayList<>();
		try {
			BufferedReader reader = new BufferedReader(new FileReader(f));
			String line = "";
			while((line = reader.readLine()) != null) {
				String[] elements = line.split("\t");
				String time = elements[0];
				String id = elements[1];
				String name = elements[2];
				Record record = new Record(time,id,name);
				res1.add(record);
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return res1;
	}

}

public class Reaction {
	private Set<String> reactant = new HashSet<>();
	private Set<String> product = new HashSet<>();
	
	public Reaction(Set<String> reactant, Set<String> product) {
		this.reactant = reactant;
		this.product = product;
	}
	
	public Set<String> getReactant(){
		return reactant;
	}
	
	public Set<String> getProduct(){
		return product;
	}
}

public Set<String> findAllComponents(String reactionFile,Set<String> initComponents){
    Set<String> result = new HashSet<>(initComponents);		//初始化直接根据initComponents构建result

    List<Reaction> reactions = readLines(reactionFile);
    int addCount = initComponents.size();
    while(addCount != 0) {
        addCount = 0;
        for(Reaction rea : reactions) {
            if(result.containsAll(rea.getReactant()) && result.addAll(rea.getProduct())) {
                addCount++;
            }else if(result.containsAll(rea.getProduct()) && result.addAll((rea.getReactant()))){
                addCount++;
            }
        }
    }
    return result;
}

public List<Reaction> readLines(String reactionFile){
    List<Reaction> res = new ArrayList<>();
    File f = new File(reactionFile);
    try {
        BufferedReader reader = new BufferedReader(new FileReader(f));
        String line = "";
        while((line = reader.readLine()) != null) {
            if(line.startsWith("#") || line.trim().length() == 0) {
                continue;
            }
            String[] reaction = line.split("=");
            String left = reaction[0];
            String right = reaction[1];
            String[] lefts = left.split("\\ \\+\\ ");	//这里是正则表达式，如果只有一个反应物则返回值不变（不分割）
            Set<String> leftSet = new HashSet<>();
            for(String ele : lefts) {
                leftSet.add(ele.trim());
            }
            String[] rights = right.split("\\ \\+\\ ");
            Set<String> rightSet = new HashSet<>();
            for(String ele : rights) {
                rightSet.add(ele.trim());
            }
            Reaction rea = new Reaction(leftSet,rightSet);
            res.add(rea);
        }
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    return res;
}

package com.huawei.classroom.student.h60;

import java.io.*;
import java.net.*;
import java.util.*;

public class ChatServer {
	/**
	 * 初始化 ， 根据情况适当抛出异常
	 * @param port
	 * @param passwordFilename 所有用户的用户名 口令
	 */
	
	private static boolean flag = true;
	private int port;
	private String passwordFilename;
	private Map<String,String> userDetails;
	private Set<ClientHandler> clientHandlers;		//保存所有登录的用户
	private List<String> messageList;

	public ChatServer (int port, String passwordFilename) throws IOException {
		this.port = port;
		this.passwordFilename = passwordFilename;
		userDetails = new HashMap<>();
		clientHandlers = new HashSet<>();
		messageList = Collections.synchronizedList(new ArrayList<>());
		loadUsersDetails();
	}
	
	public void loadUsersDetails() {
		File f = new File(passwordFilename);
		try {
			BufferedReader reader = new BufferedReader(new FileReader(f));
			String line = "";
			while((line = reader.readLine()) != null) {
				String[] detail = line.split("\t");
				if(detail.length == 2) {
					userDetails.put(detail[0], detail[1]);
				}
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	
	/**
	 *  根据情况适当抛出异常
	 * 开始监听
	 */
	public void startListen( ) {
		new Thread(()->{
			ServerSocket server = null;
			try {
				server = new ServerSocket(port);
				System.out.println("chat server listen on port:" + port + " ok!");
				while(flag) {
					Socket socket = server.accept();
					ClientHandler clientHandler = new ClientHandler(socket);
					clientHandlers.add(clientHandler);
					new Thread(clientHandler).start();
				}
				
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}).start();
	}
	
	
	private class ClientHandler implements Runnable {
        private Socket clientSocket;
        private PrintWriter out;
        private BufferedReader in;
        private String userName;
        private boolean loggedIn;			//判断是否已经登录
        private int messageIndex;

        public ClientHandler(Socket clientSocket) {
            this.clientSocket = clientSocket;
            loggedIn = false;
            messageIndex = 0;
        }

        @Override
        public void run() {
            try {
                out = new PrintWriter(clientSocket.getOutputStream(), true);
                in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

                String inputLine;
                while ((inputLine = in.readLine()) != null) {
                    String[] parts = inputLine.split(" ", 2);
                    String command = parts[0];

                    if (command.equals("LOGIN")) {
                        String[] credentials = parts[1].split(" ");
                        if (credentials.length == 2 && authenticate(credentials[0], credentials[1])) {
                            userName = credentials[0];
                            loggedIn = true;
                            out.println("LOGIN SUCCESS");
                            broadcastMessage("SYSTEM "+ userName + " has joined the chat");
                        } else {
                            out.println("LOGIN FAILURE");
                        }
                    } else if (command.equals("LOGOUT")) {
                        if (userName != null) {
                            broadcastMessage("SYSTEM "+ userName + " has left the chat");
                            clientHandlers.remove(this);
                            loggedIn = false;
                            break;
                        }
                    } else if (command.equals("SPEAK")) {
                    	if(loggedIn) {
                    		if (userName != null) {
                            	String message = "MESSAGE "+ parts[1];		//这里不用写是谁说的（根据Test要求）
                                synchronized(messageList) {
                                	messageList.add(message);
                                }
                                //broadcastMessage(message);			//如果还广播的话，就会出现四个MESSAGE信息
                            }
                    	}else {
                    		out.println("You need to login first!");
                    	}
                        
                    } else if (command.equals("READ")) {
                    	if(loggedIn) {
                        	String message;
                        	synchronized(messageList) {
                        		if(messageIndex < messageList.size()) {
                        			out.println(messageList.get(messageIndex));
                        			messageIndex++;
                        		}else {
                        			out.println("READ null");
                        		}
                        	}
                    	}else {
                    		out.println("You need to login first!");
                    	}
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (clientSocket != null) {
                        clientSocket.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        private boolean authenticate(String userName, String password) {
            return password.equals(userDetails.get(userName));
        }

        private void broadcastMessage(String message) {
            for (ClientHandler handler : clientHandlers) {
            	if(handler.loggedIn) {
            		handler.out.println(message);
            	}
            }
        }
	}
	
}

package com.huawei.classroom.student.h60;
​
import java.io.*;
import java.net.*;
​
public class ChatClient {
  private String ip;
  private int port;
  private Socket socket;
  private PrintWriter out;
  private BufferedReader in;
​
   /**
    * 根据情况适当抛出异常 
    * @param ip
    * @param port
    */
  public ChatClient (String ip, int port) {
    this.ip = ip;
    this.port = port;
  }
  /**
   * 登录,成功返回true，否则返回false，根据情况适当抛出异常 
   * 
   * @param userName
   * @param password
   * @return
   */
  public boolean login(String userName,String password) {
    try {
      socket = new Socket(ip, port);
      out = new PrintWriter(socket.getOutputStream(), true);
      in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
      
      out.println("LOGIN "+userName + " "+password);
      String response = in.readLine();
      return response.equals("LOGIN SUCCESS");
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 退出，根据情况适当抛出异常 
   */
  public void logout() {
    if(socket != null && out != null) {
      out.println("LOGOUT");
      closeConnection();
    }
  }
  /**
   * 发言, 只有登录以后才能发言， 根据情况适当抛出异常 
   * 如果没有登录 抛出异常
   *  
   * @param str
   */
  public void speak(String str) {
     if(out != null) {
       out.println("SPEAK "+ str);
     }
  }
  /**
   * 读取聊天室目前的发言，根据情况适当抛出异常 
   * 只有登录以后才可以读到,否则返回null
   * 得到聊天室里面所有的发言（包括自己的），如果此时没有发言则立刻返回null，否则每次调用read的时候按队的方式返回一个句话
   */
  public String read() {
    if(out != null) {
      out.println("READ");
      try {
        String response;
                while ((response = in.readLine()) != null) {
                    if (response.startsWith("MESSAGE ")) {
                        return response.substring(8);
                    }else if (response.startsWith("READ null")) {
                        return null;
                    }
                    if(response.equals("You need to login first!")) {
                      break;
                    }
                    // 如果是系统消息，继续读取
                }
      } catch (IOException e) {
        // TODO Auto-generated catch block
        //e.printStackTrace();
        return null;
      }
    }
    return null;
    
  }
  
  private void closeConnection() {
    
    try {
      if(socket != null) {
        socket.close();
      }
      if(out != null) {
        out.close();
      }
      if(in != null) {
        in.close();
      }
​
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  } 
  
}