Collection接口
--List接口:可重复,有序
----ArrayList类
--Set接口 :不可重复,无序

java.util.ArrayList:实现List接口,采用线性结构进行存储，可变长度的数组.
java.util.Vector:实现List接口,采用线性结构进行存储
ArrayList和Vector的区别:
* ArrayList:非线程安全的,效率较高
* Vector:线程安全,效率较低，如果在多线程程序中推荐使用Vector
不唯一,有序
使用场景:遍历或随机访问时效率较高,添加和删除元素需要大量移动位置，效率较低
常见操作:
添加:
*add(E e):将指定的元素添加到此列表的尾部。
*add(int index, E element):将指定的元素插入此列表中的指定位置。
查询:
*get(int index):返回此列表中指定位置上的元素。
删除:
*remove(int index):移除此列表中指定位置上的元素。
修改:
*set(int index, E element)：用指定的元素替代此列表中指定位置上的元素。
其他:
*size():返回此列表中的元素数。
*isEmpty():如果此列表中没有元素，则返回 true

public class TestArrayList {
　　public static void main(String[] args) {
　　　　List list = new ArrayList();//向上转型
　　　　System.out.println(list.isEmpty());
　　　　list.add(10);
　　　　list.add(13);
　　　　list.add(15);
　　　　list.add(10);
　　　　//    System.out.println(list.size());
　　　　for(int i=0;i<list.size();i++){
　　　　　　System.out.println(list.get(i));//通过下标获取指定位置上的元素
　　　　}
　　　　System.out.println("-------------");
　　　　//移除
　　　　list.remove(1);
　　　　list.add(2, 20);//将指定的元素插入此列表中的指定位置。
　　　　list.set(3, 30);
　　　　for (Object object : list) {
　　　　System.out.println(object);
　　　　}
　　　　System.out.println(list.isEmpty());
　　}
}

 

java.util.Iterator:对 collection 进行迭代的迭代器

　　hasNext(): 如果仍有元素可以迭代，则返回 true。

　　next() : 返回迭代的下一个元素

Collection常用方法:
　　addAll(Collection<? extends E> c):将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
　　iterator():返回在此 collection 的元素上进行迭代的迭代器。
　　clear():移除此 collection 中的所有元素（可选操作）。
　　contains(Object o):如果此 collection 包含指定的元素，则返回 true。

public class TestArrayList2 {
    public static void main(String[] args) {
        List list1 = new ArrayList();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        List list2 = new ArrayList();
        list2.add(4);
        list2.add(5);
        list2.add(6);
        list1.addAll(list2);//将list2中的元素添加到list1集合中
        //1.通过for循环获取元素
        //2.使用for-each获取元素
        //3.使用迭代器获取元素
        Iterator iter =  list1.iterator();//返回在此 collection 的元素上进行迭代的迭代器。
        //判断迭代器中是否存在下一个元素
        while(iter.hasNext()){
            Object obj = iter.next();//获取迭代的下一个元素
            System.out.println(obj);
        }
        System.out.println(list1.contains(2));//判断集合中是否存在指定的元素
        list1.clear();//移除list1中所有的元素
        System.out.println("------------国外习惯的一种写法---------");
        for(Iterator iter2 =  list1.iterator();iter2.hasNext();){
            Object obj = iter2.next();//获取迭代的下一个元素
            System.out.println(obj);
        }
    }
}

 

泛型：

　　语法：List<E> list list=new ArrayList<E>();

　　优点:

　　　　避免获取元素时强制转型
　　　　消除黄色警告.

 

将用户输入的5个整数转换成2进制输出:

public class TestArrayList3 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
//        List list = new ArrayList();
//        list.add("hello");
        List<Integer> list = new ArrayList<Integer>();//list只能保持Integer类型
        for(int i=1;i<=5;i++){
            System.out.println("请输入第"+i+"个整数:");
            int num = input.nextInt();
            list.add(num);
        }
        Iterator<Integer> iter = list.iterator();
        while(iter.hasNext()){
//            Integer obj=(Integer)iter.next();
//            System.out.println(Integer.toBinaryString(obj));
            Integer n = iter.next();//因为使用泛型，不需要强制转换
            System.out.println(Integer.toBinaryString(n));
        }
    }
    
}


List接口继承了Collection接口
LinkedList类:实现了List接口,采用的链表结构进行存储。
　　 使用场景:
　　　　添加删除元素时效率较高,遍历和随机访问时效率较低
　　 特有方法:
　　　　 addFirst(E e) 将指定元素插入此列表的开头。
　　　　addLast(E e) 将指定元素添加到此列表的结尾。
　　　　removeFirst() 移除并返回此列表的第一个元素。
　　　　removeLast() 移除并返回此列表的最后一个元素。
　　　　getFirst() 返回此列表的第一个元素。
　　　　getLast() 返回此列表的最后一个元素。

public class TestLinkedList {
    public static void main(String[] args) {
//        List<String> list = new LinkedList<String>();//向上转型
        LinkedList<String> list = new LinkedList<String>();
        list.add("java");
        list.add("oracle");
        list.add("html");
        list.addFirst("C");
        list.addLast("jsp");
        list.add("mysql");
        list.add("struts2");
        list.removeFirst();
        list.removeLast();
        for (String string : list) {
            System.out.println(string);
        }
        System.out.println("*************");
        System.out.println("第一个元素:"+list.getFirst());
        System.out.println("最后一个元素:"+list.getLast());
    }
}

 

 

 List接口:
　　--ArrayList
　　--LinkedList
　　--Vector
　　　　----Stack
java.util.Stack类:继承Vector类
　　　　push(E item):把项压入堆栈顶部。
　　　　pop() 移除堆栈顶部的对象，并作为此函数的值返回该对象。
　　栈:一种特殊存储结构，满足后进先出的特性，类似于生活中"弹夹"(第一个压进去的最一个弹出)
　　　　先进后出(First In Last Out)-->FILO
　　　　后进先出(Last In Frist Out)-->LIFO *
　　操作:
　　　　压栈:push
　　　　出栈(弹栈):pop

public class MyStack {
    LinkedList list = new LinkedList();
    /**
     * 压栈的操作
     */
    public void push(Object obj){
//        list.addLast(obj);
        list.addFirst(obj);
    }
    
    /**
     * 出栈的操作
     * @return:返回并移除栈顶的元素
     */
    public Object pop(){
//        Object obj= = list.removeLast();
        Object obj =list.removeFirst();
        return obj;
    }
    
    public static void main(String[] args) {
//        Stack<String> stack = new Stack<String>();
//        stack.push("java");
//        stack.push("oracle");
//        stack.push("html");
//        for (int i = 0; i < 3; i++) {
//            String el=stack.pop();
//            System.out.println(el);
//        }
        MyStack stack = new MyStack();
        stack.push("java");
        stack.push("oracle");
        stack.push("html");
        for (int i = 0; i < 3; i++) {
            Object obj=stack.pop();
            System.out.println(obj);
        }
    }
}