Java常用工具之集合（List、增强for循环、迭代器）——Java入门学习第十二天

Java常用工具——集合

在java中集合是用来存储多个元素的容器；

集合是一个体系庞大，结构层次清晰完整的一项技术

根据API文档使用步骤查找集合类：

1.查找集合类

2.查看该集合所属接口名

3.查看构造方法

4.创建集合对象

5.创建元素对象

6.添加元素到集合中

7.遍历集合

集合和数组的区别：

元素类型：

集合：引用类型（存储基本类型时会自动装箱）

数组：基本类型、引用类型

元素个数：

集合：不固定，可随意扩容

数组：固定，不能改变容量

集合的好处：

不受容器大小限制，可以随时添加删除元素，提供了大量操作元素的方法（判断、获取等）

Java的集合体系

单列集合（Collection）

List(接口，抽象类):

​ ArrayList(子类，实现类)

Set(接口，抽象类):

​ HashSet(子类，实现类)

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

双列集合（Map:key,value）

Map(接口，抽象类):

​ HashMap(子类，实现类)

List集合的特点

特点：可重复，有序（存取顺序相同）

应用：

​ list list = new ArrayList();（父接口指向子类对象）

案例：List集合的简单使用

需求：向List集合中添加三个元素，并遍历打印

public boolean add(E e):将数据添加到集合的末尾，这里的E是泛型的意思，目前可以理解为Object

public int size():获取集合的长度

public E get(int index):根据索引，索取其对应的元素(E=Object)

package list.demo;
/*
    1.创建结婚对象
    2.创建元素对象
    3.将元素对象添加到集合对象中
    4.遍历集合
 */
import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
//        需求：往List集合中添加3个学生对象，然后遍历
//        1.创建结婚对象
        List list = new ArrayList();
//        2.创建元素对象
        Student s1 = new Student("大乔",23);
        Student s = new Student("大乔",23);
        Student s2 = new Student("小乔",18);
        Student s3 = new Student("张良",22);
        Student s4 = new Student("甄姬",20);
//        3.将元素对象添加到集合对象中
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
        list.add(s);
//        直接打印集合
        System.out.println(list);

//        获取索引为2的集合
        Object o = list.get(2);
        System.out.println("所以为2的元素是："+o);
//        获取集合中的元素个数
        System.out.println("list的长度为："+list.size());
        System.out.println("——————————");
//        4.遍历集合
        for (int i = 0 ;i < list.size();i ++) {
//            i表示的就是集合中每一个元素的索引
            Object obj = list.get(i);
            System.out.println("索引为 "+i+"的元素为"+ obj);
        }
    }
}

增强for循环和迭代器

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

增强for循环格式：

​ for(数据类型 变量名：数组或者集合对象){

​ //循环体，变量即元素

​ }

案例演示（使用增强for遍历List集合）

增强for格式快捷方式：iter+回车，只会生成格式，里面的语句体要自己补充

注意：增强for的底层依赖是迭代器（Iterator）。简单理解：增强for就是迭代器的简写形式

package study5.demo;

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

//通过增强for遍历List集合
//增强for格式快捷方式：iter+回车，只会生成格式，里面的语句体要自己补充
//注意：增强for的底层依赖是迭代器（Iterator）。简单理解：增强for就是迭代器的简写形式

public class For {
    public static void main(String[] args) {
//        1.创建集合对象
        List list = new ArrayList();
//        2.创建元素对象

//        3.将元素对象添加到集合对象中
        list.add(10);           //add()里面的数据是Object类型的
        list.add(10);
        list.add(30);
        list.add(10);
        list.add(40);
//        4.遍历集合
        for (Object obj:list) {
//            System.out.println(obj);
//            obj是集合中的元素，其本身应该是Integer类型的数据
            Integer i = (Integer)obj;
            System.out.println(i);
        }
        System.out.println("——————————");
        for (Object obj : list) {       //这里的obj与上面的obj无关联的，因为作用域不一样
            System.out.println(obj);
        }
    }
}

为什么需要迭代器？

对过程的重复，称为迭代。迭代器是遍历Collection（List\Set）集合的通用方式，可以在对集合遍历的同时进行添加、删除等操作

迭代器的常用方法

next():返回迭代的下一个元素对象

hasNext():如果仍有元素可以迭代，则返回true

案例演示：（使用迭代器遍历List集合）

package study5.demo;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
//注意：
//列表迭代器是List体系独有的遍历方式，可以在对象集合遍历的同时进行添加、删除等操作，但是必须通过调用列表迭代器的方法来实现
//总结：普通的迭代器在遍历集合的同时不能添加或者删除元素否则会报错：并发修改异常
//列表迭代器在遍历集合的同时可以修改集合中的元素（添加，删除等），必须使用列表迭代器中的方法
public class Test11 {
    public static void main(String[] args) {
//        案例演示：（使用迭代器遍历List集合）
//        1.创建集合对象
        List list = new ArrayList();
//        2.创建元素对象
//        3.将元素对象添加到集合对象中
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
//        4.遍历集合
//       迭代器的用法
//    1.根据集合对象获取其对象的迭代器对象
//        Iterator it = list.iterator();
    2.判断迭代器中是否有元素
//        while (it.hasNext()) {      //如果迭代器中有元素，就一直迭代（遍历）
//            //    3.如果有就获取元素
//            String s =(String)it.next();
//            System.out.println(s);
//        }
        System.out.println("————————————");
//        需求：判断集合中如果有字符串“b”，就在其后边添加一个新的字符串：java
        Iterator it = list.iterator();
        while (it.hasNext()) {
            String s =(String)it.next();
//            s开发小技巧:s是一个变量，是从迭代器中获取的。"b"是一个常量，一般在变量和常量进行比较时，会把常量写在前边，变量写在后面
//            "b"是一个常量，常量调用方法，即使方法里传一个none,也能规避空指针异常
//            s.equals("b")
            if ("b".equals(s)) {            //这样写可以规避空指针异常
//                能走到这里，说明s里面有元素b
//                list.add("java");           //报错：ConcurrentModificationException（并发修改异常）：在遍历集合的时候，又往集合添加，或者删除元素
            }
            System.out.println(s);
        }
    }
}

package study5.demo;

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

//需求：测试列表迭代器
public class Test12 {
    public static void main(String[] args) {
        //        1.创建集合对象
        List list = new ArrayList();
//        2.创建元素对象
//        3.将元素对象添加到集合对象中
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
//        需求：判断集合中如果有字符串“b”，就在其后边添加一个新的字符串：java
        //    1.根据集合对象获取其对象的迭代器对象
        ListIterator lit = list.listIterator();     //这里已经确定集合里面有多少个元素，所以集合中的数据不可以任意修改，除非通过列表迭代器阿里实现
        //    2.判断迭代器中是否有元素
        while (lit.hasNext()){
            //        3.有就获取元素即可
            String s =(String)lit.next();
            if ("b".equals(s)) {
//                list.add("java");       //报错ConcurrentModificationException
                lit.add("java");        //列表迭代器
            }
            System.out.println(s);
//是先遍历完了再加入java，所以java改为b的话，也不会出现无限循环
        }
        System.out.println("——————————");
        System.out.println(list);
    }
}

列表迭代器是List体系独有的遍历方式，可以在对象集合遍历的同时进行添加、删除等操作，但是必须通过调用列表迭代器的方法来实现

ConcurrentModificationException（并发修改异常）：在遍历集合的时候，又往集合添加，或者删除元素

总结：普通的迭代器在遍历集合的同时不能添加或者删除元素否则会报错：并发修改异常；列表迭代器在遍历集合的同时可以修改集合中的元素（添加，删除等），必须使用列表迭代器中的方法