第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的集合类希望在定义集合时,明确表明你要向集合中装入那种类 ...
随机推荐
- 克鲁斯卡尔算法(Kruskal算法)求最小生成树
题目传送:https://loj.ac/p/10065 1.排序函数sort,任何一种排序算法都行,下面的示例代码中,我采用的是冒泡排序算法 2.寻源函数getRoot,寻找某一个点在并查集中的根,注 ...
- Codeforces Round #665 (Div. 2) D - Maximum Distributed Tree dfs贡献记录
题意: t组输入,每组数据中n个节点构成一棵树,然后给你n-1条边.给你一个m,然后给你m个k的素数因子,你需要给这n-1条边都赋一个权值,这n-1条边的权值之积应该等于k.如果k的素数因子数量小于n ...
- C. Table Decorations
time limit per test 1 second memory limit per test 256 megabytes input standard input output standar ...
- Toxophily HDU - 2298 三分+二分
代码+解析: 1 //题意: 2 //有一个大炮在(0,0)位置,为你可不可以把炮弹射到(x,y)这个位置 3 //题目给你炮弹初始速度,让你求能不能找出来一个炮弹射出时角度满足题意 4 //题解: ...
- AtCoder Beginner Contest 170 D - Not Divisible (数学)
题意:有一长度为\(n\)的数组,求该数组中有多少元素不能整除其它任一元素的个数. 题解:刚开始写了个分解质因数(我是傻逼),后来发现直接暴力枚举因子即可,注意某个元素出现多次时肯定不满足情况,再特判 ...
- Codeforces13C–Sequence （区间DP）
题目大意 给定一个含有N个数的序列,要求你对一些数减掉或者加上某个值,使得序列变为非递减的,问你加减的值的总和最少是多少? 题解 一个很显然的结果就是,变化后的每一个值肯定是等于原来序列的某个值,因为 ...
- 数据分析常用库(numpy，pandas，matplotlib，scipy)
概述 numpy numpy(numeric python)是 python 的一个开源数值计算库,主要用于数组和矩阵计算.底层是 C 语言,运行效率远高于纯 python 代码.numpy主要包含2 ...
- Leetcode（144）-二叉树的前序遍历
给定一个二叉树,返回它的 前序 遍历. 示例: 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,2,3] 进阶: 递归算法很简单,你可以通过迭代算法完成吗? 二叉树的前序遍历有递归 ...
- HDU 4336 Card Collector（状压 + 概率DP 期望）题解
题意:每包干脆面可能开出卡或者什么都没有,一共n种卡,每种卡每包爆率pi,问收齐n种卡的期望 思路:期望求解公式为:$E(x) = \sum_{i=1}^{k}pi * xi + (1 - \sum_ ...
- ysoserial Commons Collections3反序列化研究
0x00 前言 在ysoserial中,官方是没给gadget,这儿经过文章分析我认为的gadget,继承自AbstractTranslate的类被Javassist插桩后返回一个被修改过的templ ...