集合和数组的区别
-
元素类型：
-
集合：引用类型（存储基本类型时自动装箱）
-
数组：基本类型、引用类型
-
-
元素个数：
-
集合：不固定，可以任意扩容
-
数组：固定，不能改变容量
-
-
集合的好处：不受容器大小限制，可以随时添加、删除元素，提供了大量操作元素的方法（判断、获取等）
Java的集合体系
-
单列集合（Collection）
List:
ArraryList
Set:
HashSet
-
双列集合（Map: Key，value）
Map:
HashMap
List集合
特点：可重复、有序（元素的存取顺序一致）
注意：List是接口，所以可以通过创建其子类ArrayList对象来完成该接口的实例化 List list = new ArrayList();
List接口中的成员方法：
-
public boolean add(E e);//将数据添加到集合的末尾，这里的E是泛型的意思，可以先理解为Object类型
-
public E get(int index);//根据索引，索取其对应的元素
-
public int size();//获取集合长度
使用集合的步骤：
-
创建集合对象
//需求：往 List 集合中添加3个学生对象，然后遍历
// 1. 创建集合对象
List list =new ArrayList(); -
创建元素对象
// 2. 创建元素对象
Student s1=new Student("s1",11);
Student s2=new Student("s1",11);
Student s3=new Student("s3",13);
Student s4=new Student("s4",14); -
将元素对象添加到集合对象中
// 3. 将元素对象添加到集合对象中
/*
boolean b1=list.add(s1);
System.out.println(b1);
*/
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(obj);
//获取集合中的元素个数
System.out.println(list.size());
// 4. 遍历集合
for(int i=0;i<list.size();i++){
// i表示的是集合中每个元素的索引
//获取元素
Object obj2=list.get(i);
System.out.println("索引为"+i+"的元素为"+obj2);
}
增强for循环和迭代器
增强for格式
for(元素的数据类型 变量名：要遍历的数组或者集合对象){
//循环体，变量也就是元素
}
快捷键：iter 回车
注意：增强for的底层依赖的是迭代器（Iterator）(增强for就是迭代器的简写形式)
对过程的重复，称为迭代。
迭代器是遍历Collection集合的通用方式。
迭代器（Iterator）的常用方法
-
E next()：返回迭代的下一个元素对象
-
boolean hasNext():如果仍有元素可以迭代，则返回true
//迭代器的使用方法
//1.根据集合对象获取其对象的迭代器对象
//2.判断迭代器中是否有元素
//3.如果有就获取元素
使用迭代器遍历 List 集合
//通过迭代器遍历 List集合
//1.创建集合对象
List list =new ArrayList();
//2.创建元素对象
//3.将元素对象添加到集合对象中
list.add("a");
list.add("b");
list.add("c");
//遍历集合
//迭代器的使用方法
//1.根据集合对象获取其对象的迭代器对象
Iterator it=list.iterator();
//2.判断迭代器中是否有元素
while(it.hasNext()){
//3.如果有就获取元素
String s=(String)it.next();
System.out.println(s);
}
}
注意：列表迭代器是List体系独有的遍历方式，可以在对集合遍历的同时进行添加、删除等操作，但是必须通过调用列表迭代器的方法来实现
//需求：判断集合中如果有字符串"b",就在其后边添加一个新的字符串：java
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
//1.根据集合对象获取列表迭代器对象
ListIterator lit = list.listIterator();
//2.判断迭代器中是否有元素
while (lit.hasNext()) {
//3.有就获取元素
String str = (String) lit.next();
if ("b".equals(str)) { //这样写可以规避 空指针异常
//能走到这儿，说明集合中有元素 b
lit.add("java");
}
System.out.println(str);
}
System.out.println(list);
}
总结：
1. 普通的迭代器在遍历集合的同时不能添加或者删除元素，否则会报：并发修改异常
2.列表迭代器在遍历集合的同时可以修改集合中的元素（添加、删除等），必须使用列表迭代器中的方法
泛型
定义：即泛指任意类型，又叫参数化类型(ParameterizedType），对具体类型的使用起到辅助作用，类似于方法的参数
集合类泛型的解释：表示该集合中存放指定类型的元素
//给 List 集合加上泛型String
List<String> list = new ArrayList<>();//表示该集合中只能添加字符串类型的数据
泛型的好处：类型安全、避免了类型的转换。泛型一般只和集合类相结合使用。
//演示泛型（JDK5开始）
List<String> list2 = new ArrayList<String>();//从JDK7开始，后面尖括号里的数据类型可以不写
list2.add("adv");
list2.add("kkk");
list2.add("honghong");
for (String s : list2) {
System.out.println(s);
}
}
Collections工具类
（针对集合进行操作的工具类）
成员方法：
-
sort(List<T>)：根据元素的自然顺序，将指定列表按升序排列
//对集合进行升序排列
Collections.sort(list);
System.out.println("对集合进行升序排列后的结果为："+list); -
max(Collection<T>)：返回集合的最大元素
//创建集合对象
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); -
reverse(List<T>)：反转List集合元素
//对集合中的数据进行反转
Collections.reverse(list);
System.out.println("集合反转后的结果为："+list); -
shuffle(List<T>)：使用默认的随机源随机置换指定的列表
//对集合进行随机置换
Collections.shuffle(list);
System.out.println("随机置换的结果为："+list);Set集合的特点和英语
Set集合的特点：不可重复、无序
应用：Set<T> set = new HashSet<>();
案例：向Set集合中添加五个元素，并遍历打印
分析：A. 向集合中添加元素的方法为：add();
B. 遍历集合的方式：迭代器
步骤：1. 创建集合对象：Set<Student> set = new HashSet<>();
2. 分别创建五个Student对象
3. 使用add方法将Student对象添加到集合中
4. 使用迭代器遍历集合并打印，注意添加顺序和打印顺序是否相同注意：因为Set集合保证元素的唯一性 依赖equals()和hashCode()两个方法。如果没有在自定义类中重写这两个方法，则默认调用的是Object类中的这两个方法，而Object类中的equals()方法默认比较的是地址值是否相同。
//1.创建集合对象
Set<Student> set=new HashSet<>();
//2.创建元素对象
Student s1=new Student("熊大",10);
Student s2=new Student("熊二",9);
Student s3=new Student("光头强",28);
Student s4=new Student("熊大",10);
Student s5=new Student("熊二",9);
//3.将元素对象添加到集合对象中
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
set.add(s5);
//4.遍历集合对象
//通过迭代器遍历 Set 集合
//A.通过集合对象获取其对应的迭代器对象
Iterator<Student> it = set.iterator();
//B.判断迭代器中是否有元素
while(it.hasNext()){
//C.如果有，就获取元素
Student s = it.next();
System.out.println(s);
}
System.out.println("-----------------------");
//通过增强 for 遍历 Set 集合
for (Student student : set) {
System.out.println(student);
}
}
Map集合的特点和应用
Map集合的特点
-
双列集合，元素由键值对（Entry）构成
key -- value
-
key不可以重复，value可以重复
应用：Map<T1,T2> map = new HashMap<>();
-
T1表示键的数据类型
-
T2表示值的数据类型
成员方法
-
V put(K key, V value): 添加元素（键值对的形式），元素第一次添加，返回null，重复添加，会用新值覆盖旧值，并返回旧值
-
V get(Object key): 根据键获取其对应的值
-
Set<K> keySet(): 获取所有键的集合
案例：向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并打印
//向Map集合中添加三个元素，并遍历打印
//1.创建集合对象
//键：学生的编号 值：具体的学生对象
Map<Integer,Student> map = new HashMap<>();
//2.创建元素对象
Student s1=new Student("王大",21);
Student s2=new Student("张三",22);
Student s3=new Student("李四",23);
//3.将元素对象添加到集合中
map.put(1,s1);
map.put(2,s2);
map.put(3,s3);
//4.遍历集合
//一、通过迭代器遍历集合
//4.1 获取所有键的集合
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(value);
}
/* //二、通过增强 for 遍历集合
//获取所有键的集合
Set<Integer> keys = map.keySet();
for (Integer key : keys) {
// key就是双列集合中的每一个键
Student value = map.get(key);
System.out.println(value);
}
}*/
