Java代码实现动态数组ArrayList

最新推荐文章于 2024-06-12 14:33:24 发布
最新推荐文章于 2024-06-12 14:33:24 发布
阅读量358 收藏 1
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46379561/article/details/118824234
版权

ArrayList简介

ArrayList是Java集合框架中的一个重要的类，它继承于AbstractList，实现了List接口，是一个长度可变的集合，提供了增删改查的功能。集合中允许null的存在。ArrayList类还是实现了RandomAccess接口，可以对元素进行快速访问。ArrayList有如下特点：

  • 底层结构是动态数组
  • 线程不同步
  • 更擅长做随机访问（遍历）
  • 添加和删除元素速度比LinkedList慢

定义接口List

List是线性结构的接口，里面定义了该线性结构的一些通用操作并支持泛型。List接口继承自Iterable（可迭代接口），主要用于遍历数据结构，其次让我们的类可以使用for-each循环。
其中包含的方法和List接口完整代码如下：

public interface List<E> extends Iterable<E> {
    /**
     *在线性结构的末尾添加指定元素element
     */
    public void add(E element);

    /**
     * 在线性结构中指定下标index处添加元素element
     */
    public void add(int index,E element);

    /**
     * 在线性结构中删除指定元素element
     */
    public void remove(E element);

    /**
     * 在线性结构中删除指定下标index处的元素并返回
     */
    public E remove(int index);

    /**
     * 在线性结构中获取指定下标index处的元素
     */
    public E get(int index);

    /**
     * 修改指定下标处index元素为新元素element
     */
    public E set(int index,E element);

    /**
     * 获取有效元素个数
     */
    public int size();

    /**
     * 获取指定元素element在线性结构中的下标
     */
    public int indexOf(E element);

    /**
     * 查看线性表中是否包含指定元素element
     */
    public boolean contains(E element);

    /**
     * 查看线性结构是否为空
     */
    public boolean isEmpty();

    /**
     * 清空线性结构
     */
    public void clear();

    /**
     * 对线性结构按照比较器Comparator的定义进行排序（E类型不能直接用大于、于号直接比较）
     */
    public void sort(Comparator<E> comparator);

    /**
     * 获取线性结构中从指定fromIndex下标开始到toIndex下标结尾的所有元素
     * （size > toIndex > fromIndex >= 0）
     */
    public List<E> sublist(int fromIndex,int toIndex);

}

ArrayList类的创建

创建ArrayList类，实现我们刚刚编写好的List接口，类里面有3个属性：

  • data[]：存储元素的容器
  • size：有效元素的个数
  • DEFAULT_CAPACITY：默认容量大小，设置为10

构造方法有三个，第一个为无参数，即直接创建一个默认长度的ArrayList；第二个为带一个参数，用于创建一个指定长度的ArrayList；第三个为将一个数组封装为线性表，参数是数组。

  • 传入指定长度时需要判断参数的合法性，不合法则抛出异常
  • 传入指定数组时需要判断数组是否为空，为空则抛出异常
  • 第三个构造方法使用的add()方法即是本ArrayList要实现的添加元素的方法，在后面会实现

代码如下：

public class ArrayList<E> implements List<E> {

    //存储元素的容器
    private E[] data;
    //元素的有效个数
    private int size;
    //默认容量大小
    private static int DEFAULT_CAPACITY = 10;

    /**
     * 创建一个默认容量为10的线性表
     */
    public ArrayList(){
        this(DEFAULT_CAPACITY);
    }

    /**
     * 创建一个指定容量为capacity的线性表
     */
    public ArrayList(int capacity){
        if(capacity <= 0){
            throw new IllegalArgumentException("容量必须大于等于0");
        }
        data = (E[]) new Object[capacity];
        size = 0;
    }

    /**
     * 将一个现有数组封装成线性表
     */
    public ArrayList(E[] arr){
        if(arr == null){
            throw new IllegalArgumentException("数组不能为空");
        }
        data = (E[]) new Object[arr.length];
        size = 0;
        for(E e : arr){         //e是arr[i]
            add(e);             //把每个元素添加到线性表的末尾
        }
    }
}

数组的扩容

在实现其他方法前，先编写扩容函数。每当向数组中添加元素时，都要去检查添加后元素的个数是否会超出当前数组的长度，如果超出，数组将会进行扩容，以满足添加数据的需求；
如果数组元素大大小于数组长度时，同样可以使用此函数对数组进行缩容操作。

  1. 函数内定义一个新数组newData，长度为参数newLength。
  2. 将原数组data内的所有元素转移到newData中。

代码如下：

private void resize(int newLength) {
        E[] newData = (E[]) new Object[newLength];
        for(int i = 0;i < size;i++){
            newData[i] = data[i];
        }
        data = newData;
    }

添加元素

add()方法用于向ArrayList中添加元素，有带一个参数和带两个参数的形式。

  1. 判断表是否已满，如果满则调用扩容函数进行扩容。
  2. 添加元素时，将待添加位置之后的元素整体后移一个位置，将数据进行插入。
  3. size自增1。

代码如下：

  	@Override
    public void add(E element){
        add(size,element);
    }

    @Override
    public void add(int index,E element){
        if(index < 0 || index > size){          //判断传入index的正确性
            throw new IllegalArgumentException("index范围错误");
        }
        //判断是否满
        if(size == data.length){
            //如果表满则扩容
            resize(data.length * 2);
        }
        for(int i = size;i >index;i--){
            data[i] = data[i - 1];
        }
        data[index] = element;
        size++;
    }

删除元素

remove()方法用于向ArrayList中添加元素，有参数为元素和参数为下标的形式。

  1. 判断传入下标是否合法。
  2. 使用变量接取待删除的值。
  3. 删除元素时，将待添加位置之后的元素整体前移一个位置，将数据进行覆盖删除。
  4. 判断当前表内数据是否小于表容量的四分之一，如果小于则使用扩容函数进行缩容操作。
  5. 返回被删除的值。

代码如下：

	@Override
    public void remove(E element){
        int index = 0;
        while((index = indexOf(element)) != -1) {             //只要包含
            remove(index);
        }
    }

    @Override
    public E remove(int index){
        if(index < 0 || index >= size) {
            throw new IllegalArgumentException("index范围错误");
        }
        E ret = data[index];
        for(int i = index;i <= size - 2;i++){
            data[i] = data[i + 1];
        }
        size--;
        if(size == data.length / 4 && data.length > DEFAULT_CAPACITY) {  //如果有效数据长度等于data数组的四分之一，且数组长度大于默认容量，则可缩容
            resize(data.length / 2);
        }
        return ret;
    }

获取指定元素的下标

indexOf()方法用于获取指定元素element在线性结构中的下标。

  1. 使用循环对比表内元素和传入参数是否相等，相等则返回下标，否则返回-1。
  2. 因为数据类型为泛型，所以使用equals进行数据的对比。

代码如下：

	@Override
	public int indexOf(E element){
        for(int i = 0;i < size;i++){
            if(data[i].equals(element)){
                return i;
            }
        }
        return -1;
    }

查看表中是否包含元素

contains()方法用于查看线性表中是否包含指定元素element。

  1. 直接调用返回indexOf方法的值即可。

代码如下：

	@Override
    public boolean contains(E element){
        return indexOf(element) != -1;
    }

获取指定下标的元素

get()方法用于获取线性结构中指定下标的元素。

  1. 判断传入下标是否合法。
  2. 返回指定下标处的值。

代码如下：

 	@Override
    public E get(int index){
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("index范围错误");
        }
        return data[index];
    }

修改指定下标的元素的值

set()方法用于修改指定下标处index元素为新元素element。

  1. 判断传入下标是否合法。
  2. 使用变量接取修改前的值。
  3. 修改index处的数据。
  4. 返回修改前的值。

代码如下：

	@Override
    public E set(int index,E element){
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("index范围错误");
        }
        E ret = data[index];
        data[index] = element;
        return ret;
    }

判断表是否为空

isEmpty()用于判断表是否为空。

  1. 直接返回size是否等于0。

代码如下：

	@Override
    public boolean isEmpty(){
        return size == 0;
    }

获取表内元素个数

size()用于获取有效元素个数。

  1. 直接返回size的值。

代码如下：

	@Override
    public int size(){
        return size;
    }

清空全表

clear()用于清空整个表。

  1. 将data声明为一个新数组，长度为默认值。
  2. 将数据数size置为0。

代码如下：

	@Override
    public void clear(){
        data = (E[]) new Object[DEFAULT_CAPACITY];
        size = 0;
    }

数据排序

sort()用于对表内数据的排序。因为我们使用的是泛型，所以<、>等运算符均无法用来比较数据大小，这时候就要使用比较器Comparator。其中compare()方法用来比较两个参数，返回负数表示第一个比第二个小，返回正数表示第一个参数比第二个大。排序过程使用插入排序。

  1. 判断传入的比较器对象是否为空，为空则抛出异常。
  2. 使用compare()方法进行插入排序。

代码如下：

	@Override
    public void sort(Comparator<E> comparator){
        if(comparator == null){
            throw new IllegalArgumentException("比较器不能为空");
        }
        //插入排序 O(n^2)
        for(int i = 1;i < size;i++){
            E e = data[i];
            int j;
            for(j = i;j > 0 && comparator.compare(data[j - 1],e) > 0;j--){  //比较两个参数，返回负数表示第一个比第二个小，返回正数表示第一个参数比第二个大
                data[j] = data[j - 1];
            }
            data[j] = e;
        }
    }

获取一个区间内的表元素

sublist()方法用于获取线性结构中从指定fromIndex下标开始到toIndex下标结尾的所有元素。我们使用本ArrayList来存放获取到的元素，所以此方法的返回类型是一个List。

  1. 判断索引是否合法。区间为 size > toIndex > fromIndex >= 0。
  2. 创建新的ArrayList对象list。
  3. 循环，将fromIndex到toIndex区间内的值添加进list。
  4. 返回list。

代码如下：

	@Override
    public List<E> sublist(int fromIndex,int toIndex){
        if(fromIndex < 0 || toIndex >= size || fromIndex > toIndex){
            throw new IllegalArgumentException("索引超出范围");
        }
        ArrayList<E> list = new ArrayList<>();
        for(int i = fromIndex;i < toIndex;i++){
            list.add(data[i]);
        }
        return list;
    }

重写equals方法

  1. 判断传入参数是否为空。
  2. 判断传入参数是否是自己。
  3. 判断传入对象是否为ArrayList。
  4. 将传入对象obj转换成ArrayList。
  5. 先比较两个对象长度是否相等。
  6. 最后对比数据，一致则返回true；上述一个条件不满足则直接返回false。

代码如下：

	@Override
    public boolean equals(Object obj){
        if(obj == null){
            return false;                                       //先判空
        }
        if(obj == this){
            return true;                                        //判断是否是自己
        }
        if(obj instanceof ArrayList){                           //判断传入对象是否为ArrayList
            ArrayList<E> other = (ArrayList<E>) obj;            //将obj强转为ArrayList
            if(this.size == other.size){                        //先比较有效长度size是否相等
                for(int i = 0;i < this.size;i++){
                    if(!this.data[i].equals(other.data[i])){     //对比数据，不一致则返回false
                        return false;
                    }
                }
                return true;
            }
            else{
                return false;
            }
        }
        else{
            return false;
        }
    }

重写toString方法

重写toString方法，使用toString方法时可以输出ArrayList，使输出数据较为美观。
其中使用StringBuilder存放数据。代码如下：

	@Override
    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append('[');                                         //使用字符的原因是减少临时字符串常量的产生 （字符串底层是字符数组）
        if(isEmpty()){
            sb.append(']');
        }
        else{
            for(int i = 0;i < size;i++){
                sb.append(data[i]);
                if(i != size - 1){
                    sb.append(',');
                }
                else{
                    sb.append(']');
                }
            }
        }
        return sb.toString();
    }

定义迭代器内部类

定义内部类ArrayListIterator实现Iterator接口并实现hasNext()和next方法，代码如下：

	/**
     * 迭代器内部类
     */
    private class ArrayListIterator implements Iterator<E>{
        private int cur = 0;

        /**
         * 检查是否有下一个
         */
        @Override
        public boolean hasNext() {
            return cur < size;
        }

        /**
         * 取出cur然后向后移
         */
        @Override
        public E next() {
            return data[cur++];
        }
    }

返回迭代器对象

iterator()方法用于返回一个迭代器对象。返回类型是Iterator。

  1. 直接返回上面创建的迭代器内部类的对象。

代码如下：

	@Override
    public Iterator<E> iterator() {
        return new ArrayListIterator();
    }

ArrayList类完整代码

public class ArrayList<E> implements List<E> {

    //存储元素的容器
    private E[] data;
    //元素的有效个数
    private int size;
    //默认容量大小
    private static int DEFAULT_CAPACITY = 10;

    /**
     * 创建一个默认容量为10的线性表
     */
    public ArrayList(){
        this(DEFAULT_CAPACITY);
    }

    /**
     * 创建一个指定容量为capacity的线性表
     */
    public ArrayList(int capacity){
        if(capacity <= 0){
            throw new IllegalArgumentException("容量必须大于等于0");
        }
        data = (E[]) new Object[capacity];
        size = 0;
    }

    /**
     * 将一个现有数组封装成线性表
     */
    public ArrayList(E[] arr){
        if(arr == null){
            throw new IllegalArgumentException("数组不能为空");
        }
        data = (E[]) new Object[arr.length];
        size = 0;
        for(E e : arr){         //e是arr[i]
            add(e);             //把每个元素添加到线性表的末尾
        }
    }

    @Override
    public void add(E element){
        add(size,element);
    }

    @Override
    public void add(int index,E element){
        if(index < 0 || index > size){          //判断传入index的正确性
            throw new IllegalArgumentException("index范围错误");
        }
        //判断是否满
        if(size == data.length){
            //如果表满则扩容
            resize(data.length * 2);
        }
        for(int i = size;i >index;i--){
            data[i] = data[i - 1];
        }
        data[index] = element;
        size++;
    }

    @Override
    public void remove(E element){
        int index = 0;
        while((index = indexOf(element)) != -1) {             //只要包含
            remove(index);
        }
    }

    @Override
    public E remove(int index){
        if(index < 0 || index >= size) {
            throw new IllegalArgumentException("index范围错误");
        }
        E ret = data[index];
        for(int i = index;i <= size - 2;i++){
            data[i] = data[i + 1];
        }
        size--;
        if(size == data.length / 4 && data.length > DEFAULT_CAPACITY) {  //如果有效数据长度等于data数组的四分之一，且数组长度大于默认容量，则可缩容
            resize(data.length / 2);
        }
        return ret;
    }

    @Override
    public int indexOf(E element){
        for(int i = 0;i < size;i++){
            if(data[i].equals(element)){
                return i;
            }
        }
        return -1;
    }

    @Override
    public boolean contains(E element){
        return indexOf(element) != -1;
    }

    @Override
    public E get(int index){
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("index范围错误");
        }
        return data[index];
    }

    @Override
    public E set(int index,E element){
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("index范围错误");
        }
        E ret = data[index];
        data[index] = element;
        return ret;
    }

    @Override
    public boolean isEmpty(){
        return size == 0;
    }

    @Override
    public int size(){
        return size;
    }

    @Override
    public void clear(){
        data = (E[]) new Object[DEFAULT_CAPACITY];
        size = 0;
    }

    @Override
    public void sort(Comparator<E> comparator){
        if(comparator == null){
            throw new IllegalArgumentException("比较器不能为空");
        }
        //插入排序 O(n^2)
        for(int i = 1;i < size;i++){
            E e = data[i];
            int j;
            for(j = i;j > 0 && comparator.compare(data[j - 1],e) > 0;j--){  //比较两个参数，返回负数表示第一个比第二个小，返回正数表示第一个参数比第二个大
                data[j] = data[j - 1];
            }
            data[j] = e;
        }
    }

    @Override
    public List<E> sublist(int fromIndex,int toIndex){
        if(fromIndex < 0 || toIndex >= size || fromIndex > toIndex){
            throw new IllegalArgumentException("索引超出范围");
        }
        ArrayList<E> list = new ArrayList<>();
        for(int i = fromIndex;i < toIndex;i++){
            list.add(data[i]);
        }
        return list;
    }

    /**
     * 扩容
     * 每当向数组中添加元素时，都要去检查添加后元素的个数是否会超出当前数组的长度，如果超出，数组将会进行扩容，以满足添加数据的需求。
     */
    private void resize(int newLength) {
        E[] newData = (E[]) new Object[newLength];
        for(int i = 0;i < size;i++){
            newData[i] = data[i];
        }
        data = newData;
    }

    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append('[');                                         //使用字符的原因是减少临时字符串常量的产生 （字符串底层是字符数组）
        if(isEmpty()){
            sb.append(']');
        }
        else{
            for(int i = 0;i < size;i++){
                sb.append(data[i]);
                if(i != size - 1){
                    sb.append(',');
                }
                else{
                    sb.append(']');
                }
            }
        }
        return sb.toString();
    }

    @Override
    public boolean equals(Object obj){
        if(obj == null){
            return false;                                       //先判空
        }
        if(obj == this){
            return true;                                        //判断是否是自己
        }
        if(obj instanceof ArrayList){                           //判断传入对象是否为ArrayList
            ArrayList<E> other = (ArrayList<E>) obj;            //将obj强转为ArrayList
            if(this.size == other.size){                        //先比较有效长度size是否相等
                for(int i = 0;i < this.size;i++){
                    if(!this.data[i].equals(other.data[i])){     //对比数据，不一致则返回false
                        return false;
                    }
                }
                return true;
            }
            else{
                return false;
            }
        }
        else{
            return false;
        }
    }

    /**
     * 返回迭代器对象
     */
    @Override
    public Iterator<E> iterator() {
        return new ArrayListIterator();
    }

    /**
     * 迭代器内部类
     */
    private class ArrayListIterator implements Iterator<E>{
        private int cur = 0;

        /**
         * 检查是否有下一个
         */
        @Override
        public boolean hasNext() {
            return cur < size;
        }

        /**
         * 取出cur然后向后移
         */
        @Override
        public E next() {
            return data[cur++];
        }
    }
}
怎么取名啊
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java用ArrayList实现栈
Java程序猿1只
11-16 3395
import java.util.ArrayList; /** * 使用Java的ArrayList集合构造顺序栈 * @author Administrator * 包含参数： elements 栈元素 * length 栈实际长度 * 包含方法： Stack() 构造栈 * clearStack() 清空栈 * isEmpty(
Java之ArrayList实现
qq_50692350的博客
08-10 1130
Java
Java 集合框架（List篇）
无法自律的人的博客
06-13 457
当我们需要保存一组数据时，集合框架就是非常常用的工具之一。Java语言提供了许多不同类型的集合框架。其中最常用的是List集合框架。List接口是Java集合框架中最基本的一种形式，它允许存储重复元素，并可以按照索引访问集合中的元素。List集合的实现类有和Vector等。是基于动态数组实现的List集合。动态数组指的是在数组声明时无需给出数组大小，在运行时动态扩展。ArrayList支持常见的集合操作，如。
数据结构之动态数组列表List
qq_44426152的博客
12-13 429
学习了一段时间的Java，我们对Java的基本知识有了一定的了解，今天再来聊聊数组。 Java内置数组的特点 数组的长度一旦确定则不可更改 数组只能存储同一类型的数据 数组中每个存储空间大小一致且地址连续 数组提供角标的方式访问元素 我们发现数组又有一些局限性，于是在使用时又会有一些疑惑，我们可以总结一下 Java内置数组的潜在问题 容量不够用时，怎么办？ 指定位置插入或删除元...
Java数据结构之ArrayList（如果想知道Java中有关ArrayList的知识点，那么只看这一篇就足够了！）
最新发布
秋刀鱼不做梦的编程日常
06-12 2697
Java数据结构之ArrayList（如果想知道Java中有关ArrayList的知识点，那么只看这一篇就足够了！）
Java语言----动态顺序表（ArrayList）
tq02的博客
04-28 1695
Java实现动态顺序表，以及ArrayList的讲解
Java创建List 的三种方法
热门推荐
白开水
12-29 2万+
java 基础知识
java 动态创建,如何在Java中动态创建列表？
weixin_30676635的博客
02-12 198
I'm programming in java for a class project.In my project I have airplanes, airports and passengers.The passenger destination airport is randomly created, but then I have to add it to a List with pass...
Java版C语言版简单使用静态语言实现动态数组的方法
08-29
在Java中，虽然有内置的ArrayList类可以方便地实现动态数组的功能，但有时为了性能考虑，程序员会选择自定义实现。例如，Tomcat源码中就有一个自定义的动态数组实现。这个实现的核心是通过创建新的数组并复制旧数组...
Java使用数组实现ArrayList的动态扩容的方法
08-19
ArrayList的动态扩容是通过数组实现的，在本文中，我们将通过示例代码详细介绍Java使用数组实现ArrayList的动态扩容的方法。 一、ArrayList的成员变量和方法 在实现ArrayList时，我们需要定义一些成员变量和方法。...
Java如何把数组转换为ArrayList
08-25
Java中将数组转换为ArrayList的方法 Java是一种面向对象的编程语言，广泛应用于Android应用开发、Web开发、桌面应用开发等领域。其中，数组和ArrayList是Java中两个非常重要的数据结构。数组是一种基本的数据结构，...
java实现二维数组转json的方法示例
10-19
在Java编程中，将二维数组转换为JSON格式的数据是常见的数据处理需求，特别是在处理Web服务或数据交换时。本文将详细讲解如何使用Java实现这一功能，以及涉及的相关操作技巧。 首先，我们需要理解二维数组和JSON的...
java代码-lsy数组比
07-15
在"java代码-lsy数组比"这个主题中，我们可以推测这可能是关于比较或操作Java数组的一些代码示例。让我们深入探讨一下Java中的数组以及可能涉及的概念。 1. **数组定义与声明**： 在Java中，数组的定义包括指定...
ArrayList 数组
qq_45667636的博客
06-28 598
ArrayList数组
Java-数组列表（ArrayList）
Gold_Medal的博客
05-21 5247
Java-数组列表（ArrayList） ArrayList类是一个特殊的数组--动态数组。 普通的数组是静态的，只有先确定了他的大小才能给它初始化赋值或者参与运算，而且这个大小一但初始化后是不能被修改的，所以当你刚开始不确定你要输入数据的多少时，普通的数组不容易实现（万一你输入的数据多于数组大小时，就会数组溢出，导致报错），为此java有了" 数组列表"(ArrayList)。 （小声bb：其实我感觉ArrayList，甚至是Java的整个集合类，都有与C++里的STL类...
ArrayList数组
Bernard_King的博客
09-25 2084
一直想好好介绍下ArrayList数组，今天外面下雨，不能出去浪，今天正好在家好好总结下ArrayList，Java基础面试基本会闻到集合，Collecton类，以及各个实现类的特点，今天就从源码的角度分析下ArrayList数组，后面更新面试问的最多的HashMap。 好了，废话不多说，开始......，请开始你的表演！！！！ 什么是ArrayList ArrayList就是数组列表，主要是用来装载数据，能用来装int，long，boolean，short，byte类型，我们只能存...
ArrayList与数组
weixin_42511781的博客
07-17 1127
ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。 ArrayList继承了AbstractList，并实现List接口。 数组是相同数据类型的多个数据的容器。这些元素按线性顺序排序，所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最后一个元素外，每一个元素都有唯一的后继元素。 数组在初始化确定长度后，长度不会再发生变化。
Java数据结构 - 数组与ArrayList
Jiali的博客
12-22 880
数组是在，每个单元存储相同数据类型的值。这些内存单元称之为数组的，通过数组的（或称索引）访问，下标从0开始。
Java常用语法——动态数组ArrayList
qq_51241339的博客
11-13 444
Java常用语法——动态数组ArrayList
java怎么实现动态数组
05-28
Java中可以使用ArrayList类来实现动态数组。ArrayList类提供了添加、删除、获取元素等操作，它的长度可以根据需要自动增加或减少。以下是一个简单的示例代码： ```java import java.util.ArrayList; public class ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值