【博学谷学习记录】超强总结，用心分享。集合体系结构。
集合
1.集合的结构体系图
注：红色为实现类，蓝色为接口
2.结构特点
1）Collection是单列集合，其中，List的元素是可以重复的，但是Set的元素不可以重复
2）Map是双列集合。
3.Collection集合常用方法
package com.study.collectionDemo;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
public class Demo1 {
public static void main(String[] args) {
//集合的方法
/*
boolean add(E e) 添加元素
boolean remove(object o) 从集合中移除指定的元素
boolean removeif(object o) 根据条件删除 结合lambda判断
void clear() 清空集合
boolean contains(Object o)判断集合中是否存在指定的元素
boolean isEmpty() 判断集合是否为空
int size() 集合的长度，也就是集合中的元素
*/
//建立集合
//添加元素
Collection<String> collection=new ArrayList<>();
collection.add("aaa");
collection.add("bbb");
collection.add("ccc");
System.out.println(collection);//[aaa, bbb, ccc]
//从集合中删除元素
boolean result=collection.remove("aaa");
boolean result1=collection.remove("dddd");
System.out.println(result);true
System.out.println(result1);false
System.out.println(collection);[bbb, ccc]
//根据条件删除，结合Lambda判断
collection.removeIf((String s)->{
return s.length()==3;
});
System.out.println(collection);
//清空集合
collection.clear();
System.out.println(collection);
//判断元素内是否包含元素
boolean re1=collection.contains("aaa");
boolean re2=collection.contains("cccc");
System.out.println(re1);//true
System.out.println(re2);//false
//判断集合是否为空
boolean re3=collection.isEmpty();
System.out.println(re3);//false
//查看元素长度大小
int size = collection.size();
System.out.println(size);//3
}
}
4.Collection集合的遍历
Iterator迭代器，集合的专用遍历方式
格式为 Iterator<E> iterator():返回集合中的迭代器对象，该迭代器对象默认指向当前集合的0索引
Iterator中的常用方法
boolean hasNext（）：判断当前位置是否有元素可以被取出
E next（）：获取当前位置的元素，将迭代器对象移向下一个索引位置
package com.study.collectionDemo;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo2 {
public static void main(String[] args){
Collection<String> list=new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
System.out.println(list);
Iterator<String> iterator=list.iterator();
//返回集合中的迭代器对象，该迭代器对象默认指向当前集合的0索引
//利用迭代器里面的方法进行遍历
System.out.println(iterator.hasNext());
//取出当前位置的元素 将迭代器往后移动一个索引的位置
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
5.Collection集合的第二种遍历方式：增强for
增强for：简化数组和Collection集合的遍历
它是JDK5之后出现的，其内部原理是一个Iterator迭代器，实现Iterator接口的类才可以使用迭代器和增强for。
实现格式：
for（元素数据类型 变量名 ： 数组或者Collection集合）{}
范例：
ArrayList<String> list=new ArrayList<>();
for(String s:list){system.out.println(i);}
注意：修改第三方变量的值不会影响到集合中的元素，如范例中的变量名S
6.三种循环的使用场景
1.如果需要操作索引，使用普通for循环
2.如果在遍历的过程中需要删除元素，使用 迭代器
3.如果仅仅想遍历，那么使用增强for
List
1.List集合的特点
1）有序：存储和取出的元素顺序一致
2）有索引：可以通过索引操作元素
3）可重复：存储的元素可以重复
2.List集合特有方法
|
方法名 |
说明 |
|
void add(int index,E element) |
在此集合中的指定位置插入指定的元素 |
|
E remove(int index) |
删除指定索引处的元素，返回被删除的元素 |
|
E set(int index,E element) |
修改指定索引处的元素，返回被修改的元素 |
|
E get(int index) |
返回指定索引处的元素 |
3.List集合常用实现类
ArrayList集合底层数据结构是数组，查询快，增删慢
LinkedList：底层数据结构是链表，查询慢，增删快
4.LinkedList集合的特有功能
package com.study.mylistDemo;
import java.util.LinkedList;
public class Demo1 {
public static void main(String[] args) {
//LinkList的特有功能
LinkedList<String> list=new LinkedList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
//public void addFirst(E e) 在该列表开头插入指定的元素
list.addFirst("QQQ");
System.out.println(list);//[QQQ, aaa, bbb, ccc]
//public void lastFirst(E e) 在该列表末尾插入指定的元素
list.addLast("zzz");
System.out.println(list);//[QQQ, aaa, bbb, ccc, zzz]
//public e getFirst()返回此列表中第一个元素
String first = list.getFirst();
//public e getLast()返回此列表中最后一个元素
String last= list.getLast();
System.out.println(first);
System.out.println(last);
//public e removeFirst() 删除第一个
String s = list.removeFirst();
//public e removeLast() 删除z最后一个个
String s1= list.removeLast();
System.out.println(s);
System.out.println(s1);
}
}
Set集合
1.Set集合的特点
1）可以去除重复
2）存取顺序不一致
3）没有带索引的方法，所以不能使用普通for循环遍历，也不能通过索引来获取，删除Set集合里面的元素
2.TreeSet集合特点
1）不包含重复元素的集合
2）没有带索引的方法
3）可以将元素按照规则进行排序
如果想要使用TreeSet需要定制排序规则
3.自然排序Comparable的使用
1）使用空参构造创建TreeSet集合
2）自定义的Student类实现Comparable接口
3）重写里面的compareTo方法
4）自然排序简单原理图
如果返回值为负数，表示当前存入的元素是较小值，存左边。
如果返回值为0，表示当前存入的元素跟集合中元素重复了，不存
如果返回值为正数，表示当前存入的元素是较大值，存右边
4.比较器排序Comparator的使用
1）TreeSet的带参构造方法使用的是比较器排序对元素进行排序
2）比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare（To1，To2）方法
3）重写方法时，一定要注意排序规则必须按照要求的主要和次要条件来写
5.两种比较方法的小结
1）自然排序：自定义类实现Comparable接口，重写compareTo方法，根据返回值进行排序
2）比较器排序：创建TreeSet对象的时候传递Comparator方法，根据返回值进行排序
3）在使用的时候，默认使用自然排序，当自然排序不满足闲杂的需求，使用比较器排序
6.两种方式中，关于返回值的规则
1)如果返回值为负数，表示当前存入的元素是较小值，存左边
2）如果返回值为0，表示当前存入的元素跟集合中元素重复了，不存
3）如果返回值为正数，表示当前存入的元素是较大值，存右边
7.HashSet集合的特点
1）底层数据结构是哈希表
2)对集合的迭代顺序不作任何保证，也就是说，不保证存储和取出的元素顺序一致
3）没有带索引的方法，所以不能使用普通for循环遍历
4）由于是Set集合，所以元素是不重复的。
8.哈希值
哈希值是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
1）Object类中有一个方法可以获取对象的哈希值
public int hashCode():返回对象的哈希码值
2）对象的哈希值特点
同一个对象多次调用hashCode（）方法返回的哈希值是相同的
默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同
3）总结
Map
1.Map集合的概述和使用
1）单例集合一次存一个元素，双列集合一次存两个元素
2）双列元素中的键是不能重复的，值是可以重复的
3)Interface Map<K,V> K:键的数据类型 V：值的数据类型
4）键和值是一一对应的，每个键只能找到自己对应的值
5）（键+值）这个整体我们称之为键值对，或者键值对对象，在Java中叫做Entry对象
2.创建Map集合的对象
1）多态的方式
2）具体实现类HashMap
3.Map集合的基本功能
package com.study.mymap;
import java.util.HashMap;
import java.util.Map;
public class Demo1 {
//map的基本使用
public static void main(String[] args) {
//创建集合对象
Map<String,String> map=new HashMap<String,String>();
//v put(K key,V value):添加元素
map.put("aa","11");
map.put("bb","22");
map.put("cc","33");
map.put("dd","44");
System.out.println(map);
//V remove（object key）：根据键删除键值对元素
System.out.println(map.remove("aa"));//有就返回删除完之后对应的值
System.out.println(map.remove("qq"));//没有就返回null
//void clear()：移除所有的键值对元素
// map.clear();
//boolean containsKey(Object key)：判断集合是否包含指定的键
// System.out.println(map.containsKey("郭靖"));
// System.out.println(map.containsKey("郭襄"));
//boolean isEmpty()：判断集合是否为空
// System.out.println(map.isEmpty());
//int size()：集合的长度，也就是集合中键值对的个数
// System.out.println(map.size());
}
}
4.Map集合的获取功能
package com.study.mymap;
import com.sun.source.doctree.SeeTree;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo2 {
public static void main(String[] args) {
//Map集合的获取功能
Map<String,String> map=new HashMap<String, String>();
//添加元素
map.put("aa","11");
map.put("bb","22");
map.put("cc","33");
map.put("dd","44");
//V get(Object key):根据键获取值
// System.out.println(map.get("aa"));11
// System.out.println(map.get("qq"));null
//Set<K> keySet():获取所有键的集合
Set<String> keySet=map.keySet();
for (String s : keySet) {
System.out.println(s);
}
//Collection<V> values():获取所有值的集合
Collection<String> values= map.values();
for (String value : values) {
System.out.println(value);
}
}
}
5.Map的遍历方式一
package com.study.mymap;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo3 {
/*
- 我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
- 把所有的丈夫给集中起来
- 遍历丈夫的集合，获取到每一个丈夫
- 根据丈夫去找对应的妻子
- 步骤分析
- 获取所有键的集合。用keySet()方法实现
- 遍历键的集合，获取到每一个键。用增强for实现
- 根据键去找值。用get(Object key)方法实现
*/
public static void main(String[] args) {
//创建集合对象
Map<String,String> map=new HashMap<String, String>();
//添加元素
map.put("aa","11");
map.put("bb","22");
map.put("cc","33");
map.put("dd","44");
//根据键找值，用keySet（）
Set<String> keySet=map.keySet();
for (String s : keySet) {
//根据键去找值，用get（Object key）方法实现
String value= map.get(s);
System.out.println(s+","+value);
}
}
}
6.Map集合遍历方式二：根据键值对对象获取键和值
package com.study.mymap;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo4 {
/* - 获取所有键值对对象的集合
- Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合
- 遍历键值对对象的集合，得到每一个键值对对象
- 用增强for实现，得到每一个Map.Entry
- 根据键值对对象获取键和值
- 用getKey()得到键
- 用getValue()得到值
*/
public static void main(String[] args) {
Map<String,String>map=new HashMap<String, String>();
map.put("aa","11");
map.put("bb","22");
map.put("cc","33");
map.put("dd","44");
//获取所有键值对对象的集合
Set<Map.Entry<String, String>> entries = map.entrySet();
//遍历键值对对象，得到每一个键值对对象
for (Map.Entry<String, String> entry : entries) {
String key= entry.getKey();
String value=entry.getValue();
System.out.println(key+"...."+value);
}
}
}
7.HashMap的特点
1）HashMap是Map里面的一个实现类
2）没有额外需要学习的特有方法，直接使用Map里面的方法就可以了
3）HashMap跟HashSet一样底层是哈希表结构
4）依赖hashCode方法和equals方法保证键的唯一
5）如果键要存储的是自定义对象，需要重写hashCode方法和equals方法
8.TreeMap的特点
1）TreeMap是Map里面的一个实现类
2）没有额外需要学习的特有方法，直接使用Map里面的方法就可以
3）TreeMap和TreeSet一样底层是红黑树结构的
4）依赖自然排序或者比较器排序，对键进行排序
5）如果键存储的是自定义对象，需要实现Comparable接口或者在创建TreeMap对象时候给出比较器排序规则
9.可变参数
10.不可变集合
总结
对集合的体系结构知识的总结，方便自己对知识点的梳理。
package com.study.mymap;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo4 {
/* - 获取所有键值对对象的集合
- Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合
- 遍历键值对对象的集合，得到每一个键值对对象
- 用增强for实现，得到每一个Map.Entry
- 根据键值对对象获取键和值
- 用getKey()得到键
- 用getValue()得到值
*/
public static void main(String[] args) {
Map<String,String>map=new HashMap<String, String>();
map.put("aa","11");
map.put("bb","22");
map.put("cc","33");
map.put("dd","44");
//获取所有键值对对象的集合
Set<Map.Entry<String, String>> entries = map.entrySet();
//遍历键值对对象，得到每一个键值对对象
for (Map.Entry<String, String> entry : entries) {
String key= entry.getKey();
String value=entry.getValue();
System.out.println(key+"...."+value);
}
}
}
