本文介绍了Java集合框架，包括List、Set和Map集合的实现类，如ArrayList、LinkedList、HashSet、LinkedHashSet、TreeSet、HashMap、LinkedHashMap和TreeMap。详细讨论了它们的特点、底层结构、增删查改操作以及效率对比，并提到了Collections工具类的作用。
集合
list集合
Arraylist
add增加
set修改
get查询
remove移除
* 数组：只能存储单一数据类型
* 优点：线性存储 查询速度快
* 缺点：数组一旦声明长度不可修改
* List:有序可重复
* 泛型：限定数据类型
* <>钻石操作符
* ArrayList 新增、删除数据慢 查询快
* LinkedList 新增、删除数快 查询慢
public class ArraylistTest {
@Test
public void test() {
int[] array = new int[5];
array[2] = 2;
System.out.println(Arrays.toString(array));// [0, 0, 2, 0, 0]
}
@Test
public void test01(){
List list = new ArrayList();
byte a = 1;
short b = 2;
int c = 3;
long d = 4L;
double e = 5.0d;
float f = 6.0f;
char g = 'a';
boolean h = false;
String i ="桃李不言下自成蹊";
Persion persion=new Persion();
list.add(a);
list.add(b);
list.add(c);
list.add(d);
list.add(e);
list.add(f);
list.add(g);
list.add(h);
list.add(i);
list.add(persion);
System.out.println(list.size()); //10
}
@Test
public void test02(){
List list=new ArrayList();
list.add("小王");
list.add("小白");
list.add("小王");
System.out.println(list.get(0));//小王
System.out.println(list.get(1));//小白
System.out.println(list.get(2));//小王
}
@Test
public void test03(){
//3种写法
// List<String> list= new ArrayList<String>();
// List<String> list= new ArrayList<>();
// List<String> list= new ArrayList();
List<String> list =new ArrayList<>();
list.add("王鹏飞");
}
@Test
public void test04(){
List<Integer> list01 =new ArrayList<>();
for (int i = 0; i < 5; i++) {
list01.add(i);
}
System.out.println(list01);//[0, 1, 2, 3, 4]
List<Integer> list02 =new ArrayList<>(){
{
for (int i = 0; i < 5; i++) {
add(i);
}
}};
System.out.println(list02);//[0, 1, 2, 3, 4]
}
@Test
public void test05(){
//不可变集合
List<Integer> list =List.of(0,1,2,3,4);
System.out.println(list);
}
@Test
public void test06(){
//不可变集合转为可变集合
List<Integer> list=new ArrayList<>(List.of(0,1,2,3,4));
System.out.println(list);//[0, 1, 2, 3, 4]
list.add(6); //add 增加
System.out.println(list);//[0, 1, 2, 3, 4, 6]
list.set(2,20); //set 修改
System.out.println(list);//[0, 1, 20, 3, 4, 6]
}
@Test
public void test07(){
List<String> list=new ArrayList<>(List.of("0","1","2","3","4"));
System.out.println(list);
//末尾追加
list.add("6");
System.out.println(list);
//向指定位置添加
list.add(5,"5");
System.out.println(list);
//将指定index位置上的元素从集合中删除
list.remove(6);
System.out.println(list);
//在集合中删除指定元素
list.remove("5");
System.out.println(list);
//删除指定的元素的时候，如果有相同的，就会删除一个
//建议使用下标去删除
list.add("王");
list.add("王");
System.out.println(list);
list.remove("王");
System.out.println(list);
//更新指定index位置上的值
list.set(3,"三");
System.out.println(list);
//查询指定index位置上元素的值
System.out.println(list.get(3));
//输出的结果
//[0, 1, 2, 3, 4]
//[0, 1, 2, 3, 4, 6]
//[0, 1, 2, 3, 4, 5, 6]
//[0, 1, 2, 3, 4, 5]
//[0, 1, 2, 3, 4]
//[0, 1, 2, 3, 4, 王, 王]
//[0, 1, 2, 3, 4, 王]
//[0, 1, 2, 三, 4, 王]
//三
}
@Test
public void test08(){
List<Integer> list=new ArrayList<>(List.of(0,1,2,3,4));
for (int i = 0; i < 5; i++) {
System.out.println(list.get(i));
}
System.out.println("元素个数"+list.size()); //元素个数5
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("++++++++++++++++++++++");
//for(集合中的元素数据类型 集合中的每一个元素 ：被遍历的集合)
for (int num : list) {
System.out.println(num);
}
}
@Test
public void test09(){
//迭代的方式
// 在List 上用迭代器遍历
List<Integer> list=new ArrayList<>(List.of(0,1,2,3,4));
Iterator<Integer> it =list.listIterator();
while (it.hasNext()){
Integer next=it.next();
System.out.println(next); //01234
}
System.out.println("第一次"); //第一次 第二次 第三次
while (it.hasNext()){
Integer next=it.next();
System.out.println(next);
}
System.out.println("第二次");
while (it.hasNext()){
Integer next=it.next();
System.out.println(next);
}
System.out.println("第三次");
//
}
@Test
public void test10(){
List<Integer> list=new ArrayList<>(List.of(0,1,2,3,4));
list.stream().forEach(System.out::println);
}
}
泛型
泛型可以理解为参数的数据类型
List list=new ArrayList<>(List.of(0,1,2,3,4));
迭代器
Iterator<Integer> it =list.listIterator();
while (it.hasNext()){
Integer next=it.next();
System.out.println(next); //0，1，2，3
}
- List： 有序可重复 有序指的是下标有序 可重复指的是不同下标位置上可以存储相同值的元素
- Set： 无序不可重复 录入的顺序和存储的顺序不一致 不可重复指的是相同值的元素不可重复存储
isEmpty
public void test01(){
Collection c = new ArrayList();
c.add(1);
c.add(2);
System.out.println(c);
System.out.println(c.isEmpty()); //判断是否为空
}
快速失败机制
public void test06(){
//快速失败机制
Collection c = new ArrayList();
c.add("tom");
c.add("jack");
c.add("rose");
c.add("jerry");
Iterator it = c.iterator();
while (it.hasNext()){
Object o = it.next();
if ("jack".equals(o)){
// c.remove(o); //集合的方法 会造成数据异常
it.remove();//迭代器的方法
}
}
System.out.println(c);
}
遍历集合
public void test01(){
ArrayList list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
//遍历方式一
Iterator it = list.iterator();
while (it.hasNext()){
System.out.println(it.next());
// Object next = it.next();
// System.out.println(next);
}
//方式二 增强for
for (Object o : list) {
System.out.println(o);
}
//方式三 普通for循环
for (int i = 0; i < list.size(); i++) {
Object o = list.get(i);
System.out.println(o);
}
}
Arrays.aslist
//Arrays.aslist 可以生成一个list集合，是一个不可变集合（不能修改）
LinkedList
特点：
- 元素有序 可重复 可以通过所以访问元素
- 底层双向链表
- 增删快 查询慢
- 线性安全 效率低
public class LinkedList{
@Test
public void test01(){
List list = new LinkedList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
Iterator it=list.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
}
## ListIterator迭代器
List 集合额外提供了一个 listIterator() 方法，该方法返回一个 ListIterator 对象， ListIterator 接口继承了 Iterator 接口，提供了专门操作 List 的方法：
set集合
Set是一个Collection接口的典型子接口。
Set接口代表的集合特点：元素都是唯一的。通常元素都是无序的。
HashSet实现类
- 元素唯一 无序
- 底层结构 哈希表
- 综合效率高
- 特殊的 hashset 存储student 对象时，
- hashset 判断两个元素相同的依据是：
1.先比较元素的hashcode值
2.元素哈希值相同，在进行equals判断。如果都相同 则元素相同
public class HashSetTest {
@Test
public void test01(){
HashSet<String> set = new HashSet<>();
set.add("tom");
set.add("jock");
set.add("rose");
set.add("jerry");
Iterator<String> it = set.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
linkedhashset
- 元素唯一 有序
- 底层结构 哈希表基础上 维护一个链表 用于保证元素的迭代顺序
- 效率 略低于hashset
Treeset
-
元素唯一 无序 但实现了 排序
-
底层结构：红黑树 -一种相对平衡的二叉树
-
效率 查询效率高于链表
-
排序原理：
-
存储元素过程：先存储根节点，其余元素小的放右边，大的放左边
-
取出元素过程：采用中序遍历 ，即在左中右的遍历
-
TreeSet 集合要所有元素必须实现 comparde 接口 那么元素就可以比较大小了
-
或者创建TreeSet 集合时通过构造器传入一个比较器，用于 比较元素大小
map集合
- map 是一个顶层接口 表示一组键值对
- 特定 key 是唯一 通过key 可以映射到value
- map 的典型实现类
- hashmap 、linkedhashmap 、treemap 、hashtable、 properties
public class MapTest {
@Test
public void test01(){
//创建map集合
HashMap<String, String> map = new HashMap<>();
//key 是唯一的
map.put("小白","小黑");
map.put("小红","小绿");
map.put("好好","学习");
map.put("虚线","直线");
System.out.println(map);
System.out.println(map.isEmpty());
}
@Test
public void test02(){
Map<Integer,String> map =new HashMap<>();
map.put(01,"tom");
map.put(02,"jer");
map.put(03,"ros");
map.put(04,"tom");
//遍历map集合
Set<Integer> set =map.keySet();
for (Integer key : set) {
String value=map.get(key);
System.out.println(key+"---"+value);
}
}
@Test
public void test03(){
Map<Integer,String> map =new HashMap<>();
map.put(01,"tom");
map.put(02,"jerr");
map.put(03,"rose");
map.put(04,"tom");
//遍历
Set<Map.Entry<Integer,String>> set =map.entrySet();//把每对key-value 看成以恶搞entry封装到一个set集合
for (Map.Entry<Integer, String> entry : set) {
//通过entry 获取 key 和value
Integer key= entry.getKey();
String value= entry.getValue();
System.out.println(key+"---"+value);
}
}
}
HashMap
- 特点 key 唯一 无序
- 底层结构：哈希表
- 效率：综合效率高
- key 去重原理， 先比较key 的哈希值 然后哈希值相同，在进行equals比较
public class HashMapTest {
@Test
public void test01(){
HashMap<String,Integer> map =new HashMap<>();
map.put("tom",18);
map.put("jerr",20);
map.put("rose",19);
map.put("tom",20);
//遍历
Set<String> keySet=map.keySet();
for (String key : keySet) {
Integer value=map.get(key);
System.out.println(key +value);
//去重了，因为字符串 hashcode 重写了
}
}
* linkedHashMap 实现类
- 是hashmap 的子类
- 特点：key 唯一 有序
- 底层结构：哈希表基础维护一个链表 用于保证元素的迭代顺序
- 效率：略低于hashmap
* public class LinkedHashMapTest {
@Test
public void test01(){
HashMap<String,Integer> map =new HashMap<>();
map.put("tom",18);
map.put("jerr",20);
map.put("rose",19);
map.put("tom",20);
Set<Map.Entry<String,Integer>> entries=map.entrySet();
for (Map.Entry<String, Integer> entry : entries) {
String key =entry.getKey();
Integer value=entry.getValue();
System.out.println(key+value);
}
}
}
* TreeMap 实现类
- 特点：key 唯一 无序 但实现了排序
- 底层结构：红黑树
- 效率：高于链表
- TreeMap 集合实现了对象key的排序，所以要求key 必须可以比较大小，即要求key类型实现了comparable接口
- 或者创建treemap 集合时 传入一个comparator 比较器来比较key 的大小
public class TreeMapTest {
@Test
public void test01(){
TreeMap<Integer,String> map=new TreeMap<>();
map.put(110,"警察");
map.put(120,"医生");
map.put(119,"急救");
map.put(114,"坦克");
Set<Integer> keys =map.keySet();
for (Integer key : keys) {
String value=map.get(key);
System.out.println(key+value);
}
}
}
Collections工具类
Collections 是一个操作 Set、List 和 Map 等集合的工具类。Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法：
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
