Java-集合（Collection）

最新推荐文章于 2022-04-01 09:43:39 发布

pmc0_0

最新推荐文章于 2022-04-01 09:43:39 发布

阅读量189

点赞数 1

分类专栏： java 文章标签： java 数据结构集合

本文链接：https://blog.csdn.net/pmc0_0/article/details/114020943

版权

java 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

图是网上盗的哈哈

（上图是百度的直接盗来用了哈哈，下来直接步入正题）集合不能存储基本数据类型，也不能直接存储java对象，集合存储的都是引用，集合又分为两大类：

Collection
Map

list.add(100) // 自动装箱Integer

Collection

Collection接口继承了Iterable接口，Iterable有一个Iterator()方法，可以返回一个集合的迭代器对象，用来遍历集合的元素，Collection我们主要学两个子接口：

List
Set

List<Integer> list = new ArrayList<>();
Iterator iterator = list.iterator();

Modifier and Type	Method and Description
boolean	add(E e) 确保此集合包含指定的元素（可选操作）
boolean	remove(Object o) 从这个集合中移除指定元素的一个实例，如果它是存在的（可选操作）
int	size() 返回此集合中的元素的数目。
void	clear() 从这个集合中移除所有的元素（可选操作）
Iterator<E>	iterator() 返回此集合中的元素的迭代器

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

// Colletion集合通用的遍历方式
public class Test03 {
    public static void main(String[] args) {
        Collection<Integer> list = new ArrayList<>();

        list.add(10);
        list.add(9);
        list.add(8);
        list.add(3);

        // 返回此集合中的元素的迭代器，当集合发生改变，迭代器要重新获取，否则会出现运行时异常
        Iterator iterator = list.iterator();

        /**
        * boolean hasNext() 返回 true 表示还有元素可以迭代。
        * E next() 返回迭代中的下一个元素。（取出元素）
        */
        while(iterator.hasNext()){
            System.out.println(iterator.next());
            // 删除iterator指向的当前元素，不能用集合对象去删除，用集合对象去删除，集合发生改变，迭代器要重新获取
            iterator.remove();
        }

    }
}

List 接口

List集合存储元素特点是有序可重复的，存储的元素有下标，有两个重要的实现类：

ArrayList 查询数据比较快，添加和删除数据比较慢(（底层采用了数组数据结构）
LinkedList 查询数据比较慢，添加和删除数据比较快（底层采用了双向链表数据结构）

Modifier and Type	Method and Description
E	get(int index) 返回此列表中指定位置的元素
int	indexOf(Object o) 返回此列表中指定元素的第一个出现的索引（下标），或如果此列表不包含元素，返回- 1
E	set(int index, E element) 用指定元素替换此列表中指定位置的元素（可选操作）

Set 接口

Set集合存储元素特点是无序不可重复的，存储的元素没有下标，有一个重要实现类和一个子接口SortedSet，子接口SortedSet又有一个重要的实现类：

HashSet （底层是哈希表数据结构）
TreeSet 元素自动排序（小到大）（底层是二叉树数据结构）

import java.util.*;

public class SetTest01 {
    public static void main(String[] args) {
        Set set = new HashSet();
        set.add(3);
        set.add(4);
        set.add(5);
        set.add(6);
        set.add(6);
        set.add(6);

        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }


    }
}

结果：

“D:\JDK\JDK SE8\bin\java.exe” "-javaagent:D:\IDEA\IntelliJ IDEA
3
4
5
6
Process finished with exit code 0
（重复元素不会报错，但只能有一个）

TreeSet

放到TreeSet集合中的元素，等同于故到TreeMap集合key部分。一般用于排序需求的数据存取，比如要从数据库中查询一些人，人要按照年龄排序，但TreeSet不能对自定义的类型比较，如果要把对象信息放TreeSet中，要求按照年龄排序，要实现Comparable接口重写compareTo()方法

// 自定义类型要实现Comparable接口才能放到TreeSet中比较
public class User implements Comparable<User>{

    private String name;
    private String id;
    private Integer age;

    public User(Integer age){
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public int compareTo(User user) {
        return this.age - user.age ; // 升序排列，为什么这样看源码的二叉树比较原理
    }


    @Override
    public String toString(){
        return this.age.toString();
    }
}

import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class TreeSetTest01 {
    public static void main(String[] args) {
    	// 也可以自定义一个比较器，在创建TreeSet的时候用构造方法传一个比较器进去，这里不进行演示了
        Set<User> set = new TreeSet<>();

        User user1 = new User(3);
        User user2 = new User(5);
        User user3 = new User(99);
        User user4 = new User(25);

        set.add(user1);
        set.add(user2);
        set.add(user3);
        set.add(user4);

        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
}

结果：

3
5
25
99

Map

Map集合存储特点是以key-value这种键值对方式去存储元素，key是无序不可重复的，有两个重要的实现类:

TreeMap （底层是二叉树数据结构）
HashMap (底层是哈希表数据结构)

Modifier and Type	Method and Description
V	get(Object key) 返回指定的键映射的值，或 null如果这个Map不包含的键映射
int	hashCode() 返回此映射的哈希代码值
Set<K>	keySet() 返回一个 Set的关键视图包含在这个Map（获取一个key的set集合）
V	put(K key, V value) 将指定的值与此映射中的指定键关联（可选操作）
int	size() 返回这个映射中的键值映射的数目
boolean	containsValue(Object value) 返回 true如果映射到指定的值的一个或多个键
V	remove(Object key) 如果存在（可选操作），则从该Map中移除一个键的映射（键值对）
Set<Map.Entry<K,V>>	entrySet() 返回一个 Set视图的映射包含在这个Map

// Set<Map.Entry<K,V>> 方法演示
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapTest01 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();

        map.put("小明",1);
        map.put("小和",2);
        map.put("小白",9);
        map.put("小黄",6);
        map.put("小路",7);

        Set set = map.entrySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

结果：

小明=1
小白=9
小和=2
小路=7
小黄=6
Process finished with exit code 0
Map.Entry<K,V>是一个静态内部类，也是返回的Set集合泛型约束的类型

Map的遍历

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * Map集合的遍历
 */
public class MapTest02 {
    public static void main(String[] args) {

        Map<Integer,String> map = new HashMap();

        map.put(1,"xiaobai");
        map.put(2,"xiaoming");
        map.put(3,"xiaoh");
        map.put(4,"xiaol");

        // 第一种方式：获取所有的key，通过遍历key获取所有的value
        Set<Integer> keys = map.keySet(); // 获取所有key的集合，其实就是一个Set集合
        Iterator iterator = keys.iterator(); // 通过迭代器和get（）方法去取出value

        while (iterator.hasNext()){
            System.out.println(map.get(iterator.next()));
        }

        //也可以用foreach
        for (Integer key:
             keys) {
            System.out.println(map.get(key));
        }

        System.out.println("==============");

        // 第二种方式：通过entrySet()方法返回一个Set<Map.Entry<K,V>>集合
        Set<Map.Entry<Integer,String>> set = map.entrySet();

        // 迭代，每次取出的是一个Node，Node有专门的方法去取key和value，效率比第一种更高效
        Iterator<Map.Entry<Integer,String>> iterator1 = set.iterator();

        while (iterator1.hasNext()){
            Map.Entry<Integer,String> node = iterator1.next();
            System.out.println(node.getKey());
            System.out.println(node.getValue());
        }

    }
}

Collections（集合工具类）

为了方便操作集合

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

public class CollectionsTest {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();

        // 让list变成线程安全
        Collections.synchronizedList(list);

        // 排序
        Collections.sort(list);
     
    }
}