1.9 集合
一、集合
概念：
Java集合大致可分为List、Set、Queue和Map四种体系.
List：代表有序、重复的集合。
Set：代表无序、不可重复的集合。
Map：则代表具有映射关系的集合。
Queue：Java5又增加了Queue体系集合，代表一种队列集合实现。
分类：
Java的集合类主要由两个接口派生而出： Collection和Map， Collection和Map是Java 集合框架的根接口，这两个接口又包含了一些子接口或实现类。如下所示是 Java集合 简单结构图：
二、Collection集合
1、Collection集合
数组的长度是固定的。集合的长度是可变的。
数组存储任意类型数据。集合存储的都是引用数据类型。基本类型需要转为对应的包装类。
2、单列集合：collection；双列集合：map
3、collection中的功能：
| public boolean add(E e) ： | 把给定的对象添加到当前集合中 。 |
|---|---|
| public void clear() : | 清空集合中所有的元素。 |
| public boolean remove(E e) : | 把给定的对象在当前集合中删除。 |
| public boolean contains(Object obj) : | 判断当前集合中是否包含给定的对象。 |
| public boolean isEmpty() : | 判断当前集合是否为空。 |
| public int size() : | 返回集合中元素的个数。 |
| public Object[] toArray() : | 把集合中的元素，存储到数组中 |
4、Iterator迭代器
public Iterator iterator() : 获取集合对应的迭代器，用来遍历集合中的元素的；
public E next() :返回迭代的下一个元素。
public boolean hasNext() :如果仍有元素可以迭代，则返回 true；
实现代码：
Iterator<String> it = coll.iterator();
// 泛型指的是 迭代出 元素的数据类型
while(it.hasNext()){ //判断是否有迭代元素
String s = it.next();//获取迭代出的元素
System.out.println(s);
}
5、增强for：
高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。
//使用增强for遍历数组
for (int a : arr) {//a代表数组中的每个元素
System.out.println(a);
}
6、泛型：
————含有 泛型的类：——在创建对象的时候确定泛型；
class ArrayList<E> {
public boolean add(E e) {
}
public E get(int index) {
}
}
(1)、创建对象时候确定泛型：
ArrayList<String> list = new ArrayList<String>();
则原来内部代码理解为：
class ArrayList<String> {
public boolean add(String e) {
}
public String get(int index) {
}
}
————含有含有泛型的方法——调用方法时，确定泛型的类型
public class MyGenericMethod {
public <MVP> void show(MVP mvp) {
System.out.println(mvp.getClass());
}
}
(2)、调用方法时候确定：
public class GenericMethodDemo {
public static void main(String[] args) {
// 创建对象
MyGenericMethod mm = new MyGenericMethod();
// 演示看方法提示
mm.show("aaa");
mm.show(123);
}
}
————含有泛型的接口——
public interface MyGenericInterface<E> {
public abstract void add(E e);
public abstract E getE();
}
《1》定义类时确定泛型的类型
public class MyImp1 implements MyGenericInterface<String> {
}
@Override
public void add (String e){
}
《2》始终不确定泛型的类型，直到创建对象时，确定泛型的类型
public class MyImp2<E> implements MyGenericInterface<E> {
@Override
public void add(E e) {
}
}
7、泛型通配符:用来匹配泛型的
?: 代表任意的数据类型
注意: 用来匹配泛型的,而不能用来定义泛型
ArrayList<String> list1 = new ArrayList<>();
list1.add("aaa");
ArrayList<Integer> list2 = new ArrayList<>();
list2.add(200);
print(list1);
print(list2);
//定义一个方法,完成上面的两个集合的遍历
public static void print (ArrayList < ? > list){
for (Object obj : list) {
System.out.println(obj);
}
}
泛型的注意事项:
《1》创建集合对象时,<>中指定的类型,左右必须保持一致(泛型不存在多态)
《2》ArrayList<?> list:
可以接收ArrayList的任意泛型对象(创建ArrayList集合时,只要<>中定了具体的类型,就是ok的)
ArrayList<?> list;//只是用来接收创建的值得。可以用通配符；
list = new ArrayList<String>();
list = new ArrayList<Integer>();
8、 泛型上限:
? extends Person: Person类型或者Person类型的子类型，表示继承Person的类；
? extends E: E类型或者E类型的子类型
public static void print(ArrayList<? extends Person> list) {
泛型下限:
? super Teacher: Teacher类型或者Teacher类型的父类型，表示父类是Teacher的类；
? super E: E类型或者E类型的父类型
public static void print(ArrayList<? super Teacher> list) {
三、List接口
1、List接口特点：
—它是一个元素存取有序的集合。
—它是一个带有索引的集合；
—集合中可以有重复的元素；
常用方法：
- add(int index, E element) : 将指定的元素，添加到该集合中的指定位置上。
- get(int index) :返回集合中指定位置的元素。
- remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。
- set(int index, E element) :替换集合中元素,返回值的更新前的元素；
2、常见数据结构：
数据存储的常用结构有：栈、队列、数组、链表和红黑树。
——栈：
又称堆栈，运算受限的线性表，仅允许在标的一端进行插入和删除操作；
特点：
先进后出：
栈的入口、出口的都是栈的顶端位置。
压栈：就是存元素。
弹栈：就是取元素。
——队列：
运算受限的线性表，仅允许在表的一端进行插入，而在表的另一端进行删除。
先进先出；
队列的入口、出口各占一侧。
——数组：
有序的元素序列
查找元素快；增删元素慢；
在指定索引位置增加元素和删除元素;
——链表：
由一系列结点组成，其中每个结点包括两个部分：
一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域；
链表结构有单向链表与双向链表；
特点：
多个结点之间，通过地址进行连接。
查找元素慢：增删元素快：
——红黑树：
二叉树是每个节点最多有两个子树的树结构。
顶上的叫根结点，两边被称作“左子树”和“右子树”。
3、LinkedList集合：
LIst集合下面ArrayList集合和LinkedList集合;
LinkedList 集合数据存储的结构是链表结构。方便元素添加、删除的集合。
常用方法：
- addFirst(E e) :将指定元素插入此列表的开头。
- addLast(E e) :将指定元素添加到此列表的结尾。
- getFirst() :返回此列表的第一个元素。
- getLast() :返回此列表的最后一个元素。
- removeFirst() :移除并返回此列表的第一个元素。
- removeLast() :移除并返回此列表的最后一个元素。
- pop() :从此列表所表示的堆栈处弹出一个元素。
- push(E e) :将元素推入此列表所表示的堆栈。
- isEmpty() ：集合是否为空，为空返回true;
四、set接口：
Set集合取出元素的方式可以采用：迭代器、增强for。
HashSet是Set 接口的一个实现类；
特点：
存储的元素是不可重复的，并且元素都是无序的；
根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存储和查找性能。
哈希表是由数组+链表+红黑树；
保证HashSet集合元素的唯一，其实就是根据对象的hashCode和equals方法来决定的；
就必须复写hashCode和equals方法建立属于当前对象的比较方式。
1、LinkedHashSet:
链表和哈希表组合:保证了存入其中元素而的有序性，和唯一性；
Set<String> set = new LinkedHashSet<String>();
2、Collections类：
Collections 是集合工具类，用来对集合进行操作：
shuffle(List<?> list) :打乱集合顺序。
sort(List list) :将集合中元素按照默认规则排序。
int类型按照升序进行排列；
string类型，按照字母的ASC码进行排序的；
//排序方法
Collections.sort(list);
sort(List list，Comparator<? super T> ) :将集合中元素按照指定规则排序；
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getAge()‐o2.getAge();//以学生的年龄升序
}
五、Map集合
1、概念
映射：身份证号与个人，这种一一对应的关系；
Collection 中的集合称为单列集合， Map 中的集合称为双列集合；
特点：
Map 中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。
2、Map集合子类：
HashMap：存储数据采用的哈希表结构，
元素的存取顺序不能保证一致。
保证键唯一、不重复，需要重写键的hashCode()方法、equals()方法。
LinkedHashMap：HashMap下有个子类LinkedHashMap，
存储数据采用的哈希表结构+链表结构。
通过链表结构保证元素的存取顺序一致；
通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
3、常用方法：
- put(K key, V value) : 把指定的键与指定的值添加到Map集合中。
- remove(Object key) : 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的
- get(Object key) 根据指定的键，在Map集合中获取对应的值。
- Set keySet() : 获取Map集合中所有的键，存储到Set集合中。
- Set> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。
- containKey(Object key) :判断该集合中是否有此键；
4、Map的遍历：
——键找值方式：
- 获取Map中所有的键（keyset()）
- 遍历键的Set集合，得到每一个键。
- 根据键，获取键所对应的值。（get(K key)）
// 1、将key以Set形式取出
Set<Object> keySet = hashMap.keySet();
// 2、将key转为迭代器
Iterator<Object> iterator = keySet.iterator();
// 3、遍历取值
while (iterator.hasNext()) {
String key = iterator.next().toString();
String value = hashMap.get(key).toString();
System.out.println(key + "==" + value);
}
——键值对方式
使用方法：
Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。
那么同样Entry中，获取键和获取值的方法：
getKey() ：获取Entry对象中的键。
getValue() ：获取Entry对象中的值。
1、获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。— entrySet() 。
2、遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。
3、通过键值对(Entry)对象，获取Entry对象中的键与值。——getkey() getValue()
// 1、获取键值对(Entry)对象
Set<Map.Entry<Object, Object>> entries = hashMap.entrySet();
// 2、转为迭代器
Iterator<Map.Entry<Object, Object>> iterator = entries.iterator();
// 3、遍历取值
while (iterator.hasNext()) {
Map.Entry<Object, Object> next = iterator.next();
String key = next.getKey().toString();
String value = next.getValue().toString();
System.out.println(key + "==" + value);
}
5、可变参数：
public static int getSum(int… arr) ：可变参数的使用格式；
int sum = getSum(6, 7, 2, 12, 2121);//调用方法;
public static int getSum(int... arr) {//接受数值
int sum = 0;
for (int a : arr) {//遍历求和
sum += a;
}
}
注意：
1.一个方法只能有一个可变参数
2.如果方法中有多个参数，可变参数要放到最后。
Collections中也提供了添加一些元素方法：
//往集合中添加一些元素；
public static <T> boolean addAll(Collection<T> c, T... elements)
具体应用：
ArrayList<Integer> list = new ArrayList<Integer>();
//采用工具类 完成 往集合中添加元素
Collections.addAll(list, 5, 222, 1，2);
六、xmind整理
1、图：
2、CSDN地址：
https://download.csdn.net/download/weixin_44624117/12598401
3、百度云地址：
链接：https://pan.baidu.com/s/1gj6H6BZ9wi8kML9fTwEseQ
提取码：uc55
