Java12--------------Collection接口的List子接口

最新推荐文章于 2024-04-16 13:24:46 发布

哦?

最新推荐文章于 2024-04-16 13:24:46 发布

阅读量140

点赞数 1

分类专栏： Java基础

本文链接：https://blog.csdn.net/qq_44241861/article/details/107777824

版权

Java基础专栏收录该内容

25 篇文章 0 订阅

订阅专栏

文章目录

集合和数组的区别
Collection集合
List子接口

集合和数组的区别

(1): 长度区别:
数组的长度是固定的而集合的长度是可变的
(2): 存储数据类型的区别:
数组可以存储基本数据类型 , 也可以存储引用数据类型; 而集合只能存储引用数据类型，集合只能添加引用类型：对象、字符串、基本数据类型的引用类型
(3): 内容区别:
数组只能存储同种数据类型的元素 ,集合可以存储不同类型的元素

Java提出集合的概念，集合也是一种容器，集合不是某一个类，而是一个集合框架，有很多种集合构成；下面是Collection集合的继承体系：
在这里插入图片描述

Collection集合

Collection 是层次结构中的根接口，Collection 表示一组对象，这些对象也称为 collection 的元素。该集合在java.util包下。

添加功能：
1、boolean add(Object obj)：添加一个元素
2、boolean addAll(Collection c)：添加一个集合的元素 (给一个集合添加进另一个集合中的所有元素)

 //父接口 接收子类的调用
        Collection collection=new ArrayList();
        //集合只能添加引用类型：对象、字符串、基本数据类型的引用类型
        boolean b = collection.add("aa");//返回true
        //此处的100为Integer类型，自动装箱：对于基本数据类型的操作 Integer.valueOf(100)
        collection.add(100);
        System.out.println(collection);//[aa,100]

		Collection collection = new ArrayList();
        collection.add(100);
        collection.add(200);

        Collection collection2 = new ArrayList();
        collection2.add(300);
        collection2.add(400);
        //把两个集合中的元素，归并到一个集合里面去 返回值是有没有添加成功
        //集合合并，把collection2的元素放到collection中,collection2元素不变
        collection.addAll(collection2);
        System.out.println(collection);//[100, 200, 300, 400]
        System.out.println(collection2);//[300, 400]

删除功能：
3、void clear()：移除所有元素
4、boolean remove(Object o)：移除一个元素
5、boolean removeAll(Collection c)：移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素，如果没有交集元素，则删除失败，返回false；

 //清空集合中的所有元素
//collection.clear();

Collection collection = new ArrayList();
collection.add(100);
collection.add(300);

Collection collection2 = new ArrayList();
collection2.add(300);
collection2.add(400);
//删除集合中的某个元素
collection.remove(100);
System.out.println(collection);//[300]
//  boolean removeAll (Collection c):移除一个集合的元素(移除一个以上返回的就是true) 移除的元素是两个集合的交集元素
System.out.println(collection.removeAll(collection2));//true
System.out.println(collection);//[100]
System.out.println(collection2);//[300,400]

判断功能：
6、boolean contains(Object o)：判断集合中是否包含指定的元素
7、boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(这个集合包含另一个集合中所有的元素才算包含才返回true)【比如：1，2，3 containsAll 12=true 1,2,3 containsAll 2,3,4=false】
8、boolean isEmpty()：判断集合是否为空

System.out.println(collection.contains(111));//false
Collection collection = new ArrayList();
collection.add(100);
collection.add(200);
collection.add(500);
Collection collection2 = new ArrayList();
collection2.add(100);
collection2.add(200);
System.out.println(collection.containsAll(collection2));//true

//判断集合是否为空
System.out.println(collection.isEmpty());

获取功能：
9、Iterator iterator()(重点)，迭代器可以认为是指针；
长度功能：
10、int size():元素的个数

	    Collection collection = new ArrayList();
        collection.add(100);
        collection.add(200);
        collection.add(300);
        collection.add(400);
        collection.add(500);
        //遍历集合中的元素  iterator对 collection 进行迭代的迭代器。
        //父接口 迭代器接收子类调用重写的接口方法
        Iterator iterator=collection.iterator();
        // 内部类 为什么把迭代器 Itr 设计为内部类
        //直接访问外部类的成员（数组中存储）进行迭代
        System.out.println(iterator); //ArrayList$Itr@1b6d3586
      *//*  boolean hasNext ()
        如果仍有元素可以迭代，则返回 true。
        E next ()
        返回迭代的下一个元素*//*
      while ( iterator.hasNext()){
          //迭代的元素使用Object对象接收，因为不知道引用类型的具体类型。
          Object obj = iterator.next();
          System.out.println(obj);
          //如果需要调用子类特有方法，需要向下转型
         // Student student = (Student) iterator.next();
      }*/

关于迭代器：

迭代器是一种设计模式，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构（迭代器把访问逻辑从不同类型的集合类里面抽取出来，从而避免向外部暴露集合的内部结构）。迭代器通常被认为是“轻量级”对象，因为创建它的代价小。

为什么要使用迭代器？

若不使用迭代器，访问代码和集合本身是紧密耦合的，因此无法将访问逻辑从集合类和客户端代码中分离出来。而由于不同的集合会对应不同的遍历方法，所以客户端代码无法复用。而对Iterator来说，它总是用同一种逻辑来遍历集合，使得客户端自身不需要维护集合的内部结构，所有的内部状态都由Iterator来维护。

迭代器的实现原理

下面基于ArrayList的Iterator的实现分析Iterator的原理（基于JDK1.8）:在ArrayList类中有一个方法 iterator() ，此方法将返回一个iterator的实现，这里可以看出实现类交叫Itr，通过它的源码可知，这是ArrayList的一个内部类。为什么要将迭代器设置为内部类，因为内部类（无论是成员内部类还是局部内部类）可以访问外部类里面的所有成员，包括私有的成员。这样就可以遍历集合中的元素了。

交集功能：
【例如：A集合对B集合取交集，获取到的交集元素在A集合中。返回的布尔值表示的是A集合是否发生变化】
11、boolean retainAll(Collection c)：获取两个集合的交集元素(交集：两个集合都有的元素)
把集合转换为数组：
12、Object[] toArray()

		Collection collection = new ArrayList();
        collection.add(1000);
        collection.add(200);

        collection.add(500);

        Collection collection2 = new ArrayList();
        collection2.add(100);
        collection2.add(200);

        collection2.add(300);
        collection2.add(400);
        //获取两个集合的交集元素，并将交集元素赋给collection的元素 ，因此collection发生变化
        System.out.println(collection.retainAll(collection2));//true
        System.out.println(collection);//[200]
        System.out.println(collection2);//[100, 200, 300, 400]

//集合转换为数组：使用object[] 接收,不确定集合中元素的具体引用类型
        Object[] objects=collection.toArray();

List子接口

元素序列有序（存取顺序一致），并且每一个元素都有索引，集合中允许元素重复。

List集合的特有功能概述：
void add(int index,E element):在指定索引处添加元素
E remove(int index):移除指定索引处的元素返回的是移除的元素
E get(int index):获取指定索引处的元素
E set(int index,E element):更改指定索引处的元素返回的而是被替换的元素
int indexOf(Object o)：返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
int lastIndexOf(Object o)“：返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -。

  //在指定索引出添加元素
        List list=new ArrayList();
        list.add(100);
        list.add(100);
        list.add(1,"aaa");
        list.add(0,"aaa");
        System.out.println(list);//[aaa, 100, aaa, 100]

        //get(list.size() - 1); 通过索引来获取集合中的元素
        Object obj = list.get(list.size() - 1);
        System.out.println(obj);//100
        System.out.println(list);//[aaa, 100, aaa, 100]

        //删除元素 传入索引值
        //如果要删除指定元素，但是Integer类型与索引值无法区分，可以把元素包装一下。
        list.remove(Integer.valueOf(100));
        System.out.println(list);//[aaa, aaa, 100]


        //替换集合中的元素 返回的是被替换的那个旧元素
        Object oldelement = list.set(list.size() - 1, 100000);
        System.out.println(list);//[aaa, aaa, 100000]
        System.out.println(oldelement);//100

        //根据元素查找索引值
        int i = list.indexOf(100000);
        System.out.println(i);//2

遍历List集合的几种方式

 	   List list= new ArrayList();
       list.add("aaa");
        list.add(200);
        list.add(300);
        list.add(400);

        //方法一： for循环（最常用）
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        
        //方法二： 使用父接口迭代器
        Iterator iterator=list.iterator();
        while (iterator.hasNext()){
            Object obj = iterator.next();
            System.out.println(obj);
        }

        //方法三： 使用List自带的迭代器listIterator
        ListIterator listIterator=list.listIterator();
        while (listIterator.hasNext()){
            System.out.println(listIterator.next());
        }
  		//对于同一个迭代器进行反向迭代时，先要正向迭代。
  		//使得指针指向集合中的最后一个元素的后面null处，然后再反向迭代，就可以遍历到之前的元素。
        while (listIterator.hasPrevious()) {
            Object o = listIterator.previous();
            System.out.println(o);
        }

并发修改异常

需求：我有一个集合，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。

现象：在使用迭代器遍历后通过list.add()方法添加元素就会出现并发修改异常

public class test {
    public static void main(String[] args) {
      List list=  new ArrayList();
      list.add("aaa");
      list.add("bbb");
      list.add("world");
    ListIterator listIterator = list.listIterator();
    while (listIterator.hasNext()) {
        Object o = listIterator.next();
        if (o.equals("world")){
            //ConcurrentModificationException并发修改异常
            list.add("java");
        }
    }
        System.out.println(list);
    }
    }

原因：当我们使用迭代器遍历集合的时候，我们的迭代器已经事先知道集合元素的个数，突然在迭代途中增加或者删除元素，就会打乱原来集合的顺序，迭代器也就无所适从，就会抛出并发修改异常；

解决方式有两种：
1、方式一：
a:迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)
将list.add("java“);修改为listIterator.add("java");

b:集合遍历元素，集合修改元素

 public static void main(String[] args) {
      List list=  new ArrayList();
      list.add("aaa");
      list.add("bbb");
      list.add("world");
   if (list.contains("world")){list.add("java");}
        System.out.println(list);
    }
    }

执行结果：
[aaa, bbb, world, java]

2、使用for循环遍历，就可以使用集合自己的增加和删除方式

     List list=  new ArrayList();
      list.add("aaa");
      list.add("bbb");
      list.add("world");
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).equals("world"))list.add("java");
        }
        System.out.println(list);
    }

执行结果：
[aaa, bbb, world, java]

List的三个子类的特点

List：数组元素有序，允许元素重复，选择哪种集合，根据自己的需求而定
要安全还是要效率，是查找多还是增删多

ArrayList类

1、boolean add(E e) ：将指定的元素添加到此列表的尾部
2、void add(int index, E element)：将指定的元素插入此列表中的指定位置
3、void clear() ：移除此列表中的所有元素
4、Object clone() ：返回此 ArrayList 实例的浅表副本
5、boolean contains(Object o)：如果此列表中包含指定的元素，则返回 true
6、 E get(int index)：返回此列表中指定位置上的元素
6、 int indexOf(Object o) ：返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1
7、boolean isEmpty() ：如果此列表中没有元素，则返回 true
8、int lastIndexOf(Object o)：返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1
9、E remove(int index)：移除此列表中指定位置上的元素
10、boolean remove(Object o) ：移除此列表中首次出现的指定元素（如果存在）
11、protected void removeRange(int fromIndex, int toIndex)：移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素
12、E set(int index, E element)：用指定的元素替代此列表中指定位置上的元素13、int size() ：返回此列表中的元素数
14、Object[] toArray()：按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组

  ArrayList arrayList = new ArrayList();
        arrayList.add(20);
        arrayList.add(50);
        arrayList.add(100);
//JDK1.8给ArrayList集合提供了一个内部迭代 
//void forEach(Consumer<? super E> action) 执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常 
arrayList.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);

            }
        });



/*20
50
100*/

【案例】去除集合中的重复元素：要求是不能创建新的容器，就在原来的集合当中，去掉重复元素；

import java.util.ArrayList;
import java.util.ListIterator;

public class MyTest1
{
    public static void main(String[] args)
    {
        ArrayList list=new ArrayList();
        list.add(100);
        list.add(100);
        list.add(100);
        list.add(100);
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(100);
        list.add(200);
        list.add(400);
        list.add(500);
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        //方式1-----原理：类似于选择排序
        deleteEle(list);

        //方式2------递归
//遍历获取第一个元素，从索引为0处与索引为最后一位处查找这两个位置是否有同一个元素，相等就说明有重复元素在不同的位置，删除此元素；不相等i加1 再次比较直到找到相等的元素，删除，然后接着递归调用从索引为0处与索引为最后一位处查找这两个位置是否相等
//查找一遍后均没有相同元素就return 退出函数；不可以使用continue因为外层没有循环，for循环已经结束
        ArrayList list1=removeEle(list);
        System.out.println(list1);//[500, 100, 200, 300, 400]
    }

//方式3----- 创建一个新集合
//contains方法判断一个集合是否有此元素，
//contains对于对象的比较底层使用equals比较地址值，因此需要重写equals方法来比较成员变量进而判断两个对象是否相等

        ArrayList<Object> list2 = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            if (!list2.contains(o)){
                list2.add(o);
            }
        }
        System.out.println(list2);
    }



    private static ArrayList removeEle(ArrayList list)
    {
        for (int i = 0; i < list.size(); i++)
        {
            if(list.indexOf(list.get(i))!=list.lastIndexOf(list.get(i)))
            {
                list.remove(list.get(i));
                removeEle(list);
            }
        }
        return list;
    }

    private static void deleteEle(ArrayList list)
    {
        for (int i = 0; i < list.size()-1; i++)
        {
            for (int j = i+1; j < list.size(); j++)
            {
                if (list.get(i).equals(list.get(j)))
                {
                    list.remove(j);
                    j--;
                }
            }
        }
        System.out.println(list);//[100, 200, 300, 400, 500]
    }
}

Vector类

Vector集合底层数据结构仍然是数组，因此具有查询快，增删慢的特点，线程安全，效率低，因此一般不常用。以下是它的一些常用的方法：

public void addElement(E obj)
public E elementAt(int index)
public Enumeration elements()

举例：

  Vector vector = new Vector();
        //Vector的遍历
        Enumeration elements=vector.elements();
        while (elements.hasMoreElements()){
            Object o = elements.nextElement();
            System.out.println(o);
        }

LinkedList类

底层是链表，查询慢，增删快，线程不安全，效率高.
其实它底层实现了双端队列，可以在队头队尾添加元素。

LinkedList类特有功能：
public void addFirst(E e)：添加元素至集合最前面
addLast(E e)：添加元素至集合最后面
public E getFirst()：获取第一个元素
getLast()；获取第二个元素
public E removeFirst()：移除第一个元素
public E removeLast()：移除第二个元素

  LinkedList linkedList=new LinkedList();
        linkedList.add(100);
        linkedList.add(200);
        linkedList.add(300);
        linkedList.add(400);
        linkedList.add(500);
        //检索该列表的第一个元素
        System.out.println(linkedList.peekFirst());//100
        //从这个列表所表示的堆栈中弹出第一个元素。
        System.out.println(linkedList.pop());//100
        System.out.println(linkedList);//[200, 300, 400, 500]
        //检索并移除此列表的第一个元素
        System.out.println(linkedList.pollFirst());//200
        System.out.println(linkedList);//[300, 400, 500]
        //列表头部插入一个元素
        linkedList.push("scq");
        System.out.println(linkedList);//[scq, 300, 400, 500]

小应用：
请用LinkedList模拟栈数据结构的集合，并测试

栈的特点：先进的后出，后进的先出。
        class MyList {

            //私有化只能类内访问
            private LinkedList linkedList;
            public MyList(){
                linkedList = new LinkedList();
            }
            public void add(Object obj){
                linkedList.addFirst(obj);
            }
            //外部通过get方法获取linkedList的元素，返回数据类型使用Object
            //从栈内获取一个元素 栈为先进先出，因此获取先进来的元素，并放到最后一个元素
            public Object get(){
                Object firstelement=linkedList.pop();
                linkedList.addLast(firstelement);//放到最后的位置，保持栈内元素不缺
                return firstelement;
            }
        }