Java的集合

最新推荐文章于 2024-09-25 10:59:43 发布

Sayers-denb

最新推荐文章于 2024-09-25 10:59:43 发布

阅读量135

点赞数 1

文章标签： java 开发语言 jvm

本文链接：https://blog.csdn.net/m0_70990872/article/details/125510041

版权

Java集合

在Java中，Java的集合类主要负责保存、盛装其他数据，因此集合类也被称为容器类，Java 集合类型分为 Collection 和 Map，它们是 Java 集合的根接口，这两个接口包含了一些子接口或实现类。

一、Collection集合

Collection 是最基本的集合接口，一个 Collection 代表一组 Object，即为Collection 的元素, Java不提供直接继承自Collection的类，只提供继承于的子接口(如List和set)，即Collection接口主要分为List接口和Set接口。Collection 接口存储一组不唯一，无序的对象。
Collection的主要特点为有顺性、唯一性、获取元素。

1.1add

add的作用主要为：把给定的对象添加到当前集合中。其实例为：

import java.util.Collection;
import java.util.ArrayList;
 
public class DemoCollectionAdd {
    public static void main(String[] args) {
        // 使用多态，创建一个ArrayList对象
        Collection<String> collection = new ArrayList<>();
 
        // 输出该集合的内容是为空的（其中它重写了toString方法）
        System.out.println("没有进行任何操作的ArrayList集合对象：" + collection);
 
        // 往ArrayList集合中添加元素，返回值只一个boolean值，一般不用接收这个返回值
        boolean addReturn = collection.add("LeeHua");
        System.out.println("往集合中添加一个元素后的返回值：" + addReturn);
        System.out.println("使用add方法往集合里面添加了元素后：" + collection);
    }
}

其输出的结果为：
没有进行任何操作的ArrayList集合对象：[]
往集合中添加一个元素后的返回值：true
使用add方法往集合里面添加了元素后：[LeeHua]

1.2remove

remove就是删除指定的元素，把给定的对象在当前集合中册除。其实例为：

import java.util.Collection;
import java.util.ArrayList;
 
public class DemoCollectionRemove {
    public static void main(String[] args) {
        // 使用多态，创建一个ArrayList对象
        Collection<String> collection = new ArrayList<>();
        System.out.println("往集合中添加元素前的集合是：" + collection);
 
        // 往集合中添加元素
        collection.add("一号");
        collection.add("二号");
        collection.add("三号");
        collection.add("四号");
        System.out.println("往集合中添加元素后的集合是：" + collection);
 
        // 使用remove方法，把给定的对象在当前集合中册除
        // 如果要删除的元素存在该集合，那么就返回true
        // 否则返回false
        boolean removeReturn1 = collection.remove("一号");
        System.out.println("删除元素\"一号\"的返回值：" + removeReturn1);
        System.out.println("删除元素\"一号\"后的集合是：" + collection);
 
        boolean removeReturn2 = collection.remove("十号");
        System.out.println("删除元素\"十号\"的返回值：" + removeReturn2);
        System.out.println("删除元素\"十号\"后的集合是：" + collection);
    }
}

其输出的结果为：
往集合中添加元素前的集合是：[]
往集合中添加元素后的集合是：[一号, 二号, 三号, 四号]
删除元素"一号"的返回值：true
删除元素"一号"后的集合是：[二号, 三号, 四号]
删除元素"十号"的返回值：false
删除元素"十号"后的集合是：[二号, 三号, 四号]

1.3contains

contains作用为判断集合是否包含给定的对象。其实例如下：

import java.util.ArrayList;
import java.util.Collection;
 
public class DemoCollectionContains {
    public static void main(String[] args) {
        Collection<String> collection = new ArrayList<>();
 
        // 往集合中添加元素
        collection.add("对象1");
        collection.add("对象2");
        collection.add("对象3");
        collection.add("对象4");
        System.out.println("集合：" + collection);
 
        // 使用contains方法，判断当前集合中是否包合给定的对象
        // 如果包合给定的对象，那么就返回true
        // 否则返回false
        boolean containsReturn1 = collection.constains("对象100");
        System.out.println("是否包含\"对象100\"：" + containsReturn1);
 
        boolean containsReturn2 = collection.constains("对象1");
        System.out.println("是否包含\"对象1\"：" + containsReturn2);
    }
}

其输出结果为：
集合：[对象1, 对象2, 对象3, 对象4]
是否包含"对象100"：false
是否包含"对象1"：true

1.4isEmoty

isEmpty是来判断集合是否为空集合，为空则返回ture。其实例如下：

import java.util.ArrayList;
import java.util.Collection;
 
public class DemoCollectionIsEmpty {
    public static void main(String[] args) {
        // 使用多态，创建一个ArrayList对象
        Collection<String> collection = new ArrayList<>();
 
        // 判断集合是否为空
        boolean isEmptyReturn1 = collection.isEmpty();
        System.out.println("集合是否为空：" + isEmptyReturn1);
 
        // 向集合里面添加元素
        collection.add("一号元素");
        // 判断集合是否为空
        boolean isEmptyReturn2 = collection.isEmpty();
        System.out.println("集合是否为空：" + isEmptyReturn2);
    }
}

其输出结果为：
集合是否为空：true
集合是否为空：false

1.5size

size就是用来返回集合中元素的个数。其实例如下：

import java.util.ArrayList;
import java.util.Collection;
 
public class DemoCollectionSize {
    public static void main(String[] args) {
        // 使用多态，创建一个ArrayList对象
        Collection<String> collection = new ArrayList<>();
 
        // 使用size方法，查看集合中的元素个数
        int collectionSize1 = collection.size();
        System.out.println("collectionSize1 = " + collectionSize1);
 
        // 往集合中添加元素
        collection.add("一号元素");
        collection.add("二号元素");
        collection.add("三号元素");
        collection.add("四号元素");
        collection.add("五号元素");
 
        // 使用size方法，再次查看集合中的元素个数
        int collectionSize2 = collection.size();
        System.out.println("collectionSize2 = " + collectionSize2);
    }
}

其输出的结果为：
collectionSize1 = 0
collectionSize2 = 5

1.6toArray

toArray就是把集合中的元素存储到数组中。其实例如下：

public class DemoCollectionToArray {
    public static void main(String[] args) {
        // 使用多态，创建一个ArrayList对象
        Collection<String> collection = new ArrayList<>();
 
        // 往集合中添加元素
        collection.add("一号元素");
        collection.add("二号元素");
        collection.add("三号元素");
        collection.add("四号元素");
        collection.add("五号元素");
 
        // 使用toArray方法，把集合中的元素，存储到数组中。
        Object[] collectionToArray = collection.toArray();
 
        // 遍历输出
        for (int i = 0; i < collectionToArray.length; i++) {
            System.out.println(collectionToArray[i]);
        }
    }
}

其输出的结果为：
一号元素
二号元素
三号元素
四号元素
五号元素

1.7clear

clear就是清空集合中的所用元素。其实例如下：

import java.util.ArrayList;
import java.util.Collection;
 
public class DemoCollectionClear {
    public static void main(String[] args) {
        // 使用多态，创建一个ArrayList对象
        Collection<String> collection = new ArrayList<>();
 
        // 往集合中添加元素
        collection.add("一号元素");
        collection.add("二号元素");
        collection.add("三号元素");
        collection.add("四号元素");
        collection.add("五号元素");
        System.out.println("清空集合元素之前：" + collection);
 
        // 使用clear方法，清空集合中的所用元素
        collection.clear();
        System.out.println("清空集合元素之后：" + collection);
    }
}

其输出的结果为：
清空集合元素之前：[一号元素, 二号元素, 三号元素, 四号元素, 五号元素]
清空集合元素之后：[]

二、List

2.1List的介绍

List 接口的主要特点为按照元素进入先后有序保存，可重复并且有索引，包含了一些索引的方法。List接口是最常用的接口。是有序集合，允许有相同的元素。使用 List 能够精确地控制每个元素插入的位置，用户能够使用索引（元素在 List 中的位置，类似于数组下标）来访问 List 中的元素，与数组类似。

2.2List的分类

List主要包含LinkedList 接口、 ArrayList 接口、Vector 接口。
1.LinkedList 接口实现类，链表和插入删除，但没有同步，线程也不安全。
2.ArrayList 接口实现类，数组和随机访问，但没有同步，线程也不安全。
3.Vector 接口实现类数组，同步，线程安全.
4.Stack 是Vector类的实现类。

2.2.1LinkedList

LinkedList的主要特点为底层数据结构是链表，查询慢，增删快，线程不安全，效率高，可以存储重复元素。
特有的功能有：
1.添加
addFirst() addLast()
2.删除
removeFirst() removeLast()
3.获取
getFirst() getLast()

2.2.2ArrayList

ArrayList的主要特点为底层数据结构是数组，查询快，增删慢，线程不安全，效率高，可以存储重复元素。
ArrayList没有特有的功能，但是他常常被使用。

2.2.3Vector

Vector的主要特点为底层数据结构是数组，查询快，增删慢，线程安全，效率低，可以存储重复元素。
其特有的功能为：

public void addElment(E  obj)   //相当于add()

public E elementAt(int index)    //相当于get()

public Enumeration<E> elements()   //相当于iterator()

三、Set

3.1Set的介绍

Set 具有与 Collection 完全一样的接口，只是行为上有所不同，Set 不保存重复的元素。Set 接口存储一组唯一的无序的对象。（就是仅接收一次，不可重复，并做内部排序）。

3.2Set的分类

Set主要分为HashSet、LinkedHashSet、TreeSet。
HashSet使用hash表（数组）存储元素。
LinkedHashSet链表维护元素的插入次序。
TreeSet底层实现为二叉树，元素排好序。

3.2.1HashSet

HashSet集合的特点为：
1.底层数据结构是哈希表(是一个元素为链表的数组)
2.不能保证元素的顺序。
3…HashSet不是线程同步的，如果多线程操作HashSet集合，则应通过代码来保证其同步。
4.集合元素值可以是null。
5.影响哈希冲突的条件，首先看哈希值是否相等，然后判断equals是否相等（内容是否相等）。

3.2.2LinkedHashSet

LinkedHashSet集合的特点为：
1.底层数据结构是由哈希表和链表组成。
2.原来存储是什么顺序，就是什么顺序。

3.2.3TreeSet

TreeSet集合的特点为：
1.底层数据结构是红黑树(是一个自平衡的二叉树)。
2.保证元素的排序方式（自然排序），实现Comparable接口。

四、List与Set的区别

1.Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。

2.Set 检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。

3.List 和数组类似，可以动态增长，根据实际存储的数据的长度自动增长 List 的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。

五、Map

Map 接口就是存储一组键值对象，提供key（键）到value（值）的映射。

4.1Map的分类

Map 接口键值对的集合（双列集合），其主要的分类有：
1.Hashtable 接口实现类，同步，线程安全。
2.HashMap 接口实现类，没有同步，线程不安全。
3. LinkedHashMap 双向链表和哈希表实现。
4.WeakHashMap。
5.TreeMap 红黑树对所有的key进行排序。
6.IdentifyHashMap。

4.2Map的主要方法

1.void clear

2.boolean containskey(Object key) //查询Map中是否包含指定的key，如果包含则返回true

3.boolean containsValue(Object value) //查询Map中是否包含指定的value，如果包含则返回true

4.set entrySet() //返回Map中所包含的键值对所组成的set集合，每个集合元素都是Map.Enpty对象(Enpty是Map的内部类)

5.Object get(Object Key) //返回指定key所对应的value，如Map中不包含key则返回null

6.boolean isEnpty() //查询Map是否为空，如果为空则返回true

7.Set keySet() //返回该Map中所有key所组成的set集合

8.Object put(Object key , Object value) //添加一个键值对，如果已有一个相同的key值，则新的键值对覆盖旧的键值对

9.void putAll(Map m) //将指定Map中的键值对复制到Map中

10.Object remove(Object key) //删除指定key所对应的键值对，返回可以所关联的value，如果key不存在，则返回null

11.int size() //返回该Map里的键值对的个数

12.Collection values() //返回该Map里所有value组成的Collection

13.内部类Enpty
Object getkey() //返回该Enpty所包含的key值
Object getValue() //返回该Enpty所包含的Value值
Object setValue(V value) //设置该Enpty所包含的value值，并返回新设置的value值

4.3遍历 Map

遍历Map的实例如下：

import java.util.*;
 
public class Test{
     public static void main(String[] args) {
      Map<String, String> map = new HashMap<String, String>();
      map.put("1", "value1");
      map.put("2", "value2");
      map.put("3", "value3");
      
      //第一种：普遍使用，二次取值
      System.out.println("通过Map.keySet遍历key和value：");
      for (String key : map.keySet()) {
       System.out.println("key= "+ key + " and value= " + map.get(key));
      }
      
      //第二种
      System.out.println("通过Map.entrySet使用iterator遍历key和value：");
      Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
      while (it.hasNext()) {
       Map.Entry<String, String> entry = it.next();
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
      }
      
      //第三种：推荐，尤其是容量大时
      System.out.println("通过Map.entrySet遍历key和value");
      for (Map.Entry<String, String> entry : map.entrySet()) {
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
      }
    
      //第四种
      System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
      for (String v : map.values()) {
       System.out.println("value= " + v);
      }
     }
}