ArrayList常用方法演示

一.ArrayList简介

使用ArrayList集合可以减少对象数组的使用，不用考虑下标的问题，同时具备增删改查等各种功能，极大加强了代码的稳定性与复用性

二.ArrayList的对象创建

1.先创建Student类

package Data;

public class Student {
    private  String name;
    private  int age;
    private  String  stuNo;


    public Student(String name, int age, String stuNo) {
        this.name = name;
        this.age = age;
        this.stuNo = stuNo;

    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getStuNo() {
        return stuNo;
    }
    

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", stuNo='" + stuNo + '\'' +
                '}';
    }
}

注意，toString方法一定要加上，这样演示输出结果会比较轻松

2.创建Student类型的ArrayList集合对象

package ArrayListTest;

import Data.Student;

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();//创建ArrayList集合对象list
    }

三.具体方法演示

							添加方法

1. 添加方法

（1）boolean add(E e) 将指定的元素追加到此列表的末尾。

public class Test {
    public static void main(String[] args) {
        List<Student> list=new ArrayList<>();//创建ArrayList集合对象list
        list.add(new Student("henry",12,"345"));//添加方法1，直接new
        Student stu1=new Student("pola",13,"356");
        list.add(stu1);//添加方法2 先创建Student的对象stu1，再添加stu1
        list.add(stu1);
        list.add(new Student("arial",24,"453"));
         for (Student student : list) {
           System.out.println(student);
        }  
    }

输出结果

（2）void add(int index, E element) 在此列表中的指定位置插入指定的元素

  Student stu2=new Student("mick",36,"235");
        list.add(1,stu2);
        for (Student student : list) {
            System.out.println(student);
        } 

（3）boolean addAll(Collection<? extends E> c) 按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾。

		Student stu3=new Student("kang",14,"423");
        Student stu4=new Student("wang",16,"426");
        List<Student> list1=new ArrayList<>();
        list1.add(stu3);
        list1.add(stu4);
        //新的集合对象list1
        list.addAll(list1);//末尾添加集合
        for (Student student : list) {
            System.out.println(student);
        }

（4） boolean addAll(int index, Collection<? extends E> c) 将指定集合中的所有元素插入到此列表中，从指定的位置开始。

 		 list.addAll(1,list1);//指定下标下添加集合
        for (Student student : list) {
            System.out.println(student);
        }

2.删除方法

（1）E remove(int index)
删除该列表中指定位置的元素。

 list.remove(3);
        for (Student student : list) {
            System.out.println(student);
        }

（2） boolean remove(Object o)
从列表中删除指定元素的第一个出现（如果存在）。

list.remove(stu3);
        for (Student student : list) {
            System.out.println(student);
        }

（3） boolean removeAll(Collection<?> c)
从此列表中删除指定集合中包含的所有元素。

 list.removeAll(list1);
        for (Student student : list) {
            System.out.println(student);
        }

（4） protected void removeRange(int fromIndex, int toIndex)
从这个列表中删除所有索引在 fromIndex （含）和 toIndex之间的元素。

只能在同一个包里的类才能使用，我这里Student没放进同一个包里，不能演示

3.替换方法

E set(int index, E element)
用指定的元素替换此列表中指定位置的元素。

  Student stu5=new Student("rain",18,"489");
        list.set(0,stu5);
        for (Student student : list) {
            System.out.println(student);
        }

4.提取元素

E get(int index)

返回此列表中指定位置的元素。

System.out.println(list.get(1));

5.包含方法

（1） boolean contains(Object o)
如果此列表包含指定的元素，则返回 true 。
（2） boolean isEmpty() { }
判断列表是否为空，为空返回true，不为空返回false
（3） int indexOf(Object o)
返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
（4） int lastIndexOf(Object o)
返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
（5） boolean containsAll(Collection<?> c)
如果此列表包含指定集合中的所有元素，则返回 true

 		System.out.println(list.contains(stu1));
        System.out.println(list.isEmpty());
        System.out.println(list.containsAll(list1));
        System.out.println(list.indexOf(stu1));
        System.out.println(list.lastIndexOf(stu1));

6.迭代器

其实就是使用它进行输出
注意：迭代器只能使用一次，
想再用迭代器输出必须再声明一个迭代器

（1）Iterator iterator()
以正确的顺序返回该列表中的元素的迭代器

  Iterator<Student> it =list.iterator();//创建list迭代器 it
        while(it.hasNext()){
            System.out.println(it.next());
        } //用迭代器对list进行输出（其实就是遍历，顺序输出）
        注意：迭代器it只能使用一次，
        想再用迭代器输出必须再声明一个迭代器

和增强型for循环的结果是一样的

（2） ListIterator listIterator(int index) 从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。

 Iterator<Student> it3 =list.listIterator(1);//创建list迭代器 stu
        while(it3.hasNext()){
            System.out.println(it3.next());
        } 

从下标1的元素开始输出，增强型for循环做不到这一点

7.返回对象数组

Object[] toArray()
以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的object类型的数组。

        for (Object o : list.toArray()) {
            Student stu=(Student)o;//由于返回的是
            object类型的数组objiect[ ],
            因此输出之前必须先将每个元素强制转换为Student类型
            System.out.println(stu);
        }

由于返回的是object类型的数组objiect[ ],因此输出之前必须先每个元素强制转换为Student类型

听起来很高大上，其实仔细一想没啥用的方法，为啥要把集合再重新转化为对象数组呢，集合不比对象数组方便吗？？？或许还是我垃圾，到不了那种层次吧

8. 列表长度获取

int size()

返回列表长度

        System.out.println(list.size());
      

9.保留方法

boolean retainAll(Collection<?> c)
仅保留此列表中包含在指定集合中的元素

之前把list1的都删了，现在还得加回来，难受，要不然看不出来效果
加两个list1

  		list.addAll(list1);
        list.addAll(list1);
        for (Student student : list) {
            System.out.println(student);
        }

干正事吧

	 	list.retainAll(list1);
        for (Student student : list) {
            System.out.println(student);
        }

10.截取方法

List subList(int fromIndex, int toIndex)
返回此列表中指定的 fromIndex （包括）和 toIndex之间的独占视图。（前包后不包）
通俗解释就是返回list的其中一段元素组成的新集合（前包后不包）
注意：此方法不会对原来的集合list做出改变

  	 for (Student student : list.subList(0,3)) {
            System.out.println(student);
        }
        System.out.println();
        System.out.println();
        for (Student student : list) {
            System.out.println(student);
        }

上面两行是输出list.subList(0,3)（其实就是集合list下标（0-2））的遍历结果，下面是输出list的遍历结果

list没有改变