Java ArraysList

Java ArraysList

测试

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

public class testArrayList {
	public static void main(String[] args) {
		//创建集合对象，接口new实现类
		List list=new ArrayList();
		//1  add
		list.add("hello");
		list.add(123);//自动装箱
		list.add(new Scanner(System.in));
		//2   集合中元素个数
		System.out.println(list.size());
		System.out.println("是否为空"+list.isEmpty());
		//3  addAll
		List list2=new ArrayList();
		list2.add("hello");
		list2.add(123);
		list.addAll(list2);
		System.out.println("list集合中的元素个数"+list.size());
		//4    删除
		System.out.println("根据对象去删除");
		list.remove("hello");
		System.out.println(list);
//		list.remove(123);//认为123是索引
		list.remove(new Integer(123));
		System.out.println(list);
		list.remove(0);//根据索引去删除
		System.out.println(list);
		list.add("world");
	//	list.removeAll(list2);
		list.retainAll(list2);//将两个集合交叉的元素留下，不同的删除
		System.out.println(list);
		//5  判断
		System.out.println("hello是否存在"+list.contains("hello"));
		System.out.println("java在集合中是否存在"+list.contains("java"));
		//6 清空集合中所以元素对象
		System.out.println(list);
		System.out.println(list2);
		System.out.println(list.containsAll(list2));
	//	list.clear();
	//	System.out.println(list);
		
		//7 获取指定索引位置
		System.out.println(list.get(1));
		//8 设置
		list.set(1,"java");
		System.out.println(list);
		//9 在指定的索引位置上添加元素对象
		list.add(1,"htnl");
		System.out.println(list);
		//10  查找元素在集合中的元素
		System.out.println(list.indexOf("java")+"\t"+list.indexOf("aql"));
		//11 遍历集合中元素的内容
//            （1)使用加强for遍历集合元素
		System.out.println("使用for遍历集合元素");
			for(Object obj:list) {
				System.out.println(obj);
			}
//		      (2)使用普通for遍历集合元素
			System.out.println("使用for遍历集合元素");

			for(int i=0;i<list.size();i++) {
				System.out.println(list.get(i));
			}
//			 (3)使用迭代器
			System.out.println("使用迭代器遍历集合");
		Iterator lie=list.iterator();  //只能正向遍历
			while(lie.hasNext()) {
				Object obj=lie.next();
				System.out.println(obj);
			}
			
			
			System.out.println("使用listIterator()遍历");
			ListIterator listIte=list.listIterator();
			System.out.println("正向遍历");
			System.out.println("在集合的开头，后面还有元素吗"+listIte.hasNext());
			System.out.println("在集合开头，前面有元素对象吗"+listIte.hasPrevious());
			while (listIte.hasNext()) {
				System.out.println(listIte.next());
			}
			
			
			System.out.println("逆向遍历");
			System.out.println("到达集合的末尾，后面还有元素吗"+listIte.hasNext());
			System.out.println("到达集合末尾，前面有元素对象吗"+listIte.hasPrevious());
			while(listIte.hasPrevious()) {
				System.out.println(listIte.previous());
			}	
	}
}

源码分析

import java.util.ArrayList;
import java.util.Arrays;

public class testArrayList1 {
	/*ArraysList源码分析
	 * (1)无参构造方法
	 * 	this.elementDate 是一个Object类型数组
	 * 	DEFAULTCAPACITY_EMPTY_ELEMENTDATA;也是一个Object类型数组
	 * 	DEFAULTCAPACITY_EMPTY_ELEMENTDATA={};默认长度为0
	 * 		public ArrayList(){
	 * 			this.elementData=DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
	 * }
	 *  (2)带参构造
	 *   public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }	
    	(3)添加方法add
    	public boolean add(E e) {
        	modCount++;
        	//检测空间容量是否够用
        	//添加元素            add(e, elementData, size);
        		return true;
    	}
    	(4)检测空间容量是否够用
    	calculateCapacity(elementData,minCapacity)
    	//calculateCapacity方法定义
    	public void ensureCapacity(int minCapacity) {
    	//以下代码相当于额elementData={}
        if (minCapacity > elementData.length
            && !(elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
                 && minCapacity <= DEFAULT_CAPACITY)) {
                 //Math.max(10,1);
            modCount++;
            grow(minCapacity);
        }
        
    }//容量计算完毕后执行ensureExplicitCapacity方法    ensureExplicitCapacity(10)
		ensureExplicitCapacity方法的定义
		(5)扩充容量
		 private Object[] grow(int minCapacity) {
        return elementData = Arrays.copyOf(elementData,newCapacity(minCapacity));//数组拷贝
    }	
	 */
	public static void main(String[] args) {
		ArrayList list=new ArrayList();
		//第一次调用添加方法
		list.add("hello");
		Object [] obj= {};
		//
		Object ensureExplicitCapacity;
	//	ensureExplicitCapacity//缺少
	}	
}

import java.util.ArrayList;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Objects;

public class testArrayList2 {
	//(1)add(int index, E element)  在指定位置加元素
	/*
	 * public void add(int index, E element) {
        System.arraycopy(elementData, index, elementData, index + 1,s - index);
        	//size-index 拷贝的元素个数
        elementData[index] = element;//将元素添加到索引为index的位置上
        size = s + 1;  //元素个数+1
       (2)get(index )根据索引获取元素对象
        public E get(int index) {
        return elementData(index);  //调用了elementData
    } 
    //elementData方法的定义
       E elementData(int index) {
        return (E) elementData[index];
    } 
      (3)size  
      public int size() {
        return size;       //用于记录集合中的元素个数
    }
    (4)isEmpty()
     public boolean isEmpty() {
        return size == 0; //集合中一个元素都没有的时候，集合就是空的
    }
     (5)set(int index,E element)
     public E set(int index, E element) {
        E oldValue = elementData(index);   //根据索引在数组中获取元素
        elementData[index] = element;    //将新元素设置到数组中索引为index的位置上
        return oldValue;
    }
     (6)remove(int index)
         public E remove(int index) {
         E oldValue=elementData(index);//根据索引获取原始元素对象
         int numMoved=size-index-1;//拷贝的元素个数
        if(numMoved>0)
        	System.arraycopy(elementData,index+1,elementData,index,numMoved);
        elementData[--size]=null;  //将最后一个位置设置为null

        return oldValue;  //返回原始元素对象
    }
     (7)clear()
      public void clear() {
        modCount++;
        final Object[] es = elementData;
        for (int to = size, i = size = 0; i < to; i++)
            es[i] = null;
    }
	(8)iterator迭代器
        private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        // prevent creating a synthetic constructor
        Itr() {}

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            Object[] elementData = ArrayList.this.elementData;
            return (E) elementData[lastRet = i];
        }
    }*/
}