Java 集合的概念

合集 - JavaSE(37)

1.JavaSE 关键字和标识符2024-05-25 2.JavaSE 标签 break continue2024-05-25 3.JavaSE的方法 (函数)2024-05-25 4.JavaSE数组2024-05-25 5.JavaSE笔记总汇2024-05-25 6.JavaSE什么是面向对象?2024-05-25 7.Java中的变量分类(按照位置分类)2024-05-26 8.Java中类的构造与方法的重载2024-05-26 9.Java中对的创建与引用2024-05-26 10.Java static 关键字2024-05-26 11.Java中的代码块2024-05-26 12.Java中的包(Package)2024-05-26 13.Java访问权限修饰符2024-05-26 14.Java面向对象的三大特征!!!2024-05-26 15.Java final关键字2024-05-26 16.Java中的接口2024-05-26 17.Java中的空指针异常 java.lang.NullPointerException2024-05-26 18.Java中正则表达式的用法2024-05-26 19.Java中Calendar类与SimpleDateFormat类的介绍2024-05-26 20.Java BigInteger类和BigDecimal()类2024-05-26 21.Java StringBuffer 与StringBuilder 类的介绍与区别2024-05-26 22.Java方法传参中"..."的作用2024-05-26

23.Java 集合的概念2024-05-26

24.Java中File类和I/O2024-05-26 25.Java异常2024-05-26 26.Java中try catch finally 关键字2024-05-26 27.Java异常中throw 与throws的区别2024-05-26 28.Java中编译异常与运行异常的区别2024-05-26 29.Java网络编程2024-05-26 30.Java线程概念集合2024-05-26 31.Java synchronized与ReentrantLock的区别2024-05-26 32.Java常用的三个方法 `wait ` `notify` `notifyAll`2024-05-26 33.Java线程的生命周期2024-05-26 34.Java中GUI2024-05-26 35.Java GUI setSize()、setPreferredSize()的区别2024-05-26 36.Java Lambda表达式2024-06-02 37.Java Stream流2024-06-04

集合

集合

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);
       }

双列集合

doubleCollection

HashMap(对Map接口的实现)

底层实现逻辑

HashMap结构图

转化红黑树的原理如下

补: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一样

posted @ 2024-05-26 17:57 Yang0710 阅读(23) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· JavaSE数组

· 数据结构顺序表(C语言与 Java实现)以及部分练习题

· Java集合(简单介绍)

· java-集合

· 集合process2

阅读排行：
· Manus爆火，是硬核还是营销？
· 终于写完轮子一部分：tcp代理了，记录一下
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· 别再用vector＜bool＞了！Google高级工程师：这可能是STL最大的设计失误
· 单元测试从入门到精通

公告

昵称： Yang0710
园龄： 1年3个月
粉丝： 2
关注： 1

+加关注

2025年3月

日

一

二

三

四

五

六

cwyYYDS

Java 集合的概念

集合

单列集合(Collection)

Collection中的一些方法

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

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

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

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

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

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

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

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

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

构造方法

方法

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()

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

构造方法

方法

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()

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

构造方法

方法

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()

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

构造方法

TreeSet方法

public boolean add(E e)

public void clear()

public boolean contains(Object o)

public boolean isEmpty()

public boolean remove(Object o)

public E pollLast()

public E first()

public E pollFirst()

public E last()

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

构造方法

HashSet常用方法

public boolean add(E e)

public boolean contains(Object o)

public boolean remove(Object o)

public boolean isEmpty()

public void clear()

对单列集合的遍历

双列集合

HashMap(对Map接口的实现)

底层实现逻辑

构造方法