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

其他 2021-03-03 19:42:33 阅读次数: 0

迭代器

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

迭代器是遍历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);
    }
}

猜你喜欢

转载自blog.csdn.net/doudoutj/article/details/113726632
今日推荐
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
周排行
返回指定时间格式
fopen函数中的mode参数
Java 单例模式探讨
Flex remoteobject工作原理探讨
寻找mplayer的便捷安装方法
30天了解30种技术系列---(26)MySQL自动化运维工具Inception
关于Jboss/Tomcat/Jetty的JNDI定义123
程序减肥，strip，eu-strip 及其符号表
AsyncTask、View.post(Runnable)、ViewTreeObserver三种方式总结frame animation自动启动
Json和Bean的互相转换
每日归档
更多
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022