ArrayList的详解

已于 2023-05-22 21:30:16 修改
阅读量5.2k 收藏 14
点赞数 10
分类专栏： 数据结构 文章标签： java 服务器 jvm
于 2022-10-04 00:03:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53677355/article/details/127157796
版权

      线性表是n个具有相同特性的数据元素的有限序列，线性表是一种在实际中广泛使用的数据结构。线性表在逻辑上是线性结构，也就是说是连续的一条直线，但是在物理上不一定是连续的，线性表在物理上存储的时候，通常以数组和链式结构的形式存储，常见的线性表：顺序表、链表、栈、队列...

一、顺序表

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

二、ArrayList简介

       在集合框架中，ArrayList是一个普通的类，实现了List接口 

  由框架图可知：

     1、ArrayList是以泛型方式实现的，使用时必须要实例化

     2、ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问

     3、ArrayList实现了Cloneable接口，表明ArrayList是可以clone的

     4、ArrayList实现了Serializable接口，表明ArrayList是支持序列化的

     5、ArrayList不是线程安全的，在单线程下可以使用

     6、ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

三、ArrayList使用

     1、ArrayList的三种构造方法

ArrayList（）                                                       无参构造

ArrayList（Collection<? extends E> c)                利用其他Collection构建ArrayList

ArrayList（int initialCapacity）                             指定顺序表初始容量

import java.util.ArrayList;
import java.util.List;
public class Main1001_1 {
    public static void main(String[] args) {
        //ArrayList的三种构造方法
        ArrayList<String> list1  = new ArrayList<>();

        ArrayList<String> list2  = new ArrayList<>(5);
        list2.add("aaa");
        list2.add("bbb");
        list2.add("ccc");
        list2.add("ddd");
        list2.add("eee");
        System.out.println(list2);

        ArrayList<String> list3 = new ArrayList<>(list2);
        //通过一个集合快速构造出包含传入元素所有元素的新集合
        System.out.println(list3);
}
}

 2、 ArrayList的常见操作

boolean contains(Object o)判断o是否在线性表中
int indexOf(Object o)返回第一个o所在下标
int lastIndexOf(Object o)返回最后一个o的下标
List<E> subList(int fromIndex, int toIndex)截取部分list

 List<E> subList(int fromIndex, int toIndex)：

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

public class Main1001_1 {
    public static void main(String[] args) {
        //ArrayList的三种构造方法
        ArrayList<String> list1  = new ArrayList<>();

        ArrayList<String> list2  = new ArrayList<>(5);
        list2.add("aaa");
        list2.add("bbb");
        list2.add("ccc");
        list2.add("ddd");
        list2.add("eee");
        System.out.println(list2);

        ArrayList<String> list3 = new ArrayList<>(list2);
        //通过一个集合快速构造出包含传入元素所有元素的新集合
        System.out.println(list3);

        //sublist
        List<String> list4 = list2.subList(1,3);
        System.out.println(list4);//左闭右开
        //修改这个子集合
        list4.set(0,"hello");
        System.out.println(list4);
        System.out.println(list2);//list2的值也随之修改,注意引用类型的操作
    }
}

  3、ArrayList的遍历

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

import java.util.ArrayList;

public class Main1001_2 {
    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);

        //遍历的三种方法,这里先介绍前两种
        for(int i = 0;i < list.size();i++){
            System.out.print(list.get(i) + " ");
        }
        System.out.println();
        for(int num : list){
            System.out.print(num + " ");
        }
    }
}

  4、 ArrayList的扩容机制

         ArrayList是一个动态类型的顺序表，在插入元素的过程中会自动扩容

         1）调用无参构造方法，初始化ArrayList对象，底层创建了一个空数组，第一次add的时候才去指定数组的容量

         2）扩容是以1.5倍的容量去扩容的

         3）ArrayList底层是以数组存储数据的

四、自己实现MyArraylist

import java.util.Arrays;

public class MyArraylist {

    public int[] elem;
    public int usedSize;//0
    //默认容量
    private static final int DEFAULT_SIZE = 10;

    public MyArraylist() {
        this.elem = new int[DEFAULT_SIZE];
    }

    /**
     * 打印顺序表:
     * 根据usedSize判断即可
     */
    public void display() {
        if(usedSize == 0){
            System.out.println("[]");
            return;
        }
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for(int i = 0;i < usedSize;i++){
            sb.append(this.elem[i]);
            if(i < usedSize - 1){
                sb.append(", ");
            }
        }
        sb.append("]");
        System.out.println(sb.toString());
    }

    // 新增元素,默认在数组最后新增
    public void add(int data) {
        //数据满的时候我们需要进行扩容，扩容的规则是以当前容量的二倍的大小进行
        //1、判断是否已满
        if(isFull()){
            this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
        }

        this.elem[usedSize] = data;
        usedSize++;
    }

    /**
     * 判断当前的顺序表是不是满的！
     *
     * @return true:满   false代表空
     */
    public boolean isFull() {
        return usedSize == this.elem.length;
    }


    private boolean checkPosInAdd(int pos) {
        if(pos < 0 || pos > this.elem.length){
            throw new IndexOutOfBoundsException("下标异常");
        }
        return true;//合法
    }

    // 在 pos 位置新增元素
    public void add(int pos, int data) {
        //1、判断当前位置是否合法
        checkPosInAdd(pos);
        //2、判断是否已满
        if(isFull()){
            this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
        }
        //3、把pos之后的位置向后移
        for(int i = usedSize;i > pos;i--){
            this.elem[i] = this.elem[i - 1];
        }
        //4、把新增的元素插入进去
        this.elem[pos] = data;
        //5、有效位数加一
        usedSize++;
    }


    // 判定是否包含某个元素
    public boolean contains(int toFind) {
        for(int i = 0;i < usedSize;i++){
            if(this.elem[i] == toFind){
                return true;
            }
        }
        return false;
    }

    // 查找某个元素对应的位置
    public int indexOf(int toFind) {
        for(int i = 0;i < usedSize;i++){
            if(this.elem[i] == toFind){
                return i;
            }
        }
        return -1;
    }

    // 获取 pos 位置的元素
    public int get(int pos) {
        checkPosInAdd(pos);
        return this.elem[pos];
    }

    private boolean isEmpty() {
        if(usedSize == 0){
            return true;
        }
        return false;
    }

    // 给 pos 位置的元素设为【更新为】 value
    public void set(int pos, int value) {
        checkPosInAdd(pos);
        this.elem[pos] = value;
    }

    /**
     * 删除第一次出现的关键字key
     *
     * @param key
     */
    public void remove(int key) {
        int index = indexOf(key);
        if(index == -1){
            return;
        }
        for(int i = index;i < usedSize;i++){
            this.elem[i] = this.elem[i + 1];
        }
        usedSize--;
    }

    // 获取顺序表长度
    public int size() {
        return usedSize;
    }

    // 清空顺序表
    public void clear() {
        usedSize = 0;
//        //如果是引用类型，每个下标的元素都应该置为null
//        for(int i = 0;i < usedSize;i++){
//            this.elem[i] = null;
//        }
    }
}
public class Test {
    public static void main(String[] args) {
        MyArraylist list = new MyArraylist();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.display();
        list.add(1,10);
        list.display();
        System.out.println(list.contains(5));
        System.out.println(list.indexOf(5));
        System.out.println(list.get(3));
        list.set(3,33);
        list.display();
        list.remove(33);
        list.display();
    }
}

五、使用ArrayList实现扑克牌

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

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

    public Poker() {
    }

    @Override
    public String toString() {
        return "[" + suit + " " + rank + "]";
    }

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

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

    //买一副新牌
    public static List<Poker> buy(){
        List<Poker> pokers = new ArrayList<>();
        for(int i = 0;i < 3;i++){
            for(int j = 1;j <= 13;j++){
                String suitTemp = suits[i];
                pokers.add(new Poker(suitTemp,j));
            }
        }
        return pokers;
    }

    //洗牌
    public static void shuffle(List<Poker> pokers){
        //判断参数是否为空
        if(pokers == null){
            throw new RuntimeException("不能为空");
        }
        Random random = new Random();
        //开始洗牌
        for(int i = 0;i < pokers.size();i++){
            int index = random.nextInt(pokers.size());//[0,pokers.size())
            Poker temp = pokers.get(index);
            pokers.set(index,pokers.get(i));
            pokers.set(i,temp);
        }
    }

    //发牌
    public static List<List<Poker>> toDeting(List<Poker> pokers){
        //这个集合里面包含了所有的玩家
        List<List<Poker>> players = new ArrayList<>();
        //定义每个玩家，这里假设有三个
        for(int i = 0;i < 3;i++){
            List<Poker> player = new ArrayList<>();
            //把玩家加入集合
            players.add(player);
        }
        //开始发牌
        for(int i = 0;i < 5;i++){
            for(int j = 0;j < players.size();j++){
                //先获取玩家
                List<Poker> player = players.get(j);
                Poker poker = pokers.remove(0);
                //把拿到的牌加到玩家的list里面
                player.add(poker);
            }
        }
        return players;
    }
    public String getSuit() {
        return suit;
    }

    public void setSuit(String suit) {
        this.suit = suit;
    }

    public int getRank() {
        return rank;
    }

    public void setRank(int rank) {
        this.rank = rank;
    }
}

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

public class TestPoker {
    public static void main(String[] args) {
        List<Poker> pokers = Poker.buy();
        System.out.println("新生成一副牌" + pokers);

        //洗牌
        Poker.shuffle(pokers);
        System.out.println("洗牌之后" + pokers);

        //测试发牌
        List<List<Poker>> players = Poker.toDeting(pokers);
        for(int i = 0;i < players.size();i++){
            System.out.println("玩家" + (i + 1) + ":" + players.get(i));
        }
        System.out.println("剩下的牌");
        System.out.println(pokers);


    }
}

薰衣草2333
关注
专栏目录
ArrayList的理解
ZhaFi人
09-26 3474
ArrayList集合是Collection和List接口的实现类，底层的数据结构可变的Object数组，对ArrayList的所有操作都是通过数据来实现的，数据结构特点是增删慢、查询快。// 默认的容量大小（常量）// 定义的空数组（final修饰，大小固定为0）// 定义的默认空容量的数组（final修饰，大小固定为0）// 定义的不可被序列化的数组，实际存储元素的数组// 数组中元素的个数。
ArrayList（详细讲解）
Java_maxiaoyi的博客
06-03 2163
1. ArrayList 1.1 ArrayList简介 ArrayList 的底层是数组队列，相当于动态数组。与 Java 中的数组相比，它的容量能动态增长。在添加大量元素前，应用程序可以使用ensureCapacity 操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。 它继承于AbstractList，实现了List,RandomAccess,Cloneable,java.io.Serializable这些接口。 在我们学数据结构的时候就知道了线性表的顺序存...
深入理解ArrayList
逍遥的博客
11-28 162
什么是ArrayList？ ArrayList的实现原理其实就是数组（动态数组），ArrayList的介绍及简单使用方法 动态数组与一般数组有什么区别？ 与Java中的数组相比，ArrayList的容量能动态地增长 ArrayList效率怎么样？ ArrayList不是线程安全的，所以效率比较高 ，但是只能用于单线程的环境中，那多线程呢？别急，文末会讲到 ArrayList主要继承哪...
ArrayList底层原理
最新发布
weixin_64689713的博客
09-20 406
ArrayList 的源码实现主要包括成员变量、构造方法、扩容机制、添加和删除操作等部分。通过这些部分的实现，ArrayList 能够高效地存储和操作数据。在实际使用中，我们需要根据实际需求选择合适的容量，并尽量避免频繁的扩容操作，以提高程序的性能。
ArrayList详解
Oeljeklaus的博客
05-15 1472
1.2ArrayList1.2.1特点线程不安全，动态数组实现1.2.2结构1.2.3实现接口实现了哪些接口public class ArrayList&lt;E&gt; extends AbstractList&lt;E&gt;        implements List&lt;E&gt;, RandomAccess, Cloneable, java.io.Serializable可以看出A...
ArrayList
weixin_30788239的博客
05-05 140
ArrayList ArrayList 概述 成员变量 构造器 成员方法 Summary 概述 ArrayList是List接口的具体实现类，可以存储任何元素，包括null。这个类与Vector类几乎是一样的，仅有的区别就是Vector类是线程安全的(方法有synchronized关键字)，而ArrayList不是。 关于时间复杂度： con...
java关键字ArrayList详解
07-04
ArrayList是Java集合框架中的一种重要实现，它是List接口的一个具体类，主要特点是基于数组实现，提供了灵活的元素存储和操作。ArrayList支持动态扩容，可以根据需要自动增加数组的大小，这使得在不知道确切元素数量...
ArrayList详解和使用示例_动力节点Java学院整理
08-30
"ArrayList详解和使用示例" ArrayList是Java中的一种动态数组，相比于传统数组，它的容量可以动态增长。在本文中，我们将对ArrayList进行详细的介绍，并提供相关的使用示例代码。 ArrayList简介 ArrayList是一个...
C# 中 Array和 ArrayList详解及区别
12-31
C# 中 Array和 ArrayList详解及区别 一、Array 的用法 type[] typename=new type[size];  或者  type[] typename=new type[]{ };  Array类型的变量在声明的同时必须进行实例化(如果初始化至少得初始化数组...
ArrayList 详解
热门推荐
Harbour_zhang的博客
02-18 2万+
ArrayList 是 java 集合框架中比较常用的数据结构了。继承自 AbstractList，实现了 List 接口。底层基于数组实现容量大小动态变化。允许 null 的存在。同时还实现了 RandomAccess、Cloneable、Serializable 接口，所以ArrayList 是支持快速访问、复制、序列化的。 成员变量 ArrayList 底层是基于数组来实现容量大小动态变化的。 /** * The size of the ArrayList (the number of element
Java 集合系列（二）ArrayList详解
08-26
Java 集合系列（二）ArrayList详解 在 Java 集合系列中，ArrayList 是一个非常重要的部分，它通过一个数组来实现，因此它是在连续的存储位置存放对象的引用，只不过它比 Array 更智能，能够根据集合长度进行自动扩...
Vector源码分析
qq_45626944的博客
04-02 161
Vector 1.构造 1.1Vector() public Vector() { this(10); //默认初始容量为10 } 1.2Vector(int) public Vector(int initialCapacity) { this(initialCapacity, 0); //直接给初始容量，还有容量增长值。 } 1.3Vector(int,int) public Vector(int initialCapacity, int capacityIncrement) {
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

薰衣草2333

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值