Java 基础篇学习 集合框架概述与Collection接口

集合框架的概述

    1、集合、数组都是对多个数据进行存储操作的结构，简称Java容器。说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化层面的存储。
    2.1数组在存储多个数据方面的特点：1>一旦初始化以后，其长度就确定了。2> 数组一旦定义好，其元素的类型也就确定了，只能操作指定类型的数据
    2.2数组在存储多个数据方面的缺点。1>一旦初始化以后，其长度就不能改变了。2> 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，不方便，效率较低。3>获取数组实际使用的元素的个数，不方便。4>数组存储数据的特点：有序、可重复。对于无序、不可重复数组无法满足
    Java集合可分为Collection和Map体系
    Collection接口:单列数据(集合)，定义了存取一组对象的方法的集合
        List:元素有序、可重复的集合(“动态数组”)，主要实现类有ArrayList、LinkedList和Vector
        Set:元素无序、不可重复的集合，主要实现类有HashSet、LinkedHashSet和TreeSet
    Map接口：双列数据(集合)，保存具有映射关系key-value对的集合,主要实现类有，HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

Collection 接口中方法的使用

    Collection接口提供的基本api的使用

@Test
    public void test(){
        Collection<String> collection = new ArrayList<String>(){{
            // 1、add 添加元素
            add("AA");
            add("BB");
            add("CC");
            add("DD");
            add("EE");
            add("FF");
        }};
        System.out.println(collection);

        // 2、获取添加元素的个数 .size()
        int size = collection.size();
        System.out.println(size);

        //addAll
        Collection<String> collection1 = new ArrayList<String>(){{
            // add 添加
            add("GG");
            add("AA");
        }};

        // 3、addAll 将collection1所有的元素添加到当前集合中
        collection.addAll(collection1);
        System.out.println(collection);
        System.out.println(collection.size());

        // 4、判断 collection 是否为空
        boolean empty = collection.isEmpty();
        System.out.println(empty);

        // 5、清空集合元素
        collection.clear();
        System.out.println(collection);
        System.out.println(collection.size());
        System.out.println(collection.isEmpty());
    }

    @Test
    public void test1() {
        Collection coll = new ArrayList() {{
            add("test");
            add(new Student(10086, "张三"));
            add(123);
        }};
        // 6、contains() 判断当前集合中是否包含 Object
        // boolean contains(Object o)
        // contains 方法调用的是子类的equals()方法
        // 要求 对象添加进入 Collection  最好重写equals()方法
        boolean contains = coll.contains(123);
        System.out.println(contains);
        boolean contains1 = coll.contains(new Student(10086, "张三"));
        System.out.println(contains1);

        // 7、 boolean containsAll(Collection<?> coll1); 判断coll1集合中的元素是否都在 coll中
        Collection coll1 = new ArrayList() {{
            add("test");
            add(new Student(10086, "张三"));
        }};
        System.out.println(coll.containsAll(coll1));
        //  8、boolean remove(Object o);
        boolean remove = coll.remove(new Student(10086, "张三"));
        System.out.println(remove);
        System.out.println(coll);
        // 9、boolean removeAll(Collection<?> c); 当前集合中移除 c中的所有元素
        // 相当于去差集
        Collection<Integer> coll2 = Arrays.asList(123, 456);
        boolean b = coll.removeAll(coll2);
        System.out.println(b);
        System.out.println(coll);
        // 10 boolean retainAll(Collection<?> c);
        // 获取 coll1 和 coll的交集，并将一样的数据赋值给当前集合 coll1
        boolean retainAll = coll1.retainAll(coll);
        System.out.println(coll1);
        //  boolean equals(Object o);
        // 11、coll1.equals()  Collection 与obj 是否一致 方法由子类提供
        // 12、coll1.hashCode() // 获取 Collection 的hashCode
        // 13、Object[] toArray(); coll转成数组
        Object[] objects = coll.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }
        // 扩展 arr 转list
        List list = Arrays.asList(new int[]{123, 345});
        System.out.println(list);
        System.out.println(list.size());

        List list1 = Arrays.asList(new Integer[]{123, 345});
        System.out.println(list1);
        System.out.println(list1.size());


    }

@Slf4j
//@Data 使用@Data 会重写本类中的equals()方法
@Getter
@Setter
@ToString
@NoArgsConstructor
@AllArgsConstructor
class Student {

    private Integer no;

    private String name;

        @Override
    // 重写equals方法
    public boolean equals(Object o) {
        log.info("Student equals() method");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(no, student.no) &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(no, name);
    }
}

    Iterator遍历：集合元素的遍历操作，使用迭代器Iterator接口。Iterator对象称为迭代器(设计模式的一种)，主要用于遍历Collection集合中的元素。迭代器模式的定义为：提供一种方法访问一个容器(container)对象中的各个元素，而又不需要暴露该对象的内部细节。迭代器模式可以说是为容器而生。
    Collection接口继承了Iterable接口。该接口有一个iterator()方法，那么所有实现了Collection接口的集合类都拥有一个iterator()方法，用以返回一个实现了iterator接口的对象。
    iterator用于遍历集合，iterator本身并不提供承装对象的能力。如果需要创建iterator对象，必须有一个被迭代的集合。集合对象每次调用iterator()方法，都会得到一个全新的迭代器对象，默认游标都在集合的第一个对象之前。
    Iterator 提供了两个非default 的方法

/**
     * Returns {@code true} if the iteration has more elements.
     * (In other words, returns {@code true} if {@link #next} would
     * return an element rather than throwing an exception.)
     *
     * @return {@code true} if the iteration has more elements
     */
    boolean hasNext();

    /**
     * Returns the next element in the iteration.
     *
     * @return the next element in the iteration
     * @throws NoSuchElementException if the iteration has no more elements
     */
    E next();

@Test
    public void test() {

        Collection<String> coll = new ArrayList<String>() {{
            add("test");
            add("123");
            add("234");
            add("345");
        }};
        // 迭代器
        Iterator<String> iterator = coll.iterator();
        // 不推荐方式一
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        // 异常信息 java.util.NoSuchElementException
//        System.out.println(iterator.next());
        // 不推荐方式二
//        for (int i = 0; i < coll.size(); i++) {
//            System.out.println(iterator.next());
//        }
        //推荐方式 判断是否有下一个元素
        while (iterator.hasNext()) {
            // .next() 指针下移，并将下移以后集合位置上的元素返回
            System.out.println(iterator.next());
        }

        // 错误方式一
//        while (iterator.next() != null){
//            System.out.println(iterator.next());
//        }

        // 错误方式二 coll.iterator() 每次调用.iterator()方法，都会有一个新的iterator对象返回
//        while (coll.iterator().hasNext()){
//            System.out.println(coll.iterator().next());
//        }

        // iterator remove() 方法的使用
        System.out.println("-------------------------------");
        Iterator<String> iterator1 = coll.iterator();
        while (iterator1.hasNext()) {
            String next = iterator1.next();
            if ("test".equals(next)) {
                // 内部定义了remove方法，可以在遍历的时候，移除集合中的元素，此方法不同于集合中直接调用remove()方法
                iterator1.remove();
            }
        }

        // 上一步的方法等同于  Collection中的 removeIf
//        coll.removeIf("test"::equals);
        // Collection 中的 removeIf 的源码就好理解了
//        default boolean removeIf(Predicate<? super E> filter) {
//            Objects.requireNonNull(filter);
//            boolean removed = false;
//            final Iterator<E> each = iterator();
//            while (each.hasNext()) {
//                if (filter.test(each.next())) {
//                    each.remove();
//                    removed = true;
//                }
//            }
//            return removed;
//        }
        

        System.out.println("-------------------------------");
        Iterator<String> iterator2 = coll.iterator();
        while (iterator2.hasNext()) {
            System.out.println(iterator2.next());
        }

    }

    foreach 循环遍历集合元素
    foreach是Java5.0提供的方法，循环迭代访问Collection和数组，遍历操作无需获取Collection或者数组的长度，无需使用索引访问元素，遍历集合底层调用的Iterator完成操作，foreach可以用来遍历数组

 @Test
    public void test2() {
        Collection<String> coll = new ArrayList<String>() {{
            add("test");
            add("123");
            add("234");
            add("345");
        }};

        // java1.5 for (集合元素的类型 局部变量 : 集合对象) {}
        // public Iterator<E> iterator() { return new Itr(); }
        // public boolean hasNext() {return cursor != size;}
        // 底层调用的还是 Iterator
        for (String str : coll) {
            System.out.println(str);
        }

        //java 1.8 Iterable 提供 forEach
        // default void forEach(Consumer<? super T> action) {
        //        Objects.requireNonNull(action);
        //        for (T t : this) {
        //            action.accept(t);
        //        }
        //    }
        coll.forEach(item -> {
            System.out.println(item);
            System.out.println(item.length());
        });
    }