Arraylist 学习笔记

/**
 * 比如collection接口的设计一样，可能会定义一个容器需要的相关方法，但是他在提供一个AbstractCollection的抽象方法，把相关能通用的方法进行封装实现，
 * 后面的容器直接继承AbstractCollection，将需要重写的方法实现，其他abstractCollection实现的方法就不用再次实现：但是注意AbstractCollection的add方法因为考虑到线程安全问题是直接抛出的异常
 *  必须重写的方法，因为在继承的AbstractCollection中，方法是用的Abstract修饰的，没有方法体。
 */

//public class ArrayList_1 {

    /**   ArrayList --extends --- AbstractArrayList： 抽象的类，此类也是实现了Lsit接口，对其中简单的方法进行了实现
     *    ArrayList -- implements -- List: 接口，其实在AbstractArrayList已经实现了该List接口，但是这样再次实现一次的好处在于使用代理模式的时候，
     *    能够直接基于List接口去新建一个代理类，不然是会报错的，详情见：
     *    http://www.cnblogs.com/bluejavababy/p/4320545.html
     *
     *    List -- implements -- collection:
     *    AbstractArrayList -- extends -- AbstractCollections: 所以对于容器的基本实现和方法，在AbstractCollection就已经实现，不用再次编写。
     *
     *    注意：ArrayList是一个线程不安全的类，在实现的时候不能保证其原子性，具体的实现可以通过同步锁（synchronized)或者collections类的方法
     *
     *    假定是自己来对一个动态数组容器ArrayList进行实现：
     *    1、新增（首部、尾部、任意位置）：
     *          public void add(int index, E element) 因为是数组默认数据是插入在数组首部的，尾部就用size - 1来表示;注意插入的元素的类型，特别是字符型和char类型
     *    2、删除（首部、尾部、任意位置）
     *          public boolean remove(int index) ,根据指定位置进行删除
     *          public boolean remove(Object o) ,根据指定值进行删除，删除的时候有多个重复的，则删除第一个
     *    3、修改（任意位置）
     *          public E set(int index), 修改指定位置的值，把修改以前的值返回回来，当下标不存在报错
     *    4、查询（循环）
     *          public E get(int index) , 查询某个ArrayList的下标对应的值
     *    5、复制（复制collection）
     *
     *    6、比较（内容大小）
     *    7、排序
     *         Comparator: public void ArrayList.sort(Comparator<? super E> c): 排序一共有两种方式：
     *         1、自定义一个内部内： Comparator comparator = new Comparator(){
     *             public int compare(Object o1, Object o2) {
     *                 return
     *             }
     *         }
     *         Collections.sort(list, comparator);
     *         2、使用ArrayList.sort()方法：
     *         ArrayList.sort(new Comparator(){
     *             public int compare(Object o1, Object o2) {
     *                 return o1.getAge() - o2.getAge();
     *             }
     *         })
     *    8、查找元素所在位置
     *          public int indexOf(E e);
     *    9、是否包含某个元素
     *          public boolean contains(E e);
     *    10、循环
     *      1、for
     *      2、forEach
     *      3、iterator
     *    对于为什么需要三种遍历方式的理解：
     *        *  1、为什么需要iterator:
     *        *      a: for循环已经能够对集合进行遍历，但是这个遍历的前提是我们不需知道集合里元素的具体细节或者说元素的长度等信息，而iterator就是为了隐藏集合的内部细节，
     *        *      让集合的内容对使用者完全透明
     *        *      b: 在使用for的过程中是可以删除和新增的，但是这会造成list的size变化，很容易造成不必要的bug.
     *        *      c: foeEach其实是对iteartor的一层封装，但是在forEach的循环中是不允许删除和新增元素的。在看是ForEach的时候，就相当于锁住了list的size
     *        *      d：iterator的使用中相当于使用指针
     *           2、对性能的比较暂时没有出结果，可能是自己的比较方式有问题（）
     *
     * @param args
     */
    public static void main(String[] args) {

        List list = new ArrayList();
        {
            //新增
            list.add('a');
            list.add("你");
            list.add('5');
            list.add('5');
            list.add(1, 'd');
            System.out.println("ArrayList--add(int index, E element) :" + list);// ArrayList--add(int index, E element) :[a, d, 你, 5, 5]
        }

        {
            //删除
            Object result = list.remove(new Character('你'));
            System.out.println("public boolean remove(E element) : " + list + "--:" + result);// public boolean remove(E element) : [a, d, 你, 5, 5]--:false
            list.remove(1);
            System.out.println("public boolean remove(int index) : " + list);// public boolean remove(int index) : [a, 你, 5, 5]

        }

        {
            //修改
            Object result = list.set(1, "b");
            System.out.println("public E set(int index) : " + list + "-- result :" + result);// public E set(int index) : [a, b, 5, 5]-- result :你
        }

        {
            //查询
            Object o = list.get(2);
            System.out.println("public E get(int index) : " + o); //public E get(int index) : 5
        }

        {
            //循环
            List list_for = new ArrayList();
            list_for.add(2);
            list_for.add(3);
            list_for.add(4);
            list_for.add(5);
            list_for.add(6);
            System.out.println("list_for----:" + list_for);

            //1、for
            for(int i = 0; i < list_for.size(); i++) {
                System.out.println("-----i：" + list_for.get(i));
            }

            //2、forEach
            for(Object a : list_for) {
                System.out.println("----list_for:" + (Integer)a);
            }

            //3、iterator
            Iterator<Integer> iterator = list_for.iterator();
            while(iterator.hasNext()) {
                Integer a = iterator.next();
                if( a == 2) {
                    iterator.remove();
                }
                System.out.println("list_for---iterator:" + a);
            }
            System.out.println("list_for---iterator的删除以后:" + list_for);
            //list_for---iterator:2
            //list_for---iterator:3
            //list_for---iterator:4
            //list_for---iterator:5
            //list_for---iterator:6

            /**
             * 对于为什么需要三种遍历方式的理解：
             *  1、为什么需要iterator:
             *      a: for循环已经能够对集合进行遍历，但是这个遍历的前提是我们不需知道集合里元素的具体细节或者说元素的长度等信息，而iterator就是为了隐藏集合的内部细节，
             *      让集合的内容对使用者完全透明
             *      b: 在使用for的过程中是可以删除和新增的，但是这会造成list的size变化，很容易造成不必要的bug.
             *      c: foeEach其实是对iteartor的一层封装，但是在forEach的循环中是不允许删除和新增元素的。在看是ForEach的时候，就相当于锁住了list的size
             *      d：iterator的使用中相当于使用指针
             */
            /*list_for.clear();
            for(int i = 0; i < 10000; i++) {
                list_for.add(i);
            }
            //1、for
            Long begin_for = System.currentTimeMillis();
            for(int i = 0; i < list_for.size(); i++) {
            }
            Long end_for = System.currentTimeMillis();
            System.out.println("for 循环 耗时：" + (end_for - begin_for));

            //2、forEach
            Long begin_forEach = System.currentTimeMillis();
            for(Object a : list_for) {
            }
            Long end_forEach = System.currentTimeMillis();
            System.out.println("end_forEach 循环 耗时：" + (end_forEach - begin_forEach));
            //3、iterator
            Long begin_iterator = System.currentTimeMillis();
            Iterator<Integer> iterator1 = list_for.iterator();
            while(iterator1.hasNext()) {
                iterator1.next();
            }
            Long end_iterator = System.currentTimeMillis();
            System.out.println("iterator 循环 耗时：" + (end_iterator - begin_iterator));*/
        }

        {
            //list存储对象的对象属性比较
            User zs = new User("张三", 23);
            User ls = new User("李四", 24);
            User ww = new User("王五", 25);
            List list_user = new ArrayList();
            list_user.add(zs);
            list_user.add(ww);
            list_user.add(ls);
            System.out.println("list--的排序前：" + list_user);

            //1、
          /*  Comparator<User> comparator = new Comparator<User>() {
                @Override
                public int compare(User user1, User user2) {
                        return user1.getAge() - user2.getAge();
                }
            };
            Collections.sort(list_user, comparator);
            System.out.println("list--的排序后：" + list_user);*/
            //2、
            list_user.sort(new Comparator<User>() {
                @Override
                public int compare(User o1, User o2) {
                    return o1.getAge() - o2.getAge();
                }
            });
            System.out.println("list--的排序后：" + list_user);
        }

        {
            //一些查询是否包含的api
            List list_c = new ArrayList();
            list_c.add(1);
            list_c.add(2);
            list_c.add(3);
            list_c.add(4);
            Boolean result = list_c.contains(2);
            System.out.println("---contains:" + result); //---contains:true

            int a = list_c.indexOf(2);
            System.out.println("list_c--indexOf:" + a);// list_c--indexOf:1

        }

    }

//}