JAVASE-17：集合Collection、List

最新推荐文章于 2024-09-14 16:33:10 发布

绝世球王秃光光

最新推荐文章于 2024-09-14 16:33:10 发布

阅读量228

点赞数

分类专栏： JavaSE 文章标签： java 队列链表

本文链接：https://blog.csdn.net/Hannen/article/details/107805754

版权

JavaSE 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

集合

数组作为容器的不好之处就是对容器中的元素进行操作时，不够方便，比如要增删数组中的元素，就不是那么方便了，因为数组一单定义，长度就不能改变了，JAVA为了我们更方便去操作容器中的元素，提供了一种新的容器，叫做集合。

1.数组长度一单定义就固定了，集合长度是可变的；

2.数组既可以存储基本数据类型，也可以存储引用数据类型，集合只能存储引用数据类型；

3.数组只能存储同类型元素，集合可以存储不同类型的元素。

Collection集合继承体系图：

在这里插入图片描述

Collection的功能概述

添加功能
boolean add(Object obj): 添加一个元素只能存储引用数据类型
boolean addAll(Collection c): 添加一个集合的元素 (给一个集合添加进另一个集合中的所有元素)

public static void main(String[] args) {
    Collection collection = new ArrayList();
    //往集合中添加元素
    boolean b = collection.add("张曼玉");
    collection.add("钟楚红");
    collection.add("张敏");
    collection.add("毛舜筠");
    System.out.println(collection);
    // [张曼玉, 钟楚红, 张敏, 毛舜筠]
    
    int num=300;
    Collection collection1 = new ArrayList();
    collection1.add(100);// 100这里是引用类型
    collection1.add(num);// 不会报错，因为自动拆装箱机制
    collection1.add(Integer.valueOf(400));
}

public static void main(String[] args) {
    Collection collection = new ArrayList();
    collection.add(100);
    collection.add(200);
    Collection collection2 = new ArrayList();
    collection2.add(300);
    collection2.add(400);
    // 把两个集合中的元素，归并到一个集合里面去 返回值是有没有添加成功
    boolean b = collection.addAll(collection2);
    System.out.println(collection);//[100, 200, 300, 400]
    System.out.println(collection2);//[300, 400] 第二个集合元素不会变
}

删除功能
void clear(): 清空集合中所有元素
boolean remove(Object o): 移除一个元素

public static void main(String[] args) {
    Collection collection = new ArrayList();
    collection.add(100);
    collection.add(200);
    //删除集合中的某个元素
    collection.remove(100);
    System.out.println(collection);
    //清空集合中的所有元素
    collection.clear();
}

boolean removeAll(Collection c):

如果没有交集元素，则删除失败，返回false，但两个集合中元素都不会不变化；

如果有交集元素，移除一个集合的元素(移除一个以上返回的就是true) 移除的元素是两个集合的交集元素，括号内的集合不会变化。

（All—对两个集合操作）

public static void main(String[] args) {
    Collection collection = new ArrayList();
    collection.add(100);
    collection.add(200);
    collection.add(500);
    Collection collection2 = new ArrayList();
    collection2.add(100);
    collection2.add(200);
    collection2.add(300);
    collection2.add(400);
    boolean b = collection.removeAll(collection2);
    System.out.println(b);//true
    System.out.println(collection);//[500]
    System.out.println(collection2);//[100, 200, 300, 400]
}

判断功能
boolean contains(Object o)：判断集合中有没有某个元素

boolean isEmpty()：判断集合是否为空（类似字符串中.isEmpty()）

public static void main(String[] args) {
    Collection collection = new ArrayList();
    collection.add(100);
    collection.add(200);
    collection.add(500);
    //contains(1000) 判断集合中有没有该元素
    System.out.println(collection.contains(1000));
    //判断集合是否为空
    System.out.println("".isEmpty());
    collection.clear();
    System.out.println(collection.isEmpty());
}

boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(这个集合包含另一个集合中所有的元素才算包含才返回true)

遍历获取迭代器

获取功能
Iterator iterator() (重点)
长度功能
int size(): 元素的个数

public static void main(String[] args) {
    Collection collection = new ArrayList();
    collection.add(100);
    collection.add(200);
    collection.add(300);
    collection.add(400);
    collection.add(500);
    System.out.println(collection.size());
    // 遍历集合中的元素
    // Iterator 接口 对 collection 进行迭代的迭代器，迭代器
    Iterator iterator = collection.iterator();
    System.out.println(iterator);// java.util.ArrayList$Itr@1540e19d
    // ArrayList$Itr@1b6d3586  //内部类Itr实现了Iterator 接口
    // 为什么把迭代器 Itr 设计为内部类---可以直接访问外部类的成员
    /*方法摘要
    boolean hasNext ()
    如果仍有元素可以迭代，则返回 true。
    E next ()
    返回迭代的下一个元素。*/
    while (iterator.hasNext()){
        Object obj = iterator.next();
        System.out.println(obj);
    }
}

练习：

public static void main(String[] args) {
    Student s1 = new Student("张三", 23);
    Student s2 = new Student("李四", 24);
    Student s3 = new Student("王五", 25);
    Student s4 = new Student("王五4", 25);
    Collection collection = new ArrayList();
    collection.add(s1);
    collection.add(s2);
    collection.add(s3);
    collection.add(s4);

    Iterator iterator = collection.iterator();
    while (iterator.hasNext()){
        Student student = (Student) iterator.next();// 向下转型
        System.out.println(student.getName() + "==" + student.getAge());
    }

交集功能
例如：A集合对B集合取交集，获取到的交集元素存在A集合中。返回的布尔值表示的是A集合是否发生变化。如果没有交集元素，A会变空。

boolean retainAll(Collection c): 获取两个集合的交集元素(交集：两个集合都有的元素)

public static void main(String[] args) {
    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);
    boolean b = collection.retainAll(collection2);
    System.out.println(b);//true
    System.out.println(collection);//[200]
    System.out.println(collection2);//[100, 200, 300, 400]
}

把集合转换为数组 Object[] toArray()

public static void main(String[] args) {
    Collection collection = new ArrayList();
    collection.add(1000);
    collection.add(200);
    collection.add(300);
    collection.add(400);
    collection.add(500);
    /* 
    定义数组，Object类型，全是引用类型，长度是集合size
    Object[] objArr=new Object[collection.size()];
    Iterator iterator = collection.iterator();
    int index=0;
    while (iterator.hasNext()) {
        Object obj = iterator.next();
        objArr[index]=obj;
        index++;
    }
    System.out.println(Arrays.toString(objArr));*/
    
    //toArray(); 把集合转换为数组
    Object[] objects = collection.toArray();
}

List

元素有序（存的顺序和取的顺序一致），允许元素重复，并且每一个元素都存在一个索引（从0开始）。

List集合的特有功能：

void add(int index,E element)
在指定索引处添加元素

E get(int index)
获取指定索引处的元素

public static void main(String[] args) {
    // 多态
    List list = new ArrayList();
    list.add(100);
    list.add(200);
    list.add(300);
    list.add(400);
    // 在指定索引出添加元素
    list.add(0,500);
    System.out.println(list);
    
    // get(list.size() - 1); 通过索引来获取集合中的元素
    Object obj = list.get(list.size() - 1);// 获取最后一个元素
    System.out.println(obj);// 想要用可以向下转型成intager
    System.out.println(list);
}

E remove(int index)
移除指定索引处的元素返回的是移除的元素

public static void main(String[] args) {
    List list = new ArrayList();
    list.add("aaa");
    list.add("bbb");
    list.add("ccc");
    list.add("ddd");
    //根据元素来删除
    list.remove("aaa");
    //根据索引来删除集合中的元素
    list.remove(2);
    System.out.println(list);
}

注：如果索引和元素区分不出来，可以把元素包装一下。

public static void main(String[] args) {
    List list = new ArrayList();
    list.add(100);
    list.add(100);
    list.add(200);
    list.add(300);
    //IndexOutOfBoundsException: Index: 100, Size: 4
    //list.remove(100);
    //如果索引和元素区分不出来，可以把元素包装一下。
    list.remove(Integer.valueOf(100));
    System.out.println(list);
    
    //替换集合中的元素 返回的是被替换的那个旧元素
    Object oldEle = list.set(list.size() - 1, 3000);
    System.out.println(list);//[100, 200, 3000]
    System.out.println(oldEle);//300

    int index = list.indexOf(100);
    System.out.println(index);//0
}

E set(int index,E element)
替换指定索引处的元素，返回的而是被替换的元素

int indexOf(Object o)
返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。

int lastIndexOf(Object o)
返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。

遍历List集合（三种方式）：使用for循环通过size()和get()方法结合使用遍历。

public static void main(String[] args) {
    List list = new ArrayList();
    list.add(100);
    list.add(200);
    list.add(300);
    list.add(400);

    //1.get()
    for (int i = 0; i < list.size(); i++) {
        Object o = list.get(i);
        System.out.println(o);
    }
    System.out.println("==========================");

    //2.使用父接口的迭代器
    Iterator iterator = list.iterator();
    while (iterator.hasNext()){
        Object obj=iterator.next();
        System.out.println(obj);
    }
    System.out.println("==========================");

    //2.List 集合 也有自己的一个迭代器list.listIterator()
    ListIterator listIterator = list.listIterator();
    System.out.println(listIterator);
    while (listIterator.hasNext()) {
        Object next = listIterator.next();
        System.out.println(next);
    }
}

ListIterator，继承自Iterator，可以使用Iterator中的方法

ListIterator的特有功能

boolean hasPrevious()
是否存在前一个元素

E previous()
返回列表中的前一个元素

以上两个方法可以实现反向遍历，但是注意，要完成反向遍历之前，要先进行正向遍历，这样指针才能移到最后，如果直接反向遍历是没有效果的，因为指针默认位置就在最前面，他前面没有元素。

public static void main(String[] args) {
    List list = new ArrayList();
    list.add(100);
    list.add(200);
    list.add(300);
    list.add(400);
    ListIterator listIterator = list.listIterator();
    while (listIterator.hasNext()) {
        Object obj = listIterator.next();
        System.out.println(obj);
    }
    System.out.println("==============================");
    /* listIterator.next();
    System.out.println(listIterator.hasPrevious());
    Object o = listIterator.previous();
    System.out.println(o);*/
    // 进行反向迭代时，先要正向迭代。
    // ListIterator listIterator2 = list.listIterator();
    while (listIterator.hasPrevious()) {
        Object o = listIterator.previous();
        System.out.println(o);
    }
}

并发修改异常

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

public static void main(String[] args) {
    List list = new ArrayList();
    list.add("world");
    list.add("aaa");
    list.add("bbb");
    /* 一般做法：
    if (list.contains("world")) {
        list.add("javaee");
    }
    System.out.println(list);
    */
    
    //  使用迭代器遍历
    //  ConcurrentModificationException 并发修改异常
    //  我们用Iterator这个迭代器遍历采用hasNext方法和next方法，集合修改集合 会出现并发修改异常
    // 原因是我们的迭代依赖与集合 当我们往集合中添加好了元素之后 获取迭代器  那么迭代器已经知道了集合的元素个数
    // 这个时候你在遍历的时候又突然想给 集合里面加一个元素（用的是集合的add方法） 那迭代器不同意 就报错了
    ListIterator listIterator = list.listIterator();
    while (listIterator.hasNext()) {
        if (listIterator.next().equals("world")) {
           list.add("javaee");
        }
    }

ConcurrentModificationException出现原因
我们用Iterator这个迭代器遍历采用hasNext方法和next方法，集合修改集合，会出现并发修改异常。
原因是我们的迭代依赖与集合当我们往集合中添加好了元素之后，获取迭代器，那么迭代器已经知道了集合的元素个数。
这个时候你在遍历的时候又突然想给，集合里面加一个元素（用的是集合的add方法），那迭代器不同意就会报错了。

解决方案

解决方案1：
我们用ListIterator迭代器遍历，用迭代器自带的add方法添加元素那就不会报错了
a:迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)
b:集合遍历元素，集合修改元素

解决方案2：使用for循环遍历集合添加元素不会报错

public static void main(String[] args) {
    List list = new ArrayList();
    list.add("world");
    list.add("aaa");
    list.add("bbb");
    
	ListIterator listIterator = list.listIterator();
	while (listIterator.hasNext()) {
    	if (listIterator.next().equals("world")) {
       	 	//解决方式1：使用迭代器自带的添加删除元素的方法
        	listIterator.add("javaee");
        	//删除可以用listIterator.remove("XXXX");
    	}
	}

	System.out.println("=======================================");

	//解决方式2：用for循环
	for (int i = 0; i < list.size(); i++) {
    	if (list.get(i).equals("world")) {
        	list.add("javaee");
   	 	}
	}
	System.out.println(list);
}

截取功能.subList()

list.subList(0, 2); 根据起始索引和终止索引，截取集合中的一部分元素，放到一个新集合中。

public static void main(String[] args) {
    List list = new ArrayList();
    list.add("world");
    list.add("aaa");
    list.add("bbb");
    List list1 = list.subList(0, 2); //含头不含尾
    System.out.println(list1);