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