java之List接口与实现类

List 接口

List 子接口

在这里插入图片描述

List 接口使用

  • public class Demo01 {
        /*
        List 子接口的使用
        特点:有序有下标  可以重复
         */
        public static void main(String[] args) {
    //        先创建集合对象
            List list = new ArrayList();
    //        添加元素
            list.add("苹果");
            list.add(0,"oppo");
            list.add("华为");
            System.out.println("元素个数:"+list.size());
            System.out.println(list.toString());
    //        删除元素
    //        list.remove("苹果");
    //        list.remove(0);
    //        System.out.println("元素个数:"+list.size());
    //        System.out.println(list.toString());
    //        遍历元素
    //        使用for遍历
            for (int i = 0;i < list.size();i++){
                System.out.println(list.get(i));
            }
    //        使用增强for
            for (Object object : list) {
                System.out.println(object);
    
            }
    //        使用迭代器
            Iterator it = list.iterator();
            while (it.hasNext()){
                System.out.println(it.next());
            }
    //        使用列表迭代器  和iterator的区别  listIterator可以向前或向后遍历,添加、删除、修改元素
            ListIterator lit= list.listIterator();
            System.out.println("从前往后");
            while (lit.hasNext()){
                System.out.println(lit.nextIndex()+":"+lit.next());
            }
            System.out.println("从后往前");
            while (lit.hasPrevious()){
                System.out.println(lit.previousIndex()+":"+lit.previous());
            }
    //        判断
            System.out.println(list.contains("苹果"));
            System.out.println(list.isEmpty());
    //        获取
            System.out.println(list.indexOf("华为"));
        }
    }
    
  • public class Demo02 {
        /*
        List 的使用
         */
        public static void main(String[] args) {
    //        创建集合
            List list = new ArrayList();
    //        添加数字数据
            list.add(20);
            list.add(30);
            list.add(40);
            list.add(50);
            list.add(60);
            list.add(70);
            System.out.println("元素个数:"+list.size());
            System.out.println(list.toString());
    //        删除操作
    //        list.remove((Object) 20);
    //        System.out.println("删除元素:"+list.size());
    //        System.out.println(list.toString());
    //        补充方法 返回子集合  含头不含尾
            List sublist = list.subList(1, 3);
            System.out.println(sublist.toString());
        }
    }
    

List 实现类

  • ArrayList[重点]:

    • 数组结构实现,查询快、增删慢;
    • JDK1.2版本,运行效率快 ,线程不安全
  • Vector:

    • 数组结构实现,查询快、增删慢;
    • JDK1.0版本,运行效率慢,线程安全
  • LinkedList:

    • 链式结构实现,增删快、查询慢

ArrayList 使用

  • public class Demo03 {
        /*
        ArrayList 的使用
        数组结构实现,查询快、增删慢;
         */
        public static void main(String[] args) {
    //        创建集合
            ArrayList arrayList = new ArrayList<>();
    //        添加元素
            Student s1 = new Student("刘德华", 20);
            Student s2 = new Student("成龙", 20);
            Student s3 = new Student("吴彦祖", 20);
            arrayList.add(s1);
            arrayList.add(s2);
            arrayList.add(s3);
            System.out.println("元素个数"+arrayList.size());
            System.out.println(arrayList.toString());
    //        删除元素
    //        arrayList.remove(new Student("成龙", 20));
    //        System.out.println("元素个数"+arrayList.size());//
    //        System.out.println(arrayList.toString());
    //        遍历元素  {重点}
    //        使用迭代器
            Iterator it = arrayList.iterator();
            while (it.hasNext()){
                Student s = (Student)it.next();
                System.out.println(s.toString());
            }
    //        列表迭代器
            ListIterator lit = arrayList.listIterator();
            System.out.println("--------------------------------");
            while (lit.hasNext()){
                Student s = (Student)lit.next();
                System.out.println(s.toString());
            }
    //        逆序
            while (lit.hasPrevious()){
                Student s = (Student)lit.previous();
                System.out.println(s.toString());
            }
    //     判断
            System.out.println(arrayList.contains(new Student("吴彦祖", 20)));
            System.out.println(arrayList.isEmpty());
    //        查找
            System.out.println(s1);
    
        }
    }
    
  • 重写equals 方法

        @Override
        public boolean equals(Object obj) {
            if (this == obj){
                return true;
            }
            if (this == null){
                return  false;
            }
            if (obj instanceof Student){
                Student s = (Student)obj;
    //            比较属性
                if (this.name.equals(s.getName())&&this.age==s.getAge()){
                    return true;
                }
            }
    //        不满足条件
            return false;
        }
    }
    

ArrayList 源码分析

  • 默认容量大小 : DEFAULT_CAPACITY = 10;

    • 如果没有向集合中添加任何元素,容量0
  • 存放元素的数组:elementData

  • 实际的元素个数:size

  • add() 添加元素

    • public boolean add(E e) {
          ensureCapacityInternal(size + 1);  // Increments modCount!!
          elementData[size++] = e;
          return true;
      }
      
          private static int calculateCapacity(Object[] elementData, int minCapacity) {
              if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
                  return Math.max(DEFAULT_CAPACITY, minCapacity);
              }
              return 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 使用

  • public class Demo01 {
        public static void main(String[] args) {
    //        创建集合
            Vector vector = new Vector();
    //        添加元素
            vector.add("草莓");
            vector.add("西瓜");
            vector.add("芒果");
            System.out.println("元素个数:"+vector.size());
    //        删除
    //        vector.remove(0);
    //        vector.remove("西瓜");
    //        vector.clear();
    //        System.out.println("元素个数:"+vector.size());
    //        遍历
    //        使用枚举器
            Enumeration en = vector.elements();
            while (en.hasMoreElements()){
                Object o = (String)en.nextElement();
                System.out.println(o);
            }
    //        判断
            System.out.println(vector.contains("西瓜"));
            System.out.println(vector.isEmpty());
    //        其他方法
    //        firsetElement、lastElement、ElementAt();
        }
    }
    

LinkedList 的使用

  • public class Demo01 {
        public static void main(String[] args) {
    //        创建集合
            LinkedList linkedList = new LinkedList<>();
    //        添加元素
            Student s1 = new Student("刘德华", 20);
            Student s2 = new Student("成龙", 20);
            Student s3 = new Student("吴彦祖", 20);
            linkedList.add(s1);
            linkedList.add(s2);
            linkedList.add(s3);
            System.out.println("元素个数:"+linkedList.size());
            System.out.println(linkedList.toString());
    //        删除
    //        linkedList.remove(new Student("成龙", 20));
    //        System.out.println("删除之后"+linkedList.size());
    //        linkedList.clear();
    //        遍历
    //        for遍历
            System.out.println("===================================");
            for (int i = 0;i<linkedList.size();i++){
                System.out.println(linkedList.get(i));
            }
    //        增强for
            System.out.println("===================================");
            for (Object object : linkedList) {
              Student s  = (Student) object;
                System.out.println(s.toString());
            }
    //        迭代器
            System.out.println("===================================");
            Iterator it = linkedList.iterator();
            while (it.hasNext()){
                Student s = (Student)it.next();
                System.out.println(s.toString());
            }
    //        列表迭代器
            System.out.println("===================================");
            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());
    //        获取
            System.out.println(linkedList.indexOf(s2));
    
    
        }
    }
    

LinkedList 源码分析

  • int size : 集合的大小

  • Node first :链表的头节点

  • Node last : 链表的尾节点

  • void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }
    
  • private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;
    
        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
    

ArrayList 和 LinkedList 区别

  • 不同的结构实现方式

在这里插入图片描述

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值