Java核心类库之集合框架

---

提示：以下是本篇文章正文内容，Java系列学习将会持续更新

类和接口总览

回到目录…

1. List接口

  线性表(ArrayList 、LinkedList 、Vector)

1-1 ArrayList类

定义一个ArrayList

List<Integer> list3 = new ArrayList<>();     // 存放整数元素
List<Character> list4 = new ArrayList<>();   // 存放字符元素
ArrayList<String> list1 = new ArrayList<>();   //存放字符串元素
1
2
3

①添加元素

list1.add("hello");    //直接在末尾添加
list1.add(1,"world");  //在第1个元素后添加 
list2.addAll(list1);   //在list2中添加list1的全部元素
list2.addAll(2,list1); //在list2的第2个元素后添加list1的全部元素
1
2
3
4

②删除元素

list1.remove("world"); //将list1中的元素"world"删除
list1.remove(2); //将list1中索引为2的元素删除
// 如果想删除int型的元素，就用list3.remove(list3.indexOf(2));
list1.removeAll(list2); //将list1中含有list2的元素删掉
1
2
3
4

③列表长度

list1.size();   //list中的元素个数
1

④修改元素

list1.set(2,"boy");  //将list1中索引为2的元素，修改为boy
1

⑤查找元素

list1.contains("and"); //如果list1中含有"and",则返回true
list1.indexOf("and");  //获取元素"and"的索引号
list1.get(2);           //获取list中索引为2的元素
1
2
3

回到目录…

1-2 Stack类

定义一个Stack栈

Stack<Integer> stack = new Stack<>();     // 存放整数元素

// 入栈
	E push(E e);
// 出栈
	E pop();
// 返回栈顶元素
	E peek();
// 判断堆栈是否为空
	boolean empty();
// 返回元素在堆栈中的位置
	int search(E e);
1
2
3
4
5
6
7
8
9
10
11
12

回到目录…

2. Queue接口

实现的子接口：Deque
Java中的双端队列：可以从两头进行插入和删除，可以代替Stack类
实现的子类：ArrayDeque(基于数组)、LinkedList(基于链表)、PriorityQueue(优先级队列)

// JDK内置基于最小堆实现的优先级队列
	Queue<Integer> queue = new PriorityQueue<>(); //队首为最小值
// 实现一个队列
	Queue<Integer> queue1 = new ArrayDeque<>();     // 存放整数元素
	Queue<Integer> queue2 = new LinkedList<>();     // 存放整数元素
// 实现一个双端队列
	Deque<Integer> deq1 = new ArrayDeque<>();     // 存放整数元素
	Deque<Integer> deq2 = new LinkedList<>();     // 存放整数元素
1
2
3
4
5
6
7
8

// 插入元素
	boolean offer(E e);     //队尾入队
	void push(E e);   //栈顶入栈
// 删除元素
	E poll();   //队首出队
	E pop();    //栈顶出栈
// 返回队首/栈顶元素
	E peek();
// 返回元素个数
	int size();
1
2
3
4
5
6
7
8
9
10

回到目录…

3. Set接口

 一次存储一个不重复元素，方便进行元素去重处理。
 Set接口，元素的插入顺序和实际存储顺序是无关的(HashSet类)，因为hash值不一定有序。如果需要插入顺序和存储顺序相同，使用LinkedHashSet。
 Set接口是List接口的子接口，只是有了元素不重复性，其用法和List差不多。

定义一个HashSet

Set<String> set = new HashSet<>();     // 存放字符串元素
1

// 添加元素
	set.add("world");  //添加不重复的元素; 返回值是true/false
// 删除元素
	set.remove("world"); //将元素"world"删除; 返回值是true/false
	set1.removeAll(set2); //将set1中含有set2的元素删掉;返回值true/false
// 查找元素
	set.contains("and");  //set中存在"and",则返回true
// 列表长度
	set.size();   //元素个数
1
2
3
4
5
6
7
8
9

回到目录…

4. Map接口

List和Set都是一次存储一个元素。
Map接口是一种映射关系，一次存储两个元素 key -> value (键-值对)
一个key一定对应一个value; key不可以重复，但是value可以重复。
key和value可以是不同类型的元素，但都得是引用类型。

定义一个HashMap

Map<Integer,String> map = new HashMap<>(); // <整型 , 字符串>
1

①添加/修改

//若key不存在,则添加这对元素(增);若key存在,则更新value的值(改)
map.put(1,"张三"); 
1
2

②查找元素

a.根据key取出映射的value;若key不存在,则返回null
	V value = map.get(key); 
	String ret = map.get(4);
	
b.根据key取出映射的value;若key不存在,则返回默认值
	V value = map.getOrDefault(key,defaultValue); 
	String ret2 = map.getOrDefault(4,"李九");
	
c.判断key或者value是否存在
	boolean containsKey(key);
	boolean containsValue(value);
1
2
3
4
5
6
7
8
9
10
11

③删除元素

map.remove(key);  //根据键值删除整个键值对
1

④列表长度

map.size();   //元素个数
1

⑤获取集合

//获取当前Map中的所有key集合。因为key是不重复的，所以返回set集合
	Set<K> keySet(); 
	Set<Integer> keys = map.keySet();
//获取当前Map中的所有value集合
	Collection<V> values(); // 把 Collection 看作 List
	Collection<String> values = map.values();
1
2
3
4
5
6

⑥将Map集合转为Set集合，遍历一个个键值对

Map.Entry ：此接口中存储的就是一个个键值对对象，将key和value捆绑在一起

// Map -> Set
Set<Map.Entry<Integer,String>> entry = map.entrySet();
// 使用for - each遍历
for(Map.Entry<Integer,String> temp : entry){
    System.out.println(temp.getKey() + " -> " + temp.getValue());
}
1
2
3
4
5
6

总结：

HashMap / TreeMap / LinkedHashMap
1.HashMap是基于哈希表 + 红黑树结构(JDK8之后)，HashMap的元素存储顺序和元素插入顺序无关，key和value都可以为null。
2.TreeMap是基于红黑树的结构，TreeMap的元素存储顺序和元素插入顺序无关，key不能为null，但value可以为null。使用TreeMap保存元素时，元素必须是Comparable子类或传入Comparator比较器。
3. LinkedHashMap就是在HashMap的基础上维护了一个链表来记录元素插入先后顺序，可以按插入顺序来存储元素。

回到目录…

---

总结:
提示：这里对文章进行总结：
以上就是今天的学习内容，本文是Java常用集合的学习，学习了Conllection下的三大子接口和Map接口的实现类使用方法。之后的学习内容将持续更新！！！