• Java类集框架——List接口

    学习目标

    掌握List接口与Collection接口的关系。
    掌握List接口的常用子类：ArrayList、Vector。
    掌握ArrayList与Vector类的区别。
     
     Collection下分为很多的子接口，其中有一个List接口，List接口中可以存放任意的数据。而且在List接口中内容是允许重复的。
     List接口的功能要比Collection接口强大很多，因为大量扩充了Collection接口的操作。

     List接口的扩展方法

    1、public void add(int index,E element)普通  在指定的位置增加元素。
    2、public boolean addAll(int index, Collection<? extends E> c)  普通 在指定的位置增加一组元素。
    3、E get(int index) 普通 返回指定位置的元素。
    4、public int indexOf(Object o) 普通 查找指定元素的位置。
    5、public int lastIndexOf(Object o) 普通 从后向前查找指定元素的位置。
    6、public ListIterator<E> listIterator()普通 为ListIterator接口实例化。
    7、public E remove(int index) 普通 按指定的位置删除元素。
    8、public List<E> subList(int fromIndex, int toIndex) 普通 取出集合中的子集合。
    9、public E set(int index, E element)普通 替换指定位置的元素。

    List接口的常用子类——ArrayList

    ArrayList是List子类，可以直接通过对象的多态性，为List接口实例化。
    此类的定义如下：
    public class ArrayList<E> extends AbstractList<E> implements List<E>,RandomAccess, Cloneable, Serializable
    AbstractList类的定义如下：
    public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>
     
    如果要想使用接口，则肯定要使用对象的多态性进行实例化操作，那么对于List接口本身也是一样的。
    ArrayList是List中最常用的子类。
    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. import java.util.ArrayList ;  
    2. import java.util.List ;  
    3. import java.util.Collection ;  
    4. public class ArrayListDemo01{  
    5.     public static void main(String args[]){  
    6.         List<String> allList = null ;  
    7.         allList = new ArrayList<String>() ;   // 指定操作的泛型为String  
    8.         allList.add("Hello") ;  // 此方法由Collection接口而来  
    9.         allList.add("World") ;  // 默认情况下是向后加入  
    10.         System.out.println(allList) ;  
    11.   
    12.     }  
    13. };  


    在指定的位置添加，添加的方法是List接口自己扩充的方法。
    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. import java.util.ArrayList ;  
    2. import java.util.List ;  
    3. import java.util.Collection ;  
    4. public class ArrayListDemo01{  
    5.     public static void main(String args[]){  
    6.         List<String> allList = null ;  
    7.         Collection<String> allCollection = null ;  
    8.         allList = new ArrayList<String>() ;   // 指定操作的泛型为String  
    9.         allCollection = new ArrayList<String>() ; // 指定一个集合  
    10.         allList.add("Hello") ;  // 此方法由Collection接口而来  
    11.         allList.add(0,"World") ;    // 在第一个位置上添加新的内容  
    12.         System.out.println(allList) ;  
    13.         allCollection.add("LIUXUN") ;   // 向Collection中加入内容  
    14.         allCollection.add("1993") ;  
    15.         allList.addAll(allCollection) ;  
    16.         System.out.println(allList) ;  
    17.     }  
    18. };  
    注意：在指定的位置增加一个元素并不会替换原来的元素 而是后移。
    在指定的位置上增加一组元素。
    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. import java.util.ArrayList ;  
    2. import java.util.List ;  
    3. import java.util.Collection ;  
    4. public class ArrayListDemo01{  
    5.     public static void main(String args[]){  
    6.         List<String> allList = null ;  
    7.         Collection<String> allCollection = null ;  
    8.         allList = new ArrayList<String>() ;   // 指定操作的泛型为String  
    9.         allCollection = new ArrayList<String>() ; // 指定一个集合  
    10.         allList.add("Hello") ;  // 此方法由Collection接口而来  
    11.         allList.add(0,"World") ;    // 在第一个位置上添加新的内容  
    12.         System.out.println(allList) ;  
    13.         allCollection.add("LIUXUN") ;   // 向Collection中加入内容  
    14.         allCollection.add("1993") ;  
    15.         allList.addAll(allCollection) ;  
    16.         allList.addAll(0,allCollection) ;  
    17.         System.out.println(allList) ;  
    18.     }  
    19. };  
    既然可以增加数据，那么就可以删除数据。
       List中存在两种删除：根据对象内容、根据对象的编号。
    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. import java.util.ArrayList ;  
    2. import java.util.List ;  
    3. public class ArrayListDemo02{  
    4.     public static void main(String args[]){  
    5.         List<String> allList = null ;  
    6.         allList = new ArrayList<String>() ;   // 指定操作的泛型为String  
    7.         allList.add("Hello") ;  // 此方法由Collection接口而来  
    8.         allList.add(0,"World") ;    // 在第一个位置上添加新的内容  
    9.         allList.add("liuxun") ; // 向Collection中加入内容  
    10.         allList.add("1993") ;  
    11.         allList.remove(0) ; // 删除第一个元素，指定删除的位置  
    12.         allList.remove("Hello") ;   // 此方法由Collection接口继承而来  
    13.         System.out.println(allList) ;  
    14.     }  
    15. };  

    集合中的内容可以添加，可以删除，那么实际上最重要的就是输出。
    在List接口中提供了get()方法，利用此方法就可以完成输出。
     
    通过循环完成，循环的次数由size()方法取得。
    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. import java.util.ArrayList ;  
    2. import java.util.List ;  
    3. public class ArrayListDemo03{  
    4.     public static void main(String args[]){  
    5.         List<String> allList = null ;  
    6.         allList = new ArrayList<String>() ;   // 指定操作的泛型为String  
    7.         allList.add("Hello") ;  // 此方法由Collection接口而来  
    8.         allList.add(0,"World") ;    // 在第一个位置上添加新的内容  
    9.         allList.add("liuXun") ; // 向Collection中加入内容  
    10.         allList.add("1993") ;  
    11.         System.out.print("由前向后输出：") ;  
    12.         for(int i=0;i<allList.size();i++){  
    13.             System.out.print(allList.get(i) + "、") ;  
    14.         }  
    15.         System.out.print(" 由后向前输出：") ;  
    16.         for(int i=allList.size()-1;i>=0;i--){  
    17.             System.out.print(allList.get(i) + "、") ;  
    18.         }  
    19.     }  
    20. };  

    此种输出方式是List接口所独有的，而其他接口没有的，尤其是Collection中是没有根据索引取出内容的操作。
     
     
    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. import java.util.ArrayList ;  
    2. import java.util.List ;  
    3. public class ArrayListDemo04{  
    4.     public static void main(String args[]){  
    5.         List<String> allList = null ;  
    6.         allList = new ArrayList<String>() ;   // 指定操作的泛型为String  
    7.         allList.add("Hello") ;  // 此方法由Collection接口而来  
    8.         allList.add(0,"World") ;    // 在第一个位置上添加新的内容  
    9.         allList.add("liuxun") ; // 向Collection中加入内容  
    10.         allList.add("1993728") ;  
    11.         String str[] = allList.toArray(new String[]{}) ;    // 指定好类型  
    12.         System.out.print("指定数组类型：") ;  
    13.         for(int i=0;i<str.length;i++){  
    14.             System.out.print(str[i] + "、") ;  
    15.         }  
    16.         System.out.print(" 返回对象数组：") ;  
    17.         Object obj [] = allList.toArray() ; // 返回Object类型  
    18.         for(int i=0;i<obj.length;i++){  
    19.             String temp = (String)obj[i] ;  // 进行向下转型  
    20.             System.out.print(temp + "、") ;  
    21.         }  
    22.     }  
    23. };  
    既然已经完成基本的输出功能，集合中还有以下几个操作：
      判断集合是否为空：boolean isEmpty()
      截取部分集合：List<E> subList(int fromIndex, int toIndex) 由List接口扩充。
      查找指定的对象是否存在：int indexOf(Object o) 如果查找到则返回位置，否则返回-1.
      查找是否存在：boolean contains(Object o)
    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. import java.util.ArrayList ;  
    2. import java.util.List ;  
    3. public class ArrayListDemo05{  
    4.     public static void main(String args[]){  
    5.         List<String> allList = null ;  
    6.         allList = new ArrayList<String>() ;   // 指定操作的泛型为String  
    7.         System.out.println("集合操作前是否为空？" + allList.isEmpty()) ;  
    8.         allList.add("Hello") ;  // 此方法由Collection接口而来  
    9.         allList.add(0,"World") ;    // 在第一个位置上添加新的内容  
    10.         allList.add("liuxun") ; // 向Collection中加入内容  
    11.         allList.add("1993728") ;  
    12.         System.out.println(allList.contains("Hello")?""Hello"字符串存在！" : ""Hello"字符串不存在！") ;  
    13.         List<String> allSub = allList.subList(1,3) ;  // 字符串截取  
    14.         System.out.println("集合截取：") ;  
    15.         for(int i=0;i<allSub.size();i++){  
    16.             System.out.print(allSub.get(i) + "、") ;  
    17.         }  
    18.         System.out.println(" liuxun字符串的位置：" + allList.indexOf("liuxun")) ;  
    19.         System.out.println("集合操作后是否为空？" + allList.isEmpty()) ;  
    20.     }  
    21. };  

    以上的操作都是由ArrayList子类完成的。

    挽救的子类：Vector

    在List集合接口中还有一个子类：Vector，Vector类属于一个挽救的子类，从整个JAVA的集合发展史上看，Vector算是一个元老级的类，在JDK1.0的时候就已经存在此类。但是到了JAVA2（JDK1.2）之后重点强调了集合框架的概念，所以先后定义了很多的新接口（如：List等），但是考虑到一大部分的人已经习惯了使用Vector类，所以JAVA设计者，就让Vector类多实现了一个List接口，这才将其保留下来。但是因为其是List子类，所以Vector类的使用与之前没有太大区别。
    Vector类的定义：
    public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serialzable
    但是，虽然Vector类是旧的类，但是因为让其实现了List的接口，所以对于程序来讲是一样的。
    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. import java.util.Vector ;  
    2. import java.util.List ;  
    3. public class VectorDemo01{  
    4.     public static void main(String args[]){  
    5.         List<String> allList = null ;  
    6.         allList = new Vector<String>() ;  // 指定操作的泛型为String  
    7.         allList.add("Hello") ;  // 此方法由Collection接口而来  
    8.         allList.add("Hello") ;  // 此方法由Collection接口而来  
    9.         allList.add(0,"World") ;    // 在第一个位置上添加新的内容  
    10.         allList.add("liuxun") ; // 向Collection中加入内容  
    11.         allList.add("1993728") ;  
    12.         for(int i=0;i<allList.size();i++){  
    13.             System.out.print(allList.get(i) + "、") ;  
    14.         }  
    15.     }  
    16. };  

    因为Vector类本身属于旧的类，所以在类中也提供了很多重复的方法。
       增加元素：public void addElement(E obj) 此方法是最早的增加元素的操作，之后此方法的功能与add()方法是一致的。
    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. import java.util.Vector ;  
    2. import java.util.List ;  
    3. public class VectorDemo02{  
    4.     public static void main(String args[]){  
    5.         Vector<String> allList = null ;  
    6.         allList = new Vector<String>() ;  // 指定操作的泛型为String  
    7.         allList.addElement("Hello") ;   // 此方法由Collection接口而来  
    8.         allList.addElement("liuxun") ;  // 向Collection中加入内容  
    9.         allList.addElement("1993728") ;  
    10.         for(int i=0;i<allList.size();i++){  
    11.             System.out.print(allList.get(i) + "、") ;  
    12.         }  
    13.     }  
    14. };  

    子类的差异：ArrayList与Vector的区别

    1、从推出时间上看：ArrayList是JDK1.2之后推出的，属于新的操作类。Vector是JDK1.0推出的，属于旧的操作类。
    2、性能上比较：ArrayList采用异步的处理方式，性能更高。Vector采用同步的处理方式，性能较低。
    3、线程安全：ArrayList属于非线程安全的操作类，Vector属于线程安全的操作类。
    4、输出：ArrayList只能使用Iterator、foreach输出，Vector可以使用Iterator、foreach、Enumeration输出。
     
    总结：
    1、List中允许有重复元素。
    2、ArrayList和Vector类的区别。
  • 相关阅读:
    Codeforces 1439B. Graph Subset Problem (思维，复杂度分析)
    石子游戏（nim游戏+按位考虑）
    Codeforces 1437F Emotional Fishermen(思维，dp)
    Codeforces Round #671 (Div. 2) （A~E）
    Java就业企业面试问题ssh框架
    DUBBO初探搭建DUBBO开发环境
    Spring容器组建注解@Component和Resouces实现完全注解配置
    jUnit 4 在 s2sh 中的应用
    4.5、常量、作用域、内置全局变量
    Java 诗词纵向转换字符流输出
  • 原文地址：https://www.cnblogs.com/lzq198754/p/5780517.html
Copyright © 2020-2023  润新知