Java笔记_025_集合进阶
集合进阶
Collection
集合知识的回顾
集合类的特点:提供一种存储空间可变的存储模型,存储的数据容量可以随时发生改变
集合类体系结构
Collection集合的概述和使用
软件包java.util
Collection集合的概述
- 是单例集合的顶层接口,它表示一组对象,这些对象也被称为Collection的元素
- JDK不提供此接口的任何直接实现,它提供更具体的子接口(如Set和List)实现
创建Collection集合的对象
- 多态的方式
- 具体的实现类
ArrayList
import java.util.ArrayList;
import java.util.Collection;
public class Demo {
public static void main(String[] args) {
// 创建Collection集合的对象
Collection<String> c = new ArrayList<String>();
// 添加元素:boolean add (E e)
c.add("hello");
c.add("world");
c.add("java");
// 输出集合
System.out.println(c);
}
}
Collection集合常用方法
方法名 | 说明 |
---|---|
boolean add(E e) | 添加元素 |
boolean remove(Object o) | 从集合中移除指定元素 |
void clear() | 清空集合中的元素 |
boolean contains(Object o) | 判断聚合中是否存在指定元素 |
boolean isEmpty() | 判断集合是否为空 |
int size() | 集合的长度,也就是集合中元素的个数 |
Collection集合的遍历
iterator:
迭代器,集合的专用遍历方式
-
包:
java.util
-
iterator<E>iterator():
返回此集合中元素的迭代器,通过集合的iterator()
方法得到 -
迭代器是通过集合的
iterator()
方法得到的,所以我们说他是依赖于集合而存在的
iterator
中的常见方法
E next():
返回迭代中的下一个元素boolean hasNext():
如果迭代具有多个元素,则返回true
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo {
public static void main(String[] args) {
// 创建Collection集合的对象
Collection<String> c = new ArrayList<String>();
// 添加元素:boolean add (E e)
c.add("hello");
c.add("world");
c.add("java");
// 声明迭代器
Iterator<String> it = c.iterator();
// 遍历
while (it.hasNext()) {
// 判断是否有元素
String s = it.next();
System.out.println(s);
}
// 输出集合
System.out.println(c + " ");
}
}
List
List集合概述和特点
- 包
java.util
- 有序集合(也称为序列),用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素,并搜索列表中的元素
- 与Set不同,List通常允许重复元素
List集合的特点
- 有序:存储和取出的元素顺序一致
- 可重复:存储的元素可以重复
List集合特有的方法
方法名 | 说明 |
---|---|
void add(int index, E element) | 在次集合中的指定位置插入指定元素 |
E remove(int index) | 删除指定索引处的元素,并返回被删除的元素 |
E set(int index, E element) | 修改指定索引处的元素,返回被修改的元素 |
E get(int index) | 返回指定索引处的元素 |
并发修改异常
用迭代器的时候添加List中的值的时候会产生并发修改异常
可以用for循环避免发生这种结果
ListIterator
列表迭代器
-
包
java.util
-
通过List集合的
listIterator()
方法得来的,所以说它是集合特有的迭代器 -
用于允许程序员沿任意方向遍历列表的列表迭代器,在迭代期间修改列表,并获取列表中迭代器的当前位置
ListIterator
中常用的方法
E next():
返回迭代中的下一个元素boolean hasNext():
如果迭代具有更多元素则放会trueE previous():
返回列表中的上一个元素boolean hasprevious():
如果次列表迭代器在相反方向遍历列表时具有更多元素,则返回truevoid add(E e):
将指定的元素插入到列表
增强for循环
增强for:简化数组和Collection集合的遍历
- 实现Iterator接口的类允许其对象成为增强型for语句的目标
- 他是JDK5之后出现的,其内部原理是一个Iterator迭代器
增强for的格式:
for (元素数据类型 变量名: 数组或者Collection集合) {
// 在此使用变量即可,变量就是元素
}
范例
int[] arr = {1,2,3,4,5};
for (int i : arr) {
System.out.println(i);
}
List集合子类特点
List集合的常用集合:ArrayList
和LinkedList
ArrayList
:底层的数据结构是数组,查询快,增删慢LinkedList
:底层的数据结构是链表,查询慢,增删快
LinkedList
集合的特有功能
方法名 | 说明 |
---|---|
public void addFirst(E e) | 从该列表开头插入指定元素 |
public void addLast(E e) | 将指定元素追加到此列表的末尾 |
public E getFirst() | 返回该列表的第一个元素 |
public E getLast() | 返回该列表的最后一个元素 |
public E removeFirst() | 从此列表中删除并返回第一个元素 |
public E removeLast() | 从此列表中删除并返回最后一个元素 |
Set
Set集合的概述和特点
Set集合的特点:
- 不包含重复元素的集合
- 没有带索引的方法,所以不能使用普通for循环遍历
- 继承与Collection集合类,所以Collection里的方法它都可以使用
哈希值
-
是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
-
Object
类中有一个方法可以获取到对象的哈希值-
public int hashCode(); // 获取对象的哈希值码 Student s1 = new Student(); // 同一个对象多次调用hashCode()方法返回的值是相同的 int h1 = s1.hashCode(); int h2 = s1.hashCode(); Student s2 = new Student(); // 默认情况下,不同对象的哈希值是不一样的,但是通过方法重写,可以实现不同对象的哈希值一样 int h3 = s2.hashCode(); // h1 == h2 != h3
-
HashSet集合概述和特点
HashSet集合特点:
- 底层数据结构是哈希表
- 对集合的迭代是顺序不做任何保障,也就是说不保证存储和取出的元素顺序是一致的
- 没有代索引的方法,所以不能使用普通for循环来遍历
- 由于是Set集合,所以是不包含重复元素的集合
常见数据结构之哈希表
- JDK8之前,底层采用的是数组+链表实现,可以说是一个元素为链表的数组
- JDK8之后,在长度比较长的时候,底层实现了优化
LinkedHashSet
集合的概述和特点
包:java.util
LinkedHashSet
集合的特点
- 哈希表和链表实现的Set接口,具有可预测的迭代次序
- 由链表保证元素有序,也就是说元素的存储和取出的顺序是一致的
- 由哈希表保证元素唯一,也就是说没有重复的元素
TreeSet
集合的概述和特点
包:java.util
TreeSet
集合的特点
- 元素有序,这里的有序不是指存储和取出的顺序,而是按照一定的规则进行排序,具体方式取决于构造方法
TreeSet()
:根据其元素的自然排序进行排序TreeSet(Comparator comparator)
:根据指定的比较器进行排序
- 没有带索引的方法,所以不能用普通for进行循环遍历
- 由于是Set集合,所以不包含重复元素的集合
自然排序Comparable
的使用
- 存储学生对象并遍历,创建
TreeSet
集合使用无参构造方法 - 要求:按照年龄大小从大到小排序,年龄相同的时候,按照姓名的字母顺序排序
public class Student implements Comparable<Student>{
private String name;
private int age;
// 重写方法
public int compareTo(Student s) {
int num = this.age - s.age;
int num2 = num == 0 ? this.name.compareTo(s.name) : num;
return num2;
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {
}
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;
}
}
结论:
- 用
TreeSet
集合存储自定义对象,无参构造方法使用的是自然排序对元素进行排序的 - 自然排序,就是让元素所属的类实现
Comparable
接口,重写CompareTo(T o)
方法 - 重写方法时,一定要注意排序规则必须按照要求的主要条件和次要条件来写
比较器排序Comparator
的用法
- 存储学生对象并遍历,创建
TreeSet
集合使用带参构造方法 - 要求:按照年龄从小到大排序,年龄一样时,按照姓名的字母顺序排序
import java.util.Comparator;
import java.util.TreeSet;
public class Demo {
public static void main(String[] args) {
TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
int num = s1.getAge() - s2.getAge();
int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
return num2;
}
});
}
}
结论:
- 用
TreeSet
集合存储自吨车对象,带参构造方法使用的是比较器排序对元素进行排序的 - 比较器排序,就是让集合构造方法接受
Comparetor
的实现类对象,重写compareTo(T o1, T o2)
方法 - 重写方法时,一定要注意排序规则必须按照要求的主要条件和次要条件来写
泛型
泛型概述
- 泛型是JDK5中引入的特性,它提供了编译时类型安全检测机制,该机制允许在编译时检测到非法的类型
- 它的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数
- 一提到参数,最熟悉的就是定义方法时有形参,然后调用该方法时传入实参。那么参数化类型该怎么理解呢?
- 顾名思义,就是将类型由原来的具体的类型参数化,然后在使用/调用的时候传入具体的类型
- 这种参数的类型可以用在类,方法和接口中,分别被称为泛型类,泛型方法,泛型接口
泛型定义格式:
<类型>
:指定一种类型的格式。这里要求的类型可以看成是形参<类型1, 类型2, ...>
:指定多种类型的格式,多种类型之间用逗号隔开。这里的类型可以看成是形参- 将来具体调用的时候给定的类型可以看成是实参,并且形参的类型只能是引用数据类型
泛型的好处:
- 把运行时期的问题提前到了编译期间
- 避免了强制类型转换
泛型类
泛型类的定义格式:
- 格式:
修饰符 class 类名<类型>{}
- 范例:
public class Generic<T>{}
- 此处的T可以顺便写为任意标识,常见的如T, E, K, V等形式的参数常用于标识泛型
public class Generic<T> {
public <T> void show(T t) {
System.out.println(t);
}
}
泛型方法
泛型方法的定义格式
- 格式:
修饰符 <类型> 方法名<类型 参数>{}
- 范例:
public <T> show(T t){}
public class Generic {
public <T> void show(T t) {
System.out.println(t);
}
}
泛型接口
泛型接口的定义格式:
- 格式:
修饰符 interface 接口名<类型>{}
- 范例:
public interface Generic<T>{}
类型通配符
为了表示各种泛型List的父亲,可以使用类型通配符
- 类型通配符:
<?>
List<?>
:表示元素类型未知的List,它的元素可以匹配任何的类型- 这种带通配符的List仅代表它是各种泛型List的父类,并不能把元素添加到其中
如果说我们不希望List<?>
是任何泛型List的父类,只希望它代表某一类泛型的List的父亲,可以使用类型通配符的上限
- 类型通配符的上限:
<? extends 类型>
Lis<? extends Number>
:它表示的类型是Number或者其子类型
除了可以指定类型通配符的上限,还可以指定类型通配符的下限
- 类型通配符的下限:
<? super 类型>
List<? super Number>
:它表示的类型是Number或者其父类型
可变参数
可变参数又称参数格式可变,用作方法的形参出现,那么方法参数个数就是可变的了
- 格式:
修饰符 返回值类型 方法名(数据类型...变量名){}
- 范例:
public static int sum(int...a){}
可变参数注意事项:
- 这里的变量其实是一个数组
- 如果一个方法有多个参数,包含可变参数,可变参数要放在最后
可变参数的使用
Arrays工具类中有一个静态方法:
public static <T> List<T> asList(T...a)
:返回由指定数组支持的固定大小的列表List<String> list = Arrays.asList("hello", "world", "java");
- 返回的集合不能做增删操作,可以做修改操作
List接口中有一个静态方法:
public static <E> List<E> of(E...elements)
:返回包含任意数量元素的不可变列表List<String> list = List.of("hello", "world", "java");
- 返回的集合不能做增删改操作
Set接口中有一个静态方法:
public static <E> Set<E> of(E...elements)
:返回包含一个任意数量元素的不可变集合Set<String> s = Set.of("hello", "world", "java");
- 在给元素的时候,不能给重复的元素
- 返回的集合不能做增删改操作,没有修改的方法
Map
Map集合概述和使用
Map集合概述
- Interface Map(K, V) K:键的类型;V:值的类型
- 将键映射到值的对象;不能包含重复的键;每个键可以映射到最多一个值
- 举例:学生的学号和姓名
创建Map集合的对象
- 多态的方式
- 具体的实现类HashSet
Map<String, String> map = new HashMap<String, String>();
Map集合的基本功能
方法名 | 说明 |
---|---|
V put(K key, V value) | 添加元素 |
V remove(Object key) | 根据键删除键值对元素 |
void clear() | 移除所有键值对元素 |
boolean containsKey(Object key) | 判断集合是否包含指定的键 |
boolean containsValue(Object value) | 判断集合是否包含指定的值 |
boolean isEmpty() | 判断集合是否为空 |
int size() | 集合的长度,也就是集合中键值对的个数 |
Map集合的获取功能
方法名 | 说明 |
---|---|
V get(Object key) | 根据键获取值 |
Set<K> keySet() | 获取所有键的集合 |
Collection<V> values() | 获取所有值的集合 |
Set<Map.Entry<K, V>> entrySet() | 获取所有键值对对象的集合 |
Map集合的遍历(方法一)
- 获取所有键的集合。用
keySet()
方法实现 - 遍历键的集合,获取每一个键。用
增强for
实现 - 根据键去找值。用
get(Object key)
方法实现
Map集合的遍历(方法二)
- 获取所有键值对对象的集合
Set<Map.Entry<K, V>> entrySet()
获取所有键值对对象的集合
- 遍历键值对对象的集合,得到每一个键值对对象
- 用
增强for
实现,得到一个Map.Entry
- 用
- 根据键值对对象获取键和值
getKey()
获取键getValue()
获取值
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("0001", "xxx");
map.put("0002", "yyy");
map.put("0003", "zzz");
Set<Map.Entry<String, String>> entrySet = map.entrySet();
for (Map.Entry<String, String> me : entrySet) {
String key = me.getKey();
String value = me.getValue();
System.out.println(key + "," + value);
}
}
}
Collections
Collections概述和使用
Collections类的概述:
- 是针对集合操作的工具类
Collections类的常用方法:
public static <T extends Comparable<? super T>> void sort(List<T> list)
:将指定的列表按升序排序public static void reverse(List<?> list)
:反转指定列表中元素的顺序public static void shuffle(List<?> list)
:使用默认的随机源排序指定的列表