ArrayList

最新推荐文章于 2024-06-12 14:33:24 发布
最新推荐文章于 2024-06-12 14:33:24 发布
阅读量1.3k 收藏 2
点赞数
分类专栏： 数据结构 文章标签： java 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SCR1209/article/details/126923162
版权

文章目录


java集合类一般都在java .util包底下

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ThkQGj5M-1663506389475)(D:/%E4%BD%A0%E5%A5%BDJava/305.png)]

注意一：ArrayList 的构造方法

ArrayList的底层还是一个数组（泛型数组）；

在这里插入图片描述

在这里插入图片描述

public static void main(String[] args) {
        ArrayList<Integer> arrayList0 = new ArrayList<>(12);
        arrayList0.add(1);
        arrayList0.add(2);
        arrayList0.add(3);
        System.out.println(arrayList0);  //里面已经重写了toString()方法
        ArrayList<String> arrayList1 = new ArrayList<>();
        arrayList1.add("hello");
        arrayList1.add("xiaobai");
        System.out.println(arrayList1);
        ArrayList<Integer> arrayList2 = new ArrayList<>(arrayList0); 
        //ArrayList<Integer> arrayList3 = new ArrayList<>(arrayList1);
        System.out.println(arrayList2);
        //System.out.println(arrayList3);
    }

/*
[1, 2, 3]
[hello, xiaobai]
[1, 2, 3]
*/

注意：

        ArrayList<Integer> arrayList2 = new ArrayList<>(arrayList0); 
        //ArrayList<Integer> arrayList3 = new ArrayList<>(arrayList1);
        System.out.println(arrayList2);
        //System.out.println(arrayList3);

这是第二种构造方法，意思是把 arrayList0 里面的数据传递给 arrayList2;

ArrayList arrayList2 ---- > arrayList2的类型是 ArrayList 里面的元素类型是 Integer ；

arrayList0 满足： Collection<? extends E> c 注意类型的匹配，这里的E是 arrayList2 中的 Integer ，所以 arrayList0 内类型的上界应该

是Integer 。

private static final int DEFAULT_CAPACITY = 10;

private static final Object[] EMPTY_ELEMENTDATA = {};

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

transient Object[] elementData;

private int size;

public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
}


public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}


public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
}

注意二：ArrayList的常用方法

boolean add(E e) 尾插 e
    
void add(int index, E element) 将 e 插入到 index 位置
    
boolean addAll(Collection<? extends E> c) 尾插 c 中的元素
    
E remove(int index) 删除 index 位置元素
    
boolean remove(Object o) 删除遇到的第一个 o
    
E get(int index) 获取下标 index 位置元素
    
E set(int index, E element) 将下标 index 位置元素设置为 element
    
void clear() 清空
    
boolean contains(Object o) 判断 o 是否在线性表中
    
int indexOf(Object o) 返回第一个 o 所在下标
    
int lastIndexOf(Object o) 返回最后一个 o 的下标
    
List<E> subList(int fromIndex, int toIndex) 截取部分 list

注意： remove( ) 方法

public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>(5);
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        arrayList.add(4);
        System.out.println(arrayList);
        System.out.println("----------------");
        //remove(int index); 删除下标为index的元素
        arrayList.remove(0);
        System.out.println(arrayList);
        System.out.println("----------------");
        //remove(object index); 删除index对象   里面要是对象/对象的引用
        arrayList.remove(new Integer(4));
        System.out.println(arrayList);
    }

/*
[1, 2, 3, 4]
----------------
[2, 3, 4]
----------------
[2, 3]
/*

注意：subList(index1 , index2)的部分截取功能

public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>(5);
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        arrayList.add(4);
        System.out.println(arrayList);
        System.out.println("----------------");
        //注意：subList(index1,index2) 的部分截取功能，左闭右开。返回值用lIst接收
        List<Integer> list = arrayList.subList(1,3);
        System.out.println(list);

    }

注意：ArrayList内存是如何置空的

在这里插入图片描述

注意三: 打印ArrayList中的每一个元素

//打印arrayList当中的元素
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        arrayList.add(4);
        arrayList.add(5);
        arrayList.add(6);
        arrayList.add(7);
        arrayList.add(8);
        arrayList.add(9);
        arrayList.add(10);
        //方法一：
        for (int i = 0; i < arrayList.size(); i++) {
            System.out.print(arrayList.get(i)+" ");
        }
        //方法二：
        for (Integer x: arrayList) {
            System.out.print(x+" ");
        }
        //方法三
        Iterator<Integer> it = arrayList.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

/*
1 2 3 4 5 6 7 8 9 10 
1 2 3 4 5 6 7 8 9 10 
1 2 3 4 5 6 7 8 9 10 
*/

在这里插入图片描述

迭代器的删除

在这里插入图片描述

练习一：

在这里插入图片描述

package demo;

public class Student implements Comparable <Student> {
    private String name;
    private int age;
    private double score;

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

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

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

    public  void setScore(double score) {
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public  double getScore() {
        return score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +'\'' +"scores='" + score+
        '}';
    }

    @Override
    public int compareTo(Student o) {
        return (int) (this.score - o.score);
    }
}


public class Test {
    public static void main(String[] args) {
        ArrayList<Student> arrayList = new ArrayList<>(3);
        arrayList.add(0,new Student("xiaobai",10,90));
        arrayList.add(1,new Student("xiaohong",20,80));
        arrayList.add(2,new Student("xiaogang",30,70));
        Collections.sort(arrayList); //用它对顺序表排序，arrayList里面的对象那个要重写compareTo（）方法

        Iterator<Student> it = arrayList.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

/*
Student{name='xiaogang', age=30'scores='70.0}
Student{name='xiaohong', age=20'scores='80.0}
Student{name='xiaobai', age=10'scores='90.0}
*/

练习二：

在这里插入图片描述

public static ArrayList<Character> func(String str1 , String str2){
        ArrayList<Character> arrayList = new ArrayList<>();
        for (int i = 0; i < str1.length(); i++) {
            if(!str2.contains(str1.charAt(i)+"")){
                arrayList.add(str1.charAt(i));
            }
        }
        return arrayList;
    }

public static void main(String[] args) {
        ArrayList<Character> arrayList = Test.func("welcome to bit", "come");
        System.out.println(arrayList);
    }

总结：
在这里插入图片描述

练习三：

class Poker

package demo;

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

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

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

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

    public String getSuit() {
        return suit;
    }

    public int getRank() {
        return rank;
    }

    @Override
    public String toString() {
        return this.suit+" "+this.rank;
    }
}

class Pokers

package demo;

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

public class Pokers {

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

    public ArrayList<Poker> func (){

        //创建一个纸盒
        ArrayList<Poker> arrayList = new ArrayList<>();
        //一共有四个花色，每个花色13张牌
        for (int i = 0; i < 4; i++) {
            for (int j = 1; j <= 13; j++) {
                arrayList.add(new Poker(SUITS[i],j ));
                //在这个地方花色要随着I的不同而改变。所以设立一个数组
            }
        }
        return arrayList;
    }
    public void shuffle(ArrayList<Poker>arrayList){
        Random random = new Random();
        for(int i = arrayList.size()-1; i > 0; i--){
            int ret = random.nextInt(i);
            //交换
            swap(arrayList , ret , i);
        }
    }

    public static void swap(ArrayList<Poker> arrayList, int ret,int i){
        Poker temp = arrayList.get(ret);
        arrayList.set(ret,arrayList.get(i));
        arrayList.set(i,temp);
    }



    public static void main(String[] args) {
        Pokers pokers = new Pokers();
        //建立一个纸盒
        ArrayList<Poker> arrayList = pokers.func();
        System.out.println(arrayList);
        //开始洗牌
        pokers.shuffle(arrayList);
        System.out.println(arrayList);
        //开始揭牌
        //3个人每个人抽5张牌
        ArrayList<Poker> hand1 = new ArrayList<>();
        ArrayList<Poker> hand2 = new ArrayList<>();
        ArrayList<Poker> hand3 = new ArrayList<>();
        ArrayList<ArrayList<Poker>> hands = new ArrayList<>();
        hands.add(hand1);
        hands.add(hand2);
        hands.add(hand3);

        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                hands.get(j).add(i,arrayList.get(0));
                arrayList.remove(0);
            }
        }
        for (int i = 0; i < hands.size(); i++) {
            System.out.println(hands.get(i));
            System.out.println();
        }
        System.out.println("剩余牌的数目");

        System.out.println(arrayList);



    }

}

/*
[♥ 1, ♥ 2, ♥ 3, ♥ 4, ♥ 5, ♥ 6, ♥ 7, ♥ 8, ♥ 9, ♥ 10, ♥ 11, ♥ 12, ♥ 13, ♦ 1, ♦ 2, ♦ 3, ♦ 4, ♦ 5, ♦ 6, ♦ 7, ♦ 8, ♦ 9, ♦ 10, ♦ 11, ♦ 12, ♦ 13, ♣ 1, ♣ 2, ♣ 3, ♣ 4, ♣ 5, ♣ 6, ♣ 7, ♣ 8, ♣ 9, ♣ 10, ♣ 11, ♣ 12, ♣ 13, ♠ 1, ♠ 2, ♠ 3, ♠ 4, ♠ 5, ♠ 6, ♠ 7, ♠ 8, ♠ 9, ♠ 10, ♠ 11, ♠ 12, ♠ 13]


[♥ 3, ♥ 11, ♠ 13, ♥ 12, ♥ 9, ♣ 1, ♠ 4, ♣ 3, ♦ 5, ♠ 11, ♠ 2, ♠ 5, ♠ 12, ♥ 1, ♦ 3, ♦ 11, ♦ 1, ♣ 11, ♥ 13, ♠ 8, ♣ 13, ♠ 10, ♠ 1, ♦ 12, ♦ 7, ♦ 9, ♥ 7, ♦ 10, ♠ 7, ♠ 9, ♦ 8, ♣ 5, ♠ 3, ♦ 6, ♥ 6, ♦ 4, ♦ 13, ♣ 7, ♥ 5, ♣ 9, ♣ 8, ♥ 4, ♦ 2, ♠ 6, ♥ 8, ♥ 2, ♣ 4, ♣ 10, ♣ 12, ♣ 2, ♥ 10, ♣ 6]


[♥ 3, ♥ 12, ♠ 4, ♠ 11, ♠ 12]

[♥ 11, ♥ 9, ♣ 3, ♠ 2, ♥ 1]

[♠ 13, ♣ 1, ♦ 5, ♠ 5, ♦ 3]

剩余牌的数目

[♦ 11, ♦ 1, ♣ 11, ♥ 13, ♠ 8, ♣ 13, ♠ 10, ♠ 1, ♦ 12, ♦ 7, ♦ 9, ♥ 7, ♦ 10, ♠ 7, ♠ 9, ♦ 8, ♣ 5, ♠ 3, ♦ 6, ♥ 6, ♦ 4, ♦ 13, ♣ 7, ♥ 5, ♣ 9, ♣ 8, ♥ 4, ♦ 2, ♠ 6, ♥ 8, ♥ 2, ♣ 4, ♣ 10, ♣ 12, ♣ 2, ♥ 10, ♣ 6]


*/

总结 1 ：

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

//一共有四个花色，每个花色13张牌
        for (int i = 0; i < 4; i++) {
            for (int j = 1; j <= 13; j++) {
                arrayList.add(new Poker(SUITS[i],j ));
                //在这个地方花色要随着I的不同而改变。所以设立一个数组
            }
        }

一共有4个花色，每种花色有13张牌，很显然用两个for循环，

 arrayList.add(new Poker(SUITS[i],j ));

我们想 i == 0 时候一个花色对应13个数字， i == 1 时候一个花色对应13个数字，所以有了上面的静态的数组（花色4中订好了）

总结二：

//开始揭牌
        //3个人每个人抽5张牌
        ArrayList<Poker> hand1 = new ArrayList<>();
        ArrayList<Poker> hand2 = new ArrayList<>();
        ArrayList<Poker> hand3 = new ArrayList<>();
        ArrayList<ArrayList<Poker>> hands = new ArrayList<>();
        hands.add(hand1);
        hands.add(hand2);
        hands.add(hand3);

        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                hands.get(j).add(i,arrayList.get(0));
                arrayList.remove(0);
            }
        }
        for (int i = 0; i < hands.size(); i++) {
            System.out.println(hands.get(i));
            System.out.println();
        }

在这里插入图片描述

三个人每个人摸五张牌：—> 创建一个二维数组：三个人在一个数组中，三个人每个人手中有5张牌，这5张牌放在一个数组中

在这里插入图片描述

 for (int i = 0; i < 5; i++) {  //摸5次
            for (int j = 0; j < 3; j++) { 
                hands.get(j).add(i,arrayList.get(0));//每次都是get(0),因为每次都是摸第一张，第一张一直都在改变
                arrayList.remove(0); //摸一次少一张牌
            }
 }

这个地方为什么倒着写

因为我们想实现的是一个人抹完之后另一个人摸，正着写不可以实现这个功能。

HackerTerry
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
new arraylist初始化_看了这一篇，让你少踩 ArrayList 的那些坑
weixin_39606799的博客
12-05 6085
请看下面的代码，谁能看出它有什么问题吗？String a = "古时的";String b = "风筝";List stringList = Arrays.asList(a,b);stringList.add("!!!");这是一个小白程序员问我的问题。他说：成哥，帮我看看这代码有什么问题吗，为什么报错呢，啥操作都没有啊？我：看上去确实没什么问题，但是我确实没用过 Arrays.asList这个...
Java中ArrayList的使用方法简单介绍
09-02
在Java编程语言中，ArrayList是集合框架中的一种重要数据结构，属于List接口的实现类。ArrayList主要用于存储一组有序的、可变大小的对象序列。它的特点是允许快速的随机访问，但插入和删除元素时效率相对较低，因为...
java arraylist 实现原理_java集合之ArrayList的实现原理
weixin_39764494的博客
02-12 239
1. ArrayList概述：ArrayList是List接口的可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。每个ArrayList实例都有一个容量，该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向ArrayList中不断添加元素，其容量也自动增长。自动增长会带...
Java数据结构之ArrayList（如果想知道Java中有关ArrayList的知识点，那么只看这一篇就足够了！）
最新发布
秋刀鱼不做梦的编程日常
06-12 2812
Java数据结构之ArrayList（如果想知道Java中有关ArrayList的知识点，那么只看这一篇就足够了！）
new arraylist初始化_京东架构 ArrayList和LinkedList使用场景
weixin_39933484的博客
12-02 890
ArrayListArrayList 内部维护了一个动态的Object 数组，ArrayList 的动态增删就是对这个数组的动态增删。1、ArrayList 的构造以及初始化ArrayList 实例变量ArrayList构造函数：ArrayList 构造函数ArrayList 在调用构造函数初始化时(new)，如果是无参构造，则是为elementData赋值为Object[0]，即创建一个容量为0...
Java ArrayList new出来，默认的容量到底是0还是10 ？
热门推荐
默默不代表沉默
02-21 1万+
前文 最近也快到了金三银四， 想该篇文章这种问题，貌似又有了热度 ： 这种问题存在疑惑吗？ 如果你存在？ 看完这篇你就没疑惑了 。 这一篇结合源码还有小代码例子， 还有我的唠叨，我们还是一贯作风，学知识，跟着我，只学一遍，忘不掉！ 正文 不多说，开整： JDK 1.8 第一行代码，new一个ArrayList出来： List<Integer> testList = new ArrayList<>(); 然后点进去看源码， 跟着我...
java new arraylist,java基础-遇见ArrayList集合
weixin_29781865的博客
03-19 1996
1、围观某学生管理系统大伙儿快来看这个学生管理系统啊，竟然还在使用数组来存储学生信息数据，太low了吧。增加学生数量还要不停地新建数组，看来一定是不知道数组的长度是不可以改变的，是不是应该吐槽一下，来我们一起喊，小菜鸡~。我们自己来实现一个比较牛学生管理系统。2、了解集合与数组来我们来普及一下数组的最基本概念，数组是可以用来存储相同数据类型的数据的一种容器，数组一经创建长度是固定的。如果需要改变长...
java关键字ArrayList详解
07-04
ArrayList是Java集合框架中的一种重要实现，它是List接口的一个具体类，主要特点是基于数组实现，提供了灵活的元素存储和操作。ArrayList支持动态扩容，可以根据需要自动增加数组的大小，这使得在不知道确切元素数量...
Java中Vector与ArrayList的区别详解
09-05
Java中的ArrayList和Vector都是列表（List）接口的实现类，它们在功能上相似，但在细节上存在一些重要的差异。这两个类都是基于数组实现的，但它们的性能特点、线程安全性和扩容策略有所不同。 1. **扩容策略**： ...
arrayList.cpp
11-23
用数组实现的线性表，代码介绍可以参见博客：https://blog.csdn.net/qq_41453285/article/details/103198828
Java容器ArrayList知识点总结
08-27
Java容器ArrayList知识点总结 Java容器ArrayList是Java集合框架中的一种常用的容器实现，它的底层实现是基于数组的。ArrayList具有访问元素效率高、查询快、插入、修改、删除元素慢等特点，与LinkedList相比，它...
Java中ArrayList类的使用方法
09-04
ArrayList是Java中常用的一种集合类，它是基于动态数组实现的，允许我们在运行时灵活地添加、删除或修改元素。ArrayList类是Java集合框架的一部分，它实现了List接口，因此也遵循了列表的所有规则。 1. **ArrayList...
Java中为何要使用ArrayList
09-07
在Java编程中，ArrayList是一个常用的集合类，它是Java标准库`java.util`包中的一个成员，主要用于存储可变大小的数据集合。ArrayList的主要特点是它维护了一个动态的、基于数组的列表，允许开发者在列表的任何位置...
JAVA ArrayList详细介绍(示例)
09-04
ArrayList是Java集合框架中常用的列表实现之一，它是一个基于数组实现的动态列表。ArrayList的特点在于其容量能够随着元素数量的增长而自动扩展。下面我们将详细探讨ArrayList的各个方面。 1. **ArrayList的特性** ...
C#中ArrayList的使用方法
09-04
ArrayList是.NET Framework中System.Collections命名空间的一个类，它是基于对象的动态数组，允许开发者存储任意类型的数据，并在需要时自动调整大小。ArrayList提供了一种灵活的方式来管理数据集合，支持多种添加、...
ArrayList的使用详解
2201_75452232的博客
02-27 1868
ArrayList的使用场景
Java基础——ArrayList方法全解(字典版)
m0_60028455的博客
07-30 885
工具与资源中心 帮助开发者更加高效的工作，提供围绕开发者全生命周期的工具与资源 https://developer.aliyun.com/tool?spm=a1z389.11499242.0.0.65452413QrIAeR&utm_content=g_1000283979 引言 在使用集合ArrayList的时候,经常使用add、remove等,其他的没用过,甚至没听说过的还有很多.现在在这个教程中,简单的了解一下,不要求全都记下.相当于在你脑袋里建一个索引,就是有些方法在用到...
Java常用集合之ArrayList（深入源码）
m0_62609939的博客
03-18 1628
Java常用集合之ArrayList（深入源码）
Arraylist
05-25
ArrayList是Java中的一个容器类，它可以动态地存储对象。与普通数组相比，ArrayList可以自动扩容，并且提供了一些常用的方法，如添加元素、删除元素、获取元素、遍历等。下面是一些常用的方法： 1. add(Object obj): 向ArrayList中添加一个元素。 2. remove(int index): 移除ArrayList中指定位置的元素。 3. get(int index): 返回ArrayList中指定位置的元素。 4. size(): 返回ArrayList中元素的个数。 5. clear(): 移除ArrayList中的所有元素。 6. contains(Object obj): 判断ArrayList是否包含指定元素。 7. indexOf(Object obj): 返回指定元素在ArrayList中第一次出现的位置。 使用ArrayList时，需要先创建一个ArrayList对象，并指定存储的元素类型。例如，创建一个存储字符串的ArrayList对象可以这样写： ```java ArrayList<String> list = new ArrayList<String>(); ``` 接下来，就可以使用上述方法向ArrayList中添加元素、移除元素等操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

HackerTerry

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

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

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

打赏作者

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

抵扣说明：

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

余额充值