Collection的学习笔记

破车博特

已于 2022-11-02 15:06:52 修改

阅读量89

点赞数

分类专栏： Java Collection 文章标签： java 学习开发语言

于 2022-10-30 14:24:42 首次发布

本文链接：https://blog.csdn.net/MsXintu/article/details/127598978

版权

Java 同时被 2 个专栏收录

8 篇文章 0 订阅

订阅专栏

Collection

2 篇文章 0 订阅

订阅专栏

基础知识点概括：

// ———————————————————————————————————————— 集合 Collection ——————————————————————————————-——
// 知识概括:
// 1.Collection 是接口，父类为：Iterable 也是接口
// 1.1 : Collection 主要子类有： 1.Set（接口） 2.List（接口）
// 1.1.1 其中List中集合元素特点为：不可重复，有顺序（迭代时候怎么存进就以什么顺序出来），有下标
// 1.1.2 而Set 集合中的元素则相反，无顺序（迭代时候出来顺序则不同），无下标，
// 1.2 : List 主要子类： 1.ArrayList（类） 2.Vector（类） 3.LinkedList（类）
// 1.2 : Set 子类： 1.SortedSet（接口）该接口的子类有 TreeSet（类） 2.HashSet（类）
// 1.3 :Collection 中主要几个方法为 1.add（） 2.clear（） 3.size() 4.isEmpty() ，5contains（） 6.remove（）
// 2.父类接口 Iterable表示可迭代的，所有继承该接口的集合都是可迭代的，可遍历的
// 3.Collection 子类对象调用父类 Iterable中的 iterator() 方法可返回 iterator 对象，

// 4.其中iterator 主要的方法有三个： 1.hasNext() 2.next() 3.remove()
// 4.1 hasNext（）判断集合是否还有元素
// 4.2 next() 迭代器指向下一元素，并返回该对象，以Object类型返回
// 4.3 remove() 用迭代器删除集合内元素
// ---------在TestCollocation01有详细例子(上述部分)

// 5.1 其中Collection中 contains（）和 remove（）中都调用了 equals（）方法(Idea :Ctr + 鼠标单鲲左键)，且重写了该方法，比较的时候比较内容。
// 调用equals（）方法的原因为： 1.为了避免插入重复的元素，虽然插入重复的元素，不会编译报错，但无效
// 5.2 自己定义的类型，加入集合之前要重写equals（）方法，使其对比内容
// ---------在TestCollocation02有详细例子(上述部分)

// 6.1 在迭代器迭代的过程，一旦集合结构发生了变化（指的是：集合中元素发生改变），迭代器需要重写获取新的迭代器，不然报错
// 简单来说：迭代器要时时跟着集合内部情况，集合变，迭代器变
// ---------在TestCollection03中有详细例题(上述部分)

// 6.2 用迭代器删除集合元素，不需要重新获取迭代器，还可继续使用
//----------在TestCollection04中有详细例题(上述部分)

有关知识点的测试类（内含注释）

1. TestCollection01


import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class TestCollection01 {
    public static void main(String[] args) {
        Collection a=new ArrayList();// 【多态】 父类型引用指向子类对象

        // add(Object o)  ： 增添集合元素
        a.add(12);  // 自动封装为 Integer 类型
        a.add(3.14); // 自动封装为Double类型
        a.add("String");

        //size() ： 判断集合个数
        int n=a.size();
        System.out.println("该集合有"+n+"个元素"); // 3

        //isEmpty() : 判断集合是否为空，空则返回true，否false
        boolean b=a.isEmpty();
        System.out.println(b);// false

        //contains(Object o) : 判断是否包含某元素,包含true，否false
        boolean w=a.contains(12);
        System.out.println(w);// true

        // clear()  ：将集合元素清空
        a.clear();
        System.out.println(a.size());

        a.add("迭代输出");
        a.add(456);
        a.add(789);


        Iterator iterator= a.iterator(); // 子类的对象调用 iterator（）方法返回 iterator对象
        // iterator 主要三个方法：
        //1. hasNext() 判断集合是否有元素，有则true，否则false
        //2. next()  //
        //3. remove()
        //while判断，迭代输出
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }


    }
}

2. TestCollection02

import java.util.ArrayList;
import java.util.Collection;
import java.util.Objects;

public class TestCollection02 {
    public static void main(String[] args) {
        Collection collection=new ArrayList();
        String s1=new String("ok");
        String s2=new String("ok");
        collection.add(s1);

        //contains()的使用
        boolean judge=collection.contains(s2); // 判断是否包含s2元素，虽然s1与s2的地址不同，但是内容数字符串常量池同一个字符串“ok”
        System.out.println(judge);// true ： 原因：contains（）内部调用equals（）方法，且String类已经重写equals（）方法

        Bird bird=new Bird("小黑");
        Bird bird1=new Bird("小黑");
        collection.add(bird);// 添加自己定义的类
        boolean c=collection.contains(bird1);
        System.out.println(c);//false 没重写时候，重写之和为 true

        //remove()的使用,集合中添加的元素为 s1，和bird
        collection.remove(s2);
        collection.remove(bird1);
        System.out.println(collection.size()); // 结果集合元素个数为0，证明remove（）方法中调用了equals（）


    }
}

// 自己定义的类，并重写该类的equals（）方法
class Bird{
    String name;

    public Bird(String name) {
        this.name = name;
    }

    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || !(o instanceof Bird)) return false;
        Bird bird = (Bird) o;
        return this.name==bird.name;
    }

}

3.TestCollection03


import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

// 该类主要测试：1.Collection子类中List 和Set 对象的迭代差异
// 2.迭代器的获取地方，与集合改变之和的情况

public class TestCollection03 {
    public static void main(String[] args) {
        Collection collection1=new ArrayList();// new List 实现类中的 ArrayList 对象，（内部为数组数据结构）
        Collection collection2=new HashSet();// new Set实现类中的 HashSet对象，（内部为哈希表数据结构）

        /*在还为添加元素之前就获取迭代器（迭代时候会出错）
        Iterator iterator1=collection1.iterator();
        Iterator iterator2=collection2.iterator();*/


        // 为两个集合添加元素
        collection1.add(123);
        collection1.add(456);
        collection1.add(789);

        collection2.add("I");
        collection2.add("like");
        collection2.add("me");
        collection2.add("and you");

        // 两个实例对象分别调用iterator（）方法返回迭代器 （在添加元素之和才获取）
        Iterator iterator1=collection1.iterator();
        Iterator iterator2=collection2.iterator();

        //迭代输出
        System.out.println("ArrayList迭代输出：");
        while (iterator1.hasNext())
            System.out.println(iterator1.next()); // 顺序输出

        System.out.println("HasHSte迭代输出");
        while (iterator2.hasNext())
            System.out.println(iterator2.next()); //乱序输出

    }
}

4.TestCollection04

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

// 该类主要测试： 6.2 用迭代器删除集合元素，不需要重新获取迭代器，还可继续使用
public class TestCollection04 {
    public static void main(String[] args) {
        Collection collection1=new ArrayList();
        collection1.add(123);
        collection1.add(456);
        collection1.add("You");
        collection1.add("Me");
        collection1.add("like");
        collection1.add("jkjkjkjkjkjkjk");
        Iterator iterator=collection1.iterator();
        System.out.println(collection1.size());
        
        /*while (iterator.hasNext()){
            collection1.remove(iterator.next());//使用集合remove（）删除元素后，再迭代输出就报错
            System.out.println(iterator.next());
        }*/

        while (iterator.hasNext()){
            Object o=iterator.next();
            //System.out.println(o);
            iterator.remove();//使用迭代器remove（）删除元素后，再迭代输出（没问题）
            System.out.println(o);
        }
        System.out.println(collection1.size());
    }

}