Java集合详解

内容：

1、List相关

2、Set相关

3、Collection总结

4、Map相关

5、其他

1、List相关

(1)List集合存储数据的结构

List接口下有很多个集合，它们存储元素所采用的结构方式是不同的，这样就导致了这些集合有它们各自的特点，

在不同的环境下进行使用。数据存储的常用结构有：堆栈、队列、数组、链表

堆栈(栈)的特点：

• 先进后出
• 栈的入口和出口都是栈的顶端位置
• 压栈(压入元素)、弹栈(弹出元素)

队列的特点：

• 先进先出
• 队列的入口、出口各占一侧

数组的特点：

• 查找元素快(通过索引，可以快速访问指定位置的元素)
• 增删元素慢(需要移动元素)

链表的特点：

• 多个节点之间，通过地址进行连接
• 查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素
• 增删元素快：只需修改连接下个元素的地址

 

(2)List接口的特点及其实现类

List接口的特点：

• 有下标
• 有序的(存和取的顺序一致)
• 可重复

List接口实现类：ArrayList、LinkedList、Vector

• ArrayList：底层采用数组结构，查询快，增删慢  =》线程不安全
• LinkedList：底层采用链表结构，查询慢，增删快  =》线程不安全
• Vector：底层采用数组结构，查询快，增删慢  =》线程安全

List接口的方法：

• 增：add(E e)  add(int index, E e)
• 删：remove(Object obj) remove(int index)
• 改：set(int index, E e)
• 查：get(int index)
• 其他方法：size()、clear()、contains(Object obj)、toArray()、iterator()、isEmpty()

实现类中的方法：

• ArrayList：方法基本和List中定义的一模一样
• LinkedList：除了和List接口中一样的方法之外，还有一些特有的方法

 

(3)LinkedList集合

LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。实际开发中对一个集合元素的添加与删除

经常涉及到首尾操作，而LinkedList提供了大量首尾操作的方法。如下图

LinkedList是List的子类，List中的方法LinkedList都是可以使用，这里就不做详细介绍，我们只需要了解LinkedList的特有方法即可。

在开发时，LinkedList集合也可以作为堆栈，队列的结构使用

使用实例：

public class useLinkedList {
    public static void main(String[] args) {
        LinkedList<String> link = new LinkedList<String>();
        // 添加元素
        link.addFirst("abc1");
        link.addFirst("abc2");
        link.addFirst("abc3");
        // 获取元素
        System.out.println(link.getFirst());    // abc3
        System.out.println(link.getLast());        // abc1
        // 删除元素
        System.out.println(link.removeFirst());    // abc3
        System.out.println(link.removeLast());    // abc1

        while (!link.isEmpty()) { // 判断集合是否为空
            System.out.println(link.pop()); // 弹出集合中的栈顶元素
            // abc2
        }
    }
}

2、Set相关

(1)Set接口的特点及其实现类

Set接口的特点：

• 无下标
• 无序的(无序是指存和取的顺序不一定一致，LinkedHashSet和TreeSet除外)
• 不可重复

Set接口实现类：HashSet、LinkedHashSet、TreeSet

• HashSet：底层采用哈希表结构，查询快，增删快，无序的
• LinkedHashSet：底层采用链表+哈希表结构，查询快，增删快，有序的 
• TreeSet：底层采用红黑树结构，查询快，增删快， 有序的 

Set接口的方法：没有特有方法，基本和父接口Collection类一模一样

实现类中的方法：实现类中的方法基本和Set一模一样

(2)哈希相关

对象的哈希值：任何对象都有一个哈希值，哈希值是对象的一个数字表示　　

对象的字符串表示：toString方法，默认表示格式：包名.类名@地址值(这里的地址值实际上是哈希值的16进制)

如何获取对象的哈希值 =》hashCode方法(默认按地址值计算)

什么是哈希表：

哈希表底层使用的也是数组机制，数组中也存放对象，而这些对象往数组中存放时的位置比较特殊，当需要把这些

对象给数组中存放时，那么会根据这些对象的特有数据结合相应的算法，计算出这个对象在数组中的位置，然后把

这个对象存放在数组中。而这样的数组就称为哈希数组，即就是哈希表

hashCode方法和equals方法：

当向哈希表中存放元素时，需要根据元素的特有数据结合相应的算法，这个算法就是Object类中的hashCode方法。

在给哈希表中存放对象时，会调用对象的hashCode方法，算出对象在表中的存放位置，这里需要注意，如果两个对象

hashCode方法算出结果一样，这样现象称为哈希冲突，这时会调用equals方法，比较这两个对象是不是同一个对象，

如果equals方法返回true，那么就不会把第二个对象存放在哈希表中，如果返回false，就会把这个值存放在哈希表中。

public class StringHashCodeDemo {
    public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = new String("abc");
    
        System.out.println(s1==s2);        // false
        System.out.println(s1.hashCode()==s2.hashCode());    // true
        System.out.println(s1.equals(s2));                    // true
        
    }
}

注意：String类重写了hashCode方法,按照自己的方式计算(只要字符串内容一样哈希值一定相同)

总结：保证HashSet集合元素的唯一，其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义

的对象，那么保证其唯一，就必须复写hashCode和equals方法建立属于当前对象的比较方式。

哈希表结构判断元素是否重复的原理：

hashCode()：先判断新元素的哈希值是否和旧元素哈希值相同，如果都不相同直接判断不重复，添加

equals()：再调用新元素和哈希值相同的旧元素的equals方法，如果返回true判定重复元素，不添加，否则添加(不重复)

(3)Set使用实例

public class HashSetDemo {

    public static void main(String[] args) {
        // 创建HashSet对象
        HashSet<String> hs = new HashSet<String>();
        // 给集合中添加自定义对象
        hs.add("zhangsan");
        hs.add("lisi");
        hs.add("wangwu");
        hs.add("zhangsan");
        System.out.println(hs);
        // 判断是否含有某个元素
        System.out.println(hs.contains("lisi"));    // true
        // 取出集合中的每个元素
        Iterator<String> it = hs.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
    }
}

3、Collection总结

(1)Collection

Collection分类：

• List 可以存储重复元素,有序的(元素存取顺序),有索引  =》ArrayList、LinkedList
• Set 不能存储重复元素,无序的(元素存取顺序,LinkedHashSet是有序的),无索引 =》HashSet、LinkedHashSet

Collection方法：

• boolean add(Object e) 　　      把给定的对象添加到当前集合中
• void clear() 　　                        清空集合中所有的元素
• boolean remove(Object o) 　　把给定的对象在当前集合中删除
• boolean contains(Object o) 　　判断当前集合中是否包含给定的对象
• boolean isEmpty() 　　             判断当前集合是否为空
• Iterator iterator() 　　                迭代器，用来遍历集合中的元素的
• int size() 　　                             返回集合中元素的个数
• Object[] toArray() 　　               把集合中的元素，存储到数组中
• Iterator :                                     迭代器
• Object next()　　                      返回迭代的下一个元素
• boolean hasNext()　　             如果仍有元素可以迭代，则返回 true。

 

(2)List和Set

List与Set集合的区别：

• List是一个有序的集合(元素存与取的顺序相同)，可以存储重复的元素                       
• Set是一个无序的集合(元素存与取的顺序可能不同)，不能存储重复的元素

List集合中的特有方法(下标)：

• void add(int index, Object element) 将指定的元素，添加到该集合中的指定位置上
• Object get(int index)返回集合中指定位置的元素
• Object remove(int index) 移除列表中指定位置的元素, 返回的是被移除的元素
• Object set(int index, Object element)用指定元素替换集合中指定位置的元素,返回值的更新前的元素

 

List和Set的实现类：

ArrayList：

        底层数据结构是数组，查询快，增删慢

        线程不安全，效率高

LinkedList：

        底层数据结构是链表，查询慢，增删快

        线程不安全，效率高

Vector：

        底层数据结构是数组，查询快，增删慢

        线程安全，效率不高

HashSet:

        元素唯一不能重复

        底层结构是 哈希表结构

        元素的存与取的顺序不能保证一致

LinkedHashSet:

        元素唯一不能重复

        底层结构是 链表结构+哈希表结构

       元素的存与取的顺序一致

(3)Set中元素的唯一性

如何保证元素的唯一的：重写hashCode() 与 equals()方法

(4)contains

ArrayList的contains方法：

调用时,会使用传入的元素的equals方法依次与集合中的旧元素所比较，从而根据返回的布尔值判断

是否有重复元素。此时，当ArrayList存放自定义类型时，由于自定义类型在未重写equals方法前，判断是否重复的依据是地址值，

所以如果想根据内容判断是否为重复元素，需要重写元素的equals方法 

HashSet的contains方法：

与add方法同理，先判断哈希值再使用equals方法判断，只要旧元素和判断的元素的哈希值相同并且equals方法为true才判定包含

4、Map相关

(1)Map集合的特点

• Map集合和Collection集合没有继承关系，所以不能直接用迭代器
• Collection集合每一个元素都是单独存在，而Map集合中的每一个元素都是成对存在
• Map<K, V> 两个泛型，K代表键的类型，V代表值的类型，K和V必须是引用类型
• 在Map集合的元素中键是唯一的，值是可以重复的

(2)Map接口常用集合概述(实现类)

通过查看Map接口描述，看到Map有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集合：

HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，

需要重写键的hashCode()方法、equals()方法。

LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构

可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

 

注：

• 当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法
• 如果要保证map中存放的key和取出的顺序一致，可以使用LinkedHashMap集合来存放

 

(3)Map接口中的常用方法

public class HashMapDemo {
    public static void main(String[] args) {
        // 创建Map对象
        Map<String, String> map = new HashMap<String, String>();
        // 给map中添加元素
        map.put("星期一", "Monday");
        map.put("星期日", "Sunday");
        System.out.println(map); // {星期日=Sunday, 星期一=Monday}

        // 当给Map中添加元素，会返回key对应的原来的value值，若key没有对应的值，返回null
        System.out.println(map.put("星期一", "Mon")); // Monday
        System.out.println(map); // {星期日=Sunday, 星期一=Mon}

        // 根据指定的key获取对应的value
        String en = map.get("星期日");
        System.out.println(en); // Sunday

        // 根据key删除元素,会返回key对应的value值
        String value = map.remove("星期日");
        System.out.println(value); // Sunday
        System.out.println(map); // {星期一=Mon}
    }
}

(4)Map集合遍历方式

键找值方式：即通过元素中的键，获取键所对应的值

• KeySet()：获取Map集合中的所有键
• get(Object key)：通过指定的键从map集合中找出相应的值

for(String key:map.keySet()){
    System.out.println(key + " = " + map.get(key));
}

EntrySet方式(键值对方式)：

在Map类设计时，提供了一个嵌套接口：Entry。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，

就可以从每一个键值对（Entry）对象中获取对应的键与对应的值：

Set<Map.Entry<String, String>> entrySet = map.entrySet();
for (Map.Entry<String, String> entry : entrySet) {
    Stringkey = entry.getKey();
    String value = entry.getValue();
    System.out.println(key+"....."+value);
}

// 上面的代码也可以简化成这样：
for (Map.Entry<String, String> entry : map.entrySet()) {
    Stringkey = entry.getKey();
    String value = entry.getValue();
    System.out.println(key+"....."+value);
}

(5)LinkedHashMap

HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？

在HashMap下面有一个子类LinkedHashMap，它是链表和哈希表组合的一个数据存储结构，它可以保证有序

import java.util.*;
import java.util.Map.Entry;

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

        map.put("1", "a");
        map.put("2", "b");
        map.put("3", "c");

        for (Entry<String, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + "  " + entry.getValue());
        }
        // 输出结果:
        // 1 a
        // 2 b
        // 3 c
    }
}

5、其他

(1)Properties类介绍

Properties类表示了一个持久的属性集。Properties可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。

特点：

• 是Hashtable的子类，map集合中的方法都可以用
• 该集合没有泛型。键值都是字符串
• 是一个可以持久化的属性集。键值可以存储到集合中，也可以存储到持久化设备上。键值的来源也可以是持久化设备。
• 有和流技术相结合的方法。

特有的方法：

• public String getProperty(String key)　　　　　　　　功能就是Map中的get方法
• public Object setProperty(String key, String value)　    功能就是Map中的put方法
• public Set<String> stringPropertyNames()　　　　　  返回此属性列表中的键集(Map中的KeySet方法)

和流技术结合的方法：

• store方法：保存数据到文件
• load方法：加载数据

import java.io.*;
import java.util.Properties;

public class PropertiesDemo {
    public static void main(String[] args) throws IOException {
        // 创建对象
        Properties ps = new Properties();
        // 添加数据
        ps.setProperty("test", "18");
        ps.setProperty("test2", "16");
        ps.setProperty("test3", "18");
        // 讲ps的数据持久化到文件中
        ps.store(new FileWriter("test.properties"), "author is wyb");

        Properties t = new Properties();
        // 从文件中读取数据到t中
        t.load(new FileReader("test.properties"));
        // 遍历
        for (String key : t.stringPropertyNames()) {
            System.out.println(key + " = " + t.getProperty(key));
        }
    }
}

(2)可变参数

public class ParamDemo {
    public static void main(String[] args) {
        int[] arr = {21,89,32};
        int sum = add(arr);
        System.out.println(sum);
        sum = add(21, 89, 32);  // 可变参数调用形式(可以传任意多个参数)
        System.out.println(sum);
        
    }

    //JDK1.5之后写法
    public static int add(int...arr){
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }

    //原始写法
    /*
    public static int add(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }
    */
}

(3)Collections介绍

Collections是集合工具类(不能实例化)，用来对集合进行操作。部分方法如下：

// 排序：
// 排序前元素list集合元素 [33,11,77,55]
Collections.sort( list );
// 排序后元素list集合元素 [11,33,55,77]

// 打乱顺序：
// list集合元素 [11,33,55,77]
Collections.shuffle( list );
// 使用shuffle方法后，集合中的元素就会被打乱，每次执行该方法，集合中存储的元素位置都会随机打乱