【Java数据结构】---List（ArrayList）

于 2024-08-11 23:13:52 发布
阅读量1.4k 收藏 32
点赞数 41
分类专栏： Java数据结构 文章标签： 数据结构 java list 学习方法 经验分享 idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/optimistic_chen/article/details/140923556
版权

乐观学习，乐观生活，才能不断前进啊！！！

我的主页：optimistic_chen

我的专栏：c语言 ，Java

欢迎大家访问~
创作不易，大佬们点赞鼓励下吧~

文章目录

前言

在集合框架中，List是一个接口，继承自Collection
在这里插入图片描述
这些方法都是List接口下的方法：
在这里插入图片描述
这些是Collection下的方法：
在这里插入图片描述
根据这些方法数量我们可以推断，List接口扩展了Collection接口。
在这里插入图片描述

由集合框架，直接告知了我们正确的学习顺序，整体由下到上学习。今天先开始我们熟悉的顺序表(ArrayList)的具体内容。

线性表

之前C语言部分也学习过顺序表，我们这里就简单说明。

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列…（之后都会学习到）

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

顺序表（MyArrayList）

顺序表是**用一段物理地址连续的存储单元依次存储数据元素的线性结构**，一般情况下采用数组存储。在数组上完成数据的增删查改

因为ArrayList是集合框架下的一个普通的类，他的增删查改可以由编译器实现。我们要做的就是自主实现这些功能，增强对代码的理解。我们可以把这些功能先定义在一个接口IList中，再通过我们自己的MyArrayList类完成具体代码。

//接口
public interface IList {
    public void add(int data);

    public void add(int pos,int data);

    public boolean contains(int toFind);

    public int indexOf(int toFind);

    public int get(int pos);

    public void set (int pos,int value);

    public void remove(int toRemove);

    public int size();

    public void clear();

    public void display();

}

在这里插入图片描述

具体功能代码

增加元素

 @Override
    public void add(int data) {
    //判断数组空间大小
        if(isFull()){
        //扩容
            grow();
        }
        //增加元素
        this.array[this.usedSize]=data;
        //数组长度+1
        this.usedSize++;
    }
    private void grow(){
        this.array= Arrays.copyOf(this.array,2*this.array.length);
    }
    public boolean isFull(){
        return this.usedSize==array.length;
    }

指定位置插入元素

@Override
    public void add(int pos, int data) {
    //预防异常
        try{
            checkPos(pos);
            if(isFull()){
                grow();
            }
            //挪动元素
            for (int i = usedSize-1; i <=pos ; i--) {
                array[i+1]=array[i];
            }
            array[pos]=data;

            usedSize++;
        }//捕获异常
        catch(PosIllegal e){
            System.out.println("插入元素位置不合法");
            e.printStackTrace();
        }
    }
    //检查异常
    private void checkPos(int pos){
        if(pos < 0 || pos > usedSize){
            throw new PosIllegal("Pos位置不合法");
        }
    }

判断是否存在该元素

@Override
    public boolean contains(int toFind) {
        for (int i = 0; i < usedSize; i++) {
            if(array[i]==toFind){
                return true;
            }
        }
        return false;
    }

返回查找的该元素

@Override
    public int indexOf(int toFind) {
        for (int i = 0; i < usedSize; i++) {
            if(array[i]==toFind){
                return i;
            }
        }
        return 0;
    }

获取 pos 位置的元素

@Override
    public int get(int pos) {

        try{
            checkEmpty();
            checkPos2(pos);
            return array[pos];
        }catch(PosIllegal e) {
            e.printStackTrace();
        }catch(EmptyException e){
            e.printStackTrace();
        }
        return -1;
    }
    private void checkEmpty(){
        if(isEmpty()){
            throw new EmptyException("顺序表为空");
        }
    }
    public boolean isEmpty(){
        return usedSize==0;
    }
    private void checkPos2(int pos){
        if(pos < 0 || pos > usedSize){
            throw new PosIllegal("Pos位置不合法");
        }
    }

将pos位置元素改为value

@Override
    public void set(int pos, int value) {
        try{
            checkEmpty();//检查顺序表是否为空
            checkPos2(pos);//检查pos位置是否为空
            array[pos]=value;
        }catch (PosIllegal e){
            e.printStackTrace();
        }catch (EmptyException e){
            e.printStackTrace();
        }
    }

删除第一次出现的关键词

@Override
    public void remove(int toRemove) {
            try{
                checkEmpty();
                int pos = indexOf(toRemove);
                if(pos==-1){
                    return;
                }``
                for (int i = 0; i < usedSize; i++) {
                    array[i]=array[i+1];
                }
                usedSize--;
            }catch (EmptyException e) {
                e.printStackTrace();
            }
    }

获取顺序表长度

@Override
    public int size() {
        return this.usedSize;
    }

清空顺序表

 @Override
    public void clear() {
        //引用类型释放空间
        /*for (int i = 0; i < usedSize; i++) {
            array[i] = null;
        }*/
        //基本类型直接清空
        usedSize=0;
    }

ArrayList简介

ctrl+鼠标左键进入ArrayList源码，
在这里插入图片描述
也可以看到编译器中add等功能的源码，具体再次不一一展示，感兴趣的大佬可以去编译器看看。
在这里插入图片描述
由ArrayList的源码可以看到：

  1. ArrayList是以泛型方式实现的，使用时必须要先实例化
  2. ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问
  3. ArrayList实现了Cloneable接口，表明ArrayList是可以clone的
  4. ArrayList实现了Serializable接口，表明ArrayList是支持序列化的
  5. 和Vector不同，ArrayList不是线程安全的，在**单线程下可以使用，**在多线程中可以选择Vector或者CopyOnWriteArrayList
  6. ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

ArrayList的使用

因为前面说了MyArrayList的各种功能，相当于自主实现了ArrayList。这里只写了没有说到的部分功能

public static void main(String[] args) {
        ArrayList<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        System.out.println(list);

        //截取数组
        List<Integer> list1=list.subList(0,3);
        System.out.println(list1);
        System.out.println("===========");

        list.set(0,99);
        System.out.println(list);
        System.out.println(list1);
    }

在这里插入图片描述

 // 查找指定元素第一次出现的位置：indexOf从前往后找，lastIndexOf从后往前找
        list.add(2);
        list.add(6);
        list.add(4);
        list.add(5);
        list.add(9);
        list.add(78);
        list.add(66);

        System.out.println(list.indexOf(5));
        System.out.println(list.lastIndexOf(6));

在这里插入图片描述

ArrayList的遍历

ArrayList 可以使用三方方式遍历：for循环+下标、foreach、使用迭代器

public static void main(String[] args) {
  List<Integer> list = new ArrayList<>();
  list.add(1);
  list.add(2);
  list.add(3);
  list.add(4);
  list.add(5);
  // 使用下标+for遍历
  for (int i = 0; i < list.size(); i++) {
    System.out.print(list.get(i) + " ");
 }
  System.out.println();
  
  // 借助foreach遍历
  for (Integer x : list) {
    System.out.print(x + " ");
 }
  System.out.println();
  
  //使用迭代器
  Iterator<Integer> it = list.listIterator();
  while(it.hasNext()){
    System.out.print(it.next() + " ");
 }
  System.out.println();
}

在这里插入图片描述

ArrayList扩容

  1. 检测是否真正需要扩容，如果是调用grow准备扩容
  2. 预估需要库容的大小
    初步预估按照1.5倍大小扩容
    如果用户所需大小超过预估1.5倍大小，则按照用户所需大小扩容
    真正扩容之前检测是否能扩容成功，防止太大导致扩容失败
  3. 使用copyOf进行扩容
private void grow(){
        this.array= Arrays.copyOf(this.array,2*this.array.length);
    }

练习（洗牌算法）

Test1

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

public class Test1 {
    public static void main(String[] args) {
        CardDemo cardDemo=new CardDemo();

        List<Card> cardList = CardDemo.buyCard();
        System.out.println(cardList);

        cardDemo.shuffle(cardList);
        System.out.println(cardList);


        List<List<Card>> ret = CardDemo.play(cardList);
        for (int i = 0; i < ret.size(); i++) {
            System.out.println("第"+(i+1)+"个人的牌： "+ret.get(i));
        }
    }
}

Card

public class Card {
    private String suit;
    private int rank;

    public Card(String suit,int rank){
        this.suit=suit;
        this.rank=rank;
    }

    @Override
    public String toString() {
        /*return "Card{" +
                "suit='" + suit + '\'' +
                ", rank=" + rank +
                '}';*/
        return "{"+suit + rank+"} ";
    }
}

CardDemo

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Callable;


public class CardDemo {
    public static  final  String[] suits={"♥","♠","♣","♦"};

    //得到52张牌
    public static List<Card> buyCard(){
        List<Card> cardList=new ArrayList<>();
        for (int i = 1; i <= 13; i++) {
            for (int j = 0; j < 4; j++) {
                int rank = i;
                String suit=suits[j];
                Card card=new Card(suit,rank);
                cardList.add(card);
            }
        }
        return cardList;
    }
    //洗牌
    public void shuffle(List<Card> cardList){
        Random random=new Random();
        for (int i = cardList.size()-1; i >0 ; i--) {
            int index = random.nextInt(i);
            swap(cardList,i,index);
        }
    }
    private void swap(List<Card> cardList,int i,int j ){
        Card tmp=cardList.get(i);
        cardList.set(i,cardList.get(j));
        cardList.set(j,tmp);
    }
    //三人拿牌
    public static List<List<Card>> play(List<Card> cardList){
        List<Card> hand0 = new ArrayList<>();
        List<Card> hand1 = new ArrayList<>();
        List<Card> hand2 = new ArrayList<>();

        List<List<Card>> hand=new ArrayList<>();
        hand.add(hand0);
        hand.add(hand1);
        hand.add(hand2);

        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                Card card = cardList.remove(0);
                hand.get(j).add(card);
            }
        }
        return hand;
    }

}

完结

好了，到这里Java语法部分就已经结束了~
如果这个系列博客对你有帮助的话，可以点一个免费的赞并收藏起来哟~
可以点点关注，避免找不到我~ ，我的主页：optimistic_chen
我们下期不见不散~~Java

下期预告: 【Java数据结构】- - - List

optimistic_chen
关注
专栏目录
JAVA基础篇List集合&数据结构
qq_41418032的博客
06-24 745
List的概述 list是一个接口，是Collection的子接口 List接口有以下三个特点，有序（有序不是排序，有序指的是按照什么顺序存的就按照什么顺序取） 有索引（可以根据索引获取元素） 可以重复（可以存放重复元素） List是一个接口，如果要用，需要使用实现类，最常用的实现类是ArrayList List接口中的常见方法 public void add(int index,E elem...
数据结构-列表(List)介绍和Java示例代码
07-01
数据结构列表(List)介绍和Java示例代码 数据结构列表（List）是 Java 中的一种线性数据结构，用于存储有序的元素集合。它允许重复元素，并且每个元素都有一个对应的索引来访问和操作。列表可以动态增长或缩小，并且...
Java——List，ArrayList详解
m0_60867520的博客
07-02 1245
Java下的List与ArrayList概念及方法的介绍
JAVA中的arraylist集合,Java ArrayList集合
weixin_35893552的博客
03-14 126
## ArrayList集合 ##![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDgzODU4OQ_size_16_color_FFFFFF_t_70]#### 1、介绍 ####> * 集合和数组的区别：数组长度不能改变，但是...
java 的arraylist_Java中的List和ArrayList
weixin_29001655的博客
03-07 184
【问题引入】要实例化一个集合类型的对象，有以前几种方式。List alist;List blist=new List();List clist = new ArrayList();ArrayList dlist=new ArrayList();结果是： 【知识分析】在Java中，List是一个接口，而ArrayList是一个实现类。所以List不能被构造，但是可以为List创建一个引用，而Arra...
【Java】List集合之ArrayList
weixin_53972936的博客
03-12 2819
​ List集合下共有ArrayList、LinkedList、Vector三种实现方法，但是ArrayList是 java 集合框架中比较常用的数据结构。继承自 AbstractList，实现了 List 接口。底层基于数组实现容量大小动态变化。允许 null 的存在。同时还实现了 RandomAccess、Cloneable、Serializable 接口，所以ArrayList 是支持快速访问、复制、序列化的。 每一个ArrayList都有一个初始化的容量（10），该容量代表了数组的大小，随着容器
Java集合--List（ArrayList、LinkedList）
喜之郎cc果冻的博客
09-10 832
ArrayList和LinkedList是Java中两种常用的List实现类。它们之间的主要区别如下： 内部实现：ArrayList是动态数组实现，底层使用数组来存储元素。LinkedList是链表实现，底层使用双向链表来存储元素。 随机访问：对于随机index访问的get和set方法，一般ArrayList的速度要优于LinkedList。 插入和删除操作：对于插入和删除操作，LinkedList优于ArrayList。 内存占用：LinkedList比ArrayList更占内存，因为LinkedLis
javalist数据结构-Java数据结构-------List.pdf
07-11
Java中的List接口是集合框架的重要组成部分，它定义了一组有序的元素序列，允许有重复的元素。ArrayList、Vector和LinkedList都是List接口的实现...在实际使用中，根据业务需求权衡性能和功能，选择最适合的数据结构。
java——ArrayList-源码解析.docx
05-09
ArrayList 是 Java 中常用的集合类，它是 List 接口的一个实现，基于数组进行操作。ArrayList 的设计使得元素可以动态地添加和删除，同时提供了对数组大小的灵活调整。它实现了 ICollection 和 IList 接口，提供了...
java-data-struct.rar_数据结构 java_数据结构源码
09-22
"java-data-struct.rar_数据结构 java_数据结构源码"这个压缩包文件包含了用Java实现的数据结构的相关代码，对于学习和理解数据结构的实现具有很高的参考价值。 1. **链表（LinkedList）**：链表是一种线性数据结构...
java基础--list（ArrayList、LinkedList、匿名类）.docx
08-07
【Java基础——List接口详解...在实际开发中，根据具体需求选择合适的数据结构，可以提高程序性能并降低复杂度。同时，掌握如何对List进行排序，无论是通过Comparable接口还是Comparator接口，都能使数据处理更加灵活。
详解java中ArrayList
最新发布
phone15931168209的博客
01-11 1892
当你看到这篇文章我觉得很好笑，因为我开始也不同ArrayList现在轮到你了，嘻嘻嘻，但是没关系我教你，action!!!一、ArrayList是什么通俗点讲ArrayList就是数组文字解答：ArrayList属于List，List是线性表，线性表有顺序表、链表、栈、队列...，而ArrayList底层代码就是顺序表（数组）//数组// 默认的容量//数组初始化你可能感觉很奇怪，ArrayList底层既然是数组，那为什么不直接写成数组的形式呢，比如这样。
Java中的List和ArrayList
Summer
06-05 941
【问题引入】        要实例化一个集合类型的对象，有以前几种方式。 List alist; List blist=new List(); List clist = new ArrayList(); ArrayList dlist=new ArrayList(); 结果是： 【知识分析】           在Java中，List是一个接口，而ArrayList
java中List和ArrayList
weixin_43363236的博客
11-25 562
一、 java中List和ArrayList List是一个接口，有好多实现类 如：ArrayList、LinkedList、Vector 用哪个就new哪个 ArrayList是List接口的一个实现类，继承并实现了List接口 List a = new ArrayList(); 二、 List.add() 和 List.addAll() 方法 1、List.addAl...
Java List与ArrayList
PepDokHa的博客
03-23 3238
Java数据结构 List的介绍和ArrayList的使用与实现
Java ArrayList
yake1965
12-07 1014
List 在集合类中，List 是最基础的一种集合：它是一种有序列表。 List 的行为和数组几乎完全相同：List 内部按照放入元素的先后顺序存放，每个元素都可以通过索引确定自己的位置，List的索引和数组一样，从0开始。 数组和 List 类似，也是有序结构，如果我们使用数组，在添加和删除元素的时候，会非常不方便。 因此，在实际应用中，需要增删元素的有序列表，我们使用最多的是ArrayList。实际上，ArrayList 在内部使用了数组来存储所有元素。 当添加一个元素并指定索引到 ArrayList
java数据结构list
Jay112011的博客
06-29 734
java数据结构list list是一个接口 list的长度可以改变，ArrayList和linkedList都可以增加和删除元素。 list里面的元素可以重复 list里面可以添加null元素 Iterator遍历List效率比较高 for each如 for (Object s : array) 底层使用的就是Iterator遍历 list转换为array：Integer[]array=list.toArray(newInteger[list.size()]); array转换成...
评论 23
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值