- Collection
- List
- Set
- 泛型
- Map
- Collections
集合类体系结构
Collection集合概述和使用
Collection集合概述
- 是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素
- JDK不提供此接口的任何直接实现,它提供更具体的子接口(如Set和List)实现
创建Collection集合的对象
- 多态的方式
- 具体的实现类ArrayList
eg:
package Java;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo01 {
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);
}
}
终端:
[hello, world, java]
Collection集合常用方法
方法名 说明
boolean add(E e)
添加元素
boolean remove(Object o)
从集合中移除指定的元素
void clear()
清空集合中的元素
boolean contains(Object o)
判断集合中是否存在指定的元素
boolean isEmpty()
判断集合是否为空
int size()
集合的长度,也就是集合中元素的个数
eg:
package Java;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo02 {
public static void main(String[] args){
//创建集合对象
Collection<String> c=new ArrayList<String>();
//boolean add(E e):添加元素
System.out.println(c.add("hello"));
//输出集合对象
System.out.println(c);
}
}
终端:
true
[hello]
eg:
package Java;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo02 {
public static void main(String[] args){
//创建集合对象
Collection<String> c=new ArrayList<String>();
//boolean add(E e):添加元素
System.out.println(c.add("hello"));
System.out.println(c.add("world"));
//输出集合对象
System.out.println(c);
}
}
终端:
true
true
[hello, world]
eg:
package Java;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo02 {
public static void main(String[] args){
//创建集合对象
Collection<String> c=new ArrayList<String>();
//boolean add(E e):添加元素
System.out.println(c.add("hello"));
System.out.println(c.add("world"));
c.clear();
//输出集合对象
System.out.println(c);
}
}
终端:
true
true
[]
eg:
package Java;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo02 {
public static void main(String[] args){
//创建集合对象
Collection<String> c=new ArrayList<String>();
//boolean add(E e):添加元素
c.add("hello");
c.add("world");
System.out.println(c.contains("world"));
//输出集合对象
System.out.println(c);
}
}
终端:
true
[hello, world]
eg:
package Java;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo02 {
public static void main(String[] args){
//创建集合对象
Collection<String> c=new ArrayList<String>();
//boolean add(E e):添加元素
c.add("hello");
c.add("world");
System.out.println(c.isEmpty());
//输出集合对象
System.out.println(c);
}
}
终端:
false
[hello, world]
eg:
package Java;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo02 {
public static void main(String[] args){
//创建集合对象
Collection<String> c=new ArrayList<String>();
//boolean add(E e):添加元素
c.add("hello");
c.add("world");
c.clear();
System.out.println(c.isEmpty());
//输出集合对象
System.out.println(c);
}
}
终端:
true
[]
eg:
package Java;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo02 {
public static void main(String[] args){
//创建集合对象
Collection<String> c=new ArrayList<String>();
//boolean add(E e):添加元素
c.add("hello");
c.add("world");
System.out.println(c.size());
//输出集合对象
System.out.println(c);
}
}
终端:
2
[hello, world]
collection集合的遍历
Iterator:迭代器,集合的专用遍历方式
- Iterator iterator:返回此集合中元素的迭代器,通过集合的iterator()方法得到
- 迭代器是通过集合的iterator()方法得到的,所以我们说它是依赖于集合而存在的
Iterator中常用方法
- E next():返回迭代中的下一个元素
- boolean hasNext():如果迭代具有更多元素,则返回true
eg:
package Java;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionDemo02 {
public static void main(String[] args){
//创建集合对象
Collection<String> c=new ArrayList<String>();
c.add("hello");
c.add("world");
c.add("java");
Iterator<String> it=c.iterator();
System.out.println(it.next());
}
}
终端:
hello
eg:
package Java;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionDemo02 {
public static void main(String[] args){
//创建集合对象
Collection<String> c=new ArrayList<String>();
c.add("hello");
c.add("world");
c.add("java");
Iterator<String> it=c.iterator();
System.out.println(it.next());
System.out.println(it.next());
}
}
终端:
hello
world
eg:
package Java;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionDemo02 {
public static void main(String[] args){
//创建集合对象
Collection<String> c=new ArrayList<String>();
c.add("hello");
c.add("world");
c.add("java");
Iterator<String> it=c.iterator();
if(it.hasNext()){
System.out.println(it.next());
}
if(it.hasNext()){
System.out.println(it.next());
}
if(it.hasNext()){
System.out.println(it.next());
}
if(it.hasNext()){
System.out.println(it.next());
}
}
}
终端:
hello
world
java
eg:
package Java;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionDemo02 {
public static void main(String[] args){
//创建集合对象
Collection<String> c=new ArrayList<String>();
c.add("hello");
c.add("world");
c.add("java");
Iterator<String> it=c.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
终端:
hello
world
java
List
List集合概述
- 有序集合(也称为序列),用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素,并搜索列表中的元素
- 与Set集合不同,列表通常允许重复的元素
List集合特点
有序:存储和取出的元素顺序一致
可重复:存储的元素可以重复
List集合特有方法
方法名 说明
void add(int index,E element)
在此集合中的指定位置插入指定的元素
E remove(int index)
删除指定索引处的元素,返回被删除的元素
E set(index,E element)
修改指定索引处的元素,返回被修改的元素
E get(int index)
返回指定索引处的元素
案例:List集合存储学生对象并遍历
并发修改异常
并发修改异常
- ConcurrentModificationException
产生原因 - 迭代器遍历的过程中,通过集合对象修改了集合中元素的长度,造成了迭代器获取元素中判断预期修改值和实际修改值不一致
解决方案 - 用for循环遍历,然后用集合对象做对应的操作即可
Listlterator
Listlterator:列表迭代器
- 通过List集合的Listlterator()方法得到,所以说它是List集合特有的迭代器
- 用于允许程序员沿任一方向遍历列表的列表迭代器,在迭代期间修改列表,并获取列表中迭代器的当前位置
Listlterator中的常用方法
E next()
:返回迭代中的下一个元素boolean hasNext()
:如果迭代具有更多元素,则返回trueE previous()
:返回列表中的上一个元素boolean hasPrevious()
:如果此列表迭代器在相反方向遍历列表时具有更多元素,则返回truevoid add(E e)
:将指定的元素插入列表
eg:
package Java;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class ListIteratorDemo {
public static void main(String[] args){
//创建集合对象
List<String> list=new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("java");
ListIterator<String> lit=list.listIterator();
while(lit.hasNext()){
String s=lit.next();
System.out.println(s);
}
}
}
终端:
hello
world
java
增强for循环
增强for:简化数组和Collection集合的遍历
- 实现terable接口的类允许其对象称为增强型for语句的目标
- 它是JDK5之后出现的,其内部原理是一个lterator迭代器
增强for的格式:
for(元素数据类型 变量名: 数组或者Collection集合){
//在此处使用变量即可,该变量就是元素
}
范例:
int[] arr={1,2,3,4,5};
for(int i:arr){
System.out.println(i);
}
数据结构之栈和队列
常见数据结构之栈
栈是一种先进后出的模型
数据进入栈模型的过程称为:压/进栈
数据离开栈模型的过程称为:弹/出栈
常见数据结构之队列
数据从后端进入队列模型的过程称为:入队列
数据从前端离开队列模型的过程称为:出队列
队列是一种数据先进先出的模型
数据结构之数组和链表
常见数据结构之数组
查询数据通过索引定位,查询任意数据耗时相同,查询效率高
删除数据时,要将原始数据删除,同时后面每个数据前移,删除效率低
添加数据时,添加位置后的每个数据后移,再添加元素,添加效率极低
数组是一种查询快,增删慢的模型
常见数据结构之链表
存储一个数据A,保存在地址11位置
再存储一个数据C,保存在地址37位置
再存储一个数据D,保存在地址96位置
在数据AC之间添加一个数据B,保存在地址54位置
删除数据BD之间的数据C
查询数组D是否存在,必须从头(head)开始查询
查询第3个数据,必须从头(head)开始查询
链表是一种增删快的模型(对比数组)
链表是一种查询慢的模型(对比数组)
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()
从此列表中删除并返回最后一个元素
eg:
package Java;
import java.util.LinkedList;
public class LinkedListDemo{
public static void main(String[] args){
//创建集合对象
LinkedList<String> linkedList=new LinkedList<String>();
linkedList.add("hello");
linkedList.add("world");
linkedList.add("java");
linkedList.addFirst("javase");
linkedList.addLast("JVM");
System.out.println(linkedList);
}
}
终端:
[javase, hello, world, java, JVM]
eg:
package Java;
import java.util.LinkedList;
public class LinkedListDemo{
public static void main(String[] args){
//创建集合对象
LinkedList<String> linkedList=new LinkedList<String>();
linkedList.add("hello");
linkedList.add("world");
linkedList.add("java");
linkedList.addFirst("javase");
linkedList.addLast("JVM");
System.out.println(linkedList);
System.out.println(linkedList.getFirst());
System.out.println(linkedList.getLast());
}
}
终端:
[javase, hello, world, java, JVM]
javase
JVM
eg:
package Java;
import java.util.LinkedList;
public class LinkedListDemo{
public static void main(String[] args){
//创建集合对象
LinkedList<String> linkedList=new LinkedList<String>();
linkedList.add("hello");
linkedList.add("world");
linkedList.add("java");
System.out.println(linkedList.removeFirst());
System.out.println(linkedList.removeLast());
System.out.println(linkedList);
}
}
终端:
hello
java
[world]
Set集合
Set集合概述和特点
Set集合特点
- 不包含重复元素的集合
- 没有带索引的方法,所以不能使用普通for循环遍历
哈希值
哈希值:是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
Object类中有一个方法可以获取对象的哈希值
public int hashCode():返回对象的哈希码值
对象的哈希值特点
- 同一个对象多次调用hashCode()方法返回的哈希值是相同的
- 默认情况下,不同对象的哈希值是不同的。而重写hashCode()方法,可以实现让不同对象的哈希值相同
HashSet集合概述和特点
HashSet集合特点
- 底层数据结构是哈希表
- 对集合的迭代顺序不作任何保证,也就是说不保证存储和取出的元素顺序一致
- 没有带索引的方法,所以不能使用普通for循环遍历
- 由于是Set集合,所以是不包含重复元素的集合
eg:
package Java;
import java.util.HashSet;
public class HashSetDemo {
public static void main(String[] args){
//创建集合对象
HashSet<String> hs=new HashSet<String>();
//添加元素
hs.add("hello");
hs.add("world");
hs.add("java");
//遍历
for(String s:hs){
System.out.println(s);
}
}
}
终端:
world
java
hello
HashSet集合保证元素唯一性源码分析
HashSet集合添加一个元素的过程:
HashSet集合存储元素:
要保证元素唯一性,需要重写hashCode()和equals()
常见数据结构之哈希表
哈希表
- JDK8之前,底层采用数组+链表实现,可以说是一个元素为链表的数组
- JDK8以后,在长度比较长的时候,底层实现了优化
LinkedHashSet集合概述和特点
LinkedHashSet集合特点
- 哈希表和链表实现的Set接口,具有可预测的迭代次序
- 由链表保证元素有序,也就是说元素的存储和取出顺序是一致的
- 由哈希表保证元素唯一,也就是说没有重复的元素
eg:
package Java;
import java.util.HashSet;
import java.util.LinkedHashSet;
public class HashSetDemo {
public static void main(String[] args){
//创建集合对象
HashSet<String> linkedHashSet=new LinkedHashSet<String>();
//添加元素
linkedHashSet.add("hello");
linkedHashSet.add("world");
linkedHashSet.add("java");
//遍历
for(String s:linkedHashSet){
System.out.println(s);
}
}
}
终端:
hello
world
java
eg:
package Java;
import java.util.HashSet;
import java.util.LinkedHashSet;
public class HashSetDemo {
public static void main(String[] args){
//创建集合对象
HashSet<String> linkedHashSet=new LinkedHashSet<String>();
//添加元素
linkedHashSet.add("hello");
linkedHashSet.add("world");
linkedHashSet.add("java");
linkedHashSet.add("world");
//遍历
for(String s:linkedHashSet){
System.out.println(s);
}
}
}
终端:
hello
world
java
TreeSet集合概述和特点
TreeSet集合特点
- 元素有序,这里的顺序不是指存储和取出的顺序,而是按照一定的规则进行排序,具体排序方式取决于构造方法
TreeSet():根据其元素的自然排序进行排序
TreeSet(Comparator comparator):根据指定的比较器进行排序 - 没有带索引的方法,所以不能使用普通for循环遍历
- 由于是Set集合,所以不包含重复元素的集合
eg:
package Java;
import java.util.TreeSet;
public class TreeSetDemo {
public static void main(String[] args){
//创建集合对象
TreeSet<Integer> ts=new TreeSet<Integer>();
ts.add(10);
ts.add(40);
ts.add(30);
ts.add(50);
ts.add(20);
for(Integer i:ts){
System.out.println(i);
}
}
}
终端:
10
20
30
40
50
eg:
package Java;
import java.util.TreeSet;
public class TreeSetDemo {
public static void main(String[] args){
//创建集合对象
TreeSet<Integer> ts=new TreeSet<Integer>();
ts.add(10);
ts.add(40);
ts.add(30);
ts.add(50);
ts.add(20);
ts.add(30);
for(Integer i:ts){
System.out.println(i);
}
}
}
终端:
10
20
30
40
50
自然排序Comparable的使用
- 存储学生对象并遍历,创建TreeSet集合使用无参构造方法
- 要求:按照年龄从小到大排序,年龄相同时,按照姓名的字母顺序排序
结论:
- 用TreeSet集合存储自定义对象,无参构造方法使用的是自然排序对元素进行排序的
- 自然排序,就是让元素所属的类实现Comparable接口,重写compareTo(To)方法
- 重写方法时,一定要注意排序规则则必须按照要求的主要条件和次要条件来写
比较器排序Comparator的使用
- 存储学生对象并遍历,创建TreeSet集合使用带参构造方法
- 要求:按照年龄从小到大排序,年龄相同时,按照姓名的字母顺序排序
结论:
- 用TreeSet集合存储自定义对象,带参构造方法使用的是比较器排序进行排序的
- 比较器排序,就是让集合构造方法接收Comparator的实现类对象,重写compare(To1,To2)方法
- 重写方法时,一定要注意排序规则则必须按照要求的主要条件和次要条件来写
泛型
泛型概述
泛型:是JDK5中引入的特性,它提供了编译时类型安全检测机制,该机制允许在编译时检测到非法的类型,它的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数
一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。那么参数化类型怎么理解呢?
顾名思义,就是将类型由原来的具体的类型参数化,然后在使用/调用时传入具体的类型
这种参数类型可以用在类、方法和接口中,分别被称为泛型类、泛型方法、泛型接口
泛型定义格式:
- <类型>:指定一种类型的格式。这里的类型可以看做是形参
- <类型1,类型2…>:指定多种类型的格式,多种类型之间用逗号隔开。这里的类型可以看成是形参
- 将来具体调用时候可以看成是实参,并且实参的类型只能是引用数据类型
泛型的好处:
- 把运行时期的问题提前到了编译期间
- 避免了强制类型转换
泛型类
泛型类的定义格式:
- 格式:修饰符 class 类名<类型>{}
- 范例:public class Generic{}
此处T可以随便写为任意标识,常见的如T、E、K、V等形式的参数常用于表示泛型
泛型方法
泛型方法的定义格式:
- 格式:修饰符 <类型> 返回值类型 方法名(类型 变量名){}
- 范例:public void show(T t){}
泛型接口
泛型接口的定义格式:
- 格式:修饰符 interface 接口名<类型>{}
- 范例:public interface Generic{}
类型通配符
为了表示各种泛型List的父类,可以使用类型通配符
- 类型通配符:<?>
- List<?>:表示元素类型未知的List,它的元素可以匹配任何的类型
- 这种带通配符的List仅表示它是各种泛型List的父类,并不能把元素添加到其中
如果我们不希望List<?>是任何泛型List的父类,只希望它代表某一类泛型List的父类,可以使用类型类型通配符的上限
- 类型通配符上限:<?extends 类型>
- List<?extends Number>:它表示的类型是Number或者其子类型
除了可以指定类型通配符的上限,我们也可以指定类型通配符的下限
- 类型通配符下限:<?super 类型>
- List<?super Number>:它表示的类型是Number或者其父类型
可变参数
可变参数又称参数个数可变,用作方法的形参出现,那么方法参数个数就是可变的
- 格式:修饰符 返回值类型 方法名(数据类型…变量名){}
- 范例:public static int sum(int…a){}
可变参数注意事项
- 这里的变量其实是一个数组
- 如果一个方法有多个参数,包含可变参数,可变参数要放在最后
可变参数的使用
Arrays工具类中有一个静态方法:
- public static List asList(T…a):返回由指定数组支持的固定大小的列表
- 返回的集合不能做增删操作,可以做修改操作
List接口中有一个静态方法:
- public static List of(E…elements):返回包含任意数量元素的不可变列表
- 返回的集合不能做增删改操作
Set接口中有一个静态方法:
- public static Set of(E…elements):返回一个包含任意数量元素的不可变集合
- 在给元素的时候,不能给重复的元素
- 返回的集合不能做增删操作,没有修改的方法
Map集合
Map集合概述
- Interface Map<K,V> K:键的类型;V:值的类型
- 将键映射到值的对象,不能包含重复的键;每个键可以映射到最多一个值
- 举例:学生的学号和姓名
20180101 小豫
20180102 小静
20180103 小晓
创建Map集合的对象
- 多态的形式
- 具体的实现类HashMap
eg:
package Java;
import java.util.HashMap;
import java.util.Map;
public class MapDemo {
public static void main(String[] args){
Map<String,String> map=new HashMap<String,String>();
map.put("20180101", "小豫");
map.put("20180102", "小静");
map.put("20180103", "小晓");
//输出集合对象
System.out.println(map);
}
}
终端:
{20180103=小晓, 20180102=小静, 20180101=小豫}
eg:
package Java;
import java.util.HashMap;
import java.util.Map;
public class MapDemo {
public static void main(String[] args){
Map<String,String> map=new HashMap<String,String>();
map.put("20180101", "小豫");
map.put("20180102", "小静");
map.put("20180103", "小晓");
map.put("20180103", "小可");
//输出集合对象
System.out.println(map);
}
}
终端:
{20180103=小可, 20180102=小静, 20180101=小豫}
Map集合的基本功能
方法名 说明
V put(K key,V value)
添加元素
V remove(Object key)
根据键删除键值对元素
void clear()
移除所有的键值对元素
boolean containsKey(Object key)
判断集合是否包含指定的键
boolean containsKey(Object value)
判断集合是否包含指定的值
boolean is Empty()
判断集合是否为空
int size()
集合的长度,也就是集合中键值对的个数
Map集合的获取功能
方法名 说明
V get(Object key)
根据键获取值
Set <K> keySet()
获取所有键的集合
Collection <V> values()
获取所有值的集合
Set<Map.Entry<K,V>>entrySet()
获取所有键值对对象的集合
eg:
package Java;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapDemo {
public static void main(String[] args){
Map<String,String> map=new HashMap<String,String>();
map.put("鱼皮", "上海");
map.put("落拓", "香港");
System.out.println(map.get("鱼皮"));
System.out.println(map.get("Mars"));
Set<String> keySet=map.keySet();
for(String key:keySet){
System.out.println(key);
}
Collection<String> values=map.values();
for(String value:values){
System.out.println(value);
}
}
}
终端:
上海
null
鱼皮
落拓
上海
香港
Collections
Collections概述和使用
Collections类的概述:
- 是针对集合操作的工具类
Collections类的常用方法: - public static <T extends Comparable<? super T>> void sort(List list):将指定的列表按升序排序
- public static void reverse (List <?> list):反转指定列表中元素的顺序
- public static void shuttle(List <?> list):使用默认的随机源随机排列指定的列表
eg:
package Java;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionDemo01 {
public static void main(String[] args){
List<Integer> list=new ArrayList<Integer>();
list.add(30);
list.add(20);
list.add(50);
list.add(10);
list.add(40);
Collections.shuffle(list);
System.out.println(list);
}
}
终端:
[30, 50, 10, 20, 40]