集合的进阶_执行s1.addall(s2)-CSDN博客

本文链接：https://blog.csdn.net/m0_52734332/article/details/135680464

Collection集合

ArrayList只是其中的一种，为了满足不同业务场景的需求，java还提供了很多不同特点的集合给我们选择

Collection单列集合 Collection代表单列集合，每个元素只包含一个值

Map双列集合 Map代表双列集合，每个元素包含两个值（键值对）

Collection方法

//public boolean add(E e);添加元素

//Public void clear();清空集合的元素

//public void isEmpty();判断集合是否为空

//public int size();获取集合的大小

//public boolean remove(E e)删除某个元素，如果有多个重复元素，默认删除前边的第一个 //public Object[] toArray();把集合转换成数组

s1.addAll(s2); 实现将s2的数据倒入s1集合里去

public class CollectionText1 {
    public static void main(String[] args) {
        Collection<String> s =  new ArrayList<>();//多态写法
        //public boolean add(E e);添加元素
        s.add("java1");
        s.add("java2");
        s.add("java1");
        s.add("java3");
        System.out.println(s);
        //Public void clear();清空集合的元素
        //s.clear();
        System.out.println(s);
        //public void isEmpty();判断集合是否为空
        System.out.println(s.isEmpty());

        //获取集合的大小 public int size();
        System.out.println("集合的大小为："+s.size());
        //public boolean contains(Object obj)集合里是否包含某个元素
        System.out.println(s.contains("java1"));
        //public boolean remove(E e)删除某个元素，如果有多个重复元素，默认删除前边的第一个
        s.remove("java1");
        System.out.println(s);
        //把集合转换成数组public Object[] toArray();
        Object[] arr = s.toArray();
        System.out.println(Arrays.toString(arr));

    }
}

Collection的遍历方式

1.迭代器

/*
*迭代器
*/
public class CollectionText2{
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("赵敏");
        list.add("小昭");
        list.add("素素");
        list.add("灭绝");
        System.out.println(list);
        System.out.println("------------------");

        Iterator<String> iterator = list.iterator();
        //hasNext()判断当前位置是否有元素存在，存在返回true,不存在返回false
        while(iterator.hasNext()){
            //获取当前位置的元素，并同时将迭代器对象指向下一个元素
            String next = iterator.next();
            System.out.println(next);
        }
    }
}

2.增强for循环

格式：for(元素的数据类型变量名：数组或者集合）{

}

增强for循环可以用来遍历集合或者数组

增强for循环遍历集合，本质上就是迭代器遍历集合的简化写法

public class CollectionText3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("赵敏");
        list.add("小昭");
        list.add("素素");
        list.add("灭绝");
        System.out.println(list);
        System.out.println("------------------");

        //用增强for循环来遍历集合或者数组
        for(String ele : list){
            System.out.println(ele);
        }
        //用增强for循环来遍历数组
        String[] names = {"迪丽热巴","古力娜扎","易烊千玺"};
        for(String name : names){
            System.out.println(name);
        }

    }
}

3.使用lambda表达式遍历集合

得益于jdk8开始的新技术lambda表达式，提供了这一种更简单，更直接的方式来遍历集合

方法名称	说明
default void forEach(Consumer<? super T> action)	结合lambda遍历集合

public class CollectionText4 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("赵敏");
        list.add("小昭");
        list.add("素素");
        list.add("灭绝");
        System.out.println(list);
        System.out.println("------------------");

//        forEach遍历集合

        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

//        使用lambda表达式简化以后
        list.forEach(s -> System.out.println(s));

        //再次简化
        System.out.println("再次简化----------");
        list.forEach(System.out::println);

    }
}

list系列集合

有序，可重复，有索引

ArrayList:有序，可重复，有索引

LinkedList:有序，可重复，有索引

掌握List系列集合的特点，以及其提供的特有方法

public class ListText1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("蜘蛛精");
        list.add("至尊宝");
        list.add("至尊宝");
        list.add("牛夫人");
        System.out.println(list);

        //public void add(int index ,E element) 在某个位置插入元素
        list.add(2,"wwl");
        System.out.println(list);

        //public void E remove()根据索引删除元素，返回被删除元素
        System.out.println(list.remove(2));
        System.out.println(list);

        //Public E get(int index)返回集合中指定位置的元素
        System.out.println(list.get(3));

        //public E set(int index,E element)修改索引处的元素，修改成功后会返回修改以前的元素
        System.out.println(list.set(3, "牛魔王"));
        System.out.println(list);
    }
}

List集合支持的遍历方式

①for循环（因为List集合有索引）
②迭代器
③增强for循环
④Lambda表达式

ArrayList集合

1.ArrayList集合的底层原理

基于数组实现的

1查询速度快：根据索引查询数据

2删除效率低：需要向前移动大量元素

3添加效率低：需要向后移动大量元素

①利用无参构造器创建集合，会在底层创建一个默认长度为0 的数组

②添加第一个元素的时候，底层会创建一个新的长度为10的数组

③存满时，会扩容1.5倍，并将原数组的数据复制到进的数组里，新数据接到后面

④如果一次添加多个元素，1.5倍还放不下的时候，则新创建的数组长度以实际为准

2.ArrayList集合适合的场景

适合：索引查询数据，比如根据随机索引取数据，或者数据量不是很大

不适合：数据量大的同时，又要频繁地进行增删的操作

LinkedList集合

1.LinkedList集合的底层原理

是根据链表存储的

链表中的结点是独立的对象，在内存中是不连续的，每个结点包含数据值和下一个结点的地址

用途：

可以用来设计队列

可以用来做设计栈

set系列集合

JDK8之前HashSet:集合的底层原理，基于哈希表：数组+链表

创建一个默认长度16的数组，默认加载因子为0.75，数组名table
使用元素的哈希值对数组的长度求余计算出应存入的位置
判断当前位置是否为null,如果是null直接存入
如果不为null,表示有元素，则调用equals方法比较相等，则不存；不相等，则存入数组
JDK8之前，新元素存入数组，占老元素位置，老元素挂下面
JDK8开始之后，新元素直接挂在老元素下面

可变参数

可变参数的方法里实际上是一个数组

public class ParamterText {
    public static void main(String[] args) {
        text();
        text(20,30);

    }

    public static void text(int...num){
        System.out.println(num.length);
        System.out.println(Arrays.toString(num));
        System.out.println("-----------");

    }
}

注意事项：

①一个形参列表里只有做一个可变参数

②可变参数只能放在形参的最后面

Collections工具类

Map集合

map集合的方法

map集合的遍历

①键找值

public class MapText1 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();
        map.put("手套",3);
        map.put("围脖",2);
        map.put("帽子",10);
        map.put("口罩",15);
        map.put("眼睛",2);
        System.out.println(map);

        //获取集合大小
//        System.out.println(map.size());

        //获取map的全部键
        Set<String> keys = map.keySet();
        System.out.println(keys);
        for (String key : keys) {
            Integer integer = map.get(key);
            System.out.println(key+"===>"+integer);
        }

    }
}

②键值对

Hashmap底层原理

JDK 8 新特性： Stream

stream流的常用方法

1.获取stream流

2.Stream流常见的中间方法

3.stream流常见的终结方法

public class StreamText1 {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();

        Student s1 = new Student("蜘蛛精", 26, 172.5);
        Student s2 = new Student("蜘蛛精", 26, 172.5);
        Student s3 = new Student("紫霞", 23, 167.6);
        Student s4 = new Student("白晶晶", 25, 169.0);
        Student s5 = new Student("牛魔王", 35, 183.3);
        Student s6 = new Student("牛夫人", 34, 168.5);
        Collections.addAll(students,s1,s2,s3,s4,s5,s6);
        //计算出身高超过168的学生有几人
        long size = students.stream().filter(s -> s.getHeight() > 168).count();
        System.out.println(size);

        //需求2,请找出身高最高的学生对象，并输出
        Student student = students.stream().max(((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight()))).get();
        System.out.println(student);


        //需求，计算出身高最高的学生对象，并输出
        Student student1 = students.stream().min(((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight()))).get();
        System.out.println(student1);




    }
}