集合简介
集合,简称集,是用来存储多个元素的容器。
集合和数组的区别:
java的集合体系:
单列集合(Collection):List:ArrayList、Set:HashSet
双列集合(Map:key, value):Map:HashMap
List集合的特点和应用
特点:可重复、有序(存取顺序相同)
应用: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 <list.size(); i++) {
Object obj2 = list.get(i);
System.out.println("索引为 " + i + "的元素是:" + obj2);
}
}
}
增强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<String> 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<Integer> 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<Student> 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<Student> 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<T1, T2> 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<Integer, Student> 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<Integer> keys = map.keySet();
//2. 遍历所有的键,获取到每一个键 迭代器,增强for
//获取迭代器对象
Iterator<Integer> 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);
}
}
}