集合框架 第1天（集合的概念，Collection使用，List使用，ArrayList使用，Vector使用，LinkedList使用，ArrayList和LinkedList区别）

最新推荐文章于 2024-05-18 16:42:38 发布
最新推荐文章于 2024-05-18 16:42:38 发布
阅读量930 收藏 19
点赞数 16
分类专栏： # 集合框架 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/blackornate/article/details/135255336
版权

目录

1. 集合的概念

  • 概念：对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能

  • 和数组的区别：

    • 数组长度固定，集合长度不固定
    • 数组可以存储基本类型和引用类型，集合只能存储引用类型

  • 位置：java. until. *

2. Collection体系

  • Interface Collection（该体系的根接口，代表一组对象，称为“集合”）
    • Interface List（有序、有下标、元素可重复）
      • Class ArrayList
      • Class LinkedList
      • Class Vector
    • Interface Set（无序、无下标、元素不能重复）
      • Class HashSet
      • Interface SortedSet
        • Class TreeSet

3.Collection接口

  • 特点：代表一组任意类型的对象，无序、无下标、不能重复
  • 方法：
    • boolean add(Object obj)：添加一个对象
    • boolean addAll(Collection c)：将一个集合中的所有对象添加到此集合中
    • void clear()：清空此集合中所有的对象
    • boolean contains(Object obj)：检查此集合中是否包含obj对象
    • boolean equals(Object obj)：比较此集合是否与指定对象相等
    • boolean isEmpty()：判断此集合是否为空
    • boolean remove(Object obj)：在此集合中移除obj对象
    • int size()：返回此集合中的元素个数
    • Object[] toArray()：将此集合转换成数组

4. Collection使用

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

public class Test {
    public static void main(String[] args) throws Exception {
        // 创建集合
        Collection collection = new ArrayList();

        // 添加元素
        collection.add('A');
        collection.add('B');
        collection.add('C');
        System.out.println(collection);
        System.out.println(collection.size());

        // 删除元素
        collection.remove('B');
        System.out.println(collection);

        // 遍历元素
        // 1. 使用增强for
        for (Object obj : collection) {
            System.out.println(obj);
        }
        // 2. 使用迭代器
        Iterator iterator = collection.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        // 判断
        System.out.println(collection.contains('A'));
        System.out.println(collection.isEmpty());
    }
}

5. List接口

  • 特点：有序、有下标、元素可以重复
  • 方法：
    • void add(int index, Object obj)：在index位置插入对象obj
    • boolean addAll(int index, Collection c)：将一个集合中的元素添加到此集合中的index位置
    • Object get(int index)：返回集合中指定位置的元素
    • List subList(int fromIndex, int toIndex)：返回fromIndex和toIndex之间的集合元素

6. List使用

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

public class Test {
    public static void main(String[] args) throws Exception {
        // 创建集合对象
        List list = new ArrayList<>();

        // 添加元素
        list.add('A');
        list.add('C');
        list.add(1, 'B');
        list.add(3, 'D');
        System.out.println(list);
        System.out.println(list.size());

        // 删除元素
        list.remove((Object) 'B');
        list.remove(1);
        System.out.println(list);

        // 遍历
        // 1. 使用for遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        // 2. 使用增强for
        for (Object obj : list) {
            System.out.println(obj);
        }

        // 3. 使用迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        // 4.使用列表迭代器
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            System.out.println(listIterator.nextIndex());
            System.out.println(listIterator.next());
        }
        while (listIterator.hasPrevious()) {
            System.out.println(listIterator.previousIndex());
            System.out.println(listIterator.previous());
        }

        // 判断
        System.out.println(list.contains('D'));
        System.out.println(list.isEmpty());
        System.out.println(list.indexOf('A'));
    }
}

7. List实现类

  • ArrayList：
    • 数组结构实现，查询快、增删慢
    • JDK1.2版本，运行效率快、线程不安全
  • Vector：
    • 数组结构实现，查询快、增删慢
    • JDK1.0版本，运行效率慢、线程安全
  • LinkedList：
    • 链表结构实现，增删快、查询慢

8. ArrayList使用

import java.util.*;

public class Test {
    public static void main(String[] args) throws Exception {
        // 创建集合
        ArrayList arrayList = new ArrayList();

        // 添加元素
        Student student1 = new Student("A", 10);
        Student student2 = new Student("B", 20);
        Student student3 = new Student("C", 30);
        arrayList.add(student1);
        arrayList.add(student2);
        arrayList.add(student3);
        arrayList.add(student3);
        System.out.println(arrayList.size());
        System.out.println(arrayList);

        // 删除元素
        arrayList.remove(student3);
        arrayList.remove(new Student("C", 30));
        System.out.println(arrayList);

        // 遍历
        // 1. 使用迭代器
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        // 2. 使用列表迭代器
        ListIterator listIterator = arrayList.listIterator();
        while (listIterator.hasNext()) {
            System.out.println(listIterator.next());
        }
        while (listIterator.hasPrevious()) {
            System.out.println(listIterator.previous());
        }

        // 判断
        System.out.println(arrayList.contains(student2));
        System.out.println(arrayList.contains(new Student("B", 20)));
        System.out.println(arrayList.isEmpty());

        System.out.println(arrayList.indexOf(student2));
        // 查找
    }
}

class Student {
    String name;
    int age;

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

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }
}

9. Vector使用

import java.util.Enumeration;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.Vector;

public class Test {
    public static void main(String[] args) throws Exception {
        // 创建集合
        Vector vector = new Vector();

        // 添加元素
        vector.add('A');
        vector.add('B');
        vector.add('C');
        vector.add('D');
        System.out.println(vector);
        System.out.println(vector.size());

        // 删除元素
        vector.remove((Object) 'B');
        vector.remove(1);
        System.out.println(vector);

        // 遍历元素
        // 1. 使用for遍历
        for (int i = 0; i < vector.size(); i++) {
            System.out.println(vector.get(i));
        }

        // 2. 使用增强for遍历
        for (Object obj : vector) {
            System.out.println(obj);
        }

        // 3. 使用迭代器遍历
        Iterator iterator = vector.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        // 4. 使用列表迭代器
        ListIterator listIterator = vector.listIterator();
        while (listIterator.hasNext()) {
            System.out.println(listIterator.next());
        }
        while (listIterator.hasPrevious()) {
            System.out.println(listIterator.previous());
        }

        // 5. 使用枚举器
        Enumeration enumeration = vector.elements();
        while (enumeration.hasMoreElements()) {
            System.out.println(enumeration.nextElement());
        }

        // 判断
        System.out.println(vector.contains('D'));
        System.out.println(vector.isEmpty());

        // 获取元素
        System.out.println(vector.firstElement());
        System.out.println(vector.lastElement());
        System.out.println(vector.elementAt(0));
        System.out.println(vector.get(1));
    }
}

10. LinkedList使用

import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.Objects;

public class Test {
    public static void main(String[] args) throws Exception {
        // 创建集合
        LinkedList linkedList = new LinkedList();

        // 添加元素
        Student student1 = new Student("A", 10);
        Student student2 = new Student("B", 20);
        Student student3 = new Student("C", 30);
        linkedList.add(student1);
        linkedList.add(student2);
        linkedList.add(student3);
        linkedList.add(student3);
        System.out.println(linkedList);
        System.out.println(linkedList.size());

        // 删除元素
        linkedList.remove(student3);
        linkedList.remove(new Student("C", 30));
        System.out.println(linkedList);

        // 遍历
        // 遍历元素
        // 1. 使用for遍历
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }

        // 2. 使用增强for遍历
        for (Object obj : linkedList) {
            System.out.println(obj);
        }

        // 3. 使用迭代器遍历
        Iterator iterator = linkedList.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        // 4. 使用列表迭代器
        ListIterator listIterator = linkedList.listIterator();
        while (listIterator.hasNext()) {
            System.out.println(listIterator.next());
        }
        while (listIterator.hasPrevious()) {
            System.out.println(listIterator.previous());
        }

        // 判断
        System.out.println(linkedList.contains(student1));
        System.out.println(linkedList.isEmpty());

        // 获取元素
        System.out.println(linkedList.get(0));
        System.out.println(linkedList.indexOf(student2));
    }
}

class Student {
    String name;
    int age;

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

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }
}

11. ArrayList和LinkedList区别

  • 不同结构实现方式
    • ArrayList：必须开辟连续空间，查询快、增删慢
    • LinkedList：双向链表，查询慢、增删快
His Last Bow
关注
  • 16
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ArrayList和LinkedList区别及使用场景代码解析
08-28
主要介绍了ArrayList和LinkedList区别及使用场景代码解析，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下
ArrayList和LinkedList区别及使用场景
热门推荐
ForgetSky的博客
09-07 9万+
ArrayList和LinkedList区别及使用场景 1. LinkedList和ArrayList的差别主要来自于Array和LinkedList数据结构的不同。ArrayList是基于数组实现的，LinkedList是基于双链表实现的。另外LinkedList类不仅是List接口的实现类，可以根据索引来随机访问集合中的元素，除此之外，LinkedList还实现了Deque接口，Deque接...
ArrayList与LinkedList和Vector 使用上有什么区别?
YEEZY_H的博客
06-21 432
#ArrayList、LinkedList和Vector 之间的比较： Arraylsit ArrayList是底层数组实现的，宽度为10，每次扩容容量增加0.5倍。查询速度快，但修改慢，线程不安全； Linkdelist Linkdelist是基于链表、栈、队列实现的。修改快，但查询慢（从第一个索引开始），线程不安全； Vector Vector与ArrayList咋使用上非...
java集合Collection的List ArrayList LinkedList 区别
自强博客
06-17 3075
先说结论： 1、List的特点：线性顺序存储元素、元素可重复、可以存放null、可查找。 2、ArrayList（数组，中间插入删除慢、按位置查找快）、LinkedList（链表，中间插入删除快、按位置查找慢） ==============正文============ 一、List特点 如下图所示List表示一种列表的形式，因此它的元素都是一个接一个的线性排序，所以它可以重
Java学习-详谈List集合（ArrayList、LinkedList、Vector和Stack）
jQueryZK的博客
09-03 4087
1.List接口介绍 java.util.List 接口继承自 Collection 接口，是单列集合的一个重要分支，习惯性地会将实现了 List 接口的对象称为List集合。 List集合有以下特点： 在List集合中允许出现重复的元素（通过元素的equals方法来比较是否为重复的元素） 所有的元素是以一种线性方式进行存储的 它是一个带有索引的集合，在程序中可以通过索引来访问集合中的指定元素 List集合的元素有序，即元素的存入顺序和取出顺序一致 2.List接口中常用的方法 List作为Colle
JAVA LinkedList和ArrayList的使用及性能分析
09-04
JAVA LinkedList和ArrayList的使用及性能分析，这篇文章也是以JAVA List的总结。
java 集合之实现类ArrayList和LinkedList的方法
08-29
下面小编就为大家带来一篇java 集合之实现类ArrayList和LinkedList的方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java中ArrayList和LinkedList区别
12-22
一般大家都知道ArrayList和LinkedList的大致区别： 　1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。 　2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要...
List实现类中的ArrayList、Vector、LinkedList
01-20
首先，List接口继承于Collection接口，其中的所有方法都被继承，而Collection是无序、无下标，元素不可重复的，List是有序，有下标，元素可以重复，所以，List就有一些自己独有的方法。和数组相比较更加灵活，方便。...
jar包增量更新分析
junlaiyan的专栏
05-16 261
借助jdeps分析出jar包的增量文件
SpringBoot接入Knife4j接口文档
最新发布
博主是个二次元死肥宅~
05-18 678
Knife4j是Java MVC框架集成Swagger生成Api文档的增强解决方案，前身是swagger-bootstrap-ui。
java实现拼图小游戏
monkey108的博客
05-16 621
本文主要提供用java实现的拼图小游戏源代码。
命令执行漏洞（二）
XLbb的博客
05-15 905
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 913
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 248
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
C++ 11
qq_65112813的博客
05-17 654
对于类类型，如果定义了接受。
Kubernetes 审计日志采集与分析最佳实践
观测云的博客
05-17 1024
​Kubernetes 在 1.7 版本中发布了审计（Audit）日志功能，通过审计日志，我们能够非常清晰的知道 K8S 集群到底发生了什么事情。
java导出excel动态加载多sheet多复杂表头
weixin_43931108的博客
05-14 253
java导出excel动态加载多sheet多复杂表头
分别使用java编写Collection、list、arraylist、vector、linkedlist实现存储字符串并遍历
05-12
1. Collection接口的实现： ```java import java.util.*; public class CollectionDemo { public static void main(String[] args) { Collection<String> collection = new ArrayList(); collection.add("apple...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值