Java中创建List接口、ArrayList类和LinkedList类的常用方法（一）

List接口

要了解List接口，就不得不说起Java的集合框架。

（该图来自菜鸟教程）

Collection接口和Map接口

Java 集合框架主要包括两种类型的容器，集合Collection和图Map。

• Collection接口代表了单列集合，它包含了一组Object元素，每个元素都有一个值。

  （这里有个“泛型擦除”的概念，在此不提及有兴趣可自行了解）

• Map接口代表了双列集合，它包含了一组键值对，每个键值对包含两个值，一个是键，一个是对应的值。

  List

  Collection 接口又有 3 种子类型，List、Set 和 Queue。

  • List 接口存储一组不唯一，有序（插入顺序）的对象。
    1. 不唯一：允许存储重复的元素。
    2. 有序：可以精准控制元素添加的位置，因此可以根据索引访问元素。
    3. <实现类有ArrayList,LinkedList,Vector> 。
  • Set 接口存储一组唯一，无序的对象。
    1. 唯一：元素不允许重复。
    2. 无序：没有定义顺序，元素的存储顺序可能与添加顺序不同。
  • Queue接口：一个先进先出（FIFO）的集合，通常用于模拟队列数据结构。

    静态数组

    概念

    1. 是一种线性数据结构。
    2. 将相同类型的元素存储在连续的内存空间中。

    初始化

    java中两种创建静态数组的形式如下，

     int[] array = new int[5];  // { 0, 0, 0, 0, 0 } 
     int[] iarray = { 1, 2, 3, 5, 4 }; 
    

    1. • 第一行代码创建了一个名叫array的数组，长度大小为5，并且数组的长度大小不能改变。
       • 注释的意思是，java会自动给数组内的元素赋值为默认值，即int型的默认值0。
       • 第二行代码创建了一个名叫iarray的数组，长度大小为5，并且长度大小也无法改变，且编写者主动赋值为一到五的数字。

    ArrayList类

    

    概念和性质

    • ArrayList 继承了 AbstractList类 ，并实现了 List 接口。

      (AbstractList是List接口的抽象实现类，它继承自AbstractCollection类，并实现了List接口中的方法。)

    • ArrayList基于动态数组实现，内部使用一个数组来存储元素，当数组容量不足时，会进行扩容操作，通常创建一个新的更大的数组，并将原数组的元素复制到新数组中。
    • 插入删除性能：
      1. 倘若在末尾进行插入和删除操作的性能较好
      2. 但若在中间或开头进行插入删除操作时，需要移动后续元素，性能较差。
    • 随机访问性能：支持通过索引进行快速的随机访问，效率较快。

      使用

      初始化

      ArrayList初始化的基本格式如下，

      import java.util.ArrayList; // 引入 ArrayList 类
      ArrayList objectName =new ArrayList<>();　 // 初始化
      

      ElemType是数组中对象（元素）的引用类型数据，objectName是数组名字。

      （注意注意下文中的Element是ElemType引用类型的基本类型。）

      
      

      （因为实际ArrayList中的元素是对象，所以需要引用类型）

      （String可以像使用基本类型一样，但实际是引用类型）

      基本类型	引用类型
      boolean	Boolean
      byte	Byte
      short	Short
      int	Integer
      long	Long
      float	Float
      double	Double
      char	Character

      例如，

      import java.util.ArrayList; 
      ArrayList arrayList =new ArrayList<>();　 
      

      避免繁琐后边的代码例子中引入 ArrayList 类就不写了。

      add() 添加元素

      ArrayList objectName =new ArrayList<>();
      objectName.add(ElemType e);
      objectName.add(InterPre i, ElemType e);
      

      可以看到，add（）函数有两种添加方法，

      • 直接在数组的末尾添加元素e；
      • 在索引 i 前面添加元素e；

        如，

        ArrayList arrayList = new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        arrayList.add(0,6);
        for(int i : arrayList) System.out.print(i + " ");//这里的for循环迭代是依次得到数组中的元素，后边会讲
        //输出：6 1 2 3 
        

        remove() 删除元素

        ArrayList objectName =new ArrayList<>();
        objectName.remove(index i);
        

        作用：删除索引为 i 上的元素，如

        ArrayList arrayList = new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        arrayList.remove(2);
        for(int i : arrayList) System.out.print(i + " ");
        //输出：1 2
        

        get() 访问元素

        ArrayList objectName =new ArrayList<>();
        objectName.get(index i);
        

        作用：返回索引为i处上的元素，如

        ArrayList arrayList = new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        System.out.println(arrayList.get(2));
        //输出：3
        

        set() 修改元素

        ArrayList objectName =new ArrayList<>();
        objectName.set(index i, ElemType e);
        

        作用：将索引为 i 上的元素修改为 e，如

        ArrayList arrayList = new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        arrayList.set(1,6);
        for(int i : arrayList) System.out.print(i + " ");
        //输出：1 6 3
        

        size() 元素数量

        int ArrayLength = arrayList.size();
        

        作用：**返回数组的长度，**赋值给ArrayLenth。如，

        ArrayList arrayList = new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        System.out.println(arrayList.size());
        //输出：3
        

        其余函数

        下面就不给出示例代码和输出结果啦，太多了，但是会给出基本格式和用法。

        ArrayList arraylist =new ArrayList<>();
        

        • void arraylist.clear() ：删除arraylist 中的所有元素

          
          

        • boolean arraylist.contains(ElemType e) ：判断元素e是否在arraylist中，如果在返回true，否则返回false

          
          

        • int arraylist.indexOf(ElemType e) ：返回元素e在arraylist中的索引
          • 若重复出现，返回最先的索引值；
          • 若不存在，返回-1。

            
            

          • boolean arraylist.isEmpty() ：判断arraylist是否为空，为空返回true，否则返回false

            
            

          • void arraylist.removeAll() ：作用与arraylist.clear()相同，但是arraylist.clear()时间更快。

            
            

          • void arraylist.sort()： 将数组排序，使用方法这里略过后面详细说明。

            
            

          • Elem[] arraylist.toArray(Elem[] num) ：将arraylist转化为数组赋给num，数组的元素类型为同引用类型的基本类型。

            
            

          • String arraylist.toString()：将arraylist转化为String类型返回。

            
            

            迭代数组列表

            第一种，通过普通for循环迭代，依次输出arraylist中的元素。

            ArrayList arraylist = new ArrayList<>();
            /*
            ......
            (赋值操作）
            */
            for (int i = 0; i < arraylist.size(); i++) 
            	System.out.println(arraylist.get(i));
            

            第二种，通过for-each迭代，依次输出arraylist中的元素，也就是上文给出的方式。

            ArrayList arraylist = new ArrayList<>();
            /*
            ......
            (赋值操作）
            */
            for (Element e : arraylist) 
            	System.out.println(e);
            

            注意Element是ElemType引用类型的基本类型。

            
            

            ArrayList排序

            借助Collections 类

            import java.util.Collections;  // 引入 Collections 类
            Collections.sort(arraylist);
            

            注意Collections.sort(）是升序排序（从小到大）。

            本身的sort() 方法

            arraylist.sort(Comparator c)
            

            Comparator c 的意思是排序方式，分别为升序和降序。

            • 升序参数为 Comparator.naturalOrder()
            • 降序参数为 Comparator.reverseOrder()

              注意要使用这两个参数，需要引入Comparator类。

              实例如下，

              import java.util.Comparator;
              arraylist.sort( Comparator.naturalOrder()) ;
              //得到数组升序排序的结果（从小到大）
              arraylist.sort( Comparator.reverseOrder());
              //得到数组降序排序的结果（从大到小）