List、ArrayList、Vector、LinkedList的使用

最新推荐文章于 2024-05-19 21:34:53 发布
最新推荐文章于 2024-05-19 21:34:53 发布
阅读量80 收藏
点赞数
分类专栏： 学习 文章标签： 链表 列表 iterator java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44272730/article/details/118369605
版权 
package com.collection.list;

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

/**
 * @ClassName: Demo1
 * @Author: 南冥有猫不须铭
 * @Date: 2021/6/30-9:45
 * @Description: List子接口的使用
 * 特点：有序、有下标、元素可重复
 */

public class Demo1 {
    public static void main(String[] args) {
        //先创建集合对象
        List list = new ArrayList();
        //1.添加元素
        list.add("苹果");
        list.add("小米");
        list.add(0,"华为");//在最前面插入（指定位置插入）
        System.out.println("元素个数:"+list.size());//元素个数:3
        System.out.println(list.toString());//[华为, 苹果, 小米]
        //2.删除元素
        //list.remove("苹果");
        //list.clear();//清空
        //list.remove(0);//删除索引（下标）为0的元素，也就是第一个元素
        //System.out.println("删除之后:"+list.size());//删除之后:2
        //System.out.println(list.toString());//[苹果, 小米]
        //3.遍历
        //3.1使用for遍历（List集合有下标，可以使用for循环）
        System.out.println("--------------3.1使用for遍历--------------");
        for (int i=0;i<list.size();i++){
            System.out.println(list.get(i));//get()可以根据下标（索引）获取元素
        }
        //3.2使用增强for
        System.out.println("--------------3.2使用增强for--------------");
        for (Object object : list) {
            System.out.println(object);
        }
        //3.3使用迭代器
        System.out.println("--------------3.3使用迭代器--------------");
        Iterator it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //3.4使用列表迭代器（和Iterator的区别：ListIterator可以向前或向后遍历、添加、删除、修改元素）
        ListIterator lit = list.listIterator();
        System.out.println("--------------3.4使用列表迭代器从前往后--------------");
        while (lit.hasNext()){
            System.out.println(lit.nextIndex()+":"+lit.next());//打印索引和元素
        }
        System.out.println("--------------3.4使用列表迭代器从后往前--------------");
        while (lit.hasPrevious()){  //接着上面从前往后迭代到最后一个之后，再从后往前
            System.out.println(lit.previousIndex()+":"+lit.previous());//打印索引和元素
        }
        //4.判断
        System.out.println(list.contains("苹果"));//true
        System.out.println(list.isEmpty());//false
        //5.获取位置
        System.out.println(list.indexOf("华为"));//0  (即获取索引)
    }
}


package com.collection.list;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName: Demo2
 * @Author: 南冥有猫不须铭
 * @Date: 2021/6/30-11:09
 * @Description: List的使用
 */
public class Demo2 {
    public static void main(String[] args) {
        //创建集合
        List list = new ArrayList();

        //1.添加数字数据（自动装箱）
        list.add(20);//自动装箱：20已经从基本类型变成了包装类（引用类型）
        list.add(30);
        list.add(40);
        list.add(50);
        list.add(60);
        System.out.println("元素个数:"+list.size());//元素个数:5
        System.out.println(list.toString());//[20, 30, 40, 50, 60]

        //2.删除操作
        //list.remove(20);//报错(下标越界异常)   这里的删除是根据索引(下标)来进行的，括号里的数字是集合中元素的下标，现在集合下标范围（0~4）
        //list.remove(0);//删除集合中的第一个元素
        //list.remove((Object) 20);//可以把20强制转成Object类型，然后就可以直接删除20了
        list.remove(new Integer(20));//new一个Integer(包装类)，就可以删除了
        System.out.println("删除之后:"+list.size());//删除之后:4
        System.out.println(list.toString());//[30, 40, 50, 60]

        //3.补充方法subList：返回子集合，含头不含尾
        List sublist = list.subList(1,3);//包含下标为1的元素，不包含下标为3的元素
        System.out.println(sublist.toString());//[40, 50]

    }
}


package com.collection.list;

import com.collection.collection.Student;

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

/**
 * @ClassName: Demo3
 * @Author: 南冥有猫不须铭
 * @Date: 2021/6/30-14:45
 * @Description: ArrayList的使用
 * 存储结构：数组，查找遍历速度快，增删慢
 */
public class Demo3 {
    public static void main(String[] args) {
        //创建集合  size 0，容量 0；扩容原来的1.5倍
        ArrayList arrayList = new ArrayList<>();
        //1.添加元素
        Student s1 = new Student("刘德华",20);//这里用的是collection包中的Student类
        Student s2 = new Student("郭富城",22);
        Student s3 = new Student("梁朝伟",18);
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s3);
        System.out.println("元素个数:"+arrayList.size());//元素个数:4
        System.out.println(arrayList.toString());//[Student{name=刘德华, age=20}, Student{name=郭富城, age=22}, Student{name=梁朝伟, age=18}, Student{name=梁朝伟, age=18}]
        //2.删除元素
        //arrayList.remove(s1);
        arrayList.remove(new Student("刘德华",20));//equals(this==obj)方法比较的是引用地址，要重写equals方法（在Student类中）
        System.out.println("删除之后:"+arrayList.size());//删除之后:3
        System.out.println(arrayList.toString());//[Student{name=郭富城, age=22}, Student{name=梁朝伟, age=18}, Student{name=梁朝伟, age=18}]
        //3.遍历元素【重点】
        //3.1使用迭代器
        System.out.println("------------3.1使用迭代器------------");
        Iterator it = arrayList.iterator();
        while (it.hasNext()){
            Student s = (Student) it.next();//强制转换 Object-->Student
            System.out.println(s.toString());
        }
        //3.2使用列表迭代器
        ListIterator lit = arrayList.listIterator();
        System.out.println("------------3.2使用列表迭代器（正序）------------");
        while (lit.hasNext()){
            Student s = (Student) lit.next();//强制转换 Object-->Student
            System.out.println(s.toString());
        }
        System.out.println("------------3.2使用列表迭代器（逆序）------------");
        while (lit.hasPrevious()){
            Student s = (Student) lit.previous();//强制转换 Object-->Student
            System.out.println(s.toString());
        }
        //4.判断
        System.out.println(arrayList.contains(s2));//true
        System.out.println(arrayList.contains(new Student("梁朝伟",18)));//true    可以用new，因为equals()方法已经重写过了
        System.out.println(arrayList.isEmpty());//false
        //5.查找
        System.out.println(arrayList.indexOf(s1));//-1    s1在上面已经被删除了，所以不存在，返回-1
        System.out.println(arrayList.indexOf(new Student("梁朝伟",18)));//1    第一次出现下标为1，也就是排在第二
    }
}


package com.collection.list;

import java.util.Enumeration;
import java.util.Vector;

/**
 * @ClassName: Demo1
 * @Author: 南冥有猫不须铭
 * @Date: 2021/6/30-17:33
 * @Description: 演示Vector集合的使用
 * 存储结构：数组
 */
public class Demo4 {
    public static void main(String[] args) {
        //创建集合
        Vector vector = new Vector<>();
        //1.添加元素
        vector.add("草莓");
        vector.add("芒果");
        vector.add("西瓜");
        System.out.println("元素个数:"+vector.size());//元素个数:3
        //2.删除
        //vector.remove(0);
        //vector.remove("西瓜");
        //vector.clear();
        //3.遍历
        //使用枚举器
        Enumeration en = vector.elements();
        while (en.hasMoreElements()){
            String o = (String) en.nextElement();//强制转换 Object-->String
            System.out.println(o);
        }
        //4.判断
        System.out.println(vector.contains("西瓜"));
        System.out.println(vector.isEmpty());
        //5.Vector其他方法
        //firstElement()、lastElement()、elementAt();
    }
}


package com.collection.list;

import com.collection.collection.Student;

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

/**
 * @ClassName: Demo5
 * @Author: 南冥有猫不须铭
 * @Date: 2021/6/30-18:24
 * @Description: LinkedList的使用
 * 存储结构：双向链表
 */
public class Demo5 {
    public static void main(String[] args) {
        //创建集合
        LinkedList linkedList = new LinkedList<>();
        //1.添加元素
        Student s1 = new Student("刘德华",20);//这里用的是collection包中的Student类
        Student s2 = new Student("郭富城",22);
        Student s3 = new Student("梁朝伟",18);
        linkedList.add(s1);
        linkedList.add(s2);
        linkedList.add(s3);
        System.out.println("元素个数:"+linkedList.size());//元素个数:3
        System.out.println(linkedList.toString());

        //2.删除
        //linkedList.remove(s1);
        //linkedList.remove(new Student("刘德华",20));//之前在Student类中重写了equals()方法，所有这里可以用new
        //linkedList.clear();
        //System.out.println("删除之后:"+linkedList.size());//删除之后:2

        //3.遍历
        //3.1使用for遍历
        System.out.println("-----------3.1使用for遍历-----------");
        for (int i=0;i<linkedList.size();i++){
            System.out.println(linkedList.get(i));
        }
        //3.2使用增强for
        System.out.println("-----------3.2使用增强for-----------");
        for (Object object : linkedList) {
            Student s = (Student) object;//强制转换Obje-->Student
            System.out.println(s.toString());
        }
        //3.3使用迭代器
        System.out.println("-----------3.3使用迭代器-----------");
        Iterator it = linkedList.iterator();
        while (it.hasNext()){
            Student s = (Student) it.next();
            System.out.println(s.toString());
        }
        //3.4使用列表迭代器
        System.out.println("-----------3.4使用列表迭代器-----------");
        ListIterator lit = linkedList.listIterator();
        while (lit.hasNext()){
            Student s = (Student) lit.next();
            System.out.println(s.toString());
        }

        //4.判断
        System.out.println(linkedList.contains(s1));//true
        System.out.println(linkedList.isEmpty());//false

        //5.获取
        System.out.println(linkedList.indexOf(s1));//0
    }
}


package com.collection.collection;

/**
 * @ClassName: Student
 * @Author: 南冥有猫不须铭
 * @Date: 2021/6/29-22:53
 * @Description: 学生类（Demo2）
 */
public class Student {
    private String name;
    private int age;

    //无参构造方法
    public Student() {
    }

    //带参构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //get/set
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() { //重写toString()方法
        return "Student{" +
                "name=" + name +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object obj) { //重写equals()方法
        //1.判断是不是同一个对象
        if (this == obj) {
            return true;
        }
        //2.判断是否为空
        if (obj == null) {
            return false;
        }
        //3.判断是否是Student类型
        if (obj instanceof Student) {
            Student s = (Student) obj;//强制转换Object-->Student
            //4.比较属性
            if (this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }
        //5.不满足条件返回false
        return false;
    }

}
南冥有猫不须铭
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Vector,ArrayList,LinkedList的特点和区别
浮生一梦
07-11 1万+
1.Vector简介及特点 1、Vector是内部是以动态数组的形式来存储数据的。 2、Vector具有数组所具有的特性、通过索引支持随机访问、所以通过随机访问Vector中的元素效率非常高、但是执行插入、删除时效率比较地下、具体原因后面有分析。 3、Vector实现了AbstractList抽象类、List接口、所以其更具有了AbstractList和List的功能、前面我们知道Abs
List实现类中的ArrayList、Vector、LinkedList
01-20
List list = new ArrayList();可以把接口的好处5体现出来，如果ArrayList()不满足需求，直接更换就可以。 接口的好处： 1.程序的耦合度降低 2.更自然的使用多态 3.设计与实现完全分离 4.更容易搭建程序框架 5.更容易...
List集合实现类之ArrayList、Vector和LinkedList
weixin_39309402的博客
03-14 554
List集合的实现类有3种，分别是ArrayList、Vector和LinkedList，下面我将对这3个实现类的区别进行详细讲解。 1）ArrayList ArrayList继承自AbstractList而实现了List，它是最常用的List实现类，内部是通过数组实现的，所以插入或者删除元素时，需要对数组进行复制、移动、代价比较高，因此，它适合随机查找和遍历，不适合插入和删除。 pub...
Vector/Arraylist/LinkedList
小胖的博客
11-13 683
一． ArrayList 与 LinkedList 区别 ArrayList 和 LinkedList 都实现了 List 接口， 他们有以下的不同点： ArrayList 是基于索引的数据接口， 它的底层是数组。 它可以以 O(1)时间复杂度对元素进行随机访问。 与此对应， LinkedList 是以元素列表的形式存储它的数据， 每一个元素都和它的前一个和后一个元素链接在一起， 在这种情况下， ...
ArrayList和Vector以及LinkedList
青松与小红花
10-10 237
大神的文章：点击打开链接1    点击打开链接2 重点总结： 1.ArrayList和Vector是采用数组方式存储数据，此数组元素总数大于实际存储的数据个数以便增加和插入元素，二者都允许直接序号索引元素，但是插入数据要移动数组元素等内存操作，所以它们索引数据快、插入数据慢。 2.Vector是线程安全的（Vector和Hashtable都是比较古老的集合，他们是线程安全的），ArrayLi
ArrayList_Vector_LinkedList异同
一只倔强而老实的虫
07-17 145
List的三大实现类 ArrayList,Vector,LinkedList的异同
关于List集合类ArrayList、LinkedList、Vector详解
扎哇太枣糕的笔记博客
06-02 867
  各位小伙伴们大家好，欢迎来到这个小扎扎的《Java核心技术 卷Ⅰ》笔记专栏，在这个系列专栏中我将记录浅学这本书所得收获，鉴于 看到就是学到、学到就是赚到 精神，这波简直就是血赚
ArrayList、LinkedList和Vector
qq_40413333的博客
09-04 767
ArrayList、 LinkedList 和 Vector都实现了List接口，是List的三种实现。 ArrayList底层是用数组实现的。可以认为ArrayList是一个可改变大小的数组。随着越来越多的元素被添加到ArrayList中，其规模是动态增加的。 LinkedList底层是通过双向链表实现的。所以，LinkedList和ArrayList之前的区别主要就是数组和链表的区别。 所以，LinkedList和ArrayList相比，增删的速度较快。但是查询和修改值的速度较慢。同时，Linke
ArrayList、LinkedList和Vector的区别
m0_59749255的博客
08-30 1159
2. ArrayList和LinkedList的区别是他们的数据结构不同，ArrayList是动态数组，LinkedList是双向链表，在查询操作较多，在特定位置插入数据和删除数据较少的情况下一般选用ArrayList，在特定位置插入数据，删除数据操作较多，查询较少的情况下一般选用LinkedList，但是在大多数应用中都是对查询效率要求较高，所以ArrayList集合应用更广泛一些。添加操做add调用的是linkLast方法，是在链表尾部添加数据，在指定位置新增数据，则针对索引需要进行合法性检查；...
Vector,ArrayList, LinkedList的区别
weixin_38610651的博客
12-13 443
  1、Vector、ArrayList都是以类似数组的形式存储在内存中，LinkedList则以链表的形式进行存储。 2、List中的元素有序、允许有重复的元素，Set中的元素无序、不允许有重复元素。 3、Vector线程同步，ArrayList、LinkedList线程不同步。 4、LinkedList适合指定位置插入、删除操作，不适合查找；ArrayList、Vector适合查找，不...
比较ArrayList、LinkedList、Vector1
08-08
1. List概述List,就如图名字所示一样,是元素的有序列表 3. ArrayList示例[java] view plain copy public sta
分析Java中ArrayList与LinkedList列表结构的
09-02
主要介绍了Java中ArrayList与LinkedList列表结构的源码,文章最后对LinkedList和ArrayList以及Vector的特性有一个对比总结,需要的朋友可以参考下
java8源码-csn-list:ArrayList、LinkedList、Vector、Stack源码分析
06-04
遍历ArrayList时，使用随机访问(即，通过索引序号访问)效率最高 转数组：Integer[] newText = v.toArray(new Integer[v.size()]) Fail-Fast机制 fail-fast 机制是java集合(Collection)中的一种错误机制。当多个线程...
JDK1.6中Arraylist，Vector，LinkedList源码
05-28
这是我从JDK中拿出的Arraylist，Vector，LinkedList源码，自己看源码的时候弄出来的，并写了一点自己的分析，仅供源码分析者使用
jar包增量更新分析
junlaiyan的专栏
05-16 399
借助jdeps分析出jar包的增量文件
docker中安装jenkins，并在node和cloud上跑通基于源码控制SCM的pipeline
qq_29022265的博客
05-19 1106
从安装jenkins到创建jenkins的node和cloud，最后再将scm和FreeStyle两种流水线跑通。
java实现拼图小游戏
monkey108的博客
05-16 720
本文主要提供用java实现的拼图小游戏源代码。
分布式锁2-Zookeeper分布式锁实战
最新发布
qq_43676797的博客
05-19 242
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
命令执行漏洞（二）
XLbb的博客
05-15 1025
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漏洞存在！
arraylist linkedlist vector区别
05-30
ArrayList、LinkedList和Vector都是List的实现...综上所述，如果需要线程安全的List，可以使用Vector，如果需要随机访问元素的高效率，可以使用ArrayList，如果需要频繁地在列表中插入或删除元素，可以使用LinkedList。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值