第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的集合类希望在定义集合时,明确表明你要向集合中装入那种类 ...
随机推荐
- Jenkins（3）拉取git仓库代码，执行python自动化脚本
前言 python自动化的脚本开发完成后需提交到git代码仓库,接下来就是用Jenkins拉取代码去构建自动化代码了 新建项目 打开Jenkins新建一个自由风格的项目 源码管理 Repository ...
- ProBuilder快速原型开发技术 ---操作基础
本篇文章笔者对ProBuilder(以下简称:PB),进行操作基础的介绍. 一:PB大小图标显示方式 PB操作面板有两种显示方式:小图标与大图标.大图标优点是显示清晰操作方便,缺点是没有更加精确的参数 ...
- 2020 CCPC-Wannafly Winter Camp Day2
2020 CCPC-Wannafly Winter Camp Day2 A 托米的字符串 虽然每个子串出现的概率是相同的,但是同一长度的子串个数是不同的,所以要分别处理.计算出某一长度的情况下,元音字 ...
- 【noi 2.6_9281】技能树（DP）
题意:要求二叉树中每个节点的子节点数为0或2,求有N个节点高度为M的不同的二叉树有多少个(输出 mod 9901 后的结果). 解法:f[i][j]表示高度为i的有j个节点的二叉树个数.同上题一样,把 ...
- SQL Server 新安装启用sa用户/sa用户登录提示管道另一端无进程
安装时只用windows验证 安装完成后: 首先选中服务器(右键)->属性->安全性->服务器身份验证修改为"SQL SERVER和WINDOWS身份验证模式"其 ...
- LEETCODE - 1181【前后拼接】
class Solution { public: string gethead(string str){//获取头单词 string ret = ""; int strlen = ...
- ++i和i++的区别
它们两个的数值变化的区别,我这里就不多说了 这里主要说明两者在效率上的区别 (1)首先如果是自带的数据类型,比如int型,++i和i++,编译器的实现方式是相同的,两者并没有效率上的区别,虽然也有副本 ...
- mysql 查询,天,周,月等写法
1.查询当天的数据 select * from 表名 where TO_DAYS(时间字段)=TO_DAYS(NOW()); 2.查询当周的数据 select * from 表名 where YEAR ...
- BZOJ 3676 回文串（回文树）题解
题意: 一个回文的价值为长度 * 出现次数,问一个串中的子串的最大回文价值 思路: 回文树模板题,跑PAM,然后计算所有节点出现次数. 参考: 回文串问题的克星--Palindrome Tree(回文 ...
- codevs1068乌龟棋-四维DP，五维如何缩减一维
我们从起点x开始暴力枚举所有决策 于是可以得到如下转移 void dfs(int x,int A,int B,int C,int D,int y) { if (x==n) {ans=max(ans,y ...