[Js-Java SE]集合类

主要集合概述：

• List：是一个有序集合，可以放重复的数据
• Set：是一个无序集合，不允许放重复的数据
• Map：是一个无序集合，集合中包含一个键对象，一个值对象，键对象不允许重复 ，值对象可以重复（身份证号—姓名）

 Collection 详解：

注意：

Collection 是java.until下的接口，是各种集合结构的父接口，

Collections 是java.until下的类，包含各种有关集合操作的镜头方法

Collection 以及几个重要实现类和接口的继承关系图：

注：

Collection 只能存储引用数据类型，并且是单个存储

ArrayList 底层所采用的是数组存储元素，所以 ArrayList 集合适合查询，不适合频繁地随机增删元素

LinkedList 底层采用的是双层链表存储数据，链表适合频繁地增删元素，不适合查询操作

Vector 的底层实现和ArrayList集合相同，但是 Vector 是线程安全的，效率较低，所以使用较少（所以图中显示为灰色）

HashSet 的底层实现是一个哈希表/散列表

 

关于 ArrayList 的练习：

package com.neu.core;

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

public class ArrayListTest {
    public static void main(String[] args) {
        Collection<Integer> a = new ArrayList<>();

        // 添加对象
        a.add(1);// 自动装箱
        a.add(2);
        a.add(3);

        // 1.父类或者接口是否可以调用子类或实现类的独有方法？
        // 错误的写法，c为一个Collection对象，不存在set方法
        // c.set(0, 4);
        // 正确的写法s
        ArrayList<Integer> al = (ArrayList<Integer>) a;
        al.set(0, 4);

        // 2.插入类型不同的对象会发生什么？
        // 会在强制类型转换的时候发生ClassCastException
        // al.add("qwer");

        // 3.输出对象的方式?
        System.out.println("======foreach循环======");
        for (Integer integer : a) {
            System.out.println(integer);
        }
        System.out.println("======for循环======");
        for (int i = 0; i < al.size(); i++) {
            // 将 Object 强制转换为 Integer
            Integer e = (Integer) al.get(i);
            System.out.println(e);
        }
        System.out.println("======while+迭代器======");
        Iterator<Integer> it = al.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        System.out.println("======while+for循环======");
        for (it = al.iterator(); it.hasNext();) {
            System.out.println((Integer) it.next());
        }
        // Iterator使用完不能再使用，只能返回一个新的迭代器

        // 4.删除集合中的元素?
        // al.remove(2);
        // System.out.println("============");
        // for (Integer integer : al) {// al变成[4,2]
        // System.out.println(integer);
        // }
        al.remove(new Integer(2));
        System.out.println("============");
        for (Integer integer : al) {// al变成[4,3]
            System.out.println(integer);
        }
        // 以上两种方式不一样，第一种传入的是下标，第二种传入的是对象引用

        // 5.判断是否含某个对象
        System.out.println("============");
        System.out.println(al.contains(3));

        // 6.判断是否为空
        System.out.println("============");
        System.out.println(al.isEmpty());

        // 7.转换为对象数组
        System.out.println("============");
        Object[] oArray1 = al.toArray();
        for (int i = 0; i < oArray1.length; i++) {
            Integer v = (Integer) oArray1[i];
            System.out.println(v);
        }
        System.out.println("============");
        Integer[] iArray = new Integer[al.size()];
        al.toArray(iArray);
        for (int i = 0; i < iArray.length; i++) {
            int v = iArray[i];
            System.out.println(v);
        }

    }
}

 

LinkedList 的用法与 ArrayList 类似，就不再写例子了

 

哈希表简单解释：哈希表是一种数据结构，哈希表能够提供快速存取操作。哈希表是基于数组的，所以也存在缺点，数组一旦创建将不能扩展。正常的数组，如果需要查询某个值，需要对数组进行遍历，只是一种线性查找，查找的速度比较慢。如果数组中的元素值和下标能够存在明确的对应关系，那么通过数组元素的值就可以换算出数据元素的下标，通过下标就可以快数定位数组元素，这样的数组就是哈希表 。

一张哈希表：
元素值 10 11 12 13 14 15 16 17 18
元素下标 0 1 2 3 4 5 6 7 8
以上我们的示例元素值和下标的关系为：
元素下标=元素值-10，此时的示例 hashcode就是和数组下标一致了,取得 hashcode 方法如下：

//取得 hashCode
pubic int hashCode(int value) {
return value – 10;
}

 

有了 hashCode 后，我们就可以快速的定位相应的元素，查找到相应的信息

由此算法衍生出 HashSet ，HashSet 中的数据是无序的不可重复的。HashSet 按照哈希算法存取数据的，具有非常好性能，它的工作原理是这样的，当向 HashSet 中插入数据的时候，他会调用对象的 hashCode得到该对象的哈希码，然后根据哈希码计算出该对象插入到集合中的位置。

 关于 HashSet 的练习

package com.neu.core;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class HashSetTest {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        // 无序且不重复
        set.add("a");
        set.add("b");
        set.add("c");
        // 输出无序
        for (Iterator<String> it = set.iterator(); it.hasNext();) {
            System.out.println(it.next());
        }
        // 加入重复数据
        set.add("a");
        for (Iterator<String> it = set.iterator(); it.hasNext();) {
            System.out.println(it.next());
        }

        String s1 = new String("abc");
        String s2 = new String("abc");

        System.out.println(s1.equals(s2));
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());

        String s3 = new String("ghj");
        System.out.println(s1.equals(s3));
        System.out.println(s3.hashCode());

    }
}