Java 集合框架初识

为什么要使用集合？

　　在实际开发中经常对一组相同数据类型的元素进行操作，自己实现动态数组、树、链表等结构不太方便，所以Java提供了丰富的集合框架API提升开发者的开发效率。

集合框架简化图：

 

 

 集合中分为三大接口：Iterator、Collection、Map

Collection接口

　　Collection表示一组对象，这些对象成为Collection的元素，JDK不提供Collection接口的具体实现，但提供了其子接口（List、Set）的具体实现。

　　接口定义：public interfaec Collection<E> extends Iterable<E>

List接口：

　　1、有序的，可以重复

　　2、允许多个null元素

　　3、具体的实现类有：ArrayList    Vector    LinkedList

List接口实现类的代码示例

 

package com.collection.list;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;

/*
    在实际开发中怎么选择合适的List?
        1、安全性
        2、是否进行频繁插入、删除操作
        3、是否是存储后遍历
 */
public class ListDemo {
    public static void main(String args[]){
        linkedListTest();

    }

    //在声明 List实例对象时，要是不使用泛型，实例对象可以添加不同类型的元素
    //但是一般不会这样做，我们应该在一个集合中存储相同的数据类型对象
    /*
    ArrayList：
        1、实现原理：采用动态数组方式实现，创建对象时构造函数创建了一个空的对象数组
        2、不适合插入、删除操作
        3、线程不安全，适合在单线程环境下使用
     */
    public static void arrayListTest(){
        List<String> al = new ArrayList<String>();
        al.add("小王");
        al.add("小赖");
        al.add("老朱");
        int size = al.size();
        for (int i=0;i<size;i++)
            System.out.println(al.get(i));
    }


    /*
        Vector：
        1、实现原理：采用动态数组方式实现，创建对象时构造函数创建了一个空的对象数组
        2、不适合插入、删除操作
        3、线程安全，适合在多线程环境使用，效率较低
    */
    public static void VetorTest(){
        List<String> al = new Vector<>();
        al.add("王老师");
        al.add("赖老师");
        al.add("朱老师");
        int size = al.size();
        for (int i=0;i<size;i++)
            System.out.println(al.get(i));
    }

    /*
    LinkedList：
        1、实现原理：双向链表
        2、适合插入、删除操作且此类操作效率高
    */
    public static void linkedListTest(){
        List<String> al = new LinkedList<>();
        al.add("王老师");
        al.add("赖老师");
        al.add("朱老师");
        int size = al.size();
        for (int i=0;i<size;i++)
            System.out.println(al.get(i));
    }
}

 

Set接口：

　　常用实现类： HashSet    TreeSet    HashLinkedSet

示例代码：

package com.collection.set;

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

/*
    Set接口：
        1、无序的（不保证顺序）
        2、无重复元素
        3、最多只有一个null元素
        4、具体实现类：HashSet   TreeSet   LinkedHashSet
 */
public class SetDemo {
    public static void main(String args[]){
//        hashSetTest();
//        treeSetTest();
        hashLinkedSetTest();
    }

    /*
        HashSet:
            1、实现原理：基于哈希表（HashMap）实现
            2、不允许重复，可以有一个null元素
            3、不保证顺序恒久不变
            4、添加元素时把元素作为HashMap的key存储，与此同时HashMap的值是同一个Object对象
            5、判断重复对象是通过equals方法来检查对象是否相同
            6、判断两个对象是否相同，先判断两个对象的hashcode是否相同，如果两个对象的hashcode相同，不一定是同一个对象，如果不同，一定不是同一个对象。
                如果两个对象的hashcode相同，再进行equals判断，若equals判断相同，则是同一个对象，要是不同，则不是同一个对象。
            7、hashset添加自定义对象时，认为属性值相同是同一个对象，有这种需求时，我们需要重写hashcode()和equals()方法

        小结：
            哈希表的结构：数组+链表，数组中的每个元素以链表的形式存储
            哈希表怎么存储一个元素：先计算对象的hashcode值（一个整数），再对数组的长度求余，来决定对象存储在数组的哪个位置
            解决hashset中的重复值参考上述6

     */
    public static void hashSetTest(){
        Set<Cat> hs = new HashSet<>();
        hs.add(new Cat(1,"小白",2));
        hs.add(new Cat(2,"小黑",1));
        hs.add(new Cat(3,"小花",3));
        hs.add(new Cat(4,"小白",2));
        for (Cat s:hs){
            System.out.println(s);
        }
    }

    /*
        TreeSet:
            1、有序。基于TreeMap（二叉树结构）实现，对象需要比较大小，所以被比较的对象需要实现对象比较器
                对象比较器还可以用来去除重复元素，自己自定义的类，没有实现比较器接口，则无法将对象加入到TreeMap当中。
     */
    public static void treeSetTest(){
        Set<Cat> th = new TreeSet<>(new CatComparator ());
        th.add(new Cat(1,"小白",2));
        th.add(new Cat(2,"小黑",1));
        th.add(new Cat(3,"小花",3));
        th.add(new Cat(4,"小白",2));
        for (Cat s:th){
            System.out.println(s);
        }
    }
    /*
        HashLinkedSet：
            1、基于哈希表和链表列表实现
            2、维护着一个记录所有条目的双重链接列表，此链接列表记录着所有迭代顺序，即迭代的时候按照元素插入顺序进行迭代
     */
    public static void hashLinkedSetTest(){
        Set<Cat> lhs = new LinkedHashSet<>();
        lhs.add(new Cat(1,"小白",2));
        lhs.add(new Cat(2,"小黑",1));
        lhs.add(new Cat(3,"小花",3));
        lhs.add(new Cat(4,"小白",2));
        for (Cat s:lhs){
            System.out.println(s);
        }
    }
}