zoukankan      html  css  js  c++  java

  • 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类的区别。
  • 相关阅读:
    BF算法和KMP算法
    Python课程笔记 (五)
    0268. Missing Number (E)
    0009. Palindrome Number (E)
    0008. String to Integer (atoi) (M)
    0213. House Robber II (M)
    0198. House Robber (E)
    0187. Repeated DNA Sequences (M)
    0007. Reverse Integer (E)
    0006. ZigZag Conversion (M)
  • 原文地址：https://www.cnblogs.com/lzq198754/p/5780517.html
Copyright © 2011-2022 走看看