圖書館仿真

     這是我一次仿真的嘗試，但是老實說，自我感覺並不是很好，因為有關於線程的問題並沒有想清楚，而且，真的，線程這種東西真的是很讓人頭暈啊，雖然我看書的時候，對於那些基礎的知識點是能夠理解，但是自己寫代碼的時候，就發現一個問題，就是現實生活中的實際模型復雜得很，不是書上幾個例子就能涵蓋的，看來我還是得慢慢捉摸這塊，畢竟並發這塊在現代越來越重要，尤其是現在交互式已經爛大街了。好吧，我先說明一下，這次我的仿真對象是什么，只是一個模擬中間有一個中轉台的圖書館查詢系統，就像是前台你跟服務員說一下你想要找的書，然后，然后服務員傳達給中轉台，中轉台在它的庫里尋找相關的內容，然后生成一份名單，名單上有這些書的評分，接着再到圖書館里尋找，畢竟圖書館里面的書的信息已經更換過了或者被別人借走了，假設中轉台的信息是比較落后的。 首先，說一下我的代碼的執行流程，首先，我一個方法是用來讓用戶輸入關鍵字的，然后將這個關鍵字傳給中轉台，使它能夠根據這個關鍵字在它的信息庫里找出相應的圖書，接着就是將這份名單傳給圖書館，圖書館再進一步看看它的信息庫里有沒有包含該書，然后就是顯示出來。這個過程，我們可以看到一點，就是如果用戶沒有輸入關鍵字，那個整個流程根本就不會開始，接着就是中轉台如果沒有生成名單，那么，圖書館也就不會運行，也就不會有任何東西顯示出來。那么，這個過程可以向下面那樣進行：

       用戶輸入關鍵字--->中轉台開始搜索圖書信息，這時，如果沒有名單交給圖書館，那么，圖書館這邊應該告訴用戶，現在正在檢索中，等到圖書館開始工作時，如果沒有生成名單，那么，正在檢索的信息依然還在控制台上顯示，知道圖書館這邊生成名單，就會告訴用戶，檢索完畢，然后將名單顯示出來，中間的確沒有什么共享的資源，因為它們之間的關系並不是競爭，更像是一種傳遞，只有前面一個流程結束，后面才能開始，那么，線程要如何體現呢？我覺得，所謂的線程，也就是一直在運轉的線程就是那個所謂的正在檢索中吧，因為它所貫穿的是兩個過程，也就是說，這個線程的開始是在輸入關鍵字開始，圖書館開始生成名單后結束，那么，我就能這么寫，當關鍵字輸入完后，這個線程就被喚醒，然后這個線程直到圖書館生成名單后掛起。那，我不應該將之前三個過程分開，因為它們其實是在一塊的邏輯，在這塊的邏輯中，決定什么時候將檢索這個線程喚醒和掛起而已。，好吧，試試看，然后，再得到這個運行的時間，來看看檢索的時間到底有多長。

       然后上代碼：

     

public class Library {
    private static long startTime = 0;
    private static long endTime = 0;

    @SuppressWarnings("deprecation")
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Call());
        String name = enterName();
        List<RatingBook> ratingList = checkName(name, t);
        List<RatingBook> bookList = getBook(ratingList);
        int flag = 0;
        for (int i = 0; i < bookList.size(); i++) {
            if ((bookList.get(i).getBook()).equals("")) {
                flag++;
            }
        }
        if (flag == bookList.size()) {
            t.stop();
            endTime = System.currentTimeMillis();
            System.out.println("圖書館沒有書！" + "檢索所需時間為：" + "\n"
                    + (endTime - startTime));
        } else {
            sortBook(bookList);
            t.stop();
            endTime = System.currentTimeMillis();
            for (int i = 1; i < bookList.size(); i++) {
                if (!(bookList.get(i).getBook().equals(""))) {
                    RatingBook book = bookList.get(i);
                    showInfor("圖書館里的圖書列表:", book);
                }
            }
            System.out.println("檢索所需時間為：" + "\n" + (endTime - startTime));
        }

    }
//顯示書本的內容
    private static void showInfor(String string, RatingBook book) {

        System.out.println(string + book.getBook() + " 評分：" + book.getRating());
    }
//按照評分的高低來將名單進行排列
    private static void sortBook(List<RatingBook> list) {

        for (int i = 0; i < list.size() - 1; i++) {
            for (int j = i + 1; j < list.size(); j++) {
                if ((list.get(i).getRating()) < (list.get(j).getRating())) {
                    String temp = list.get(i).getBook();
                    int rating = list.get(i).getRating();
                    list.get(i).setBook(list.get(j).getBook());
                    list.get(i).setRating(list.get(j).getRating());
                    list.get(j).setBook(temp);
                    list.get(j).setRating(rating);
                }
            }

        }

    }

    private static List<RatingBook> checkName(String name, Thread t) {
        t.start();
        startTime = System.currentTimeMillis();
        List<RatingBook> list = new ArrayList<RatingBook>();
        List<RatingBook> nlist = new ArrayList<RatingBook>();

        for (int i = 0; i < new Random().nextInt(10); i++) {
            RatingBook book = new RatingBook();
            bookLibrary bookArray = new bookLibrary();
            book.setBook(bookArray.bookArr1[new Random().nextInt(11)]);
            book.setRating(new Random().nextInt(6));
            list.add(book);
        }
        for (int i = 0; i < list.size(); i++) {
            String book = list.get(i).getBook().toLowerCase();
            showInfor("中轉台圖書列表：", list.get(i));
            if (book.contains(name)) {
                showInfor("有該書：", list.get(i));
                nlist.add(list.get(i));

            } else {
                showInfor("要刪除的圖書:", list.get(i));
            }
        }
        showList("現在的圖書列表：", nlist);

        sortBook(nlist);

        showList("符合條件的圖書列表：", nlist);
        return nlist;

    }
//顯示名單的內容
    private static void showList(String string, List<RatingBook> list) {

        for (int i = 0; i < list.size(); i++) {
            if (!(list.get(i).getBook().equals(""))) {
                System.out.println(string + list.get(i).getBook() + " 評分："
                        + list.get(i).getRating());
            }

        }

    }
//讓用戶輸入關鍵字進行查找
    private static String enterName() {
        BufferedReader name = new BufferedReader(new InputStreamReader(
                System.in));
        String entername = null;
        try {
            entername = name.readLine().toLowerCase();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return entername;
    }
//模擬圖書館的生成名單，就是圖書館會根據里面有沒有來將中轉台傳過來的名單進行修改，如果有，就加上中轉台里面的評分信息
    private static List<RatingBook> getBook(List<RatingBook> ratingList) {

        List<RatingBook> bookList = new ArrayList<RatingBook>();
        List<RatingBook> nbookList = new ArrayList<RatingBook>();
        RatingBook FlagBook = new RatingBook();
        FlagBook.setBook("");
        nbookList.add(FlagBook);
        for (int i = 0; i < new Random().nextInt(20); i++) {
            RatingBook book = new RatingBook();
            bookLibrary bookArray = new bookLibrary();
            book.setBook(bookArray.bookArr2[new Random().nextInt(13)]);
            book.setRating(0);
            bookList.add(book);
        }

        for (int i = 0; i < bookList.size(); i++) {
            for (int j = 0; j < ratingList.size(); j++) {
                if ((bookList.get(i).getBook().toLowerCase())
                        .contains((ratingList.get(j).getBook().toLowerCase()))) {
                    bookList.get(i).setRating(ratingList.get(j).getRating());
                    nbookList.add(bookList.get(i));
                } else {
                    nbookList.add(FlagBook);
                }
            }

        }
        return nbookList;

    }

}
//模擬前台服務員小姐常常說的：“現在正在等待中。。”這也是我這里面唯一一個附加的線程！
class Call implements Runnable {

    @Override
    public void run() {
        System.out.println("正在檢索中");

    }

}

      運行的結果如：

      java
正在檢索中
中轉台圖書列表：javascript 評分：5
有該書：javascript 評分：5
中轉台圖書列表：java 評分：1
有該書：java 評分：1
現在的圖書列表：javascript 評分：5
現在的圖書列表：java 評分：1
符合條件的圖書列表：javascript 評分：5
符合條件的圖書列表：java 評分：1
圖書館里的圖書列表:java and SQL 評分：1
圖書館里的圖書列表:java and SQL 評分：1
圖書館里的圖書列表:java and SQL 評分：1
檢索所需時間為：
4

     唉，說是仿真，但是我覺得這里面跟並發一點關系都沒有，只是我自己強加上一個線程而已，但是我現在的水平又想不出什么好的主意來，只能先放在博客上，希望哪個大神看到能提個醒，畢竟小弟現在還是新手，很多問題根本就無從下手啊！！！

     經過我的第一次重構后，這次，先就代碼的可讀性下手，並沒有考慮到性能，所以，有關於線程，排序等等，這些東西，先放一邊，我就直接上代碼：

    

public class Library {
    @SuppressWarnings("deprecation")
    public static void main(String[] args) throws InterruptedException,
            IOException {
        long endTime = 0;
        String name = enterName();
        Thread t = new Thread(new Call());
        t.start();
        long startTime = System.currentTimeMillis();
        List<RatingBook> doubanList = checkNameAndShowBookInDouban(name);
        List<RatingBook> libraryList = getBookFromLibrary(doubanList, name);
        sortBook(libraryList);
        t.stop();
        endTime = System.currentTimeMillis();
        System.out.println("圖書館里的圖書列表:");
        for (int i = 0; i < libraryList.size(); i++) {
            if (!(libraryList.get(i).getBook().equals(""))) {
                RatingBook book = libraryList.get(i);
                showInfor(book);
            }
        }
        System.out.println("檢索所需時間為：" + "\n" + (endTime - startTime));
    }

    private static String enterName() throws IOException {
        BufferedReader name = new BufferedReader(new InputStreamReader(
                System.in));
        String entername = name.readLine().toLowerCase();
        return entername;
    }

    private static List<RatingBook> checkNameAndShowBookInDouban(String name) {
        List<RatingBook> mlist = new ArrayList<RatingBook>();
        List<RatingBook> list = createAndReturnBookInZhongZhuanTai();
        RatingBook[] containsBook = new RatingBook[list.size()];
        RatingBook[] deleteBook = new RatingBook[list.size()];
        System.out.println("中轉台圖書列表：");
        for (int i = 0; i < list.size(); i++) {
            String book = list.get(i).getBook().toLowerCase();
            showInfor(list.get(i));
            if (book.contains(name)) {
                containsBook[i] = list.get(i);
                mlist.add(list.get(i));
            } else {
                deleteBook[i] = list.get(i);
            }
        }
        System.out.println("中轉台符合條件的圖書：");
        showInfoOfCheck(containsBook);
        System.out.println("要刪除的圖書：");
        showInfoOfCheck(deleteBook);
        System.out.println("符合條件的圖書列表：");
        showList(mlist);
        return mlist;
    }

    private static List<RatingBook> createAndReturnBookInZhongZhuanTai() {
        List<RatingBook> list = new ArrayList<RatingBook>();
        for (int i = 0; i < returnIndex(10); i++) {
            RatingBook book = new RatingBook();
            bookLibrary bookArray = new bookLibrary();
            book.setBook(bookArray.doubanBookList[returnIndex(11)]);
            book.setRating(returnIndex(6));
            list.add(book);
        }
        return list;
    }

    private static int returnIndex(int i) {
        return new Random().nextInt(i);
    }

    private static void showInfor(RatingBook book) {
        if (book == null) {
        } else {
            System.out.println(book.getBook() + " 評分：" + book.getRating());
        }
    }

    private static void showInfoOfCheck(RatingBook[] BookArr) {
        for (int i = 0; i < BookArr.length; i++) {
            showInfor(BookArr[i]);
        }
    }

    private static void showList(List<RatingBook> list) {
        sortBook(list);
        for (int i = 0; i < list.size(); i++) {
            if (!(list.get(i).getBook().equals(""))) {
                System.out.println(list.get(i).getBook() + " 評分："
                        + list.get(i).getRating());
            }
        }
    }

    private static void sortBook(List<RatingBook> list) {
        List<RatingBook> mlist = removeSameBook(list);
        sortBookByRating(mlist);
    }

    private static List<RatingBook> removeSameBook(List<RatingBook> list) {
        for (int i = 0; i < list.size() - 1; i++) {
            for (int j = i + 1; j < list.size(); j++) {
                if ((list.get(i).getBook()).equals(list.get(j).getBook())) {
                    list.remove(j);
                }
            }
        }
        return list;
    }

    private static void sortBookByRating(List<RatingBook> list) {
        for (int i = 0; i < list.size() - 1; i++) {
            for (int j = i + 1; j < list.size(); j++) {
                if ((list.get(i).getRating()) <= (list.get(j).getRating())) {
                    String temp = list.get(i).getBook();
                    int rating = list.get(i).getRating();
                    list.get(i).setBook(list.get(j).getBook());
                    list.get(i).setRating(list.get(j).getRating());
                    list.get(j).setBook(temp);
                    list.get(j).setRating(rating);
                }
            }

        }
    }

    private static List<RatingBook> getBookFromLibrary(List<RatingBook> list,
            String name) {
        List<RatingBook> bookList = new ArrayList<RatingBook>();
        List<RatingBook> mBookList = new ArrayList<RatingBook>();
        for (int i = 0; i < returnIndex(12); i++) {
            RatingBook book = new RatingBook();
            bookLibrary bookArray = new bookLibrary();
            book.setBook(bookArray.libraryBookList[returnIndex(13)]);
            book.setRating(0);
            bookList.add(book);
        }
        for (int i = 0; i < bookList.size(); i++) {
            if ((bookList.get(i).getBook()).contains(name)) {
                mBookList.add(bookList.get(i));
            }
        }
        for (int i = 0; i < mBookList.size(); i++) {
            for (int j = 0; j < list.size(); j++) {
                if ((mBookList.get(i).getBook())
                        .equals((list.get(j).getBook()))) {
                    mBookList.get(i).setRating(list.get(j).getRating());
                }
            }
        }
        return mBookList;
    }
}

      然后我就是將那個Runnable類移到其他文件里，就是這樣，不知道大家認為可讀性是不是比以前提高了，代碼運行效果如下：
      java
正在檢索中
中轉台圖書列表：
java and c 評分：1
sql 評分：5
INT 評分：1
INT 評分：5
ZHENGWENBIAO 評分：3
javascript 1 評分：3
中轉台符合條件的圖書：
java and c 評分：1
javascript 1 評分：3
要刪除的圖書：
sql 評分：5
INT 評分：1
INT 評分：5
ZHENGWENBIAO 評分：3
符合條件的圖書列表：
javascript 1 評分：3
java and c 評分：1
圖書館里的圖書列表:
javascript 評分：0
檢索所需時間為：
4