集合(Ⅰ) ---------- Collection

最新推荐文章于 2025-03-24 20:40:03 发布

珀伽

最新推荐文章于 2025-03-24 20:40:03 发布

阅读量409

点赞数

CC 4.0 BY-SA版权

分类专栏： java基础

本文链接：https://blog.youkuaiyun.com/qq_25583079/article/details/49274413

java基础专栏收录该内容

13 篇文章

订阅专栏

一、集合

一个集合是代表一组对象的一个对象，集合中的这一组对象称为它的元素。集合主要来处理各种类型的对象的聚集。集合保留了对 Object 类的引用，因此，任何数据类型的对象都可以存放在集合中。
集合中包含3个重要接口： Collection、Set、List，它们都可以用来组织多个对象，但是又各不相同。

Collection 集中的对象存放没有顺序，而且允许重复。
Set 对象的无序聚集，但不允许重复。
List 有序的对象聚集，对象按照一定顺序存放，同时允许重复。
集合的继承关系如图：

二、Collection 接口

Collection 接口是单值存放的最大父接口，可以向其中保存多个单值（单个对象）数据。此接口定义如下方法：

boolean add(E e)         // 向集合中插入元素
boolean addAll(Collection<? extends E> c)    // 将一个集合的内容插入进来
void clear()   // 清除此集合中所有的元素
boolean contains(Object o)     // 判断某一个对象是否在集合中存在
boolean containsAll(Collection<?> c)   // 判断一组对象是否在集合中存在
boolean equals(Object o)   // 对象比较
int hashCode()   // 哈希码
boolean isEmpty()  // 集合是否为空
Iterator<E> iterator()  // 为 Iterator 接口实例化
boolean remove(Object o)   // 删除指定元素
boolean removeAll(Collection<?> c)  // 删除一组对象
boolean retainAll(Collection<?> c)  // 保存指定内容
int size()    // 求出集合的大小
Object[] toArray()   // 讲一个集合变成对象数据
<T> T[] toArray(T[] a)   // 指定好返回的对象数组类型

2.1 Collection 子接口

如果直接操作使用 Collection 接口，则表示操作意义不明确，所以在 Java 开发中不提倡使用直接操作 Collection 接口，主要子接口如下：
- List 可以存放重复的内容。
- Set 不能存放重复的内容，重复的内容靠 hashCode() 和 equals()两个方法区分。
- Queue 队列接口。
- SortedSet 可以对集合中的数据进行操作。

三、List 接口

与 Collection 接口不同的是，在 List 接口中大量地扩充了 Collection 接口，下面列出 List 中对象Collection 接口的扩展方法：

void add(int index, E element)    // 在指定位置增加元素
boolean addAll(int index, Collection<? extends E> c)   // 在指定位置增加一组元素
E get(int index)        // 返回列表中指定位置的元素。
int indexOf(Object o)   // 返回此列表中第一次出现的指定元素的索引
int lastIndexOf(Object o)   // 返回此列表中最后出现的指定元素的索引
ListIterator<E> listIterator()  // 为 ListIterator 接口实例化
E remove(int index)   // 移除列表中指定位置的元素
List<E> subList(int fromIndex, int toIndex)  // 取出集合的子集合
E set(int index, E element)   // 用指定元素替换列表中指定位置的元素

void add(int index, E element)    // 在指定位置增加元素
boolean addAll(int index, Collection<? extends E> c)   // 在指定位置增加一组元素
E get(int index)        // 返回列表中指定位置的元素。
int indexOf(Object o)   // 返回此列表中第一次出现的指定元素的索引
int lastIndexOf(Object o)   // 返回此列表中最后出现的指定元素的索引
ListIterator<E> listIterator()  // 为 ListIterator 接口实例化
E remove(int index)   // 移除列表中指定位置的元素
List<E> subList(int fromIndex, int toIndex)  // 取出集合的子集合
E set(int index, E element)   // 用指定元素替换列表中指定位置的元素

3.1 List 接口的常用子类

3.1.1 ArrayList

ArrayList 是 List 子类，可以直接通过对象的多态性为 List 接口实例化。

public class ArrayListDemo01 {
    public static void main(String[] args) {
        List<String> allList = null;    // 定义 List 对象
        Collection<String> allCollection = null;   // 定义 Collection 对象
        allList = new ArrayList<String>();    
        allCollection = new ArrayList<String>();
        // 向集合中添加元素
        allList.add("hello");
        allList.add(0, "world");   // List 扩展 Collection 的 add()方法
        System.out.println(allList);
        allCollection.add("HELLO");
        allCollection.add("WORLD");
        allList.addAll(allCollection);
        System.out.println(allList);
        // 删除元素
        allList.remove(0);   // List 扩展 Collection 的remove() 方法
        allList.remove("HELLO");
        System.out.println(allList);
        // 遍历元素
        for (int i = 0; i < allList.size(); i++) {
            System.out.println(allList.get(i));
        }
        // 将集合变成对象数组
        String[] strings = allList.toArray(new String[]{}); // allList.toArray()
        for (int i = 0; i < strings.length; i++) {
            System.out.println(strings[i]);
        }
    }
}

3.1.2 Vector

从整个 Java 的集合发展历史来看，Vector算是一个元老级的类，在JDK1.0时就已经存在此类。到了JDK1.2之后重点强调集合框架的概念，所以定义很多新接口（如List等），但是考虑一大部分用户已经习惯了使用 Vector 类，所以 Java 的设计者就让 Vector 类多实现了一个 List 接口，这才将其保留下来。由于其是 List 子类，所以 Vector 类的使用与之前的并没有太大的区别。

public class VectorDemo01 {
    public static void main(String[] args) {
        List<String> allList = null;
        allList = new Vector<String>();   
        // 直接使用的是 List 接口進行操作
        allList.add("hello");
        allList.add(0, "world");
        for (int i = 0; i < allList.size(); i++) {
            System.out.print(allList.get(i) + "   ");
        }
        System.out.println();
        System.out.println("---------------------");
        // 使用 Vector 類中的 addElement(E o) 方法，是最早的向集合中增加元素的操作
        Vector<String> vectors = new Vector<String>();
        vectors.addElement("pegasus");
        vectors.addElement("flyingdancing");
        Enumeration<String> enums = vectors.elements();
        while (enums.hasMoreElements()) {
            String value = enums.nextElement();
            System.out.println(value);
        }
    }
}

3.1.3 ArrayList 与 Vector 的区别

ArrayList 在 JDK1.2 之后推出的，属于新的操作类。采用异步处理方式，性能更高，属于非线程安全的操作类，只能使用 Iterator、foreach输出。
Vector 在 JDK1.0 时推出，属于旧的操作类。采用同步处理方式，性能较低，属于线程安全的操作类，可以使用 Iterator、foreach、Enumeration 输出。

3.1.4 LinkedList 子类与 Queue 接口

LinkedList 表示的是一个链表的操作类，此类实现了 List 接口，同时实现了 Queue 接口。Queue 表示的是队列操作接口，采用 FIFO（先进先出）的方式操作。
Queue 接口定义的方法

public E element()         // 找到链表的标表头
public boolean offer(E o)  // 将指定元素增加到链表的结尾
public E peek()            // 找到但并不删除链表的头
public E poll()            // 找到并删除此链表的头
public E remove()          // 检索并移除表头

LinkedList 类的主要方法

public void addFirst(E o)      // 在链表开头增加元素
public void addLast(E o)       // 在链表结尾增加元素
public boolean offer(E o)      // 将指定元素增加到链表的结尾
public E removeFirst()         // 删除链表的第一个元素
public E removeLast()          // 删除链表的最后一个元素

示例操作

public class LinkedListDemo01 {
    public static void main(String[] args) {
        LinkedList<String> linkedLists = new LinkedList<String>();
        linkedLists.add("A");
        linkedLists.add("B");
        linkedLists.add("C");
        System.out.println("初始化鏈表：" + linkedLists);
        linkedLists.addFirst("X");
        linkedLists.addLast("Y");
        System.out.println("增加頭和尾之後的鏈表：" + linkedLists);

        System.out.println("1-1、element() 方法找到表頭：" + linkedLists.element());
        System.out.println("2-1、peek()方法找到表頭：" + linkedLists.peek());
        System.out.println("2-2、找到之後的鏈表內容：" + linkedLists);
        System.out.println("3-1、poll()方法找到表頭：" + linkedLists.poll());
        System.out.println("3-2、找到之後的鏈表內容：" + linkedLists);

        System.out.println("以FIFO的方式輸出：");
        for (int i = 0; i < linkedLists.size(); i++) {
            System.out.print(linkedLists.get(i) + "、");
        }
    }
}

四、Set

Set 接口也是 Collection 接口的子接口，但与Collection 或 List 接口不同的是，Set 接口中不能加入重复的元素。Set 接口的实例无法像 List 接口那样可以进行双向输出，因为此接口没有提供像 List 接口的 get(int index) 方法。

4. 1 Set 接口的常用子类

4.1.1 HashSet

HashSet 线程不安全，存取速度快。可以通过元素的两个方法， hashCode 和 equals 来完成保证元素唯一性。如果元素的 hashCode 值相同，才会判断 equals 是否为 true 。如果元素的 hashCode 值不同，不会调用 equals。
示例：

public class HashSetDemo01 {
    public static void main(String[] args) {
        HashSet<Person> hs = new HashSet<Person>();
        hs.add(new Person("pegasus", 21));
        hs.add(new Person("mbyd", 16));
        hs.add(new Person("flyingdancing", 35));
        hs.add(new Person("wbjbaqblca", 10));
        hs.add(new Person("wbjbaqblca", 10));

        Iterator<Person> iterators = hs.iterator();
        while (iterators.hasNext()) {
            Person person = iterators.next();
            System.out.println(person.getName() + ", " + person.getAge());
        }
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
}

4.1.2 TreeSet

特点
a)、底层的数据结构为二叉树结构（红黑树结构）
b)、可对Set集合中的元素进行排序，是因为：TreeSet类实现了Comparable接口，该接口强制让增加到集合中的对象进行了比较，需要复写compareTo方法，才能让对象按指定需求进行排序，并加入集合。
注意：排序时，当主要条件相同时，按次要条件排序。
c)、保证数据的唯一性的依据：通过compareTo方法的返回值，是正整数、负整数或零，则两个对象较大、较小或相同。相等时则不会存入。

Tree排序的两种方式
a)、第一种排序方式：自然排序
让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也被称为元素的自然顺序，或者叫做默认顺序。
b)、第二种方式：比较器
当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。
在集合初始化时，就有了比较方式。定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
比较器构造方式：定义一个类，实现Comparator接口，覆盖compare方法。
当两种排序都存在时，以比较器为主。
示例：

public class TreeSetDemo01 {
    public static void main(String[] args) {
        TreeSet<Person> hs = new TreeSet<Person>(new LenCompare());
        hs.add(new Person("pegasus", 21));
        hs.add(new Person("mbyd", 16));
        hs.add(new Person("flyingdancing", 35));
        hs.add(new Person("wbjbaqblca", 10));
        hs.add(new Person("wbjbaqblca", 10));

        Iterator<Person> iterators = hs.iterator();
        while (iterators.hasNext()) {
            Person person = iterators.next();
            System.out.println(person.getName() + ", " + person.getAge());
        }
    }
}

class Person implements Comparable<Person> {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    @Override
    public int compareTo(Person o) {
        Person person = o;
        if (this.age == person.age) {
            return this.name.compareTo(person.name);
        }
        return this.age - person.age;
    }
}

// 定义一个比较器，以姓名长度为主要比较
class LenCompare implements Comparator<Person> {
    public int compare(Person o1, Person o2) {
        int num = new Integer(o1.getName().length()).compareTo(new Integer(o2.getName().length()));
        if (num == 0) {
            return new Integer(o1.getAge()).compareTo(o2.getAge());
        }
        return num;
    }
}

4.1.3 HashSet 与 TreeSet 区别

1、TreeSet 是二差树实现的,Treeset中的数据是自动排好序的，不允许放入null值。
2、HashSet 是哈希表实现的,HashSet中的数据是无序的，可以放入null，但只能放入一个null，两者中的值都不能重复，就如数据库中唯一约束。
3、HashSet要求放入的对象必须实现HashCode()方法，放入的对象，是以hashcode码作为标识的，而具有相同内容的String对象，hashcode是一样，所以放入的内容不能重复。但是同一个类的对象可以放入不同的实例。