集合目前所学

集合

---

一、集合是什么？

集合类是Java数据结构的实现。Java的集合类是java.util包中的重要内容，它允许以各种方式将元素分组，并定义了各种使这些元素更容易操作的方法。Java集合类是Java将一些基本的和使用频率极高的基础类进行封装和增强后再以一个类的形式提供。集合类是可以往里面保存多个对象的类，存放的是对象，不同的集合类有不同的功能和特点，适合不同的场合，用以解决一些实际问题。

二、分类

java中的集合类可以分为两大类：一类是实现Collection接口；另一类是实现Map接口。Map没有继承Collection接口，与Collection是并列关系。Collection有两个重要的子接口List和Set。

List

List有两个接口，一个是ArrayList，一个是LinkedList

List接口的特点

有下标 有序可重复 有序指的是按照新增的顺序存储 可重复指的是存储元素的值可以重复

ArrayList 和 LinkedList

ArrayList的优缺点 新增数据和删除数据比较慢，但是查询和修改速度快，因为是线性存储
因为List可以存放任意的数据类型，而ArrayList 和 LinkedList继承了List所以ArrayList 和 LinkedListt也可以存放任意的数据类型
LinkedList的优缺点 新增数据和删除数据比较快，但是查询和修改速度慢，因为是双向链表结构

@Test
    public void test01() {
        List list = new ArrayList();
        //新增元素
        byte a = 1;
        short b = 2;
        int c = 3;
        long d = 4l;
        double e = 5.0d;
        float f = 6.0f;
        char g = 'a';
        boolean h = false;
        Person person = new Person();
        list.add(a);
        list.add(b);
        list.add(c);
        list.add(d);
        list.add(e);
        list.add(f);
        list.add(g);
        list.add(h);
        list.add(person);
        System.out.println(list.size());
    }


 @Test
    public void test01() {
        List list = new LinkedList();
        //新增元素
        byte a = 1;
        short b = 2;
        int c = 3;
        long d = 4l;
        double e = 5.0d;
        float f = 6.0f;
        char g = 'a';
        boolean h = false;
        Person person = new Person();
        list.add(a);
        list.add(b);
        list.add(c);
        list.add(d);
        list.add(e);
        list.add(f);
        list.add(g);
        list.add(h);
        list.add(person);
        System.out.println(list.size());
    }

ArrayList 和 LinkedList遍历元素

 @Test
    //遍历元素
    public void test03() {
        List list = new ArrayList();
        for (int i = 0; i < 10; i++) {
            list.add("哈哈哈" + i);
            System.out.println(list.get(i));
        }
    }


  @Test
    //遍历元素
    public void test03() {
        List list = new LinkedList();
        for (int i = 0; i < 10; i++) {
            list.add("哈哈哈" + i);
            System.out.println(list.get(i));
        }
    }

ArrayList 和 LinkedList在指定下标插入，删除，修改数据

 @Test
    //在指定下标插入数据
    public void test04(){
        List list = new ArrayList();
        for (int i = 0; i < 10; i++) {
            list.add("哈哈哈" + i);
        }
        list.add(4,"哈哈哈");
        System.out.println(list);
    }


 @Test
    //在指定下标删除数据
    public void test05(){
        List list = new ArrayList();
        for (int i = 0; i < 10; i++) {
            list.add("哈哈哈" + i);
        }
        list.remove(4);
        System.out.println(list);
    }

 @Test
    //在指定下标修改数据
    public void test06(){
        List list = new ArrayList();
        for (int i = 0; i < 10; i++) {
            list.add("哈哈哈" + i);
        }
        list.set(4,"哈哈哈");
        System.out.println(list);
    }



 @Test
    //在指定下标插入数据
    public void test04(){
        List list = new LinkedList();
        for (int i = 0; i < 10; i++) {
            list.add("哈哈哈" + i);
        }
        list.add(4,"哈哈哈");
        System.out.println(list);
    }


 @Test
    //在指定下标删除数据
    public void test05(){
        List list = new LinkedList();
        for (int i = 0; i < 10; i++) {
            list.add("哈哈哈" + i);
        }
        list.remove(4);
        System.out.println(list);
    }


 @Test
    //在指定下标修改数据
    public void test06(){
        List list = new LinkedList();
        for (int i = 0; i < 10; i++) {
            list.add("哈哈哈" + i);
        }
        list.set(4,"哈哈哈");
        System.out.println(list);
    }

foreach循环遍历ArrayList 和 LinkedList

 @Test
    //foreach循环遍历ArrayList
    public void test07(){
        List list = new ArrayList();
        for (int i = 0; i < 10; i++) {
            list.add("哈哈哈" + i);
        }
        //Object 集合中元素的数据类型
        // name:遍历后集合中每一个元素的变量
        // list 被遍历的集合
        for (Object name:list) {
            System.out.print(name + "\t");
        }
    }


 @Test
    //foreach循环遍历LinkedList
    public void test07(){
        List list = new LinkedList();
        for (int i = 0; i < 10; i++) {
            list.add("哈哈哈" + i);
        }
        //Object 集合中元素的数据类型
        // name:遍历后集合中每一个元素的变量
        // list 被遍历的集合
        for (Object name:list) {
            System.out.print(name + "\t");
        }
    }

使用迭代器遍历

 @Test
    public void test09(){
    //<String> 泛型  可以简单理解为参数的数据类型
        List<String> list = new ArrayList();
        for (int i = 0; i < 10; i++) {
            list.add("哈哈哈" + i);
        }
        //获取该集合的迭代器
        Iterator<String> it = list.listIterator();
        while (it.hasNext()){
            String next = it.next();
            System.out.print(next + "\t");
        }
    }


@Test
    public void test09(){
        List<String> list = new LinkedList();
        for (int i = 0; i < 10; i++) {
            list.add("哈哈哈" + i);
        }
        //获取该集合的迭代器
        Iterator<String> it = list.listIterator();
        while (it.hasNext()){
            String next = it.next();
            System.out.print(next + "\t");
        }
    }

Set

Set接口的特点

无下标 无序不可重复 无序指的是不会按照新增的顺序存储 不可重复指的是存储元素的值不可以重复

HaHashSet（无序不可重复）

 @Test
    public void test02(){
        Set set = new HashSet();
        byte a = 1;
        short b = 2;
        int c = 3;
        long d = 4L;
        double e = 5.0d;
        float f = 6.0f;
        char g = 'a';
        boolean h = false;
        set.add(a);
        set.add(b);
        set.add(c);
        set.add(d);
        set.add(e);
        set.add(f);
        set.add(g);
        set.add(h);
        set.add(a);
        System.out.println(set);
    }

输出结果

[6.0, 1, a, 2, 3, 4, 5.0, false]

LinkedHashSet（有序不可重复 有序指的是按照新增的顺序存储）

 @Test
    public void test01(){
        Set set = new LinkedHashSet();
        byte a = 1;
        short b = 2;
        int c = 3;
        long d = 4L;
        double e = 5.0d;
        float f = 6.0f;
        char g = 'a';
        boolean h = false;
        set.add(a);
        set.add(b);
        set.add(c);
        set.add(d);
        set.add(e);
        set.add(f);
        set.add(g);
        set.add(h);
        set.add(a);
        System.out.println(set);
    }

输出结果为

[1, 2, 3, 4, 5.0, 6.0, a, false]

Treest

使用Treest排序

 /**
     * 书名
     */
    private String name;
    /**
     * 作者
     */
    private String author;
    /**
     * 单价
     */
    private int price;
    /**
     * 销量
     */
    private int sales;

    @Override
    public int compareTo(Object o) {
        Book book = (Book) o;
        int x = this.author.compareTo(book.getAuthor());
        int y = book.getPrice() - this.price;
        int z = book.getSales() - this.sales;
        int k = this.name.compareTo(book.getName());

        if (x != 0) {
            return x;
        } else if (y != 0) {
            return y;
        } else if (z != 0) {
            return z;
        } else {
            return k;
        }
    }


 @Test
    public void test01(){
        SortedSet<Book> books = new TreeSet<>();
        // books.add(new Book("一步之遥", "姜文", 35, 180));
        books.add(new Book("浮城谜事", "娄烨", 35, 150));
        books.add(new Book("邪不压正", "姜文", 35, 150));
        books.add(new Book("推拿", "娄烨", 33, 150));
        books.add(new Book("让子弹飞", "姜文", 33, 150));
        books.add(new Book("颐和园", "娄烨", 35, 180));
        books.add(new Book("一步之遥", "姜文", 35, 180));
        Iterator<Book> it = books.iterator();
        while (it.hasNext()){
            Book book = it.next();
            System.out.println(book);
        }
    }

Map

HashMap

    @Test
    //新增和读取
    public void test02(){
        HashMap<String, String> map = new HashMap<>();
        map.put("key1","value1");
        map.put("key2","value2");
        map.put("key3","value3");
        System.out.println(map.get("key1"));
        System.out.println(map.get("key2"));
        System.out.println(map.get("key3"));
    }
输出结果为value1 value2 value3

 @Test
    //修改和删除
    public void test03(){
        HashMap<String, String> map = new HashMap<>();
        map.put("key1","value1");
        map.put("key2","value2");
        map.put("key3","value3");
        System.out.println(("key2 >>>" + map.get("key2")));
        map.put("key2","v2");
        System.out.println(("key2 >>>" + map.get("key2")));
        map.remove("key2");
        System.out.println(("key2 >>>" + map.get("key2")));
    }
输出结果为key2 >>>value2 key2 >>>v2 key2 >>>null

• put 方法中key如果不存在就是新增 存在就是修改

判断key是否存在 存在就移除 不存在就不移除

 @Test
    //方法1
    public void test04(){
        HashMap<String, String> map = new HashMap<>();
        map.put("key1","value1");
        map.put("key2","value2");
        map.put("key3","value3");
        System.out.println(("key2 >>>" + map.get("key2")));
        if (map.containsKey("key5")){
            map.remove("key5");
            System.out.println("删除key5");
        }
        System.out.println(("key2 >>>" + map.get("key2")));
    }

@Test
    
    //方法2
    public void test05(){
        HashMap<String, String> map = new HashMap<>();
        map.put("key1","value1");
        map.put("key2","value2");
        map.put("key3","value3");
        System.out.println(("key2 >>>" + map.get("key2")));
        System.out.println("key2 >>>" + map.getOrDefault("key2","哈哈哈"));
        System.out.println("key2 >>>" + map.getOrDefault("key5","哈哈哈"));
    }

遍历

 @Test
    //遍历
    //方法1
    public void test07(){
        HashMap<String, String> map = new HashMap<>();
        for (int i = 0; i < 10; i++) {
            map.put("key" + i,"value" + i);
        }
        Set<String> keySet = map.keySet();
        Iterator<String> it = keySet.iterator();
        while (it.hasNext()){
            String key = it.next();
            System.out.println("key >>>" + key +"\tvalue" + map.get(key));
        }
    }

    @Test
    //遍历
    //方法2
    public void test08(){
        HashMap<String, String> map = new HashMap<>();
        for (int i = 0; i < 10; i++) {
            map.put("key" + i,"value" + i);
        }
        Collection<String> values = map.values();
        Iterator<String> it = values.iterator();
        while (it.hasNext()){
            String value = it.next();
            System.out.println(value);
        }
    }


    @Test
    //遍历
    //方法3
    public void test09(){
        HashMap<String, String> map = new HashMap<>();
        for (int i = 0; i < 10; i++) {
            map.put("key" + i,"value" + i);
        }
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        Iterator<Map.Entry<String, String>> it = entrySet.iterator();
        while (it.hasNext()){
            //entry中包含了key和value
            Map.Entry<String, String> entry = it.next();
            System.out.println("key >>>" + entry.getKey() + "\tvalue" + entry.getValue());
        }
    }

LinkedHashMap

 @Test
    public void test(){
        Map<String, String> map = new LinkedHashMap<>();
        for (int i = 0; i < 10; i++) {
            map.put("key" + i,"value" + i);
        }
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        Iterator<Map.Entry<String, String>> it = entrySet.iterator();
        while (it.hasNext()){
            //entry中包含了key和value
            Map.Entry<String, String> entry = it.next();
            System.out.println("key >>>" + entry.getKey() + "\tvalue >>>" + entry.getValue());
        }
    }

输出结果为
key >>>key1	valuevalue1
key >>>key2	valuevalue2
key >>>key0	valuevalue0
key >>>key5	valuevalue5
key >>>key6	valuevalue6
key >>>key3	valuevalue3
key >>>key4	valuevalue4
key >>>key9	valuevalue9
key >>>key7	valuevalue7
key >>>key8	valuevalue8

与HashMap不同，LinkedHashMap是有序的