一篇文章带你入门java集合
一、简介
1、java集合框架图
从上面的集合框架图可以看到，java 集合框架主要包括两种类型的容器，一种是集合（collection），存储一个元素集合，另一种是图（map），存储键/值对映射。collection 接口又有 3 种子类型，list、set 和 queue，再下面是一些抽象类，最后是具体实现类，常用的有 arraylist、linkedlist、hashset、linkedhashset、hashmap、linkedhashmap 等等。
集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容：
- 接口：是代表集合的抽象数据类型。例如 collection、list、set、map 等。之所以定义多个接口，是为了以不同的方式操作集合对象
- 实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：arraylist、linkedlist、hashset、hashmap。
- 算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。
除了集合，该框架也定义了几个 map 接口和类。map 里存储的是键/值对。尽管 map 不是集合，但是它们完全整合在集合中。
2、集合框架体系
3、set和list的区别
1)set 接口实例存储的是无序的，不重复的数据。list 接口实例存储的是有序的，可以重复的元素
2)set 接口实例存储的是无序的，不重复的数据。list 接口实例存储的是有序的，可以重复的元素
3)list和数组类似，可以动态增长，根据实际存储的数据的长度自动增长list的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有arraylist,linkedlist,vector>
二、arraylist
1、定义
arraylist 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。
arraylist 继承了 abstractlist ，并实现了 list 接口。
arraylist 类位于 java.util 包中，使用前需要引入它，语法格式如下：
import java.util.arraylist; // 引入 arraylist 类 arraylist<e> objectname =new arraylist<>(); // 初始化
2、用实例了解arraylist
@test
public void listtest(){
list<integer> list = new arraylist<integer>();
//增加元素
list.add(1);
list.add(9);
list.add(8);
list.add(4);
list.add(5);
list.add(3);
//访问
system.out.println("list新增完元素访问:");
for(int s : list){
system.out.print(s+" ");
}
system.out.println();
//用set方法修改
list.set(2, 10);
//访问
system.out.println("list修改完元素访问:");
for(int s : list){
system.out.print(s+" ");
}
system.out.println();
list.remove(2);
//访问
system.out.println("list删除完元素访问:");
for(int s : list){
system.out.print(s+" ");
}
system.out.println();
//当前list大小
system.out.println("list当前数据元素个数:"+list.size());
//排序
collections.sort(list);//默认升序
//访问
system.out.println("list排序完元素访问:");
for(int s : list){
system.out.print(s+" ");
}
system.out.println();
}
结果:
list新增完元素访问:
1 9 8 4 5 3
list修改完元素访问:
1 9 10 4 5 3
list删除完元素访问:
1 9 4 5 3
list当前数据元素个数:5
list排序完元素访问:
1 3 4 5 9
java arraylist 常用方法列表如下：
| 方法 | 描述 |
|---|---|
| 将元素插入到指定位置的 arraylist 中 | |
| addall() | 添加集合中的所有元素到 arraylist 中 |
| 删除 arraylist 中的所有元素 | |
| 复制一份 arraylist | |
| 判断元素是否在 arraylist | |
| 通过索引值获取 arraylist 中的元素 | |
| indexof() | 返回 arraylist 中元素的索引值 |
| removeall() | 删除存在于指定集合中的 arraylist 里的所有元素 |
| 删除 arraylist 里的单个元素 | |
| 返回 arraylist 里元素数量 | |
| isempty() | 判断 arraylist 是否为空 |
| sublist() | 截取部分 arraylist 的元素 |
| 替换 arraylist 中指定索引的元素 | |
| 对 arraylist 元素进行排序 | |
| toarray() | 将 arraylist 转换为数组 |
| tostring() | 将 arraylist 转换为字符串 |
| ensurecapacity() | 设置指定容量大小的 arraylist |
| lastindexof() | 返回指定元素在 arraylist 中最后一次出现的位置 |
| retainall() | 保留 arraylist 中在指定集合中也存在的那些元素 |
| containsall() | 查看 arraylist 是否包含指定集合中的所有元素 |
| trimtosize() | 将 arraylist 中的容量调整为数组中的元素个数 |
| removerange() | 删除 arraylist 中指定索引之间存在的元素 |
| replaceall() | 将给定的操作内容替换掉数组中每一个元素 |
| removeif() | 删除所有满足特定条件的 arraylist 元素 |
| foreach() | 遍历 arraylist 中每一个元素并执行特定操作 |
三、linkedlist
链表（linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。
链表可分为单向链表和双向链表。
一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接
一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。
java linkedlist（链表） 类似于 arraylist，是一种常用的数据容器。
与 arraylist 相比，linkedlist 的增加和删除对操作效率更高，而查找和修改的操作效率较低。
以下情况使用 arraylist :
频繁访问列表中的某一个元素。只需要在列表末尾进行添加和删除元素操作。
以下情况使用 linkedlist :
你需要通过循环迭代来访问列表中的某些元素。需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。
1、语法
// 引入 linkedlist 类 import java.util.linkedlist; linkedlist<e> list = new linkedlist<e>(); // 普通创建方法 或者 linkedlist<e> list = new linkedlist(collection<? extends e> c); // 使用集合创建链表
2、示例
@test
public void linklisttest(){
linkedlist<integer> nums = new linkedlist<integer>();
//添加
nums.add(3);
nums.add(5);
nums.add(1);
nums.add(8);
system.out.println(nums);
// 使用 addfirst() 在头部添加元素
nums.addfirst(0);
system.out.println(nums);
nums.addlast(20);
system.out.println(nums);
//移除首位
nums.removefirst();
system.out.println(nums);
// 使用 getfirst() 获取头部元素
system.out.println(nums.getfirst());
//for循环迭代
for (int size = nums.size(), i = 0; i < size; i++) {
system.out.println(nums.get(i));
}
}
结果:
[3, 5, 1, 8]
[0, 3, 5, 1, 8]
[0, 3, 5, 1, 8, 20]
[3, 5, 1, 8, 20]
3
3
5
1
8
20
| 方法 | 描述 |
|---|---|
| public boolean add(e e) | 链表末尾添加元素，返回是否成功，成功为 true，失败为 false。 |
| public void add(int index, e element) | 向指定位置插入元素。 |
| public boolean addall(collection c) | 将一个集合的所有元素添加到链表后面，返回是否成功，成功为 true，失败为 false。 |
| public boolean addall(int index, collection c) | 将一个集合的所有元素添加到链表的指定位置后面，返回是否成功，成功为 true，失败为 false。 |
| public void addfirst(e e) | 元素添加到头部。 |
| public void addlast(e e) | 元素添加到尾部。 |
| public boolean offer(e e) | 向链表末尾添加元素，返回是否成功，成功为 true，失败为 false。 |
| public boolean offerfirst(e e) | 头部插入元素，返回是否成功，成功为 true，失败为 false。 |
| public boolean offerlast(e e) | 尾部插入元素，返回是否成功，成功为 true，失败为 false。 |
| public void clear() | 清空链表。 |
| public e removefirst() | 删除并返回第一个元素。 |
| public e removelast() | 删除并返回最后一个元素。 |
| public boolean remove(object o) | 删除某一元素，返回是否成功，成功为 true，失败为 false。 |
| public e remove(int index) | 删除指定位置的元素。 |
| public e poll() | 删除并返回第一个元素。 |
| public e remove() | 删除并返回第一个元素。 |
| public boolean contains(object o) | 判断是否含有某一元素。 |
| public e get(int index) | 返回指定位置的元素。 |
| public e getfirst() | 返回第一个元素。 |
| public e getlast() | 返回最后一个元素。 |
| public int indexof(object o) | 查找指定元素从前往后第一次出现的索引。 |
| public int lastindexof(object o) | 查找指定元素最后一次出现的索引。 |
| public e peek() | 返回第一个元素。 |
| public e element() | 返回第一个元素。 |
| public e peekfirst() | 返回头部元素。 |
| public e peeklast() | 返回尾部元素。 |
| public e set(int index, e element) | 设置指定位置的元素。 |
| public object clone() | 克隆该列表。 |
| public iterator descendingiterator() | 返回倒序迭代器。 |
| public int size() | 返回链表元素个数。 |
| public listiterator listiterator(int index) | 返回从指定位置开始到末尾的迭代器。 |
| public object[] toarray() | 返回一个由链表元素组成的数组。 |
| public t[] toarray(t[] a) | 返回一个由链表元素转换类型而成的数组。 |
四、hashset
1、定义
hashset 基于 hashmap 来实现的，是一个不允许有重复元素的集合。
hashset 允许有 null 值。
hashset 是无序的，即不会记录插入的顺序。
hashset 不是线程安全的， 如果多个线程尝试同时修改 hashset，则最终结果是不确定的。 您必须在多线程访问时显式同步对 hashset 的并发访问。
hashset 实现了 set 接口。
2、语法
import java.util.hashset; // 引入 hashset 类 hashset<string> sites = new hashset<string>();
3、示例
@test
public void settest(){
set<integer> nums = new hashset<integer>();
//添加
nums.add(3);
nums.add(5);
nums.add(5);
nums.add(5);
nums.add(1);
nums.add(8);
system.out.println(nums);
//判断元素是否存在
system.out.println(nums.contains(8));
nums.remove(1); // 删除元素，删除成功返回 true，否则为 false
system.out.println(nums);
//计算大小
system.out.println(nums.size());
for (int i : nums) {//访问
system.out.println(i);
}
//清除
nums.clear();
system.out.println(nums);
}
结果:
[1, 3, 5, 8]
true
[3, 5, 8]
3
3
5
8
[]
五、hashmap
1、定义
hashmap 是一个散列表，它存储的内容是键值对(key-value)映射。
hashmap 实现了 map 接口，根据键的 hashcode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。
hashmap 是无序的，即不会记录插入的顺序。
hashmap 继承于abstractmap，实现了 map、cloneable、java.io.serializable 接口。
hashmap 的 key 与 value 类型可以相同也可以不同，可以是字符串（string）类型的 key 和 value，也可以是整型（integer）的 key 和字符串（string）类型的 value。
2、语法
import java.util.hashmap; // 引入 hashmap 类 hashmap<integer, string> sites = new hashmap<integer, string>();
3、示例
@test
public void maptest(){
// 创建 hashmap 对象 sites
hashmap<string, string> sites = new hashmap<string, string>();
// 添加键值对
sites.put("one", "google");
sites.put("two", "runoob");
sites.put("three", "taobao");
sites.put("four", "zhihu");
system.out.println(sites);
//访问-根据key
system.out.println(sites.get("four"));
//删除
sites.remove("four");
system.out.println(sites);
//计算大小
system.out.println(sites.size());
// 输出 key 和 value
for (string i : sites.keyset()) {
system.out.println("key: " + i + " value: " + sites.get(i));
}
// 返回所有 value 值
for(string value: sites.values()) {
// 输出每一个value
system.out.print(value + ", ");
}
}
结果:
{four=zhihu, one=google, two=runoob, three=taobao}
zhihu
{one=google, two=runoob, three=taobao}
3
key: one value: google
key: two value: runoob
key: three value: taobao
google, runoob, taobao,
java hashmap 方法
hashmap
java hashmap 常用方法列表如下：
| 方法 | 描述 |
|---|---|
| 删除 hashmap 中的所有键/值对 | |
| 复制一份 hashmap | |
| isempty() | 判断 hashmap 是否为空 |
| 计算 hashmap 中键/值对的数量 | |
| 将键/值对添加到 hashmap 中 | |
| putall() | 将所有键/值对添加到 hashmap 中 |
| putifabsent() | 如果 hashmap 中不存在指定的键，则将指定的键/值对插入到 hashmap 中。 |
| 删除 hashmap 中指定键 key 的映射关系 | |
| containskey() | 检查 hashmap 中是否存在指定的 key 对应的映射关系。 |
| containsvalue() | 检查 hashmap 中是否存在指定的 value 对应的映射关系。 |
| 替换 hashmap 中是指定的 key 对应的 value。 | |
| replaceall() | 将 hashmap 中的所有映射关系替换成给定的函数所执行的结果。 |
| 获取指定 key 对应对 value | |
| getordefault() | 获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值 |
| foreach() | 对 hashmap 中的每个映射执行指定的操作。 |
| entryset() | 返回 hashmap 中所有映射项的集合集合视图。 |
| keyset() | 返回 hashmap 中所有 key 组成的集合视图。 |
| 返回 hashmap 中存在的所有 value 值。 | |
| 添加键值对到 hashmap 中 | |
| 对 hashmap 中指定 key 的值进行重新计算 | |
| computeifabsent() | 对 hashmap 中指定 key 的值进行重新计算，如果不存在这个 key，则添加到 hasmap 中 |
| computeifpresent() | 对 hashmap 中指定 key 的值进行重新计算，前提是该 key 存在于 hashmap 中。 |
六、iterator（迭代器）
1、定义
java iterator（迭代器）不是一个集合，它是一种用于访问集合的方法，可用于迭代 arraylist 和 hashset 等集合。
iterator 是 java 迭代器最简单的实现，listiterator 是 collection api 中的接口， 它扩展了 iterator 接口。
2、示例
@test
public void iteratortest(){
list<integer> list = new arraylist<integer>();
//增加元素
list.add(1);
list.add(9);
list.add(8);
list.add(4);
list.add(5);
list.add(3);
iterator<integer> it = list.iterator();
while(it.hasnext()){
int i = it.next();
system.out.print(i+" ");
}
}
结果:
1 9 8 4 5 3
七、list和数组互转
@test
public void arrtolisttest(){
list<integer> list = new arraylist<integer>();
//增加元素
list.add(1);
list.add(9);
list.add(8);
list.add(4);
list.add(5);
list.add(3);
object[] arr = list.toarray();
for(object o : arr){
system.out.print(o+" ");
}
system.out.println();
list<object> ll = arrays.aslist(arr);
system.out.println(ll);
}
结果:
1 9 8 4 5 3
[1, 9, 8, 4, 5, 3]
总结
本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注的更多内容！