java：集合(Collection)和集合的应用方法，List（接口）

什么是集合

简单来讲：集合就是一个放数据的容器，准确的说是放引用数据的容器。

为什么要使用集合框架？

传统的容器(数组)在进行增、删等破坏性操作时，需要移动元素，可能导致性能问题；同时添加、删除等算法和具体业务耦合在一起，增加了程序开发的复杂度。

Java集合框架提供了一套性能优良、使用方便的接口和类，它们位于java.util包中

package cn.collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**Collection是java集合框架(collection-frame)中的顶层接口。
   Collection接口是一个容器，容器中只能存储引用数据类型，建议存同一类型的引用类型，方便后续遍历等操作。
        容器中的元素可以是有序的、可重复的，称为List接口
      也可能是无序的、唯一的，称为Set接口。
 * 
 * 
 *
 */
public class TestCollection {
public static void main(String[] args) {
    /**通过实现类来实现
     * 增:add/addAll
     * 删:clear/remove/removeAll/retainAll
     * 改:
     * 查:contains/containsAll/isEmpty/size
     */
    Collection c1=new ArrayList();//通过ArrayList类(本质上是List接口的实现类)实现Collection接口
    //通过ArrayList类把引用数据追加给Collection容器
    c1.add("apple"); // Object object = new String("apple");
    c1.add("banana");//把引用数据类型加入Collection容器
    System.out.println(c1);//输出结果：[apple, banana]
    
    //基本数据类型通过包装类存入Collection
    // c1.add(1);         // Object object = new Integer(1); 
    
    // 追加一个集合 
    Collection c2 = new ArrayList();
    c2.add("java");//把引用数据类型加入Collection容器
    c2.add("c+");
    c2.add("c");
    c2.add("c++");
    c2.add("a++");
    c2.add("d++");
    c1.addAll(c2);//可以直接把一个集合追加给另一个相同类型的集合
    System.out.println(c1);//输出结果：[apple, banana, java, c+, c, c++, a++, d++]
    
    
    
    
    Collection c3=new ArrayList();
    c3.add("d++");
    c3.add("ff++");
    //删除列表中的所有元素。
    //c1.clear();
    System.out.println(c1);//输出结果：[]
    
    // 删除此列表中首次出现的指定元素（如果存在，从左往右）。
    c2.remove("c++");
    System.out.println(c2);//输出结果：[java, c+, c, a++, d++]
    
    //删除c1中的和c3有同样的元素（删除两个容器中同样的元素）
    c1.removeAll(c3);
    System.out.println(c1);//输出结果：[apple, banana, java, c+, c, c++, a++]
    
    //提取两个容器中相同的元素，然后清空c1，再把相同元素追加给c1
    c1.retainAll(c2);
    System.out.println(c1);//输出结果：[java, c+, c, a++]
    
    
    
    //如果此列表中包含指定的元素，则返回 true。
    System.out.println(c1.contains("apple"));//输出结果：false
    System.out.println(c2);//输出结果：[java, c+, c, a++, d++]
    
    c1.add("d++");
    //c1和c2是否相等
    System.out.println(c1.containsAll(c2));//输出结果：true
    
    //c1是否为空
    //c1.clear();//清空c1//输出结果：true
    
    System.out.println(c1.isEmpty());//输出结果：false
    // 返回集合元素的个数
    System.out.println(c1.size());//输出结果：5
    //c1和c2内元素是否相等
    System.out.println(c1.equals(c2));//输出结果：true
    
    
    

    Collection c4 = new ArrayList();
    c4.add("apple");
    c4.add("banana");
    c4.add("coco");
    
    
    // 快速遍历
    // for-each
    // Object 表示元素类型 
    // object 表示迭代变量（循环输出的变量）
    // c1表示集合
    for (Object object : c4) {
        
        System.out.println(object.toString());//输出结果：apple（循环输出）
                 }                                 //  banana
                                                    // coco
    
    /**Iterator接口：Iterable 可遍历的接口，集合接口继承于它，集合支持快速遍历。
     * 有hasNext方法：如果仍有元素可以迭代，则返回 true。
     *  next()方法:返回迭代的下一个元素。
     *  remove() :  从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。
      */
    // 迭代器遍历（国内）
    /**快速遍历的本质
     * Collection继承Iterable接口，表示集合支持快速遍历。Iterable接口定义了一个方法iterator()用于获取集合的迭代器，
                是一个Iterator接口类型，iterator()内部返回一个实现类实现类Iterator接口。
                这个实现类一定具有hasNext和next方法用于判断是否有下一个元素和获取下一个元素。快速遍历就是基于迭代器工作的。
      
     */
    //Iterator是对 collection 进行迭代的迭代器，蕴含了迭代的能力的接口
    Iterator it = c4.iterator();////iterator是Iterable类的方法，通过方法里的接口Iterator返回在此 collection 的元素上进行迭代的迭代器。
    while(it.hasNext()) {         //是否还有下个元素
    Object item = it.next();       //Object是几乎所有类的父类，所以通过父类引用子类来实现方法
    System.out.println(item.toString());//输出结果：apple（循环输出）
    }                                        //  banana
                                             // coco
            
                                                
    // 国外
    for(Iterator it2=c4.iterator();it2.hasNext();) {
    Object item = it2.next();
    System.out.println(item.toString());
    }
   }
}

package cn.collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**1.3List接口（继承了collection接口）
 List 接口中的元素时有序的、可重复的。List接口中的元素通过索引(index)来确定元素的顺序。
有序的 collection（也称为序列）。可以对列表中每个元素的插入位置进行精确地控制。
用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素
 */
public class ArraysList {
    public static void main(String[] args) {
    /**通过List接口实现类来实现，比collection接口本身使用实现类来实现更完善方法更多
     * 增:add/addAll/add(index,el)/addAll(index,collection)
     * 删:clear/remove/removeAll/remove(index)
     * 改:set(index,el)
     * 查:get(index)/indexOf/lastIndexOf()
     * 其他:contains/containsAll/isEmpty/size
     */
    List list1 = new ArrayList();//接口引用实现类，ArrayList类是collection接口和List接口共有的实现类
    // 添加元素
    list1.add("apple");
    list1.add("banana");
    // 在指定位置添加元素
    list1.add(0, "coco");
    
    System.out.println(list1);//输出结果：[coco, apple, banana]
    
    List list2 = new ArrayList();
    list2.add("java");
    list2.add("c++");
    
    list1.addAll(1, list2); //把list2的元素放在list1的第一个位置
    System.out.println(list1);//输出结果：[coco, java, c++, apple, banana]
    
    // 删除
    //从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。
    list1.remove("coco");
    System.out.println(list1);//输出结果：[java, c++, apple, banana]
    //移除列表中指定位置的元素（可选操作）。
    list1.remove(0);
    System.out.println(list1);//输出结果：[c++, apple, banana]
            
    // 修改:指定元素替换列表中指定位置的元素（可选操作）。
    list1.set(0, "javax");
    System.out.println(list1);//输出结果：[javax, apple, banana]
            
    // 查: 返回列表中指定位置的元素。
    System.out.println(list1.get(0));//输出结果：javax
    list1.add("apple");
    list1.add("apple");
    //List：元素是有序的、可重复的。
    System.out.println(list1);//输出结果：[javax, apple, banana, apple, apple]
    //从左到右返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
    System.out.println(list1.indexOf("apple"));//输出结果：1
    //从右到左返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
    System.out.println(list1.lastIndexOf("apple"));//输出结果：4
    
    /**ListIterator 继承于Iterator，在Iterator的基础上提供了以正向遍历集合，也可以以逆序遍历集合。
       * 所以有hasNext/next 以正向遍历
                     还多了 hasPrevious/previous 以逆序遍历
      */
    
    List list3 = new ArrayList();
    list3.add("apple");
    list3.add("banana");
    list3.add("coco");
    
    
   // 【1】快速遍历
    for (Object item : list3) {
        System.out.println(item.toString());//输出结果：apple  banana   coco   
    }
    
    
    // 【2】普通for（collection接口不行）
    //size()返回列表中的元素数。
    for(int i=0;i<list3.size();i++) {//因为知道元素个数，所以通过循序遍历输出
        System.out.println(list3.get(i));//输出结果：apple  banana   coco 
    }
    
    
    // 【3】集合迭代器
    Iterator it = list3.iterator();
    while(it.hasNext()) {
        System.out.println(it.next());//输出结果：apple  banana   coco 
    }
    
    
    //ListIterator接口是继承了Iterator接口，所以ListIterator接口能力更强大
    // listIterator()返回此列表元素的列表迭代器（按适当顺序）
    //listIterator(int index)  返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。
   // 正向遍历
    ListIterator it2 = list3.listIterator();
    while(it2.hasNext()) {
        System.out.println(it2.next());//输出结果：apple  banana   coco 
    }
    
    // 逆序遍历
    //hasPrevious()逆序输出
    while(it2.hasPrevious()) {
        System.out.println(it2.previous());//输出结果： coco banana  apple
    }
    

    
    ////listIterator(int index)  返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。
    ListIterator it3 = list3.listIterator(1);
    while(it3.hasNext()) {
        System.out.println(it3.next());//输出结果：banana  coco
         }    
    }
}

package cn.collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

/**ArrayList 是List接口的实现类，底层数据结构是数组，实现大小可变的数组。
ArrayList 线程不安全，jdk1.2
ArrayList 底层数据结构是数组，默认数组大小是10,如果添加的元素个数超过默认容量，
ArrayList会自动拓容，拓容原则:newCapacity = oldCapacity + oldCapacity / 2;
如果未来确定序列的元素不在增加，通过调用trimToSize()调制容量至合适的空间。
ArrayList作为List接口的实现类，常用方法和遍历方法参考List接口。
 
 */
public class ArraysList01 {
public static void main(String[] args) {
    ArrayList list1 = new ArrayList();
    list1.add("apple1");
    list1.add("apple2");
    list1.add("apple3");
    list1.add("apple4");
    list1.add("apple5");
    list1.add("apple6");
    list1.add("apple7");
    list1.add("apple8");
    list1.add("apple9");
    list1.add("apple10");
    System.out.println(list1.size());
    //结果输出：10
    
    
    ArrayList list = new ArrayList();
    list.add("apple1");
    list.add("apple2");
    list.add("apple3");
    
    
    for (Object item: list) {
        System.out.println(item);//结果输出：apple1 apple2 apple3
    }
    
    for (int i = 0; i < list.size(); i++) {
        Object item = list.get(i);
        System.out.println(item);//结果输出：apple1 apple2 apple3
    }
    
    Iterator it = list.iterator();
    while(it.hasNext()) {
        System.out.println(it.next());//结果输出：apple1 apple2 apple3
    }
    
    ListIterator it2 = list.listIterator();
    while(it2.hasNext()) {
        System.out.println(it2.next());}//结果输出：apple1 apple2 apple3
}
}

package cn.collection;

import java.util.ListIterator;
import java.util.Vector;

/*Vector 是List接口的实现类，底层数据结构也是数组，也是大小可变的数组。
Vector是线程安全的，jdk1.0
Vector底层数据结构是数组，默认数组大小是10,如果添加的元素个数超过默认容量，Vector会自动拓容，
拓容原则:newCapacity = oldCapacity +capacityIncrement(增长因子);
如果未来确定序列的元素不在增加，通过调用trimToSize()调制容量至合适的空间。
注意:Vector 在实现List接口的同时，同添加了自身特有的方法xxxElement,


未来使用时为了程序的可拓展性，一定要按照接口来操作Vector。*/
public class Vector01 {
public static void main(String[] args) {
    Vector list = new Vector();
    list.add("apple1");
    list.add("apple2");
  System.out.println(list.size());//输出结果：2
  // 返回此向量的当前容量。
  System.out.println(list.capacity());//输出结果：10
    // 返回此向量中第一次出现的指定元素的索引，从 index 处正向搜索，如果未找到该元素，则返回 -1。
  System.out.println(list.indexOf("apple2",1));//输出结果：1
  
  
  //将指定的元素添加在容器末尾，容量加1
  list.addElement("apple3");
  ListIterator it = list.listIterator();
    while(it.hasNext()) {
        System.out.println(it.next());}//结果输出：apple1 apple2 apple3
// vector:特有的方法都加了：Element
  

  
  }
}

package cn.collection;

import java.util.LinkedList;

/*LinkedList是List接口的实现类，底层数据结构是链表。
LinekList常用方法和遍历方法参照List接口。
LinkedList 线程不安全。

除了实现List接口， 还实现栈接口
*/

//push入栈操作  pop出栈操作
public class LinkedList01 {
public static void main(String[] args) {
    //push入栈操作（add/remove/element() 可能会出现NoSuchElementException异常）
    LinkedList list = new LinkedList();
    list.push("apple");
    list.push("banana");
    list.push("coco");
    System.out.println(list.element());//获取表头元素：输出结果：coco（先入的在最底下）
    // pop出栈操作：从此列表所表示的堆栈处弹出一个元素。（先入后出）入口和出口相同
    System.out.println(list.pop());//输出结果：coco
    System.out.println(list.pop());//输出结果：banana
    System.out.println(list.pop());//输出结果：apple
    
    //如果容器内已没有元素，再次 pop出栈操作就会 异常输出
    //System.out.println(list.pop());// 输出结果：java.util.NoSuchElementException（没有元素异常）
    
    
    
    //以队列形式操作LinkedList，（先入后出）一个入口和一个出口（分开来的）
    LinkedList queue = new LinkedList();
    // 入队
    /**
     * 队列头                          队列尾
     *<-----          <-----
     * [apple, banana, coco]
     */
    queue.add("apple");//将指定元素添加到此列表的结尾。
    queue.add("banana");
    queue.add("coco");
    System.out.println(queue);//输出结果：[apple, banana, coco]
        // 获取表头元素
    System.out.println(queue.element());//输出结果：apple
    // 出队，
    System.out.println(queue.remove());//输出结果：apple
    System.out.println(queue.remove());//输出结果：banana
    System.out.println(queue.remove());    //输出结果：coco    
    System.out.println(queue);//输出结果：[]
    //System.out.println(queue.remove());// java.util.NoSuchElementException
    
    
    // 入队（offer/poll/peek 可能会返回特殊值(null)）
            /**先入先出
             * 队列头                          队列尾
             *<-----          <-----
             * [apple, banana, coco]
             */
    LinkedList list1 = new LinkedList();
    list1.offer("apple");
    list1.offer("banana");
    list1.offer("coco");
    System.out.println(list1);//输出结果：[apple, banana, coco]
    System.out.println(list1.peek());//输出结果：apple
     
    
    // 出队列
    System.out.println(list1.poll());//输出结果：apple
    System.out.println(list1.poll());//输出结果：banana
    System.out.println(list1.poll());//输出结果：coco    
     //获取但不移除此列表的头（第一个元素）。
     System.out.println(list1.peek());//输出结果：null（因为已经全部取出了，容器已没有元素）
    
     
     
     LinkedList queue2 = new LinkedList();
    // 入队
    /**头和尾同时输出
     *<-----          <-----
     * [apple, banana, coco]
     * ---->          ----->
     */
    
    queue2.addFirst("apple");
    queue2.addFirst("banana");
    queue2.addFirst("coco");
    System.out.println(queue2);//输出结果：[coco, banana, apple]
    System.out.println(queue2.getFirst());//表头：输出结果：coco
    //先输出尾在输出头最后才输出中间
    System.out.println(queue2.removeLast());//输出结果：apple
    System.out.println(queue2.removeFirst());//输出结果：coco
    System.out.println(queue2.removeFirst());//输出结果：banana
    System.out.println(queue2);//输出结果：[]
    
    // 获取头元素
    System.out.println(queue2.getFirst());//输出结果： java.util.NoSuchElementException

    
    }
}