第29天学习打卡（迭代器、泛型 、Collection工具类、set集合的特点及应用、Map集合的特点及应用）
迭代器
对过程的重复，称为迭代。
迭代器是遍历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<T>)
根据元素的自然顺序，将指定列表按升序排序
max(Collection<T>)
返回集合的最大元素
reverse(List<T>)
反转List集合元素
suffle(List<T>)
使用默认的随机源随机置换指定的列表
需要用到哪个方法就把注释去掉进行使用 ：
- 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<>();
案例：Set集合的简单使用
需求：向Set集合中添加五个元素，并遍历打印
分析：
A.向集合中添加元素的方法:add()
B.遍历集合的方式:迭代器
步骤：
1.创建集合对象：
Set<Student> 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.创建集合对象：
- Map<Integer,Student> map = new HashMap<>();
2.分别创建三个Student对象
3.使用put方法将Student对象添加到集合中
4.获取所有的key，并使用迭代器遍历
5.通过key分别获取对应的value并打印
- 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(): 获取所有键的集合
*/
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);
}
}
第29天学习打卡（迭代器、泛型 、Collection工具类、set集合的特点及应用、Map集合的特点及应用）的更多相关文章
- java内部类、接口、集合框架、泛型、工具类、实现类
.t1 { background-color: #ff8080; width: 1100px; height: 40px } 一.内部类 1.成员内部类. (1)成员内部类的实例化: 外部类名.内部类 ...
- hibernate学习系列-----（9）hibernate对集合属性的操作之Map集合篇
照旧,先新建一个StudentMap.java实体类,将hobby属性使用map集合接口来存放: package com.joe.entity; import java.util.Map; publi ...
- Java基础学习总结(49)——Excel导入导出工具类
在项目的pom文件中引入 <dependency> <groupId>net.sourceforge.jexcelapi</groupId> <artifac ...
- 第28天学习打卡（Date和Calendar类 基本类型的包装类 集合 增强for循环 ）
Date和Calendar类 简介 日期和日历类,用于操作日期相关信息. 构造方法 Date(): 构造一个日期对象,当前系统时间,精确到毫秒. Date(long): 构造一个日期对象,时间为自&q ...
- mybatis学习笔记(二）-- 使用mybatisUtil工具类体验基于xml和注解实现
项目结构 基础入门可参考:mybatis学习笔记(一)-- 简单入门(附测试Demo详细过程) 开始体验 1.新建项目,新建类MybatisUtil.java,路径:src/util/Mybatis ...
- Android开发学习之路-Palette颜色提取工具类使用
视频(要FQ):https://www.youtube.com/watch?v=5u0dtzXL3PQ Palette是一个在support-v7包中的一个颜色提取工具类,用法比较简单,而且是谷歌官方 ...
- JavaScript学习系列博客_31_JavaScript Math 工具类
Math - Math属于一个工具类,它不需要我们创建对象(例如Date日期对象需要通过构造函数创建对象 var 变量=new Date(),Math不需要),它里边封装了属性运算相关的常量和方法 我 ...
- 黑马程序员——【Java基础】——泛型、Utilities工具类、其他对象API
---------- android培训.java培训.期待与您交流! ---------- 一.泛型 (一)泛型概述 1.泛型:JDK1.5版本以后出现的新特性,用于解决安全问题,是一个类型安全机制 ...
- Java基础---泛型、集合框架工具类：collections和Arrays
第一讲 泛型(Generic) 一.概述 1.JDK1.5版本以后出现的新特性.用于解决安全问题,是一个类型安全机制. 2.JDK1.5的集合类希望在定义集合时,明确表明你要向集合中装入那种类 ...
随机推荐
- 力扣1423. 可获得的最大点数-C语言
题目 题目链接 几张卡牌 排成一行,每张卡牌都有一个对应的点数.点数由整数数组 cardPoints 给出. 每次行动,你可以从行的开头或者末尾拿一张卡牌,最终你必须正好拿 k 张卡牌. 你的点数就是 ...
- WPF 之 依赖属性与附加属性（五）
一.CLR 属性 程序的本质是"数据+算法",或者说用算法来处理数据以期得到输出结果.在程序中,数据表现为各种各样的变量,算法则表现为各种各样的函数(操作符是函数的简记法). ...
- 2019牛客暑期多校训练营（第五场）I.three points 1(暴力几何)
题意:现在给你一个矩形边框 一个三角形的三边长 现在问你能否把三角形放入矩阵边框中 并且输出三个点的坐标 思路:我们可以发现如果一定有解 我们就可以让一个点在左下角(0,0)处 还有一个点在矩形边上 ...
- poj 1410 (没做出来，记得闲着没事看看这道题)
听说这道题是个大大的坑题 结果wa了十多发,,,,还是没找到原因 #include<cstdio> #include<cmath> #include<algorithm& ...
- C - Last Digit
Description The function f(n, k) is defined by f(n, k) = 1k + 2k + 3k +...+ nk. If you know the valu ...
- P1020 导弹拦截（LIS）
题目描述 某国为了防御敌国的导弹袭击,发展出一种导弹拦截系统.但是这种导弹拦截系统有一个缺陷:虽然它的第一发炮弹能够到达任意的高度,但是以后每一发炮弹都不能高于前一发的高度.某天,雷达捕捉到敌国的导弹 ...
- 牛客编程巅峰赛S1第5场 - 青铜&白银 B.完全平方数的尾巴 (暴力)
题意:有一个数\(x\),判断其是否能有某个完全平方数$mod$1000得到. 题解:直接写个for判断一下就好了,因为对1000取模,所以枚举到1000即可. 代码: class Solution ...
- 设计模式（二十一）——解释器模式(Spring 框架中SpelExpressionParser源码分析）
1 四则运算问题 通过解释器模式来实现四则运算,如计算 a+b-c 的值,具体要求 1) 先输入表达式的形式,比如 a+b+c-d+e, 要求表达式的字母不能重复 2) 在分别输入 a ,b, c, ...
- FZU2105 Digits Count（按位建线段树）题解
题意: 给出区间与.或.异或\(x\)操作,还有询问区间和. 思路: 因为数比较小,我们给每一位建线段树,这样每次只要更新对应位的答案. 与\(0\)和或\(1\)相当于重置区间,异或\(1\)相当于 ...
- 力扣485. 最大连续1的个数-C语言实现-简单题
题目 [题目传送门] 给定一个二进制数组, 计算其中最大连续1的个数. 示例 1: 输入: [1,1,0,1,1,1] 输出: 3 解释: 开头的两位和最后的三位都是连续1,所以最大连续1的个数是 3 ...