集合简介List集合的特点和应用增强for循环和迭代器泛型简介Collections工具类Set集合的特点Map集合的特点和应用
集合简介集合，简称集，是用来存储多个元素的容器。
集合和数组的区别：
java的集合体系：
单列集合（Collection）:List：ArrayList、Set：HashSet
双列集合（Map：key, value）：Map：HashMap
特点：可重复、有序（存取顺序相同）
应用：List list = new ArrayList():
package com.collect;
import java.util.ArrayList;
import java.util.List;
public class test01 {
public static void main(String[] args) {
//使用集合的步骤：
//1. 创建集合对象 2. 创建元素对象 3.将元素对象添加到集合对象中 4.遍历集合对象
//往List集合中添加三个学生对象，然后遍历
//1. 创建集合对象
List list = new ArrayList();
//2. 创建元素对象
Student s1 = new Student("乔峰", 41);
Student s2 = new Student("乔峰", 41);
Student s3 = new Student("虚竹", 38);
Student s4 = new Student("段誉", 26);
//3. 将元素对象添加到集合对象中
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
//直接打印集合
System.out.println(list);
//获取索引为2的元素
Object obj = list.get(2);
System.out.println("索引为2的元素是：" + obj);
//获取集合中的元素个数
System.out.println("集合的长度为：" + list.size());
//4.遍历集合
for (int i = 0; i
增强for循环和迭代器
1.迭代器是遍历Collection集合的通用方式，可以在对集合遍历的同时进行添加、删除等操作。
2.迭代器的常用方法
next()：返回迭代的下一个元素对象
hasNext()：如果仍有元素可以迭代，则返回true
使用步骤：
1.根据集合对象获取其对象的迭代器对象；
2.判断迭代器中是否有元素
3.如果有就获取元素
package com.collect;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class test02 {
public static void main(String[] args) {
//通过迭代器遍历list集合
//创建集合对象
List list = new ArrayList();
//添加元素对象
list.add("a");
list.add("b");
list.add("c");
//迭代器遍历
//根据集合对象获取其对象的迭代器对象
Iterator it = list.iterator();
//判断迭代器中是否有元素
while (it.hasNext()) {
//如果有元素就获取
// Object obj = it.next();
// System.out.println(obj);
String s = (String)it.next();
// if ("b".equals(s)){ //这样写可以规避：空指针异常
// list.add("z"); //这样写不行，并发修改异常 需要使用列表迭代器
// }
System.out.println(s);
}
//使用列表迭代器修改list
//根据集合对象获取列表迭代器对象
ListIterator lit = list.listIterator();
//判断迭代器中是否有元素
while (lit.hasNext()) {
//获取元素
String s = (String)lit.next();
if ("b".equals(s)) {
lit.add("z");
}
System.out.println(s);
}
System.out.println("新集合的值:" + list); //新集合的值:[a, b, z, c]
}
}
列表迭代器是List体系独有的遍历方式，可以在对集合遍历的同时进行添加、删除等操作，但必须通过调用列表迭代器的方法来实现。
泛型简介
泛型即泛指任意类型，又叫参数化类型，对具体类型的使用起到辅助作用，类似于方法的参数。泛型一般只和集合类相结合使用。
例：集合类泛型，表示该集合中存放指定类型的元素。
好处：类型安全，避免了类型转换
例：List list = new ArrayList<>();
package com.collect;
import java.util.ArrayList;
import java.util.List;
public class test03 {
public static void main(String[] args) {
//正常
List list1 = new ArrayList();
list1.add("a");
list1.add("b");
list1.add("c");
for (Object obj : list1) {
String s = (String)obj;
System.out.println(s);
}
//泛型
List list2 = new ArrayList<>();
list2.add("abc");
list2.add("bcd");
list2.add("cde");
for (String s: list2) {
System.out.println(s);
}
}
}
Collections工具类
Collections工具类是针对集合进行操作的工具类。
成员方法：
sort(List)：根据元素的自然顺序，将指定列表按升序排序
max(Collection)：返回集合的最大元素
reverse(List)：反转list集合元素
shuffle(List)：使用默认的随机源随机置换指定的列表
package com.collect;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
public class test04 {
public static void main(String[] args) {
List list = new ArrayList<>();
list.add(1);
list.add(13);
list.add(3);
list.add(4);
list.add(1);
list.add(99);
//获取集合中的最大元素
int max = Collections.max(list);
System.out.println(max);
//升序排列
Collections.sort(list);
//反转
Collections.reverse(list);
//随机打乱
Collections.shuffle(list);
System.out.println(list);
}
}
Set集合的特点
特点：不可重复、无序
package com.collect;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class test05 {
public static void main(String[] args) {
//往set集合添加5个学生对象，然后遍历
//1. 创建集合对象
Set set = new HashSet<>();
//2.创建元素对象
Student s1 = new Student("乔峰", 41);
Student s2 = new Student("虚竹", 38);
Student s3 = new Student("段誉", 26);
Student s4 = new Student("乔峰", 41);
Student s5 = new Student("虚竹", 38);
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
set.add(s5);
System.out.println(set);
//打印出的结果并没有"去重"，因为equals() 和 hashCode() 两个方法没有在Student类里重写
//重写后打印出的结果只有三条
//迭代器遍历集合
Iterator it = set.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println(s);
}
//增强for遍历set集合 快捷键：iter
for (Student student : set) {
System.out.println(student);
}
}
}
Map集合的特点和应用
特点：双列集合，元素由键值对构成，键不可以重复，值可以重复应用：Map map = new HashMap<>();成员方法：
（1）V put(K key, V value)：添加元素（键值对的形式）；
（2）V get(Object key)：根据键获取其对应的值
（3）Set keySet()：获取所有键的集合
package com.collect;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class test06 {
public static void main(String[] args) {
//往Map集合中添加3个学生对象，然后打印
//1.创建集合对象
Map map = new HashMap<>();
//2.创建元素对象
Student s1 = new Student("张三", 23);
Student s2 = new Student("李四", 24);
Student s3 = new Student("张三", 23);
//3.将元素对象添加到集合中
map.put(1, s1);
map.put(2, s2);
map.put(3, s3);
System.out.println(map);
//根据键，获取值
Student stu3 = map.get(3);
System.out.println("key: " + 2 +", value: " + stu3);
//遍历集合
//1. 获取所有键的集合 keySet()
Set keys = map.keySet();
//2. 遍历所有的键，获取到每一个键 迭代器，增强for
//获取迭代器对象
Iterator it = keys.iterator();
while (it.hasNext()) {
Integer key = it.next();
//根据键获取值
Student value = map.get(key);
System.out.println("key: " + key + " value" + value);
}
//获取到所有键
for (Integer key: keys) {
Student value = map.get(key);
System.out.println("key: " + key + " value" + value);
}
}
}
