Java进阶：Collection接口

已于 2022-04-06 15:18:18 修改
阅读量317 收藏 3
点赞数
分类专栏： Java 文章标签： java
于 2022-04-02 09:44:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53151171/article/details/123913293
版权

Collection接口

Collection接口

Collection中 只要是Object的子类型，都能存储(集合中不能直接存储基本数据类型，也不能存储java对象，只是存储Java对象的内存地址)
关于java.util.Collection接口中常用的方法

  1. boolean add(Object e) 向集合中添加元素
  2. int size() 获取集合中元素的个数
  3. void clear() 清空集合
  4. boolean isEmpty() 判断该集合中的元素个数是否为0
  5. boolean contains(Object o) 判断当前集合中是否包含元素o，包含返回true，不包含返回false
  6. boolean remove(Object o) 删除集合中的某个元素
  7. Object[] toArray() 把集合转换成数组
public class CollectionTest {
    public static void main(String[] args) {
        // 创建一个集合对象
        //Collection c = new Collection(); // 接口是抽象的，无法实例化
        // 多态
        Collection c = new ArrayList();

        // 测试Collection接口中的常用方法
        // 1. boolean add(Object e) 向集合中添加元素
        c.add(123);    // 自动装箱，实际上存储的是对象的内存地址
        // 2. int size() 获取集合中元素的个数
        System.out.println("集合中的元素个数是：" + c.size());  //1
        // 3. void clear() 清空集合
        c.clear();
        System.out.println("集合中的元素个数是：" + c.size());  //0

        // 4. boolean isEmpty() 判断该集合中的元素个数是否为0
        System.out.println(c.isEmpty());    //true

        // 再添加元素
        c.add("hello");
        c.add("would");

        // 5. boolean contains(Object o) 判断当前集合中是否包含元素o，包含返回true，不包含返回false
        System.out.println(c.contains("hello"));    //true

        // 6. boolean remove(Object o) 删除集合中的某个元素
        System.out.println("集合中的元素个数是：" + c.size());    //2
        c.remove("would");
        System.out.println("集合中的元素个数是：" + c.size());    //1
    }
}

集合遍历/迭代（重点）

集合遍历/迭代方式在Map集合中不能用，在所有的Collection以及子类中使用。
迭代器对象Iterator中的方法：

  • boolean hasNext() 如果仍有元素可以迭代，则返回true
  • Object next() 返回迭代器的下一个元素
public class CollectionTest01 {
    public static void main(String[] args) {
        // 创建集合对象，不一定要HashSet
        Collection c = new HashSet();

        // 添加元素
        c.add("asd");
        c.add("qwe");
        c.add(123);
        c.add(new Object());

        // 对集合Collection进行遍历/迭代
        // 1.获取集合对象的迭代器对象Iterator
        Iterator iterator = c.iterator();
        // 2.通过以上获取的迭代器对象开始迭代/遍历集合
        while (iterator.hasNext()) {
            Object obj = iterator.next();   //取出来的都是Object类型的
            System.out.println(obj);
        }
    }
}

深入contains、remove方法

总结：存放在集合里的类型必须重写equals方法

public class CollectionTest02 {
    public static void main(String[] args) {
        // 创建集合对象
        Collection c = new ArrayList();

        // 向集合中存储元素
        String s1 = new String("asd");
        c.add(s1);

        String s2 = new String("qwe");
        c.add(s2);

        // 集合中的元素个数
        System.out.println("集合中的元素个数是：" + c.size());    //2

        // 新建的对象String
        String s = new String("asd");
        // 底层调用equals方法，比较的是内容
        System.out.println(c.contains(s));  // true
        System.out.println("remove:" + c.remove(s));    // true
        System.out.println("集合中的元素个数是：" + c.size());    //1


        System.out.println("----------------------------------------");

        User u1 = new User("zxc");
        c.add(u1);

        User u = new User("zxc");

        System.out.println("集合中的元素个数是：" + c.size());    //2
        // 没有重写equals方法
        //System.out.println(c.contains(u));  //false
        //System.out.println("remove:" + c.remove(s));    //false
        // 重写equals方法之后
        System.out.println(c.contains(u));  //true
        System.out.println("remove" + c.remove(s));   //true
        System.out.println("集合中的元素个数是：" + c.size());
    }
}


class User{
    private String name;

    public User() {
    }

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

    // 重写equals
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || !(obj instanceof User)) return false;
        User user = (User) obj;
        return Objects.equals(name, user.name);
    }
}

重点：在迭代元素的过程中，一定要使用迭代器Iterator的remove方法删除元素，不要使用集合自带的remove方法，否则会出现ConcurrentModificationException异常

public class CollectionTest03 {
    public static void main(String[] args) {
        // 创建集合对象，不一定要HashSet
        Collection c = new ArrayList();

        // 添加元素
        c.add("asd");
        c.add("qwe");
        c.add("zxc");

        // 对集合Collection进行遍历/迭代
        // 注意：集合结构只要发生改变，迭代器必须重新获取
        Iterator iterator = c.iterator();

        while (iterator.hasNext()) {
            Object obj = iterator.next();
            // 删除元素之后，集合的结构发生了变化，会出现java.util.ConcurrentModificationException异常
            //c.remove(obj);    // 直接通过集合去删除元素，没有通知迭代器。（导致迭代器的快照与原集合不同）
            // 可以使用迭代器的remove()方法
            iterator.remove();  // 删除的一定是迭代器指向的当前元素（迭代器与原集合同时删除）
            System.out.println(obj);
        }
        System.out.println("集合中的元素个数是：" + c.size());    //0
    }
}

List接口

1.List集合存储元素特点：有序可重复
2.List是Collection接口的子接口，
以下是List接口特有的常用方法：

  1. void add(int index, Object element) 在列表指定位置插入指定元素（第一个参数是下标） 使用不多，效率较低
  2. Object set(int index, Object element) 修改指定位置的元素
  3. Object get(int index) 根据下标获取元素
  4. int indexOf(Object o) 获取指定对象第一次出现处的索引
  5. int lastIndexOf(Object o) 获取指定对象最后一次出现处的索引
  6. Object remove(int index) 删除指定下标位置的元素
public class ListTest {
    public static void main(String[] args) {
        // 创建List类型的集合
        List myList = new ArrayList();

        // 添加元素
        myList.add("asd");  // 默认都是向集合末尾添加元素
        myList.add("qwe");
        myList.add("zxc");
        myList.add("zxc");
        // 1. void add(int index, Object element) 在列表指定位置插入指定元素（第一个参数是下标）
        // 使用不多，效率较低
        myList.add(1,"asd1");

        Iterator iterator = myList.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println(obj);
        }

        System.out.println("----------------------------");

        // 2. Object set(int index, Object element) 修改指定位置的元素
        myList.set(1,"asd2");
        for (int i = 0; i < myList.size(); i++) {
            Object obj = myList.get(i);
            System.out.println(obj);
        }

        System.out.println("----------------------------");

        // 3. Object get(int index) 根据下标获取元素
        Object firstObj = myList.get(0);
        System.out.println(firstObj);

        // 通过下标遍历（List集合特有的方式，Set没有）
        for (int i = 0; i < myList.size(); i++) {
            Object obj = myList.get(i);
            System.out.println(obj);
        }

        System.out.println("----------------------------");

        // 4. int indexOf(Object o) 获取指定对象第一次出现处的索引
        System.out.println(myList.indexOf("zxc"));  //3
        // 5. int lastIndexOf(Object o) 获取指定对象最后一次出现处的索引
        System.out.println(myList.lastIndexOf("zxc"));  //4

        //6. Object remove(int index) 删除指定下标位置的元素
        System.out.println(myList.size());  //5
        myList.remove(1);
        System.out.println(myList.size());  //4
    }
}

ArrayList集合

  • 默认初始化容量是10(底层先创建了一个长度为0的数组，当添加第一个元素的时候，初始化容量为10)
  • 集合底层是一个Object[]数组
  • 构造方法：
    new ArrayList();
    new ArrayList(20);
  • ArrayList集合的扩容：
    原容量的1.5倍
    ArrayList集合底层是数组，怎么优化？
    • 尽可能少的扩容。因为数组扩容效率比较低(因为很难找到一块连续的比较大的内存空间)，建议在使用ArrayList集合的时候预估计元素的个数，给定一个初始化容量。
  • 数组优点：
    • 检索效率比较高（每个元素占用空间大小相同，内存地址是连续的，知道首元素内存地址，然后知道下标，通过数学表达式计算出元素的内存地址，所以检索效率最高）
  • 数组缺点：
    • 随机增删元素效率比较低
  • 向数组末尾添加元素，效率很高，不受影响
  • ArrayList集合的使用最多，因为往数组末尾添加元素，效率很高，且检索/查找某个元素的操作比较多。
public class ArrayListTest {
    public static void main(String[] args) {
        // 默认初始化容量 10
        List list = new ArrayList();
        // 集合的size()方法是获取当前集合中元素的个数，不是获取集合的容量。
        System.out.println(list.size());    //0

        // 指定初始化容量 20
        List list1 = new ArrayList(20);
        System.out.println(list1.size());   //0

        // 创建一个HashSet集合
        Collection c = new HashSet();
        c.add(1);
        c.add(2);
        c.add(3);

        // 通过这个构造方法就可以将HashSet集合转换成List集合
        List list2 = new ArrayList(c);
        for (int i = 0; i < list2.size(); i++) {
            System.out.println(list2.get(i));
        }
    }
}

补充：位运算符 >> <<

public class BinaryTest {
    public static void main(String[] args) {
        // >> 1 二进制右移1位
        // 10的二进制：00001010
        // 右移1位后：00000101
        System.out.println(10 >> 1);    //5

        // << 1 二进制左移一位
        // 10的二进制：00001010
        // 左移1位后：00010100
        System.out.println(10 << 1);    //20
    }
}

LinkedList集合

链表的优点：

  • 由于链表上的元素在空间存储上内存地址不连续。
  • 所以随机增删元素的时候不会有大量元素位移，因此随机增删效率较高
  • 遇到随机增删集合中元素的业务比较多时，建议使用LinkedList

链表的缺点：

  • 不能通过数学表达式计算被查找元素的内存地址，每一次查找都是从头节点开始遍历，直到找到为止。
  • 所以LinkedList集合检索/查找效率较低

ArrayList：把检索发挥到极致。
LinkedList：把随机增删发挥到极致。
添加元素一般都是往末尾加，所以ArrayList用的比LinkedList多。

public class LinkedListTest {
    public static void main(String[] args) {
        // LinkedList集合没有初始化容量
        // LinkedList集合底层也是有下标的
        // 注意：ArrayList之所以检索效率比较高，不是单纯因为下标的原因，主要是底层数组发挥的作用。
        // LinkedList集合照样有下标，但是检索/查找某个元素的时候效率比较第，因为每一次查找都是从头节点开始一个一个遍历
        List list = new LinkedList();   // 底层是链表
        //List list = new ArrayList();  // 底层是数组
        
        // 面向接口编程
        list.add("a");
        list.add("b");
        list.add("c");

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

Vector集合

  • 底层也是一个数组

  • 初始化容量：10

  • Vector集合扩容方式：扩容之后是原容量的2倍。

  • ArrayList集合扩容特点：扩容之后是原容量的1.5倍。

  • Vector中所有的方法都是线程同步的，都带有synchronized关键字，是线程安全的。效率比较低，使用较少了。

  • 将一个线程不安全的ArrayList集合转换成线程安全的方法：
    使用集合工具类： java.util.Collections

      java.util.Collection 是集合接口
  java.util.Collections 是集合工具类

public class VectorList {
    public static void main(String[] args) {
        List vector = new Vector();

        // 初始容量10
        vector.add(1);
        vector.add(2);
        vector.add(3);
        vector.add(4);
        vector.add(5);
        vector.add(6);
        vector.add(7);
        vector.add(8);
        vector.add(9);
        vector.add(10);

        // 满了之后扩容（扩容之后是20）
        vector.add(11);

        Iterator iterator = vector.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }


        List myList = new ArrayList();  // 非线程安全的

        // 将ArrayList集合转换成线程安全的
        Collections.synchronizedList(myList);

        myList.add("123");

    }
}

Set接口

HsahSet集合

/*
    HashSet集合存储元素特点：无序不可重复
 */
public class HashSetTest {
    public static void main(String[] args) {
        // 创建集合对象
        Set<String> set = new HashSet<>();

        // 添加元素
        set.add("hello1");
        set.add("hello3");
        set.add("hello2");
        set.add("hello1");

        // 遍历
        for (String s : set) {
            System.out.println(s);  // hello1 hello2 hello3
        }

    }
}

TreeSet集合

/*
    TreeSet集合存储元素特点：
        1.无序不可重复，但是存储的元素可以按照大小顺序排序（称为可排序集合）
        2.无序：这里的无序指的是存进去的顺序和取出来的顺序不同，并且没有下标
 */
public class TreeSetTest {
    public static void main(String[] args) {
        // 创建集合对象
        Set<String> set = new TreeSet<>();

        // 添加元素
        set.add("hello1");
        set.add("hello3");
        set.add("hello2");
        set.add("hello1");

        // 遍历
        for (String s : set) {
            System.out.println(s);  // hello1 hello2 hello3
        }
    }
}

Collection和Collections

java.util.Collection 集合接口
java.util.Collections 集合工具类，方便集合的操作

public class CollectionsTest {
    public static void main(String[] args) {
        // ArrayList集合不是线程安全的
        List<String> list = new ArrayList<>();
        // 变成线程安全的
        Collections.synchronizedList(list);
        list.add("asd");
        list.add("asf");
        list.add("asc");
        // 对元素进行排序
        Collections.sort(list);
        for (String s : list) {
            System.out.println(s);
        }

        // 对Set集合排序
        HashSet<String> set = new HashSet<>();
        set.add("asd");
        set.add("asf");
        set.add("abc");
        // 将Set集合转换成List集合
        ArrayList<String> myList = new ArrayList<>(set);
        Collections.sort(myList);
        for (String s : myList) {
            System.out.println(s);
        }
    }
}
璃 白
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java集合类之Collection接口及其子接口
qq_41299382的博客
04-29 5607
Collection接口 在Java的类集里面(java.util包)提供了两个最为核心的接口:Collection、Map接口。 Collection是单个集合保存的最大父接口 Collection接口继承树: Collection接口常用方法: 1. add(E e) : 向集合中添加元素 2. addAll(Collection<? extends E> c) : 向集合中添加...
Java基础之Collection
qq_45344586的博客
04-07 3418
Java基础之Collection
javaSE集合框架（一）—— Collection接口
qq_44886213的博客
07-25 462
javaSE集合框架
java集合之——Collection接口
you do ,you win
04-15 4010
前言 老师在教我们学习集合的时候，大多都是以数组为砖，列举了对象数组有那些问题？比如普通的对象数组的最大问题在于数组中的元素个数是固定的，不能动态的扩充大小，所以最早的时候可以通过链表实现一个动态对象数组。但是这样做毕竟太复杂了，所以在 Java 中为了方便用户操作各个数据结构，所以引入了类集的概念，有时候就可以把类集称为 java 对数据结构的实现。 在整个类集中的，这个概念是从 JDK 1.2（Java 2）之后才正式引入的，最早也提供了很多的操作类，但是并没有完整的提出类集的完整概念。 类集中最大的几
集合以及应用
weixin_48100716的博客
08-05 211
java.util.Collection接口，java中所有的集合都实现了该接口，集合像数组一样，可以保存一组元素，并且对于元素的操作全部封装成了方法，使用便捷。这里重复指的是元素是否重复，而判定重复的标准是依靠元素equals方法比较的结果，equals方法返回true则为重复。判断当前集合是否包含给定元素，判断依据是给定元素是否与集合元素存在equals比较为true的情况。删除集合中比较为true的元素,若存在相同元素，则只删一个。java.util.List接口：线性表，是一个可重复且有序的集合。.
Java基础和Java进阶
10-16
`Collection`是所有单列集合的根接口，定义了基本的添加、删除和查询操作。`ArrayList`是有序、可重复、有索引的集合，而`HashSet`则是无序、不可重复、无索引的集合。学习集合框架的常用方法有助于高效地管理和操作...
java进阶13天资料.zip
08-08
Java进阶13天资料 day01-复习回顾、静态、继承、引用类型使用 day02-抽象类、接口、代码块，final、单例、枚举 day03-多态、包、权限修饰符、内部类，Object类，Date类 day04-常用API、正则表达式，泛型、Collection...
7-java进阶-集合1
08-03
本节主要讨论的是Java集合中的高级话题，特别是关于`List`、`Set`接口以及它们的实现类，如`ArrayList`、`LinkedList`、`HashSet`、`HashMap`等。 首先，集合框架的核心是`Collection`接口，它是所有单个数据存储的...
Backend_development:JAVA进阶代码实例&最新面试题(看完涨薪2k+)
05-14
14.接口和抽象类有什么区别？ 15.Java 中 IO 流分为几种？ 16.BIO、NIO、AIO 有什么区别？ 17.Files的常用方法都有哪些？ 容器 18.Java 容器都有哪些？ 19. Collection 和 Collections 有什么区别？ 20. List、Set、...
Java进阶--深入理解ArrayList实现原理
01-27
ArrayList就是动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了动态的增加和减少元素，实现了Collection和List接口，可以灵活的设置数组的大小。要注意的是ArrayList并不是线程安全的，因此一般建议在单...
Collection接口（Java）
m0_55679446的博客
05-23 1598
1、Collection接口包括的主要方法： 添加元素：add(E),addAll() 删除元素：remove(Object),removeAll,removeIf,clear 是否包含元素：contains(Object) 获取元素个数：size 是否为空集合：isEmpty 遍历所有元素：iterator() 转换为数组：toArray,toArray(T[]) 1）添加元素： public boolean add(E object); public boolean addAll(C
泛型-集合总结
qq_45195830的博客
04-02 395
目录集合一、数组与集合1.数组与集合概述2.数组存储的特点二、Collection接口1.集合框架结构2.Collection接口的常用方法项目3.Collection集合与数组间的转换4.使用Collection集合存储对象，要求对象的属性满足三、Iterator接口四、Map接口泛型 集合 一、数组与集合 1.数组与集合概述 集合、数组都是对多个数据进行存储操作的结构，简称Java容器。 说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi，数据库中) 2.数组
一万五千字讲清Java当中Collection下的接口
古城的博客
05-19 550
集合就是一个容器 类似于数组，用来存储一组数据，但是数组一旦定义，长度将不能再变化。 然而在我们的实际开发中，经常需要保存一些变长的数据集合，于是，我们需 要一些能够动态增长长度的容器来保存我们的数据。 也有我们对数据的存储逻辑可能是各种各样的，于是就需要各种各样的数据结构。 Java当中对于各种数据结构的具体实现，就利用的是集合。
Java 集合-Collection接口
u011997561的博客
12-08 1307
Java集合大致可分为Set、List和Map三种体系，其中Set代表无序、不可重复的集合；List代表有序、重复的集合；而Map则代表具有映射关系的集合。Java 5之后，增加了Queue体系集合，代表一种队列集合实现。 Java集合框架主要由Collection和Map两个根接口及其子接口、实现类组成。本文仅探讨Collection接口及其子接口、实现类-。 1. Collection...
Java集合框架 02.浅谈Collection接口
努力推石头的西西弗斯
02-16 247
Java集合 02.Collection接口解析   java.util.Collection接口是java中对集合的抽象，此处的集合并不是数学意义上的集合，区别在于Collection中元素是可以重复的。 Collection中的核心方法 int size()   获得集合的长度。 boolean isEmpty()   返回集合是否为空。 contains(Object o)   返回是否包含指定元素。 containsAll(Collection<?> c)   返回是否包含指定集合中的所
Java Collection接口
知识共享，快乐分享
08-13 2208
在java.util包中提供了一些集合类，常用的有List、Set和Map类，其中List类和Set类继承了Collection接口。这些集合类又称为容器，长度是可变的，数组用来存放基本数据类型的数据，集合用来存放类对象的引用。 List接口、Set接口、Map接口以及Collection接口的主要特征如下： Collection接口是List接口和Set接口的父接口，通常情况下不被直接使用。
java Collection接口使用
Ren_WL的博客
04-10 724
所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置...
Java中Collection接口中的常用方法
NewBie_xW的博客
10-13 399
Java中Collection接口中的常用方法 关于java.util.Collection接口中常用的方法： Collection是所有单元素存储集合的根接口，要想学习集合，就必须了解它们的父接口有什么方法。 1、Collection中能存放什么类型的元素？ 没有使用“泛型”时，Collection中可以存储Object的所有子类型。 使用了“泛型”之后，Collection中只能存储某个具体的类型。 集合中不能直接存储基本数据类型，也不能直接存java对象，而是存储java对象的内存地址。 2、Coll
异常、Colletion、List
最新发布
04-11
`Collection`是所有集合类的顶级接口，包括`List`、`Set`和`Queue`等子接口。`List`是一个有序的集合，允许包含重复元素，提供了按索引访问元素的功能。常见的`List`实现有`ArrayList`和`LinkedList`。 `ArrayList`...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值