LIST集合初始化及常见方法

目录

1.ArrayList集合的初始化：

2.常用的List集合方法：

1.添加元素方法

2.查看（遍历元素）：

3.修改元素：

4.删除元素：

5.其他的常见方法：

---

1.ArrayList集合的初始化：

1 方法 1：使用Arrays.asList进行初始化（add,remove,可能会报错）

2 方法 2：初始化ArrayList的匿名内部类方法

3 方法 3：ArrayList初始化的正常方式（推荐使用）

4 方法4：使用Collections.nocopies

@Test
    public void testDefined(){{
        //1 方法 1：使用Arrays.asList进行初始化
        List<Integer> integers = Arrays.asList(1, 3, 4, 5, 6);
        //2 方法 2：初始化ArrayList的匿名内部类方法
        List<Integer> integers1 = new ArrayList<Integer>() {{
            add(1);
            add(2);
            add(3);
        }};
        //3 方法 3：ArrayList初始化的正常方式
        ArrayList<Integer> integers2 = new ArrayList<>();
        //4 方法4：使用Collections.nCopies
        ArrayList<Integer> integers3 = new ArrayList<>(Collections.nCopies(5, 3));
        integers3.forEach(System.out::println);  //33333  5个3
    }}

2.常用的List集合方法：

1.添加元素方法

1.add(E e):添加元素在列表的末尾

2.add(int index, E e):添加元素在列表的指定位置，指定位置的元素依次后退一位

3.addAll(Collection<? extends E> c):

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

//添加元素,无索引
    @Test
    public void testAdd(){
        List<Integer> integers = new ArrayList<>();
        //1.add(E e):添加元素在列表的末尾
        integers.add(1);
        integers.add(2);
        integers.add(3);//结果  123
        //2.add(int index, E e):添加元素在列表的指定位置，指定位置的元素依次后退一位
        integers.add(1, 5);  //结果：1523
        integers.forEach(System.out::print);
        List<Integer> integers1 = new ArrayList<>();
        //3.addAll(Collection<? extends E> c):
        integers1.addAll(integers);
        integers1.forEach(System.out::print);//结果:1523
        //4.addAll(int index, Collection<? extends E> c):
        integers.addAll(1,integers1);
        integers.forEach(System.out::print); //1 1523 523
    }

2.查看（遍历元素）：

1.for循环

2.增强for循环

3.迭代器iterator()

4.Collections.enumeration(集合)：

5.java8:lambda表达式输出

//遍历list集合
    @Test
    public void testGet(){
        List<Integer> integers = new ArrayList<>();
        //1.add(E e):添加元素在列表的末尾
        integers.add(1);
        integers.add(2);
        integers.add(3);//结果  123
        //1.for循环
        for (int i = 0; i < integers.size(); i++){
            System.out.println(integers.get(i)); //123
        }
        //2.增强for循环
        for (Integer integer : integers) {
            System.out.println(integer); //123
        }
        //3.迭代器iterator()
        Iterator<Integer> iterator = integers.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //4.Collections.enumeration(集合)
        Enumeration<Integer> enumeration = Collections.enumeration(integers);
        while (enumeration.hasMoreElements()) {
            System.out.println("enumeration: " + enumeration.nextElement());
            //结果
            //enumeration: 1
            //enumeration: 2
            //enumeration: 3
        }
        //5.java8:lambda表达式输出
        integers.forEach(System.out::println);
    }

3.修改元素：

set(int index, E e）

    @Test
    public void testListSet(){
        List<Integer> integers = new ArrayList<>();
        integers.add(1);
        integers.add(2);
        integers.add(3);
        integers.forEach(System.out::println); //1 2 3
        integers.set(1, 100);
        integers.forEach(System.out::println); // 1 100 3
    }

4.删除元素：

1.remove(int index)

2.remove(Object o)

3.remove(Collection<? extends E> c)

4.removeRange(int 头索引， int 尾索引）

    @Test
    public void testRemove(){
        List<Integer> ints= Arrays.asList(1,3,2,4,11,3,6,78,45);
        System.out.println(ints.size());
        Integer remove = ints.remove(4); //报错
        System.out.println(remove);
        ints.remove("5"); 
        List<String> strs= Arrays.asList("1","2","5");
        strs.remove("5");
        System.out.println(ints.size());
    }

报java.lang.UnsupportedOperationException

    @Test
    public void testRemove(){
        List<Integer> ints = new ArrayList<>();
        System.out.println(ints.size()); //0
        ints.add(1);
        ints.add(12);
        ints.add(13);
        ints.add(16);
        ints.add(16);
        ints.add(17);
        ints.add(10);
        System.out.println(ints.size()); // 7
        Integer remove = ints.remove(4);
        System.out.println(remove);
        System.out.println(ints.size());  // 6
}

可以成功运行并删除，调用Arrays.asList()生产的List的add、remove方法时报UnsupportedOperationException异常，这是由Arrays.asList() 返回的是Arrays的内部类ArrayList， 而不是java.util.ArrayList。Arrays的内部类ArrayList

java.util.ArrayList都是继承AbstractList，remove、add等方法AbstractList中是默认throw UnsupportedOperationException而且不作任何操作。java.util.ArrayList重写了这些方法而Arrays的内部类ArrayList没有重写，所以会抛出异常。

使用java.util.ArrayList 数组即可

5.其他的常见方法：

1.size():返回此列表中的长度。

2.Collections.sort(Collection<? extends E> c):集合升序排序

3.Collections.sort(list)  ---> Collections.reverse(list)  :   集合降序排序

或者：Collections.sort(list,Collections.reverseOrder());

4.public List<E> subList(int fromIndex, int toIndex): 获取现有list子列表

5.public int lastIndexOf(Object o)：返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。

6. public E get(int index):返回此列表中指定位置的元素。

7. public int indexOf(Object o):返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。

8.public boolean contains(Object o):可以用来比较两个ArrayList集合中的元素是否一致

业务需求：判断对象更新之后，修改前后的值是否改变

9.Collections.swap(List, int index1, int index2):交换同集合中index1位置与index2位置的元素

10.public Object[] toArray()：以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。此数组是全新的，意思就是和之前的ArrayList不是指向一个引用，调用者可以自由地修改返回的数组

11.public void ensureCapacity(int minCapacity)：增加数组的容量

    @Test
    public void testSort(){
        List<Integer> ints= Arrays.asList(1,3,2,4,11,3,6,78,45);
        //1.size():返回此列表中的长度。
        System.out.println(ints.size());   // 9
        ints.forEach(System.out::println); //1 3 2 4 11 3 6 78 45
        //2.Collections.sort(Collection<? extends E> c):集合升序排序
        Collections.sort(ints);
        ints.forEach(System.out::println); //1 2 3 3 4 6 11 45 78
        //3.Collections.reverse(list)  :   集合降序排序
        Collections.reverse(ints);
        ints.forEach(System.out::println); //78 45 11 6 4 3 3 2 1
        //比较器Collections.reverseOrder()
        Collections.sort(integers1, Collections.reverseOrder());
        integers1.forEach(System.out::println); //78 45 11 6 4 3 3 2 1
    }

对象排序：对象实体必须实现Comparable()接口，需重写其中的compareTo（）方法

     否则报错