Java学习笔记——List集合

版权声明：以上所有博客均为冷漠的小猿所有，引用请注明出处 https://blog.csdn.net/lyf1997115/article/details/81674441

List集合

1.掌握集合的概念以及和数组的对比
2.了解集合的框架
3.了解Collection接口中的常用方法
4.了解泛型的使用及注意事项
5.掌握Iterator的工作原理以及使用
6.掌握List接口的存储特点
7.掌握ArrayList的使用
8.了解LinkedList、Vector和Stack的使用

第一节 概念

1.1 集合的概念

集合：就是一个存储数据的容器。
集合与数组一样，也是一个容器，与数组不同的是
1 数组长度固定，集合的长度不定，可以无限的向集合中添加元素
2 集合中存储的元素类型只能是引用类型，数组可以存储基本类型和引用类型。

1.2 集合的框架结构介绍

Collection集合的框架结构

Map集合的框架结构

1.3 集合与数组的对比

相同点：

都是数据的容器，在一个数组或集合中可以存储多个数据

不同点：

元素：数组中的元素只能是相同，集合中的元素是任意的（泛型）
      数组中可以存储基本类型和引用类型，集合只能存储引用类型

长度(元素个数)：
    数组是定长的，一旦初始化长度就不可以修改
    集合长度可以修改，可以删除元素和添加元素

第二节 Collection接口

2.1 Collection中常用的方法

  方法名                               描述                                      
  add(E e)                          确保此 collection 包含指定的元素（可选操作）。           
  addAll(Collection<? extends E> c) 将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
  clear()                           移除此 collection 中的所有元素（可选操作）。            
  contains(Object o)                如果此 collection 包含指定的元素，则返回true。         
  containsAll(Collection<?> c)      如果此 collection 包含指定 collection 中的所有元素，则返回 true。
  equals(Object o)                  比较此 collection 与指定对象是否相等。               
  isEmpty()                         如果此 collection 不包含元素，则返回true。           
  iterator()                        返回在此 collection 的元素上进行迭代的迭代器。           
  remove(Object o)                  从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
  removeAll(Collection<?> c)        移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
  retainAll(Collection<?> c)        仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
  size()                            返回此 collection 中的元素数。                   
  toArray()                         返回包含此 collection 中所有元素的数组。              

上机练习1

扫描二维码关注公众号，回复： 3027834 查看本文章

//1创建Collection对象
            Collection collection=new ArrayList();
            //2操作
            //2.1添加
            collection.add("张三");
            collection.add("李四");
            collection.add("他二大爷");
            collection.add("他老爷");
            collection.add("七大妈");
            collection.add("张三");
            System.out.println("集合的元素个数:"+collection.size());
            //2.2删除
            //2.2.1删除一个
    //      collection.remove("张三");
    //      System.out.println("删除之后的数据个数:"+collection.size());
            //2.2.2清空
    //      collection.clear();
    //      System.out.println("清空之后:"+collection.size());

            //3遍历
            //3.1 使用增强for
            System.out.println("--------使用增强for遍历----------");
            for(Object obj:collection){
                System.out.println(obj);
            }
            //3.2使用迭代器
            System.out.println("-------使用迭代器---------");
            Iterator it=collection.iterator();
            while(it.hasNext()){
                Object obj=it.next();
                System.out.println(obj);
            }
            //4判断
            //4.1判断是否存在
            boolean b=collection.contains("王五");
            boolean b2=collection.contains("他老爷");
            System.out.println(b);
            System.out.println(b2);
            //4.2判断是否为空
            System.out.println(collection.isEmpty());

            //5查找

            //6其他方法
            Collection c1=new ArrayList();
            c1.add("中国");
            c1.add("朝鲜");
            Collection c2=new ArrayList();
            c2.add("中国");
            c2.add("朝鲜");
            System.out.println("c1.equals(c2):"+c1.equals(c2));
            System.out.println("c1==c2:"+(c1==c2));

上机练习2

Collection collection=new ArrayList();
            //1添加
            collection.add(111);//111自动装箱 new Integer(111)
            collection.add(222);
            collection.add("111");
            collection.add("222");
            //2删除
            System.out.println("元素的个数:"+collection.size());
            System.out.println("删除之前:"+collection);
            collection.remove("111");
            System.out.println("删除之后:"+collection.size());
            System.out.println("删除之后:"+collection);
            //3遍历
            //3.1增强for循环
            System.out.println("增强for.....");
            for (Object object : collection) {
                System.out.println(object);
            }
            //3.2使用迭代器
            System.out.println("迭代器.....");
            Iterator it=collection.iterator();
            while(it.hasNext()){
                Object obj=it.next();
                System.out.println(obj);
            }

第三节 泛型

3.1 什么是泛型

泛型就是可以表示一个广泛数据类型的类型参数（泛型只能表示引用类型）,把数据类型作为参数来传递。
形式参数：声明方法时，在方法的参数列表中声明，而且在方法体中会使用到，但是是一个未知的数据
类型参数：在一个类中声明一个未知的数据类型，在类中可以使用这个类型，但是具体类型取决于实例化时传入的实际类型

3.2 泛型的声明

1）泛型可以声明在方法中：(泛型方法)
public static <标识符> void fun(){}

2）泛型可以声明在类中：（泛型类）
public class 类名<标识符>{
    //类体
    //泛型可以在类中充当成员变量
    //泛型可以再类中充当方法的返回值
    //泛型可以在类中充当方法的参数
}

3）泛型可以声明在接口中：（泛型接口）
public interface 接口名<标识符>{

    //泛型可以充当接口中方法的返回值
    //泛型可以充当接口中方法的参数
}

案例1：

package com.qf.day15_2;
    /**
     * 学生类
     * @author wgy
     *
     */
    public class Student {
        String name;
        int age;

        public void show(String s) {
            System.out.println("姓名:"+name+" 年龄:"+age+"   "+s);
        }

        /**
         * 泛型方法  
         * T 占位符  表示一种未知的数据类型
         * T type
         * E 
         * K 
         * V 
         */
        public <T> void fun(T t) {
            System.out.println(t);
        }


    }

    package com.qf.day15_2;
    /**
     * 老师类
     * 泛型类
     * T 占位符:表示未知的数据类型
     * @author wgy
     *
     */
    public class Teacher<T>{
        String name;
        int age;
        int workyear;
        T t;

        public void show() {
            System.out.println("姓名:"+name+" 年龄:"+age+" 工作年限:"+workyear+"  t:"+t);
        }



    }

案例3：

 package com.qf.day15_2;
    /**
     * 接口
     * 泛型的
     * @author wgy
     *
     */
    public interface MyCollection<T> {
        void add(T t);
        void remove(T t);
        T get();
    }


    package com.qf.day15_2;

    public class MyArray<T> implements MyCollection<T>{

        @Override
        public void add(T t) {
            // TODO Auto-generated method stub
            System.out.println("添加了:"+t);
        }

        @Override
        public void remove(T t) {
            // TODO Auto-generated method stub
            System.out.println("删除了:"+t);
        }

        @Override
        public T get() {
            // TODO Auto-generated method stub
            return null;
        }

    }

案例4

package com.qf.day15_3;

    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;

    import javax.net.ssl.SSLContext;

    public class Demo1 {
        public static void main(String[] args) {
            //创建泛型对象  元素类型String
            Collection<String> coll=new ArrayList<String>();
            //1添加
            coll.add("苹果");
            coll.add("桔子");
            coll.add("芒果");
            coll.add("西瓜");
            System.out.println("元素个数:"+coll.size());
            System.out.println(coll);
            //2删除
    //      coll.remove("苹果");
    //      System.out.println("删除之后");
    //      System.out.println(coll);
            //3遍历
            //3.1增强for
            System.out.println("---------增强for--------");
            for(String s:coll) {
                System.out.println(s);
            }
            System.out.println("---------迭代器--------");
            Iterator<String> it=coll.iterator();
            while(it.hasNext()) {
                System.out.println(it.next());
            }

        }
    }

3.3 说明

1）标识符(占位符)：只要是一个合法的标识符即可，一般情况下，只使用一个大写字母表示泛型
例：public class Person<T>{} E(Element)  K(key)  V(value)
2）泛型的类型与声明的类或接口不需要有任何的关系
3）泛型可以在类中充当任何的成员
4）泛型具体类型取决于实例化对象时传入的实际类型

3.4 泛型使用时的注意事项

1）泛型不能在类中声明静态属性、常量
final修饰的属性必须在声明的同时初始化，所以泛型不能声明常量
static修饰的属性是静态属性，先于对象，泛型类型取决于创建对象时传入的实际类型，所以泛型不能声明静态属性
综上所述：不能使用泛型声明静态属性、常量

2）泛型不能在类中初始化数组，但是可以声明数组
初始化数组时需要给元素进行分配空间,但是泛型类型不确定无法分配空间

3）在类中不能使用泛型声明参数个数相同的重载方法
当一个类中有两个泛型时，创建对象时，两个泛型使用相同类型替换，那么重载方法就是相同的方法（同名，参数列表也相同）

4）使用不同实际类型创建出的泛型类对象的引用不可以相互赋值

3.5 受限泛型(理解即可)

1）<?>：表示任意类型
2）<? extends T>：表示T类或者T类的子类
3）<? super T>：表示T类或者T类的父类

3.6 泛型应用在集合上

泛型在集合中应用，表示的是集合中元素的类型

第四节 Iterator迭代器

4.1 迭代器的工作原理

迭代器相当于一个游标，最初获取迭代器时，迭代器的位置在所有元素的前面，每迭代一个元素，迭代器向后移动一个位置

4.2 迭代器的使用

方法名 描述
hasNext() 判断迭代器是否存在下一个元素可以迭代器
next() 迭代器迭代下一个元素
remove() 从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。

第五节 List接口

  方法名                                       描述                                      
  add(int index, E element)                 在列表的指定位置插入指定元素（可选操作）。                   
  addAll(int index, Collection<? extends E> c)  将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
  containsAll(Collection<?> c)              如果列表包含指定 collection 的所有元素，则返回true。      
  get(int index)                            返回列表中指定位置的元素。                           
  indexOf(Object o)                         返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。 
  lastIndexOf(Object o)                     返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。   
  listIterator()                            返回此列表元素的列表迭代器（按适当顺序）。                   
  remove(int index)                         移除列表中指定位置的元素（可选操作）。                     
  set(int index, E element)                 用指定元素替换列表中指定位置的元素（可选操作）。                
  subList(int fromIndex, int toIndex)       返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。

5.1 List接口的存储特点

    相对有序存储，可以存储相同元素（不排重），可以通过下标访问集合元素
    List接口中可以使用独有的迭代器ListIterator，具有反向遍历的功能

5.2 List接口的实现类

5.2.1 ArrayList类

ArrayList类是List接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括null在内的所有元素。

存储特点：
    相对有序存储，可以存储相同元素（不排重），可以通过下标访问集合元素，通过数组实现的集合
存储结构:数组

代码实现：

public class ArrayListDemo {
                public static void main(String[] args) {
                    //创建一个ArrayList集合
                    ArrayList<String> list = new ArrayList<>();//构造方法中的泛型可以省略
                    list.add("zhangsan");//向集合中添加元素
                    list.add("lisi");
                    list.add("wangwu");
                    System.out.println(list.isEmpty());//判断list集合是否为空集合
                    System.out.println(list.size());//查看集合中元素的个数
                    System.out.println(list.get(1));//获取集合中下标为1的元素
                    System.out.println(list.set(1,"zhaoliu"));//修改集合中下标为1的元素
                    System.out.println(list.contains("wangwu"));//查看"wangwu"是否是集合中的元素
                    list.remove("wangwu");//删除集合中"wangwu"元素
                    list.remove(1);//删除集合中下标为1的元素
                    //for循环遍历集合
                    for(int i=0; i<list.size(); i++){
                      System.out.println(list.get(i));
                    }
                    //使用Iterator迭代器遍历
                    Iterator<String> it = list.iterator();//获取迭代器
                    while(it.hasNext()){
                      System.out.println(it.next());
                    }
                    //使用ListIterator迭代器遍历
                    ListIterator<String> lit = list.listIterator();
                    while(lit.hasNext()){
                      System.out.println(lit.next());
                    }
                    //反向遍历
                    while(lit.hasPrevious()){
                      System.out.println(lit.previous());
                    }
             }
    }

5.2.2 LinkedList类

LinkedList类是List接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括null）。
存储特点：
    相对有序存储，可以存储相同元素（不排重），可以通过下标访问集合元素，通过链表实现的集合
存储结构:双向链表

LinkedList集合适用在对元素插入和删除操作较频繁的时候
ArrayList集合适用在对元素查询、遍历操作较频繁的时候

5.2.3 Vector

Vector类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是Vector
的大小可以根据需要增大或缩小，以适应创建 Vector后进行添加或移除项的操作。

5.2.4 Stack

Stack类表示后进先出（LIFO）的对象栈。是Vector的子类。

5.2.5 ArrayList与LinkedList，Vector三种实现类存储的比较

a.功能基本相同
b.底层存储结构：ArrayList是数组，LinkedList是链表，Vector是数组
c.Vector是一个古老的集合，从JDK1.0开始就有了，Vector存在一些方法名比较长的方法，xxxElement
d.Vector是线程安全的，效率低，ArrayList是线程不安全的，效率高，推荐使用ArrayList【Collections工具类中有相应的方法可以将ArrayList改为线程安全的】
e.ArrayList查找遍历比较快，LinkedList插入删除比较快

总结

1 集合概念，用来存储一组数据的容器。和数组类似，数组是长度固定的，集合长度可以变化。数组能存储基本类型和应用类型，集合只能存储引用类型。
2 Collection接口，父接口， add()  remove()  clear()  contains()  iterator()
3 Collection有两个子接口 List和Set
4 泛型：本质使用数据类型作为参数传递
    4.1 定义泛型类  泛型方法 泛型接口
    4.2 使用 创建类对象，指定泛型的实际类型
    4.3 泛型限制，<?> 表示任何类型  
                 <? extends T> 表示泛型上限， T类型或T的子类 
                 <? super T> 表示泛型下限，T类型或T的父类
5 Iterator迭代器
        hasNext();
        next();
6 List接口 
     List接口的特点：有序的，可以重复
7 ArrayList实现类
     存储结构：数组
     适合遍历查找
8 LinkedList实现
     存储结构：双向链表
     适合做添加，删除
9 Vector向量集合  Stack栈 （先进后出）