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);
        }
    }
}