《Java基础知识》Java集合（Collection）

作为一个Developer，Java集合类是我们在工作中运用最多的、最频繁的类。相比于数组(Array)来说，集合类的长度可变，更加适合于现代开发需求；

Java集合就像一个容器，可以存储任何类型的数据，也可以结合泛型来存储具体的类型对象。在程序运行时，Java集合可以动态的进行扩展，随着元素的增加而扩大。在Java中，集合类通常存在于java.util包中。

Java集合主要由2大体系构成，分别是Collection体系和Map体系，其中Collection和Map分别是2大体系中的顶层接口。

今天主要讲：Collection主要有三个子接口，分别为List(列表)、Set(集)、Queue(队列)。其中，List、Queue中的元素有序可重复，而Set中的元素无序不可重复；

List中主要有ArrayList、LinkedList两个实现类；Set中则是有HashSet实现类；而Queue是在JDK1.5后才出现的新集合，主要以数组和链表两种形式存在。

继承关系图：

常用集合：ArrayList （数组）

特点

• 容量不固定，随着容量的增加而动态扩容（阈值基本不会达到）
• 有序集合（插入的顺序==输出的顺序）
• 插入的元素可以为null
• 效率更高（相对于LinkedList来说）
• 线程不安全

list 常用方法

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

public class var {
    public static void main(String[] args){
        List<String> list = new ArrayList();
        List<String> list1 = new ArrayList();

        //list添加数据
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六");
        System.out.println("add:"+list);

        //list的长度
        System.out.println("size:"+list.size());

        //集合转数组
        Object[] arr = list.toArray();
        System.out.println("toArray:"+arr);

        //判断集合是否为空
        if(!list.isEmpty()){
            System.out.println("集合list 不为空。");
        }

        //判断集合中是否包含某个元素
        if(list.contains("张三")){
            System.out.println("list包含张三。");
        }
        if(list.contains("李三")){
            //
        }else{
            System.out.println("list不包含李三。");
        }

        //复制list
        list1.addAll(list);
        System.out.println("addAll:"+list1);

        //list 删除数据
        list.remove(0); //按照角标删除
        list.remove("王五"); //按照内容删除。
        System.out.println("remove:"+list);

        //获取第2个数据数据
        System.out.println("get:"+list.get(1));

        //清空元素
        list.clear();
        System.out.println("clear:"+list);

        //判断集合是否为空
        if(list.isEmpty()){
            System.out.println("集合list 为空。");
        }
    }
}

运行结果：

list 中还有其他方法，见JDK的API。  补充一种集合新增，修改，删除有锁，查询不加锁CopyOnWriteArrayList，使用的是ReentrantLock锁。

 

常用集合：LinkedList（链表）

特点：插入，删除快。

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

public class var {
    public static void main(String[] agrs){
        List<String> linkedList = new LinkedList<String>();
        System.out.println("LinkedList初始容量："+linkedList.size());

        //添加功能：
        linkedList.add("my");
        linkedList.add("name");
        linkedList.add("is");
        linkedList.add("jiaboyan");
        System.out.println("LinkedList当前容量："+ linkedList.size());

        //修改功能:
        linkedList.set(0,"hello");
        linkedList.set(1,"world");
        System.out.println("LinkedList当前内容："+ linkedList.toString());

        //获取功能：
        String element = linkedList.get(0);
        System.out.println(element);

        //遍历集合：(LinkedList实际的跌倒器是ListItr对象)
        Iterator<String> iterator =  linkedList.iterator();
        while(iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
        }
        //for循环迭代集合：
        for(String str:linkedList){
            System.out.println(str);
        }

        //判断功能：
        boolean isEmpty = linkedList.isEmpty();
        boolean isContains = linkedList.contains("jiaboyan");

        //长度功能：
        int size = linkedList.size();

        //删除功能：
        linkedList.remove(0);
        linkedList.remove("jiaboyan");
        linkedList.clear();
        System.out.println("LinkedList当前容量：" + linkedList.size());
    }
}

运行结果：

 

ArrayList 和 LinkedList 对比

1. 插入数据：差不多，不一定是谁快。

2. 查询数据：ArrayList 效率非常高。

3. 空间利用率 ：LinkedList 高。

 

不常用集合：Vector（队列）

特点：线程安全

import java.util.Arrays;
import java.util.Vector;

public class var {
    public static void main(String[] agrs){
        Vector vector = new Vector();

        //向该集合中添加元素
        vector.add("A");
        vector.add("B");
        vector.add("C");
        System.out.println(vector);

        //向指定的位置添加元素
        vector.add(1,"F");
        vector.add(3,"H");
        System.out.println(vector);

        //删除元素
        vector.remove("H");
        vector.remove(1);
        System.out.println(vector);

        //修改元素
        vector.set(1,"G");
        System.out.println(vector);

        //查询元素
        System.out.println("get: "+vector.get(1));

        //判断当前集合是否为空
        boolean b = vector.isEmpty();
        System.out.println(b);

        //返回集合vector中元素的个数
        int i = vector.size();
        System.out.println("size: "+i);

        //将集合对象转为Object的数组
        Object[] array = vector.toArray();
        System.out.println(Arrays.toString(array));
    }
}

运行结果：

因为vector 线程安全，导致效率低，所以使用较少。

 

不常用集合：Stack (堆栈)

特点：先进后出

import java.util.Stack;

public class var {
    public static void main(String[] agrs){
        Stack stack = new Stack();

        //提供了push,写入元素
        stack.push("A");
        stack.push("B");
        stack.push("C");

        //提供了push,写入一个元素
        stack.push("D");
        System.out.println(stack);

        //pop 拉取一个元素，并移除
        System.out.println(stack.pop());
        System.out.println(stack);

        //拉取一个元素，不移除
        System.out.println(stack.peek());
        System.out.println(stack);

        // 查找search
        System.out.println(stack.search("B"));
    }
}

运行结果：

 

常用集合：HashSet（哈希）

 特点：元素不会重复。

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

public class var {
    public static void main(String[] agrs){
        Set set= new HashSet();
        set.add("1");
        set.add("1");
        set.add("2");
        set.add("3");
        set.add("4");
        set.add("5");
        set.add("5");
        System.out.println(set);
    }
}

运行结果：

 

常用集合：TreeSet（红黑树）

特点：TreeSet是用来排序的, 可以指定一个顺序, 对象存入之后会按照指定的顺序排列

public class Person {

    public String name;    //姓名
    public Integer age;    //年龄

    public Person(String name,Integer age) {
        this.name=name;
        this.age=age;
    }
}

import demo.design.strategy.imp.Person;
import java.util.TreeSet;

public class var {
    public static void main(String[] agrs){
        TreeSet<Person> ts = new TreeSet<>();
        ts.add(new Person("张三", 23));
        ts.add(new Person("李四", 13));
        ts.add(new Person("周七", 13));
        ts.add(new Person("王五", 43));
        ts.add(new Person("赵六", 33));
        System.out.println(ts);
    }
}

运行结果：

 

因为TreeSet需要排序，所以需要指定类的排序逻辑

public class Person implements Comparable<Person>{

    public String name;    //姓名
    public Integer age;    //年龄

    public Person(String name,Integer age) {
        this.name=name;
        this.age=age;
    }

    /**
     * 加上比较方法，让TreeSet 可以根据这个排序
     * @param o
     * @return
     */
    public int compareTo(Person o){
        if(o.age > this.age){
            return 1;
        }else if(o.age > this.age){
            return -1;
        }else {
            return 0;
        }
    }
}

import java.util.Iterator;
import java.util.TreeSet;

public class var {
    public static void main(String[] agrs){
        TreeSet<Person> ts = new TreeSet<>();
        ts.add(new Person("张三", 23));
        ts.add(new Person("李四", 13));
        ts.add(new Person("周七", 13));
        ts.add(new Person("王五", 43));
        ts.add(new Person("赵六", 33));

        //使用迭代方式获取元素
        Iterator<Person> it = ts.iterator();
        while (it.hasNext()){
            Person person= it.next();
            System.out.println("姓名："+person.name+"年龄："+person.age);
        }
    }
}

运行结果：

能够熟料掌握以上集合，在今后的工作中已经够用，需要继续了解，可以阅读JDK API文档。

参考：https://www.jianshu.com/p/63b01b6379fb

           https://www.jianshu.com/p/a2236f562ead

           https://www.cnblogs.com/yzssoft/p/7127894.html