java常用集合框架

---

前言

java中常用的数据结构

一.java集合框架图

注：图片来源于菜鸟教程

二.List

1.list接口

1.List 接口
List接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中位置，类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。

List 接口存储一组不唯一，有序（插入顺序）的对象。

1.源码

 public interface List<E> extends Collection<E> {
    int size();
    boolean isEmpty();
       boolean contains(Object o);
       Iterator<E> iterator();
       Object[] toArray();
}

说明：从源码中可以看出List继承了Collection接口

2. ArrayList

ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。

ArrayList 继承了 AbstractList ，并实现了 List 接口。

下面展示简单的实现。

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

public class test {
    public static void main(String[] args){
//        定义list1,list2
        ArrayList<String> list1=new ArrayList<String>();
        ArrayList<String> list2=new ArrayList<String>();
//        存放数据
        list1.add("java基础");
        list1.add("javaWeb");
        list1.add("SSH");

        list2.add("小明");
        list2.add("小丽");
        System.out.println(list2);
//        判断list1中是否包含list2
        int flag=0;
        for (String i : list2) {
            if (list1.contains(i)){
                System.out.println("list1中有包含list2中的"+i);
                flag=1;
            }

        }
//        判断有没有包含
        if (flag==0){
            System.out.println("list1中没有包含list2");
        }




    }
}

3.LinkedList

1.结构图

Java中LinkedList是一个双向链表结构，简单画了一个图

2.代码实现

下面展示一些简单的实现，和常用的方法。

import java.util.Iterator;
import java.util.LinkedList;

public class Link_List {
    public static void main(String[] args) {
//        创建一个链表
        LinkedList<String> list = new LinkedList<String>();
//        添加节点
        list.add("123");
        list.add("124");
        list.add("125");
//        头插一个节点
        list.addFirst("first");
//        尾插一个节点
        list.addLast("last");
//        删除，对于控值默认删除第一个
        list.remove();
//        通过值来删除
        list.remove("123");
//        通过索引来删除
        list.remove(1);

//        查找
        list.contains("last");
        list.indexOf("last");
//        增加的节点可以为空
        list.addLast(null);


//        修改
        list.set(2, "set");


//        循环for
        for (int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        
        
//        循环 iterator
        Iterator<String> it=list.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
        
//        循环 foreach
        for (String n:list) {
            System.out.println(n);
        }

//        循环 forEach
        list.forEach((e)->{
            System.out.println(e);
        });
    }
}

3.基本属性

1.以下情况使用 ArrayList :
频繁访问列表中的某一个元素。
只需要在列表末尾进行添加和删除元素操作。

2 以下情况使用 LinkedList :
你需要通过循环迭代来访问列表中的某些元素。
需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。
LinkedList 继承了 AbstractSequentialList 类。
LinkedList 实现了 Queue 接口，可作为队列使用。
LinkedList 实现了 List 接口，可进行列表的相关操作。
LinkedList 实现了 Deque 接口，可作为队列使用。
LinkedList 实现了 Cloneable 接口，可实现克隆。
LinkedList 实现了 java.io.Serializable 接口，即可支持序列化，能通过序列化去传输。

为什么ArrayList随机访问比LinkedList快?

LinkedList要遍历找到该位置才能进行修改，而ArrayList是内部数组操作会更快。

2. vector

vector 和ArrayList基本一样,但需要注意的一点是， vector是线程安全的，synchronized修饰的操作方法。

二.Set

1. hashSet

HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。

HashSet 允许有 null 值。

HashSet 是无序的，即不会记录插入的顺序。

HashSet 不是线程安全的， 如果多个线程尝试同时修改 HashSet，则最终结果是不确定的。 您必须在多线程访问时显式同步对 HashSet 的并发访问。

HashSet 实现了 Set 接口。

下面展示代码。

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

public class set {
    public static void main(String[] args) {
        HashSet hash=new HashSet();
        hash.add("a");
        hash.add("c");
        hash.add("d");
        hash.add("e");
        hash.add("f");
        hash.add("q");
//      hashSet 循环  hashTree 循环 输出，有序输出
        Iterator<String > it=hash.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }


//        删除
        hash.remove("a");
//        修改
//        查找
        hash.contains("c");
//        循环for(;;)不能够使用。没有下标

//             循环 iterator
        Iterator<String> it_hash=hash.iterator();
        while(it_hash.hasNext()) {
            System.out.println(it_hash.next());
        }

        //        循环 foreach
        for (Object n:hash) {
            System.out.println(n);
        }

        //        循环 forEach
        hash.forEach((e)->{
            System.out.println(e);
        });

    }

}

2 .TreeSet

TreeSet底层是TreepMap
未完，待续…