Java集合之ArrayList常見操做，實例說明

一.定義
集合(Collection)是Java存儲對象常見的一種方式；集合中的各個對象最終存儲在相似數組[]中。那麼，爲何有了數組還要用集合呢？由於，集合中的長度可變，因此不用一開始就定義其長度(數組在定義時必需要定義其長度），數組中能夠存儲基本數據類型，而集合中能夠存儲任意的對象。
Java集合(collection)包含List和Set;本章先講List集合
二.List分類
List常見的又可包含:ArrayList，LinkedList，Vecor;
ArrayList是可變長度數組，它的初始默認長度是10，當添加的元素長度超過10時，它會新產生一個數組，長度按50%的增幅增長，產生新數組後會將以前的數據拷貝到新數組中，後續元素將繼續添加。

三.List常見的操做
下面以ArrayList來說解List常見的操做方法。

• List屬於集合中的一種，它的長度是可變的，值也是可變的，內容能夠爲任意的對象

  • List結果是一個相似數組的格式，也可看作相似pyhotn中的list
  • List是有序的，它的值能夠重複，因此它可使用索引來進行操做
  • 而Set是無序的，因此它的值不能重複

  List中的方法
  產生Arraylist對象
  ArrayList arraylist = new ArrayList();
  1.增
  arraylist.add()默認在最後位置添加
  arraylist.add(int index,Object obj)在指定位置添加
  2.刪
  arraylist.remove(int index) 按索引進行移除
  arraylist.remove(Object)按照值對象進行移除,如有多個相同的對象則按前後順序刪除第一個
  3.改
  arraylist.set(int index,Object obj) 按照指定索引對其值進行設置
  4.查
  arraylist.get(int index) 按索引獲取對應的值
  arraylist.index(Object obj) 按照具體對象獲取對應的索引值，若有相同對象則獲取第一個角標
  arraylist.lastindex(Object obj) 按照具體對象獲取對應的最後一個索引值(逆向安排)
  5.遍歷List
  5.1 使用for循環
  for(int i=0;i<arraylist.size();i++){
  System.out.println(arraylist1.get(i));
  }
  5.2 使用迭代器Iterator
  Iterator it = arraylist.iterator();
  5.2.1方法1s使用for循環
  for(;it.hasNext();){
  System.out.println(it.next());
  }

  5.2.2方法2使用while循環
  while(it.hasNext()){
  System.out.println(it.next());
  }
  7.判斷
  
  8.List特有的迭代器ListIterator

  1. • 列表迭代器是List專有的
  2. • 咱們平時在對List進行遍歷時，使用Iterator時，只能進行hasNext(）、Next、remove操做，可是每每咱們在遍歷時還須要對遍歷的對象進行增刪改查等操做，此時Iterator再也不符合需求，此時你可能想到在遍歷時直接操做集合(List)，可是Java此時會報ConcurrentModificationExceptiony異常(以下圖)，也就是說咱們在對集合使用Iterator時，不能再對原有的集合進行操做。
       
       緣由:能夠這樣思考:Iterator是對原有的集合(例如:List)進行做用產生一個新Iterator的對象，若是在操做Iteartor時再對原集合進行增、改操做時，現有的Iterator所對應的原有的集合已經發生改變了，Java會拋異常。
       爲了解決該問題，List提供了特有的ListIterator列表迭代器,它能夠在遍歷的時候對ListIterator和原有集合進行操做。以下圖:
       
       運行結果以下圖:
       

9.部分示例代碼以下

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class ListTest {
    public static void main(String[] args){
        /*ArrayList al1 = new ArrayList();
        ArrayList al2 = new ArrayList();
        al1.add("i");
        al1.add("want");
        al1.add("a");
        al1.add("dream");
        al2.add("what");
        al2.add("is");
        al2.add("your");
        al2.add("dream");
        System.out.println("al1="+al1);
        System.out.println("al2="+al2);
        //判斷arraylist是否含有某個元素或集合
        boolean b1 = al1.contains("want");
        boolean b2 = al1.contains("go");
        boolean b3 = al1.containsAll(al2);
        System.out.println("b1="+b1+";b2="+b2+";b3="+b3);
        //判斷兩個arraylist是否相等
        boolean b4 = al1.equals(al2);
        System.out.println("b4="+b4);
        //判斷arraylist是否爲空
        boolean b6 = al1.isEmpty();
        System.out.println("b6="+b6);*/

        //產生ArrayList對象
        ArrayList arraylist1 = new ArrayList();
        //增長元素
        arraylist1.add("you");
        arraylist1.add(0,"What");
        System.out.println(arraylist1);
        //判斷元素是否在該arrylist中
        boolean b1 = arraylist1.contains("You");
        System.out.println(b1);
        //增長元素
        arraylist1.add("you");
        arraylist1.add(2,"and");
        System.out.println(arraylist1);
        //經過索引(下標)來直接獲取對應的元素，超過則提示角標越界異常
        System.out.println(arraylist1.get(1));
        //刪除(移除元素)
        arraylist1.remove("and");
        arraylist1.remove(1);//可能發生角標越界異常
        //經過角標更改元素值,可能發生角標越界異常
        arraylist1.set(1,"who");
        System.out.println(arraylist1);
        //經過對象的方式移除arraylist中的某個元素
        arraylist1.remove("you");
        //獲取對應元素的角標，按照具體對象獲取對應的索引值，若有相同對象則獲取第一個角標
        int a1 = arraylist1.indexOf("What");
        int a2 = arraylist1.indexOf("do");
        System.out.println("a1="+a1);
        System.out.println("a2="+a2);
        //遍歷arraylist中的元素,使用for循環的方式
        for(int i =0;i<arraylist1.size();i++){
            System.out.println(arraylist1.get(i));
        }
        //遍歷使用迭代器的for循環方式,建議使用該方式
        Iterator it1 = arraylist1.iterator();
        for(;it1.hasNext();){
            System.out.println(it1.next());
        }
        //遍歷使用迭代器的while循環方式
        while(it1.hasNext()){
            System.out.println(it1.next());
        }

        arraylist1.add("and");
        arraylist1.add("me");
        String array1[] ={"i","want","to","do"};
        arraylist1.add(array1);
        System.out.println("--------"+arraylist1);
        //經過角標獲取字列表(含頭不含尾)
        List sublist1 = arraylist1.subList(1, 3);
        System.out.println("sublist1="+sublist1);
        /**
         * ListIterator列表迭代器
         * 列表迭代器是List專有的
         * 咱們平時在對List進行遍歷時，使用Iterator時，只能進行hasNext(）、Next、remove操做，
         *      可是每每咱們在遍歷時還須要對遍歷的對象進行增刪改查等操做，此時Iterator再也不符合需求，此時你可能想到在遍歷時直接操做集合(List)
         *      ，可是Java此時會報ConcurrentModificationExceptiony異常(以下圖)，也就是說咱們在對集合使用Iterator時，不能再對原有的集合進行操做。
         *      緣由:能夠這樣思考:Iterator是對原有的集合(例如:List)進行做用產生一個新的Iterator的對象，若是在操做Iteartor時再對原集合進行增、改操做時，
         *      現有的Iterator所對應的原有的集合已經發生改變了，Java會拋異常。
         *      爲了解決該問題，List提供了特有的ListIterator列表迭代器,它能夠在遍歷的時候對ListIterator和原有集合進行操做。
         */
       /* while(it1.hasNext()){
            if(it1.next()=="What"){
                arraylist1.add("add");
            }
        }*/
        System.out.println("原來的arraylist="+arraylist1);
        ListIterator listIt = arraylist1.listIterator();
        for(;listIt.hasNext();){
            Object obj = listIt.next();
            System.out.println(obj);
            if(obj=="who"){
                //使用listIterator對原集合進行增長操做，新添加的元素不在遍歷的範圍內
                listIt.add("Iterator");
            }
            else if(obj=="me"){
                //使用listIterator對原集合進行修改操做
                listIt.set("ME");
            }
            else if(obj=="and"){
                //使用listIterator對原集合進行刪除操做
                listIt.remove();
            }
        }
        System.out.println("如今的arraylist="+arraylist1);
        System.out.println(arraylist1.equals(listIt));
    }
}