本文由 发布，转载请注明出处，如有问题请联系我们！ 发布时间: 2021-07-30Java基础——ArrayList方法全解(字典版)

前言

在应用结合 ArrayList 的情况下,常常应用add、remove等,别的的未用过,乃至真不知道的也有许多.如今在这个实例教程中,简易的了解一下,不规定统统记录下来.等同于在你脑壳里建一个数据库索引,便是有一些方式 在使用的情况下,不必去重的造轮子罢了.

ArrayList 建筑结构以下

包括构造函数一共是33个方式 .

逐渐

下列根据JDK1.8版本号,下列方式 排行不区分依次

ArrayList()

能够应用new ArrayList() 建立一个 ArrayList 结合,以下:

/**
 * 1 简易的ArrayList
 */
public static ArrayList getArrayList(){
    ArrayList arrayList = new ArrayList();
    arrayList.add("张三");
    arrayList.add("里斯");
    return arrayList;
}

一些在线编辑器中会报双黄线或是浅黄情况提醒,如下图

这一必须给 ArrayList 一个种类,比如 ArrayList<String> .

ArrayList(Collection<? extends E> c)

能够放进一个结合体来复位 ArrayList,实例编码以下:

HashSet<String> temp1 = new HashSet<>();
temp1.add("张三");
temp1.add("里斯");
ArrayList<String> arrayList2 = new ArrayList<>(temp1);
arrayList2.forEach(System.out::println);

ArrayList(int initialCapacity)

结构一个具备特定原始容积的空目录,应用领域便是如果你大约了解这一结合储存的信息量,立即界定好容积,绕开结合自增室内空间破坏环境.

ArrayList<String> arrayList3 = new ArrayList<>(1000);

add() 与 add(int, E)

add()方式 是将括弧内的值提升到结合结尾.
add(int, E)是将数据信息插进的实际的字符上,下表从零开始.

ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("张三");
arrayList.add(0,"在天");
arrayList.add("里斯");
arrayList.forEach(System.out::println);

addAll(Collection<? extends E> c)

指结合中的全部原素增加到此目录的结尾;

ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("张三");
arrayList.add("李四");
arrayList.add("王二");
ArrayList<String> arrayList2 = new ArrayList<>();
arrayList2.add("大麻子");
arrayList2.add("铁哥");
arrayList.addAll(arrayList2);
System.out.println(arrayList);

輸出:

[张三, 李四, 王二, 大麻子, 铁哥]

addAll(int index,Collection<? extends E> c)

等同于是add(int index,E) 与 addAll(Collection<? extends E> c) 融合版
在特定的数据库索引字符,先后增加特定结合中的全部原素.比如上一个事例,我觉得在张三后边就把大麻子与铁哥都排队进来,那麼如出来完成一下.

public static void testAddAllByIndex(){
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("张三");
    arrayList.add("李四");
    arrayList.add("王二");
    ArrayList<String> arrayList2 = new ArrayList<>();
    arrayList2.add("大麻子");
    arrayList2.add("铁哥");
    arrayList.addAll(1,arrayList2);
    System.out.println(arrayList);
}

輸出:

[张三, 大麻子, 铁哥, 李四, 王二]

clear()

看名称就应当清晰.此后目录中删掉全部原素.此启用回到后,目录将为空,并不是Null.

public static void testClear() {
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("张三");
    arrayList.add("李四");
    arrayList.add("王二");
    System.out.println("实行 clear() 前,arrayList.size="   arrayList.size());
    arrayList.clear();
    System.out.println("实行 clear() 后,arrayList.size="   arrayList.size());
}

輸出:

实行 clear() 前,arrayList.size=3
实行 clear() 后,arrayList.size=0

clone()

在表明这一以前大家先举一个板栗.

复制目标

public static void testCloneTemp() {
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("张三");
    arrayList.add("李四");
    arrayList.add("王二");
    ArrayList<String> arrayList2 = arrayList;
    arrayList.add("混混");
    arrayList2.add("王多鱼");
    System.out.println(arrayList2);
}

輸出:

[张三, 李四, 王二, 混混, 王多鱼]
大家实际上 想做到的实际效果是arrayList2 不必混混,只必须王多鱼.可是大家使了=造成了她们2个的MAC地址偏向了同一个,这个时候就反映到clone的必要性.

public static void testClone() {
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("张三");
    arrayList.add("李四");
    arrayList.add("王二");
    ArrayList<String> arrayList2 = (ArrayList<String>) arrayList.clone();
    arrayList.add("混混");
    arrayList2.add("王多鱼");
    System.out.println(arrayList2);
}

輸出:

[张三, 李四, 王二, 王多鱼]
那样她们就不容易相互之间危害到.

contains(Object o)

目录包括原素o就回到true,不然就回到false;

public static void testContains() {
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("张三");
    arrayList.add("李四");
    arrayList.add("王二");
    boolean existMazi = arrayList.contains("大麻子");
    boolean existZhangsan = arrayList.contains("张三");
    System.out.printf("存有张三:%s,存有大麻子:%s%n", existZhangsan, existMazi);
}

輸出:

存有张三:true,存有大麻子:false

ensureCapacity(int size)

变动ArrayList的容积为size.

public static void testChangeCapacity() throws NoSuchFieldException, IllegalAccessException {
    ArrayList<String> arrayList = new ArrayList<>(100);
    int sizeBefore = getCapacity(arrayList);
    arrayList.ensureCapacity(1000);
    int sizeAfter = getCapacity(arrayList);
    System.out.printf("变更前的size=%d,变更后的size=%d", sizeBefore, sizeAfter);
}

輸出:

变更前的size=100,变更后的size=1000
方式 getCapacity为ArrayList获得容积尺寸的自定方式 ,以下:

public static int getCapacity(ArrayList<?> arrayList) throws NoSuchFieldException, IllegalAccessException {
    Class<ArrayList> arrayListClass = ArrayList.class;
    Field field = arrayListClass.getDeclaredField("elementData");
    field.setAccessible(true);
    Object[] objects = (Object[]) field.get(arrayList);
    return objects.length;
}

forEach 方式 解析xml结合

不要在应用forEach的与此同时应用remove和 add 方式 , 要不然会报出现异常.
对于为何,这儿也不打开而言了,由于我还没有看懂,搜索一下后在评价帮我讲下.

应用蛮方便快捷的,便是上边的操作方法,仅仅不必启用增加与删掉的方式 就行.

get(int index)

依据字符获得相匹配下标底值.

public static void testGet(){
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("张三");
    arrayList.add("李四");
    arrayList.add("王二");
    for (int i = 0; i < arrayList.size(); i  ) {
        String valueByIndex = arrayList.get(i);
        System.out.println(valueByIndex);
    }
}

輸出:

张三
李四
王二

indexOf()

依据值获得相匹配的字符.

public static void testindexOf() {
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("张三");
    arrayList.add("李四");
    System.out.printf("获得李四的字符:%d%n", arrayList.indexOf("张三"));
    System.out.printf("获得李四一的字符:%d%n", arrayList.indexOf("李四一"));
}

輸出:

获得李四的字符:0
获得李四一的字符:-1

isEmpty()

分辨是不是为空集合,空回到true,不然相反回到true.不可以用以null.

public static void testIsEmpty() {
    ArrayList<String> arrayList = new ArrayList<>(100);
    System.out.printf("获得是不是为空集合:%s%n", arrayList.isEmpty());
}

輸出:

获得是不是为空集合:true

iterator()

获得迭代器,应用迭代器解析xml结合.只有应用一次,二次应用必须再次获得.比如下边编码我注解的地区,再去应用早已沒有实际效果.

public static void testIterator() {
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("张三");
    arrayList.add("李四");
    Iterator<String> iterator = arrayList.iterator();
    while (iterator.hasNext()){
        String str = iterator.next();
        System.out.println(str);
        if("张三".equals(str)){
            iterator.remove();
        }
    }
    // while (iterator.hasNext())
    System.out.println(arrayList);
}

輸出:

张三
李四
[李四]

lastIndexOf(Object o)

回到特定目标在这里结合中最后一次发生处的字符.假如寻找目标,回到字符,找不到男朋友就回到-1.

public static void testLastIndexOf() {
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("张三");
    arrayList.add("李四");
    arrayList.add("张三");
    int lastIndexZs = arrayList.lastIndexOf("张三");//应当回到2
    int lastIndexLsy = arrayList.lastIndexOf("李四一");
    System.out.printf("张三最终发生的字符为:%d,李四一最终发生的字符为:%d%n", lastIndexZs, lastIndexLsy);
}

輸出:

张三最终发生的字符为:2,李四一最终发生的字符为:-1

listIterator()

好像iterator的全新升级,能够正反向解析xml.适用解析xml全过程中改动数据信息,比如set、remove、add.

public static void testListIterator() {
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("张三");
    arrayList.add("李四");
    ListIterator<String> listIterator = arrayList.listIterator();
    String firstIndex = listIterator.next();
    System.out.printf("逐渐删掉:%s,arrayList:%s%n", firstIndex, arrayList);
    listIterator.remove();
    System.out.printf("删掉后,arrayList%s%n" , arrayList);
    listIterator.add("张三");
    listIterator.next();
    listIterator.set("李四替死鬼");
    System.out.printf("set后,arrayList%s%n" , arrayList);
    int prevIndex = listIterator.previousIndex();
    System.out.printf("获得上一个原素的字符%d%n" , prevIndex);
    listIterator.previous();
    listIterator.set("张三替死鬼");
    System.out.printf("set后,arrayList%s%n" , arrayList);
}

輸出:

逐渐删掉:张三,arrayList:[张三, 李四]
删掉后,arrayList[李四]
set后,arrayList[张三, 李四替死鬼]
获得上一个原素的字符1
set后,arrayList[张三, 张三替死鬼]

listIterator(int index)

从特定字符逐渐解析xml.

public static void testListIteratorStartIndex() {
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("张三");
    arrayList.add("李四");
    arrayList.add("王二");
    // 因法外狂徒张三坐牢，只留后边的值
    ListIterator<String> iterator = arrayList.listIterator(1);
    while (iterator.hasNext()) {
        System.out.println(iterator.next());
    }
}

輸出:

李四
王二

remove(int index)

根据字符清除目标,假如进到字符不会有,会发生IndexOutOfBoundsException出现异常.清除取得成功会回到目标.

public static void testRemove() {
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("张三");
    arrayList.add("李四");
    String removeStr = arrayList.remove(1);
    System.out.println(removeStr);
}

輸出:

李四

remove(Object obj)

清除目标,检测后只能清除第一个配对的值.清除取得成功回到true,否之回到false.

public static void testRemoveByObject() {
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("张三");
    arrayList.add("李四");
    arrayList.add("张三");
    arrayList.add(null);
    System.out.printf("arrayList.remove("张三")回到=%s%n",arrayList.remove("张三"));
    System.out.printf("arrayList=%s%n",arrayList);
}

輸出:

arrayList.remove("张三")回到=true
arrayList=[李四, 张三, null]

removeAll(Collection<?> c)

清除传到结合中的目标.

public static void testremoveAll() {
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("张三");
    arrayList.add("李四");
    arrayList.add("张三");
    arrayList.removeAll(new ArrayList<String>() {{
        add("张三");
    }});
    System.out.printf("arrayList=%s%n", arrayList);
}

輸出:

arrayList=[李四]

removeIf()

删掉达到特殊条件的目标.

public static void testRemoveIf() {
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("张三");
    arrayList.add("李四");
    arrayList.add("张三");
    System.out.printf("删掉张三前,arrayList=%s%n", arrayList);
    arrayList.removeIf("张三"::equals);
    System.out.printf("删掉张三后,arrayList=%s%n", arrayList);
}

輸出:

删掉张三前,arrayList=[张三, 李四, 张三]
删掉张三后,arrayList=[李四]

replaceAll()

更换原素,比如将结合内原素全变为英文大写,或是所有原素开展测算.

public static void testReplaceAll() {
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("张三");
    arrayList.add("李四");
    arrayList.add("王五");
    arrayList.add("赵六");
    arrayList.replaceAll(item -> "名字:"   item);
    System.out.printf("arrayList=%s%n", arrayList);
}

輸出:

arrayList=[名字:张三, 名字:李四, 名字:王五, 名字:赵六]

retainAll(Collection<?> c)

取2个结合的或且,去除没有两结合中与此同时存有的原素;

public static void testRetainAll() {
    ArrayList<String> arrayList = new ArrayList<String>() {{
        add("张三");
        add("李四");
        add("王五");
        add("赵六");
    }};
    arrayList.retainAll(Arrays.asList("王五", "赵六"));
    System.out.printf("arrayList=%s%n", arrayList);
}

輸出:

arrayList=[王五, 赵六]

set(int index, E element)

依据字符更换或是插进目标.
实例,设定结合中字符为1的数值鲁班七号.

public static void testSet() {
    ArrayList<String> arrayList = new ArrayList<String>() {{
        add("张三");
        add("李四");
        add("王五");
        add("赵六");
    }};
    System.out.printf("设定前,arrayList=%s%n", arrayList);
    arrayList.set(1,"鲁班七号");
    System.out.printf("设定后,arrayList=%s%n", arrayList);
}

方式 运作輸出結果为:

设定前,arrayList=[张三, 李四, 王五, 赵六]
设定后,arrayList=[张三, 鲁班七号, 王五, 赵六]

size()

回到结合中的数据信息总数.

sort(Comparator<? super E> c)

对结合内目标开展以特定方法排列.

public static void testSort() {
    ArrayList<Integer> arrayList = new ArrayList<Integer>() {{
        add(100);
        add(200);
        add(40);
        add(80);
    }};
    System.out.printf("排列前,arrayList=%s%n", arrayList);
    arrayList.sort(Comparator.naturalOrder());
    System.out.printf("当然排列顺序后,arrayList=%s%n", arrayList);
    arrayList.sort(Comparator.reverseOrder());
    System.out.printf("倒序排序后,arrayList=%s%n", arrayList);
}

方式 运作輸出結果为:

排列前,arrayList=[100, 200, 40, 80]
当然排列顺序后,arrayList=[40, 80, 100, 200]
倒序排序后,arrayList=[200, 100, 80, 40]

spliterator()

并行处理迭代器,便是把结合中的目标放进迭代器中.
随后,能够打开好几个进程并行计算这种目标.
实例编码以下:

public static void testSpliterator() {
    ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6));

    Spliterator<Integer> sItr = arrayList.spliterator();
    // 解析xml后迭代器中的值也会消退
    // sItr.forEachRemaining(d -> System.out.print(d));   //123456
    new Thread(() -> {
        for (int i = 0; i < 4; i  ) {
            sItr.tryAdvance(d -> System.out.printf("进程:%s,抢到:%d%n", Thread.currentThread().getName(), d));
        }
    }).start();
    new Thread(() -> {
        for (int i = 0; i < 4; i  ) {
            sItr.tryAdvance(d -> System.out.printf("进程:%s,抢到:%d%n", Thread.currentThread().getName(), d));
        }
    }).start();
}

方式 运作輸出結果为:

进程:Thread-0,抢到:1
进程:Thread-0,抢到:3
进程:Thread-0,抢到:4
进程:Thread-0,抢到:5
进程:Thread-1,抢到:2
进程:Thread-1,抢到:6

subList(int formIndex,int toIndex)

提取结合的一部分并回到一个List结合.

图来源于菜鸟教程
实例编码以下:

public static void testSubList() {
    ArrayList<String> arrayList = new ArrayList<>(Arrays.asList("p", "r", "o", "g", "r", "a", "m"));
    List<String> subList1 = arrayList.subList(0, 7);
    System.out.printf("arrayList.subList(0,7) result:%s%n", subList1);
    List<String> subList2 = arrayList.subList(3, 7);
    System.out.printf("arrayList.subList(3,7) result:%s%n", subList2);
    List<String> subList3 = arrayList.subList(3, 6);
    System.out.printf("arrayList.subList(3,6) result:%s%n", subList3);
}

方式 运作輸出結果为:

arrayList.subList(0,7) result:[p, r, o, g, r, a, m]
arrayList.subList(3,7) result:[g, r, a, m]
arrayList.subList(3,6) result:[g, r, a]

toArray() && toArray(T[] a)

回到一个当今结合排列顺序而且包括 ArrayList 中全部原素的二维数组.
实例编码以下:

public static void testToArray() {
    // 1. toArray()
    ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(10, 20, 3, 41, 15, 26));
    Object[] num = arrayList.toArray();
    System.out.println(Arrays.toString(num));
    // 2. toArray(T[] a)
    Integer[] arr = new Integer[arrayList.size()];
    arr = arrayList.toArray(arr);
    System.out.println(Arrays.toString(arr));
}

方式 运作輸出結果为:

[10, 20, 3, 41, 15, 26]
[10, 20, 3, 41, 15, 26]

trimToSize()

除去ArrayList不必要的容积.
实例编码以下:

public static void testTrimToSize() throws NoSuchFieldException, IllegalAccessException {
    ArrayList<Integer> arrayList = new ArrayList<>(100);
    arrayList.add(11);
    arrayList.add(12);
    arrayList.add(13);
    System.out.printf("trimToSize以前ArrayList容积尺寸:%d%n", getCapacity(arrayList));
    arrayList.trimToSize();
    System.out.printf("trimToSize以后ArrayList容积尺寸:%d%n", getCapacity(arrayList));
}

方式 运作輸出結果为:

trimToSize以前ArrayList容积尺寸:100
trimToSize以后ArrayList容积尺寸:3

写完辽

无需死记硬背的,个人收藏起來当做词典查一查.
上边编码的详细地址
https://GitHub.com/cuifuan/house/blob/master/src/test/java/com/home/test/TestArrayListFun.java

告别!