Java基础知识(九)

12 集合

12.1集合概述

（1）集合是存储其他对象的特殊对象。可以将集合当做一个容器。

（2）集合的相关接口和类位于java.util包中

（3）集合中的接口和类是一个整体、一个体系。

list:有序可重复

set接口无序不可重复

12.2 集合接口

接口定义了一组抽象方法，实现该接口的类需要实现这些抽象方法，从而实现接口的类就具备了接口所规定的行为（功能）。

集合框架定义了一些接口，它们决定了集合类的本质特性。具体的集合类只是提供了标准接口的不同实现。

接 口	描 述
Collection	允许操作一组对象，它位于集合层次结构的顶部
List	扩展Collection，以处理序列(对象列表)
Set	扩展Collection，以处理组，组中的元素必须唯一

注意：

Set类型的集合（实现Set接口的类）称为集，有些资料称为组，其特点是组中的元素必须唯一。

12.2.1 Collection**接口**

Collection接口是构建集合框架的基础，Collection是泛型接口，其声明如下：

interface Collection<E>，

其中，E指定了集合将存储的对象类型。

提示：

l 集合中只能存储对象，不能存基本类型。

l 使用泛型的优点是在编译时可以检查元素的类型，从而更加安全。

Collection接口扩展了Iterable接口。这意味着所有集合都可以使用for-each风格的for循环进行遍历。

1、Collection接口中没有提供修改元素的方法。

2、Collection接口的父接口是Iterable接口，实现了Iterable接口的类是可以迭代的。

12.2.2 List接口<重复有序 >

List接口扩展了Collection，并且声明了存储一连串元素的集合的行为。在列表中，可以使用从0开始的索引，通过它们的位置插入或访问元素。列表可以包含重复的元素。其声明如下：

List接口中操作元素的方法许多都提供了index参数，这是与Collection接口中所提供相关方法的主要区别

Arraylist类

ArrayList实现了List接口。本质上是元素为对象引用的长度可变的数组。

构造方法：

l ArrayList( ) //长度取默认值 10

l ArrayList(int capacity) //指定长度，容量

泛型：

T ：代表一般的任何类。

E ：代表 Element 元素的意思，或者 Exception 异常的意思。

K ：代表 Key 的意思。

V ：代表 Value 的意思，通常与 K 一起配合使用。

  
{
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        Date date = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd");
        String format = simpleDateFormat.format(date);
        arrayList.add(format);
        arrayList.add(2023);
        arrayList.add("年");
        arrayList.add('c');
        System.out.println(arrayList);
​
        arrayList.add(3,2);
        arrayList.get(3);
        arrayList.add(4,"月");
        System.out.println(arrayList);
        arrayList.add(format);
        arrayList.add(2023);
        arrayList.add("年");
        arrayList.add('c');
        arrayList.add(format);
        arrayList.add(2023);
        arrayList.add("年");
        arrayList.add('c');
        System.out.println(arrayList);
        arrayList.remove(2);
        System.out.println(arrayList);
        arrayList.remove("月");
        System.out.println(arrayList);
        System.out.println(arrayList.lastIndexOf('c'));
        System.out.println(arrayList.indexOf(format));
        System.out.println(arrayList.size());
        System.out.println(arrayList.isEmpty());
        ArrayList arrayList1 = new ArrayList();
        arrayList1.addAll(arrayList);
        System.out.println(arrayList1);
        arrayList1.add(3,arrayList);
        System.out.println(arrayList1);
//        arrayList1.add(arrayList);
//        System.out.println(arrayList1);
//        arrayList1.addAll(arrayList);
//        System.out.println(arrayList);
        System.out.println(arrayList1.contains(3));
    }
}

输出:

[2024/02/21, 2023, 年, c] [2024/02/21, 2023, 年, 2, 月, c] [2024/02/21, 2023, 年, 2, 月, c, 2024/02/21, 2023, 年, c, 2024/02/21, 2023, 年, c] [2024/02/21, 2023, 2, 月, c, 2024/02/21, 2023, 年, c, 2024/02/21, 2023, 年, c] [2024/02/21, 2023, 2, c, 2024/02/21, 2023, 年, c, 2024/02/21, 2023, 年, c] 11 0 12 false [2024/02/21, 2023, 2, c, 2024/02/21, 2023, 年, c, 2024/02/21, 2023, 年, c] [2024/02/21, 2023, 2, [2024/02/21, 2023, 2, c, 2024/02/21, 2023, 年, c, 2024/02/21, 2023, 年, c], c, 2024/02/21, 2023, 年, c, 2024/02/21, 2023, 年, c] false

LinkedList

inkedList类实现了List、Deque以及Queue接口。它提供了（双向）链表数据结构。

LinkedList具有两个构造方法：

LinkedList( )

LinkedList(Collection<? extends E> c)

ArrayList与LinkedList的区别：

1、ArrayList是基于数组结构的集合，有容量的概念；LinkedList是基于链表结构的集合，没有容量的概念

2、对于随机访问（get和set方法），ArrayList优于LinkedList，因为LinkedList要移动指针。

3、对于新增和删除操作（add和remove方法），LinkedList比较占优势，因为ArrayList要移动数据。但是如果只是在末尾追加元素，并且没有超出容量限制，则ArrayList的性能更好。不关容量的情况，效率差不多。

4、LinkedList 还实现了Queue接口,该接口比List提供了更多的方法,包括 offer(),peek(),poll()等。

LinkedList list = new LinkedList();
list.add(2);
list.add("大哥你好");
list.add('c');
Date date = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
String format = simpleDateFormat.format(date);
list.add(format);
System.out.println(list);
​
LinkedList list1 = new LinkedList();
list1.addAll(list);
System.out.println(list1);
list1.addAll(2, list);
System.out.println(list1);
​
list1.addFirst("a");
System.out.println(list1);
​
list1.addLast("范一凡大哥");
System.out.println(list1);
​
System.out.println(list1.contains("a"));
​
System.out.println(list1.element());
System.out.println(list1);
​
System.out.println(list1.get(3));
​
System.out.println(list1.lastIndexOf('c'));
System.out.println(list1.remove());
System.out.println(list1);
System.out.println(list1.removeFirst());
System.out.println(list1);
list1.set(1, "范一凡");
System.out.println(list1);

输出:[2, 大哥你好, c, 24-2-21 下午8:34] [2, 大哥你好, c, 24-2-21 下午8:34] [2, 大哥你好, 2, 大哥你好, c, 24-2-21 下午8:34, c, 24-2-21 下午8:34] [a, 2, 大哥你好, 2, 大哥你好, c, 24-2-21 下午8:34, c, 24-2-21 下午8:34] [a, 2, 大哥你好, 2, 大哥你好, c, 24-2-21 下午8:34, c, 24-2-21 下午8:34, 范一凡大哥] true a [a, 2, 大哥你好, 2, 大哥你好, c, 24-2-21 下午8:34, c, 24-2-21 下午8:34, 范一凡大哥] 2 7 a [2, 大哥你好, 2, 大哥你好, c, 24-2-21 下午8:34, c, 24-2-21 下午8:34, 范一凡大哥] 2 [大哥你好, 2, 大哥你好, c, 24-2-21 下午8:34, c, 24-2-21 下午8:34, 范一凡大哥] [大哥你好, 范一凡, 大哥你好, c, 24-2-21 下午8:34, c, 24-2-21 下午8:34, 范一凡大哥]

总结:

集合只能存储对象,不能存储数据类型

使用泛型的优点是在编译时可以检查元素的类型，从而更加安全。

T ：代表一般的任何类。

E ：代表 Element 元素的意思，或者 Exception 异常的意思。

K ：代表 Key 的意思。

V ：代表 Value 的意思，通常与 K 一起配合使用。

list:有序可重复

set接口无序不可重复

ArrayList与LinkedList的区别：

ArrayList是基于数组结构的集合，有容量的概念；LinkedList是基于链表结构的集合，没有容量的概念

linkedlist没有扩容机制

ArrayLis有扩容 1.5倍 初始10

ArrayList可以直接定位在哪里

LinkedList必须遍历一遍

12.3 set接口<无序不可重复>

12.3.1HashSet接口

Set接口定义了组/集/集合(set)。它扩展了Collection接口，并声明了不允许重复元素的集合的行为。如果为集合添加重复的元素，add()方法会返回false。声明如下：

interface Set<E>

Set接口没有添加自己的方法。

SortedSet接口扩展了Set接口，并且声明了以升序进行排序的集合的行为。

interface SortedSet<E>

SortedSet定义了一些便于进行集合处理的方法。例如，为了获得集合中的第一个对象，可以调用first()方法。为了得到最后一个元素，可以使用last()方法。

NavigableSet接口扩展了SortedSet接口，并且该接口声明了支持基于最接近匹配原则检索元素的集合行为。

注意：

Set相关接口表示的集合没有索引的概念。

12.3.3 HashSet

HashSet类实现了Set接口。该类在内部使用哈希表存储元素。

哈希表使用称之为散列法(hashing)的机制存储信息。哈希法的优点是add()、contains()、remove()以及size()方法的执行时间保持不变，即使是对于比较大的集合也是如此。

HashSet( ) //默认容量是16

HashSet(int capacity)

HashSet(int capacity, float fillRatio) //填充率：0.0-1.0之间，默认0.75

HashSet(Collection<? extends E> c)

HashSet中元素不是按有序的顺序存储的，遍历输出HashSet中的元素时精确的输出可能不同。

12.3.4 LinkedHashSet类

LinkedHashSet类扩展了HashSet类，它没有添加它自己的方法。

LinkedHashSet在内部使用一个链表维护元素添加到集合中的顺序，因此可以按照插入顺序迭代集合。

12.3.4 .1TreeSet类

TreeSet类实现了NavigableSet接口，该类在内部使用树结构存储元素。元素以升序存储，访问和检索相当快。TreeSet适合于存储大量的、必须能够快速查找到的有序信息。

Set与List的区别：

1、Set中的元素无序不能重复，List中的有序元素可以重复。

2、List有索引（下标）的概念，Set没有索引的概念。

3、对于Set表示的集合，通常是遍历操作，没有get()和set()方法。

注意：

TreeSet以升序保存对象，所以TreeSet中保存的对象比较能够比较大小，即TreeSet保存的对象类型必须实现Comparable接口。

注意：

HashSet是无序的，LinkedHashSet和TreeSet是有序的。

例如:

package com.xszx.test;
​
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.TreeSet;
​
​
public class Test_set {
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
        hashSet.add("你好小帅");
        hashSet.add("你好小帅");
        hashSet.add(111);
        hashSet.add(141);
        hashSet.add(151);
        hashSet.add(124);
        System.out.println(hashSet.add("你好"));
        hashSet.add(123);
        System.out.println(hashSet);
        hashSet.remove(123);
        System.out.println(hashSet);
        System.out.println(hashSet.size());
//按照输入顺序排序
        LinkedHashSet link= new LinkedHashSet();
        link.add(123);
        link.add(456);
        link.add(416);
        link.add(256);
        link.add(656);
        System.out.println(link);
        System.out.println(link.remove(123));
        TreeSet treeSet = new TreeSet();
        treeSet.add(123);
        treeSet.add(456);
        treeSet.add(416);
        treeSet.add(256);
        treeSet.add(656);
        System.out.println(treeSet);
        System.out.println(" 返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。"+treeSet.ceiling(123));
        System.out.println("返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回 null。"+treeSet.comparator());
        System.out.println(" 如果此 set 包含指定的元素，则返回 true。"+treeSet.contains(1));
        System.out.println("返回此 set 中当前第一个（最低）元素。"+treeSet.first());
        System.out.println("返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。"+treeSet.floor(420));
        System.out.println(treeSet.last());//返回此 set 中当前最后一个（最高）元素。
        System.out.println(treeSet.lower(250));//返回此 set 中当前最后一个（最高）元素。;
        System.out.println(treeSet.higher(250));//返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。
​
    }
}

12.4 集合遍历

12.4.1 增强for循环

如果不修改集合的内容，也不以反向获取元素，则使用for-each版的for循环遍历集合通常比使用迭代器更方便。

例如:

for (String studentName : set) {
    if (studentName.equals(name)) {
        b = true;
        ArrayList<Clbum> studentList = clbum.get(studentName);
        if (studentList.isEmpty()) {
            System.out.println("暂时没有学生快去添加新同学吧!");
        } else {
            for (Clbum clbumName : studentList) {
                System.out.println(clbumName);
            }
        }
        new ClbumOperationCnotroller().operation();
        break; // 结束循环，无需继续遍历班级列表
    }
}

12.4.2 Iterable接口

实现了Iterable接口的类是可以遍历的。因为Iterable接口是Collection接口的父接口，而所有集合类都实现了Collection接口，从而也都实现了Iterable接口，所以所有集合类都是可以遍历的。

Iterable接口只定义了一个方法：

Iterator<T> iterator() //返回迭代器对象

既然所有集合都实现了Iterable接口，所以所有集合类都重写了iterator()方法以返回一个迭代器对象。

12.4.3 Iterator接口

Iterator接口描述了迭代器的行为，所有迭代器类都必须实现该接口，该接口定义了一下方法：

l boolean hasNext() 如果迭代还有更多的元素则返回true

l T next() 返回下一个元素

l void remove() 删除迭代器返回的元素

提示：

从Iterator接口定义的方法不难看出Iterator只能从前向后进行遍历。

12.4.4 ListIterator接口

Iterator接口有一个子接口ListIterator，ListIterator接口即可以从前向后遍历，也可以从后向前遍历集合。只有实现了List接口的集合类才提供了ListIterator迭代器。

List接口提供以下两个方法用于获取列表集合的列表迭代器：

ListIterator<E> listIterator() 该迭代器从列表的开头开始

ListIterator<E> listIterator()(int index) 该迭代器从index所指定的位置开始

ListIterator接口定义了以下常用方法。

l boolean hasNext()

l Boolean hasPrevious()

l E next()

l int nextIndex()

l E previous()

l int previousIndex()

12.4.5 使用迭代器

通常，为了使用迭代器遍历集合的内容，需要以下步骤：

1．通过调用集合的Iterator()方法，获取指向集合开头的迭代器。

2．建立一个hasNext()调用循环。只要hasNext()返回true，就循环迭代。

3．在循环中，通过调用next()获取每个元素。

对于实现了List接口的集合，还可以调用listIterator()获取迭代器。列表迭代器提供了向前和向后两个方向访问集合的能力，并且允许修改元素。

迭代器与增强的for循环之间的区别：

使用迭代器遍历集合时，可以调用Iterator.remove()方法删除集合中元素，使用增强的for循环遍历集合时，不能删除集合中的元素。

可以使用增强的for循环遍历数组，但是数组不支持迭代器。

使用增强的for循环遍历基本类型的数组时，只能使用数组元素，而不能修改数组元素。

12.5Collections**工具类**

12.5.1 C**ollections类里面包括动态、有序、可变大小的一维数组Vector与ArrayList。**

Collections提供以下方法对List进行排序操作

void reverse(List list)：反转

void shuffle(List list),随机排序

void sort(List list),按自然排序的升序排序

void sort(List list, Comparator c);定制排序，由Comparator控制排序逻辑

void swap(List list, int i , int j),交换两个索引位置的元素

12.6 遗留的集合类和接口

在集合之前，Java提供了特定的类，存储和管理对象组，例如Dictionary、Vector、Stack和Properties。

早期版本的java.util包没有包含集合框架。反而，定义了几个类和接口，提供存储对象的专门方法。当添加集合时(由J2SE 1.2添加)，对几个原始类进行了重新设计，以支持集合接口。因此，从技术上讲它们现在是集合框架的组成部分。

前面介绍的所有现代集合类都不是同步的，但是所有遗留类都是同步的。

12.6.1 Vector类

现在Vector类实现了动态数组，与ArrayList类似，也实现List接口。但有如下区别：

l Vector实现同步，线程安全。ArrayList没有实现线程安全。

l Vector性能比ArrayList低。

l Vector和ArrayList在更多元素添加进来时会请求更大的空间。Vector每次请求其大小的双倍空间，而ArrayList每次对size增长50%.

项目分层

beans//实体类

controller//控制层

dao //持久层/数据层

service //业务层

test //测试层

util //工具类