Java 集合框架 - Java ArrayList - 《Java》

ArrayList 方法
ArrayList增删改查
List 与 Set 相互转化
其他的引用类型
ArrayList 排序
遍历 ArrayList
模拟斗地主洗牌发牌
Java中Collections.sort()排序详解
- 第一种：Comparable 排序接口
- 第二种：Comparator比较器接口
Collections.addAll()与ArrayList.addAll()的区别
数组、集合、列表常用方法
拓展：自己实现一个动态数组

java.util.ArrayList 集合数据存储的结构是数组结构 ArrayList对元素的增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合 ArrayList 类是可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。 ArrayList 继承了 AbstractList ，并实现了 List 接口

ArrayList 类位于 java.util 包中，使用前需要引入它，语法格式如下：

import java.util.ArrayList;  // 引入 ArrayList 类
ArrayList<E> objectName =new ArrayList<>();　 // 初始化

E: 泛型数据类型，用于设置 objectName 的数据类型，只能为引用数据类型
objectName: 对象名

ArrayList 方法

Java ArrayList 常用方法列表如下：

方法	描述
add()	将元素插入到指定位置的 arraylist 中
addAll()	添加集合中的所有元素到 arraylist 中
clear()	删除 arraylist 中的所有元素
clone()	复制一份 arraylist
contains()	判断元素是否在 arraylist
get()	通过索引值获取 arraylist 中的元素
indexOf()	返回 arraylist 中元素的索引值
removeAll()	删除存在于指定集合中的 arraylist 里的所有元素
remove()	删除 arraylist 里的单个元素
size()	返回 arraylist 里元素数量
isEmpty()	判断 arraylist 是否为空
subList()	截取部分 arraylist 的元素
set()	替换 arraylist 中指定索引的元素
sort()	对 arraylist 元素进行排序
toArray()	将 arraylist 转换为数组
toString()	将 arraylist 转换为字符串
ensureCapacity()	设置指定容量大小的 arraylist
lastIndexOf()	返回指定元素在 arraylist 中最后一次出现的位置
retainAll()	保留 arraylist 中在指定集合中也存在的那些元素
containsAll()	查看 arraylist 是否包含指定集合中的所有元素
trimToSize()	将 arraylist 中的容量调整为数组中的元素个数
removeRange()	删除 arraylist 中指定索引之间存在的元素
replaceAll()	将给定的操作内容替换掉数组中每一个元素
removeIf()	删除所有满足特定条件的 arraylist 元素
forEach()	遍历 arraylist 中每一个元素并执行特定操作

ArrayList增删改查

ArrayList 是一个数组队列，提供了相关的添加、删除、修改、遍历等功能

添加元素

ArrayList 类提供了很多有用的方法，添加元素到 ArrayList 可以使用 add() 方法:

import java.util.ArrayList;
public class Test {
  public static void main(final String[] args) {
    final ArrayList<String> sites = new ArrayList<String>();
    sites.add("Apple");
    sites.add("Google");
    sites.add("Microsoft");
    System.out.println(sites);
    sites.add(0, "Intel");
    sites.add(3, "Microsoft");
    sites.set(4, "America");
    System.out.println(sites);
  }
}
// [Apple,Google,Microsoft]
// [Intel, Apple, Google, Microsoft, America]

访问元素

访问 ArrayList 中的元素可以使用 get() 方法：

import java.util.ArrayList;
public class Test {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Apple");
        sites.add("Google");
        sites.add("Microsoft");
        System.out.println(sites.get(1)); // 访问第二个元素 Google
    }
}

修改元素

如果要修改 ArrayList 中的元素可以使用 set() 方法：

import java.util.ArrayList;
public class Test {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Apple");
        sites.add("Google");
        sites.add("Microsoft");
        sites.set(2, "Intel"); // 第一个参数为索引位置，第二个为要修改的值
        System.out.println(sites);
    }
}

删除元素

如果要删除 ArrayList 中的元素可以使用 remove() 方法：

import java.util.ArrayList;
public class RunoobTest {
  public static void main(String[] args) {
    ArrayList<String> sites = new ArrayList<String>();
    sites.add("Apple");
    sites.add("Google");
    sites.add("Microsoft");
    sites.add("Taobao");
    sites.remove(3); // 删除第四个元素
    sites.remove("Microsoft"); // 删除第四个元素
    System.out.println(sites); // [Apple, Google]
  }
}

计算大小

如果要计算 ArrayList 中的元素数量可以使用 size() 方法：

import java.util.ArrayList;
public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Apple");
        sites.add("Google");
        sites.add("Microsoft");
        System.out.println(sites.size()); // 3
    }
}

迭代数组列表

我们可以使用 for 来迭代数组列表中的元素：

import java.util.ArrayList;
public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Apple");
        sites.add("Google");
        sites.add("Microsoft");
        for (int i = 0; i < sites.size(); i++) {
            System.out.println(sites.get(i));
        }
        for (String string : sites) {
            System.out.println(string);
        }
    }
}

List 与 Set 相互转化

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class Test {
  public static void main(final String[] args) {
    final ArrayList<String> sites = new ArrayList<String>();
    sites.add("Apple");
    sites.add("Google");
    sites.add("Microsoft");
    sites.add("Apple");
    System.out.println(sites); // [Apple, Google, Microsoft, Apple]
    // List转Set
    final Set<String> tmpSet = new HashSet<String>(sites);
    System.out.println(tmpSet); // [Google, Apple, Microsoft]
    // Set转List
    final List<String> tmpList = new ArrayList<>(tmpSet);
    System.out.println(tmpList); // [Google, Apple, Microsoft]
    tmpList.add("Google");
    System.out.println(tmpList); // [Google, Apple, Microsoft, Google]
  }
}

其他的引用类型

ArrayList 中的元素实际上是对象，在以上实例中，数组列表元素都是字符串 String 类型。
如果我们要存储其他类型，而只能为引用数据类型，这时我们就需要使用到基本类型的包装类。
基本类型对应的包装类表如下：

boolean	Boolean
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character

此外，BigInteger、BigDecimal 用于高精度的运算，BigInteger 支持任意精度的整数，也是引用类型，但它们没有相对应的基本类型

import java.util.ArrayList;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<Integer> myNumbers = new ArrayList<Integer>();
        myNumbers.add(1);
        myNumbers.add(2);
        myNumbers.add(3);
        myNumbers.add(4);
        for (int i : myNumbers) {
            System.out.println(i);
        }
    }
}

/* 
1
2
3
4 
*/

ArrayList 排序

Collections 类也是一个非常有用的类，位于 java.util 包中，提供的 sort() 方法可以对字符或数字列表进行排序。
以下实例对字母进行排序：

import java.util.ArrayList;
import java.util.Collections; // 引入 Collections 类

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Apple");
        sites.add("Microsoft");
        Collections.sort(sites); // 字母排序
        for (String i : sites) {
            System.out.println(i);
        }
    }
}

/* 
Apple
Google
Microsoft 
*/

以下实例对数字进行排序：

import java.util.ArrayList;
import java.util.Collections; // 引入 Collections 类

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<Integer> myNumbers = new ArrayList<Integer>();
        myNumbers.add(4);
        myNumbers.add(2);
        myNumbers.add(6);
        myNumbers.add(1);
        myNumbers.add(5);
        myNumbers.add(3);

        Collections.sort(myNumbers); // 数字排序

        for (int i : myNumbers) { System.out.println(i); }
    }
}

// 1 2 3 4 5 6

遍历 ArrayList

import java.util.*;

public class Test {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("Hello");
        list.add("World");
        list.add("Ken");
        // 第一种遍历，把链表变为数组相关的内容进行遍历
        String[] strArray = new String[list.size()];
        list.toArray(strArray);
        for (int i = 0; i < strArray.length; i++) // 这里也可以改写为 for(String str:strArray) 这种形式
        {
            System.out.println(strArray[i]);
        }

        // 第二种遍历方法使用 For-Each 遍历 List
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        for (String str : list) {
            System.out.println(str);
        }

        // 第三种遍历 使用迭代器进行相关遍历
        Iterator<String> ite = list.iterator();
        while (ite.hasNext())// 判断下一个元素之后有值
        {
            System.out.println(ite.next());
        }
    }
}

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

public class TestArrayList {
    public static void main(String[] args) {
        System.out.println(generateArrayList().toString());
        ArrayList<Integer> evenNumList = generateArrayList();
        long startTime = System.currentTimeMillis();
        run(evenNumList);
        long endTime = System.currentTimeMillis();
        System.out.println(endTime - startTime +"毫秒");
    }

    public static void run(ArrayList<Integer> evenNumList) {
        for (Integer even : evenNumList) {
            System.out.println(even);
        }
    }

    public static ArrayList<Integer> generateArrayList() {
        ArrayList<Integer> list = new ArrayList<Integer>();
        Random r = new Random();
        for (int i = 0; i < 100000; i++) {
            Integer evenNum = r.nextInt(1000);
            if (evenNum % 2 == 0) {
                list.add(evenNum);
            }
        }
        return list;
    }

};

模拟斗地主洗牌发牌

import java.util.ArrayList;
import java.util.Collections;

public class Poker {
  public static void main(String[] args) {
    /*
     * 1: 准备牌操作
     */
    // 1.1 创建牌盒 将来存储牌面的
    ArrayList<String> pokerBox = new ArrayList<String>();
    // 1.2 创建花色集合
    ArrayList<String> colors = new ArrayList<String>();
    // 1.3 创建数字集合
    ArrayList<String> numbers = new ArrayList<String>();
    // 1.4 分别给花色 以及 数字集合添加元素
    colors.add("♥");
    colors.add("♦");
    colors.add("♠");
    colors.add("♣");
    for (int i = 2; i <= 10; i++) {
      numbers.add(i + "");
    }
    numbers.add("J");
    numbers.add("Q");
    numbers.add("K");
    numbers.add("A");
    // 1.5 创造牌 拼接牌操作
    // 拿出每一个花色 然后跟每一个数字 进行结合 存储到牌盒中
    for (String color : colors) {
      // color每一个花色
      // 遍历数字集合
      for (String number : numbers) {
        // 结合
        String card = color + number;
        // 存储到牌盒中
        pokerBox.add(card);
      }
    }
    // 1.6大王小王
    pokerBox.add("小☺");
    pokerBox.add("大☠");
    // System.out.println(pokerBox);
    // 洗牌 是不是就是将 牌盒中 牌的索引打乱
    // Collections类 工具类 都是 静态方法
    // shuffer方法
    /*
     * static void shuffle(List<?> list) 使用默认随机源对指定列表进行置换。
     */
    // 2:洗牌
    Collections.shuffle(pokerBox);
    System.out.println(pokerBox.toString());
    // 3 发牌
    // 3.1 创建 三个 玩家集合 创建一个底牌集合
    ArrayList<String> player1 = new ArrayList<String>();
    ArrayList<String> player2 = new ArrayList<String>();
    ArrayList<String> player3 = new ArrayList<String>();
    ArrayList<String> dipai = new ArrayList<String>();
    // 遍历 牌盒 必须知道索引
    for (int i = 0; i < pokerBox.size(); i++) {
      // 获取 牌面
      String card = pokerBox.get(i);
      // 留出三张底牌 存到 底牌集合中
      if (i >= 51) {// 存到底牌集合中
        dipai.add(card);
      } else {
        // 玩家1 %3 ==0
        if (i % 3 == 0) {
          player1.add(card);
        } else if (i % 3 == 1) {// 玩家2
          player2.add(card);
        } else {// 玩家3
          player3.add(card);
        }
      }
    }
    // 看看
    System.out.println("令狐冲：" + player1);
    System.out.println("田伯光：" + player2);
    System.out.println("绿竹翁：" + player3);
    System.out.println("底牌：" + dipai);
  }
}

Java中Collections.sort()排序详解

第一种：Comparable 排序接口

package com.test;

import java.util.*;

class SortA implements Comparable<SortA> {

  private String name;
  private Integer order;

  public String getName() {
    return name;
  }

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

  public Integer getOrder() {
    return order;
  }

  public void setOrder(Integer order) {
    this.order = order;
  }

  @Override
  public String toString() {
    return "{name:" + name + "," + "order:" + order + "}";
  }

  @Override
  public int compareTo(SortA a) {
    // return a.getOrder()-this.order; //升序
    // return this.order-a.getOrder(); //倒序

    return this.order.compareTo(a.getOrder());//升序
    // return a.getOrder().compareTo(this.order);// 倒序
  }

}

public class SortTest {

  public static void main(String[] args) {
    // 添加字符示例：
    List<String> aList = new ArrayList<String>();
    aList.add("5");
    aList.add("2");
    aList.add("0");
    // aLists中的对象Strin 本身含有compareTo方法，所以可以直接调用sort方法，按自然顺序排序，即升序排序
    Collections.sort(aList);

    // 添加对象示例：
    List<SortA> bList = new ArrayList<SortA>();
    SortA a1 = new SortA();
    a1.setName("a");
    a1.setOrder(2);

    SortA a2 = new SortA();
    a2.setName("b");
    a2.setOrder(0);

    SortA a3 = new SortA();
    a3.setName("c");
    a3.setOrder(5);

    bList.add(a1);
    bList.add(a2);
    bList.add(a3);
    // list中的对象A实现Comparable接口
    Collections.sort(bList);

    System.out.println(aList);
    System.out.println(bList);

  }
}

/* 
[0, 2, 5]
[{name:b,order:0}, {name:a,order:2}, {name:c,order:5}] 
*/

第二种：Comparator比较器接口

import java.util.*;

public class SortTest extends Object {
  public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<String>();
    list.add("beijing");
    list.add("shanghai");
    list.add("hangzhou");

    Collections.sort(list, new Comparator<String>() {
      @Override
      public int compare(String a, String b) {
        System.out.println(a.charAt(0) + ":" + b.charAt(0));
        return a.charAt(0) - b.charAt(0);
        // return a.compareTo(b); // 排序方法 按照第一个单词的降序
      }
    });
    System.out.println(list); // [beijing, hangzhou, shanghai]
  }
}

import java.util.*;

class SortA {

  private String name;
  private Integer order;

  public String getName() {
    return name;
  }

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

  public Integer getOrder() {
    return order;
  }

  public void setOrder(Integer order) {
    this.order = order;
  }

  @Override
  public String toString() {
    return "{name:" + name + "," + "order:" + order + "}";
  }

}

public class SortTest {

  public static void main(String[] args) {
    // 第一种方法示例：
    List<String> aList = new ArrayList<String>();
    aList.add("5");
    aList.add("0");
    aList.add("2");
    // aList中的对象String本身含有compareTo方法，所以可以直接调用sort方法，按自然顺序排序，即升序排序
    Collections.sort(aList);

    // 第一种方法示例：
    List<SortA> bList = new ArrayList<SortA>();
    SortA a1 = new SortA();
    a1.setName("a");
    a1.setOrder(2);
    SortA a2 = new SortA();
    a2.setName("b");
    a2.setOrder(0);
    SortA a3 = new SortA();
    a3.setName("c");
    a3.setOrder(5);
    bList.add(a1);
    bList.add(a2);
    bList.add(a3);

    // list中的对象A实现Comparable接口
    // Collections.sort(aList);
    Collections.sort(bList, new Comparator<SortA>() {
      public int compare(SortA s1, SortA s2) {
        // 升序排:第一个参数.compareTo(第二个参数);
        // 降序排:第二个参数.compareTo(第一个参数);
        return s2.getOrder().compareTo(s1.getOrder());
      }

    });

    System.out.println(aList); // [0, 2, 5]
    System.out.println(bList); // [{name:c,order:5}, {name:a,order:2}, {name:b,order:0}]
  }
}

Collections.addAll()与ArrayList.addAll()的区别

我们在编码时经常需要将一些元素添加到一个List中，此时我们一般有两种选择：Collections.addAll()或者是ArrayList.addAll()。
1. 在需添加元素比较少的情况下，并在List的size在万级以上时，一般建议Collections.addAll()，但当List的size较小时，两种方法没有什么区别，甚至ArrayList.addAll()更好。
2. 当我们将一个数组添加到一个List中时，Collections.addAll()和ArrayList.addAll()没有什么性能差异，但当我们将一个List添加到一个List中时，建议使用ArrayList.addAll()。
3. 添加数组和列表，要比添加元素快。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class CollectionsTest {

    public static void main(String[] args) {

        List<Integer> list1 = new ArrayList<Integer>() {
            {
                add(0);
                add(-1);
            }
        };
        List<Integer> list2 = new ArrayList<Integer>(Arrays.asList(2, 4, -9));

        list1.addAll(list2);
        System.out.println(list1);
        list2.set(0, 100000); // 改变list2中的元素
        System.out.printf("%s\n", list1); // 深复制

        // 功能性展示
        Collections.addAll(list2, 34, 67, 78);
        System.out.printf("%s\n", list2);
        list2.addAll(Arrays.asList(34, 67, 78));
        System.out.printf("%s\n", list2);

        // 性能展示
        System.out.println("添加元素---------------------------\n");
        for (int size = 1000; size < 100000000; size *= 10) {
            long time = System.nanoTime();
            List<Integer> list3 = new ArrayList<Integer>();
            for (int i = 0; i < size; i++) {
                list3.addAll(Arrays.asList(1, 45, 34, 456, 1212, -6, 43, 55));
            }
            System.out.println("ArrayList.addAll()@size = " + size + "\ntime:" + (System.nanoTime() - time));

            time = System.nanoTime();
            List<Integer> list4 = new ArrayList<Integer>();
            for (int i = 0; i < size; i++) {
                Collections.addAll(list4, 1, 45, 34, 456, 1212, -6, 43, 55);
            }
            System.out.println("Collections.addAll()@size = " + size + "\ntime:" + (System.nanoTime() - time) + "\n");
        }
        System.gc();


        System.out.println("添加数组---------------------------\n");
        Integer[] arr = { 1, 45, 34, 456, 1212, -6, 43, 55 };
        for (int size = 1000; size < 100000000; size *= 10) {
            long time = System.nanoTime();
            List<Integer> list3 = new ArrayList<Integer>();
            for (int i = 0; i < size; i++) {
                list3.addAll(Arrays.asList(arr));
            }
            System.out.println("ArrayList.addAll()@size = " + size + "\ntime:" + (System.nanoTime() - time));

            time = System.nanoTime();
            List<Integer> list4 = new ArrayList<Integer>();
            for (int i = 0; i < size; i++) {
                Collections.addAll(list4, arr);
            }
            System.out.println("Collections.addAll()@size = " + size + "\ntime:" + (System.nanoTime() - time) + "\n");
        }
        System.gc();


        System.out.println("添加列表---------------------------\n");
        ArrayList<Integer> list = new ArrayList<Integer>(Arrays.asList(1, 45, 34, 456, 1212, -6, 43, 55));
        for (int size = 1000; size < 100000000; size *= 10) {
            long time = System.nanoTime();
            List<Integer> list3 = new ArrayList<Integer>();
            for (int i = 0; i < size; i++) {
                list3.addAll(list);
            }
            System.out.println("ArrayList.addAll()@size = " + size + "\ntime:" + (System.nanoTime() - time));

            time = System.nanoTime();
            List<Integer> list4 = new ArrayList<Integer>();
            for (int i = 0; i < size; i++) {
                Collections.addAll(list4, list.toArray(new Integer[0]));
            }
            System.out.println("Collections.addAll()@size = " + size + "\ntime:" + (System.nanoTime() - time) + "\n");
        }
    }
}

数组、集合、列表常用方法

//将集合中元素按照默认规则排序
java.util.Collections.sort(List<Integer> list) 

//将集合中元素按照指定规则排序
java.util.Collections
public static <T> void sort(List<T> list，Comparator<? super T> )

//打乱顺序
java.util.Collections.shuffle(List<?> list)

//往集合中添加一些元素
java.util.Collections.addAll(Collection<? super String> c, String... elements)

//列表添加元素
java.util.ArrayList.addAll(Collection c)

//将数组、游离的元素组转为集合
<Integer> List<Integer> java.util.Arrays.asList(Integer... a)

//将列表转为数组
Object[] java.util.List.toArray()

//将数组转为字符(列表结构)输出
String java.util.Arrays.toString(Object[] a)

import java.util.*;

public class SortTest {

  public static void main(String[] args) {
    // 数组转列表(asList()可用于将数组、游离的元素组转为集合)
    Integer[] array = new Integer[] { 1, 2, 3, 4, 5 };
    List<Integer> arrayToList = Arrays.asList(array);
    System.out.println(arrayToList);

    //列表转数组
    Object[] listToArray = arrayToList.toArray();
    System.out.println(listToArray.toString());
    System.out.println(Arrays.toString(listToArray));
  }
}

拓展：自己实现一个动态数组

先写一个实体类DynamicArray；主要包括属性有数组容量，结点数据和数组长度； ```jsx package com.java.model;

public class DynamicArray { // 动态数组最大容量 public final static int capacity = 100;

// 顺序表的结点数据 public int[] data; // 顺序表的长度，用来标识数组中的元素个数 public int size;

// 构造函数 public DynamicArray(int[] data, int size) { this.data = data; this.size = size; } }


2. 再写数组方法类DynamicArrayDao；主要包括数组的各种操作方法，插入、查找等；
```jsx
package com.java.dao;

import com.java.model.DynamicArray;
import static com.java.model.DynamicArray.capacity;

public class DynamicArrayDao {

  // 初始化数组
  public DynamicArray Init_Array() {
    // 数组数据域初始化
    int[] data1 = new int[capacity];

    // DynamicArray初始化
    DynamicArray myArray = new DynamicArray(data1, 0);

    // 数组赋值
    for (int i = 0; i < capacity; i++) {
      myArray.data[i] = 0;
    }
    return myArray;
  }

  // 插入指定值
  public void PushBack_Array(DynamicArray array, int value) {
    if (array == null) {
      return;
    }
    // 如果线性表容量小于或等于数组容量
    if (array.size == capacity) {
      return;
    }
    // 插入元素
    array.data[array.size] = value;
    array.size++;
  }

  // 根据位置删除
  public void RemoveByPos_Array(DynamicArray array, int pos) {
    if (array == null) {
      return;
    }
    // 判断位置是否有效
    if (pos < 0 || pos >= array.size) {
      return;
    }
    // 删除元素
    for (int i = pos; i < array.size - 1; i++) {
      array.data[i] = array.data[i + 1];
    }
    array.size--;
  }

  // 查找元素,返回该值第一次出现时对应的下标位置
  public int Find_Array(DynamicArray array, int value) {
    if (array == null) {
      return -1;
    }
    // 找到该值第一次出现的位置，-1表示没有找到；
    int pos = -1;
    for (int i = 0; i < array.size; i++) {
      if (array.data[i] == value) {
        pos = i;
        break;
      }
    }
    return pos;
  }

  // 根据位置查找到某个元素
  public int At_Array(DynamicArray array, int pos) {
    if (array == null) {
      return -1;
    }
    return array.data[pos];
  }

  // 根据值删除
  public void RemoveByValue_Array(DynamicArray array, int value) {
    if (array == null) {
      return;
    }
    // 首先找到该值对应的数组下标
    int pos = Find_Array(array, value);
    // 调用根据位置删除的方法
    RemoveByPos_Array(array, pos);
  }

  // 打印
  public void Print_Array(DynamicArray array) {
    if (array == null) {
      return;
    }
    for (int i = 0; i < array.size; i++) {
      System.out.print(array.data[i] + ",");
    }
  }

  // 清空数组
  public void Clear_Array(DynamicArray array) {
    if (array == null) {
      return;
    }
    for (int i = 0; i < array.size; i++) {
      array.data[i] = 0;
    }
    array.size = 0;
  }

  // 获得动态数组当前元素个数
  public int Size_Array(DynamicArray array) {
    if (array == null) {
      return -1;
    }
    return array.size;
  }
}

主函数Main；包括测试各种函数等； ```jsx package com.java.main;

import com.java.dao.DynamicArrayDao; import com.java.model.DynamicArray; import static com.java.model.DynamicArray.capacity;

public class DynamicArrayMain { public static void main(String[] args) { DynamicArrayDao dynamicArrayDao = new DynamicArrayDao(); // 初始化动态数组 DynamicArray myArray = dynamicArrayDao.Init_Array(); System.out.println(“初始化动态数组:”); // 获取容量 System.out.println(“数组容量:” + capacity); System.out.println(“数组实际大小:” + dynamicArrayDao.Size_Array(myArray)); // 插入元素 for (int i = 0; i < 10; i++) { dynamicArrayDao.PushBack_Array(myArray, i); } System.out.println();

System.out.println("插入元素之后:");
// 获取容量
System.out.println("数组容量:" + capacity);
System.out.println("数组实际大小:" + dynamicArrayDao.Size_Array(myArray));
System.out.println();

// 打印插入元素
System.out.println("打印插入的元素:");
dynamicArrayDao.Print_Array(myArray);
System.out.println();

// 根据元素位置删除元素
dynamicArrayDao.RemoveByPos_Array(myArray, 2);
// 根据元素值删除元素
dynamicArrayDao.RemoveByValue_Array(myArray, 7);
System.out.println();

// 打印删除后的数组
System.out.println("打印删除后的元素:");
dynamicArrayDao.Print_Array(myArray);
System.out.println();

// 查找元素为5的位置
System.out.println();
System.out.print("元素5的位置为: ");
int pos = dynamicArrayDao.Find_Array(myArray, 5);
System.out.println(pos);

// 查找位置为7的元素值
System.out.println();
System.out.print("位置为7的元素为: ");
int value = dynamicArrayDao.At_Array(myArray, 7);
System.out.println(value);

// 获取容量
System.out.println();
System.out.println("此时的数组容量:" + capacity);
System.out.println("此时的数组实际大小:" + dynamicArrayDao.Size_Array(myArray));
System.out.println();

} } ```