ArrayList簡單使用方法總結

目錄

數據結構：

存儲特點，有序可重複

常量

構造函數：

public ArrayList() 

public ArrayList(Collection c) 

public ArrayList(int initialCapacity) 

常用方法

設置摸一個位置上的值：public void add(int index, E element) 

添加另一個Collection：public boolean addAll(Collection c)

public boolean addAll(int index, Collection c)

把list中數組值全部置空，並把size初始化爲0：list.clear();

克隆：public Object clone()

public void ensureCapacity(int minCapacity)

便利的方式：

數組遍歷

迭代遍歷：

for循環遍歷

ArrayList自帶的forEach遍歷

public int indexOf(Object o)：元素在list中的位置

public boolean isEmpty()：判斷是不是沒有數據

判斷list是不是沒有數據，兩種方法

public int lastIndexOf(Object o)：獲取最後一個元素的位置

public boolean removeAll(Collection c)：list移除list2中值相等的元素

public boolean removeIf(Predicate filter)：按照一定規則刪除list中的元素

public void replaceAll(UnaryOperator operator)：通過規則替換值

public boolean retainAll(Collection c)：保留兩個集合的交集

public void sort(Comparator c) ；list按照自定義規則排序

public List subList(int fromIndex, int toIndex)：獲取子list（左閉右開）

public Object[] toArray()：list裝換數組，只能返回Object[]

public T[] toArray(T[] a):list轉換到指定的數組

public void trimToSize()：優化list數組的存儲

public Spliterator spliterator() ：

---

數據結構：

底層就是數組

存儲特點，有序可重複

public class Test{
    public static void main(String[] args) {
        List<Integer> list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(1);
        System.out.println(list.get(0));
        System.out.println(list.get(1));
        System.out.println(list.get(2));
        System.out.println(list.get(3));
    }
}

結果：1,2,3,1 

常量

DEFAULT_CAPACITY = 10	默認初始數組容量10
Object[] EMPTY_ELEMENTDATA = {}	空數組
Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}	默認空數組
Object[] elementData;	存儲實際數據的數組默認初始容量是10
int size;	當前list存儲的數據個數

構造函數：

public ArrayList() 

List<Integer> list = new ArrayList();

public ArrayList(Collection<? extends E> c) 

public class Test{
    public static void main(String[] args) {
        List<Integer> list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(1);
        //這個構造方法我用的少，所以加了個列子
        List<Integer> list2 = new ArrayList(list);
        System.out.println(list2.get(0));
        System.out.println(list2.get(1));
        System.out.println(list2.get(2));
        System.out.println(list2.get(3));
    }
}

結果：1,2,3,1 

public ArrayList(int initialCapacity) 

//定義了內部數組的長度，list3.size（）依然是0
List<Integer> list3 = new ArrayList(100);
System.out.println(list3.size());

常用方法

非常常用的add和remove方法不做介紹，主要介紹一些不常用的方法

設置摸一個位置上的值：public void add(int index, E element) 

下標從0開始

public class Test{
    public static void main(String[] args) {
        List<Integer> list = new ArrayList();
        list.add(1);
        list.add(2);
        System.out.println(list);
        list.set(0,10);
        System.out.println(list);
    }
}

結果：1,2,10,2

添加另一個Collection：public boolean addAll(Collection<? extends E> c)

public class Test{
    public static void main(String[] args) {
        List<Integer> list = new ArrayList();
        list.add(1);
        list.add(2);
        List<Integer> list2 = new ArrayList();
        list.add(3);
        list.add(4);
        list.addAll(list2);
        System.out.println(list);
    }
}

結果1,2,3,4

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

添加的結合在原集合中的開始位置

public class Test{
    public static void main(String[] args) {
        List<Integer> list = new ArrayList();
        list.add(1);
        list.add(2);
        List<Integer> list2 = new ArrayList();
        list2.add(3);
        list2.add(4);
        list.addAll(0,list2);
        System.out.println(list);
    }
}

結果：3,4,1,2（應爲list2是從0的位置開始添加）

把list中數組值全部置空，並把size初始化爲0：list.clear();

public class Test{
    public static void main(String[] args) {
        List<Integer> list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        System.out.println(list);

        list.clear();
        System.out.println("clear之後");
        System.out.println(list);
    }
}

結果：

[1, 2, 3, 4]
clear之後

克隆：public Object clone()

如果要使用clone，不能List<Integer> list = new ArrayList();聲明list， 要使用ArrayList<Integer> list = new ArrayList();聲明list，否則會報錯

public class Test{
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        //如果要使用clone，不能List<Integer> list = new ArrayList();聲明list，
        // 要使用ArrayList<Integer> list = new ArrayList();聲明list，否則會報錯
        ArrayList<Integer> listCopy=(ArrayList<Integer>)list.clone();
        System.out.println(list);
        listCopy.remove(3);
        System.out.println(listCopy);
    }
}

結果：克隆之後，listCopy.remove(3),只是刪除了listCopy對對象3的引用，所以原來的list並不會收到影響

[1, 2, 3, 4]
[1, 2, 3]

public void ensureCapacity(int minCapacity)

如果需要，增加數組的容量，以確保它至少可以容納minCapacity個參數

便利的方式：

數組遍歷

public class Test{
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        System.out.println(list.get(0));
        System.out.println(list.get(1));
        System.out.println(list.get(2));
        System.out.println(list.get(3));
        
    }
}

迭代遍歷：

public class Test{
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

for循環遍歷

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

ArrayList自帶的forEach遍歷

public class Test{
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.forEach(item->{
            System.out.println(item);
        });
    }
}

public int indexOf(Object o)：元素在list中的位置

public class Test{
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        System.out.println(list.indexOf(3));
    }
}

結果：2（從0開始）

public boolean isEmpty()：判斷是不是沒有數據

這個方法有個坑，在使用之前一定要判斷list是不是空的

這個代碼運行就會報錯：

public class Test{
    public static void main(String[] args) {
        ArrayList<Integer> list = null;
        System.out.println(list.isEmpty());
    }
}

報錯

Exception in thread "main" java.lang.NullPointerException
	at cn.enjoyedu.ch5.src.Test.main(Test.java:14)

Process finished with exit code 1

判斷list是不是沒有數據，兩種方法

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> list = null;
        System.out.println(list.isEmpty());
        if (list != null && !list.isEmpty()) {

        }
        if (list != null && list.size() > 0) {
            
        }
    }
}

public int lastIndexOf(Object o)：獲取最後一個元素的位置

有兩個元素2，這裏返回最後一個元素的位置

public class Test{
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(2);
        System.out.println(list.lastIndexOf(2));
    }
}

結果：3

public boolean removeAll(Collection<?> c)：list移除list2中值相等的元素

public class Test{
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(2);
        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(1);
        list2.add(2);
        list2.add(10);
        System.out.println(list);
        list.removeAll(list2);
        System.out.println(list);
    }
}

結果：

[1, 2, 3, 2]
[3]

public boolean removeIf(Predicate<? super E> filter)：按照一定規則刪除list中的元素

移除list中等於2的元素

public class Test{
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(2);
        list.removeIf(item->item==2);
        System.out.println(list);
    }
}

public void replaceAll(UnaryOperator<E> operator)：通過規則替換值

和方法

public class Test{
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(2);
        System.out.println(list);
        list.replaceAll(item->item+1);
        System.out.println(list);
    }
}

結果：

[1, 2, 3, 2]
[2, 3, 4, 3]

public boolean retainAll(Collection<?> c)：保留兩個集合的交集

public class Test{
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(1);
        list2.add(2);
        list2.add(10);
        list.retainAll(list2);
        System.out.println(list);
    }
}

結果：[1, 2]

public void sort(Comparator<? super E> c) ；list按照自定義規則排序

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        list.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        });
        System.out.println(list);
    }
}

結果：[1, 2, 3, 4]

public List<E> subList(int fromIndex, int toIndex)：獲取子list（左閉右開）

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        List<Integer> list2 = list.subList(0, 1);
        System.out.println(list);
        System.out.println(list2);
    }
}

結果

[1, 3, 4, 2]
[1]

public Object[] toArray()：list裝換數組，只能返回Object[]

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        Object[] objects =  list.toArray();
        System.out.println(list);
        System.out.println(objects[0]);
    }
}

public <T> T[] toArray(T[] a):list轉換到指定的數組

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        Integer[] a = new Integer[4];
        list.toArray(a);
        System.out.println(list);
        System.out.println(a[0]);
        System.out.println(a[1]);
        System.out.println(a[2]);
        System.out.println(a[3]);
    }
}

結果

[1, 3, 4, 2]
1
3
4
2

public void trimToSize()：優化list數組的存儲

比如list中數組默認長度是10，list中存儲了3個元素，那麼數組就有7個位置空間被浪費了，通過調用trimToSize（），可以讓數組長度變爲3，從而節省空間

writeObject

public Spliterator<E> spliterator() ：

這個方法我看的頭大，後面補充