Java进阶 --集合(List)

集合的体系结构以及Collection集合

• 集合的体系结构：

  1. 单列集合：Collection接口

     • List接口：元素可重复
       ArrayList类、LinkedList类
     • Set接口：元素不可以重复
       HashSet类、TreeSet类
       

  2. 双列集合：Map接口
     HashMap类

• Collection集合：
  创建对象：Collection<String> c=new ArrayList();
  常用方法：所有单列集合通用的方法。
  boolean add(E e):添加元素,返回值表示是否添加成功，使用ArrayList集合返回的是固定值true。
boolean remove(Object o):从集合中移除指定的元素，返回值表示是否移除成功
void clear():清空集合中的元素
boolean contains(Object o):判断集合中是否存在指定的元素，true表示包含
boolean isEmpty():判断集合是否为空，true表示为空
int size():集合的长度，也就是集合中元素的个数

• Collection集合遍历-迭代器

 			//1、通过集合的iterator方法获取迭代器对象。
            
            //2、循环判断是否有下一个元素。it.hasNext()方法
            while(it.hasNext()){
                //3、如果有下一个元素，那么就获取下一个元素。it.next()方法
                String s = it.next();
                System.out.println(s);
            }

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

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

        // 添加元素
        array.add("林青霞");
        array.add("风清扬");
        array.add("张曼玉");

        // 移除元素
//        array.remove("风清扬");

        // 清空元素
//        array.clear();

//        System.out.println(array.contains("林青霞"));;
//        System.out.println(array.contains("刘德华"));

//        System.out.println(array.isEmpty());

//        System.out.println(array.size());

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

            System.out.println(s);
        }

    }
}

list集合的遍历以及数据结构

• List集合的特点：
  1、有序：存和取得顺序一致。
  2、元素可重复
  3、有索引，可以使用fori的方式遍历。

• List集合常用方法：
  void add(int index,E element)：在此集合中的指定位置插入指定的元素
E remove(int index)：删除指定索引处的元素，返回被删除的元素
E set(int index,E element)：修改指定索引处的元素，返回被修改的元素
E get(int index)：返回指定索引处的元素

• 总结：在开发中我们一般是使用List集合而不是使用Collection集合。
  方法分类：

  1. 增/添加：
     boolean add(E e)：在集合的末尾添加元素e
void add(int index, E e):在index索引出添加元素e
  2. 删/移除：
     boolean remove(E e):根据元素e删除
E remove(int index)：根据索引index删除元素
  3. 改/设置：
     E set(int index,E element)：将索引index处的元素重新设置成element，返回值是被修改的元素。
  4. 查/获取：
     E get(int index):根据索引获取元素
int size():获取集合的长度
  5. 遍历方式：
     1、首选：fori遍历，只能针对有索引的集合遍历。
     2、迭代器iterator，但是不太推荐，麻烦。

• 迭代器并发修改异常：ConcurrentModificationException
  原因：集合中有一个记录修改(添加和移除)次数的变量modCount。使用集合添加元素和删除元素modCount都会++，也叫做实际修改次数++；
  iterator迭代器中也有一个期望修改次数的变量expectedModCount，默认值等于集合的modCount；每当我们调用迭代器的next()
  方法时，内部都会将expectedModCount和modCount进行比较，如果不一样就会抛出ConcurrentModificationException并发
  修改异常。
  ps：集合的长度发生了变化，集合中的modCount就会++；

• 解决办法：
  第一种：使用fori遍历代替迭代器的方式遍历。

  第二种：不使用Itr迭代器，使用他的子类ListItr来遍历集合，获取的方式为集合的listIterator();
  但是添加元素和删除元素要使用迭代器中提供的add方法和remove()

• 增强for循环：第三种遍历方式，底层使用的是迭代器，相当于迭代器的一种简化遍历方式。

		   语法：用于遍历集合和数组
            for(集合/数组元素类型 变量名:集合/数组对象){
                //循环体，变量保存的就是每次遍历的结果。
            }

快捷键：集合/数组对象.for+回车

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

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = 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;
    }

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

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

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

        // 添加元素
        list.add(new Student("风清扬", 28));
        list.add(new Student("刘德华", 49));
        list.add(new Student("陈奕迅", 23));
        list.add(new Student("周星驰", 36));

        // 变量集合
        Iterator<Student> it = list.iterator();

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

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

        while (it.hasNext()) {
            Student stu = it.next();
            System.out.println(stu);
        }
    }
}

集合的三种遍历方式

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

public class ListDemo2 {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<Student>();

        list.add(new Student("江西财经大学", 90));
        list.add(new Student("清华大学", 130));
        list.add(new Student("北京大学", 100));
        list.add(new Student("江西农业大学", 69));

        // 第一种遍历
        for (int i=0; i<list.size(); i++) {
            Student stu = list.get(i);
            System.out.println(stu.getName() + ", " + stu.getAge());
        }

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

        // 第二种遍历
        Iterator<Student> it = list.iterator();
        while (it.hasNext()) {
            Student stu = it.next();
            System.out.println(stu.getName() + ", " + stu.getAge());
        }

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

        // 第三种遍历
        for (Student stu : list) {
            System.out.println(stu.getName() + ", " + stu.getAge());
        }
    }
}

ArrayList集合和LinkedList集合

• 栈结构：先进后出。例如：弹夹

• 队列结构：先进显出。例如：打饭排队。

• 数组结构：查询快，增删慢，ArrayList底层是数组结构

• 链表结构：查询慢，增删快，LinkedList底层是链表接结构