集合框架（一）

1、集合的相关概念

1.1、为什么需要集合？

集合也是一个容器，但是可以自动扩容，只需要往里面添加元素就行，这样可以解决数组的定长问题。但是不能储存基本数据类型。添加基本数据类型需要使用包装类。

1.2、集合的分类：单列集合和双列集合。

2、ArrayList

2.1、基本使用如下所示：

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<String> person = new ArrayList<>();       //后面的尖括号不能少
        /**
         * ArrayList的基本方法
         * 增：add，返回bool
         * 删：remove（E e），返回bool     remove（int index）：删除指定索引并返回这个元素
         * 查：e get（int index）：获取指定索引的元素，size（）：返回集合的长度
         * 改：E set（int index，E e）：修改指定索引的元素，并且返回原来的元素
         *
         * */
        
        //添加数据
        person.add(new String("qz1027"));
        person.add(new String("酋长"));
        System.out.println(person);

        //循环遍历集合
        for (int i = 0; i < person.size(); i++) {
            System.out.println(person.get(i));
        }

        //添加基本数据类型
        ArrayList<Integer> age = new ArrayList<>();
        //可以直接往里面添加基本数据
        for (int i = 1; i <= 10; i++) {
            age.add(i);
        }
        for (int i = 0; i < person.size(); i++) {
            System.out.println(age.get(i));
        }
    }
}

3、Collection集合（单列集合的顶层父类接口）

3.1、体系框架如下所示：

3.2、List（ArrayList和LinkedList）系列集合：添加的元素是有序（存和取的顺序相同），可重复，有索引的。

3.3、Set（HashSet和TreeSet和LinkedHashSet）系列集合：添加的元素是无序 ，不重复，无索引的（意味着删除时不能通过索引删除）。

Collection常见方法如下所示：

==上述方法中，如果要使用contains方法判断当前集合（此集合里面的内容是非String的自定义数据类型）中是否包含给定的对象，一定要在Javabean中重写equals方法！！！==如下所示：

import java.util.Objects;

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }


    public Student() {
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }

}
//测试类
import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<Student> stu = new ArrayList<>();
        stu.add(new Student("张三",18));
        stu.add(new Student("李四",21));

        boolean flag = stu.contains(new Student("张三",18));
        System.out.println(flag);       //true
        flag = stu.contains(new Student("张三",21));
        System.out.println(flag);       //false
    }
}

3.4、Collection的遍历方式

3.4.1、迭代器遍历

迭代器在Java中的类是Iterator，迭代器是集合专用的遍历方式。

实例代码如下所示：

import java.util.ArrayList;
import java.util.Iterator;

public class Test {
    public static void main(String[] args) {
        ArrayList<String> str = new ArrayList<>();
        str.add(new String("张三"));
        str.add(new String("李四"));

        //获取对象
        Iterator<String> it = str.iterator();
        //循环遍历
        while(it.hasNext()){
            System.out.println(it.next());
        }

    }
}

注意点：

①、当循环结束的时候，迭代器指针不会归零，如果想要再次遍历，需要再次定义一个迭代器

②、使用迭代器遍历的时候，不能使用集合的方法进行添加和删除。会有并发修改的异常！！如果要进行删除，要用迭代器提供的remove方法，格式为：迭代器.remove();

3.4.2、增强for遍历

简化迭代器遍历单列集合的繁琐，并且只有单列集合和数组才能用增强for进行遍历。

格式为(在idea中有快捷生成方式，直接集合的名字+ for回车)：

for（元素的数据类型 变量名：数组或者单列集合）{

​ System.out.println(变量名);

}

增强for的细节：如果修改增强for中的变量，不会改变集合中原有的数据。

3.4.3、基于Lambda表达式进行遍历（调用forEach方法，底层也是逐一遍历集合）

测试代码如下所示：

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<String> str = new ArrayList<>();
        str.add(new String("张三"));
        str.add(new String("李四"));

        //使用Lambda表达式进行遍历
        str.forEach((String s) -> {
            System.out.println(s);
        });

    }
}

三种遍历方式的选择：

迭代器：在遍历的过程中需要对数据进行删除。

增强for和Lambda表达式遍历：只对数据进行遍历，而不进行操作。

3.5、List集合的特有方法

这里删除有两种方式，当集合里面存放的是基本数据类型时，如果我们传递过去一个数字进行删除，那么首先会调用通过索引进行删除(因为在Java中，会优先调用实参数据类型和形参数据类型相同的方法)，如果要想直接删除传递过去的那个数，我们需要进行手动装箱，如下所示：

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> integers = new ArrayList<>();
        //添加数据
        for (int i = 1; i <= 5; i++) {
            integers.add(i);
        }

        //下面的代码将删除1号索引处的数据,如果想要删除数据1，我们要进行手动装箱
        integers.remove(1);
        System.out.println(integers);   //输出：[1, 3, 4, 5]

        //手动装箱
        Integer i = Integer.valueOf(1);
        //然后再传递至remove
        integers.remove(i);
        System.out.println(integers);  //输出：[3, 4, 5]

    }

}

3.5.1、List的遍历方式

①、迭代器遍历

②、增强for遍历

③、Lambda表达式遍历

④、基于索引的遍历

⑤、列表迭代器遍历（这种方式里面提供了操控数据的方法，比如增加修改等）

import java.util.ArrayList;
import java.util.ListIterator;

public class Test {
    public static void main(String[] args) {
        test01();
    }

    public static void test01(){
        ArrayList<Integer> integers = new ArrayList<>();
        //添加数据
        for (int i = 1; i <= 5; i++) {
            integers.add(i);
        }

        ListIterator<Integer> it = integers.listIterator();

        while(it.hasNext()){
            int value = it.next();
            System.out.println(value);
            //可以对数据进行修改
            if(value == 2){
                it.set(100);
            }
        }

        System.out.println("---------------------");

        ListIterator<Integer> it1 = integers.listIterator();

        while(it1.hasNext()){
            int value = it1.next();
            System.out.println(value);
        }

    }

}