java - 集合 - collection

数组长度固定不能扩展，所以现在一般采用集合

集合分类：（所在包: java.util）

collection   存储的是值  value

map           存储的是键值对 key（无序不重复） - value（无序可重复）

 

collection分类：

list：有序可重复

set：无序不重复

 

list：

ArrayList，Vector，Stack，LinkedList

 

ArrayList：遍历查询速度快

LinkedList：插入删除速度快

 

 ArrayList

package List;

import java.util.ArrayList;

public class ArrayListTest {
    public static void main(String[] args){

        //ArrayList
        ArrayList arrayList1 = new ArrayList();//无参数
        ArrayList arrayList2 = new ArrayList(3);//容量
        arrayList2.add("a");
        arrayList2.add("b");
        arrayList2.add("c");
        ArrayList arrayList3 = new ArrayList(arrayList2);//collection集合,
        ArrayList arrayList4 = new ArrayList<String>(arrayList3);//可以定义arraylist内部元素的类型   -----》 泛型


        //add
        showArray(arrayList4);
        //a b c
        arrayList4.add("d");
        showArray(arrayList4);
        //a b c d
        arrayList4.add(2,"d"); // 在index = 2 的位置插入"d"

        //remove
        showArray(arrayList4);
        //a b d c d
        arrayList4.remove(1);
        showArray(arrayList4);
        //a d c d
        arrayList4.remove("d");  //删除第一个遇到的d
        //如果想删掉一个int类型的数字，需要remove(new Integer(1));,否则删掉的是index = 1 的对象。



        //modify
        showArray(arrayList4);
        //a c d
        arrayList4.set(2,"e");//inde = 2 的位置的元素 设为e （覆盖），会把旧的返回，防止删错或者用来备份


        //check
        showArray(arrayList4);
        //a c e
        System.out.println(arrayList4.get(2)); //取到inde = 2 的位置的元素
        //e

        //size
        System.out.println(arrayList4.size());//list的长度
        //3

        //list可以直接输出,重写了toString
        System.out.println(arrayList4);
        //[a, c, e]


        arrayList4.removeAll(arrayList2); // 删除arrayList4中，arrayList2[a,b,c]含有的元素
        System.out.println(arrayList4);
        //[e]

        arrayList4.add("a");
        arrayList4.addAll(arrayList2); // 把arrayList2[a,b,c]含有的元素添加到arrayList4中,可以重复，直接加在后面
        System.out.println(arrayList4);
        //[e, a, a, b, c]

        arrayList4.retainAll(arrayList2);//求交集，可重复
        System.out.println(arrayList4);
        //[a, a, b, c]

        //删除全部值
        //arrayList4.removeAll(arrayList4);

        System.out.println(arrayList4.contains("a"));//判断是否包含
        //true
        arrayList4.add("a");
        System.out.println(arrayList4.indexOf("a")); //第一个“a”出现的位置
        System.out.println(arrayList4.lastIndexOf("a"));//最后一个“a”出现的位置
        //0
        //4


        String[] sArr = new String[arrayList4.size()];
        arrayList4.toArray(sArr);  //public <T> T[] toArray(T[] a) 返回值是参数，把arrayLst的元素放入参数中传回
        for (String s:sArr) {
            System.out.print(s + " ");
        }
        System.out.println();
        //a a b c a





    }

    private static void showArray(ArrayList arrayList){
        for(Object s:arrayList){
            System.out.print(s.toString() + " ");
        }
        System.out.println();
    }

}

 Vector ArrayList早期版本

安全高（单线程访问），效率低

默认扩容2倍，

ArrayList是1.5倍 capacity=capacity+(capacity>>1) 

 

Stack：

栈：后进先出

package List;

import java.util.Stack;

public class StackTest {
    public static void main(String[] args){
        //Stack继承了Vector，所以Vector的大部分方法都可以使用
        Stack s = new Stack(); //只有这一种构造方法
        //栈因为结构保证先进后出，所以重写和扩展的方法很少
        s.push("a"); //压入栈顶
        s.push("b");
        s.push("c");
        System.out.println(s.pop());//取出栈顶，并返回
        //c
        System.out.println(s.peek());//查看栈顶元素，不删除
        //b
        System.out.println(s);//查看所有元素
        //[a, b]
        System.out.println(s.search("a"));//查看元素位置 返回的是从栈顶开始数的第几个
        //2
        System.out.println(s.indexOf("a"));//本质存储形式还是protected Object[] elementData 逻辑上的栈
        //0
    }
}

 

Queue：

队列：先进先出

常用类： LinkedList

package List;

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

public class QueueTest {
    public static void main(String[] args){
        LinkedList l = new LinkedList();//继承Queue，队列先进先出
        Stack s =new Stack();
        s.push("a");
        s.push("b");
        s.push("c");
        System.out.println(s);
        //[a, b, c]
        l = new LinkedList(s); // LinkedList 构造方法可以传入collect作为参数，Stack，ArrayList都是collection的子类，所以都可以作为参数
        l.add("d");
        l.add("e");
//        l.addFirst("a");插入第一个index = 0的位置上
//        l.addLast("e"); 插入最后一个
        System.out.println(l);
        //[a, b, c, d, e]

        System.out.println(l.remove());//先进先出，所以从index = 0小的开始删，返回删除的对象，不含参数的remove是它特有的,他的父类Vector的remove必须要传递参数index或者element
        //a
        System.out.println(l);
        //[b, c, d, e]

        System.out.println(l.peek());//返回队列第一个值（index = 0），Stack是返回最后一个
        //b

        System.out.println(l.get(1));//返回index = 1,和ArrayList一样
        //c
        //总体来说LinkedList和Stack方法类似，只不过一个满足先进先出，一个满足先进后出

        //性能测试,100万次插入
        LinkedList linkedList = new LinkedList();
        ArrayList arrayList = new ArrayList();

        Long time1 = System.currentTimeMillis();
        for(int i = 0; i < 100000; i++){
            linkedList.addFirst("a");
        }
        Long time2 = System.currentTimeMillis();
        for(int i = 0; i < 100000; i++){
            arrayList.add(0,"a");
        }
        Long time3 = System.currentTimeMillis();

        System.out.println(time2 - time1);
        System.out.println(time3 - time2);
        //7
        //670
        //从前插入明显LinkedList更快，不过如果从末尾插入网上都说LickedList快，但是我测试多次都是ArrayList更快。。。
    }
}