集合

集合

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 ...

随机推荐

szfpga 高云gowin国产开发板GW2AR-18核心板fpga cpld测试板
1. 概述国产FPGA是最近几年起来的产品,具有性价比高特点.而GOWIN属于国产FPGA成员,在服务和芯片都是比较大的优势,很多用户都用在LED控制,电机控制,PLC设备上,以及用于替换Latti ...
ArcPy自动绘制大量地图并设置地图要素：Python
本文介绍基于Python语言中ArcPy模块,实现ArcMap自动批量出图,并对地图要素进行自定义批量设置的方法. 1 任务需求首先,我们来明确一下本文所需实现的需求. 现有通过Pyth ...
剑指offer51(Java)-数组中的逆序对（困难）
题目: 在数组中的两个数字,如果前面一个数字大于后面的数字,则这两个数字组成一个逆序对.输入一个数组,求出这个数组中的逆序对的总数. 示例1: 输入: [7,5,6,4] 输出: 5 限制: 0 &l ...
力扣1097(MySQL)-游戏玩法分析Ⅴ（困难）
题目: 我们将玩家的安装日期定义为该玩家的第一个登录日. 我们还将某个日期 X 的第 1 天留存时间定义为安装日期为 X 的玩家的数量,他们在 X 之后的一天重新登录,除以安装日期为 X 的玩家的数量 ...
dotnet 给 NuGet 包加上 Aliases 别名解决类型冲突
有时某个相同命名空间相同名字的类型被两个不同的 NuGet 包定义了,尽管这是非常少见的事情,咱需要使用到其中的一个 NuGet 包的类型,但默认情况下将会因为类型冲突而构建不通过.本文将告诉大家如何 ...
shell 去掉逗号_shell替换和去掉换行符
用shell处理文件的时候我们常常需要去掉或者加上换行符,name问题就来了怎么才能快速的替换呢? 我们有这样一个文件[root@hxy working]# cat 1 GD200A16C013493 ...
源码研习 — TVM中的IR设计与技术实现
一.关键问题 TVM中的 IR 是什么,架构设计上分几层? 解答:TVM的整体结构图如下: 概念上,分为两层:上层为面向前端组网的Relay IR, 下层为面向LLVM的底层 IR. 但从设计实现上, ...
ansible系列(30)--ansible的role详解
目录 1. Ansible Roles 1.1 roles目录结构 1.2 roles编写步骤 1.2.1 编写基本的roles 1.2.2 roles的调用 1.2.3 roles中使用变量 1.2 ...
nim 3. 各种集合
其实我挺想先去学习一下nim的模块系统,毕竟我决定暂时放弃学习golang,就是因为感觉他的模块和包方面的设计,不像c#+nuget的组合那么舒服. 但是这里还是先学习一下集合吧,感觉这方面nim很有 ...
开发环境需要同时安装2个nodejs版本
由于同时有vue2和vue3的项目开发情况,vue2项目的nodejs版本是12,vue3项目在node12版本下运行不了,要求最低14版本,因此要用nvm同时安装和控制2个版本. 安装步骤: 1.卸 ...