ArrayListStudy

过完年很久一段时间处于空档期，没有更新博客了，作为一个菜鸟，愈发觉得自己的基本功还是很烂，空余时间自己还是到处找资料，看看基础。集合，作为java开发的重点，不明白其中原理是很难正确的使用，应用场景，数据结构等，于是闲余时间我也到处找资料也跟着看看源码“认真“的学习了一波

这里写代码片
import com.tatelucky.study.model.Car;
import com.tatelucky.study.model.People;

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

/**
 * Create by tate ON 2017/12/21.
 */
public class ArrayListStudy {

    public static int i;
    private int k;

    public static void main(String[] args) {

        List<Car> arrayList = new ArrayList<Car>();
        Car car = new Car(" 奔驰","黑色",50);
        Car car1 = new Car("兰博基尼","黄色",100);

        arrayList.add(car);
        arrayList.add(car1);
        arrayList.add(null);
        System.out.println(arrayList.get(0));

        System.out.println(i+1);


//        Car test = new Car();
//        System.out.println(test.getMoney()+1);  //int类型就没有问题初始化是0

//        People people = new People();
//        System.out.println(people.getAge()+1);//Exception in thread "main" java.lang.NullPointerException  Integer

        //底层是数组，数组是Object对象，所以允许为null
        //数组的初始容量 ：10
        //默认空数组
        //线程不安全
        //数组最大容量：2^31 -8
        //ArrayList基于数组实现，可以通过下标索引直接查找到指定位置的元素，因此查找效率高，
        //         但每次插入或删除元素，就要大量地移动元素，插入删除元素的效率低。
        //在查找给定元素索引值等的方法中，源码都将该元素的值分为null和不为null两种情况处理，ArrayList中允许元素为null
        //扩容：当容量不足以容纳当前的元素个数时，就设置新的容量为旧的容量的1.5倍加1，
        //     如果设置后的新容量还不够，则直接新容量设置为传入的参数（也就是所需的容量），
        //     而后用   Arrays.copyof()     方法将元素拷贝到新的数组，从中可以看出，当容量不够时，
        //     每次增加元素，都要将原来的元素拷贝到一个新的数组中，非常之耗时，
        //     也因此建议在事先能确定元素数量的情况下，才使用ArrayList，否则建议使用LinkedList
        //并发：ArrayList不是线程安全的，只能用在单线程环境下，
        // 多线程环境下可以考虑用Collections.synchronizedList(List l)函数  见SynchronizedListStudy
        // 返回一个线程安全的ArrayList类，
        // 也可以使用concurrent并发包下的   CopyOnWriteArrayList   类（ReentrantLock锁）


        //Arrays.copyof()：
        //        public static <T> T[] copyOf(T[] original, int newLength) {
        //            return (T[]) copyOf(original, newLength, original.getClass());
        //        }
        //        public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        //            T[] copy = ((Object)newType == (Object)Object[].class)
        //                    ? (T[]) new Object[newLength]
        //                    : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        //            System.arraycopy(original, 0, copy, 0,
        //                    Math.min(original.length, newLength));
        //            return copy;
        //        }
        //很明显，在这个copyOf的方法中，实际上是在其内部又创建了一个newLength的数组，再去调用System.arraycopy()，将原来数组中的元素复制到了新的数组中。
        //它可以保证同一个数组内元素的正确复制和移动，比一般的复制方法的实现效率要高很多，很适合用来批量处理数组。
        // Java强烈推荐在复制大量数组元素时用该方法，以取得更高的效率。
        //System.arraycopy():   可以自己复制自己    调用了c语言memmove函数，
        //public static void (Object src,   源数组
        //int srcPos, 源数组要复制的起始位置
        //Object dest,目的数组
        //int destPos,目的数组放置的起始位置
        //int length) 复制的长度


        //遍历时候操作
        List<String> a = new ArrayList<String>();
        a.add("1");
        a.add("2");
//        for (String temp : a) {
//            if("2".equals(temp)){     //异常
//                a.remove(temp);
//            }
//        }
//
//        System.out.println(a);/

        //遍历的时候有增删操作最好是用Iterator，避免出现上述异常
        Iterator<String> it = a.iterator();
        while(it.hasNext()){
            String temp = it.next();
            if("1".equals(temp)){
                it.remove();
            }
        }
        System.out.println(a);
    }
}