集合之Collection家族的 List接口+LinkedList+Vector+Stack及Set接口+HashSet+LinkedHashSet+TreeSet
集合之Collection家族的 List接口+LinkedList+Vector+Stack及Set接口+HashSet+LinkedHashSet+TreeSet
一、LinkedList
1.LinkedList的使用
注意：因为LinkedList和ArrayList都实现了List接口(标准)，所以使用上几乎没有区别
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
public class Test01 {
public static void main(String[] args) {
//创建LinkedList对象
LinkedList<String> list = new LinkedList<>();
//添加元素
list.add("夏侯惇");
list.add("赵云");
list.add("妲己");
list.add("瑶妹");
list.add("鲁班");
list.add("鲁班");
//设置指定下标上的元素
list.set(2, "貂蝉");
//获取指定下标上的元素
String str = list.get(3);
System.out.println("获取指定下标上的元素：" + str);
int size = list.size();
System.out.println("获取元素个数：" + size);
//插入元素
list.add(4,"后裔");
LinkedList<String> newList1 = new LinkedList<>();
//利用集合工具类做批量添加
Collections.addAll(newList1, "aaa","bbb","ccc");
//将newList1中所有的元素添加到list末尾
list.addAll(newList1);
LinkedList<String> newList2 = new LinkedList<>();
//利用集合工具类做批量添加
Collections.addAll(newList2, "xxx","yyy","zzz");
//将newList2中所有的元素添加到list指定下标的位置
list.addAll(5,newList2);
//清空集合中所有的元素
//list.clear();
System.out.println("判断集合中是否包含指定元素：" + list.contains("后裔"));
System.out.println("判断集合中是否包含子集合：" + list.containsAll(newList2));
System.out.println("获取集合中元素第一次出现的下标：" + list.indexOf("鲁班"));
System.out.println("获取集合中元素最后一次出现的下标：" + list.lastIndexOf("鲁班"));
System.out.println("判断集合中是否不包含元素：" + list.isEmpty());
//根据下标删除元素
list.remove(5);
//根据元素删除元素
list.remove("鲁班");
//去除交集(删除list中包含了newList1中所有的元素)
list.removeAll(newList1);
//保留交集(保留list中包含了newList2中所有的元素)
list.retainAll(newList2);
//替换指定下标上的元素
list.set(1, "后裔");
//将集合转换为数组
Object[] array = list.toArray();
System.out.println(array);
//将集合转换为数组
String[] ss = new String[list.size()];
list.toArray(ss);
System.out.println(Arrays.toString(ss));
System.out.println("----------------------------");
//遍历方式1 -- for循环
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("---------------------");
//遍历方式2 -- foreach
for (String element : list) {
System.out.println(element);
}
System.out.println("---------------------");
//遍历方式3 -- Iterator
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){//判断是否有可迭代的元素
String next = iterator.next();//返回下一个元素
System.out.println(next);
}
System.out.println("---------------------");
//遍历方式4 -- ListIterator
ListIterator<String> listIterator = list.listIterator();
while(listIterator.hasNext()){//判断是否有可迭代的元素
String next = listIterator.next();//返回下一个元素
System.out.println(next);
}
}
}
2.LinkedList独有的方法
LinkedList底层的数据结构：双向链表
import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedList;
public class Test02 {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
list.add("上官婉儿1");
list.add("上官婉儿2");
list.add("上官婉儿3");
list.add("上官婉儿4");
list.add("上官婉儿5");
list.add("abc");
//将元素添加到双向链表的头部
list.addFirst("女娲");
//将元素添加到双向链表的尾部
list.addLast("凯哥");
//删除双向链表的头部元素
list.removeFirst();
//删除双向链表的尾部元素
list.removeLast();
//以相反的顺序返回此deque中的元素的迭代器。
Iterator<String> descendingIterator = list.descendingIterator();
while (descendingIterator.hasNext()) {
String next = descendingIterator.next();
System.out.println(next);
}
//获取双向链表中第一个元素
String element = list.element();
System.out.println("获取双向链表中第一个元素：" + element);
//获取双向链表中第一个元素
String first = list.getFirst();
System.out.println("获取双向链表中第一个元素：" + first);
//将元素添加到双向链表的尾部
list.offer("苏烈");
//将元素添加到双向链表的头部
list.offerFirst("aaa");
//将元素添加到双向链表的尾部
list.offerLast("bbb");
//将元素添加到双向链表的头部元素
list.push("abc");
//获取双向链表头部元素
String peek = list.peek();
System.out.println("获取双向链表头部元素：" + peek);
//获取双向链表头部元素
String peekFirst = list.peekFirst();
System.out.println("获取双向链表头部元素：" + peekFirst);
//获取双向链表尾部元素
String peekLast = list.peekLast();
System.out.println("获取双向链表尾部元素：" + peekLast);
//删除双向链表的头部元素
String poll = list.poll();
System.out.println("删除双向链表的头部元素：" + poll);
//删除双向链表的头部元素
String pollFirst = list.pollFirst();
System.out.println("删除双向链表的头部元素：" + pollFirst);
//删除双向链表的尾部元素
String pollLast = list.pollLast();
System.out.println("删除双向链表的尾部元素：" + pollLast);
//删除双向链表的头部元素
String pop = list.pop();
System.out.println("删除双向链表的头部元素：" + pop);
//删除出现的第一个元素
//list.removeFirstOccurrence("abc");
//删除出现的最后一个元素
list.removeLastOccurrence("abc");
System.out.println(Arrays.toString(list.toArray()));
}
}
3.LinkedList – 队列模式
含义：先进先出
import java.util.LinkedList;
public class Test03 {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
list.add("兰陵王1");
list.add("兰陵王2");
list.add("兰陵王3");
list.add("兰陵王4");
list.add("兰陵王5");
list.add("兰陵王6");
System.out.println("获取元素个数：" + list.size());//6
while (!list.isEmpty()) {
String removeFirst = list.removeFirst();
System.out.println(removeFirst);
}
System.out.println("获取元素个数：" + list.size());//0
}
}
4.LinkedList – 栈模式
含义：先进后出、后进先出
import java.util.LinkedList;
public class Test04 {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
//将元素压入栈顶
list.push("不知火舞1");
list.push("不知火舞2");
list.push("不知火舞3");
list.push("不知火舞4");
list.push("不知火舞5");
System.out.println("获取元素个数：" + list.size());//5
while (!list.isEmpty()) {
//删除栈顶元素，并返回
String pop = list.pop();
System.out.println(pop);
}
System.out.println("获取元素个数：" + list.size());//0
}
}
二、Vector
1.Vector的使用
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.Vector;
public class Test01 {
public static void main(String[] args) {
//创建Vector对象
Vector<String> list = new Vector<>();
//添加元素
list.add("张飞");
list.add("关羽");
list.add("刘备");
list.add("赵云");
list.add("马超");
list.add("黄忠");
list.add("黄忠");
//设置指定下标上的元素
list.set(3, "曹操");
//获取指定下标上的元素
String str = list.get(3);
System.out.println("获取指定下标上的元素：" + str);
//获取元素个数
int size = list.size();
System.out.println("获取元素个数：" + size);//7
//插入元素
list.add(4,"韩信");
Vector<String> newList1 = new Vector<>();
//利用集合工具类做批量添加
Collections.addAll(newList1, "aaa","bbb","ccc");
//将newList1中所有的元素添加到list末尾
list.addAll(newList1);
Vector<String> newList2 = new Vector<>();
//利用集合工具类做批量添加
Collections.addAll(newList2, "xxx","yyy","zzz");
//将newList2中所有的元素添加到list指定下标的位置
list.addAll(newList2);
//清空集合中所有的元素
//list.clear();
System.out.println("判断集合中是否包含指定元素：" + list.contains("关羽"));
System.out.println("判断集合中是否包含子集合：" + list.containsAll(newList1));
System.out.println("获取集合中元素第一次出现的下标：" + list.indexOf("黄忠"));
System.out.println("获取集合中元素最后一次出现的下标：" + list.lastIndexOf("黄忠"));
//(注意：不包含元素返回true，包含元素返回false)
System.out.println("判断集合中是否不包含元素：" + list.isEmpty());
//根据下标删除元素
list.remove(3);
//根据元素删除元素
list.remove("曹操");
//去除交集(删除list中包含了newList1中所有的元素)
list.removeAll(newList1);
//保留交集(b敖柳list中包含了newList2中所有的元素)
list.retainAll(newList2);
//替换指定下标上的元素
list.set(1,"夏侯惇");
//将集合转换为数组
Object[] array = list.toArray();
System.out.println(Arrays.toString(array));
//将集合转换为数组
String[] ss = new String[list.size()];
list.toArray(ss);
System.out.println(Arrays.toString(ss));
System.out.println("---------------------");
//遍历方式1 -- for循环
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("-----------------------");
//遍历方式2 -- foreach
for (String element : list) {
System.out.println(element);
}
System.out.println("-------------------------");
//遍历方式3 -- Iterator
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
//判断是否有可迭代的元素
String next = iterator.next();
//返回下一个元素
System.out.println(next);
}
System.out.println("--------------------------");
//遍历方式4 -- ListIterator
ListIterator<String> listIterator = list.listIterator();
while (listIterator.hasNext()) {
//判断是否有可迭代的元素
String next = listIterator.next();
//返回下一个元素
System.out.println(next);
}
}
}
2.Vector原始的方法
1.理解：
Vector是JDK1.0开始就存在集合类（元老级别的集合类），集合框架的概念是从JDK1.2开始，Java的设计者为了将Vector保留下来，又让Vector多实现了一个接口(List)
2.底层的数据结构：一维数组
3.ArrayList vs Vector
1.相同点：数据结构是一维数组
2.不同点：
ArrayList线程不安全的
Vector线程安全的
import java.util.Enumeration;
import java.util.Vector;
public class Test02 {
public static void main(String[] args) {
Vector<String> v = new Vector<>();
//添加元素
v.addElement("武媚娘1");
v.addElement("武媚娘2");
v.addElement("武媚娘3");
v.addElement("武媚娘4");
v.addElement("武媚娘5");
v.addElement("武媚娘6");
//根据下标删除
v.removeElementAt(0);
//根据元素删除
v.removeElement("武媚娘4");
//遍历
Enumeration<String> elements = v.elements();
while (elements.hasMoreElements()) {
String nextElement = elements.nextElement();
System.out.println(nextElement);
}
}
}
三、Stack
1.Stack独有的方法
2.特点：栈的数据结构 – 先进后出
3.继承关系：class Stack extends Vector
import java.util.Stack;
public class Test01 {
public static void main(String[] args) {
Stack<String> stack = new Stack<>();
//将元素压入栈顶
stack.push("大桥1");
stack.push("大桥2");
stack.push("大桥3");
stack.push("大桥4");
stack.push("大桥5");
stack.push("大桥6");
//查询元素距离栈顶的位置(从1开始)
int search = stack.search("大桥6");
System.out.println("查询元素距离栈顶的位置：" + search);//1
//查看栈顶元素
String peek = stack.peek();
System.out.println("查看栈顶元素：" + peek);//大桥6
while (!stack.empty()) {
String pop = stack.pop();
System.out.println(pop);
}
}
}
四、Set接口 -------HashSet
1.HashSet的使用
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
public class Test01 {
public static void main(String[] args) {
//创建HashSet对象
HashSet<String> set = new HashSet<>();
//添加元素
set.add("曹操");
set.add("戏志才");
set.add("郭嘉");
set.add("于禁");
set.add("典韦");
set.add("夏侯惇");
set.add("于禁");
//获取元素个数/
int size = set.size();
System.out.println("获取元素个数：" + size);//7
HashSet<String> newSet1 = new HashSet<>();
//利用集合工具类做批量添加
Collections.addAll(newSet1, "aaa","bbb","ccc");
//将newset1中所有的元素添加到set末尾
set.addAll(newSet1);
//清空集合中所有的元素
//set.clear();
System.out.println("判断集合中是否包含指定元素：" + set.contains("曹操"));//true
System.out.println("判断集合中是否包含子集合：" + set.containsAll(newSet1));//true
//(注意：不包含元素返回true，包含元素返
System.out.println("判断集合中是否不包含元素：" + set.isEmpty());//false 返回false)
set.remove("典韦");//根据元素删除元素
set.removeAll(newSet1);//去除交集(删除set中包含了newSet1中所有的元素)
HashSet<String> newSet2 = new HashSet<>();
Collections.addAll(newSet2, "郭嘉","夏侯惇","戏志才");
set.retainAll(newSet2);//保留交集(b敖柳set中包含了newset2中所有的元素)
//将集合转换为数组
Object[] array = set.toArray();
System.out.println(Arrays.toString(array));
//将集合转换为数组
String[] ss = new String[set.size()];
set.toArray(ss);
System.out.println(Arrays.toString(ss));
System.out.println("---------------------");
//遍历方式1 -- foreach
for (String element : set) {
System.out.println(element);
}
System.out.println("---------------------");
//遍历方式2 -- Iterator
Iterator<String> iterator = set.iterator();
while(iterator.hasNext()){//判断是否有可迭代的元素
String next = iterator.next();//返回下一个元素
System.out.println(next);
}
}
}
2.理解HashSet为什么无序且不可重复
3.无序：存入顺序和取出顺序不一致（无序不代表随机）
4.存入元素的逻辑：
1.获取元素的hash值
2.通过hash值计算出在一维数组中的下标
3.判断该下标上是否有元素
1. 没有元素 – 直接将元素存入
2 .有元素 — 判断两个元素是否相同（hash || == && equals）
不相同 – JDK1.7头插法、JDK1.8尾插法 – （单向链表）
相同 — 则不存入（去重的效果）
5.取出元素的逻辑：遍历数组
import java.util.HashSet;
public class Test02 {
public static void main(String[] args) {
HashSet<String> set = new HashSet<>();
set.add("曹操");
set.add("戏志才");
set.add("郭嘉");
set.add("于禁");
set.add("典韦");
set.add("Aa");//hash值 -- 2112
set.add("BB");//hash值 -- 2112
for (String element : set) {
System.out.println(element);
}
}
}
五、LinkedHashSet
1.LinkedHashSet的使用
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.Iterator;
public class Test01 {
public static void main(String[] args) {
//创建LinkedHashSet对象
LinkedHashSet<String> set = new LinkedHashSet<>();
//添加元素
set.add("曹操");
set.add("戏志才");
set.add("郭嘉");
set.add("于禁");
set.add("典韦");
set.add("夏侯惇");
set.add("于禁");
//获取元素个数/
int size = set.size();
System.out.println("获取元素个数：" + size);//7
LinkedHashSet<String> newSet1 = new LinkedHashSet<>();
//利用集合工具类做批量添加
Collections.addAll(newSet1, "aaa","bbb","ccc");
//将newset1中所有的元素添加到set末尾
set.addAll(newSet1);
//清空集合中所有的元素
//set.clear();
System.out.println("判断集合中是否包含指定元素：" + set.contains("曹操"));//true
System.out.println("判断集合中是否包含子集合：" + set.containsAll(newSet1));//true
//(注意：不包含元素返回true，包含元素返
System.out.println("判断集合中是否不包含元素：" + set.isEmpty());//false 返回false)
set.remove("典韦");//根据元素删除元素
set.removeAll(newSet1);//去除交集(删除set中包含了newSet1中所有的元素)
LinkedHashSet<String> newSet2 = new LinkedHashSet<>();
Collections.addAll(newSet2, "郭嘉","夏侯惇","戏志才");
set.retainAll(newSet2);//保留交集(b敖柳set中包含了newset2中所有的元素)
//将集合转换为数组
Object[] array = set.toArray();
System.out.println(Arrays.toString(array));
//将集合转换为数组
String[] ss = new String[set.size()];
set.toArray(ss);
System.out.println(Arrays.toString(ss));
System.out.println("---------------------");
//遍历方式1 -- foreach
for (String element : set) {
System.out.println(element);
}
System.out.println("---------------------");
//遍历方式2 -- Iterator
Iterator<String> iterator = set.iterator();
while(iterator.hasNext()){//判断是否有可迭代的元素
String next = iterator.next();//返回下一个元素
System.out.println(next);
}
}
}
2.理解LinkedHashSet为什么无序且不可重复
import java.util.LinkedHashSet;
public class Test02 {
public static void main(String[] args) {
LinkedHashSet<String> set = new LinkedHashSet<>();
set.add("曹操");
set.add("戏志才");
set.add("郭嘉");
set.add("于禁");
set.add("典韦");
for (String element : set) {
System.out.println(element);
}
}
}
六 、TreeSet
1.TreeSet的使用
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.TreeSet;
public class Test01 {
public static void main(String[] args) {
//创建TreeSet对象
TreeSet<String> set = new TreeSet<>();
//添加元素
set.add("曹操");
set.add("戏志才");
set.add("郭嘉");
set.add("于禁");
set.add("典韦");
set.add("夏侯惇");
set.add("于禁");
//获取元素个数
int size = set.size();
System.out.println("获取元素个数：" + size);//7
TreeSet<String> newSet1 = new TreeSet<>();
//利用集合工具类做批量添加
Collections.addAll(newSet1, "aaa","bbb","ccc");
//将newset1中所有的元素添加到set末尾
set.addAll(newSet1);
//清空集合中所有的元素
//set.clear();
System.out.println("判断集合中是否包含指定元素：" + set.contains("典韦"));//true
System.out.println("判断集合中是否包含子集合：" + set.containsAll(newSet1));//true
//(注意：不包含元素返回true，包含元素返回false)
System.out.println("判断集合中是否不包含元素：" + set.isEmpty());//false (注意：不包含元素返回true，包含元素返回false)
//根据元素删除元素
set.remove("于禁");
//去除交集(删除set中包含了newSet1中所有的元素)
set.removeAll(newSet1);
TreeSet<String> newSet2 = new TreeSet<>();
Collections.addAll(newSet2, "曹操","戏志才","郭嘉");
//保留交集(b敖柳set中包含了newset2中所有的元素)
set.retainAll(newSet2);
//将集合转换为数组
Object[] array = set.toArray();
System.out.println(Arrays.toString(array));
//将集合转换为数组
String[] ss = new String[set.size()];
set.toArray(ss);
System.out.println(Arrays.toString(ss));
System.out.println("---------------------");
//遍历方式1 -- foreach
for (String element : set) {
System.out.println(element);
}
System.out.println("---------------------");
//遍历方式2 -- Iterator
Iterator<String> iterator = set.iterator();
while(iterator.hasNext()){//判断是否有可迭代的元素
String next = iterator.next();//返回下一个元素
System.out.println(next);
}
}
}
2.理解TreeSet的自然排序
自然排序：根据不同的类型选择不同的排序方式
import java.util.Arrays;
import java.util.TreeSet;
public class Test02 {
public static void main(String[] args) {
//TreeSet存储Integer类的排序方式：数字升序
TreeSet<Integer> set1 = new TreeSet<>();
set1.add(4);
set1.add(2);
set1.add(1);
set1.add(5);
set1.add(3);
set1.add(3);
set1.add(1);
System.out.println(Arrays.toString(set1.toArray()));
//TreeSet存储String类的排序方式：字典排序
TreeSet<String> set2 = new TreeSet<>();
set2.add("a");
set2.add("c");
set2.add("bd");
set2.add("c");
set2.add("b");
set2.add("d");
set2.add("bc");
System.out.println(Arrays.toString(set2.toArray()));
}
}