Collection接口 是集合类的接口 定义了集合共有的方法
  -|List接口 列表(数组) 允许有重复的对象，有序
    -|ArrayList 实现类 线性表结构 当频繁使用get查找时使用
    -|LinkedList 实现类 内部使用的是链表结构 当频繁出现add remove时使用
  -|Set接口 集合 没有顺序且不能包含重复对象
    -|HashSet

MyClass.java

class Person implements Comparable<Person> {
    int age;
    int score;
    String name;

    public Person (int age, int score, String name) {
        this.age = age;
        this.score = score;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person" +
            "age=" + age +;
    }

    //升序  从小到大
    //降序  从大到小

    //升序
    @Override
    public int compareTo(Person person) {
        if (age > person.age) {
            return 1;
        } else if (age == person.age) {
            return 0;
        }
        return -1;
    }
}

public class MyClass {
    public static void main (Strinng[] agrs){
        //数组的创建
        //集合对象里面只能保存同一种数据类型
        List<Person> people = new ArrayList<>();
        ArrayList<Person> personList = new ArrayList<>();

        //添加对象
        //Person xw = new Person(32, 98, "小王");
        //在数组的末尾添加
        personList.add(new Person(age: 32, score: 98, name: "小王"));
        //在某个位置插入数据
        personList.add(i: 0, new Person(age: 30, score: 91, name: "Jack"));
        
        //获取一个对象
        Person person = personList.get(0);

        //遍历这个数组
        //1.使用for循环遍历
        for (int i = 0; i < personList.size(); i++){
            Person p = personList.get(i);
            //删除 i 对应的对象
            //personList.remove(i);
            //删除某个对象
            //personList.remove(p);
        }

        //2.使用增强for循环
        for (Person p : personList){
            System.out.println(p);
        }

        //3.使用Iterator遍历器来遍历
        //主要区别是：当在遍历的同时需要删除对象
        //获取数组对应的遍历器对象
        Iterator<Person> iterator = personList.iterator();
        //使用hasNext()  判断是否还有下一个
        //next()  获取下一个对象
        while (iterator.hasNext()) {
            Person p = iterator.next();
            iterator.remove();
        }
        
        //数据的删除
        //1.按照一定的条件删除
        //创建Predicate的子类对象
        MyPredicate predicate = new MyPredicate();
        personList.removeIf(predicate);

        //2.使用内名内部类
        personList.removeIf(new Predicate<Person>() {
            @Override
            public boolean test(Person person) {
                if (person.age > 30) {
                    //如果返回值为true  那么这个对象将会被删除
                    return true;
                }
                return false;
            }
        });

        //排序
        //1.自己定义的类必须实现Comparable接口和compareTo方法
        Collrctions.sort(personList);

        personList.sort(new Comparator<Person>() {
            @Override
            public int compare(Person person, Person t1) {
                //指定比较的规则
                return person.name.compareTo(t1.name);
            }
        });
        
        //判断数组里是否包含某一个元素
        //contains比较的是两个元素本身，而不是内容
        if (personList.contains(person)){
            System.out.println("有这个人");
        }else{
            System.out.println("没有这个人");
        }

        //获取某个对象的索引值
        System.out.println(personList.indexOf(person));

        //重新改变某个值
        personList.set(0, person);

        //清空
        personList.clear();
    }

    //创建一个类实现Predicate接口方法
    static class MyPredicate implements Predicate<Person>{
        @Override
        public boolean test(Person person) {
            if (person.age > 30){
                return true;
            }
            return false;
        }
    }
}