java：集合

文章目录

- 简介
- 顺序存储
- 链式存储
- 集合类和接口
- Collection
- - List
  - Set
  - - HashSet
    - TreeSet
- Map
- - HashMap
  - Hashtable
- Iterator（迭代器）
- Collections工具类

简介

集合就是一组数据，存储多个元素的数据结构。
集合的存储结构分为两种：

顺序结构
链式结构

顺序存储

将集合中的元素依次放在某个区域中，称为顺序结构，在内存中分配的空间是连续的。
特性：访问效率高、插入或删除效率低。
在这里插入图片描述

链式存储

在内存中分配的空间可以是不连续的，分为：

单向链式存储
双向链式存储

特性：插入和删除效率高，访问效率低
在这里插入图片描述

集合类和接口

集合相关的 API 都在 java.util 包中
在这里插入图片描述

Collection

是接口，继承自他接口的主要是List和Set

List

ArrayList

import java.util.ArrayList;

public class RunoobTest {
    
    
    public static void main(String[] args) {
    
    
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        // 访问元素
        sites.get(1); // 访问第二个元素
        // 修改元素
        sites.set(2, "Wiki"); // 第一个参数为索引位置，第二个为要修改的值
        // 删除元素
        sites.remove(3); // 删除第四个元素
        // 计算大小
        sites.size();
        // 迭代数组列表
        for (int i = 0; i < sites.size(); i++) {
    
    
            System.out.println(sites.get(i));
        }
        for (String i : sites) {
    
    
            System.out.println(i);
        }
        ...
        ...
        ...
    }
}
// [Google, Runoob, Taobao, Weibo]

详见

Vector

老了，不建议使用。
优点：线程安全

LinkedList

当需要频繁的插入或删除时，使用LinkedList，双向链式存储

扫描二维码关注公众号，回复： 12787971 查看本文章

// 引入 LinkedList 类
import java.util.LinkedList; 

LinkedList<E> list = new LinkedList<E>();   // 普通创建方法
或者
LinkedList<E> list = new LinkedList(Collection<? extends E> c); // 使用集合创建链表

import java.util.LinkedList;

public class RunoobTest {
    
    
    public static void main(String[] args) {
    
    
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        // 使用 addFirst() 在头部添加元素
        sites.addFirst("Wiki");
        // 使用 addLast() 在尾部添加元素
        sites.addLast("Wiki");
        // 使用 removeFirst() 移除头部元素
        sites.removeFirst();
        // 使用 removeLast() 移除尾部元素
        sites.removeLast();
        // 使用 getFirst() 获取头部元素
        sites.getFirst()
        // 使用 getLast() 获取尾部元素
        sites.getLast()
        // 迭代元素
        for (int size = sites.size(), i = 0; i < size; i++) {
    
    
            System.out.println(sites.get(i));
        }
        for (String i : sites) {
    
    
            System.out.println(i);
        }
        System.out.println(sites);
    }
}

Set

无序（元素顺序与放入顺序无关），不能按索引访问元素。
不可重复（集合中不可出现重复元素）。

HashSet

// 引入 HashSet 类      
import java.util.HashSet;

public class RunoobTest {
    
    
    public static void main(String[] args) {
    
    
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");  // 重复的元素不会被添加
        // 判断元素是否存在
        sites.contains("Taobao")
        sites.remove("Taobao");  // 删除元素，删除成功返回 true，否则为 false
        // 计算大小
        sites.size()
        // 迭代
        for (String i : sites) {
    
    
            System.out.println(i);
        }
        System.out.println(sites);
    }
}

TreeSet

会对元素进行排序，如从小到大

// 引入 TreeSet 类      
import java.util.TreeSet;

public class RunoobTest {
    
    
    public static void main(String[] args) {
    
    
    TreeSet<String> sites = new TreeSet<String>();
        sites.add(2);
        sites.add(5);
        sites.add(1);
        sites.add(3);
        sites.add(4);
        System.out.println(sites);
    }
}
// [1, 2, 3, 4, 5]

排序依据：
1、自然顺序
2、提供一个比较器

Map

它存储的内容是键值对(key-value)映射。

HashMap

// 引入 HashMap 类      
import java.util.HashMap;

public class RunoobTest {
    
    
    public static void main(String[] args) {
    
    
        // 创建 HashMap 对象 Sites
        HashMap<Integer, String> Sites = new HashMap<Integer, String>();
        // 添加键值对
        Sites.put(1, "Google");
        Sites.put(2, "Runoob");
        Sites.put(3, "Taobao");
        Sites.put(4, "Zhihu");
        // 访问元素
        Sites.get(3);
        // 删除元素
        Sites.remove(4);
        // 删除所有键值对
        Sites.clear();
        // 计算大小
        Sites.size();
        // 输出 key 和 value
        for (Integer i : Sites.keySet()) {
    
    
            System.out.println("key: " + i + " value: " + Sites.get(i));
        }
        // 返回所有 value 值
        for(String value: Sites.values()) {
    
    
          // 输出每一个value
          System.out.print(value + ", ");
        }
        System.out.println(Sites);
    }
}

Hashtable

同步的，线程安全（不常用）

Iterator（迭代器）

Java Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法，可用于迭代 ArrayList 和 HashSet 等集合。

迭代器 it 的两个基本操作是 next 、hasNext 和 remove。

调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。
调用 it.hasNext() 用于检测集合中是否还有元素。
调用 it.remove() 将迭代器返回的元素删除。

// 引入 ArrayList 和 Iterator 类
import java.util.ArrayList;
import java.util.Iterator;

public class RunoobTest {
    
    
    public static void main(String[] args) {
    
    

        // 创建集合
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");

        // 获取迭代器
        Iterator<String> it = sites.iterator();

        // 输出集合中的第一个元素
        System.out.println(it.next());
    }
}

输出集合 sites 中的所有元素：

// 引入 ArrayList 和 Iterator 类
import java.util.ArrayList;
import java.util.Iterator;

public class RunoobTest {
    
    
    public static void main(String[] args) {
    
    

        // 创建集合
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");

        // 获取迭代器
        Iterator<String> it = sites.iterator();

        // 输出集合中的所有元素
        while(it.hasNext()) {
    
    
            System.out.println(it.next());
        }
    }
}

删除元素

// 引入 ArrayList 和 Iterator 类
import java.util.ArrayList;
import java.util.Iterator;

public class RunoobTest {
    
    
    public static void main(String[] args) {
    
    
        ArrayList<Integer> numbers = new ArrayList<Integer>();
        numbers.add(12);
        numbers.add(8);
        numbers.add(2);
        numbers.add(23);
        Iterator<Integer> it = numbers.iterator();
        while(it.hasNext()) {
    
    
            Integer i = it.next();
            if(i < 10) {
    
      
                it.remove();  // 删除小于 10 的元素
            }
        }
        System.out.println(numbers);
    }
}

Collections工具类

操作集合的工具类

import java.util.ArrayList;

public class RunoobTest {
    
    
    public static void main(String[] args) {
    
    
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        // 访问元素
        Collections.addAll(sites, "123", "哈哈哈")
        // 最大值
        Collections.max(sites)
        // 翻转
        // 替换
        // 交换
        // 初始化
    }
}
// [Google, Runoob, Taobao, Weibo]