迭代器
对过程的重复，称为迭代。
迭代器是遍历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);
}
}