思维导图
一、Collection集合
1、集合体系结构
集合类的特点
提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变
集合类的体系图
2、Collection集合概述和使用
Collection集合概述
是接口（不能被实例化，只能梳理化它的子类），表示一组对象，对象也称为Collection的元素
重写了toString（）
一些Collection 允许有重复元素，一些Collection是有序（List）的（输入顺序为元素顺序）;Set 是无序的
JDK 不提供此接口的任何直接实现，提供更具体的子接口（如Set和List）实现
Collection集合基本使用
数组的缺点：长度固定，不可改变；无法求出真实有效数据个数；增删改查比较麻烦
3、Collection集合的常用方法
| 方法名 | 说明 |
|---|---|
| boolean add(E e) | 添加元素 |
| boolean remove(Object o) | 从集合中移除指定的元素 |
| void clear() | 清空集合中的元素 |
| boolean contains(Object o) | 判断集合中是否存在指定的元素 |
| boolean isEmpty() | 判断集合是否为空 |
| int size() | 集合的长度，也就是集合中元素的个数 |
public class CollectionDemo01 {
public static void main(String[] args) {
//创建Collection集合的对象
Collection<Student> c = new ArrayList<Student>();
collection c1 = new ArrayList();
//添加元素：boolean add(E e)
c.add("a");
c.add(stu);
c.addAll(c1)//将c中所有元素添加到c1中
//删除元素：boolean remove(Object o)
c.remove("a");
c.removeAll(c1)//删除c中c1中包含的所有元素
//检测c中是否包含某个指定对象：boolean contains(Object o)
c.contains("a")
c.contains(stu)
//检测集合中是否包含另一个集合的所有元素：boolean containsAll(Object o)
c.contains(c1)
//判断集合是否为空：boolean isEmpty()
c.isEmpty();
//清空集合void clear()
c.clear();
//迭代器:iterator()
iterator iter = c.interator();
//判断集合是否有下一个元素:iter.hasNext() :
while(iter.hasNext()){
String result=(String)iter.next();//取出下一个元素：iter.next();
}
//c中只保留c1的所有元素
c.retainAll(c1)
//获取当前集合之中元素的个数：int size()
c.size();
//将集合转换为数组：Object toArray();
Object[] cc = c.toArray()
//创建学生对象
Student stu=new Student("ww",23)
//输出集合对象
System.out.println(c);
}
}##
4、Collection集合的遍历
迭代器的介绍
迭代器，集合的专用遍历方式
Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的
Collection集合的遍历
//创建集合对象 Collection<String> c = new ArrayList<>(); //添加元素 c.add("hello"); c.add("world"); c.add("java"); c.add("javaee"); //Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到 Iterator<String> it = c.iterator(); //用while循环改进元素的判断和获取 while (it.hasNext()) { String s = it.next(); System.out.println(s); } } }
二、List集合
1、List集合概述和特点
List集合概述
有序集合(也称为序列)，用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素
与Set集合不同，列表通常允许重复的元素
List集合特点
有索引
可以存储重复元素
元素存取有序
2、List集合的特有方法
| 方法名 | 描述 |
|---|---|
| void add(int index,E element) | 在此集合中的指定位置插入指定的元素 |
| E remove(int index) | 删除指定索引处的元素，返回被删除的元素 |
| E set(int index,E element) | 修改指定索引处的元素，返回被修改的元素 |
| E get(int index) | 返回指定索引处的元素 |
import java.util.ArrayList;
import java.util.List;
public class Demo1 {
public static void main(String[] args) {
List l = new ArrayList();
List l1= new ArrayList();
// 添加元素
l.add("a");
l.add(2,"b");//添加到指定位置
l.addAll(l1);//添加l1到l
l.addAll(0,l1);//将l1添加到指定位置
//获取指定位置的元素
Object object=l.get(1);
//获取指定对象在集合中的位置(从集合开头往后找第一次出现指定对象的位置)：indexof()
int index=l.indexOf("a");
//获取指定对象在集合中的位置(从集合末尾开始往前找第一次出现指定对象的位置)：lastIndexof()
int index1=l.lastIndexOf("a");
//删除第一次出现位置的指定对象
l.remove("a");
l.remove(0);//删除指定索引的对象
//替换指定位置的元素
l.set(2,"c");
//截取从第0开始到第3-1个元素（左闭右开）
l.subList(0,3);
}
}3、List集合遍历
//迭代器方式
Iterator<Student> it = list.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println(s.getName() + "," + s.getAge());
}
System.out.println("--------");
//for循环方式
for(int i=0; i<list.size(); i++) {
Student s = list.get(i);
System.out.println(s.getName() + "," + s.getAge());
}List集合的实现类
1、List集合子类的特点
ArrayList集合
底层是数组结构实现，查询快、增删慢
LinkedList集合
底层是链表结构实现，查询慢、增删快
2、LinkedList集合的特有功能
特有方法
方法名 说明 public void addFirst(E e) 在该列表开头插入指定的元素 public void addLast(E e) 将指定的元素追加到此列表的末尾 public E getFirst() 返回此列表中的第一个元素 public E getLast() 返回此列表中的最后一个元素 public E removeFirst() 从此列表中删除并返回第一个元素 public E removeLast() 从此列表中删除并返回最后一个元素
LinkedList li=new LinkedList();
li.addFirst("a");//最开头添加
li.addLast("w");//最末尾添加
li.remove(1);
li.remove("a");
li.removeFirst();//从此列表中删除并返回第一个元素三、set集合
1、Set集合概述和特点
Set集合的特点
元素存取无序
没有索引、只能通过迭代器或增强for循环遍历
不能存储重复元素
//创建集合对象
Set set = new HashSet();
//添加元素
set.add("hello");
set.add("world");
set.add("java");
//不包含重复元素的集合
set.add("world");
//remove()不能根据索引删，只能根据内容删
set.remove("hello");
//遍历
for(String s : set) {
System.out.println(s);
}2、哈希值
哈希值简介
是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
如何获取哈希值
Object类中的public int hashCode()：返回对象的哈希码值
哈希值的特点
同一个对象多次调用hashCode()方法返回的哈希值是相同的
默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同
3、HashSet集合概述和特点
HashSet集合的特点
底层数据结构是哈希表
对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
没有带索引的方法，所以不能使用普通for循环遍历
由于是Set集合，所以是不包含重复元素的集合
HashSet集合的基本使用
//创建集合对象 HashSet<String> hs = new HashSet<String>(); //添加元素 hs.add("hello"); hs.add("world"); hs.add("java"); //遍历 for(String s : hs) { System.out.println(s); }
4、HashSet集合保证元素唯一性源码分析
HashSet集合保证元素唯一性的原理
1.根据对象的哈希值计算存储位置
如果当前位置没有元素则直接存入
如果当前位置有元素存在，则进入第二步
2.当前元素的元素和已经存在的元素比较哈希值
如果哈希值不同，则将当前元素进行存储
如果哈希值相同，则进入第三步
3.通过equals()方法比较两个元素的内容
如果内容不相同，则将当前元素进行存储
如果内容相同，则不存储当前元素
5、LinkedHashSet集合概述和特点
LinkedHashSet集合特点
哈希表和链表实现的Set接口，具有可预测的迭代次序
由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
由哈希表保证元素唯一，也就是说没有重复的元素
6、Set集合排序
TreeSet集合概述和特点
TreeSet集合概述
元素有序，可以按照一定的规则进行排序，具体排序方式取决于构造方法
TreeSet()：根据其元素的自然排序进行排序
TreeSet(Comparator comparator) ：根据指定的比较器进行排序
没有带索引的方法，所以不能使用普通for循环遍历
由于是Set集合，所以不包含重复元素的集合
四、数据结构
1、数据结构之栈和队列
栈结构
先进后出
队列结构
先进先出
2、数据结构之数组和链表
数组结构
查询快、增删慢
队列结构
查询慢、增删快
五、Map集合
1、Map集合概述和特点
Map集合概述
interface Map<K,V> K：键的类型；V：值的类型
Map集合的特点
键值对映射关系
一个键对应一个值
键不能重复，值可以重复
元素存取无序
Map集合的基本使用
//创建集合对象 Map<String,String> map = new HashMap<String,String>(); HashMap map=new HashMap(); //V put(K key, V value) 将指定的值与该映射中的指定键相关联 map.put("001","a"); map.put("002","b"); map.put("003","c"); map.put("003","d"); //输出集合对象 System.out.println(map); } }
2、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() 集合的长度，也就是集合中键值对的个数 V get(Object key) 根据键获取值 Set<K> keySet() 获取所有键的集合 Collection<V> values() 获取所有值的集合 Set<Map.Entry<K,V>> entrySet() 获取所有键值对对象的集合
//创建集合对象
Map<String,String> map = new HashMap<String,String>();
//V put(K key,V value)：添加元素
map.put("001","a");
map.put("002","b");
map.put("003","c");
//V remove(Object key)：根据键删除键值对元素（删除不成功不报错）返回值是值
System.out.println(map.remove("001"));
//void clear()：移除所有的键值对元素
map.clear();
//boolean containsKey(Object key)：判断集合是否包含指定的键
System.out.println(map.containsKey("001"));
//boolean isEmpty()：判断集合是否为空
System.out.println(map.isEmpty());
//int size()：集合的长度，也就是集合中键值对的个数
System.out.println(map.size());
//V get(Object key):根据键获取值
System.out.println(map.get("001"));
//Set（唯一、无序）<K> keySet():获取所有键的集合
Set<String> keySet = map.keySet();
for(String key : keySet) {
System.out.println(key);
}
//Collection（不唯一、无序）<V> values():获取所有值的集合
Collection<String> values = map.values();
for(String value : values) {
System.out.println(value);
}
//遍历
//1、获取所有键值对对象的集合
Set<Map.Entry<String, String>> entrySet = map.entrySet();
//遍历键值对对象的集合，得到每一个键值对对象
for (Map.Entry me : entrySet) {
//根据键值对对象获取键和值
System.out.println(me.getKey() + "," + me.getValue());
}
//2、先用keySet()取出所有key值，再取出对应value——增强for循环遍历*/
System.out.println("====1、先用keySet()取出所有key值，再取出对应value——增强for循环遍历====");
Set keyset = hashMap.keySet();
for(Object key:keyset){
System.out.println(key+"-"+hashMap.get(key));
}
//3、先用keySet()取出所有key值，再取出对应value——使用迭代器遍历*/
System.out.println("====2、先用keySet()取出所有key值，再取出对应value——使用迭代器遍历====");
Iterator iterator = keyset.iterator();
while(iterator.hasNext()){
Object key = iterator.next();
System.out.println(key+"-"+hashMap.get(key));
}
//4、3、通过entrySet()获得key-value值——增强for循环遍历*/
System.out.println("====3、通过entrySet()获得key-value值——增强for循环遍历====");
Set set = hashMap.entrySet();
for(Object key:set){
Map.Entry entry = (Map.Entry) key;
System.out.println(entry.getKey()+"-"+entry.getValue());
}
//5、通过entrySet()获得key-value值——使用迭代器遍历
System.out.println("====4、通过entrySet()获得key-value值——使用迭代器遍历====");
Set set1 = hashMap.entrySet();
Iterator iterator1 = set1.iterator();
while(iterator1.hasNext()){
Object itset = iterator1.next();
Map.Entry entry = (Map.Entry) itset;
System.out.println(entry.getKey()+"-"+entry.getValue());
}
}
//输出集合对象
System.out.println(map);
}
}六、Collection与Map区别
Collection：存储的数据时不唯一、无序的对象
List：存储的数据是不唯一、有序（输入顺序与输出顺序一致）的对象
Set：存储的数据是唯一（ 元素不能重复）、无序的对象
HashMap:无序；key唯一，value不唯一
HashXxx：底层借助了“哈希表”的数据结构；默认不支持排序
TreeXxx：底层借助了“红黑树”的数据结构；默认支持排序
Collection与Map虽然底层有联系，但是他们在接口层面没有继承实现关系
Collection：单值集合
Map：”键值对“集合（key和value之间一一对应）
删除：Collection（List、Set）：删除返回值为Boolean；Map：删除返回值为元素
遍历：（1）for循环[普通for（set、map不能使用），增强for]（2）迭代器
Map遍历：将双值集合转为单值集合，
七、泛型
1、作用
（1）数据安全
（2）防止类型转换时出错
2、泛型概述和好处
泛型概述
是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型，参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口
泛型定义格式
<类型>：指定一种类型的格式。这里的类型可以看成是形参，不能用基本数据类型，只能使对象
<类型1,类型2…>：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参
将来具体调用时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型
泛型的好处
把运行时期的问题提前到了编译期间
避免了强制类型转换
包装类
将8 个基本类型，包装成了8个对象。这8 个对象类型就成为包装类
自动装箱：int--->Integer（值不在[-128,127]之间的，比较地址）;
自动拆箱：Integer-->int；
3、泛型类
定义格式
修饰符 class 类名<类型> { } public class Generic <String>{}
4、泛型方法
定义格式
修饰符 <类型> 返回值类型 方法名(类型 变量名) { } public class Generic { public <String> void show(String str) { System.out.println(t); } }
5、泛型接口
修饰符 interface 接口名<类型> { }
public interface Generic<String> { }
6、类型通配符
类型通配符的作用
为了表示各种泛型List的父类，可以使用类型通配符
类型通配符的分类
类型通配符：<?>
List<?>：表示元素类型未知的List，它的元素可以匹配任何的类型
这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中
类型通配符上限：<? extends 类型>
List<? extends Number>：它表示的类型是Number或者其子类型
类型通配符下限：<? super 类型>
List<? super Number>：它表示的类型是Number或者其父类型
7、可变参数
可变参数介绍
可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了
可变参数定义格式
修饰符 返回值类型 方法名(数据类型… 变量名) { } public static int sum(int... a) { int sum = 0; for(int i : a) { sum += i; } return sum; } System.out.println(sum(10, 20)); System.out.println(sum(10, 20, 30));可变参数的注意事项
这里的变量其实是一个数组
如果一个方法有多个参数，包含可变参数，可变参数要放在最后
8、可变参数的使用
Arrays工具类中有一个静态方法：
public static <T> List<T> asList(T... a)：返回由指定数组支持的固定大小的列表
返回的集合不能做增删操作，可以做修改操作
List接口中有一个静态方法：
public static <E> List<E> of(E... elements)：返回包含任意数量元素的不可变列表
返回的集合不能做增删改操作
Set接口中有一个静态方法：
public static <E> Set<E> of(E... elements) ：返回一个包含任意数量元素的不可变集合
在给元素的时候，不能给重复的元素
返回的集合不能做增删操作，没有修改的方法
八、集合工具类
1、集合工具类Collections（处理集合）
Collections概述和使用
Collections类的作用
是针对集合操作的工具类
Collections类常用方法
方法名 说明 public static void sort(List<T> list) 将指定的列表按升序排序 public static void reverse(List<?> list) 反转指定列表中元素的顺序 public static void shuffle(List<?> list) 使用默认的随机源随机排列指定的列表
//创建集合对象
List<Integer> list = new ArrayList<Integer>();
//添加元素
list.add(30);
list.add(20);
//将指定的列表按升序排序
Collections.sort(list);
//反转指定列表中元素的顺序
Collections.reverse(list);
//使用默认的随机源随机排列指定的列表
Collections.shuffle(list);
//二分查找（使用前保证集合元素是自然有序的）返回元素位置
Collections.sort(list);
Collections.binarySearch(list)
//打乱已有顺序
Collections.shuffle();
//将位置2与位置3的元素交换位置
Collections.swap(list,2,3)
//将集合中所有20替换为100
Collections.replaceAll(list,20,100)
//将集合全部用00填充
Collections.fill(list,00)
}2、数据工具类Arrays 比如：Arrays.sort(数组)
方法与Collestions差不多
补充：
2、比较器
Collections.sort(list) //能够识别一些自然顺序：数字大小，字母表
如果集合中的元素是用户自定义对象则需要自定义比较器：Compareble、Comparetor
Compareble：内部比较器
将比较对象实现comparable接口，重写compareTo（）方法
注：Person是个自定义类
public int compareTo (Object o){
Person inputPerson=(Person) o;
//根据学号，降序
int result= this.id>inputPerson.id ? 1 :(this.id==inputPerson.id ? 0: -1);
//如果学号相同根据姓名升序/降序（在this前面加‘ - ’）
if(result==0){
result=this.name.compareTo(inputPerson.name);
}
return result;
}Comparator：外部比较器，无侵入性，不需要修改原有代码
思路：先写一个类实现Comparator接口；重写compare方法
使用方法：Collections.sort(person,new Mycompare());
3、equal()方法和hashcode()的重写
@Override
public boolean equals(Object o) {
// 首先判断传进来的o是否是调用equals方法对象的this本身，提高判断效率
if (o==this){return true;}
// 判断传进来的o是否是null，提高判断效率
if (o==null){return false;}
判断传进来的o是否是对象，防止出现类型转换的异常
if (o instanceof Book){
Book book =(Book) o;
boolean flag=this.title.equals(book.title)&&this.price==book.price&&this.author.equals(book.author);
return flag;
}
// 如果没有走类型判断语句说明两个比较的对象它们的类型都不一样，结果就是false了
return false;
}
@Override
public int hashCode() {
// result = 31 *result + (对象 !=null ?对象.hashCode() : 0);
// result = 31 *result + 基本数值类型;(int)
// result=31*result+(int)(Double.doubleToLongBits(x));强制转换为int类型
// result = 31 *result + (布尔变量?1:0);
int result=title.hashCode();
result = 31*result+author.hashCode();
result=31*result+(int)(Double.doubleToLongBits(price));
return result;
}4、并发修改异常
出现的原因
迭代器遍历的过程中，通过集合对象修改了集合中的元素，造成了迭代器获取元素中判断预期修改值和实际修改值不一致，则会出现：ConcurrentModificationException
解决的方案
用for循环遍历，然后用集合对象做对应的操作即可
5、列表迭代器
ListIterator介绍
通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器
用于允许程序员沿任一方向遍历的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置
6、增强for循环
定义格式
for(元素数据类型 变量名 : 数组/集合对象名) { 循环体; } for(String s : list) { if(s.equals("world")) { list.add("javaee"); //ConcurrentModificationException } }