• Day16_ArrayList的使用


    ArrayList的使用

    • 迭代器:专门用来遍历集合一种方式

      • hasNext();有下一个元素吗?如果有怎返回true,否则false
      • next();获取下一个元素
      • remove();删除元素
    • List接口的特点:有序有下标,可以重复

    • List常见实现类

      • ArrayList:

        源码分析:默认容量DEFAULT_CAPACITY = 10

        ​ 注意:如果没有向几个中添加任何元素时,容量0,添加任何一个数据之后,容量是10

        ​ 每次扩容原来的1,5倍

        elementDate存放元素数组

        size 实际元素个数

        public boolean add(E e) {
            ensureCapacityInternal(size + 1);  // Increments modCount!!
            elementData[size++] = e;
            return true;
        }
        
        private void ensureCapacityInternal(int minCapacity) {
            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
                    minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
            }
            ensureExplicitCapacity(minCapacity);
        }
        
        private void ensureExplicitCapacity(int minCapacity) {
            modCount++;
        
            // overflow-conscious code
            if (minCapacity - elementData.length > 0)
                grow(minCapacity);
        }
        
        private void grow(int minCapacity) {
            // overflow-conscious code
            int oldCapacity = elementData.length;
            int newCapacity = oldCapacity + (oldCapacity >> 1);
            if (newCapacity - minCapacity < 0)
                newCapacity = minCapacity;
            if (newCapacity - MAX_ARRAY_SIZE > 0)
                newCapacity = hugeCapacity(minCapacity);
            // minCapacity is usually close to size, so this is a win:
            elementData = Arrays.copyOf(elementData, newCapacity);
        }
        
      • Vector:

        • 数组结构实现,查询快、增删慢
        • JDK1.0版本,运行效率慢、线程安全
        package com.oop.demo13;
        
        import java.util.Enumeration;
        import java.util.Vector;
        
        public class Demo01 {
            public static void main(String[] args) {
                //创建集合
                Vector vector=new Vector <>();
                //添加元素
                vector.add ("apple");
                vector.add ("lemon");
                vector.add ("pear");
                vector.add ("water");
                System.out.println ("元素个数"+vector.size ());
                //2.删除
                vector.remove ("pear");
                System.out.println ("删除之后"+vector.size ());
                //vector.clear ();
                //4.判断
                System.out.println (vector.contains ("lemon"));
                System.out.println (vector.isEmpty ());
                //3.遍历
                //使用枚举器
                System.out.println ("--------使用枚举器----------");
                Enumeration en = vector.elements ();
                while (en.hasMoreElements ()){
                    String o = (String)en.nextElement ();
                    System.out.println (o);
                }
                //5.vector其他方法
                System.out.println ("-----------------");
                System.out.println (vector.firstElement ());//得到第一个元素
                System.out.println (vector.lastElement ());//得到最后一个元素
                System.out.println ( vector.elementAt (1));//获取某个位置的元素
            }
        }
        
      • L.inkedList:

        • 链表结构实现,增删快,查询慢。
    package com.oop.demo13;
    
    import com.oop.Demo12.Student;
    
    import java.util.Iterator;
    import java.util.LinkedList;
    import java.util.ListIterator;
    
    /**
     * LinkedList使用
     * 存储结构:双向链表
     */
    public class Demo02 {
        public static void main(String[] args) {
            //创建集合
            LinkedList linkedList=new LinkedList ();
            //添加元素
            Student s1=new Student ("xiaoming",10);
            Student s2=new Student ("xiaoHong",16);
            Student s3=new Student ("xiaobai",14);
            linkedList.add (s1);
            linkedList.add (s2);
            linkedList.add (s3);
            //linkedList.add (s1);//可重复元素个数4
            //[Student[name='xiaoming', age=10], Student[name='xiaoHong', age=16], Student[name='xiaobai', age=14], Student[name='xiaoming', age=10]]
            System.out.println ("元素个数"+linkedList.size ());
            System.out.println (linkedList.toString ());
            //2.删除
            /**Student类
             * @Override
             *     public boolean equals(Object obj) {
             *         //1判断是不是同一个对象
             *         if(this==obj){
             *             return true;
             *         }
             *         //2.判断是否为空
             *         if (obj==null) {
             *             return false;
             *         }
             *         //3.判断是否是Student类型
             *         if (obj instanceof Student){
             *             Student s=(Student) obj;
             *             //比较属性
             *             if (this.name.equals (s.getName ())&&this.age==s.getAge ()){
             *                 return true;
             *             }
             *
             *         }
             *         //5不满足条件返回false
             *         return false;
             *     }
             */
            /*linkedList.remove (new Student ("xiaoming",10));
            System.out.println ("删除之后"+linkedList.size ());//删除之后2
            linkedList.clear ();*/
            //3.遍历
            //3.1for遍历
            System.out.println ("-----3.1for遍历-------");
            for (int i = 0; i < linkedList.size (); i++) {
                System.out.println (linkedList.get (i));
            }
            System.out.println ("-----3.2增强for遍历------");
            for (Object o : linkedList) {
                Student s=(Student)o;
                System.out.println (s.toString ());
            }
            //3.3使用迭代器
            System.out.println ("-------3.3使用迭代器-----");
            Iterator it=linkedList.iterator ();
            while (it.hasNext ()){
                Student s=(Student)it.next ();
                System.out.println (s.toString ());
            }
            //3.4使用列表迭代器
            System.out.println ("-------3.4使用列表迭代器---");
            ListIterator lit =linkedList.listIterator ();
            while (lit.hasNext ()){
                Student s= (Student) lit.next ();
                System.out.println (s.toString ());
            }
    
            //判断
            System.out.println (linkedList.contains (s1));
            System.out.println (linkedList.isEmpty ());
            //5.获取
            System.out.println (linkedList.indexOf (s1));
        }
    }
    
  • 相关阅读:
    数据结构之链表——加里森的任务(循环链表)
    数据结构之队列——回文字判断
    数据结构之栈——二进制转十进制
    《爱的艺术》人类超越了本能
    从一个Activity返回上一个Activity
    VS(C++)编程遇到的错误集合
    C++(MFC)编程一些注意事项
    Tomcat部署(进行web服务器开发)
    本地IP与宽带IP
    opencv的Mat图像显示在MFC控件中
  • 原文地址:https://www.cnblogs.com/lemonlover/p/14074405.html
Copyright © 2020-2023  润新知