java_集合

类图

collection常用的方法

package Collection_接口;

import java.util.ArrayList;
import java.util.List;

/**
 * @author ZhouHao
 * @version 1.0
 */
@SuppressWarnings("all")
public class ArrayList_way {
    public static void main(String[] args) {
//        Collection接口中常用的方法  子类接口 List new 一个实现Collection的对象实列
        List list = new ArrayList();
//      一、 add添加数据
        list.add("ZhouHao");
        list.add("ZhouHao");
        list.add(10);  //list.add(new Integer(10)) 装箱的过程
        list.add(true);
        System.out.println(list);

//      二、 remove 删除指定的元素
        list.remove(0);    //删除第一个元素 返回被删除的元素
        list.remove(true);    //删除指定的元素 返回boolean
        System.out.println(list);

//      三、 contains 查找元素是否存在
        System.out.println(list.contains(10));

//      四、 size 获取元素的个数
        System.out.println(list.size());

//      五、isEmpty 判断集合是否是空
        System.out.println(list.isEmpty());

//       get()  获取一个元素
        System.out.println(list.get(1)+"4444");

//      六、clear 清空所有的元素
        list.clear();
        System.out.println(list);

//  ----------------------------------------------------------
//      七、addAll 添加多个元素
        ArrayList arrayList=new ArrayList();
        arrayList.add("zhouhao");
        arrayList.add("www");
        list.addAll(arrayList);  //添加一个集合

//      八、 containsAll 查找多个元素是否都存在
        System.out.println(list.containsAll(arrayList));

//      九、 removeAll 删除多个元素
        list.add("aaa");
        System.out.println(list.removeAll(arrayList));
        System.out.println(list);
    }
}

List接口

List 接口：元素按进入先后有序保存，可重复
实现类：
LinkedList 接口实现类， 链表， 插入删除， 没有同步， 线程不安全
ArrayList 接口实现类， 数组， 随机访问， 没有同步， 线程不安全
Vector 接口实现类 数组，同步， 线程安全 Stack 是Vector类的实现类

list 接口常用的方法

一、 add: 在索引的位置插入一个元素 没有索引默认插在最后
二、 addAll : 从 index 位置将元素全部插入进来
三、get: 获取指定index的元素
四、 indexOf :返回元素在集合中首次出现的位置
五、 lastIndexOf :返回在集合最后出现的位置
六、 remove: 移除指定index位置的元素 并返回被移除的元素
七、 set 指定index 位置为新的元素 相当于替换
八、 List subList(int start int end) 返回指定（start <= x < end）索引处的子集合

package Liat_接口;

import java.util.ArrayList;
import java.util.List;

/**
 * @author ZhouHao
 * @version 1.0
 * @ 思路分析:
 */
@SuppressWarnings("all")
public class List_Method {
    public static void main(String[] args) {
        List list=new ArrayList();
        list.add("zhouhao");
        list.add("zhangjiangjiang");
//  一、 add 在索引的位置插入一个元素 没有索引默认插在最后
        list.add(1,"周浩");
        System.out.println(list);

//  二、 addAll 从 index 位置将元素全部插入进来
        List tag =new ArrayList();
        tag.add(10);
        tag.add(20);
        list.addAll(2,tag);
        System.out.println(list);

//  三、 get 获取指定index的元素
        Object obj=list.get(2);
        System.out.println(obj);

//  四、 indexOf 返回元素在集合中首次出现的位置
        Object obj1=list.indexOf("zhouhao");
        System.out.println(list);
        System.out.println(obj1);

//  五、 lastIndexOf 返回在集合最后出现的位置
        System.out.println(list.lastIndexOf(10));

//  六、 remove 移除指定index位置的元素 并返回被移除的元素
        System.out.println(list.remove(1));

//  七、 set  指定index 位置为新的元素 相当于替换
        list.set(1,"1111111");
        System.out.println(list);
//  八、 List subList(int start int end)  返回指定（start <= x < end）索引处的子集合
        List list1=list.subList(1,2);   // 包含1 但不包含2
        System.out.println("子集合："+list1);
        System.out.println("List："+list);

    }
}

List的三种遍历方式

一、迭代器遍历
二、增强for
三、普通的for循环

package Liat_接口;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * @author ZhouHao
 * @version 1.0
 * 只要干不死,就往死里干
 * 成为想成为的人,越努力越幸运
 * 我自光芒万丈，何须他人半点光
 * 有要做的事，请从知晓的那一刻百分之百去执行
 * 2023/10/22 19:48
 */
public class for_ {
    @SuppressWarnings("all")
    public static void main(String[] ages){
        List arrayList = new ArrayList();
        arrayList.add("周浩");
        arrayList.add("hao");
        arrayList.add("zhou");

        /*使用迭代器来遍历*/
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println("obj = " + obj);
        }

        /*使用增强for*/
        for (Object obj:arrayList){
            System.out.println(obj);
        }

        /*使用普通的for*/
        for (int i = 0; i < arrayList.size(); i++) {
            System.out.println(arrayList.get(i));

        }
    }
}

set接口：

Set 接口： 且是无序的（取出和存储顺序不一致），不可重复（元素唯一，会覆盖），不能根据索引来获取元素

实现类：
==HashSet ==使用hash表（数组）存储元素
LinkedHashSet 链表维护元素的插入次序
==TreeSet ==底层实现为二叉树，元素排好序

list和set的区别

有序性：
list：保证插入的顺序排序
set：存储和取出的顺序不一致
唯一性：
list：可以重复
set：元素唯一
获取元素：
list：可以通过元素的索引直接获取元素
set：不能通过索引来获取元素

Map 接口 键值对的集合 （双列集合）

实现类：
Hashtable 接口实现类， 同步， 线程安全
HashMap 接口实现类 ，没有同步， 线程不安全-
LinkedHashMap 双向链表和哈希表实现
WeakHashMap
TreeMap 红黑树对所有的key进行排序
IdentifyHashMap

map接口常用的方法

map的遍历

特点
Map接口在Java中有一些特点，包括：

1. 键值对映射： Map是一种键值对（key-value）映射的数据结构，允许你将键与值关联起来，以便快速查找和检索值。

2. 键的唯一性： 在Map中，每个键必须是唯一的。如果尝试使用相同的键存储多个值，后续的值将覆盖先前的值。

3. 键和值的数据类型： Map接口允许你定义键和值的数据类型。通常，键和值可以是任何引用类型，但必须满足特定的要求，例如实现equals()和hashCode()方法。

4. 快速查找： Map使用哈希表或其他高效的数据结构来实现快速查找和插入操作。平均情况下，这些操作的时间复杂度是常数时间（O(1)）。

5. 无序性： Map接口不保证键值对的顺序。具体的Map实现类（如HashMap和LinkedHashMap）可以以不同的顺序存储键值对。

6. 可遍历： 你可以使用迭代器、keySet()、values()和entrySet()等方法来遍历Map中的键、值和键值对。

7. 动态大小： Map可以根据需要自动扩展或缩小其大小，以适应存储的键值对数量。

8. 适用性广泛： Map接口在编程中广泛使用，用于实现各种功能，包括存储配置信息、缓存数据、管理用户会话等。

9. 常用实现类： Java提供了多个Map接口的实现类，包括HashMap、TreeMap、LinkedHashMap等，每个实现类都有不同的特点和适用场景。

hashmap和hashtable之间的区别

1. 线程安全性：

   • HashMap：HashMap 是非线程安全的。在多线程环境中使用时，需要外部同步控制。
   • Hashtable：Hashtable 是线程安全的，它使用同步机制来确保多线程访问时的安全性。然而，这可能会导致性能开销。

2. null 键和值：

   • HashMap：允许存储一个 null 键和多个 null 值。
   • Hashtable：不允许存储 null 键或值。如果尝试存储 null 键或值，会抛出 NullPointerException。

3. 性能：

   • HashMap：通常比 Hashtable 更快，因为它不具备额外的同步开销。
   • Hashtable：由于同步开销，性能可能不如 HashMap。

4. 迭代顺序：

   • HashMap：在 JDK 8 之后，HashMap 会保留插入顺序，但它仍然不是一种有序的数据结构。
   • Hashtable：不保证键值对的顺序。

treemap特点

TreeMap 是 Java 中的一个 Map 实现类，它基于红黑树数据结构实现，具有以下特点：

1. 有序性： TreeMap 会根据键的自然顺序（或者使用指定的比较器）对键进行排序。这使得 TreeMap 中的键值对是有序的。

2. 键的唯一性： 在一个 TreeMap 中，每个键必须是唯一的。如果尝试使用相同的键添加多个值，新值将替代旧值。

3. 快速查找： 由于底层数据结构是红黑树，TreeMap 具有快速查找、插入和删除键值对的能力。查找、插入和删除操作的时间复杂度是 O(log n)，其中 n 是键值对的数量。

4. 可根据自然顺序或比较器进行排序： 你可以选择使用键的自然顺序或者提供自定义的比较器来排序键值对。这使得 TreeMap 适用于各种不同的排序需求。

5. 非线程安全： TreeMap 不是线程安全的。如果在多线程环境中使用 TreeMap，你需要外部同步控制。

6. 支持子映射： TreeMap 支持获取子映射，可以通过 subMap(), headMap(), tailMap() 等方法获取部分键值对的子集。

7. 迭代顺序： TreeMap 的迭代顺序是按照键的顺序进行的，这对于需要按键顺序遍历数据的情况非常有用。

8. 红黑树的平衡性： 红黑树是一种自平衡的二叉搜索树，确保树的高度保持在合理范围内，从而保证了快速查找、插入和删除操作的性能。

集合的实现类 之间应该如何选择