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

1
2
3
import java.util.ArrayList;
import java.util.List;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
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);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
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);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
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);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
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);
    }
}