集合Day01

使用数组的缺陷：

• 数组长度固定不变。

• 可通过数组名.length获取数组长度，却无法直接获取数组中实际存储的元素个数。

• 数组采用在内存中分配连续空间的存储方式存储，根据元素信息查找时效率比较低，需要多次进行比较。

集合框架中的接口和类位于java.util包。

分类：

单列集合：一个一个 Collection

双列集合：一对一对 Map

Collection:接口，是java集合框架中的根接口，继承了Iterable接口，因此可以用于遍历集合中的元素。存储的元素不唯一，无序。

Queue:接口，表示队列的数据结构，不允许插入null元素，也不允许包含重复的元素。

Deque:接口，双端队列。

特点：

1. 双向操作：允许在队列两端进行插入、删除、检索操作。

2. 队列特性：支持队列特性，包括队尾插入，队头删除，支持先进先出（FIFO）的行为。

3. 栈特性：支持栈特性，包括队头插入，队头删除，支持后进先出（LIFO）的栈行为。

4. 实现类：包括 ArrayDeque 和LinkedList ，可根据使用场景选择合适的实现类。

List:接口，可以存储一组不唯一、有序的对象。List常用的实现类ArrayList、LinkedList、Stack和Vector类等。

Vector

特点：

1. 动态数组：底层数组，自动扩展和缩小数组大小。

2. 线程安全：所有方法都是线程同步，可以在多线程环境中使用。

3. 支持随机访问：通过索引访问集合中的元素，具有常数时间复杂度的随机访问特性。

4. 可以包含重复元素：与set不同。

5. 可以插入null元素：与set不同。

方法：

remove((Integer)22) //删除数字集合中的元素22

remove(2) //删除集合中下标为2的元素

集合遍历的方式：

1.迭代器方法

Iterator iterator = vector.Iterator(); //获取迭代器对象并指向第一个元素

E next() //获取当前位置的元素，并将迭代器对象指向下一个

hasNext() //判断是否还有下一个元素

2.forEach方法

public void forEach(Consumer super E> action)

参数：此方法采取参数操作，该参数操作表示要对每个元素执行的操作。

返回值：此方法不返回任何内容。

异常：如果指定的操作为null，则此方法将引发NullPointerException。

参数：Consumer(函数式接口 jdk8)

Vector.forEach(new Consumer(){
		@Override
		public void accept(Object O){
				System.out.println(o);
		}
});


Vector.forEach(o -> System.out.println(o)); //Lambda表达式

3.增强for方法

继承Iterator接口都可以使用

for(Object 0,vector){
		System.out.println(o);
}

4.普通for

排序：

Comparator:是javase中的接口，位于java.util包下。（函数式接口）

使用场景：

1. 排序，需要比较两个对象谁排在前谁排在后（排序也可以让类实现Comparable接口，实现后该类的实例也具有排序能力）。

2. 分组，需要比较两个对象是否是属于同一组。

方式一：使用类实现Comparator接口，重写compare方法。

方式二：匿名函数。

方式三：Lambda表达式。

public class QQCY {
    private String name;
    private int age;
    private String hobby;

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

    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;
    }

    public String getHobby() {
        return hobby;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }

    @Override
    public String toString() {
        return "QQCY{" +
                "名字：'" + name + '\'' +
                ", 年龄：" + age +
                ", 爱好：'" + hobby + '\'' +
                '}';
    }

import java.util.Comparator;

import java.util.Vector;

public class QQCYTest {
    public static void main(String[] args) {
        Vector vector = new Vector(5);
        System.out.println(vector.capacity());
        vector.add(new QQCY("喜羊羊", 17, "学习"));
        vector.add(new QQCY("美羊羊", 16, "爱美"));
        vector.add(new QQCY("沸羊羊", 15, "舔羊"));
        vector.add(new QQCY("灰太狼", 30, "抓羊"));
        vector.add(new QQCY("小灰灰", 5, "吃"));
        vector.add(new QQCY("懒羊羊", 15, "睡觉"));


        vector.sort(new QQCTComparator());
        System.out.println("***继承接口***");
        for (Object o: vector) {
            System.out.println(o);
        }

        //匿名内部类
        vector.sort(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof  QQCY q1 && o2 instanceof QQCY q2){
                    return q1.getAge() - q2.getAge();
                }
                return 0;
            }
        });

        System.out.println("***匿名内部类***");
        for (Object o: vector) {
            System.out.println(o);
        }

        //lambda表达式
        vector.sort((o1, o2) -> {
                if (o1 instanceof QQCY q1 && o2 instanceof QQCY q2){
                    return q1.getAge() - q2.getAge();
                }
                return 0;
        });

        System.out.println("***lambda表达式***");
        for (Object o: vector) {
            System.out.println(o);
        }

    }


}
class QQCTComparator implements Comparator{

    @Override
    public int compare(Object o1,Object o2) {
        if (o1 instanceof QQCY  && o2 instanceof QQCY ){
            return  ((QQCY) o2).getAge() - ((QQCY) o1).getAge();
        }
        return 0;

    }
}

Stack类

特点：

1. 先进后出。

2. 继承自Vector:Stack类继承自Vector类，继承特性动态数组的自动扩展和缩小、线程安全等。

输出：

迭代器、增强for，普通for、forEach。