Java集合类的list set map的理解运用

1.什么运用情景使用集合

集合：用于集中存放多个数据。如果我们事先知道我们要保存的数据量，那么数组是个很好的选择，一旦在数组初始化时指定了这个数组长度，这个数组长度就是不可变的，那么如果我们需要保存一个可以动态增长的数据(在编译时无法确定具体的数量)，就需要用到java的集合类了。

集合和数组的区别

数组是固定长度的；集合可变长度的。

数组可以存储基本数据类型，也可以存储引用数据类型；集合只能存储引用数据类型。

数组存储的元素必须是同一个数据类型；集合存储的对象可以是不同数据类型。

2.集合类

所有集合类都位于java.util包下。Java的集合类主要由两个接口派生而出：Collection和Map，Collection和Map是Java集合框架的根接口，这两个接口又包含了一些子接口或实现类。

Collection一次存一个元素，是单列集合；

Map一次存一对元素，是双列集合。Map存储的一对元素：键–值，键（key）与值(value)间有对应==(映射)==关系。

List , Set, Map都是接口，前两个继承至Collection接口，Map与Collection为独立的根接口。

（1）List：有序(元素存入集合的顺序和取出的顺序一致)，元素都有索引。元素可以重复。

（2）Set：无序(存入和取出顺序有可能不一致)，不可以存储重复元素。必须保证元素唯一性

list----有序可重复

List的主要实现：ArrayList， LinkedList， Vector。
ArrayList
优点: 底层数据结构是数组，*查询快，增删慢*。
缺点: *线程不安全，*效率高
Vector
优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程安全，效率低
LinkedList
优点: 底层数据结构是链表，查询慢，增删快。
缺点: 线程不安全，效率高

list的实现分别什么场景用

要安全吗?
是：Vector
否：ArrayList或者LinkedList
查询多：ArrayList
增删多：LinkedList
如果你知道是List，但是不知道是哪个List，就用ArrayList。
如果你知道是Collection集合，但是不知道使用谁，就用ArrayList。
如果你知道用集合，就用ArrayList。

set----无序唯一性

Set的主要实现HashSet，LinkedHashSet，TreeSet
HashSet
底层数据结构是哈希表。(无序,唯一)
如何来保证元素唯一性?
依赖两个方法：hashCode()和equals()

LinkedHashSet
底层数据结构是链表和哈希表。
1.由链表保证元素有序
2.由哈希表保证元素唯一

TreeSet
底层数据结构是红黑树。(唯一，有序)
1.如何保证元素排序的
自然排序
比较器排序
2.如何保证元素唯一性
根据比较的返回值是否是0来决定

set的实现分别什么场景用

唯一吗?
是：Set
排序吗?
是：TreeSet或LinkedHashSet
否：HashSet
如果你知道是Set，但是不知道是哪个Set，就用HashSet。

Map

Map接口
Map 是一种把键对象和值对象映射的集合
Map 的常用实现类：**HashMap、TreeMap、HashTable、

TreeMap：基于红黑树实现，有序的。

HashMap：基于哈希表实现。无序的，不同步的，线程不安全，效率较高。

HashTable：和 HashMap 类似，无序的，同步的，线程安全的，效率较低。现在可以使用 ConcurrentHashMap 来支持线程安全，并且ConcurrentHashMap 的效率会更高，因为 ConcurrentHashMap 引入了分段锁。

Map的实现分别什么场景用

有序吗?
是：TreeMap
如果对同步性或与遗留代码的兼容性没有任何要求，建议使用HashMap。

如何选用集合

根据集合的特点来选用，

（1）需要根据键值获取到元素值时就选用Map接口下的集合。
（2）需要排序时选择TreeMap,不需要排序时就选择HashMap,需要保证线程安全就选用ConcurrentHashMap.
（3）只需要存放元素值时，就选择实现Collection接口的集合，
（4）需要保证元素唯一时选择实现Set接口的集合比如TreeSet或HashSet，不需要就选择实现List接口的比如ArrayList或LinkedList，然后再根据实现这些接口的集合的特点来选用。

集合类的运用场景实例代码。

//集合类实现一个简单的图书管理系统，增删查改
//图书类
package Demo6;

    /*
     * 图书类
     */
    public class Book {
        private int id ;  		//书的编号
        private String name;		//书名
        private double price;		//价格
        private String author;		//作者
        public int getId() {
            return id;
        }
        public void setId(int id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public double getPrice() {
            return price;
        }
        public void setPrice(double price) {
            this.price = price;
        }
        public String getAuthor() {
            return author;
        }
        public void setAuthor(String author) {
            this.author = author;
        }
        /*
         * 在创建Book对象的时候明确书的具体属性
         */
        public Book(int id, String name, double price, String author) {
            super();
            this.id = id;
            this.name = name;
            this.price = price;
            this.author = author;
        }
        public Book() {
        }
        public String toString() {
            return "Book [id=" + id + ", name=" + name + ", price=" + price
                    + ", author=" + author + "]";
        }
    }


//管理方法
package Demo6;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class BookManege {
    /*
     * 主要负责存储图书
     */
        private static ArrayList<Book> DB = new ArrayList<>();

        //对外提供给DB中存储图书的功能
        public static boolean addBook( Book b ){
            return DB.add(b);
        }
        /*
         * 负责查询所有图书
         */
        public static List<Book> findAll() {
            return DB;
        }
        /*
         * 根据图书名称返回所有的图书
         */
        public static List<Book> find(String name) {

            //创建一个集合，用于存储符合name名称的所有图书
            List<Book> books = new ArrayList<>();
            //遍历容器，取出每本数，然后判断这本书的名字和传递进来的name是否相同
            for( Book b : DB ){
                if( b.getName().equals(name) ){
                    books.add(b);
                }
            }
            //在把DB遍历完之后判断，到底有没有符合条件的图书
            if( books.size() == 0 ){
                //没有符合条件的图书，就返回null
                return null;
            }
            return books;

        }
        /*
         * 根据id查询有没有这本书
         */
        public static boolean getBookById(int id) {
            boolean flag = false;
            //这里使用迭代器遍历，在遍历的时候可以删除数据
            for (Iterator<Book> it = DB.iterator(); it.hasNext();) {
                //获取一本书  Book b = it.next();  if( b.getId() == id ){
                //相同就删除
                it.remove();
                flag = true;
            }
		return flag;
    }
    //给DB中添加需要修改的图书
    public static boolean updateBook(Book b2) {
        return DB.add(b2);
    }

}

//主界面
package Demo6;

import java.util.List;
import java.util.Scanner;

/*
* 图书的增删改查
*/
public class BookText {
    public static void main(String[] args) {
        System.out.println("-------欢迎光临图书管理系统-------");
        //这里需要去调用其他的程序完成图书的更加具体的操作。
        new BookM().menu();
        System.out.println("-------您已经退出本图书管理系统-------");
        }
    }

 class BookM {

        private int id=1;

        public void menu(){

            System.out.print("A、输入图书信息\t");
            System.out.print("B、删除图书信息\t");
            System.out.print("C、修改图书信息\t");
            System.out.print("D、查询图书信息\t");
            System.out.print("E、查询所有图书信息\t");
            System.out.println("F、退出系统\t");
            System.out.println("请您选择具体的操作类型：");
            //获取用户输入的操作类型
            String operator = getKeyInfo();
            //把用户输入的操作类型转成大写
            operator = operator.toUpperCase();
            //使用switch语句分层次来判断到底用户输入的是什么操作符
            switch( operator ){
                case  "A" :
                    //调用获取图书对象的方法
                    Book book = getBook();
                    book.setId(id);
                    id++;
                    //把book对象存储到集合中。
                    boolean boo = BookManege.addBook(book);
                    //判断返回的boo值
                    if( boo ){
                        System.out.println("添加成功");
                    }else{
                        System.out.println("添加失败");
                    }
                    menu();
                    break;

                case  "B" :
                    System.out.println("删除图书");
                    /*
                     * 删除图书根据id删除。
                     * 1、第一步需要获取用户输入的图书id
                     * 2、把这个id传递到后台，然后遍历DB容器，取出图书的id，通过判断图书的id和传递的id是否相同
                     * 		相同就删除这本书。
                     * 注意：集合在删除的时候，需要使用迭代器自身的删除功能，不能在遍历的时候使用集合自身的删除功能。
                     */


                    break;

                case  "C" :
                    System.out.println("修改图书");
                    /*
                     * 根据id来修改图书信息
                     */
                    //首先需要用户输入id
                    System.out.println("请输入要修改图书的编号：");
                    int id = Integer.parseInt(getKeyInfo());
                    //把id传递后台，判断有没有这个id 的图书
                    boolean boo2 = BookManege.getBookById(id);
                    if( boo2 == false ){
                        System.out.println("此编号"+id+"没有对应的图书");
                    }else{
                        //在后台查询完成之后，有此id对应的图书
                        //让用户输入图书的其他信息并封装成book对象
                        Book b2 = getBook();
                        //给book设置id
                        b2.setId(id);
                        //把要修改的这个图书给后台
                        boolean b = BookManege.updateBook(b2);
                        if( b ){
                            System.out.println("恭喜您，修改成功");
                        }else{
                            System.out.println("很遗憾，修改失败");
                        }
                    }
                    menu();
                    break;

                case  "D" :
                    System.out.println("查询图书");
                    /*
                     *按照书名进行查询，注意书名可能重复，这样会导致查询到的是一个集合
                     */
                    String name = getBookName();
                    //把书名传递给后台程序，获取当前这个书名对象的所有的图书
                    List<Book> books = BookManege.find(name);
                    //判断当前的书名有没有查询到对应的图书
                    if( books == null ){
                        System.out.println(name+"没有这本书");
                    }else{
                        for(Book b : books){
                            System.out.println(b);
                        }
                    }
                    menu();
                    break;
                case  "E" :
                    List<Book> db = BookManege.findAll();
                    for(Book b : db){
                        System.out.println(b);
                    }
                    menu();
                    break;
                case  "F" :
                    System.out.println("退出图书");
                    System.out.println("================您已经退出本图书管理系统====================");
                    System.exit(0);
                default:
                    System.out.println("本系统现在不支持您的需求，请等待。。。。。");
            }

        }

        /*
         * 让用户输入书名，并把书名返回
         */

        public String getBookName() {
            System.out.println("请输入要查询的书名");
            return getKeyInfo();
        }
        /*
         * 用于获取图书信息
         */
        public Book getBook() {
            System.out.println("请输入图名称:");
            String name = getKeyInfo();
            System.out.println("请输入价格:");
            //这里处理对异常处理，保证可以正常获取到一个价格数据。
            double price = Double.parseDouble(getKeyInfo());
            System.out.println("请输入作者:");
            String author = getKeyInfo();
            //创建Book对象，把书名，价格还是作者封装到book，返回
            Book b = new Book();
            //给book封装数据
            b.setAuthor(author);
            b.setName(name);
            b.setPrice(price);
            //把book返回
            return b;
        }
        /*
         * 单独抽取方法，用于获取键盘录入数据
         */
        public String getKeyInfo(){
            Scanner s = new Scanner(System.in);
            return s.next();
        }

    }