容器
容器简介
容器，是用来容纳物体、管理物体。生活中,
我们会用到各种各样的 容器。如锅碗瓢盆、箱子和包等。
程序中的“
容器
”
也有类似的功能，用来容纳和管理数据。
基于数组并不能满足我们对于“
管理和组织数据的需求
”
，所以我们需要一种更强大、更灵活、容量随时可扩的容器来装载我们的对象。 这就是我们今天要学习的容器，也叫集合(Collection)
。
容器的结构
单例集合
Collection接口介绍
Collection 表示一组对象，它是集中、收集的意思。
Collection
接口的两个子接口是List
、
Set
接口。
Collection接口中定义的方法
双例集合
List接口特点
List是有序、可重复的容器。
有序：有序
(
元素存入集合的顺序和取出的顺序一致
)
。
List
中每个元素都有索引标记。可以根据元素的索引标记（在List
中的位置）访问元素，从而精确控制这些元素。
可重复：List
允许加入重复的元素。更确切地讲，
List
通常允许满足e1.equals(e2) 的元素重复加入容器。
ArrayList容器的基本使用
ArrayList是
List
接口的实现类。是
List
存储特征的具体实现。
ArrayList底层是用数组实现的存储。 特点：查询效率高，增删效率低，线程不安全。
public class ArrayListTest {
public static void main(String[] args) {
//实例化ArrayList容器
List<String> list = new ArrayList<>();
//添加元素
boolean flag1 = list.add("秃头");
boolean flag2 = list.add("小子");
boolean flag3 = list.add("TuT");
boolean flag4 = list.add("XiZ");
System.out.println(flag1+"\t"+flag2+"\t"+flag3+"\t"+flag4);
//删除元素
boolean flag4 =list.remove("秃头");
System.out.println(flag4);
//获取容器中元素的个数
int size = list.size();
System.out.println(size);
//判断容器是否为空
boolean empty = list.isEmpty();
System.out.println(empty);
//容器中是否包含指定的元素
boolean value =list.contains("TuT");
System.out.println(value);
//清空容器
list.clear();
Object[] objects1 = list.toArray();
System.out.println(Arrays.toString(objects1));
}
}ArrayList容器的索引操作
public class ArrayListTest2 {
public static void main(String[] args) {
//实例化容器
List<String> list = new ArrayList<>();
//添加元素
list.add("tut");
list.add("秃头");
//向指定位置添加元素
list.add(0,"小子");
System.out.println("获取元素");
String value1 = list.get(0);
System.out.println(value1);
System.out.println("获取所有元素方式一");
//使用普通for循环
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
System.out.println("获取所有元素方式二");
//使用Foreach循环
for(String str:list){
System.out.println(str);
}
System.out.println("元素替换");
list.set(1,"sun");
for(String str:list){
System.out.println(str);
}
System.out.println("根据索引位置删除元素);
String value2 = list.remove(1);
System.out.println(value2);
System.out.println("----------------");
for(String str:list){
System.out.println(str);
}
System.out.println("查找元素第一次出现的位置");
int value3 = list.indexOf("小子");
System.out.println(value3);
System.out.println("查找元素最后一次出现的位置");
list.add("小子");
for(String str:list){
System.out.println(str);
}
int value4 =list.lastIndexOf("小子");
System.out.println(value4);
}
}ArrayList的并集、交集、差集
并集
//并集操作：将另一个容器中的元素添加到当前容器中
List<String> a = new ArrayList<>();
a.add("a");
a.add("b");
a.add("c");
List<String> b = new ArrayList<>();
b.add("a");
b.add("b");
b.add("c");
//a并集b
a.addAll(b);
for(String str :a){
System.out.println(str);
}
交集
//交集操作：保留相同的，删除不同的
List<String> a1 = new ArrayList<>();
a1.add("a");
a1.add("b");
a1.add("c");
List<String> b1 = new ArrayList<>();
b1.add("a");
b1.add("d");
b1.add("e");
//交集操作
a1.retainAll(b1);
for(String str :a1){40
System.out.println(str);
}
差集
//差集操作：保留不同的，删除相同的
List<String> a2 = new ArrayList<>();
a2.add("a");
a2.add("b");
a2.add("c");
List<String> b2= new ArrayList<>();
b2.add("b");
b2.add("c");
b2.add("d");
a2.removeAll(b2);
for(String str :a2){
System.out.println(str);
}ArrayList底层是用数组实现的存储。
Vector容器的基本使用
Vector底层是用数组实现的，相关的方法都加了同步检查，因此
“
线程安全,
效率低
”
。 比如，
indexOf
方法就增加了
synchronized
同步标记。
Vector
的使用
Vector的使用与
ArrayList
是相同的，因为他们都实现了
List
接口，对List
接口中的抽象方法做了具体实现。
public class VectorTest {
public static void main(String[] args) {
//实例化Vector
List<String> v = new Vector<>();
v.add("a");
v.add("b");
v.add("a");
for(int i=0;i<v.size();i++){
System.out.println(v.get(i));
}
System.out.println("----------------------");
for(String str:v){
System.out.println(str);
}
}
}LinkedList容器的基本使用
LinkedList底层用双向链表实现的存储。特点：查询效率低，增删效率高，线程不安全。
双向链表也叫双链表，是链表的一种，它的每个数据节点中都有两个指针，分别指向前一个节点和后一个节点。 所以，从双向链表中的任意一个节点开始，都可以很方便地找到所有节点。
每个节点都应该有 3 部分内容：class Node < E > {Node < E > previous ; // 前一个节点E element ; // 本节点保存的数据Node < E > next ; // 后一个节点}
List 实现类的选用规则如何选用ArrayList 、 LinkedList 、 Vector?1 需要线程安全时，用 Vector 。2 不存在线程安全问题时，并且查找较多用 ArrayList （一般使用它）3 不存在线程安全问题时，增加或删除元素较多用 LinkedList
LinkedList容器的使用（List标准）
LinkedList实现了
List
接口，所以
LinkedList
是具备
List
的存储特征的(有序，元素有重复
)
。
public class LinkedListTest {
public static void main(String[] args) {
//实例化LinkedList容器
List<String> list = new LinkedList<>();
//添加元素
boolean a = list.add("a");
boolean b = list.add("b");
boolean c = list.add("c");
list.add(3,"a");
System.out.println(a+"\t"+b+"\t"+c);LinkedList容器的使用（非List标准）
方法说明：
- void addFirst(E e) 将指定元素插入到开头
- void addLast(E e) 将指定元素插入到结尾
- getFirst() 返回此链表的第一个元素
- getLast() 返回此链表的最后一个元素
- removeFirst() 移除此链表中的第一个元素，并返回这个元素
- removeLast() 移除此链表中的最后一个元素，并返回这个元素
- E pop() 从此链表所表示的堆栈处弹出一个元素,等效于removeFirst
- void push(E e) 将元素推入此链表所表示的堆栈 这个等效于addFisrt(E e)
public class LinkedListTest2 {
public static void main(String[] args) {
System.out.println("-------LinkedList-------------");
//将指定元素插入到链表开头
LinkedList<String> linkedList1 = newLinkedList<>();
linkedList1.addFirst("a");
linkedList1.addFirst("b");
linkedList1.addFirst("c");
for (String str:linkedList1){
System.out.println(str);
}
System.out.println("----------------------");
//将指定元素插入到链表结尾
LinkedList<String> linkedList = newLinkedList<>();
linkedList.addLast("a");
linkedList.addLast("b");
linkedList.addLast("c");
for (String str:linkedList){
System.out.println(str);
}
System.out.println("---------------------------");
//返回此链表的第一个元素
System.out.println(linkedList.getFirst());
//返回此链表的最后一个元素
System.out.println(linkedList.getLast());
System.out.println("-----------------------");
//移除此链表中的第一个元素，并返回这个元素
linkedList.removeFirst();
//移除此链表中的最后一个元素，并返回这个元素
linkedList.removeLast();
for (String str:linkedList){
System.out.println(str);
}
System.out.println("-----------------------");
linkedList.addLast("c");
//从此链表所表示的堆栈处弹出一个元素,等效于removeFirst
linkedList.pop();
for (String str:linkedList){
System.out.println(str);
}
System.out.println("-------------------");
//将元素推入此链表所表示的堆栈 这个等效于addFisrt(E e)
linkedList.push("h");
for (String str:linkedList){
System.out.println(str);
}
}
}
只讲干货
#有什么错误的地方大家多多担待，欢迎大家留下意见共同努力。
#需要什么技术的内容大家也可以积极留言。
#有升本的伙伴也可留言，后序也可更新升本内容C 和数据结构。
#有需要的伙伴或有什么问题直接联留下wx或联系邮箱2821835676qq.com
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
