👀Collection接口的常用方法

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
public class Test01 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        /*
        Collection接口的常用方法：
        增加：add(E e) addAll(Collection<? extends E> c)
        删除：clear() remove(Object o)
        修改：
        查看：iterator() size()
        判断：contains(Object o) equals(Object o) isEmpty()
         */
        //创建对象：接口不能创建对象，利用实现类创建对象：
        Collection col = new ArrayList();//多态
        //调用方法：
        //集合有一个特点：只能存放引用类型的数据，不能是基本数据类型
        //基本数据类型自动装箱，对应包装类。int--->Integer
        col.add(18);
        col.add(12);
        col.add(11);
        col.add(17);
        System.out.println(col/*.toString()*/);
                                                                            //将数组转化为ArrayList集合
        List list = Arrays.asList(new Integer[]{11, 15, 3, 7, 1});
        col.addAll(list);//将另一个集合添加进col中
        System.out.println(col);
        //col.clear();清空集合
        System.out.println(col);
        System.out.println("集合中元素的数量为："+col.size());
        System.out.println("集合中是否为空："+col.isEmpty());
        boolean isRemove = col.remove(15);
        System.out.println(col);
        System.out.println("集合中数据是否被删除："+isRemove);
        Collection col2 = new ArrayList();
        col2.add(18);
        col2.add(12);
        col2.add(11);
        col2.add(17);
        Collection col3 = new ArrayList();
        col3.add(18);
        col3.add(12);
        col3.add(11);
        col3.add(17);
        System.out.println(col2.equals(col3));
        System.out.println(col2==col3);//地址一定不相等 false
        System.out.println("是否包含元素："+col3.contains(117));
    }
}

💨Collection集合的遍历

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Test02 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Collection col = new ArrayList();//多态
        col.add(18);
        col.add(12);
        col.add(11);
        col.add(17);
        col.add("abc");
        col.add(9.8);
        //对集合遍历（对集合中的元素进行查看）
        //方式1：普通for循环（X）
      /*  for (int i = 0; i < col.size(); i++) {
            col.
        }*/
        //方式2：增强for循环
                                                                                //为什么用Object的类型来接受数据，因为col里面可以放入的数据就是Object，如果用Integer来接受，向下转型不安全
        for(Object o:col){
            System.out.println(o);
        }
        System.out.println("--------------------------");
        //方式3：iterator()
        Iterator it = col.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

🔎迭代器简要原理

🧾面试题：iterator(),Iterator,Iterable关系

👉【1】对应的关系：

👉【2】hasNext(),next()的具体实现：

👉【3】增强for循环底层也是通过迭代器实现的：

🔔ListIterator迭代器

场景：用迭代器遍历的时候加入字符串：

import java.util.ArrayList;
import java.util.Iterator;
public class Test2 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        list.add("dd");
        list.add("ee");
        //在"cc"之后添加一个字符串"kk"
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            if ("cc".equals(it.next())){
                list.add("kk");
            }
        }
    }
}

发现报错：

出错原因：就是迭代器和list同时对集合进行操作：

解决办法：事情让一个“人”做 --》引入新的迭代器：ListIterator
迭代和添加操作都是靠ListIterator来完成的：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
public class Test2 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        list.add("dd");
        list.add("ee");
        //在"cc"之后添加一个字符串"kk"
        /**
         * 下面方法不可取 it 和 list 不能同时操作集合
         * 需要引入一个新的迭代器来解决这个问题
         */
        /*Iterator<String> it = list.iterator();
        while(it.hasNext()){
            if ("cc".equals(it.next())){
                list.add("kk");
            }
        }*/
        /**
         * listIterator()来解决
         * 迭代和添加操作都是靠ListIterator来完成的
         */
        ListIterator<String> it = list.listIterator();
        while(it.hasNext()){
            if ("cc".equals(it.next())){
                it.add("kk");
            }
        }
        System.out.println(it.hasNext());//判断下面是否还有元素 false
        System.out.println(it.hasPrevious());//判断上面是否还有元素 true
        //逆向遍历：
        while(it.hasPrevious()){
            System.out.println(it.previous());
        }
        //逆向遍历之后指针就相当于移到上面去了，所以此时下面有元素，上面没有元素
        System.out.println(it.hasNext());//判断下面是否还有元素 true
        System.out.println(it.hasPrevious());//判断上面是否还有元素 false
        System.out.println(list);
    }
}

🔧Collections工具类

✒练习1

import java.util.ArrayList;
import java.util.Collections;
public class Test03 {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //Collections不支持创建对象，因为构造器私有化
        /*Collections cols = new Collections();*/
        //里面的属性和方法都是被static修饰，我们可以直接类名.去调用即可：
        ArrayList<String> list = new ArrayList<>();
        list.add("cc");
        list.add("bb");
        list.add("aa");
        Collections.addAll(list,"ee","dd","ff");
        Collections.addAll(list,new String[]{"gg","oo","pp"});
        System.out.println(list.size());
        System.out.println(list);
        //binarySearch必须在有序的集合中查找：-->排序
        Collections.sort(list);//升序排列
        System.out.println(list);
        System.out.println(Collections.binarySearch(list, "cc"));
        //copy:替换方法
        ArrayList<String> list2 = new ArrayList<>();
        Collections.addAll(list2,"tt","ss","ws");
        Collections.copy(list,list2);//将list2的内容替换到list上去
        System.out.println(list);
        System.out.println(list2);
        //fill填充
        Collections.fill(list2,"yyy");
        System.out.println(list2);
    }
}

✒练习2

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/*
    Collections类的概述
        是针对集合操作的工具类
    Collections类的常用方法
        public static <T extends Comparable<? super T>> void sort(List<T> list)：将指定的列表按升序排序
        public static void reverse(List<?> list)：反转指定列表中元素的顺序
        public static void shuffle(List<?> list)：使用默认的随机源随机排列指定的列表
 */
public class CollectionsDemo {
    public static void main(String[] args) {
        //创建集合对象
        List<Integer> list = new ArrayList<>();
        //添加元素
        list.add(30);
        list.add(20);
        list.add(50);
        list.add(10);
        list.add(40);
        //public static <T extends Comparable<? super T>> void sort(List<T> list)：将指定的列表按升序排序
//        Collections.sort(list);
        //public static void reverse(List<?> list)：反转指定列表中元素的顺序
//        Collections.reverse(list);
        //public static void shuffle(List<?> list)：使用默认的随机源随机排列指定的列表
//        Collections.shuffle(list);
        Collections.shuffle(list);
        System.out.println("随机打乱后："+list);
        Collections.sort(list);
        System.out.println("升序后："+list);
        Collections.reverse(list);
        System.out.println("反转后："+list);
    }
}