Java 集合

Java 集合

1. Collection集合（单列集合）

集合概述

• 集合：集合是Java提供的一种容器，可以用来存储多个数据。
• 数组的长度是固定的，而集合的长度是可变的。
• 数组中存储的是同一类型的元素，可以存储基本类型的值。集合存储的都是对象，是引用类型，而且对象的类型可以不一样。在开发中一般当对象多的时候，使用集合进行存储。

集合的架构

Collection常用的方法

Collection是所有单列集合的父接口，因此在Collection中定义了单列集合（list和set）通用的一些方法，这些方法可用于操作所有的单列集合，共性方法如下：

• public boolean add(E e)：把给定的对象添加到当前集合当中。
• public void clear()：清空集合当中所有的元素。
• public boolean remove(E e)：把给定的对象从当前集合当中删除。
• public boolean contains (E e)：判断当前集合中是否包含给定的对象。
• public boolean isEmpty(E e)：判断当前集合是否为空。
• public int size()：返回集合中元素的个数。
• public Object[] toArray()：把集合中的元素，存储到数组中。

import java.util.ArrayList;
import java.util.Collection;
/*
public boolean add(E e);
public void clear();
public boolean remove(E e);
public int size();
public boolean isEmpty();
public Object[] toArray();
public boolean contains(E e);
 */

public class DemoCollection {
    public static void main(String[] args) {
        Collection coll = new ArrayList<>();
        System.out.println(coll);

        // add 添加元素
        coll.add("迪丽热巴");
        coll.add("古力娜扎");
        coll.add("马尔扎哈");
        coll.add("鹿晗");
        coll.add("赵丽颖");

        System.out.println(coll);

        // isEmpty 判断是否为空
        System.out.println(coll.isEmpty());

        // size 当前集合的大小
        System.out.println(coll.size());

        // remove 清除一个元素
        coll.remove("马尔扎哈");

        // Object[] toArray
        Object[] objects = coll.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }
        
        // contains 判断当前集合是否包含给定的对象
        boolean b1 = coll.contains("赵丽颖");
        System.out.println(b1);

        // clear 清空集合中的元素，但集合仍然存在，只不过为空
        coll.clear();
        System.out.println(coll.isEmpty());
    }
}

Iterator

• 迭代：即Collection集合元素的通用获取方式。在取元素之前先判断集合中有没有元素，如果有，就把这个元素取出来，再继续判断，如果还有就再取出来。一直把集合中所有元素取出。这种取出的方式专业术语称为迭代。
• java.util.Iterator接口：迭代器（对集合进行遍历）

有两个常用的方法

1. public boolean hasNext()：判断集合当中还有没有下一个元素，有就返回true，没有就返回false。
2. public E next()：取出集合当中的下一个元素。

Iterator迭代器，是一个接口，我们无法直接使用，需要使用Iterator接口的实现类对象，获得实现类的方式比较特殊，Collection接口中有一个方法，叫iterator()，这个方法返回的就是迭代器的实现对象。

• Iteratoriterator()：返回在此 Collection 的元素上进行迭代的迭代器。

Iterator迭代器的使用步骤：

1. 使用集合当中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接受（多态）。
2. 使用Iterator接口当中的方法hasNext()判断还有没有下一个元素。
3. 使用Iterator接口当中的方法next()取出集合当中的下一个元素。

注意事项：
Iterator接口也是有泛型的，迭代器的泛型跟着集合走，集合是什么泛型，迭代器就是什么泛型。

迭代器的实现原理

public class DemoCollection {
    public static void main(String[] args) {
        Collection coll = new ArrayList<>();

        coll.add("迪丽热巴");
        coll.add("马儿扎哈");
        coll.add("赵丽颖");
        coll.add("鹿晗");
        
        Iterator it = coll.iterator();

        while (it.hasNext()){
            String str = it.next();
            System.out.println(str);
        }
    }
}

• coll.iterator()：获取集合的实现类对象，并且会把指针（索引）指向集合的-1索引。
• it.hasNext()：判断集合还有没有下一个元素。
• it.next()：做了两件事
  1. 取出下一个元素
  2. 会把指针向后移动一位

2. 增强for（for each）

• 增强for循环（也称 for each循环）是JDK 1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。
• public interface Collectionextends Iterable：所有的单列 集合都可以使用增强for。

• public interface Iterable实现这个接口允许对象成为 "foreach" 语句的目标。

• 格式：

for (元素的数据类型 变量名称 : Collection集合 or 数组){
        // 写操作代码
}

注意事项：

1. 不要在遍历的过程中对集合元素进行增删操作。
2. 增强 for循环必须有被遍历的对象，目标只能是Collection集合或者数组，新式for仅仅作为遍历操作出现。

3. 泛型(Generic)

泛型概念

泛型是一种未知的数据类型，当我们不知道使用什么数据类型的时候，就可以使用泛型。
泛型也可以看作是一个变量，用来接受数据类型。

E e：Element 元素
T t：Type 类型

创建集合对象的时候，就会确定泛型的数据类型。

使用泛型的好处

创建集合对象，不使用泛型

• 好处：集合不使用泛型，默认的类型就是Object类型，可以存储任意类型的数据。
• 弊端：不安全，容易引发异常。

创建集合，使用泛型

• 好处 ：
  1. 避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型。
  2. 把运行期异常（代码运行之后会抛出的异常），提升到了编译期（写代码的时候会报错）。
• 弊端：
  泛型是什么类型，只能存储什么类型。

定义含有泛型的类

• 格式：

修饰符 class 类名<泛型>{
        // ...
}

• 示例：

public class GenericClass  {
    private E name;

    public void setName(E name){
        this.name = name;
    }

    public E getName(){
        return this.name;
    }
}

定义含有泛型的方法

泛型定义在方法的修饰符和返回值类型之间

• 格式：

修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
        // ...
}

• 示例：

public class GenericMethod {
    // 定义泛型普通方法
    public  void methodNormal(E e){
        System.out.println(e);
    }
    // 定义泛型静态方法
    public static  void methodStatic(E e){
        System.out.println(e);
    }
}

定义含有泛型的接口

• 格式：

修饰符 interface 接口名称<泛型>{
        // ...
}

1. 第一种使用方式：定义接口的实现类，实现接口，指定接口的泛型。

public interface Iterator``{
    E next();
}

Scanner类实现了Iterator接口，并指定接口的泛型为String，所以重写的next方法泛型默认就是String。

public final class Scanner implements Iterator{
    public String next();
}

1. 第二种使用方式：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走，就相当于定义了一个含有泛型的类，创建对象的时候确定泛型的类型。

public class ArrayListimplements List{
    public boolean add(E e);
    public E get(int index);
}

public interface List extends Collection {
    boolean add(E e);
    E get(int index);
}

泛型的通配符

• ？：代表任意的数据类型
• 使用方式：不能创建对象使用，只能作为方法的参数使用。
• 不知道使用什么类型来接收的时候，此时可以使用 ？ ，？表示未知通配符。
• 但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身的方法无法使用。
• 练习：

/*
题目要求：
定义一个方法，能遍历所有类型的ArrayList集合
分析：
这时候我们不知道ArrayList集合使用什么数据类型，
可以使用泛型的通配符 ? 来接受数据类型
 */
public class DemoGeneric01 {
    public static void main(String[] args) {
        ArrayList listA = new ArrayList<>();
        listA.add(10);
        listA.add(20);

        ArrayList listB = new ArrayList<>();
        listB.add("马尔扎哈");
        listB.add("格利纳扎");

        printArray(listA);
        printArray(listB);
    }
    public static void printArray(ArrayList list){
        Iterator it = list.iterator();
        while (it.hasNext()){
            Object o = it.next();
            System.out.println(o);
        }
    }
}

注意事项：
泛型不存在继承关系。
Collection