学习笔记：集合

最新推荐文章于 2024-06-14 15:02:13 发布

Serein_Pt

最新推荐文章于 2024-06-14 15:02:13 发布

阅读量350

点赞数 3

分类专栏： Java SE 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_49019244/article/details/121565592

版权

Java SE 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

学习内容：集合

文章目录

学习内容：集合

1. 集合概述

1、什么是集合？有什么用？
集合实际上就是一个容器。可以来容纳其他类型的数据。（数组其实就是一个集合）

1.2、集合不能直接存储基本数据类型，另外集合也不能直接存储java对象，集合当中存储的都是java对象的内存地址。（或者说集合中存储的是引用）

1.3、在java中没一个不同的集合，底层对应不同的数据结构。往不同的集合中存储元素，等于将数据放到了不同的数据结构当中。

1.4、所有的集合类和集合接口都在java.util包下。

1.5、集合的继承结构图。
Collection集合：
在这里插入图片描述
Map集合：

1.6、集合和数组的区别

2. Collection接口中的方法

2.1 Collection接口中的方法及运用
在这里插入图片描述
例：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Test01 {
    public static void main(String[] args){
        //创建一个集合对象
        //Collection c=new Collection(); 接口是抽象的，无法实例化。
        //多态
        Collection c =new ArrayList();
        //测试Collection接口中的常用方法：
        //boolean add(E e) 向集合中添加元素
        c.add(1200);//自动装箱，实际上是放进去了一个对象的内存地址。
        c.add(new Object());
        c.add(true);//自动装箱

        //boolean remove(Object o) 删除集合中的元素o，删除成功返回true
        System.out.println(c.remove(1200));//true

        //int size() 获取集合中元素的个数
        System.out.println("集合中元素的个数是："+c.size());//输出结果：3

        //void clear() 清空集合
        c.clear();
        System.out.println("集合中元素的个数是："+c.size());//输出结果：0

        //boolean contains(Object o) 判断当前集合中是否包含元素o，包含返回true，不包含返回false
        c.add("绿巨人");
        c.add("钢铁侠");
        c.add("蜘蛛侠");
        System.out.println(c.contains("绿巨人"));//true
        System.out.println(c.contains("美国队长"));//false

        //boolean isEmpty() 判断集合是否为空
        System.out.println(c.isEmpty());//false
        c.clear();
        System.out.println(c.isEmpty());//true

        //Object[] toArray() 调用这个方法可以把集合转换成数组
        c.add("abc");
        c.add("def");
        c.add(100);
        c.add("Serein");
        Object[] objs=c.toArray();
        for(int i=0;i<objs.length;i++){
            System.out.println(objs[i]);//输出结果：abc   def  100  Serein(每个元素都换行了的)
        }

        //boolean addAll(Collection c) 将一个集合中的所有元素添加到另一个集合,添加成功返回true
        Collection c1 =new ArrayList();
        c1.add("123");
        c1.add("456");
        Collection c2 =new ArrayList();
        c2.add("789");
        c2.add("000");
        System.out.println(c2.addAll(c1));//true

        //Iterator iterator() 迭代器，遍历集合
        //一下的遍历方式/迭代方式，是所有Collection通用的一种方式。
        //在Map集合中不能用。在所有的Collection以及子类中使用。
        //创建集合对象和添加元素省略（以上面的c1和c2为例）

        //第一步：获取集合对象的迭代器对象Iterator
        Iterator it=c2.iterator();
        //第二步：通过以上获取的迭代器对象开始迭代/遍历集合。
        /*
            以下两个方法是迭代器对象Iterator中的方法：
                boolean hasNext() 如果仍有元素可迭代，这返回true
                Object next() 返回迭代的下一个元素
         */
        while (it.hasNext()){
            Object obj=it.next();
            System.out.println(obj);//输出结果：789 000 123 456
        }
    }
}

2.2 注意：合结构只要发生改变，迭代器必须从重新获取。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Test02 {
    public static void main(String[] args) {
        //创建集合
        Collection c=new ArrayList();

        //注意：此时获取的迭代器，指向的是那时集合中没有元素状态下的迭代器。
        Iterator it = c.iterator();
        //一定要注意：集合结构只要发生改变，迭代器必须从重新获取。
        //如果没有重新获取，调用next()方法时会发生异常：java.util.ConcurrentModificationException


        //添加元素
        c.add(1);
        c.add(2);
        c.add(3);

        //获取迭代器
        //Iterator it=c.iterator();
        while (it.hasNext()){
            Object obj=it.next();
            System.out.println(obj);
        }
    }
}

2.3 Iterator 中的remove()方法和Collection 中remove()方法的区别

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Test02 {
    public static void main(String[] args) {

        Collection c=new ArrayList();
        c.add("abc");
        c.add("def");
        c.add("xyz");

        Iterator it=c.iterator();
        while (it.hasNext()){
            Object obj=it.next();
            //删除元素
            //c.remove(obj);
            //删除元素之后，集合的结构发生了变化，应该重新去获取迭代器
            //但是，循环下一次的时候并没有获取迭代器，所有会出现异常：java.util.ConcurrentModificationException
            
            //使用迭代器来删除
            //迭代器去删除时，会自动更新迭代器，并且更新集合（删除集合中的元素）
            it.remove();//删除的一定是迭代器指向的当前元素
            System.out.println(obj);
        }
        System.out.println(c.size());//0
    }
}

3. List

3.1、List接口中特有方法

void add(int index,E element) 在列表指定位置插入指定元素

public class Test03 {
    public static void main(String[] args) {
        //创建List类型的集合
        //List mylist=new Vector();
        //List mylist=new LinkedList();
        List mylist=new ArrayList();

        //添加元素
        mylist.add("A");
        mylist.add("B");
        mylist.add("C");
        mylist.add("C");
        mylist.add(1,"Serein");

        //迭代
        Iterator it=mylist.iterator();
        while (it.hasNext()){
            Object elt=it.next();
            System.out.println(elt);
        }
    }
}

在这里插入图片描述

E get(int index) 根据下标获取元素
（以上述代码为例）

Object firstObj=mylist.get(0);
System.out.println(firstObj);//输出结果：A

int indexOf(Object o) 获取指定对象第一次出现处的索引。
（以上述代码为例）

System.out.println(mylist.indexOf("Serein"));//输出结果：1

int lastIndexOf(Object o) 获取指定对象最后一次出现处的索引。
（以上述代码为例）

System.out.println(mylist.lastindexOf("C"));//输出结果：4

E remove(int index) 删除指定下标位置的元素
（以上述代码为例）（遍历省略，可用迭代器或者根据下标for循环）

mylist.remove(0);

在这里插入图片描述

E set(int index, E element) 修改指定位置的元素
（以上述代码为例）（遍历省略，可用迭代器或者根据下标for循环）

mylist.set(1,"Pt");

在这里插入图片描述

3.2 、ArrayList集合

1、默认初始化容量10
2、集合底层是一个Object[]数组
3、构造方法：ArrayList()、ArrayList(int initialCapacity)、ArrayList(Collection<? extends E> c)

//ArrayList() 构造一个初始容量为十的空列表。
//ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。
List list1=new ArrayList();//初始化容量为10
List list2=new ArrayList(20);//初始化容量为20

//创建一个HashSet集合
Collection c=new HashSet();
c.add(100);
c.add(200);
//ArrayList(Collection<? extends E> c)
//通过这个构造方法就可以将HashSet集合转换成List集合
List mylist=new ArrayList(c);

4、ArrayList集合的扩容：原容量的1.5倍

3.3 、LinkedList集合

1、LinkedList集合是双向链表
2、对于链表数据结构来说，随机增删效率较高。检索效率较低
3、链表中的元素在空间存储上，内存地址不连续

3.4 、Vector

1、底层也是一个数组
2、初始化容量是10
3、Vector的扩容：原容量的2倍
4、Vector中所有的方法都是线程同步的，都带有synchronized关键字，是线程安全的
5、怎么将一个线程不安全的ArrayList集合转换成线程安全的呢？
使用集合工具类：java.util.Collections
注意区分（集合接口：java.util.Collection）

List mylist=new ArrayList();//非线程安全的
Collections.synchronizedList(mylist);

4. Set

4.1 、HashSet集合

1、存储时顺序和取出的顺序不同
2、不可重复
3、放到HashSet集合中的元素实际上是放到HashMap集合的key部分了。

4.2 、TreeSet集合

1、无序不可重复的，但是存储的元素可以自动按照大小顺序排列！称为：可排序集合

import java.util.*;

public class Test03 {
    public static void main(String[] args) {
        Set<String> strs=new TreeSet<>();
        strs.add("C");
        strs.add("Z");
        strs.add("K");
        strs.add("F");
        strs.add("A");
        //foreach遍历
        for (String s:strs) {
            System.out.println(s);
        }
    }
}

在这里插入图片描述

5. Map

1、Map和Collection没有继承关系。
2、Map集合以key和value的方式存储数据：键值对
key和value都是引用数据类型
key和value都是存储对象的内存地址
key起到主导的地位，value是key的一个附属品

5.1、Map接口中常用方法：

V put(K key, V value) 向Map集合中添加键值对

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

public class Test03 {
    public static void main(String[] args) {
        //创建Map集合对象
        Map<Integer,String> map=new HashMap<>();

        //向Map集合中添加键值对
        map.put(1,"zhangshan");//这里的1进行了自动装箱
        map.put(2,"lisi");
        map.put(3,"wangwu");
        map.put(4,"zhaoliu");
    }
}

V get(Object key) 通过key获取value
（以上述代码为例）

//通过key获取value
String value=map.get(2);
System.out.println(value);//输出结果：lisi

int size() 获取Map集合中键值对的个数
（以上述代码为例）

//获取键值对的数量
System.out.println("键值对的数量："+map.size());//输出结果：4

V remove(Object key) 通过key删除键值对
（以上述代码为例）

//通过key删除key-value
map.remove(2);
System.out.println("键值对的数量："+map.size());//输出结果：3

boolean containsKey(Object key) 判断Map中是否包含某个key
（以上述代码为例）

//判断是否包含某个key
//contains方法底层调用的都是equals进行比对的，所有自定义的类型需要重写equals方法
System.out.println(map.containsKey(4));//输出结果：true

boolean containsValue(Object value) 判断Map中是否包含某个value
（以上述代码为例）

//判断是否包含某个value
System.out.println(map.containsValue("wangwu"));//输出结果：true

Collection<V> values() 获取Map集合中所有的value，返回一个Collection
（以上述代码为例）

//获取所有的value
Collection<String> values=map.values();
for(String s:values){
   System.out.println(s);
}

在这里插入图片描述

void clear() 清空Map集合
（以上述代码为例）

//清空Map集合
map.clear();
System.out.println("键值对的数量："+map.size());//输出结果：0

boolean isEmpty() 判断Map集合中元素个数是否为0
（以上述代码为例）

/判断是否为空
System.out.println(map.isEmpty());//输出结果：true

Set<K> keySet() 获取Map集合所有的key（所有的键是一个set集合）
（以上述代码为例）

Set<Integer> keys=map.keySet();

Set<Map.Entry<K,V>> entrySet() 将Map集合转换成Set集合
（以上述代码为例）

Set<Map.Entry<Integer,String>> set=map.entrySet();

5.2、Map集合的遍历

第一种方式：获取所有的key，通过遍历key，来遍历value。

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Test04 {
    public static void main(String[] args) {
        Map<Integer,String> map=new HashMap<>();
        map.put(1,"zhangshan");
        map.put(2,"lisi");
        map.put(3,"wangwu");
        map.put(4,"zhaoliu");

        //遍历Map集合
        //获取所有的key，所有的key是一个Set集合
        Set<Integer> keys=map.keySet();
        //遍历key，通过key获取value
        //迭代器
        Iterator<Integer> it=keys.iterator();
        while (it.hasNext()){
            //取出其中一个key
            Integer key= it.next();
            //通过key获取value
            String value=map.get(key);
            System.out.println(key+"="+value);
        }
        //foreach
        for (Integer key:keys) {
            System.out.println(key+"="+map.get(key));
        }
    }
}

在这里插入图片描述

第二种方式：Set<Map.Entry<K,V>> entrySet()。
（以上述代码为例）

Set<Map.Entry<Integer,String>> set=map.entrySet();
        //迭代器
        Iterator<Map.Entry<Integer,String>> it2=set.iterator();
        while (it2.hasNext()){
            Map.Entry<Integer,String> node=it2.next();
            Integer key= node.getKey();
            String value= node.getValue();
            System.out.println(key+"="+value);
        }
        //foreach
        //这种方式效率比较高，因为获取key和value都是直接从node对象中获取的属性值。
        for (Map.Entry<Integer,String> node:set) {
            System.out.println(node.getKey()+"--->"+node.getValue());
        }

在这里插入图片描述

5.3、HashMap集合

1、HashMap集合底层是哈希表/散列表的数据结构
2、哈希表是一个怎样的数据结构呢？
哈希表是一个数组和单向链表的结合体。
数组：在查询方面效率很高，随机增删方面效率很低。
单向链表：在随机增删方面效率较高，在查询方面效率较低。
哈希表将以上的两种数据结构融合在一起，充分发挥它们各自的优点。
3、主要掌握：
map.put(k,v)和v=map.get(k)两个方法是实现原理
在这里插入图片描述
4、HashMap集合的key部分特点：
无序，不可重复。
为什么无需？因为不一定挂到哪个单向链表上。
不可重复是怎么保证的？equals方法来包装HashMap集合的key不可重复。
如果key重复了，value会覆盖。

放在HashMap集合的key部分的元素其实就是放到HashSet集合中了。
所以HashSet集合中的元素也需要同时重写hashCode()+equals()方法。

5、哈希表HashMap使用不当时无法发挥性能！
假设将所有的hashCode()方法返回值固定为某个值，那么会导致底层哈希表变成了单纯的单向链表。这种情况我们称为：散列分布不均匀。

6、放在HashMap集合的key部分的元素，以及放到HashSet集合中的元素，需要同时重写hashCode()+equals()方法。

7、HashMap集合的默认初始化容量是16，默认加载因子是0.75.
这个默认加载因子是当HashMap集合底层数组的容量达到75%的时候，数组开始扩容。

记住：HashMap集合初始化容量必须是2的倍数，这也是官方推荐到，这是因为达到散列均匀，为了提高HashMap集合的存取效率，所必须的。

5.3、HashMap和Hashtable的区别

在这里插入图片描述

5.4、Properties类（属性类）

Properties是一个Map集合，继承Hashtable，Properties的key和value都是String类型。
Properties被称为属性类对象。
Properties是线程安全的。
Properties的两个方法：setProperty()（存）和getProperty()（取）

import java.util.Properties;

public class Test05 {
    public static void main(String[] args) {
        Properties pro=new Properties();
        pro.setProperty("username","admin");
        pro.setProperty("password","123");

        String user=pro.getProperty("username");
        String pass=pro.getProperty("password");
        System.out.println(user);
        System.out.println(pass);
    }
}

在这里插入图片描述

5.5、TreeMap

1、TreeSet集合底层实际上是一个TreeMap
2、TreeMap集合底层是一个二叉树
3、放到TreeSet集合中的元素，等同于放到TreeMap集合key部分了。
4、TreeSet集合中的元素：无需不可重复，但是可以按照元素的大小自动排序。称为可排序集合

TreeSet集合中元素可排序的两种方式

Collections工具类

Serein_Pt

关注

3
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
学习笔记：集合

学习内容：集合文章目录学习内容：集合1. 集合概述2. Collection接口中的方法3. List3.1、List接口中特有方法3.2 、ArrayList集合3.3 、LinkedList集合3.4 、Vector4. Set4.1 、HashSet集合4.2 、TreeSet集合5. Map5.1、Map接口中常用方法：5.2、Map集合的遍历5.3、HashMap集合5.3、HashMap和Hashtable的区别5.4、Properties类（属性类）5.5、TreeMap1. 集合概述1
复制链接

扫一扫