JAVA高级（五）

Java集合

Java集合框架概述

一方面， 面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。另一方面，使用Array存储对象方面具有一些弊端，而Java集合就像一种容器，可以动态地把多个对象的引用放入容器中。

1.集合、数组都是对多个数据进行存储操作的结构，简称Java容器

        说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt、.jpg、.avi、数据库中）

2.1数组在存储多个数据方面的特点：

        > 一旦初始化以后，其长度就确定了。

        > 数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。

                比如: String[] arr; int[] arr1;Object[] arr2;

2.2数组在存储多个数据方面的缺点：

        > 一旦初始化以后，其长度就不可修改

        > 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高

        > 获取数组中实际元素的个数，数组没有现成的属性或方法可用

        > 数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。

集合框架

        Collection接口：单列集合，用来存储一个一个的对象

                List接口：存储有序的，可重复的数据  -->  "动态"数组，替换原有的数组

                        ArrayList

                        LinkedList

                        Vector

                Set接口：存储无序的，不可重复的数据  -->  高中讲的集合

                        HashSet

                        LinkedHashSet

                        TreeSet

        Map接口：双列集合，用来存储一对（key - value）一对的数据 -->  高中函数 y = f(x)

                HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

Collection接口中的方法的使用

package com.xxx.java2;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;

/**
 * @author Alkaid
 * @create 2022-08-17 14:36
 */
public class CollectionTest {
    @Test
    public void test1(){
        Collection coll = new ArrayList();

        //add(Object e)：将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add(123);//自动装箱
        coll.add(new Date());

        //size()：获取添加的元素的个数
        System.out.println(coll.size());

        //addAll(Collection coll1)：将coll1集合中的元素添加到当前的集合中
        Collection coll1 = new ArrayList();
        coll1.add(456);
        coll1.add("CC");

        coll.addAll(coll1);
        System.out.println(coll.size());
        System.out.println(coll);

        //clear():清空集合元素
        coll.clear();

        //isEmpty():判断当前集合是否为空
        System.out.println(coll.isEmpty());
    }
}

package com.xxx.java;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

/**
 * @author Alkaid
 * @create 2022-08-17 16:04
 */
public class CollectionTest {

    @Test
    public void test1() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);

//        Person p = new Person("Jerry", 20);
//        coll.add(p);
        coll.add(new Person("Jerry", 20));

        //contains(Object obj)：判断当前集合是否包含obj
        //我们在判断时会调用obj对象所在类的equals（）
        boolean contains = coll.contains(123);
        System.out.println(contains);
        System.out.println(coll.contains(new String("Tom")));
        System.out.println(coll.contains(new Person("Jerry", 20)));

        //containsAll(Collection coll):判断形参coll中的所有元素是否都存在于当前集合中
        Collection coll1 = Arrays.asList(123, 4567);
        System.out.println(coll.containsAll(coll1));
    }
    @Test
    public void test2(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(new Person("Jerry", 20));
        coll.add(false);

        //remove(Object obj)：从当前集合中移除obj元素
//        coll.remove(123);
        System.out.println(coll);

        coll.remove(new Person("Jerry", 20));
        System.out.println(coll);

        //removeAll(Collecton coll):差集：从当前集合中移除coll中所有的元素
        Collection coll1 = Arrays.asList(123, 456);
        coll.removeAll(coll1);
        System.out.println(coll);

    }

    @Test
    public void test3(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(new Person("Jerry", 20));
        coll.add(false);

        //retainAll(Collecton coll)：交集：获取当前集合和coll集合的交集，并返回给当前集合

//        Collection coll1 = Arrays.asList(123, 456,789);
//        coll.retainAll(coll1);
//        System.out.println(coll);

        //equals(Object obj)：要想返回true，需要当前集合和形参集合的元素都相同
        Collection coll1 = new ArrayList();
        coll1.add(456);
        coll1.add(123);

        coll1.add(new String("Tom"));
        coll1.add(new Person("Jerry", 20));
        coll1.add(false);

        System.out.println(coll.equals(coll1));
    }

    @Test
    public void test4(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(new Person("Jerry", 20));
        coll.add(false);

        //hashCode()：返回当前对象的哈希值
        System.out.println(coll.hashCode());

        //集合 ——>数组：toArray()
        Object[] arr = coll.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        //拓展：数组 ——> 集合：调用Arrays类的静态方法asList()
        List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
        System.out.println(list);

        List arr1 = Arrays.asList(new int[]{123, 456});
        System.out.println(arr1.size());   //1

        List<Integer> arr2 = Arrays.asList(new Integer[]{123, 456});
        System.out.println(arr2.size());   //2

        //iterator()：返回Iterator接口的实例，用于遍历集合元素。
    }
}

package com.xxx.java;

import java.util.Objects;

/**
 * @author Alkaid
 * @create 2022-08-17 16:06
 */
public class Person {
    private String name;
    private int age;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
//        System.out.println("调用了Person的equals（）方法");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Person person = (Person) o;

        if (age != person.age) return false;
        return Objects.equals(name, person.name);
    }
//
//    @Override
//    public int hashCode() {
//        int result = name != null ? name.hashCode() : 0;
//        result = 31 * result + age;
//        return result;
//    }
}

向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals（）

add(Object e)：将元素e添加到集合coll中，返回布尔值代表是否添加成功

addAll(Collection coll1)：将coll1集合中的元素添加到当前的集合中，返回布尔值代表是否添加成功

size()：返回集合的元素的个数

clear():清空集合元素

isEmpty():判断当前集合是否为空,返回布尔值

contains(Object obj)：判断当前集合是否包含obj，返回布尔值

containsAll(Collection coll):判断形参coll中的所有元素是否都存在于当前集合中，返回布尔值

remove(Object obj)：从当前集合中移除obj元素，返回布尔值代表是否删除成功

removeAll(Collecton coll):差集：从当前集合中移除coll中所有的元素，返回布尔值代表是否删除成功

retainAll(Collecton coll)：交集：获取当前集合和coll集合的交集，会改变当前集合的值，返回布尔值代表是否执行成功

equals(Object obj)：要想返回true，需要当前集合和形参集合的元素都相同，返回布尔值代表是否执行成功

hashCode()：返回当前对象的哈希值

集合 ——>数组：toArray()

拓展：数组 ——> 集合：调用Arrays类的静态方法asList()

Iterator迭代器接口

Iterator对象称为迭代器(设计模式的一种)，主要用于遍历 Collection 集合中的元素。

GOF给迭代器模式的定义为：提供一种方法访问一个容器(container)对象中各个元 素，而又不需暴露该对象的内部细节。迭代器模式，就是为容器而生。

Collection接口继承了java.lang.Iterable接口，该接口有一个iterator()方法，那么所 有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了 Iterator接口的对象

Iterator 仅用于遍历集合，Iterator 本身并不提供承装对象的能力。如果需要创建 Iterator 对象，则必须有一个被迭代的集合。

集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合 的第一个元素之前。

iterator()：返回Iterator接口的实例，用于遍历集合元素。

1.内部的方法：hasNext()和next（）

2.集合对象每次第哦啊有iterator（）方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前

3.内部定义了remove（），可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove（）

        如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法， 再调用remove都会报IllegalStateException。

package com.xxx.java;

import org.j