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() ：

这个方法我看的头大，后面补充