Javat集合之Lis---（ArrayList和LinkedList）

文章目录

一、 List概述
- 1.1概念
- 1.2list体系结构图
- 1.3 通用方法
- 测试代码
二、List的特点
三、遍历方式
- foreach
- for循环
- 迭代器
四、ArrayList
- ArrayList概述
- - 概念
  - 数据结构
- ArrayList的特点
ArrayList去重
- 字符串去重
- 对象去重
五、LinkedList
- LinkedList概述
- - 概念
  - 数据结构
  - LinkedList的特点
- 常用方法
ArrayList和LinkedList的比较

提示：以下是本篇文章正文内容，下面案例可供参考

一、 List概述

1.1概念

List是一种常用的集合类型，它可以存储任意类型的对象，也可以结合泛型来存储具体的类型对象，本质上就是一个容器。

1.2list体系结构图

在这里插入图片描述

1.3 通用方法

ArrayList和LinkedList通用方法：
在这里插入图片描述
以上方法通用且常用的方法其他方法可参考相关的文档进行查询即可，

测试代码

以List的实现类ArrayList：

public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 创建集合
		List list = new ArrayList<>();

		// 添加元素
		list.add("hello");
		list.add("world");
		list.add("java");

		// public boolean remove(Object o)：删除指定的元素，返回删除是否成功
		 System.out.println(list.remove("world"));//true
		 System.out.println(list.remove("javaee"));//false

		// public E remove(int index)：删除指定索引处的元素，返回被删除的元素
		 System.out.println(list.remove(1));//world

		// IndexOutOfBoundsException
		 System.out.println(list.remove(3));

		// public E set(int index,E element)：修改指定索引处的元素，返回被修改的元素
		 System.out.println(list.set(1,"javaee"));//world

		// IndexOutOfBoundsException
		 System.out.println(list.set(3,"javaee"));

		// public E get(int index)：返回指定索引处的元素
		 System.out.println(list.get(0));//hello
		 System.out.println(list.get(1));//world
		 System.out.println(list.get(2));//java
		// IndexOutOfBoundsException
		 System.out.println(list.get(3));

		// public int size()：返回集合中的元素的个数
		 System.out.println(list.size());//3
		
		// 输出集合
		 System.out.println("list:" + list);//list:[hello, world, java]

		// boolean contains(Object o) 如果此列表包含指定的元素，则返回 true
		 System.out.println(list.contains("world"));//true
		 
		// boolean addAll(int index, Collection c) 
		//将指定集合中的所有元素插入到此列表中，从指定的位置开始
		List list2 = new ArrayList<>();
		//addall前list2
		System.out.println(list2);// []
		System.out.println(list2.addAll(0, list));// true
		//addall后list2
		System.out.println(list2);// [hello, world, java]
	}

二、List的特点

（1）有序性：List中的元素是按照添加顺序进行存放的。因为有序，所以有下标，下标从0开始

（2）可重复性： List中可以存储重复的元素

三、遍历方式

利用三种方式进遍历list

foreach

       List list = new ArrayList<>();

        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        for (Object object : list) {
			System.out.println(object);
		}

for循环

根据下标进行遍历、

       //创建集合
       List list = new ArrayList<>();

        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
       for (int i = 0; i < list.size(); i++) {
		System.out.println(list.get(i));
	}

迭代器

        //创建集合
       List list = new ArrayList<>();

        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
        	System.out.println(iterator.next());
		}

四、ArrayList

ArrayList概述

概念

ArrayList是Java中的一个类，实现了List接口，底层使用数组来存储元素。与数组相比，它具有更灵活的大小和动态的增加和删除元素。

数据结构

ArrayList的数据结构本质上就是数组。区别在于，数组是一种静态的数据结构，需要在创建数组时就指定它的长度，并且创建后长度无法改变。而ArrayList是一种动态的数据结构，它可以自动进行扩容。

ArrayList的底层数据结构:

在这里插入图片描述

ArrayList的特点

除了具备List有序性、可重复性特点外，ArrayList还具备以下的特点：

1.自动扩容
当向ArrayList中加入的元素超过了其默认的长度时（由于ArrayList是数组的封装类，在创建ArrayList时不用给定长度，其默认长度为10），它会自动扩容以增加存储容量

2.随机访问
随机访问是指可以直接访问元素，而不需要从头部或者尾部遍历整个列表。由于ArrayList底层是用数组实现的，因此可以通过索引来快速访问元素。

3.慢速插入/删除：
相比于链表（如LinkedList），ArrayList在中间插入或删除元素较慢，因为需要移动元素。

4.高效的遍历
由于ArrayList底层采用了数组来存储元素，所以对于ArrayList的遍历操作比较高效。

常用方法：
在这里插入图片描述

ArrayList去重

字符串去重

使用contains方法

	   public static void main(String[] args) {
	        List list = new ArrayList();
	        list.add("a");
	        list.add("b");
	        list.add("c");
	        System.out.println("目前集合容器中的元素："+list);//目前集合容器中的元素：[a, b, c]
	        if (!list.contains("b")){//如果不包含“b”
	            list.add("b");//才增加
	        }
	        System.out.println("目前集合容器中的元素："+list);//目前集合容器中的元素：[a, b, c]
	    }
}

对象去重

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Student("zs",16));
        list.add(new Student("ls",17));
        list.add(new Student("ww",18));
        System.out.println("目前集合容器中的元素："+list);
        //目前集合容器中的元素：[com.xqx.demo.Student@33909752, com.xqx.demo.Student@55f96302, com.xqx.demo.Student@3d4eac69]
        if (!list.contains(new Student("ls",17))){//不包含才新增
            list.add(new Student("ls",17));
        }
        System.out.println("目前集合容器中的元素："+list);
        //目前集合容器中的元素：[com.xqx.demo.Student@33909752, com.xqx.demo.Student@55f96302, com.xqx.demo.Student@3d4eac69, com.xqx.demo.Student@42a57993]

        if (list.contains(new Student("ls",17))){//包含才移除
            list.remove(new Student("ls",17));
        }
        System.out.println("目前集合容器中的元素："+list);
        //目前集合容器中的元素：[com.xqx.demo.Student@33909752, com.xqx.demo.Student@55f96302, com.xqx.demo.Student@3d4eac69, com.xqx.demo.Student@42a57993]

    }
}
class Student{
    private String name;
    private int age;

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

    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;
    }

五、LinkedList

LinkedList概述

概念

LinkedList也是Java中的一个常用的集合类，实现了List接口，底层使用的是双向链表数据结构。

与ArrayList不同，LinkedList在内部存储元素时，不是使用连续的内存空间，而是使用一个链表来存储元素。

数据结构

LinkedList底层采用的是双向链表（doubly linked list）数据结构。链表中的每个节点（结点）都由两个部分组成，一部分是存储数据元素的值域，另一部分是指向前一个节点和后一个节点的指针（引用）。对于双向链表来说，除了一个指向前一个节点的指针外，还有一个指向后一个节点的指针

LinkedList的特点

随机访问性能较差：
LinkedList的随机访问性能较差，因为在链表中要从头开始遍历链表，直到找到目标元素。所以如果在代码中需要频繁进行随机访问元素的操作，LinkedList可能不是一个最佳的选择。

添加/删除操作快：
由于LinkedList底层使用双向链表，因此它的添加和删除操作非常快，因为只需要更改指针的指向即可，不需要像ArrayList一样重新分配数组空间，而且LinkedList还支持在指定位置插入和删除元素。

需要额外空间：
链表中每个节点都需要额外存储到前一个和后一个节点的指针，因此比数组等其他数据结构需要更多的内存空间。

适用于队列和双端队列：
LinkedList还可以支持队列和双端队列的功能，如在链表头部或尾部添加或删除元素，实现队列和双端队列的常见操作。

双端队列（Deque，即Double Ended Queue的缩写）是一种允许在队列的两端进行插入和删除操作的数据结构。双端队列可以从队列的头部和尾部添加和移除元素

常用方法

在这里插入图片描述

ArrayList和LinkedList的比较

1、由于ArrayList的数据结构为数组，所以查询修改快，新增删除慢；而LinkedList的数据结构为链表

结构，所以查询修改慢，新增删除快

2、ArrayList是基于数组实现的动态数组，在内存中有连续的空间，可以通过下标访问元素，由于数组需要提前分配一定大小的空间，因此当元素数量增多之后，可能会导致数组空间不足需要重新分配数组，这种情况下可能会出现内存空间浪费；相比之下，LinkedList是基于链表实现的，每个元素都有一个引用指向下一个元素，不需要提前分配空间，因此能够更加灵活地插入和删除元素。然而，链表在内存中是不连续的，每个元素的引用占用额外的内存空间。由于链表中每个元素都需要有一个指向下一个元素的引用，因此在存储同样数量的元素时，LinkedList通常会占用比ArrayList更大的内存空间。

好啦，今天的分享就到此为止！希望你看完本篇文章有所收获，祝你变得更强！！!