首页 > 其他分享 >Collection集合（实际是一个接口）

Collection集合（实际是一个接口）

时间：2024-10-20 21:14:29浏览次数：7  
标签：元素 System 接口 println add Collection 集合 c1

Collection集合介绍

Collection【接口】:

    我们通过帮助文档发现，Collection是一个接口，不能直接new对象
    根据元素是否可以发生重复，继续分类
    - List【接口】元素可以发生重复，且有索引的概念
        ArrayList
    - Set【接口】元素不可以发生重复，没有索引

借助 ArrayList 子类对象来使用 Collection 接口中的方法

学习 Java 中任意一个集合的步骤：

  1. 创建相关集合对象。
  2. 创建元素对象。
  3. 将元素添加到集合中。
  4. 遍历集合。

Collection 中的成员方法：

  • boolean add(E e)：向集合中添加元素。
  • boolean remove(Object o)：从集合中移除元素。
  • void clear()：清空集合。
  • boolean contains(Object o)：判断某元素是否在集合中。
  • boolean isEmpty()：判断集合是否为空。
  • int size()：获取集合长度（元素个数）。
public class CollectionDemo1 {
    public static void main(String[] args) {
        //借助ArrayList创建对象来使用Collection接口中的方法
        // 1、创建相关集合对象
        Collection c1 = new ArrayList();

        //boolean add(Object e)
        c1.add(100); //这里涉及到自动装箱 int -> Integer
        c1.add(true);
        c1.add(12.34);
        c1.add(1000L);
        c1.add(100);
        c1.add(12.34);
        // 重写toString()方法的类是ArrayList类的父类的父类中重写的。
        // 底层是使用StringBuilder实现的
        System.out.println("c1: " + c1);
        //注意：我们今后使用集合的时候，规定一个集合只能存储一种数据类型的元素
        System.out.println("-----------------------------------------");
        //[100, true, 12.34, 1000, 100, 12.34]
        //boolean remove(Object o) 从集合中删除一个元素,只会删除最左边的一个匹配元素
        c1.remove(100);
        System.out.println("c1: " + c1);
        System.out.println("-----------------------------------------");
        //void clear() 清空集合元素
//        c1.clear();
//        System.out.println("c1: " + c1);
        System.out.println("-----------------------------------------");
        //boolean contains(Object o) 判断Collection集合中是否包含某个元素
        System.out.println(c1.contains(12.34));
        System.out.println("-----------------------------------------");
        //boolean isEmpty() 判断Collection集合是否为空
        System.out.println(c1.isEmpty());
        System.out.println("-----------------------------------------");
        //int size() 获取集合的长度【元素的个数】
        System.out.println(c1.size());


    }
}

注意

在使用集合的时候，规定一个集合只能存储一种类型的数据元素。

List 集合详解

在 Java 中，List 是 Collection 接口的一个子接口，它表示一个元素有序、可重复的集合。List 接口有三个主要的实现类：ArrayList、Vector 和 LinkedList。这些类提供了不同的性能特点和线程安全特性。

List 集合的特点

  • 元素有序：List 集合中的元素有顺序，可以通过索引访问。
  • 元素可重复：List 集合允许存储重复的元素。
  • 索引访问：可以通过索引快速访问集合中的元素。

List 集合的实现类

ArrayList 类

  • 底层数据结构：动态数组
  • 特点：查询速度快，增删操作相对较慢，线程不安全，但效率高。
  • 使用场景：适用于频繁读取，较少修改的场景。

Vector 类

  • 底层数据结构：动态数组
  • 特点：查询速度快，增删操作相对较慢，线程安全，但效率较低。
  • 使用场景：适用于多线程环境，需要线程安全的场景。

LinkedList 类

  • 底层数据结构：双向链表
  • 特点：增删操作快，查询操作慢，线程不安全，效率高。
  • 使用场景：适用于频繁插入和删除的场景。

List 集合的常用方法

  • add(E e)：向集合中添加元素。
  • remove(Object o)：从集合中移除元素。
  • clear()：清空集合。
  • contains(Object o)：检查集合是否包含某个元素。
  • isEmpty()：检查集合是否为空。
  • size()：获取集合中元素的数量。
  • addAll(Collection c)：将另一个集合中的所有元素添加到当前集合。
  • removeAll(Collection c)：移除当前集合中所有存在于指定集合的元素。
  • containsAll(Collection c)：检查当前集合是否包含指定集合的所有元素。
  • retainAll(Collection c)：保留当前集合中所有存在于指定集合的元素。
public class Demo1Collection {
    public static void main(String[] args) {
         //由于Collection是一个接口,List接口继承了Collection,而实现List接口的具体类是ArrayList
        // 所以使用多态,借助ArrayList创建对象来使用Collection接口中的方法
        Collection c1 = new ArrayList();//父类的引用指向子类对象

        //在集合中添加元素
        c1.add(100);//这里涉及到自动装箱int-->Integer
        c1.add(true);
        c1.add(12.34);
        c1.add(1000L);
        c1.add(100);
        c1.add(12.34);
        System.out.println(c1);//重写toString方法的类是ArrayList类的父类的父类中重写的,底层使用的是StringBuffer实现的

        c1.remove(100);//若有重复的只会删除第一个找到的元素
        System.out.println(c1);


        System.out.println(c1.contains(100));//判断集合中是否包含某元素

        System.out.println(c1.isEmpty());//判断集合是否为空

        System.out.println(c1.size());//获取集合的长度

    }
}


public class Demo2Collection {
    public static void main(String[] args) {
        //创建结合对象
        Collection c1 = new ArrayList();
        c1.add("java");
        c1.add("maven");
        c1.add("clickhouse");
        c1.add("redis");

        Collection c2 = new ArrayList();
        c2.add("java");
        c2.add("hadoop");
        c2.add("maven");
        c2.add("hive");
        c2.add("hbase");
        c2.add("数据采集");

        System.out.println("c1:"+c1);
        System.out.println("c2:"+c2);
        System.out.println("----------------------");

        c1.addAll(c2);//将c2全部添加到c1里面
        System.out.println("c1:"+c1);
        System.out.println("------------------------");

        c1.removeAll(c2);//把c1里面所有的c2的元素删除
        System.out.println("c2:"+c2);
        System.out.println("---------------------------");

        System.out.println(c1.containsAll(c2));//判断c1是否完全包含c2
        System.out.println("--------------------------");

        c1.retainAll(c2);//求c1和c2的交集,结果在c1里面
        System.out.println("c1:"+c1);

    }
}

List 集合特有的方法

List集合中特有的成员方法(list集合有索引的概念,根据索引提供了一些特有的方法)：
void add(int index,E element)----按指定索引的位置添加元素
E remove(int index)---按指定索引删除元素
E get(int index)---按指定索引获取元素
E set(int index,E element)---按索引修改元素(集合长度不变,会返回原来索引对应的值)
ListIterator listIterator()---list集合独有的迭代器(列表迭代器)

public class Demo1List {
    public static void main(String[] args) {
        List list1 = new ArrayList();
        list1.add("hello");
        list1.add("world");
        list1.add("banana");
        list1.add("watermelon");
        list1.add("mango");
        System.out.println(list1);//存储有序
        System.out.println("--------------------");

        list1.add(2,"nice");
        System.out.println(list1);
        System.out.println("--------------------");

        list1.remove(2);
        System.out.println(list1);
        System.out.println("--------------------");

        System.out.println(list1.get(2));
        System.out.println("---------------------");

        list1.set(2, "dog");
        System.out.println(list1);
        System.out.println("----------------------------");

        System.out.println("集合的长度是:"+list1.size());
        System.out.println("----------------------------");

List 集合的遍历方式

使用 toArray() 方法

List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");

Object[] array = list.toArray();
for (Object obj : array) {
    System.out.println(obj);
}

使用 Iterator 迭代器(接口)

Iterator使用方法

Iterator iterator() 迭代器，集合的专用遍历方式
Collection本身是不能遍历的,但是可以调用Collection中的方法生成一个可以遍历的迭代器,去遍历该迭代器

注意:在使用迭代器遍历时,若集合发生改变(如:向集合中添加元素),就会报错

如果想在遍历时作修改就只能对遍历器本身作相应的操作(迭代器改变,集合也会相应的发生变化)
而Integer迭代器是没有添加等操作的,只能使用ListInteger迭代器

List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

List 集合存储自定义对象

存储自定义对象的步骤：

  1. 创建集合对象。
  2. 创建元素对象。
  3. 将元素添加到集合中。
  4. 遍历集合。
class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

List<Student> students = new ArrayList<>();
students.add(new Student("Alice", 20));
students.add(new Student("Bob", 22));

for (Student student : students) {
    System.out.println(student);
}

总结

List 接口及其实现类提供了灵活的元素存储和管理功能。选择哪种 List 实现类取决于具体的应用场景和性能要求。ArrayList 适合于需要快速访问元素的场景，Vector 适合于需要线程安全的场景，而 LinkedList 适合于需要频繁插入和删除元素的场景。通过理解 List 接口及其实现类的特点和使用方法，可以更有效地进行数据存储和管理。

到目前位置，我们学习过哪些可以存储元素的容器：

  1. 数组：

    • 优点：不同的数组可以存储不同数据类型的元素。
    • 缺点：长度不可变。

  2. StringBuffer/StringBuilder：

    • 优点：长度可以跟随元素的数量而改变。
    • 缺点：里面的元素只有一种字符数据类型。

我们今后会根据元素的是否重复，存储和取出的顺序等来决定我们该使用什么样的容器来进行存储

如何遍历一个 Collection 集合

  1. 使用 toArray() 方法：把集合转成数组，可以实现集合的遍历。
  2. 使用 Iterator 接口：迭代器，集合的专用遍历方式。

注意：

在使用迭代器遍历时，若集合发生改变（如：向集合中添加元素），就会报错。如果想在遍历时作修改就只能对遍历器本身作相应的操作（迭代器改变，集合也会相应的发生变化），而 Integer 迭代器是没有添加等操作的，只能使用 ListIterator,这是List集合特有的集合迭代器且只能用来遍历List集合且可以在正着遍历完集合的情况下倒着遍历集合。

Set 集合详解

在 Java 中，Set 是 Collection 接口的一个子接口，它表示一个元素无序、不重复的集合。Set 接口有两个主要的实现类：HashSet 和 TreeSet。这些类提供了不同的性能特点和排序特性。

Set 接口的特点

  • 元素无序：Set 集合中的元素没有顺序。
  • 元素唯一：Set 集合不允许存储重复的元素。
  • 没有索引：Set 集合中的元素没有索引概念。

Set 接口的实现类

HashSet 类

  • 底层数据结构：哈希表
  • 特点：查找速度快，元素唯一，线程不安全，效率高。
  • 使用场景：适用于需要快速查找和去重的场景。

HashSet 的 add 方法

HashSet 中的 add 方法实际上调用的是 HashMap 中的 put 方法。底层判断待插入的元素是否已经存在哈希表中的方式是：将待插入的元素的哈希值与已经存储在哈希表中元素哈希值进行比较，然后再调用待插入的元素的 equals 方法比较已经存储在哈希表中元素。若哈希值一样，且 equals 结果为 true，就表示这两个元素是同一个元素，不做添加。

结论

若想要使用 HashSet 对元素进行去重，需要元素类型本身重写 hashCode 方法和 equals 方法。

TreeSet 类

  • 底层数据结构：红黑树（自平衡二叉树）
  • 特点：元素有序，线程不安全，效率相对较低。
  • 使用场景：适用于需要有序集合的场景。

TreeSet 的排序方式

  • 自然排序：元素类型实现 Comparable 接口，重写 compareTo 方法。
  • 比较器排序：在构造方法中传入实现了 Comparator 接口的对象，重写 compare 方法。

TreeSet 的 add 方法

TreeSet 中的 add 方法实际上是调用了 TreeMap 中的 put 方法。

LinkedHashSet 类

  • 底层数据结构：哈希表和双链表
  • 特点：保证了元素的唯一性，同时维护元素的插入顺序，线程不安全，效率较高。
  • 使用场景：适用于需要快速查找和保持插入顺序的场景。

Set 集合的常用方法

  • add(E e)：向集合中添加元素。
  • remove(Object o)：从集合中移除元素。
  • clear()：清空集合。
  • contains(Object o)：检查集合是否包含某个元素。
  • isEmpty()：检查集合是否为空。
  • size()：获取集合中元素的数量。

示例代码

Set<Integer> numbers = new HashSet<>();

// 添加元素
numbers.add(1); // [1]
numbers.add(2); // [1, 2]
numbers.add(3); // [1, 2, 3]

// 检查集合是否包含某个元素
boolean contains = numbers.contains(2); // true
boolean containsNot = numbers.contains(4); // false

// 移除元素
numbers.remove(2); // [1, 3]

// 清空集合
numbers.clear(); // []

// 检查集合是否为空
boolean isEmpty = numbers.isEmpty(); // true

// 获取集合中元素的数量
int size = numbers.size(); // 0

Set 集合存储自定义对象

class Student implements Comparable<Student> {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Student other) {
        return this.age - other.age; // 自然排序按年龄
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Set<Student> students = new TreeSet<>();
students.add(new Student("Alice", 20));
students.add(new Student("Bob", 22));
students.add(new Student("Charlie", 20));

for (Student student : students) {
    System.out.println(student);
}

总结

Set 接口及其实现类提供了元素唯一和无序的集合存储功能。HashSet 适合于需要快速查找和去重的场景，而 TreeSet 适合于需要有序集合的场景。LinkedHashSet 结合了 HashSet 和 TreeSet 的特点，既保证了元素的唯一性，又维护了元素的插入顺序。通过理解 Set 接口及其实现类的特点和使用方法，可以更有效地进行数据存储和管理。

标签：元素,System,接口,println,add,Collection,集合,c1
From： https://www.cnblogs.com/bjynjj/p/18487888

相关文章

  • 算法笔记-字符串算法集合（未完）
    这里有一些别样的学习思路。KMP用途模式串匹配过程我们分解\(O(nm)\)的算法过程。如图，红色竖线包括的为目前匹配成功的部分，对于下一位\(i\)：首先，如果成功匹配，那么匹配长度加一。否则，我们考虑失配情况。我们会将\(S\)串的匹配部分左端点向右移动一位，然后\(T\)串......
  • 接口
    什么是接口语法：使用interface来定义接口当中的成员变量默认是publicstaticfinal的，接口中的每一个方法默认是抽象方法，接口不能存在普通的方法,要想存在普通的只有被static和default修饰的方法，接口不能通过new关键字进行实例话，类和接口是可以通过implements来实现关系的,接口......
  • stm32入门教程--TIM编码器接口
    TIM编码器接口是一种重要的硬件接口，主要用于接收增量（正交）编码器的信号。以下是对TIM编码器接口的详细介绍：一、功能与作用TIM编码器接口可以接收由编码器旋转产生的正交信号脉冲。这些信号脉冲被用来自动控制一个计数器（CNT）的自增或自减，从而能够指示编码器的位置、旋转方向和......
  • 第38篇 net8接口调试方式
    .net提供了内置的接口调试方式1.新建.netcorewebapi控制台应用程序2.封装好jwt验证机制token令牌验证机制///<summary>///登录///</summary>///<paramname="request"></param>///<returns></returns>///<exceptioncref="N......
  • Chromium 中chrome.contextMenus扩展接口实现分析c++
    一、chrome.contextMenus使用 chrome.contextMenus API向GoogleChrome的上下文菜单中添加项。您可以选择从右键菜单中添加的对象类型，例如图片、超链接和页面。权限contextMenus您必须在扩展程序的清单中声明 "contextMenus" 权限，才能使用该API。此外，您应指定一个......
  • 泛型<>类 方法 接口
    泛型类：对我们=创建的类进行规范形式点击查看代码classDemo1<E>{publicvoidgetData(Ee){System.out.println("这是一串很厉害的咒语"+e);}}publicclassFanXingDemo1{publicstaticvoidmain(String[]args){Demo1<String>s=newDemo1<>();......
  • 神经技术：解码大脑与人机接口的未来
    神经技术（Neurotechnology）是一个涵盖广泛的领域，旨在研究、理解、增强或修复大脑与神经系统的功能。它结合了神经科学、工程学、计算机科学和生物技术，通过开发各种工具与技术，帮助我们更深入地理解大脑的运作机制，并为治疗神经疾病、增强人类认知能力、提升人机交互体验提供全新的......
  • Java之集合介绍
    一、Java集合概述Java集合框架（JavaCollectionsFramework）是Java提供的一套用于存储和操作数据的接口、实现类和算法的统一架构。它大大简化了数据处理的复杂性，提高了代码的可重用性和效率。集合框架主要由几个核心接口组成，每个接口定义了一组操作和行为，具体实现类则提供了......
  • [Java基础] 集合框架
    往期回顾[Java基础]基本数据类型[Java基础]运算符[Java基础]流程控制[Java基础]面向对象编程[Java基础]集合框架[Java基础]输入输出流[Java基础]异常处理机制[Java基础]Lambda表达式目录List接口数据结构最佳实践实战代码Set接口数据结构最佳实践......
  • json-server详细模拟GET、POST、DELETE等接口数据教程
    引言在前端开发过程中,我们经常需要在后端API尚未就绪的情况下模拟接口数据。json-server是一个强大而灵活的工具,可以帮助我们快速创建一个模拟的RESTfulAPI。本文将详细介绍如何使用json-server来模拟GET、POST、PUT、PATCH、DELETE等常用的HTTP方法,以及如何处理复杂的数......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99