List是一个接口，不能直接实例化，通过Arraylist来实例化

结合是一种类，一种工具类。可以存储任意数量的具有共同属性的对象。集合的长度是动态的，可以改变，数组不可以。

List（序列）有序可重复。Queue（队列）。Set（集）无序不可重复

Entry是Map的内部类，Key和value可以是任意类型

实现类；ArrayList（数组序列）LinkedList（链表） HashSet（哈希集）

HsahMap（哈希表）

JAVA中的集合类：一种工具类，储存任意数量的具有共同属性的对象

集合的作用：

        在类内部对数据进行组织

        简单快速的搜索大数量的条目（利用集合接口提供了一系列有序元素或对象的映射关系）

数组和集合：

        数组长度固定，集合容量可变     

        数组只能通过下标访问元素（下标一般是未知的）且类型固定，而有的集合（Map类）可通过任意类型查找所映射的具体对

JAVA集合框架：Collection接口 : 子接口：List  Queue （有序可重复）  Set（无序不可重复）

                                          子接口实现类：ArrayList   

                         Map : 重要实现类：哈希表（HashMap）

一定要注意哦：

1、 调用 SimpleDateFormat 对象的 parse() 方法时可能会出现转换异常，即 ParseException ，因此需要进行异常处理

2、 使用 Date 类时需要导入 java.util 包，使用 SimpleDateFormat 时需要导入 java.text 包

Books.java

package com.imooc;

public class Books {
    private int seqID = 0;
    private String bookName = "Book";
    
    public Books(int segID, String bookName) {
        this.seqID = segID;
        this.bookName = bookName;
    }

    public int getSeqID() {
        return seqID;
    }

    public void setSeqID(int seqID) {
        this.seqID = seqID;
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }
    
    
}

BookException.java

package com.imooc;

public class BookException extends Exception {
    public BookException(String message) {
        super(message);
    }
    
    
}

FindBook.java

package com.imooc;


public class FindBook {
    public void FindBookbyName(Books[] books, String bookName) {
        for (Books book : books) {
            if (bookName.equals(book.getBookName())) {
                bookName = "Found";
                System.out.println("Book Found: " + book.getBookName());
                break;
            }
        }
        if (!bookName.equals("Found")) {
            System.out.println("Book not exists!");
        }
    }
    
    public void FindBookbyID(Books[] books, int ID){
        if (ID < 0 || ID > books.length) {
            System.out.println("Book is not exists");
        } else {
            System.out.println("Book Found: " + books[ID-1].getBookName());
        }
    }
}

BookRentSys2.java

package com.imooc;
import java.util.Scanner;
import java.util.regex.Pattern;

public class BookRentSys2 {
    public static void main(String[] args) {
        /*
         * userInput: get user input from console
         * menuSelection: only could be 1 or 2
         */
        BookRentSys2 bs2 = new BookRentSys2();
        Scanner input = new Scanner(System.in);
        String userInput = "";
        int menuSelection = 0;
        Books[] books = {new Books(1, "JAVA1"),
                 new Books(2, "Java2"),
                 new Books(3, "JAva3")};
        
        // Show main menu and get user menu choice
        while (! userInput.equals("Q")) {
            bs2.showMenu();
            try {
                userInput = input.next();
                if (!userInput.equals("Q")) {
                    menuSelection = bs2.validinputInt(userInput);
                    if (menuSelection == 1 || menuSelection == 2) {
                        FindBook fb = new FindBook();
                        switch (menuSelection) {
                        case 1:
                            // Find book by ID
                            int bookID = 0;
                            while(bookID == 0) {
                                try {
                                    System.out.print("Enter bookID (only number be allowed): ");
                                    bookID = bs2.validinputInt(input.next());
                                } catch (BookException b1) {
                                    System.out.println(b1.getMessage());
                                }
                            }
                            fb.FindBookbyID(books, bookID);
                            continue;
                        case 2:
                            // Find book by Name
                            System.out.print("Please enter a bookname: ");
                            String bookName = input.next();
                            fb.FindBookbyName(books, bookName);
                            continue;
                        default:
                            System.out.println("Error Input");
                            continue;
                        }
                    } else {
                        System.out.println("No such function!");
                        continue;
                    }
                } else {
                    System.out.println("Goodbye!");
                }
            } catch (BookException b) {
                System.out.println(b.getMessage());
            }
        }
        
        input.close();
    }
    
    public void showMenu() {
        System.out.println("Please Enter your choice:"
                + " 1. Search book by sequence ID and 2. Search book by name and Q. Exit");
        System.out.print("Your choice now: ");

    }
    
    public int validinputInt(String input) throws BookException {
        Pattern p = Pattern.compile("^[0-9]+$");
        
        if (p.matcher(input).matches()) {
            return Integer.parseInt(input);
        } else {
            throw new BookException("Please enter per notify info!");
        }
    }
}
;

Comparable---默认的比较规则

Comparator---临时的比较规则

Comparator接口

Comparable接口

sort()

Collection.sort(List)方法排序规则，Integer从小到大排序，String按照0-9>A-Z>a-z排序

Map中用containsKey(key)/containsValue(Value)来判断是否包含某对象

indexOf()

set.contains(obj)

需要重写equals()

重写equals（）方法

public boolean equals(Object obj){
    if(this=== obj){
        return true;
    }
    if(obj == null)
    return false;
    if(!(boj instanceof Course))
    return false;
    Course course=(Course)obj;
    if(ths.name==null){
        if(course.name==null)
        return true;
        else
        return false;
    }else{
        if(this.name.equals(course.name))
        return true;
        else 
        return false;
    }
}

contains(),containsAll()

put（key,新Value）用于修改