SDKD Javaコンテナ実験4

実験の目的

1. クラスライブラリのコンテナで、従来の方法に精通しています。
2. 一般的なアプリケーションの問題を解決するために、共通のコンテナを使用しました。

ウェブテスト

ソートの学生

プログラムを書いて、ユーザがキーボードの学生の名前から番号とスコアを入力することができます（毎回プログラムは、ユーザが「N」は、ユーザ入力された入力した場合、学生の情報を入力する継続するかどうかを決定するために、「Y」または「N」の入力を促す。入力"Y"、 "N" 大文字と小文字を区別しません）。ユーザの入力が完了した後、生徒の名前とスコアの出力に応じて降順にプログラム結果を（名前とスコアとの間の空間によって分割します）。[注：キーボード入力Scannerクラスを使用することができます}

コード

Main.java

import java.util.Objects;
import java.util.Scanner;
import java.util.TreeSet;

public class Main {
    static final Scanner cin = new Scanner(System.in);
    public static void main(String[] args) {
    // write your code here
        var set =  new TreeSet<Student>();
        /*
            流程模拟
        */
        while(true) {
            System.out.print("是否添加一个学生？(y/n)");
            String option = cin.next();
            if(Objects.equals(option, "Y") || Objects.equals(option, "y")) {
                set.add(new Student(cin.next(),cin.nextDouble()));
            }else if(Objects.equals(option, "N") || Objects.equals(option, "n"))
                break;
            else
                System.out.print("输入错误,");
        }
        /*
            输出
        */
        for(Student tmp : set)
            System.out.println(tmp);
    }
}

Student.java

/*
学生类：存储学生姓名 成绩，自带排序功能
*/
public class Student implements Comparable<Student>{

    private String name;
    private double score;
    public Student(String name, double score) {
        this.name = name;
        this.score = score;
    }
    @Override
    public String toString() {
        return name + " " + score;
    }
    @Override
    public int compareTo(Student other) {
        return -Double.compare(score, other.score);
    }
}

オンラインショッピングカート

オンラインショッピングカートでのHashMapのシミュレーション。要件：Nキーボード書籍名、価格、数量からの入力、この情報はメソッドgetSum（HashMapの書籍）、本戻るの合計金額を算出するためのメソッドを呼び出すようにHashMapの次に、ハッシュマップに格納されます。[注：Scannerクラスは、キーボードを使用することができます]

コード

Main.java

import java.util.Scanner;

public class Main {
    private static final Scanner cin = new Scanner(System.in);

    public static void main(String[] args) {
        // write your code here
        //程序输入部分
        System.out.print("请输入你要购买的书的种类数:");
        int n = cin.nextInt();
        ShoppingCart cart = new ShoppingCart();
        for (int i = 1; i <= n; ++i) {
            System.out.println("请输入你要购买的第" + i + "种书的名称、单价、购买数量(以空格分隔)");
            Book item = new Book(cin.next(), cin.nextDouble());
            cart.add(item, cin.nextInt());
        }
        //输出
        System.out.print("你本次购物总计消费" + cart.getSum(cart.getData()) + "元");
    }
}

/*
测试数据：
4
a 1 2
b 2 2
c 1 1
d 1 0
*/

Book.java

import java.util.Objects;
/*
    图书类：存储图书的名称和价格
*/
public class Book {
    private String name;
    private double price;
    public String getName() {
        return name;
    }
    public Book(String name, double price) {
        this.name = name;
        this.price = price;
    }
    public double getPrice() {
        return price;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Book book = (Book) o;
        return Double.compare(book.price, price) == 0 &&
                Objects.equals(name, book.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, price);
    }
}

ShoppingCart.java

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class ShoppingCart {
    private HashMap<Book, Integer> data = new HashMap<Book, Integer>();

    //向购物车添加商品
    public Integer add(Book book, int num) {
        return data.put(book, num);
    }
    //向购物车添加商品
    public void showAll() {
        Iterator it = data.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry entry = (Map.Entry) it.next();
            Book book = (Book) entry.getKey();
            int num = (int) entry.getValue();
            System.out.println(book.getName() + " " + book.getPrice() + " " + num);
        }
    }
    /*
        提取购物车的数据
    */
    public HashMap<Book, Integer> getData() {
        return data;
    }

    /*
        getSum() 计算购物车内的商品总价
        既可以计算本购物车的总价，也可以计算外部购物车数据的总价
    */
    
    public Double getSum(HashMap<Book, Integer> all) {
        Double sum = 0.0;
        Iterator it = all.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry entry = (Map.Entry) it.next();
            Book book = (Book) entry.getKey();
            int num = (int) entry.getValue();
            sum += (book.getPrice() * num);
        }
        return sum;
    }
    public Double getSum() {
        Double sum = 0.0;
        Iterator it = data.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry entry = (Map.Entry) it.next();
            Book book = (Book) entry.getKey();
            int num = (int) entry.getValue();
            sum += (book.getPrice() * num);
        }
        return sum;
    }
}

30 7選挙

30 7選挙：宝くじシミュレーションプログラムを書きます。ランダム生成乱数7（1〜30の間）、注意深いは繰り返しません。その後、キーボード7からの数値入力、同じ乱数かどう番号7と比較。「いくつかの数字インチ」最後のショー 数は6であれば、賞金表示;一方、数7、一等賞の表示であれば5、3賞ディスプレイの数の場合。要件：まず、コメント内のデータ構造を使用し、特に手続きをアイデアを実現するためのプログラムを書き、その後、Java実装のコードを記述します。[注：キーボード入力Scannerクラスを使用することができます}

コード

Main.java

import java.util.*;

public class Main {
    //创建Scanner 和 彩票机对象实例
    static final Scanner cin = new Scanner(System.in);
    private static LotteryMachine lotteryMachine = new LotteryMachine();

    public static void main(String[] args) {
        // write your code here
        
        
        //输入 开奖 展示
        Set<Integer> numbers = getInput();
        int prices = lotteryMachine.lottery(numbers);
        Set<Integer> ans = lotteryMachine.getWinNumber();
        
        /*
            展示抽奖数据
        */
        System.out.print("本期中奖号码是:");
        for (int i : ans) {
            System.out.print(i + " ");
        }
        System.out.print('\n');
        //System.out.println("price: " + prices);
        System.out.println("您猜中了" + prices + "个数");
        int awardLevel = LotteryMachine.SELECT_NUMBER - prices;
        //System.out.println("awardLevel: " + awardLevel);
        if (awardLevel < LotteryMachine.AWARD_LEVELS.length)
            System.out.println("恭喜，您获得了" + LotteryMachine.AWARD_LEVELS[awardLevel]);
        else
            System.out.println("很遗憾，您未中奖，再接再厉吧!");

    }
    /*
        程序的输入及其预处理方法
    */
    private static Set<Integer> getInput() {
        
        List<Integer> list = new ArrayList<>();
        Set<Integer> set = new HashSet<>();
        while (true) {
            // 每次输入前刷新中奖值
            lotteryMachine.refresh();
            list.clear();
            
            //程序在此获得用户输入
            System.out.println("请在1~" + LotteryMachine.RANGE + "之间选择" + LotteryMachine.SELECT_NUMBER + "个不同的数:");
            while (list.size() < LotteryMachine.SELECT_NUMBER)
                list.add(cin.nextInt());
            
            set.addAll(list);
            /*
                输入预处理部分
            */
            if (set.size() < LotteryMachine.SELECT_NUMBER) {
                //用户输入重复数字
                System.out.println("输入错误:你选择的数字中不同的数不足" + LotteryMachine.SELECT_NUMBER + "个");
            } else {
                /*
                    在此判断用户输入是否在指定范围
                */
                int invalidCount = 0;
                for (int i : set)
                    if (i > LotteryMachine.RANGE || i < 1) {
                        ++invalidCount;
                        System.out.println("输入错误:你选择的数字中有不在1~" + LotteryMachine.RANGE + "之间的数");
                    }
                //输入符合规则    
                if (invalidCount == 0)
                    return set;
            }
        }
    }
}

LotteryMachine.java

import java.util.HashSet;
import java.util.Set;

/*
      彩票机类
    * 可自定义抽奖范围 一次抽出数字个数 奖项的个数及名称
    * */
    

class LotteryMachine {
    //抽奖范围
    public static final int RANGE = 30;
    //抽出数字个数
    public static final int SELECT_NUMBER = 7;
    //奖项设置
    public static final String[] AWARD_LEVELS = {"一等奖", "二等奖", "三等奖"/*, "四等奖", "五等奖", "六等奖", "七等奖"*/};
    //TODO:创建中奖数的存储空间
    private Set<Integer> data = new HashSet<>();
    public LotteryMachine() {
        //创建彩票机时进行初始化刷新
        this.refresh();
    }
    /*
        刷新彩票机的的中奖数据
    */
    public void refresh() {
        data.clear();//TODO:清空彩票机中奖数据
        do {
            data.add(getRandomNumber());
        } while (data.size() != SELECT_NUMBER);
    }
    /*
        刷新彩票机的的中奖数据
    */
    public int lottery(Set<Integer> selected) {
        int num;
        selected.addAll(data);
        num = 2 * SELECT_NUMBER - selected.size();
        return num;
    }
    /*
        查看本期的中奖号码
    */
    public Set<Integer> getWinNumber() {
        final Set<Integer> result = new HashSet<>(data); //TODO :一定要创建新的对象，否则后续刷新将改变getWinNumber()的结果
        this.refresh();
        return result;
    }
    /*
        获取一个符合彩票范围的随机数
    */
    static private int getRandomNumber() {
        double random = Math.random();
        return 1 + (int) (random * RANGE);
    }
}

デカルト積

プリントアウト二つの入力文字列の集合であるクラスを設計する方法であって、（各セット内の文字列は、同じ意味を有し、例えば、完全な名前は、文字列、完全な文字列クラスです）、二組の直積。

コード

Main.java

import java.util.*;

public class Main {
    static final Scanner cin = new Scanner(System.in);

    public static void main(String[] args) {
        // write your code here
        int n;
        CartesianProductCalculator<Object> calculator = new CartesianProductCalculator<Object>();
        /*
            数据的填入
        */
        String[] str1 = {"小明", "小红"};
        String[] str2 = {"一班", "二班"};
        List<Set<Object>> list = new ArrayList<>();
        list.add(new HashSet<>(Arrays.asList(str1)));
        list.add(new HashSet<>(Arrays.asList(str2)));

        /**
         * 该编写方式实现了求n个任意集合的笛卡尔积
         * 下方已注释代码块提供了String Integer Double 求笛卡尔积的实例
         */

/*
        Integer[] str3 = {1, 2};
        Double[] str4 = {99.5, 86.4};
        String[] str5 = {"A"};
        list.add(new HashSet<>(Arrays.asList(str3)));
        list.add(new HashSet<>(Arrays.asList(str4)));
        list.add(new HashSet<>(Arrays.asList(str5)));
*/
        calculator.inputData(list);
        //展示结果
        Set<List<Object>> ans = calculator.getAns();
        for (List<Object> i : ans) {
            for (int j = 0; j < i.size(); ++j) {
                if (j != 0) System.out.print(" ");
                System.out.print(i.get(j));
            }
            System.out.print("\n");
        }
    }
}

CartesianProductCalculator.java

import java.util.*;

/*
    笛卡尔积计算器
*/

class CartesianProductCalculator<E> {
    List<Set<E>> data;/* = new List<>();*/
    Set<List<E>> ans;
    // 通过传参输入数据
    public void inputData(List<Set<E>> data)
    {
        this.data = new ArrayList<Set<E>>(data);
    }
    /*
        通过两两求笛卡尔积的方式，求任意数量集合的笛卡尔积
    */
    private void calculate(){
        ans = new HashSet<List<E>>();
        Iterator it = data.iterator();
        if(it.hasNext()){
            Set<E> tmp = data.get(0);
            for(E e : tmp){
                List<E> node = new ArrayList<E>();
                node.add(e);
                ans.add(node);
            }
        }
        for(int i = 1; i < data.size(); ++i)
        {
            List<E> first = new ArrayList<E>(data.get(i));
            List<List<E>> second = new ArrayList<List<E>>(ans);
            ans.clear();
            for(E fir : first)
                for(List<E> sec : second)
                {
                    List<E> node = new ArrayList<E>(sec);
                    node.add(fir);
                    ans.add(node);
                }
        }
    }
    // 计算并返回结果
    public Set<List<E>> getAns(){
        calculate();
        return ans;
    }
}

王党派ゲーム

作者：张峰老师
单位：山东科技大学

アナログライセンスプロセスゲームの王党派開始。ルール：4ポーカー、5人のプレーヤー。1）マークキング皇帝があります。ディーラーは、ディーラーはプレイヤーの王を持つたびに皇帝です。2）天皇ガード（も皇帝のグループとのゲーム中に、ポールの子供、ジオイカとして知られている）を選択します。カードの彼の3枚のカードから皇帝の同じ選択（ランクとスーツが同じである）を持つプレーヤーとして（ 4人の他のプレイヤーはこのカードは警備員である必要があり、2,3、キングサイズ）にすることはできません。例えば、皇帝は3人の心5、5人の警備員の心のある選手の4人の他のプレイヤーを持っています。特殊な例：皇帝が自分のガードを行うことができますポイントカードの同じ数の4枚のカードの1）天皇セット、2）天皇は、アクセスガードの欠如をライセンス要件を満たしていませんでした。プログラムの要件：プログラムが起動した後、5人のプレーヤーを生成し、自動的にそれらにカードを送ります。その後、出力：1）名称と皇帝ガードと彼のカード（各カードの出力は、カードの使用「」スプリット間の心5、として「色」+「ポイント」）であり、キングに応じて、小王、2、K、Q、J、順次配置10,9,8,7,6,5,4,3が、一緒に同じスーツのカードのカードの異なった色の点の同じ数; 2）警備員の特定のブランド（「色」+「ポイント」）行くように。あなたは警備員を得ることができない場合は、プログラムは迅速に対応する出力します。たとえば、次のような結果を実行しているプログラムの出力：

皇帝は：プレイヤー1
皇帝カードである：[皇帝、王、王、王、王、正方形片2,2スペードは、スペード、ハートA、正方形片K、プラムスペードK、Kをスペード、ハートK、梅Q、梅Qは、Q、J正方形シート、サイドシートJ、J正方形ピース、J心臓、クラブ9,9スペード、スペード9、正方形片8をスペード、8プラム、心8、7つのクラブ、スペード7,7スペード、ハートの7、クラブ6,6クラブ、スペード6、スペード6、サイドプレート5、クラブ5、スペード5枚のスペード5、梅4,4梅梅4、サイドプレート3、心臓の三】

警備員がカードをされ、対応する：J正方形の作品

警備員は、次のとおりです。2人の選手

ガードカードである：[正方形片2,2スペード、ハート2、側片A、正方形片K、梅K、梅Kは、Kがスペード、ハートK、心Kは、Qがスペード、ハートQ、J正方形シート、サイドシート10、10枚のスペード、ハート10、10人の心、心臓10、側片9,9心臓、正方形片8、梅8,8クラブ、スペード8枚のスペード8,8スペード、赤いハート8、心8、側板7,7スペード、スペード7、サイドシート6、6枚のスペード、スペードの5、クラブ4,4スペード、ハート4、 4桃、側片3,3クラブ、スペード3,3心臓、心臓3]

コード

Main.java

public class Main {
    public static void main(String[] args) {
    // write your code here
        Game game = new Game();
        game.run();
    }
}

Game.java

import java.util.Set;

/*
    游戏类
*/

public class Game {
    //默认的玩家数量
    static final int DEFAULT_PLAYER_NUMBER = 5;
    //默认几副牌
    static final int DEFAULT_DECK_NUMBER = 4;
    //玩家数
    private int playerNumber;
    //牌的数量
    private int deckNumber;
    //发牌员对象实例
    private Dealer dealer;
    //玩家对象实例
    private Player[] players;

    public Game() {
        //创建玩家
        this.playerNumber = DEFAULT_PLAYER_NUMBER;
        players = new Player[playerNumber];
        //生成牌堆
        this.deckNumber = DEFAULT_DECK_NUMBER;
        dealer = new Dealer(deckNumber);
        
        // 创建数组不会自动生成对象
        for (int i = 0; i < players.length; ++i)
            players[i] = new Player();

    }

    public Game(int playerNumber, int deckNumber) {
        this.playerNumber = playerNumber;
        this.deckNumber = deckNumber;
        dealer = new Dealer(deckNumber);
        players = new Player[playerNumber];
        // 创建数组不会自动生成对象
        for (int i = 0; i < players.length; ++i)
            players[i] = new Player();
    }
    /*
        询问各玩家是不是皇帝
    */
    private int findEmperor() {
        int i;
        for (i = 0; i < players.length; ++i)
            if (players[i].isEmperor())
                break;
        return i;
    }
    /*
        游戏运行
    */
    public void run() {
        //发牌员发牌
        dealer.licensing(players);
        //获取皇帝
        int emperorId = findEmperor();
        System.out.println("玩家" + (emperorId + 1) + "是皇帝");
        System.out.println("手牌是" + players[emperorId].cardsToString());
        
        Set<PokerCard> s = players[emperorId].getEmperorCard(deckNumber);
    
        /*
            展示可选的侍卫，以及侍卫的牌
        */
        
        if (s.size() > 0) {
            System.out.print("可选的侍卫牌有:");
            for (PokerCard card : s)
                System.out.print(" " + card);
            System.out.print('\n');
            for (PokerCard card : s) {
                System.out.print("\n如果你选择" + card + ",那么");
                int i;
                for (i = 0; i < players.length; ++i)
                    if (players[i].getCardCount(card) == 1 || players[i].getCardCount(card) == 4)
                        break;
                if (i == emperorId)
                    System.out.println("你得自保");
                else {
                    System.out.println("你的侍卫是玩家" + (i + 1));
                    System.out.print("他的手牌是:");
                    System.out.println(players[i].cardsToString());
                }
            }
        } else {
            System.out.println("很遗憾，你没有可选的侍卫牌");
        }
    }
}

Dealer.java

import java.util.*;

public class Dealer {
    private Queue<PokerCard> cardsQueue = new LinkedList<PokerCard>();
    private int deckNumber;

    public Dealer(int deckNumber) {
        
        this.deckNumber = deckNumber;
        refreshQueue();
    }

    public void setDeckNumber(int deckNumber) {
        //设置要发几副牌
        this.deckNumber = deckNumber;
        refreshQueue();
    }

    public void refreshQueue() {
        //刷新发牌队列
        cardsQueue.clear();
        List<PokerCard> cards = new LinkedList<PokerCard>();
        for (int i = 0; i < this.deckNumber; ++i)
            cards.addAll(makePokercards());
        //产生皇帝，取出发牌队列中的第一个大王，使其变成皇帝
        cards.set(cards.indexOf(new PokerCard(PokerCard.BIG_JOKER_INDEX, PokerCard.JOKER_POINT))
                , new PokerCard(PokerCard.EMPEROR_INDEX, PokerCard.JOKER_POINT));
        //洗牌
        Collections.shuffle(cards);
        cardsQueue.addAll(cards);
    }

    public void licensing(Player... players) {
        //发牌
        while (!cardsQueue.isEmpty())
            for (Player player : players) {
                if (cardsQueue.isEmpty()) break;
                //空指针异常处理
                try {
                    //发牌员将单张的扑克牌发给玩家
                    player.addCard(cardsQueue.poll());
                } catch (NullPointerException e) {
                    System.out.println("空指针异常: " + e);
                }
            }
    }

    private ArrayList<PokerCard> makePokercards() {
        ArrayList<PokerCard> cards = new ArrayList<PokerCard>();
        //生成大王小王
        cards.add(new PokerCard(PokerCard.BIG_JOKER_INDEX, PokerCard.JOKER_POINT));
        cards.add(new PokerCard(PokerCard.SMALL_JOKER_INDEX, PokerCard.JOKER_POINT));
        //生成其他牌
        for (int i = 0; i < 4; ++i)
            for (int j = 0; j < PokerCard.POINT.length; ++j)
                cards.add(new PokerCard(i, j));

        return cards;
    }
}

Player.java

import java.util.HashMap;
import java.util.Set;
import java.util.TreeSet;

public class Player {
    //存储有哪些牌
    private Set<PokerCard> handCards = new TreeSet<PokerCard>();
    //存一下都有几张
    private HashMap<PokerCard, Integer> cardsCounter = new HashMap<PokerCard, Integer>();
    boolean emperor = false;

    //通过传参的方式获取一张牌
    public void addCard(PokerCard poll) {
        handCards.add(poll);
        //自己看一下是不是皇帝
        if (poll.getSuit().equals("皇上"))
            emperor = true;
        cardsCounter.merge(poll, 1, Integer::sum);
    }

    //获取某一种牌的张数
    public int getCardCount(PokerCard card) {
        if (cardsCounter.get(card) == null)
            return 0;
        else return cardsCounter.get(card);
    }

    //手里的牌转换成字符串
    public String cardsToString() {
        StringBuilder str = new StringBuilder();
        str.append("[");
        boolean flag = true;
        for (PokerCard card : handCards) {
            for (int i = 0; i < cardsCounter.get(card); ++i) {
                if (flag) flag = false;
                else str.append(", ");
                str.append(card.toString());
            }
        }
        str.append("]");
        return str.toString();
    }

    //告知别人自己是不是皇帝
    public boolean isEmperor() {
        return emperor;
    }

    //看一下自己可以选哪张牌作为侍卫牌
    public Set<PokerCard> getEmperorCard(int deckNumber){
        Set<PokerCard> ret = new TreeSet<PokerCard>();
        for (PokerCard card : handCards)
            if(!card.getPoint().equals("") && !card.getPoint().equals("3") && cardsCounter.get(card) >= (deckNumber - 1))
                ret.add(card);
        return ret;
    }

}

PokerCard.java

import java.util.Objects;

public class PokerCard implements Comparable<PokerCard> {
    //小王花色序号
    static public final int SMALL_JOKER_INDEX = 4;
    //小王花色序号
    static public final int BIG_JOKER_INDEX = 5;
    //王的点数
    static public final int JOKER_POINT = 100;
    //小王花色序号
    static public final int EMPEROR_INDEX = 6;
    //扑克牌的牌面
    static public final String[] SUIT = { "梅花","方片","红桃","黑桃", "小王", "大王", "皇上"};
    static public final String[] POINT = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
    //存储点数和花色
    private int suit, point;

    public PokerCard(int suit, int point) {
        this.suit = suit;
        this.point = point;
    }
    //获取牌的花色点数
    public String getSuit() {
        return SUIT[suit];
    }
    public String getPoint() {
        if (point != JOKER_POINT)return POINT[point];
        else return "";
    }

    @Override
    public String toString() {
        return getSuit() + getPoint();
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        PokerCard pokerCard = (PokerCard) o;
        return suit == pokerCard.suit && point == pokerCard.point;
    }

    @Override
    public int hashCode() {
        return Objects.hash(suit, point);
    }
    //牌的排序方法
    @Override
    public int compareTo(PokerCard o) {
        if(point == o.point) {
            return -Integer.compare(suit, o.suit);
        }
        else return -Integer.compare(point, o.point);
    }
}

（オプション）XMAN

教授チャールズ・エグゼビアは、X-メン、彼らの力と弱さのすべての種類を覚えてタフな時間を持っています。脳の向上に伴い、彼の心は、地球上の任意の場所に到達することができます。彼はすぐにそれらを見つけることができるようにX-男性のデータベースを構築することを決めました。あなたはこの宿題で偉大な教授を支援します。
編集：コンストラクタは今だけでなく1体の敵の敵のリストを取ります。
あなたは、この情報を格納するために2つのクラスを作成する必要があります。まず、XMANクラスを作成する必要があります。それは、次の方法が必要になります。

方法	特徴
公共XMAN（文字列名、文字列のXName、文字列のパワー、文字列の弱点、リスト<文字列>敵、日付生年月日、文字列の性別、文字列のDNA配列）	コンストラクタは、適切なインスタンス変数を設定する必要があります。
公共の文字列のgetName（）	このメソッドは、たXName（名前）のように連結したXNameと名前を返す必要があります。
公共の文字列getPower（）	電源を返します。
公共の文字列getWeakness（）	弱さを返します。
公共の一覧<XMAN> getEnemy（）	敵Xmenを返します。
公共日getBirthDate（）	生年月日を返します。あなたは、パッケージをインポートする必要がありますjava.util.date
公共の文字列getGender（）	性別を返します。
公共の文字列getDNASequence（）	（デバッグ用のprint文を使用することを決定した場合、これは本当に長い文字列であることに注意してください）DNA配列を返します。
パブリックブールのequals（オブジェクトo）	あなたが等しい同一のDNA配列を有する2つのXMANが等しいと見なされるように、（）メソッドをオーバーライドする必要があります。

X-男性がたくさんあるので、私たちはそれらを見て、高速な方法が必要です。我々は、DNA配列と名の両方で、レコードを検索する方法を作成するために、クラスで説明したハッシュテーブルを使用するつもりです。リストの二つの配列が含まれていますクラスXDatabaseを行います。

一覧<XMAN> [] dnaSeq。

一覧<XMAN> [] nameIndex。

配列の各インデックスのリストを持つことは、私たちは、単にその場所に複数のレコードを追加することによって、衝突を処理することができます。あなたが好きなリンクリストや配列リストを使用することができます。（これはあなたの/ JavaのデフォルトのLinkedList / ArrayListにすることができます）

Javaの基本クラスオブジェクトは、そのオブジェクトの値に基づいて整数を返すメソッドのハッシュコード（）を有しています。これは負の整数を返すことができることに注意することが重要ですので、あなたがそれをハッシュするとき、あなたは絶対値を取る必要があります。だから我々はレコードがでthednaSeq配列に属する位置を把握することができます：

int i = Math.abs(xman.getDNASequence().hashCode()) % dnaSeq.length;

私達は私達のデータベースではX-男性の数が多いとしているので、我々は、メモリ使用量を意識する必要があります。これは、我々はそのインデックスに何かを保存するまで、我々は、インデックスのリストを作成しないことを意味します。
最後に、これはあなたのXDatabaseクラスで実装する必要がありますメソッドのリストです：

方法	特徴
公共XDatabase（int型のサイズ）	コンストラクタは、指定したサイズであるためにあなたの二つの配列を初期化します。また、あなたのデータベース内の項目の合計数を追跡する必要がありますので、あなたもここで0にサイズの変数を初期化する必要があります。
公共XMAN追加（XMANのxmanの）	この方法は、XMANに取り、適切な場所にdnaSeqとnameIndex配列に両方を追加します。同じDNA配列を持つレコードがデータベースに既に存在している場合は、交換を受ける必要があり、前のレコードが返されます。そうでない場合はnullを返します。
公共XMAN getByDNASequence（文字列dnaSeqence）	この方法では、あなたのdnaSeqリストを使用して、指定されたDNA配列とXMANを検索します。そのDNA配列を持つレコードが存在しない場合はnullを返す必要があります。
公共の一覧<XMAN>のgetByName（文字列名）	この方法は、nameIndexを使用して、名前に基づいてXMANを検索します。複数XMANが同じ名前を持つことが可能ですので、それが一致する名前でXMANのリストを返します。レコードが一致しない場合は、空のリストが返されます。
公共XMAN削除（文字列dnaSeq）	この方法では、両方の索引から一致するdnaSeqでXMANを削除し、そのレコードを返す必要があります。レコードが見つからない場合は、nullを返す必要があります。
公共int型のサイズ（）	このメソッドは、データベースに保存されているXMANの数を返す必要があります。
公共の一覧<XMAN>友人（文字列dnaSeq）	XMANのdnaSeqを考えると、彼/彼女の友人を見つけます。XMAN A、AがBの敵の一覧とAにない場合にのみ、何の友人が見つからない場合は、Bのenemysにの少なくとも一つの敵のリストに含まれている場合は、空のリストを返し、別のXMAN Bの友人です。
公共の一覧<XMAN>パートナー（文字列名）	XMANの名前を考えると、彼/彼女のパートナーを見つけます。XMAN AおよびAは、Bの敵一覧ではなく、何のパートナーが見つからない場合は、AがBのすべての敵の敵のリストにある場合にのみ、空のリストを返す場合は、別のXMAN Bのパートナーです。複数XMANが同じ名前で検出された場合は、リスト内のすべてのパートナーを連結します。
公共の一覧<XMAN>ライバル（文字列名）	XMANの名前を考えると、彼/彼女のアーチライバルを見つけます。Aは、バンドAの敵のリストにある場合にのみ何のアーチライバルが見つからない場合は、空のリストを返すBのすべての友達の敵のリストにある場合XMAN Aは、別のXMAN Bのアーチライバルです。複数XMANが同じ名前で検出された場合は、リスト内のすべての彼らのアーチライバルを連結します。

コード

Xman.java

import java.util.*;
public class Xman {
    private String name;
    private String xname;
    private String power;
    private String weakness;
    private List<String> enemy;
    private Date birthDate;
    private String gender;
    private String DNASequence;

    public Xman(String name, String xname, String power, String weakness, List<String> enemy, Date birthDate, String gender, String DNASequence) {
        this.name = name;
        this.xname = xname;
        this.power = power;
        this.weakness = weakness;
        this.enemy = enemy;
        this.birthDate = birthDate;
        this.gender = gender;
        this.DNASequence = DNASequence;
    }

    public String getName() {
        return xname+"("+name+")";
    }

    public String getWeakness() {
        return weakness;
    }

    public List<String> getEnemy() {
        return enemy;
    }

    public Date getBirthDate() {
        return birthDate;
    }

    public String getGender() {
        return gender;
    }

    public String getDNASequence() {
        return DNASequence;
    }

    public int dnaHash() {
        return Math.abs(getDNASequence().hashCode()) % getDNASequence().length();
    }
    
    public int nameHash() {
        return Math.abs(getName().hashCode()) % getName().length();
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Xman xman = (Xman) o;
        return Objects.equals(DNASequence, xman.DNASequence);
    }
}

XDatabase.java

import java.util.*;

public class XDatabase {
    private List<Xman>[] dnaSeq;
    private List<Xman>[] nameIndex;
    private int size;

    public XDatabase(int size) {
        this.size = size;
        init();
    }

    public XDatabase() {
        this.size = 0;
        init();
    }

    private void init() {
        dnaSeq = new ArrayList[size];
        nameIndex = new ArrayList[size];
        for (int i = 0; i < size; ++i) {
            dnaSeq[i] = new ArrayList<Xman>();
            nameIndex[i] = new ArrayList<Xman>();
        }
    }

    public Xman add(Xman xman) {
        Xman bak = null;
        int nameId = xman.nameHash() % size;
        int dnaId = xman.dnaHash() % size;
        if (nameIndex[nameId] == null) {
            nameIndex[nameId] = new ArrayList<Xman>();
            nameIndex[nameId].add(xman);
        }else {
            nameIndex[nameId].add(xman);
        }
        if(dnaSeq[dnaId] != null) bak = dnaSeq[dnaId].get(0);
        dnaSeq[dnaId] = new ArrayList<Xman>();
        dnaSeq[dnaId].add(xman);
        return bak;
    }

    private static int dnaHash(String dnaSeqence) {
        return Math.abs(dnaSeqence.hashCode()) % dnaSeqence.length();
    }

    public Xman getByDNASequence(String dnaSeqence) {
        int dnaId = dnaHash(dnaSeqence);
        return dnaSeq[dnaId]==null? null:dnaSeq[dnaId].get(0);
    }

    private static int nameHash(String name) {
        return Math.abs(name.hashCode()) % name.length();
    }

    public List<Xman> getByName(String name) {
        int nameId = nameHash(name);
        return nameIndex[nameId];
    }

    public Xman delete(String dnaSeq) {
        Xman ret = getByDNASequence(dnaSeq);
        for(int i = 0; i < size; ++i){
            if(this.dnaSeq[i].contains(ret))
                this.dnaSeq[i].clear();
            int id;
            if((id = nameIndex[i].indexOf(ret)) != -1)
                nameIndex[i].remove(id);
        }
        return ret;
    }

    public int size() {
        return this.size;
    }

    public List<Xman> friends(String dnaSeq) {
        //要找朋友的Xman
        Xman xmanFind = getByDNASequence(dnaSeq);
        List<Xman> xFriends = new ArrayList<Xman>();
        if(xmanFind == null) return xFriends;
        for(int i = 0; i < size; ++i){
            if(this.dnaSeq[i].size() == 0)continue;
            Xman check = this.dnaSeq[i].get(0);
            if(xmanFind.getEnemy().contains(check.getDNASequence())) continue;
            for(int j = 0; j < xmanFind.getEnemy().size(); ++j){
                Xman enemy = getByDNASequence(xmanFind.getEnemy().get(j));
                if(enemy == null) continue;
                if(enemy.getEnemy().contains(check.getDNASequence()))
                {
                    xFriends.add(check);
                    break;
                }
            }
        }
        return xFriends;
    }

    public List<Xman> partner(String name) {
        List<Xman> xmanBs = getByName(name);
        List<Xman> partners = new ArrayList<Xman>();
        for (Xman xmanB : xmanBs)
            for(int i = 0; i < size; ++i){
                if(dnaSeq[i].size() == 0)continue;
                Xman xmanA = dnaSeq[i].get(0);
                if(xmanB.getEnemy().contains(xmanA.getDNASequence()))continue;
                boolean ok = true;
                for(int j = 0; j < xmanB.getEnemy().size(); ++j){
                    Xman enemy = getByDNASequence(xmanB.getEnemy().get(j));
                    if(!enemy.getEnemy().contains(xmanA.getDNASequence())){
                        ok = false;
                        break;
                    }
                }
                if(ok)
                    partners.add(xmanA);
            }

        return partners;
    }
    /**
     * 给定Xman的名字，找到他/她的主要对手。 当且仅当A在B的敌方列表中并且A在B的所有朋友的敌方列表
     * 中时，XmanA才是另一个XmanB的敌手。如果未找到任何敌方，则返回空列表。
     * 如果找到多个具有相同名称的Xman，则将其所有主要竞争对手串联在一起。
     * */
    public List<Xman> archrival(String name) {
        List<Xman> xmanBs = getByName(name);
        List<Xman> archrivals = new ArrayList<Xman>();
        for (Xman xmanB : xmanBs)
            for (int i = 0; i < size; ++i)
            {
                Xman xmanA = dnaSeq[i].get(0);
                if(xmanB.getEnemy().contains(xmanA.getDNASequence()))continue;
                boolean ok = true;
                List<Xman> Bfriends = friends(xmanB.getDNASequence());
                for(Xman bfriend : Bfriends)
                    if(!bfriend.getEnemy().contains(xmanA.getDNASequence())){
                        ok = false;
                        break;
                    }
                if(ok)
                    archrivals.add(xmanA);
            }
        return archrivals;
    }
}