第29天学习打卡（迭代器、泛型 、Collection工具类、set集合的特点及应用、Map集合的特点及应用）

于 2021-02-06 15:38:47 发布
阅读量91 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/doudoutj/article/details/113726632
版权

迭代器

对过程的重复，称为迭代。

迭代器是遍历Collection集合的通用方式，可以在对集合遍历的同时进行添加、删除等操作。

迭代器的常用方法

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

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

package cn.itcast.demo12;
/*
迭代器：
   概述：
      对过程的重复，称为迭代。
      迭代器是遍历Collection集合的通用方式。
迭代器的常用方法：
           E next():返回迭代的下一个元素对象
           boolean hasNext():如果仍有元素可以迭代，则返回true
   注意：列表迭代器是List体系独有的遍历方式，可以在对集合遍历的同时进行添加，删除等操作。
        但是必须通过调用列表迭代器的方法来实现。

   使用步骤：
         1.根据集合对象获取其对象的迭代器对象
         2.判断迭代器中是否有元素
         3.如果有就获取对象


 */

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

public class Test {
    public static void main(String[] args) {
        //需求：通过迭代器遍历List集合。
        //1.创建集合对象
        List list = new ArrayList();

        //2.创建元素对象
        //3.将元素对象添加到集合对象中
        list.add("a");
        list.add("b");
        list.add("c");

        //4.遍历集合
        //迭代器的用法
        //1.根据集合对象获取其对象的迭代器对象
        Iterator it = list.iterator();
        //2.判断迭代器中是否有元素
        while (it.hasNext()) {
            //如果迭代器中有元素，就一直迭代
            //因为迭代器中都是字符，所以Object向下转形
            //3.如果有就获取对象
            String s = (String) it.next();
            System.out.println(s);
        }
       
        

    }
}


package cn.itcast.demo12;
/*
迭代器：
   概述：
      对过程的重复，称为迭代。
      迭代器是遍历Collection集合的通用方式。
迭代器的常用方法：
           E next():返回迭代的下一个元素对象
           boolean hasNext():如果仍有元素可以迭代，则返回true
   注意：列表迭代器是List体系独有的遍历方式，可以在对集合遍历的同时进行添加，删除等操作。
        但是必须通过调用列表迭代器的方法来实现。

   使用步骤：
         1.根据集合对象获取其对象的迭代器对象
         2.判断迭代器中是否有元素
         3.如果有就获取对象
   总结：
       普通的迭代器在遍历集合的同时不能添加或者删除元素，否则会报错：并发修改异常
       列表迭代器在遍历集合的同时可以修改集合中的元素（添加，删除等），必须使用列表迭代器中的方法


 */

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

public class Test {
    public static void main(String[] args) {
        //需求：通过迭代器遍历List集合。
        //1.创建集合对象
        List list = new ArrayList();

        //2.创建元素对象
        //3.将元素对象添加到集合对象中
        list.add("a");
        list.add("b");
        list.add("c");

        //4.遍历集合
        //迭代器的用法


        //需求：判断集合中如果有字符串“b”,就在其后边添加一个新的字符串：java
        //1.根据集合对象获取其对象的迭代对象
        Iterator it = list.iterator();
        //2.判断迭代器中是否有元素
        while (it.hasNext()) {
            //如果迭代器中有元素，就一直迭代

            //3.如果有就获取元素
            String s = (String)it.next();
            if("b".equals(s)) {//"b"常量 s：变量  这样写可以规避：空指针异常
                //能走到这里，说明集合中有元素b
               // list.add("java");//这样写不行，会报ConcurrentModificationException（并发修改异常）
            }
            System.out.println(s);
        }

    }
}


package cn.itcast.demo12;

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

public class Test1 {
    public static void main(String[] args) {
        //需求：通过迭代器遍历List集合。
        //1.创建集合对象
        List list = new ArrayList();

        //2.创建元素对象
        //3.将元素对象添加到集合对象中
        list.add("a");
        list.add("b");
        list.add("c");
        //需求：判断集合中如果有字符串“b”,就在其后边添加一个新的字符串：java
        //1.根据集合对象获取列表迭代器对象
       ListIterator lit = list.listIterator();
        //2.判断迭代器中是否有元素
        while(lit.hasNext()) {
            //3.有就获取元素即可
            String s = (String)lit.next();
            if("b".equals(s)){
                //list.add("java");//这样写不行，必须调用列表迭代器的方法来实现
                lit.add("java");

            }
            System.out.println(s);
        }
        System.out.println("=================");
        //打印新的集合的值
        System.out.println(list);
    }
}

泛型简介

泛型：

​ 即指任意类型，又叫参数化类型（ParameterizedType）,对具体类型的使用起到辅助作用，类似于方法参数。

集合类泛型的解释：

​ 表示该集合中存放指定类型的元素

  #### 案例演示（给List集合加上泛型String）

List<String> list = new ArrayList<>();
泛型的好处

​ 类型安全

​ 避免了类型转换

package cn.itcast.demo13;
/*
泛型：
   概述：
       即泛指任意类型，又叫参数化类型（ParameterizedType）,对具体类型的使用起到辅助作用，类似于方法的参数。

       集合类泛型的解释：
              表示该集合中存放指定类型的元素

        好处：
           类型安全
           避免了类型转换

    总结：
        泛型一般只和集合类相结合使用
        泛型是JDK5的新特性，但是从JDK7开始，后边的泛型可以不用写具体的数据类型（菱形泛型）
 */

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

public class Test {
    public static void main(String[] args) {
        //不使用泛型的集合
        //1.创建集合对象
        List list1 = new ArrayList();
        //2.创建元素对象
        //3.将元素对象添加到集合对象中
        list1.add("a");
        list1.add("b");
        list1.add("c");
        //list1.add(10);//会报类型转换异常ClassCastException
        
        //4.遍历集合
        for (Object obj : list1) {
            String s = (String)obj;
            System.out.println(s);
            
        }
        System.out.println("=======================");
        //需求：演示泛型
        //1.创建集合对象
        List<String> list2 = new ArrayList<>();
        //2.创建元素对象
        //3.将元素对象添加到集合对象中
        list2.add("abc");
        list2.add("bcd");
        list2.add("cde");

        //遍历集合
        for (String s : list2) {
            System.out.println(s);
            
        }

    }
}

Collection工具类

简介：

​ 针对集合操作的工具类

成员方法

sort(List)

​ 根据元素的自然顺序，将指定列表按升序排序

max(Collection)

​ 返回集合的最大元素

reverse(List)

​ 反转List集合元素

suffle(List)

​ 使用默认的随机源随机置换指定的列表

需要用到哪个方法就把注释去掉进行使用 ：

package cn.itcast.demo14;
/*
Collections:
      概述：
         针对集合进行操作的工具类
      成员方法：
         max(Collection<T>):  返回集合的最大元素
         sort(List<T>):        根据元素的自然顺序，将指定列表按升序排序
         reverse(List<T>):     反转List集合元素
         shuffle(List<T>):     使用默认的随机置换指定的列表


 */

import com.sun.xml.internal.bind.v2.runtime.reflect.Lister;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        //创建集合对象
        List<Integer> list = new ArrayList<>();
        //往集合中添加数据
        list.add(1);
        list.add(3);
        list.add(3);
        list.add(5);
        list.add(2);
        list.add(2);
        list.add(4);
        //打印集合
        System.out.println("没有操作以前，集合中的数据是:" + list);
        System.out.println("=====================");

        //获取集合中的最大元素
        Integer max = Collections.max(list);
        System.out.println("集合中的最大元素为:" + max);
        System.out.println("=================================");

        //对集合进行升序排列
       /* Collections.sort(list);
        System.out.println("升序排列后的结果为:" + list);
        System.out.println("======================");

        //对集合中的数据进行反转
        Collections.reverse(list);
        System.out.println("反转以后集合中的数据为:" + list);*/

        //需求：对集合中的数据进行降序排列

        //先对集合中的数据进行：升序排列
       /* Collections.sort(list);
        //然后反转集合中的元素
        Collections.reverse(list);
        System.out.println("降序后的结果为:" + list);*/

        //随机置换，相当于洗牌
        Collections.shuffle(list);
        System.out.println("随机置换后的结果为:" + list);

    }
}

Set 集合的特点和应用

Set集合的特点

不可重复、无序

应用
Set<T> set = new HashSet<>();

image-20210206095744593

案例：Set集合的简单使用

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

分析：

​ A.向集合中添加元素的方法:add()

​ B.遍历集合的方式:迭代器

步骤：

​ 1.创建集合对象：

​ Set set = new HashSet<>();

​ 2.分别创建五个Student对象

​ 3.使用add方法将Student对象添加到集合中

​ 4.使用迭代器遍历集合并打印，注意添加顺序和打印顺序是否相同

package cn.itcast.demo15;
/*
单列集合（Collection）之Set集合；
     特点：
        无序（元素的存取顺序不一致），唯一


  结论：
     Set集合保证元素的唯一性依赖：equals(),hashCode()两个方法
 */

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class Test {
    public static void main(String[] args) {
        //需求：往set集合中添加5个学生对象，然后遍历。
        //1.创建集合对象
        Set<Student> set = new HashSet<>();
        //2.创建元素对象
        Student s1 = new Student("乔峰",40);
        Student s2 = new Student("虚竹",38);
        Student s3 = new Student("段誉",26);
        Student s4 = new Student("乔峰",40);
        Student s5 = new Student("虚竹",38);
        //3.将集合对象添加到元素对象中
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);
        //4.遍历集合
        /*
        为什么Set集合没有”去重“？
            因为Set集合保证元素的唯一性依赖：equals()和hashCode()两个方法
            没有在Student类中重写这两个方法，默认调用的是Object类中的这两个方法
            俩Object类中的equals()方法默认比较的是地址值是否相同


        解决方案：
               在Student类中重写equals()和hashCode()方法
         */
        System.out.println(set);
        System.out.println("============");

        System.out.println("通过迭代器实现");
        //A 通过迭代器遍历Set集合
        Iterator<Student> it = set.iterator();
        //B判断迭代器中是否有元素
        while (it.hasNext()) {
            //c如果有，就获取元素
            Student s = it.next();
            System.out.println(s);
        }
        System.out.println("==================");

        //通过for遍历Set集合
        System.out.println("通过增强for循环遍历Set集合");
        for (Student student : set) {
            System.out.println(student);

        }


    }
}


package cn.itcast.demo15;

import java.util.Objects;

//学生类
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 +
                '}';
    }

    @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);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

Map集合的特点和应用

Map集合的特点

特点：

双列集合，元素由键值对(Entry)构成：

​ key—value

key不可以重复，value可以重复

应用：

Map<T1,T2> map = new HashMap<>();

案例：Map集合的简单使用

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

分析：

​ A.向map集合中添加元素的方法为:put()

​ B.遍历集合的方式：

​ 获取所有的key:keySet()

​ 遍历keySet,通过key获取value:get()

​ C.遍历keySet的方法：iterator()

步骤：

​ 1.创建集合对象：

         ```java

Map<Integer,Student> map = new HashMap<>();
```

​ 2.分别创建三个Student对象

​ 3.使用put方法将Student对象添加到集合中

​ 4.获取所有的key，并使用迭代器遍历

​ 5.通过key分别获取对应的value并打印

```java

package cn.itcast.demo16;
/*
Map集合的特点
特点：
双列集合，元素由键值对（Entry）构成
key(键)----value(值)
注意：
键（key）不可以重复，值（value）可以重复
应用：
Map<T1,T2> map = new HashMap<>();
解释：
T1:表示键的数值类型
T2：表示值的数值类型
成员方法：
V put(K key, V value):添加元素（键值对的形式） 元素第一次添加，返回null,重复添加，会用新值覆盖旧值，并返回就旧值
V set(Object key):根据键获取对应的值
Set keySet(): 获取所有键的集合
*/

import java.util.HashMap;
import java.util.Map;

public class Test {
public static void main(String[] args) {
//需求：往Map集合中添加3个学生对象，然后打印
//1.创建集合对象
//键：学生的编号 值：具体的学生对象
Map<Integer,Student> map = new HashMap<>();

    //2.创建元素对象
    Student s1 = new Student("张三",21);
    Student s2 = new Student("李四",24);
    Student s3 = new Student("张三",21);

    //3.将元素对象添加到集合中
    Student stu1 = map.put(1,s1);
    System.out.println("stu1: " + stu1);
    Student stu2 = map.put(1,s2);
    System.out.println("stu2:" + stu2);

    //打印集合
    System.out.println(map);
    //4.遍历集合
}

}

```

​ 输出结果：

stu1: null
stu2:Student{name=‘张三’, age=21}
{1=Student{name=‘李四’, age=24}}

Process finished with exit code 0

迭代器获取
package cn.itcast.demo16;
/*
Map集合的特点
        特点：
             双列集合，元素由键值对（Entry）构成
             key(键)----value(值)
        注意：
             键（key）不可以重复，值（value）可以重复
        应用：
             Map<T1,T2> map = new HashMap<>();
        解释：
             T1:表示键的数值类型
             T2：表示值的数值类型
        成员方法：
              V put(K key, V value):添加元素（键值对的形式） 元素第一次添加，返回null,重复添加，会用新值覆盖旧值，并返回就旧值
              V set(Object key):根据键获取对应的值
              Set<K> keySet(): 获取所有键的集合

         遍历步骤：
             1.获取所有键的集合    keySet()
             2.遍历所有的键，获取到每一个键。 通过 迭代器 或者增强for获得
             3.根据键，获取指定的值。get()
 */

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Test {
    public static void main(String[] args) {
        //需求：往Map集合中添加3个学生对象，然后打印
        //1.创建集合对象
        //键：学生的编号  值：具体的学生对象
        Map<Integer,Student> map = new HashMap<>();

        //2.创建元素对象
        Student s1 = new Student("张三",21);
        Student s2 = new Student("李四",24);
        Student s3 = new Student("张三",21);

        //3.将元素对象添加到集合中
        /*Student stu1 = map.put(1,s1);
        System.out.println("stu1: " + stu1);
        Student stu2 = map.put(1,s2);
        System.out.println("stu2:" + stu2);*/
        map.put(1,s1);
        map.put(2,s2);
        map.put(3,s3);
        //根据键获取值
        Student stu3 = map.get(3);
        System.out.println("key" + 3 +",value:" + stu3);

        //打印集合
        System.out.println(map);
        //4.遍历集合
       // 4.1.获取所有键的集合    keySet()
        Set<Integer> keys = map.keySet();
        //4.2.遍历所有的键，获取到每一个键。 通过 迭代器 或者增强for获得
        Iterator<Integer> it = keys.iterator();
        while (it.hasNext()){
            //如果迭代器中有数据，就获取
            Integer key = it.next();

            //4.3.根据键，获取指定的值。get()
            Student value = map.get(key);
            System.out.println("key" + key + "...value" + value);
        }

    }
}

增强for

package cn.itcast.demo16;
/*
Map集合的特点
        特点：
             双列集合，元素由键值对（Entry）构成
             key(键)----value(值)
        注意：
             键（key）不可以重复，值（value）可以重复
        应用：
             Map<T1,T2> map = new HashMap<>();
        解释：
             T1:表示键的数值类型
             T2：表示值的数值类型
        成员方法：
              V put(K key, V value):添加元素（键值对的形式） 元素第一次添加，返回null,重复添加，会用新值覆盖旧值，并返回就旧值
              V set(Object key):根据键获取对应的值
              Set<K> keySet(): 获取所有键的集合

         遍历步骤：
             1.获取所有键的集合    keySet()
             2.遍历所有的键，获取到每一个键。 通过 迭代器 或者增强for获得
             3.根据键，获取指定的值。get()
 */

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Test {
    public static void main(String[] args) {
        //需求：往Map集合中添加3个学生对象，然后打印
        //1.创建集合对象
        //键：学生的编号  值：具体的学生对象
        Map<Integer,Student> map = new HashMap<>();

        //2.创建元素对象
        Student s1 = new Student("张三",21);
        Student s2 = new Student("李四",24);
        Student s3 = new Student("张三",21);

        //3.将元素对象添加到集合中
        /*Student stu1 = map.put(1,s1);
        System.out.println("stu1: " + stu1);
        Student stu2 = map.put(1,s2);
        System.out.println("stu2:" + stu2);*/
        map.put(1,s1);
        map.put(2,s2);
        map.put(3,s3);
        //根据键获取值
        Student stu3 = map.get(3);
        System.out.println("key" + 3 +",value:" + stu3);

        //打印集合
        System.out.println(map);
        //通过增强for实现
        //获取所有的键
        Set<Integer> keys = map.keySet();
        for (Integer key:keys){
            //key就是双列集合中的每一个键
            Student value = map.get(key);
            System.out.println("value :" + value);

        }

    }
}


package cn.itcast.demo16;

import java.util.Objects;

//学生类
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 +
                '}';
    }

    @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);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
doudoutj
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值