集合

集合

Java集合是一组用于存储和操作数据的类和接口。它们提供了一种方便和灵活的方式来处理数据集合，包括列表、集合、映射等。Java集合框架提供了一组通用的接口和类，用于操作和管理集合对象。

集合分为:单列集合双列集合

以下为集合结构体系图

单列集合(Collection)

单列集合(又称单元素集合,单元集合),一次只包含一个元素的集合

Collection中的一些方法

先创建集合对象

ArrayList<Integer> arrayList = new ArrayList<>();

public static < T > boolean addAll(Collection<? super T> c, T... elements)

把T...类型数据添加到继承Collection父类的子类中

Collections.addAll(arrayList, 1,2,3,4,5,6);//把,1,2,3,4,5,6数据添加到ArrayList集合中

public static <T extends Comparable<? super T>> void sort(List < T > list)

对集合进行排序
```
Collections.sort(arrayList);//排序
```

public static < T > void copy(List<? super T> dest, List<? extends T> src)

把src集合复制到dest集合,要保证第一个目标集合的长度大于第二个集合长度,src已有的数据会覆盖dest目标对应位置的元素

Collections.copy(arrayList, arrayList1);//*注:第一个目标集合长度要大于第二个

public static void swap(List<?> list, int i, int j)

交换集合list中位置i与位置j的元素

Collections.swap(arrayList,1,3);//调换第二个和第四个位置

public static < T > boolean addAll(Collection<? super T> c, T... elements)

对目标集合C添加多个元素element

Collections.addAll(arrayList1,1,2,3,4,5,7) ;

public static < T > void fill(List<? super T> list, T obj)

把集合list的所有元素用 obj类型进行填充

Collections.fill(arrayList,1);//即所有元素都为1

public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)

获取集合中元素的最大值
```
Collections.max(arrayList)
```

public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)

获取集合元素中的最小值
```
Collections.min(arrayList)
```

ArrayList类(对List接口的实现,底层由数组实现)

构造方法

ArrayList arrayList = new ArrayList();//默认为Object类,可以存储任意类型

//ArrayList<E>  E为泛型

ArrayList<String> stringArrayList = new ArrayList<>();//定义String类型

ArrayList<Integer> integerArrayList = new ArrayList<>();//定义Integer类型集合

方法

public boolean add(E e)

integerArrayList.add(10);//自动装箱,10自动转为Integer类型,自动添加内容

		stringArrayList.add("0");

        stringArrayList.add("1");

        stringArrayList.add("2");

        stringArrayList.add("3");

        stringArrayList.add("4");

返回值为boolean类型,添加成功-true 失败-false

public void add(int index , E element)

stringArrayList.add(1,"0");

//在指定位置Index插入数据,不能对没有使用的位置进行插入操作(从0到size(集合元素个数))

public boolean remove(Object O)

stringArrayList.remove("1");

//删除指定元素,并自动进行排序,返回值为boolean类型,如果匹配到对应元素删除成功返回-true 找不到-false

public E remove( int index)

stringArrayList.remove(1);

//删除指定位置(index)元素并返回该元素,并对剩余元素进行排序,并返回该元素

public boolean contains(Object O)

boolean b = stringArrayList.contains("1");

//判断是否包含该元素,返回boolean类型数据

public E get (int index)

stringArrayList.get(2);

//获取指定位置上的元素

public int indexOf(Object O)

stringArrayList.indexOf("1");

//查找指定位置元素,并返回该元素位置

//查找方式:从头查找

public int lastIndexOf(Object O)

stringArrayList.lastIndexOf("1");

//查找指定位置元素,并返回该元素位置

//查找方式:从末尾开始查找

public boolean isEmpty()

stringArrayList.isEmpty();

//判断该集合是否为空,, 是-true 否-false

public int size()

stringArrayList.size();

//返回集合元素个数(即长度)

public void clear()

stringArrayList.clear();

//清空元素个数

Vector类(对List接口的实现,底层由数组实现)

构造方法

Vector<Integer> vector = new Vector<>();//存储Integer类型数据,<>里面也可以是其他类

Vector vector = new Vector();//可以存储任意类型数据

方法

public synchronized boolean add(E e)

public synchronized void add(int index , E element)

public synchronized boolean remove(Object O)

public synchronized E remove( int index)

public synchronized boolean contains(Object O)

public synchronized E get (int index)

public synchronized int indexOf(Object O)

public synchronized int lastIndexOf(Object O)

public synchronized boolean isEmpty()

public synchronized int size()

public synchronized void clear()

用法和ArrayList类方法一样,区别是,Vector类方法被synchronized关键字修饰,当多线程运行时,只允许一个请求调用方法,相比ArrayList是安全的

LInkedList类(对List接口的实现,底层是链表)

构造方法

//1.

LinkedList linkedList = new LinkedList();//可以存储任意类型

//2.

LInkedList<String(可以是任意类型)> stringLinkedList = new LinkedList<>();

//可以存储<>里对应的类型

方法

public boolean add(E e)

public void add(int index , E element)

public boolean remove(Object O)

public E remove( int index)

public boolean contains(Object O)

public E get (int index)

public int indexOf(Object O)

public int lastIndexOf(Object O)

public boolean isEmpty()

public int size()

public void clear()

注:以上三种类是可以存储重复的元素的(对List实现的接口),而对set接口实现的类是不能存储重复的元素

TreeSet(对Set接口的实现,底层是有TreeMap实现的)

注:TreeSet实际是利用TreeMap的key来存储元素,而TreeMap中的Value是位null,底层都是树结构

TreeSet可以给Set集合中的元素进行指定方式的排序。存储的对象必须实现Comparable接口

底层:是树形结构
添加进来的元素可以进行排序(有序的不是添加的顺序,是元素的自然顺序)
添加顺序是大的元素向右放,小的元素向左放;

构造方法

创建对象方法:

	TreeSet set = new TreeSet();//指存储任意类型元素

	TreeSet<Integer> set = new TreeSet<>();//指存储Integer元素(不仅可以是Integer可以是其他类,<>里面的也称为 java中的泛型)

TreeSet方法

public boolean add(E e)

对集合添加元素,对应E类型

TreeSet<Integer> set = new TreeSet<>();

	set.add(3);

    set.add(4);

    set.add(2);

    set.add(1);

    set.add(3);

public void clear()

删除集合中所有的元素
```
set.size();
```

public boolean contains(Object o)

判断元素(对象)是否在集合中存在

set.contains(1);//是否存在某元素

public boolean isEmpty()

判断集合是否为空.
```
set.isEmpty
```

public boolean remove(Object o)

删除集合中的指定元素(对象) O
```
set.remove(1);//删除元素1
```

public E pollLast()

删除集合中最后的一个元素(对象)并返回

set.pollLast();//删除并返回最后一个元素

public E first()

返回集合第一个位置的元素
```
set.first();//返回第一个元素
```

public E pollFirst()

删除集合中第一个元素返回这个元素

set.pollFirst();//删除并返回第一个元素

public E last()

返回集合中最后一个元素

set.last();//返回最后一个个元素

**. . . . . . **

HashSet(对Set接口的实现,底层是HashMap实现的)

Set接口

不能存储重复元素

HashSet

无序的(既不是添加顺序,也不是按元素自然顺序)

不会重复的原因:

底层使用hashCode()和equals()方法;
用内存计算一个hash值(整数),用hash值比较速度块,

注:hash是不安全的,有可能两个内容不一样,hash值一样

当hash值相同时,调用equals()方法,

这样效率提高,也保证安全了

构造方法

HashSet<String> stringHashSet = new HashSet<>();//存储String类型的HashSet,不止可以是String可		以是其他类型,Integer 对象...

HashSet stringHashSet = new HashSet();//存储任意类型

HashSet常用方法

public boolean add(E e)

对集合添加元素

public boolean contains(Object o)

判断集合是否包含指定元素(对象) O.

public boolean remove(Object o)

删除集合中指定元素(对象) O

public boolean isEmpty()

判断集合是否为空

public void clear()

删除集合中所有元素

当HashSet中的泛型为自己写的类创建的对象时

import java.util.Objects;

//定义Student类

public class Student implements Comparable{

    private int id;

    private String name;

    public Student(int id, String name) {

        this.id = id;

        this.name = name;

    }

    @Override

    public String toString() {

        return id+name;

    }

    @Override

    public boolean equals(Object o) {

        if (this == o) return true;

        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        return id==id &&

                name.equals(student.name);

    }

//如果我们想要对象中内容相同的元素判断为重复元素,就必须在我们类中重写hashCode()与equals()方法

    @Override

    public int hashCode() {

        return Objects.hash(id, name);

    }

    @Override

    public int compareTo(Object o) {

        return this.id-((Student)o).id;

    }

}

HashSet<Student> studentHashSet = new HashSet<>();

        Student student = new Student(101, "cwy");

        Student student1 = new Student(102, "dqw");

        Student student2 = new Student(103, "wyn");

        Student student3 = new Student(101, "cwy");

        studentHashSet.add(student);

        studentHashSet.add(student1);

        studentHashSet.add(student2);

        studentHashSet.add(student3);

        System.out.println(studentHashSet);

如果Student类中没有重写hashCode()与equals()方法,则运行结果会发现存在重复项,这是因为判断重复项时会调用类中的hashCode()计算hash值,类中若是没有hashCode()会调用父类的hashCode(),即Object类中的public native int hashCode();(native本地方法,由操作系统提供的)所以,只要是new出来的,调用Object值,是内存地址,肯定不同

如果我们想要对象中内容相同的元素判断为重复元素,就必须在我们类中重写hashCode()与equals()方法

对单列集合的遍历

使用for循环

ArrayList<String> stringArrayList = new ArrayList<>();

//1.for循环遍历

        for (int i=0;i<stringArrayList.size();i++){

            if(stringArrayList.get(i).equals("2")){

                stringArrayList.remove(i);

                //for循环的时候,是支持从元素中删除元素的,但是删除后,后面的元素会前移,需要控制索引

            i--;

            }

        }

        System.out.println(stringArrayList);

//2.增强for循环    不支持删除元素

        for(String s:stringArrayList){

            System.out.println(s);

        }

使用迭代器

//3.使用迭代器1.0遍历Iterator 支持删除方法,且不会漏掉元素

       Iterator<String> iterator = stringArrayList.iterator();

       while(iterator.hasNext()){

           String s = iterator.next();

           if(s.equals("2")){

               iterator.remove();//迭代器中删除的方法

           }

           System.out.println(s);

       }

       //迭代器2.0 只能遍历List

       ListIterator<String> stringListIterator = stringArrayList.listIterator();

       while(stringListIterator.hasNext()){

           String s = stringListIterator.next();

           System.out.println(s);

       }

       //从指定位置索引

       ListIterator<String> stringListIterator2 = 			`			           stringArrayList.listIterator(stringArrayList.size());//size=最大索引+1

       //逆序

       while(stringListIterator2.hasPrevious()){

           String s = stringListIterator2.previous();

           System.out.println(s);

       }

双列集合

HashMap(对Map接口的实现)

底层实现逻辑

转化红黑树的原理如下

补:TreeMap键值都可以是null

构造方法

HashMap<String,String> stringHashMap = new HashMap<>();//创建HashMap对象,键值分别是String与String  当然也可以是其他的类

常用方法

public V put(K key, V value)

对图进行添加新的元素(必须对应你预定的类型)

	stringHashMap.put("1", "一");

       stringHashMap.put("3", "三");

       stringHashMap.put("5", "五");

       stringHashMap.put("4", "四");

       stringHashMap.put("2", "二");

       stringHashMap.put("1", "一");

       stringHashMap.put(null, "一");

       //存储也是无序且不重复的,且只判断前面部分是否重复(即Key值不可以重复),

存储原理如上面的原理图
存储原理如下

public void clear()

清空所有元素

public V remove(Object key)

删除指定键的元素,并返回对应的值

System.out.println(stringHashMap.remove("1"));//删除键并返回对应值

public boolean containsKey(Object key)

判断指定的Key键是否存在

System.out.println(stringHashMap.containsKey("1"));//判断键是否存在

public boolean containsValue(Object value)

判断指定的Value是否存在

System.out.println(stringHashMap.containsValue("二"));//判断值是否存在

public boolean isEmpty()

判断集合是否为空

System.out.println(stringHashMap.isEmpty());//判断集合是否为空

public int size()

返回元素个数即元素长度

System.out.println(stringHashMap.size());//判断元素个数

public V get(Object key)

通过Key键来返回对应的Value值

System.out.println(stringHashMap.get("1"));//通过Key返回Value

HashMap的键值遍历

对值的遍历

Collection<String> collection = stringHashMap.values();//获取值 System.out.println(collection);

对键的遍历

Set<String> set =stringHashMap.keySet();//获取键的集合

 System.out.println(set);

结合public V get(Object key)可以遍历对应的Value

对整体的遍历(使用迭代器)

       //通过entrySet()  获取到Entry类型的集合,Entry中放有键值对

        Set<Map.Entry<String,String>>entries = stringHashMap.entrySet();

        for(Map.Entry<String,String> empty:entries){

            System.out.println(empty);

            System.out.println(empty.getKey());//获取键

            System.out.println(empty.getValue());//获取值

        }

Hashtable(底层与HashMap一样,只不过方法修饰符不同)

底层结构与HashMap相同,但是线程安全的,方法被synchronized关键字修饰

TreeMap(实现SortedMap接口)

有序性:TreeMap 存储的键值对是有序的。具体来说，键的插入顺序和自然排序顺序或者自定义的比较器排序顺序是一致的
其余方法都与TreeMap一样

Java 集合的概念的更多相关文章

Java集合基本概念及元素添加
Java容器类类库的用途是"保存对象", 并将其划分为两个不同的概念: (1)Collection: 一个独立元素的序列, 这些元素都服从一条或多条规则. List必须按照插入的顺 ...
java集合介绍（List，Set，Map）
前言介绍java的常用集合+各个集合使用用例欢迎转载,请注明作者和出处哦☺ 参考: 1,<Java核心编程技术(第二版)> 2, http://www.cnblogs.com/Litt ...
Java线程：概念与原理
Java线程:概念与原理一.操作系统中线程和进程的概念现在的操作系统是多任务操作系统.多线程是实现多任务的一种方式. 进程是指一个内存中运行的应用程序,每个进程都有自己独立的一块内存空间,一个进程 ...
Java集合容器简介
Java集合容器主要有以下几类: 1,内置容器:数组 2,list容器:Vetor,Stack,ArrayList,LinkedList, CopyOnWriteArrayList(1.5),Attr ...
Java集合框架中List接口的简单使用
Java集合框架可以简单的理解为一种放置对象的容器,和数学中的集合概念类似,Java中的集合可以存放一系列对象的引用,也可以看做是数组的提升,Java集合类是一种工具类,只有相同类型的对象引用才可以放 ...
java集合框架之java HashMap代码解析
java集合框架之java HashMap代码解析文章Java集合框架综述后,具体集合类的代码,首先以既熟悉又陌生的HashMap开始. 源自http://www.codeceo.com/arti ...
Java 集合系列 09 HashMap详细介绍(源码解析)和使用示例
java 集合系列目录: Java 集合系列 01 总体框架 Java 集合系列 02 Collection架构 Java 集合系列 03 ArrayList详细介绍(源码解析)和使用示例 Java ...
Java 集合系列 14 hashCode
java 集合系列目录: Java 集合系列 01 总体框架 Java 集合系列 02 Collection架构 Java 集合系列 03 ArrayList详细介绍(源码解析)和使用示例 Java ...
Java 集合系列 12 TreeMap
java 集合系列目录: Java 集合系列 01 总体框架 Java 集合系列 02 Collection架构 Java 集合系列 03 ArrayList详细介绍(源码解析)和使用示例 Java ...
Java 集合系列 11 hashmap 和 hashtable 的区别
java 集合系列目录: Java 集合系列 01 总体框架 Java 集合系列 02 Collection架构 Java 集合系列 03 ArrayList详细介绍(源码解析)和使用示例 Java ...

随机推荐

前端使用 Konva 实现可视化设计器（5）
关于第三章提到的 selectingNodesArea,在后续的实现中已经精简掉了. 而 transformer 的 dragBoundFunc 中的逻辑,也直接移动 transformer 的 dr ...
EasyNLP带你实现中英文机器阅读理解
简介: 本⽂将提供对MacBERT模型的技术解读,以及如何在EasyNLP框架中使⽤MacBERT及其他预训练语言模型,进行中英文机器阅读理解任务的训练与预测. 作者:施晨.黄俊导读机器阅读理解是 ...
为 Serverless Devs 插上 Terraform 的翅膀，实现企业级多环境部署（上）
简介: Serverless Devs 离不开对云资源的操作,但支持新资源时需要开发相应的组件代码:如果将环境模板的定义通过 Terraform IaC 来完成,在 Serverless Devs ...
从“预见”到“遇见” | SAE 引领应用步入 Serverless 全托管新时代
简介: 阿里云 Serverless 应用引擎(简称 SAE)初衷是让客户不改任何代码,不改变应用部署方式,就可以享受到微服务+K8s+Serverless 的完整体验,开箱即用免运维.作为业界首款面 ...
[Mobi] Android Studio arm 模拟器
从右下角 Configure 打开 AVD Manager. 点击 "Create New Device" 来创建新设备选择TV 接着Next,然后用 Other Imag ...
dotnet win32 使用 WIC 获取系统编解码器
在 Windows 系统上,有一个很重要的概念是 Windows Imaging Component 也就是 WIC 层,这是专门用来处理多媒体相关的系统组件,特别是用来处理图片相关,包括编码和解码和 ...
2019-8-31-dotnet-使用-Environment.FailFast-结束程序
title author date CreateTime categories dotnet 使用 Environment.FailFast 结束程序 lindexi 2019-08-31 16:55 ...
大模型必备 - 中文最佳向量模型 acge_text_embedding
近期,上海合合信息科技股份有限公司发布的文本向量化模型 acge_text_embedding 在中文文本向量化领域取得了重大突破,荣获 Massive Text Embedding Benchmar ...
使用Kafka Assistant监控Kafka关键指标
使用Kafka Assistant监控Kafka关键指标使用Kafka时,我们比较关心下面这些常见指标. Kafka Assistant下载地址:http://www.redisant.cn/ka ...
4.k8s-配置网络策略 NetworkPolicy
一.基本了解官方文档:https://kubernetes.io/zh-cn/docs/concepts/services-networking/network-policies/基本了解: 1.网 ...