ArrayList的详解

已于 2023-05-22 21:30:16 修改
阅读量4.2k 收藏 10
点赞数 9
分类专栏： 数据结构 文章标签： 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
关注
  • 9
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Java 集合系列（二）ArrayList详解
08-26
主要介绍了Java集合系列ArrayList，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
【Java】ArrayList(集合)超详解
接着奏乐接着舞的博客
04-20 9322
什么是集合​ 提供一种存储空间可变的存储模型，存储的数据容量可以发生改变ArrayList集合的特点​ 底层是数组实现的，长度可以变化泛型的使用​ 用于约束集合中存储元素的数据类型。
java关键字ArrayList详解
07-04
ArrayList是Java中的一种常见的数据结构，它实现了List接口，是线程不安全的动态数组。它的容量可以自动增长，因此可以方便地插入、删除和查找数据，是Java集合框架中广泛使用的一种结构。 ArrayList的优势在于灵活性和运行速度，它可以自动扩展，支持任何类型的元素并且元素索引从0开始。通过使用ArrayList，开发人员可以通过添加和删除元素来动态修改数组的大小，使其适应不同的应用程序场景。并且，由于ArrayList底层是使用数组实现的，因此它的访问速度非常快。 另一方面，由于ArrayList是线程不安全的，因此在使用ArrayList时需要注意多线程同步问题，可以通过使用线程安全的Collections.synchronizedList()方法来创建线程安全的ArrayList。 总之，ArrayList是Java中一种很有用的数据结构，同时也是Java集合框架中最常用的一种结构。通过使用ArrayList，开发人员既可以动态地添加和删除元素，也可以快速访问元素。在开发过程中，如果要使用ArrayList，请注意考虑多线程安全问题。
ArrayList的基本操作以及使用（java日志七）
cr18175627706的博客
04-15 3675
我们在存放对象时可以使用类数组，但是这有明显的弊端，数组的大小是固定的，当对象数量过多时，数组会发生越界，你可能在想，那就尽可能让数组开大一点，可是如果数组开大，数组中又会存在空间浪费问题，并且，也并未解决数组会越界的问题。这时候我们就需要用到集合，接下来我们重点讲java中的一种集合类型Arraylist。以上就是今天要讲的内容，本文简单介绍了ArrayList的创建以及基本操作方法。
Java ArrayList new出来，默认的容量到底是0还是10 ？
默默不代表沉默
02-21 1万+
前文 最近也快到了金三银四， 想该篇文章这种问题，貌似又有了热度 ： 这种问题存在疑惑吗？ 如果你存在？ 看完这篇你就没疑惑了 。 这一篇结合源码还有小代码例子， 还有我的唠叨，我们还是一贯作风，学知识，跟着我，只学一遍，忘不掉！ 正文 不多说，开整： JDK 1.8 第一行代码，new一个ArrayList出来： List<Integer> testList = new ArrayList<>(); 然后点进去看源码， 跟着我...
C# 中 Array和 ArrayList详解及区别
12-31
C# 中 Array和 ArrayList详解及区别 一、Array 的用法 type[] typename=new type[size];   或者   type[] typename=new type[]{ };  Array类型的变量在声明的同时必须进行实例化(如果初始化至少得初始化数组的大小)  平常我们int[],string[]…事实上就是声明一个array数组了    如： string [] srt=new string[]{a,b}; int[] a=new int[2]; string [] srt=new string[3]; (
ArrayList详解
Valineliu
03-11 4万+
1、简介 ArrayList是Java集合框架中的一个重要的类，它继承于AbstractList，实现了List接口，是一个长度可变的集合，提供了增删改查的功能。集合中允许null的存在。ArrayList类还是实现了RandomAccess接口，可以对元素进行快速访问。实现了Serializable接口，说明ArrayList可以被序列化，还有Cloneable接口，可以被复制。和Ve
Java集合篇：ArrayList详解
张维鹏的博客
10-25 1万+
一、ArrayList概述： ArrayList是实现了List接口的动态数组，所谓动态数组就是他的大小是可变的。实现了所有可选列表操作，并允许包括Null在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。 每个ArrayList实例都有一个容量，该容量是指用来存储列表元素的数组的大小。默认初始容量是10。默认初始容量为10。随着ArrayLis...
ArrayList简介
NRapid&JRapid
04-26 3034
ArrayList 是一个数组列表。它的主要底层实现是Object数组，但与 Java 中的数组相比，它的容量能动态变化，可看作是一个动态数组结构。特别注意的是，当我们装载的是基本类型的数据 int，long，boolean，short，byte… 的时候，我们只能存储他们对应的包装类。
ArrayList详解和使用示例_动力节点Java学院整理
08-30
ArrayList 是一个数组队列，相当于 动态数组。与Java中的数组相比，它的容量能动态增长。接下来通过本文给大家介绍arraylist详解和使用示例代码，需要的的朋友一起学习吧
java中ArrayList的简述和用法
weixin_73996519的博客
05-20 101
ArrayList实现了List这个接口，List接口继承了collection接口，它是声明有序存储对象（可重复）功能的公共接口。List集合中只能存引用数据类型，不能存基础数据类型；当然如果一定要存的话可以用基础数据类型的封装类。这也决定了ArrayList也只能存对象。按我的理解，ArrayList是把每个对象的地址以数组的方式存储起来，只不过这个数组长度是可变的。
Java——ArrayList类的常用方法
weixin_44217936的博客
08-19 4474
Java——ArrayList类的常用方法
Java 中的 ArrayList 和 LinkedList
小康2022的博客
07-28 968
列表是一种数据结构，为了方便理解，我们可以认为它是动态的数组。众所周知，数组的大小在定义的时候就固定了，不可改变，那么它就无法存储超过它容量的数据，而列表的容量是无限大的，因为它可以随着其存储内容的大小进行动态的变化（包括容量扩增和缩小），这和 java.util.Vector 很像，但又不完全相同。Java 中对列表的实现有两种，ArrayList 和 LinkedList。
Java集合框架：ArrayList详解
weixin_64874291的博客
06-11 4096
1. ArrayList是以泛型的方式实现的，使用时必须先实例化2. ArrayList实现了randomAccess接口，所以ArrayList支持随机访问3. ArrayList实现了Cloneable接口，ArrayList时可以克隆的4. ArrayList不是线程安全的，（Vector是线程安全的）5. ArrayList是一段连续的空间，可以动态扩容，是动态的顺序表。
Arraylist的基本使用方法
热门推荐
m0_59392076的博客
05-15 6万+
目录 前言 Arraylist 是javase基础中重要的知识点，以后在工作中也可能常常用到。 一、Arraylist是什么？ 二、使用步骤 1.ArrayList 类位于 java.util 包中，使用前需要引入它，语法格式如下： 2.添加元素 3.删除元素 4.计算大小 5.其他的引用类型 6.ArrayList 排序 7.Java ArrayList 方法 Arraylist 是javase基础中重要的知识点，以后在工作中也可能常常用到。 提示：以下是...
ArrayList
深入探索技术领域，持续学习成长，追求实践与进步，共同构建技术未来
09-18 1049
ArrayList
mybatisPlus使用MetaObjectHandler对字段进行更新
最新发布
m0_56356631的博客
04-23 316
都是符合我们的预期的。
arraylist详解
07-17
ArrayList是Java中的一个集合类，它是通过数组实现的动态数组。ArrayList可以存储任意类型的对象，具有自动扩容的功能，并且支持添加、删除、查找、修改等操作。其中，嵌套ArrayList也可以通过在ArrayList中储存ArrayList来实现。在使用时，可使用add()方法来添加元素，remove()方法来删除元素，get()方法来获取元素，size()方法来获取元素个数等方法来对ArrayList进行操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

薰衣草2333

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

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

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

打赏作者

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

抵扣说明：

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

余额充值