Java——集合

最新推荐文章于 2023-09-12 20:19:17 发布
最新推荐文章于 2023-09-12 20:19:17 发布
阅读量518 收藏
点赞数
分类专栏： Java笔记 文章标签： java mybatis 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45042462/article/details/131270730
版权

文章目录

1、集合概述

  • 集合和数组都是容器
  • 数组的特点
    • 数组 定义完成并启动后，类型确定、长度固定
    • 在进行增删改查操作的时候，数组是不太合适的，增删数据都需要放弃原有数组或者移位
  • 数组适合的场景
    • 当业务数据的个数是固定的，且都是同一批数据类型的时候，可以采取定义数组存储
  • 集合是Java中存储对象数据的一种容器
  • 集合的特点
    • 集合的大小不固定，启动后可以动态变化，类型也可选择不固定
    • 集合非常适合做元素的增删操作
  • 注意：集合中只能存储引用类型数据，如果要存储基本类型数据可以选用包装类
  • 集合适合的场景
    • 数据的个数不确定，需要进行增删元素的时候

2、集合类体系结构

在这里插入图片描述

  • Collection单列集合，每个元素（数据）只包含一个值
  • Map双列集合，每个元素包含两个值（键值对）

Collection集合体系

在这里插入图片描述
Collection集合特点

  • List系列集合 ：添加的元素是有序、可重复、有索引
    • ArrayList、LinekdList：有序、可重复、有索引
  • Set系列结合 ：添加的元素是无序、不重复、无索引
    • HashSet：无序、不重复、无索引
    • LinkedHasSet：有序、不重复、无索引
    • TreeSet：按照大小默认升序排序、不重复、无索引

Demo

package collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;

public class CollectionDemo1 {
    public static void main( String[] args ) {
        //有序    可重复     有索引
        Collection list = new ArrayList();
        list.add("java");
        list.add("java");
        list.add("Mybatis");
        list.add(123);
        list.add(true);
        list.add(123.5);
        list.add(false);
        list.add(false);
        System.out.println(list);

        //无序    不重复     无索引
        Collection set = new HashSet();
        set.add("java");
        set.add("java");
        set.add("Mybatis");
        set.add(123);
        set.add(true);
        set.add(123.5);
        set.add(false);
        set.add(false);
        System.out.println(set);
    }
}

运行结果
在这里插入图片描述

  • 集合对于泛型的支持
    • 集合都是支持泛型的，可以在编译阶段约束集合只能操作某种数据类型
      Collection<String> list = new ArrayList<String>();
Collection<String> list = new ArrayList<>();		//从JDK1.7开始后面的泛型类型申明可以省略不写

3、Collection集合常用API

Collection集合

  • Collection是单列集合的祖宗接口，它的功能是全部单列集合都可以继承使用的

Collection API

名称说明
public boolean add(E e)把给定的对象添加到当前集合中
public void clear()清空集合中所有的元素
public boolean remove(E e)把给定的对象在当前集合中删除
public boolean contains(Object ob)判断当前集合中是否包含给定的对象
public boolean isEmpty()判断当前集合是否为空
public int size()返回集合中元素的个数
public Object[] toArray()把结合汇总元素，存储到数组中

Demo

package collection;

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

public class CollectionDemo2 {
    public static void main( String[] args ) {
        Collection<String> list = new ArrayList<>();
        // 1.添加元素，添加成功返回true
        list.add("java");
        list.add("MySQL");
        list.add("HTMl");
        list.add("HTMl");
        list.add("java");
        list.add("xiaowu");
        System.out.println(list);

        // 2.清空集合元素
        /*list.clear();
        System.out.println(list);*/

        // 3.判断集合是否为空，为空返回true
        System.out.println(list.isEmpty());

        // 4.获取集合的大小
        System.out.println(list.size());

        // 5.判断集合中是否包含某个元素
        System.out.println(list.contains("java"));  //true
        System.out.println(list.contains("Java"));  //false

        // 6.删除某个元素：如果有多个重复元素默认删除前面第一个
        System.out.println(list.remove("Java"));    //false
        System.out.println(list);
        System.out.println(list.remove("java"));    //true
        System.out.println(list);

        // 7.把集合转换成数组   [MySQL, HTMl, HTMl, java, xiaowu]
        Object[] arrs = list.toArray();
        System.out.println("数组:"+ Arrays.toString(arrs));
        
    }
}

运行结果
在这里插入图片描述

3、Collection集合的遍历方式

方式一：迭代器

迭代器概述

  • 遍历就是一个一个的把容器中的元素访问以便
  • 迭代器在Java中的代表是 Iterator，迭代器是集合的专用遍历方式

Collection集合获取迭代器

名称说明
Iterator iterator()返回集合中的迭代器对象，该迭代器对象默认指向当前集合的0索引

Iterator中的常用方法

名称说明
boolean hasNext()询问当前位置是否有元素存在，存在返回true，不存在返回false
E next()获取当前位置的元素，并同时将迭代器对象移向下一个位置，注意防止取出越界

Demo

package collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo3 {
    public static void main( String[] args ) {
        Collection<String> list = new ArrayList<>();
        list.add("java");
        list.add("html");
        list.add("js");
        list.add("vue");
        System.out.println(list);

        // 1. 得到当前的迭代器对象
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

运行结果
在这里插入图片描述

方式二：foreach/增强for循环

  • 增强for循环：既可以遍历集合也可以遍历数组

  • 它是JDK5之后出现的，其内部原理是一个Iterator迭代器，遍历集合相当于是迭代器的简化写法

  • 实现Iterable接口的类才可以使用迭代器和增强for，Collection接口已经实现了Iterable接口

  • 格式

    for(元素数据类型 变量名 : 数组或者Collection集合){
	//在此处使用变量即可，该变量就是元素
}

Demo

package collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo3 {
    public static void main( String[] args ) {
        Collection<String> list = new ArrayList<>();
        list.add("java");
        list.add("html");
        list.add("js");
        list.add("vue");
        System.out.println(list);

        for (String s : list) {
            System.out.println(s);
        }
    }
}

运行结果
在这里插入图片描述

方式三：lambda表达式

  • 得益于JDK8开始的新技术Lambda表达式，提供了一种更简单、更直接的遍历集合的方式

Collection结合Lambda遍历的API

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

Demo

package collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.function.Consumer;

public class CollectionDemo3 {
    public static void main( String[] args ) {
        Collection<String> list = new ArrayList<>();
        list.add("java");
        list.add("html");
        list.add("js");
        list.add("vue");
        System.out.println(list);

        list.forEach(s->{
            System.out.println(s);
        });
    }
}

运行结果
在这里插入图片描述

4、List系列集合

List集合特点和特有API

  • ArrayList、LinekdList：有序、可重复、有索引
  • 有序：存储和取出的元素顺序一致
  • 可重复：存储的元素可以重复
  • 有索引：可以通过索引操作元素

List的实现类的底层原理

  • ArrayList底层是基于数组实现的：根据索引定位元素快，增删相对慢
  • LinkedList底层基于双链表实现的：查询元素慢，增删首元素是非常快的

List集合特有方法

  • List集合因为支持索引，所以多了很多索引操作的独特API，其他Collection的功能List也都继承了

    package list;

import java.util.ArrayList;
import java.util.List;

public class ListDemo1 {
    public static void main( String[] args ) {
        List<String> list = new ArrayList<>();
        list.add("java");
        list.add("java");
        list.add("html");
        list.add("html");
        list.add("mysql");
        list.add("mysql");
        // 在索引位置插入元素
        list.add(2,"小吴");
        System.out.println(list);

        // 根据索引删除元素
        list.remove(1);
        System.out.println(list);

        // 根据索引获取元素
        System.out.println(list.get(1));

        // 修改索引位置处的元素
        list.set(1,"小吴在敲Bug");
        System.out.println(list);
    }
}

LinkedList集合

  • 底层数据结构是双链表，查询慢，首尾操作的速度极快，所以多了很多首尾操作的特有API

LinkedList集合的特有功能

名称说明
public void addFirst(E e)在该列表开头插入指定的元素
public void addLast(E e)将指定的元素追加到此列表的末尾
public E getFirst()返回此列表中的第一个元素
public E getLast()返回此列表中的最后一个元素
public E removeFirst()从此列表中删除并返回第一个元素
public E removeLast()从此列表中删除并返回最后一个元素

Demo

package list;

import java.util.LinkedList;

public class ListDemo2 {
    public static void main( String[] args ) {
        // LinkedList可以完成队列结构，和栈结构（双列表）
        // 1.做一个队列
        LinkedList<String> queue = new LinkedList<>();
        queue.addLast("1号");
        queue.addLast("2号");
        queue.addLast("3号");
        System.out.println(queue);

        // 出队
        System.out.println(queue.removeFirst());
        System.out.println(queue);

        // 2.做一个栈
        LinkedList<String > stack = new LinkedList<>();
        // 入栈
        stack.push("第1颗子弹");
        stack.push("第2颗子弹");
        stack.push("第3颗子弹");
        stack.push("第4颗子弹");
        System.out.println(stack);

        //出栈
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack);
    }
}

运行结果
在这里插入图片描述

5、集合的并发修改异常问题

  • 当我们从集合中找出某个元素并删除的时候可能出现一种并发修改问题
    Demo
package update_delete;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test {
    public static void main( String[] args ) {
        // 1. 准备数据
        List<String> list = new ArrayList<>();
        list.add("java");
        list.add("html");
        list.add("html");
        list.add("css");
        list.add("js");
        list.add("Linux");
        System.out.println(list);

        /**
         * 需求：删除全部的html信息
         */
        // 1.迭代器
        /*Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String ele = iterator.next();
            if("html".equals(ele)){
                //删除html
                //list.remove(ele); //集合删除会出毛病
                iterator.remove();  //删除迭代器所在位置的元素值（没毛病）
            }

        }*/

        // 2.foreach遍历删除（会出现问题，无法解决的，fareach不能边遍历边删除，会出现Bug）
        /*for (String s : list) {
            if("html".equals(s)){
                list.remove(s);
            }
        }*/

        // 3.lambda表达式（会出现问题，无法解决的，lambda不能边遍历边删除，会出现Bug）
        /*list.forEach(s->{
            if("html".equals(s)){
                list.remove(s);
            }
        });*/

        // 4.for循环（边遍历边删除集合没毛病，但是必须从后面开始遍历删除才不会漏掉应该删除的元素)
        for (int i = list.size()-1; i >=0 ; i--) {
            String ele = list.get(i);
            if("html".equals(ele)){
                list.remove(ele);
            }

        }

        System.out.println(list);

    }
}

那些遍历存在问题?

  • 迭代器遍历集合且直接用集合删除元素的时候可能出现
  • 增强for循环遍历集合且直接用集合删除元素的时候可能出现
    哪种遍历且删除元素不出问题？
  • 迭代器遍历集合但是用迭代器自己的删除方法操作可以解决
  • 使用for循环遍历并删除不会存在这个问题

6、Set系列集合

概述

Set集合的功能基本上与Collection的API一致

Set系列集合特点

  • 无序：存取顺序不一致
  • 不重复：可以去除重复
  • 无索引：没有带索引的方法，所以不能使用普通for循环遍历，不能通过索引来获取元素

Set集合实现类特点

  • HashSet：无序、不重复、无索引
  • LinkedHashSet：有序、不重复、无索引
  • TreeSet：排序 、不重复、无索引

Demo

package set;

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;

public class SetDemo1 {
    public static void main( String[] args ) {
        // 看看Set系列集合的特点：HashSet LinkedHashSet TreeSet

        Set<String> sets = new HashSet<>();// 无序 不重复 无索引
        //Set<String> sets = new LinkedHashSet<>(); //有序 不重复 无索引
        sets.add("Java");
        sets.add("Java");
        sets.add("HTML");
        sets.add("HTML");
        sets.add("CSS");
        sets.add("CSS");
        sets.add("Linux");
        sets.add("Linux");
        System.out.println(sets);
    }
}

运行结果
在这里插入图片描述

HashSet底层原理

  • HashSet集合底层采取 哈希表 存储的数据
  • 哈希表是一种对于增删改查数据性能都较好的结构

哈希表的组成

  • JDK8之前，底层使用 数组+链表 组成
  • JDK8开始后：底层采用 数组+链表+红黑树 组成

哈希值

  • 是JDK根据对象的 地址，按照某种规则算出来的int类型的 数值

Object类的API

  • public int hashCode()：返回对象的哈希值

对象的哈希值特点

  • 同一个对象多次调用hashCode()方法返回的哈希值是相同的

  • 默认情况下，不同对象的哈希值是不同的

  • Demo

    package set;

public class SetDemo2 {
    public static void main( String[] args ) {
        String name = "小吴在敲Bug";
        System.out.println(name.hashCode());
        System.out.println(name.hashCode());
        String name1 = "小吴";
        System.out.println(name1.hashCode());
        System.out.println(name1.hashCode());
    }
}

· 在这里插入图片描述

哈希表的详细流程
1. 创建一个默认长度16，默认加载为0.75数组，数组名table
2. 根据元素的焊锡值跟数组的长度求余计算出应存入的位置
3. 判断当前位置是否为null，如果是null直接存入，如果位置不为null，表示有元素，则调用equals方法比较属性值，如果一样，则不存，如果不一样，则存入数组
4. 当数组存满到16*0.75=12时，就自动扩容，每次扩容原先的两倍

如果希望Set集合认为两个内容相同的对象是重复的应该怎么办？

  • 重写对象的hashCode和equals方法

LInkedHashSet类

  • 有序、不重复、无索引
  • 这里的有序指的是保证存储和取出的元素顺序一致
  • 底层数据结构依然是哈希表，只是每个元素又额外的多了一个双链表的机制记录存储的顺序

TreeSet类

  • 不重复、无索引、可排序
  • 可排序：按照元素的大小默认升序（由小到大）排序
  • TreeSet集合底层是基于 红黑树的数据结构 实现排序的，增删改查性能都较好
  • 注意：TreeSet集合是一定要排序的，可以将元素按照指定的规则进行排序

TreeSet集合默认排序规则

  • 对于数值类型：Integer，Double，官方默认按照大小进行升序排序
  • 对于字符串类型：默认按照首字符的编号升序排序
  • 对于自定义类型如Student对象，TreeSet无法直接排序

自定义排序规则

  • TreeSet集合存储对象的时候有2种方式可以设计自定义比较规则
  • 注意：如果TreeSet集合存储的对象有实现比较规则，集合也自带比较器，默认使用集合自带的比较器排序

方式一

  • 让自定义类（如学生类）实现Comparable接口 重写里面的 compareTo 方法 来定制比较规则

    public class Student implements Comparable<Student> {
    private String name;
    private int age;
    private char sex;

    /**
     * 方式一：类自定义比较规则
     *
     * @param o
     * @return
     */
    @Override
    public int compareTo( Student o ) {
        //按照年龄进行比较
        return this.age - o.age >= 0 ? 1 : -1;
    }
}

方式二

  • TreeSet集合有参数构造器，可以设置Comparator接口对应的比较器对象，来定制比较规则

    // 方式二：集合自带比较器对象进行规则定制
Set<Student> studentSet = new TreeSet<>(( Student s1, Student s2 ) -> {
    return s2.getAge() - s1.getAge() >= 0 ? 1 : -1;
});

7、集合操作的工具类（Collections）

Collections集合工具类

  • java.utils.Collections：集合工具类
  • 作用：Collections并不属于集合，是用来操作集合的工具类

Collections常用API

名称说明
public static <T> addAll(Collection<? super T> c,T … elements)把集合对象批量添加元素
public static void shuffle(List<?> list)打乱List集合元素的顺序
public static <T> void sort(List<T> list)将集合中元素按照默认规则排序
public static <T> void sort(List<T> list, Comparator<? super T> c)将集合中元素按照指定的规则排序

8、Map集合体系

Map集合概述和使用

  • Map集合是一种双列集合，每个元素包含两个数据
  • Map集合的每个元素格式：key=value(键值对元素)
  • Map集合也被称为“键值对集合”
  • Map结合的完整格式：{key1=value1,key2=value2,key3=value3,……}

Map集合体系

在这里插入图片描述
说明

  • 使用最多的Map集合是HashMap
  • 重点掌握HashMap，LinkedHashMap，TreeMap

Map集合体系特点

  • Map集合的特点都是由键决定的
  • Map集合的键是无序，不重复，无索引，值不做要求（可以重复）
  • Map集合后面重复的键对应的值会覆盖前面重复键的值
  • Map集合的键值对都可以为null

Map集合实现类特点

  • HashMap：元素按照键是无序，不重复，无索引，值不做要求
    • Demo
      package map;

import java.util.HashMap;
import java.util.Map;

public class MapDemo1 {
    public static void main( String[] args ) {
        // 1.创建一个Map集合对象
        Map<String,Integer> maps = new HashMap<>();//一行经典代码
        maps.put("鸿星尔克",3);
        maps.put("鸿星尔克",5);
        maps.put("键盘",2);
        maps.put("Java从入门到砸键盘",1);
        maps.put(null,null);

        System.out.println(maps);
    }
}
    • 运行结果
      在这里插入图片描述
  • LinkedHashMap：元素按照键是 有序，不重复，无索引，值不做要求
    • Demo
      package map;

import java.util.LinkedHashMap;
import java.util.Map;

public class MapDemo1 {
    public static void main( String[] args ) {
        // 1.创建一个Map集合对象
        Map<String,Integer> maps = new LinkedHashMap<>();//一行经典代码
        maps.put("鸿星尔克",3);
        maps.put("鸿星尔克",5);
        maps.put("键盘",2);
        maps.put("Java从入门到砸键盘",1);
        maps.put(null,null);

        System.out.println(maps);
    }
}
    • 运行结果
      在这里插入图片描述
  • TreeMap：元素按照键是 排序，不重复，无索引，值不做要求

Map常用API

Map集合

  • Map是双列集合的祖宗类接口，它的功能是全部双列集合都可以继承使用

Map API如下

名称说明
V put(K key,V value)添加元素
V remove(Object key)根据键删除值对元素
void clear()移除所有的键值对元素
boolean containsKey(Object key)判断集合是否包含指定的键
boolean containsValue(Object value)判断集合是否包含指定的值
boolean isEmpty()判断集合是否为空
int size()集合的长度，也就是集合中键值对的个数

Map集合的遍历

方式一：键找值流程

  • 先获取Map集合的全部键的Set集合
  • 遍历键的Set集合，然后通过提取对应值

键找值涉及到的API

名称说明
Set<K> keySet()获取所有键的集合
V get(Object key)根据键获取值

Demo

package map;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapDemo2 {
    public static void main( String[] args ) {
        Map<String, Integer> maps = new HashMap<>();
        // 添加元素
        maps.put("娃娃", 30);
        maps.put("iphoneX", 100);
        maps.put("huawei", 1000);
        maps.put("生活用品", 10);
        maps.put("手表", 10);
        System.out.println(maps);       // {huawei=1000, 手表=10, 生活用品=10, iphoneX=100, 娃娃=30}

        // 1.键找值，第一步，先拿到集合的全部键
        Set<String> keys = maps.keySet();

        // 2.遍历每个键，根据键提取值
        for (String key : keys) {
            int value = maps.get(key);
            System.out.println(key + "=====>" + value);
        }

    }
}

运行结果
在这里插入图片描述

方式二：键值对

  • 先把Map集合转换成Set集合，Set集合中每个元素都是键值对实体类型
  • 遍历Set集合，然后提取键以及提取值

键值对涉及到的API

名称说明
Set<Map,Entry<K,V> entrySet()获取所有键值对对象的集合
K getKey()获得键
K getValue()获取值

Demo

package map;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapDemo3 {
    public static void main( String[] args ) {
        Map<String, Integer> maps = new HashMap<>();
        // 添加元素
        maps.put("娃娃", 30);
        maps.put("iphoneX", 100);
        maps.put("huawei", 1000);
        maps.put("生活用品", 10);
        maps.put("手表", 10);
        System.out.println(maps);       // {huawei=1000, 手表=10, 生活用品=10, iphoneX=100, 娃娃=30}

        // 1.把Map集合转换成Set集合
        Set<Map.Entry<String, Integer>> entries = maps.entrySet();

        // 2.开始遍历
        for (Map.Entry<String, Integer> entry : entries) {
            String key = entry.getKey();
            int value = entry.getValue();
            System.out.println(key+"=====>"+value);

        }

    }
}

运行结果
在这里插入图片描述

方式三：Lambda

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

Map结合Lambda遍历的API

名称说明
default void forEach(BiConsumer< ? super K,? super V> action)结合Lambda遍历Map集合

Demo

package map;

import java.util.HashMap;
import java.util.Map;

public class MapDemo4 {
    public static void main( String[] args ) {
        Map<String, Integer> maps = new HashMap<>();
        // 添加元素
        maps.put("娃娃", 30);
        maps.put("iphoneX", 100);
        maps.put("huawei", 1000);
        maps.put("生活用品", 10);
        maps.put("手表", 10);
        System.out.println(maps);       // {huawei=1000, 手表=10, 生活用品=10, iphoneX=100, 娃娃=30}

        maps.forEach((key,value)->{
            System.out.println(key+"====>"+value);
        });
    }
}

运行结果
在这里插入图片描述

9、Stream流

  • 在Java8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream流概念
  • 目的：用于简化集合和数组操作的API

获取Stream流

集合获取Stream流

名称说明
default Stream<E> stream()获取当前集合对象的Stream流

数组获取Stream流的方式

名称说明
public static <T> Steam<T> stream(T[] array)获取当前数组的Stream流
public static<T> Stream<T> of(T…values)获取当前数组/可变数据的Stream流

Demo

package stream;

import java.util.*;
import java.util.stream.Stream;

public class StreamDemo1 {
    public static void main( String[] args ) {
        // Collection集合获取流
        Collection<String> list = new ArrayList<>();
        Stream<String> stream = list.stream();

        // Map集合获取流
        Map<String,Integer> maps = new HashMap<>();

        // 键流
        Stream<String> keyStram = maps.keySet().stream();
        // 值流
        Stream<Integer> valueStram = maps.values().stream();

        // 键值对
        Stream<Map.Entry<String, Integer>> keyAndValueStream = maps.entrySet().stream();

        // 数组获取流
        String[] names={"Java","HTML","CSS","Vue"};

        //方式一
        Stream<String> nameStream1 = Arrays.stream(names);

        //方式二
        Stream<String> nameStream2 = Stream.of(names);
    }
}

Stream流常用API

名称说明
Stream<T> filter(Predicate<? super T> predicate)用于对流中的数据进行 过滤
Stream<T> limit(long maxSize)获取前几个元素
Stream<T> skip(long n)跳过前几个元素
Stream<T> distinct去除流中重复的元素（依赖hashCode和equals方法）
static <T> Stream concat(Stream a,Stream b)合并a和b两个流为一个流
  • 中间方法也称为非终结方法，调用完成后返回新的Stream流可以继续使用，支持链式编程
  • 在Stream流中无法直接修改集合、数组中的数据

Demo

package stream;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;

public class StreamDemo2 {
    public static void main( String[] args ) {
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"Java","HTML","Css",
                "Vue","JavaScript","JavaSE","JavaSE");

        list.stream().filter(s -> s.startsWith("J")).forEach(s -> System.out.println(s));

        long count = list.stream().filter(s -> s.length() == 3).count();
        System.out.println(count);

        list.stream().filter(s-> s.startsWith("J")).limit(2).forEach(s-> System.out.println(s));

        list.stream().filter(s-> s.startsWith("J")).skip(2).forEach(s-> System.out.println(s));

        //Map加工方法
        //给集合元素的前面加上  小吴在学
        list.stream().map((item)-> "小吴在学"+item).forEach(s-> System.out.println(s));

        Stream<String> s1 = list.stream().filter(s -> s.startsWith("J"));
        Stream<String> s2 = Stream.of("Css1", "Css2");
        Stream<String> s3 = Stream.concat(s1, s2);
        s3.forEach(s-> System.out.println(s));

    }
}

运行结果
在这里插入图片描述

Stream流的收集操作

  • 收集Stream流的含义：就是把Stream流操作后的结果数据转回到集合或者数组中去

Stream流的收集方法

名称说明
R collect(Collector collector)开始收集Stream流，指定收集器

Collectors工具类提供了具体的收集方式

名称说明
public static <T> Collector toList()把元素收集到List集合中
public static <T> Collector toSet()把元素收集到Set集合中
public static <T> Collector toMap(Function keyMapper,Function valueMapper)把元素收集到Map集合中

Demo

package stream;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamDemo3 {
    public static void main( String[] args ) {
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"Java","HTML","Css",
                "Vue","JavaScript","JavaSE","JavaSE");

        Stream<String> jStream = list.stream().filter(s -> s.startsWith("J"));
        List<String> jList = jStream.collect(Collectors.toList());
        System.out.println(jList);

        
    }
}

运行结果
在这里插入图片描述

小吴在敲Bug
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java集合——全
12-22
集合、数组都是对多个数据进行存储操作的结构，简称Java容器。 说明:此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi，数据库中) 数组存储的特点： 一旦初始化以后，其长度就确定了。 ...
java——jdk1.8
04-03
4. **Java版本**：JDK 1.8引入了许多新特性，包括Lambda表达式、方法引用来简化代码，Stream API增强集合操作，以及Date和Time API的改进。Lambda表达式允许开发者以更简洁的方式处理函数式编程，而Stream API则提供...
java——集合
m0_59325161的博客
07-05 68
Java——集合(练习题)
beyond谚语的博客
07-15 7942
例题1：产生10个1~20之间的随机数，要求随机数不能重复 import java.util.HashSet; import java.util.Random; public class Test1 { /** * 产生10个1~20之间的随机数，要求随机数不能重复 * * 分析： * 1,有Random类...
JAVA——集合框架
爱学习的鱼的博客
07-21 178
Java——集合的关系图
smile4548656的博客
04-19 440
集合的关系图
java——集合——List集合——ArrayList集合
小白龙白龙马的博客
11-19 125
ArrayList集合 ArrayList集合有缺点：查询快、增删慢 java.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。 许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。 ...
Java——集合体系结构
Small__明的博客
11-25 86
Java——集合体系结构 集合类体系结构 Collection集合概述 集合常用方法 A/t + 7可以打开一个窗口看见所有类的信息。 集合的遍历 List集合
Java ——集合（一）
最新发布
lyy281241的博客
09-12 68
java——集合——Map集合——Map常用子类
小白龙白龙马的博客
11-19 164
Map常用子类 java.util.HashMap集合 implements Map接口HashMap集合的特点:1.HashMap集合底层是哈希表:查询的速度特别的快JDK1.8之前:数组+单向链表JDK1.8之后:数组+单向链表|红黑树(链表的长度超过8):提高查询的速度2.hashMap集合是一个无序的集合,存储元素和取出元素的顺序有可能不一致 java.util.Link...
java——集合——Map集合——Map集合的概述
小白龙白龙马的博客
11-19 112
java基础——集合ArrayList ,LinkedList
01-21
目录前言数组与集合区别集合描述集合格式方法ArrayList实例1.add(E e)2.add(int index, E element)3.addAll(Collection c)4.clear() 与 isEmpty()5.contains(Object o)6.indexOf(Object o)7.iterator()8.remove(int ...
java——基础程序设计
03-08
Java 中的 foreach 语句是 Java 语言中用来遍历数组或集合的语句。foreach 语句的语法是，for(元素类型 元素变量：遍历对象) {执行的代码}。 例如，int[] a = {1, 2, 3, 4, 5}; for(int hobby：a) { System.out....
Java集合类——前言
01-07
Java.util 包提供了集合类（也称容器类） Java集合主要有4个部分： List列表 Set集合 Map映射 工具类（Iterator迭代器、Enumeration枚举类、Arrays和Collections） 这个图乱的一批o_o … emmmm大致可以看出，上面有...
Java——多态与接口.rar
11-16
在“Java——多态与接口”实验中，你可能需要编写一些示例代码来实践这些概念，例如创建一个基类，然后定义几个子类继承基类并覆盖其方法；再定义一个接口，让部分子类实现这个接口并提供接口方法的实现。通过运行和...
Java——JUC
12-29
JUC主要包含在`java.util.concurrent`包中，提供了线程池、同步容器、并发集合、原子类、异步计算以及定时任务等多种高级并发工具。 1. **线程池（ExecutorService）** - 线程池是JUC中的核心组件，它允许开发者...
详解Java 集合系列（三）—— LinkedList
08-26
Java 集合系列——LinkedList Java 集合系列中的 LinkedList 是一种可以在任何位置进行高效地插入和删除操作的有序序列。它的最基本存储结构是一个节点：每个节点将存储对象，以及前后节点的引用。结构图中，我们...
Java——jdk1.8(64位和32位)
11-12
10. **并发改进**：Java 8在并发编程方面也有优化，如Fork/Join框架的改进，以及并发集合类的增强，如ConcurrentHashMap的性能提升。 以上就是Java JDK 1.8的关键知识点，无论是64位还是32位版本，都为开发者提供了...
Java核心知识——集合类、接口及实现方式
其中包括Java集合的核心知识点和常用的集合类，以及List、Set和Map三者之间的区别。 Java集合框架中，Map接口和Collection接口是所有集合类的父接口。接口与接口之间可以有继承关系，类与类之间也可以有继承关系，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小吴在敲Bug

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值