集合（Collectijon、List、ArrayList、LinkedList）【2】

集合

集合的特点：提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变

1.Collection

1.1 集合类体系结构

1.2 Collection集合概述和使用

Collection集合概述

是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
JDK不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现

创建Collection集合的对象

多态的方式
具体的实现类ArrayList

public class CollectionDemo01 {
    public static void main(String[] args) {
        //创建一个Collection集合的对象
        Collection<String> c = new ArrayList<>();

        //添加元素 add(E e)
        c.add("浪浪");
        c.add("学习");
        c.add("java");

        //打印输出
        System.out.println(c);
    }
}

1.3 Collection 集合常用方法

public class CollectionDemo02 {
    public static void main(String[] args) {
        //创建Collection对象
        Collection<String> c = new ArrayList<>();

        //add(E e) 添加元素
        c.add("浪浪");
        c.add("学习");
        c.add("java");
        c.add("java");
        //可插入重复数据

        //remove(Object o) :从集合中移除指定的元素
        System.out.println(c.remove("java"));//true
        System.out.println(c.remove("javaee"));//false

        //clear(): 清空集合中的元素
        //c.clear();

        System.out.println(c.contains("浪浪"));//true
        System.out.println(c.contains("浪浪的"));//false

        //isEmpty():是否为空
        System.out.println(c.isEmpty());//不为空时为false

        //size()获取集合长度
        System.out.println(c.size());


        System.out.println(c);
    }
}

1.4 Collection 集合的遍历

Iterator:迭代器，集合的专用遍历方式

Iterator<E> iterator(): 返回此集合中元素的迭代器，通过集合的iterator()方法得到
迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的

Iterator中的常用方法

E next() : 返回迭代器中的下一个元素
boolean hasNext(): 如果迭代器具有更多的元素，则返回true

public class CollectionDemo03 {
    public static void main(String[] args) {
        //创建Collection对象
        Collection<String> c = new ArrayList<>();

        //add(E e) 添加元素
        c.add("浪浪");
        c.add("学习");
        c.add("java");


        //Iterator<E>
        Iterator<String> it = c.iterator();
        /*System.out.println(it.next());
        System.out.println(it.next());
        System.out.println(it.next());
        System.out.println(it.next());//java.util.NoSuchElementException:表示被请求的元素不存在*/
        /*if (it.hasNext()){
            System.out.println(it.next());
        }
        if (it.hasNext()){
            System.out.println(it.next());
        }
        if (it.hasNext()){
            System.out.println(it.next());
        }
        if (it.hasNext()){
            System.out.println(it.next());
        }*/
        //用while循环改进判断
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

1.5 集合的使用步骤

Collection 集合存储学生对象并遍历

需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

思路：

① 定义学生类

② 创建Collection集合对象

③ 创建学生对象

④ 把学生添加到集合

⑤ 遍历集合（迭代方式）

学生类

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student() {
    }

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

测试类

public class CollectionDemo {
    public static void main(String[] args) {
        //创建Collection集合对象
        Collection<Student> c = new ArrayList<>();

        //创建学生对象
        Student s1 = new Student("张三",20);
        Student s2 = new Student("李四",45);
        Student s3 = new Student("王五",57);

        c.add(s1);
        c.add(s2);
        c.add(s3);

        //遍历集合（迭代器方式）
        Iterator<Student> it = c.iterator();
        while (it.hasNext()){
            Student s = it.next();
            System.out.println(s.getName()+","+s.getAge());
        }

    }
}

2.List

2.1 List集合概述和特点

有序集合（也称为序列），用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素
与Set集合不同，列表通常允许重复的元素

List集合特点

有序：存储和取出的元素顺序一致
可重复：存储的元素可以重复

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

        //添加元素
        list.add("浪浪");
        list.add("学习");
        list.add("java");

        //输出集合对象
        System.out.println(list);

        //迭代器遍历
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

2.2 List 集合特有方法

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

        //添加元素
        list.add("浪浪");
        list.add("学习");
        list.add("java");

        //add(int index,E element):在此集合中的指定位置插入指定的元素
        list.add(1,"在");
        //list.add(11,"在");//java.lang.IndexOutOfBoundsException: Index: 11, Size: 4 索引越界异常

        //E remove(int index): 删除指定索引处的元素，返回被删除的元素
        //System.out.println(list.remove(1));//返回删除的元素
        //System.out.println(list.remove(11));//java.lang.IndexOutOfBoundsException: Index: 11, Size: 3 索引越界异常

        //E set(int index,E element) : 修改指定索引处的元素，返回被修改的元素
        System.out.println(list.set(1,"是在"));
        //System.out.println(list.set(11,"是在"));//java.lang.IndexOutOfBoundsException: 索引越界异常

        //E get(int index): 返回指定索引处的元素
        System.out.println(list.get(1));

        /*
            注意有用到索引的方法 索引一定不要大于集合的长度，否则会索引越界异常
         */

        //输出集合对象
        //System.out.println(list);

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

    }
}

List 集合存储学生对象并遍历

需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

思路：

① 定义学生类

② 创建List集合对象

③ 创建学生对象

④ 把学生添加到集合

⑤ 遍历集合（迭代器方式，for循环方式）

学生实体类

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student() {
    }

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

测试类

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

        //创建学生对象
        Student s1 = new Student("张三",20);
        Student s2 = new Student("李四",45);
        Student s3 = new Student("王五",57);

        //添加到list
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //迭代器遍历
        Iterator<Student> it = list.iterator();
        while (it.hasNext()){
            Student s = it.next();
            System.out.println(s.getName()+","+s.getAge());
        }
        System.out.println("***************");

        //for循环遍历
        for (int i = 0; i < list.size(); i++) {
            Student s = list.get(i);
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

2.3 并发修改异常

并发修改异常

ConcurrentModificationException

产生原因

迭代器遍历的过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素中判断预期修改值和实际修改值不一致

解决方案

用for循环遍历，然后用集合对象做对应的操作即可

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

        //添加元素
        list.add("浪浪");
        list.add("学习");
        list.add("java");

        //遍历集合，得到每一个元素
        //java.util.ConcurrentModificationException 当不允许这样的修改时，可以通过检测到的并发修改的方法来抛出异常
        /*Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            if (s.equals("java")){
                list.add("持续中");
            }
        }*/

        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            if (s.equals("java")){
                list.add("持续中");
            }
        }

        System.out.println(list);
    }
}

2.4 ListIterator

Listlterator:列表迭代器

通过List集合的listIterator（）方法得到，所以说它是List集合特有的迭代器
用于允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

ListIterator中的常用方法

E next():返回迭代中的下一个元素
boolean hasNext（）：如果迭代具有更多元素，则返回true
E previous（）：返回列表中的上一元素
boolean hasPrevious（）：如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
void add（E e）：将指定的元素插入列表

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

        //添加元素
        list.add("浪浪");
        list.add("学习");
        list.add("java");

        //通过List集合的listIterator（）方法得到 //正向遍历
        /*ListIterator<String> lit = list.listIterator();
        while(lit.hasNext()){
            String s = lit.next();
            System.out.println(s);
        }
        System.out.println("*********************");

        //逆向遍历
        while(lit.hasPrevious()){
            String s = lit.previous();
            System.out.println(s);
        }*/

        //获取列表迭代器
        ListIterator<String> lit = list.listIterator();
        while(lit.hasNext()){
            String s = lit.next();
            if (s.equals("java")){
                lit.add("持续中");
            }
        }
        System.out.println(list);


    }
}

2.5 增强for循环

增强for：简化数组和Colection集合的遍历

实现Iterator接口的类允许其对象成为增强型for语句的目标
它是JDK5之后出现的，其内部原理是一个Iterator迭代器

增强for的格式：

格式：

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

//在此处使用变量即可，该变量就是元素

}
范例：

int[] arr = {1,2,3,4,5}

for(int i : arr){

System.out.printIn(i);

}

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

        //添加元素
        list.add("浪浪");
        list.add("学习");
        list.add("java");

        //增强for 内部原理是Iterator迭代器
        //java.util.ConcurrentModificationException
        /*for (String s:list) {
            if (s.equals("java")){
                list.add("持续中");
            }
        }*/
        for(String s : list){
            System.out.println(s);
        }
    }
}

案例：List 集合存储学生对象用三种方式遍历

需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

思路：

① 定义学生类

② 创建List集合对象

③ 创建学生对象

④ 把学生添加到集合

⑤ 遍历集合

迭代器：集合特有的遍历方式

普通for：带有索引的遍历方式

增强for：最方便的遍历方式

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

        Student s1 = new Student("张三",20);
        Student s2 = new Student("李四",24);
        Student s3 = new Student("王五",21);

        list.add(s1);
        list.add(s2);
        list.add(s3);

        //方法1： 普通for循环
        for (int i = 0; i < list.size(); i++){
            System.out.println(list.get(i));
        }
        System.out.println("***************");

        //方法2：增强for循环
        for (Student s : list){
            System.out.println(s);
        }
        System.out.println("***************");

        //方法3：Iterator迭代器遍历
        Iterator<Student> it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println("**************");

        //方法4： ListIterator迭代器遍历
        ListIterator<Student> lit = list.listIterator();
        while (lit.hasNext()){
            System.out.println(lit.next());
        }

    }
}

2.6 数据结构

数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率

2.7 常见数据结构之栈

2.8 常见数据结构之队列

2.9 常见数据结构之数组

数组是一种查询快，增删慢的模型

查询数据通过索引定位，查询任意数据耗时相同，查询效率高

删除数据时，要将原始数据删除，同时后面每个数据前移，删除效率低

添加数据时，添加位置后的每个数据后移，再添加元素，添加效率极低

2.10 常见数据结构之链表

2.11 List集合子类的特点

List集合常用子类： ArrayList、LinkedList

ArrayList：底层数据结构是数组，查询快，增删慢
LinkedList：底层数组结构是链表，查询慢，增删快

练习：

分别用ArrayList 和 LinkedList 完成存储字符串并遍历

public class ListDemo {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<String> array = new ArrayList<>();

        array.add("浪浪");
        array.add("学习");
        array.add("java");

        //遍历
        Iterator<String> it = array.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

        for (int i = 0; i < array.size(); i++) {
            System.out.println(array.get(i));
        }

        for (String s : array){
            System.out.println(s);
        }

        LinkedList<String> linkedList = new LinkedList<>();

        linkedList.add("张三");
        linkedList.add("也在");
        linkedList.add("学java");

        //三种遍历
        Iterator<String> it1 = linkedList.iterator();
        while (it1.hasNext()){
            System.out.println(it1.next());
        }
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }
        for (String s : linkedList
             ) {
            System.out.println(s);
        }

    }
}

2.12 LinkedList 集合的特有功能

public class LinkedListDemo {
    public static void main(String[] args) {
        //创建集合对象
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("浪浪");
        linkedList.add("学习");
        linkedList.add("java");

        //加在列表中第一个元素
        linkedList.addFirst("javaee");
        //加在列表中最后一个
        linkedList.addLast("持续中");

        //返回列表中第一个元素
        System.out.println(linkedList.getFirst());
        //返回列表中最后一个元素
        System.out.println(linkedList.getLast());

        //删除列表中第一个元素.并返回删除值
        System.out.println(linkedList.removeFirst());
        //删除列表中最后一个元素，并返回删除值
        System.out.println(linkedList.removeLast());

        System.out.println(linkedList);
    }
}