您现在的位置是:首页 > 正文

Arraylist 学习笔记

2024-04-01 00:41:36阅读 1


/**
 * 比如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

        }

    }

//}

网站文章

  • linux saslauth用户,Linux中Postfix邮件认证配置(五)

    linux saslauth用户,Linux中Postfix邮件认证配置(五)

    原标题:Linux中Postfix邮件认证配置(五) Postfix+Dovecot+Sasl工作原理1.A用户使用MUA客户端借助smtp协议登陆smtpd服务器,需要先进行用户和密码认证,而SMT...

    2024-04-01 00:41:07
  • python基础学习(数据类型转换)

    python基础学习(数据类型转换)

    基础入门:python数据类型转换。

    2024-04-01 00:40:59
  • RFID汽车制造工业系统解决方案

    RFID汽车制造工业系统解决方案

    汽车使用寿命很长,因为不少车企为了更好的服务终端客户,也逐渐建立起跟踪车辆供应链全过程的系统,对车辆的生命周期进行管理。在第一阶段通过重复使用的标签在装配车间来监控车辆,到第二阶段,他们使用了可以抛弃...

    2024-04-01 00:40:53
  • Neurocomputing投稿记录

    Neurocomputing投稿记录

    Neurocomputing投稿记录

    2024-04-01 00:40:47
  • 怎么看android底层源码,从底层源码分析Android事件传递机制

    怎么看android底层源码,从底层源码分析Android事件传递机制

    点击一下告诉你什么是事件分发,知其然知其所以然,所以这边我篇我们就对源码展开分析!我们知道事件都是由Activity往下面分发的!但是Activity.dispatchTouchEvent()又是从被...

    2024-04-01 00:40:20
  • 哔咔漫画怎样切换横屏?

    小编建议大家,可以在官网picacr.com下载最新版

    2024-04-01 00:40:11
  • 每周七问(第三十五期):精通区块链之散列函数

    每周七问(第三十五期):精通区块链之散列函数

    每周七问:《每周七问》是由毛球科技集团打造的业内首个讲解区块链行业的知识科普类海报系列。我们将抽象的区块链行业内每一个概念转化为轻松易懂的小图片,每张图都能学懂一个知识点。本期,我们将为您带来主题为“...

    2024-04-01 00:40:04
  • 【JVM系列】5、Jvm垃圾回收器(算法篇)

    【JVM系列】5、Jvm垃圾回收器(算法篇)

    在《【JVM系列】4、Jvm垃圾回收器(基础篇)》中我们主要学习了判断对象是否存活还是死亡?两种基础的垃圾回收算法:引用计数法、可达性分析算法。以及Java引用的4种分类:强引用、软引用、弱引用、虚引用。和方法区的回收介绍。那么接下来我们重点研究下虚拟机的几种常见的垃圾回收算法:标记-清除算法、复制算法、标记-整理算法、分代收集算法。一:标记-清除算法  最基础的收集算法,总共分为‘ ...

    2024-04-01 00:39:40
  • CSS学习(三)—— 浮动与定位

    六、浮动与定位 1、浮动 1)浮动基本概念 浮动最本质的功能:用来实现并排 浮动使用要点:如若要浮动,并排的盒子都要设置浮动;父盒子要有足够宽度,否则盒子会掉下去 浮动的顺序贴靠特性:子盒子会按照顺序...

    2024-04-01 00:39:33
  • Map和Set常用的方法

    Set数据类型:Set和Map类似,也是一组key的集合,但不S存储value。由于key不能重复,所以在Set中,没有重复的key。Map数据类型:Map和Object有点类似,都是键值对来存储数据,和Object不同的是,javaScript支持的所有类型都可以当作Map的key。.........

    2024-04-01 00:39:27