不可变集合、Lambda表达式、Stream流

不可变集合、Lambda表达式、Stream流

创建不可变集合

不能被修改的集合

应用场景

如果某个数据不能被修改，把它防御性的拷贝到不可变集合中是个很好的实践。

当集合对象被不可信的库调用时，不可变形式是安全的。

创建不可变集合

在List、Set、Map接口中，都存在静态的of方法，可以获取一个不可变的集合。

注意：这个集合不能添加、不能删除、不能修改。

示例

List

package com.louis;

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

/**
 * @author XRY
 * @date 2023年08月30日16:41
 */
public class ImmutableDemo1 {
    public static void main(String[] args) {
        /**
         * 创建不可变的List集合
         * 一旦创建完毕之后，是无法进行修改的，只能查询操作
         */
        List<String> list = List.of("louis", "khan", "Alex");
        System.out.println("list = " + list.toString());

        System.out.println("--------使用迭代器的方法遍历--------");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            String con = iterator.next();
            System.out.println(con);
        }
        /*
        * louis
          khan
          Alex
        * */

        System.out.println("---------测试是否能删除-----------");
        list.remove("louis");
        /*Exception in thread "main" java.lang.UnsupportedOperationException
                ....
                at com.louis.ImmutableDemo1.main(ImmutableDemo1.java:32)*/
    }
}

Set

package com.louis;

import java.util.Iterator;
import java.util.List;
import java.util.Set;

/**
 * @author XRY
 * @date 2023年08月30日16:41
 */
public class ImmutableDemo2 {
    public static void main(String[] args) {
        /**
         * 创建不可变的Set集合
         * 一旦创建完毕之后，是无法进行修改的，只能查询操作
         */
        Set<String> set = Set.of("louis", "khan");
        Iterator<String> iterator = set.iterator();
        while(iterator.hasNext()){
            String con = iterator.next();
            System.out.println(con);
        }
        /*
        * louis
          khan
        * */

        set.remove("louis");
        /*
        * Exception in thread "main" java.lang.UnsupportedOperationException
        *       ....
        *       at com.louis.ImmutableDemo2.main(ImmutableDemo2.java:28)      
        * */
    }
}

注意：

当我们要获取一个不可变的Set集合时，里面的参数一定要保证唯一性。

Map

package com.louis;

import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * @author XRY
 * @date 2023年08月30日16:41
 */
public class ImmutableDemo3 {
    public static void main(String[] args) {
        /**
         * 创建不可变的Map集合
         * 一旦创建完毕之后，是无法进行修改的，只能查询操作
         */

        Map<String, String> map = Map.of("1", "louis", "2", "louis", "3", "alex");
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println(map.get(key));
        }
        /*
        * alex
          louis
          louis
        * */

        System.out.println("------------------");
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            String key = entry.getKey();
            String value =  entry.getValue();
            System.out.println(key + "=" + value);
        }
        /*
        * 1=louis
          3=alex
          2=louis
        * */
    }
}

注意：

1、键是不能重复的

2、Map里面的of方法，参数是有上限的，最多只能传递20个参数，即10个键值对

原因：可变参数只能存在一个且只能在最后。

static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5,
                           K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10) {
    return new ImmutableCollections.MapN<>(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5,
                                           k6, v6, k7, v7, k8, v8, k9, v9, k10, v10);
}

ofEntries

如果想要创建Map的不可变集合，且键值对的数量超过了10个。

package com.louis;

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

/**
 * @author XRY
 * @date 2023年08月30日16:41
 */
public class ImmutableDemo4 {
    public static void main(String[] args) {
        /**
         * 创建Map的不可变集合， 键值对的数量超过10个
         */
        //1、创建一个普通的Map集合
        HashMap<String, String> map = new HashMap<>();
        map.put("1", "a");
        map.put("2", "b");
        map.put("3", "c");
        map.put("4", "d");
        map.put("5", "e");
        map.put("6", "f");
        map.put("7", "g");
        map.put("8", "h");
        map.put("9", "i");
        map.put("10", "j");
        map.put("11", "k");

        //2、利用上面的数据来获取一个不可变的集合
        //获取到所有的键值对对象(Entry对象)
        Set<Map.Entry<String, String>> entries = map.entrySet();

        //把entries变成一个数组(指定类型entry)
        Map.Entry[] array = entries.toArray(new Map.Entry[0]);

        /*toArray方法会比较集合的长度和数组长度两者之间的大小
        如果集合的长度大于数组的长度，表示数据在数组中放不下，此时会根据实际数据的个数重新创建数组。
        如果集合的长度小于等于数组的长度，数据在数组中可以存放，此时不会创建新的数组而是直接使用， 剩余的会默认初始化值null*/
        Map m = Map.ofEntries(array);

    }
}

在JDK10之后，不可变集合可以使用copyOf()方法

    /**
     * Returns an <a href="#unmodifiable">unmodifiable Map</a> containing the entries
     * of the given Map. The given Map must not be null, and it must not contain any
     * null keys or values. If the given Map is subsequently modified, the returned
     * Map will not reflect such modifications.
     *
     * @implNote
     * If the given Map is an <a href="#unmodifiable">unmodifiable Map</a>,
     * calling copyOf will generally not create a copy.
     *
     * @param <K> the {@code Map}'s key type
     * @param <V> the {@code Map}'s value type
     * @param map a {@code Map} from which entries are drawn, must be non-null
     * @return a {@code Map} containing the entries of the given {@code Map}
     * @throws NullPointerException if map is null, or if it contains any null keys or values
     * @since 10
     */
    @SuppressWarnings({"rawtypes","unchecked"})
    static <K, V> Map<K, V> copyOf(Map<? extends K, ? extends V> map) {
        if (map instanceof ImmutableCollections.AbstractImmutableMap) {
            return (Map<K,V>)map;
        } else {
            return (Map<K,V>)Map.ofEntries(map.entrySet().toArray(new Entry[0]));
        }
    }

Lambda表达式

简介

什么是Lambda

Lambda是JAVA 8 添加的新特性，是一个匿名函数，使用Lambda表达式可以对一个接口进行非常简洁的实现。它是实现接口的一种方式。

示例

package com.louis;

/**
 * @author XRY
 * @date 2023年08月31日16:16
 */
public class Program {
    //1、实现接口
    MyComparator myComparator = new MyComparator();
    //2、使用匿名内部类
    Comparator comparator = new Comparator() {
        @Override
        public int compare(int a, int b) {
            return a-b;
        }
    };
    //3、使用Lambda表达式实现接口
    Comparator comparator1 = (a, b)->a-b;

    class MyComparator implements Comparator{

        @Override
        public int compare(int a, int b) {
            return a - b;
        }
    }


    interface Comparator{
        int compare(int a, int b);
    }
}

Lambda对接口的要求

虽然可以使用Lambda表达式对某些接口进行简单的实现，但并不是所有的接口都可以使用Lambda表达式实现。要求接口中定义的必须要实现的抽象方法只能是一个。

在JAVA8对接口加了一个新特性：default(可以实现也可以不实现)。

@FunctionalInterface:用来修饰函数式接口，即接口中的抽象方法只有一个。

@FunctionalInterface
interface Comparator{
    int compare(int a, int b);
}

Lambda基础语法

Lambda是一个匿名函数，最主要包括参数列表和方法体。

()：用来描述参数列表

{}：用来描述方法体

->：Lambda运算符，读作goes to

不同类型接口

package com.louis.interfaces;

/**
 * @author XRY
 * @date 2023年08月31日16:34
 */
public class Interfaces {
    @FunctionalInterface
    public interface LambdaHaveReturnMultipleParameter {
        int test(int a, int b);
    }

    @FunctionalInterface
    public interface LambdaHaveReturnNoneParameter {
        int test();
    }

    @FunctionalInterface
    public interface LambdaHaveReturnSingleParameter {
        int test(int a);
    }

    @FunctionalInterface
    public interface LambdaNoneReturnMultipleParameter {
        void  test(int a, int b);
    }

    @FunctionalInterface
    public interface LambdaNoneReturnNoneParameter {
        void  test();
    }

    @FunctionalInterface
    public interface LambdaNoneReturnSingleParameter {
        void  test(int n);
    }
}

基础语法实现

package com.louis.syntax;

import com.louis.interfaces.Interfaces;

/**
 * @author XRY
 * @date 2023年08月31日16:36
 */
public class Syntax1 {
    public static void main(String[] args) {
        //1、Lambda表达式的基础语法
        /*Lambda是一个匿名函数，最主要包括参数列表和方法体。
        ()：用来描述参数列表
        {}：用来描述方法体
        ->：Lambda运算符，读作goes to*/


        //无参无返回
        Interfaces.LambdaNoneReturnNoneParameter lambda1 = ()->{
            System.out.println("hello Lambda");
        };
        lambda1.test();
        /*hello Lambda*/

        //无返回值单个参数
        Interfaces.LambdaNoneReturnSingleParameter lambda2 = (int a) -> {
            System.out.println(a);
        };
        lambda2.test(2);
        /*2*/

        //无返回值、多个参数
        Interfaces.LambdaNoneReturnMultipleParameter lambda3 = (int a, int b)->{
            System.out.println(a-b);
        };
        lambda3.test(10, 20);
        /*-10*/

        //有返回值、无参数
        Interfaces.LambdaHaveReturnNoneParameter lambda4 = ()->{
            System.out.println("lambda4");
            return 100;
        };
        int test = lambda4.test();
        System.out.println(test);
        /*lambda4
          100*/

        //有返回值、有一个参数
        Interfaces.LambdaHaveReturnSingleParameter lambda5 = (int a)->{
            return a + 2;
        };
        int test1 = lambda5.test(10);
        System.out.println(test1);
        /*12*/

        //有返回值、多个参数
        Interfaces.LambdaHaveReturnMultipleParameter lambda6 = (int a, int b)->{
            return a + b;
        };
        int test2 = lambda6.test(10, 20);
        System.out.println(test2);
        /*30*/
    }
}

Lambda语法精简

1、参数：

参数类型：由于在接口中已经定义了参数的类型和数量，所以在Lambda表达式中参数的类型可以省略。
注意：如果需要省略类型，则每一个参数的类型都要省略。千万不要出现省略一个参数，不省略一个参数类型的请况。

参数小括号：如果参数列表中，参数的数量只有一个。此时小括号可以省略。

2、方法体

方法大括号：如果方法体中只有一条语句，此时大括号可以省略。

方法体有返回：如果方法体中唯一的一条语句是一个返回语句，则在省略掉大括号的同时也必须省略掉return。

package com.louis.syntax;

import com.louis.interfaces.Interfaces;

/**
 * @author XRY
 * @date 2023年08月31日16:58
 */
public class Syntax2 {
    public static void main(String[] args) {
        //语法精简
        //1、参数类型
        /*参数类型：由于在接口中已经定义了参数的类型和数量，所以在Lambda表达式中参数的类型可以省略。
`       注意：`如果需要省略类型，则每一个参数的类型都要省略。千万不要出现省略一个参数，不省略一个参数类型的请况。*/
        Interfaces.LambdaNoneReturnMultipleParameter lambda1 = (a, b)->{
            System.out.println("Hello Lambda" + (a + b));
        };
        lambda1.test(10, 11);
        /*Hello Lambda21*/

        //2、参数小阔号
        /*如果参数列表中参数数量只有一个，可以省略小括号*/
        Interfaces.LambdaNoneReturnSingleParameter lambda2 = a->{
            System.out.println(a);
        };
        lambda2.test(10);
        /*10*/

        //3、方法大括号：如果方法体中只有一条语句，此时大括号可以省略
        Interfaces.LambdaNoneReturnSingleParameter lambda3 = a-> System.out.println(a);
        lambda3.test(12);
        /*12*/

        //4、方法体有返回：如果方法体中唯一的一条语句是一个返回语句，则在省略掉大括号的同时也必须省略掉return。
        Interfaces.LambdaHaveReturnNoneParameter lambda4 = ()->13;
        int test = lambda4.test();
        System.out.println(test);
        /*13*/
    }
}

Lambda语法进阶

方法引用

方法引用:可以将一个Lambda表达式的实现指向一个已经实现的方法。

语法：方法的隶属者::方法名，如果是静态方法，隶属者就是所在类，如果是非静态，隶属者就是所在对象。

注意：

• 1、参数数量和类型必须和接口中定义的方法一致
• 2、返回值的类型也一定需要和接口中定义的方法一致

package com.louis.syntax;

import com.louis.interfaces.Interfaces;

/**
 * @author XRY
 * @date 2023年08月31日17:19
 */
public class Syntax3 {
    public static void main(String[] args) {
        //方法引用:可以将一个Lambda表达式的实现指向一个已经实现的方法。
        //语法：方法的隶属者::方法名，如果是静态方法，隶属者就是所在类，如果是非静态，隶属者就是所在对象。
        /*注意：
        * 1、参数数量和类型必须和接口中定义的方法一致
        * 2、返回值的类型也一定需要和接口中定义的方法一致
        * */
        

        /*Interfaces.LambdaHaveReturnSingleParameter lambda = a->a*2;*/
        Interfaces.LambdaHaveReturnSingleParameter lambda1 = a->change(a);
        //方法引用：引用了change的方法实现
        Interfaces.LambdaHaveReturnSingleParameter lambda2 = Syntax3::change;

    }

    private static int change(int a){
        return a*2;
    }
}

构造方法引用

Person实体类

package com.louis.data;

/**
 * @author XRY
 * @date 2023年08月31日17:33
 */
public class Person {
    public String name;
    public Integer age;

    public Person(){
        System.out.println("Person的无参构造方法");
    }

    public Person(String name, Integer age){
        this.age = age;
        this.name = name;
        System.out.println("Person类的有参构造执行了");
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

构造方法引用

package com.louis.syntax;

import com.louis.data.Person;
import com.louis.interfaces.Interfaces;

/**
 * @author XRY
 * @date 2023年08月31日16:36
 */
public class Syntax4 {
    public static void main(String[] args) {
        PersonCreator creator = ()->new Person();
        creator.getPerson();
        /*Person的无参构造方法*/

        //无参构造方法的引用
        PersonCreator creator1 = Person::new;
        creator1.getPerson();
        /*Person的无参构造方法*/

        //有参构造方法的引用
        PersonCreator1 creator2 = Person::new;
        creator2.getPerson("louis", 24);
        /*Person类的有参构造执行了*/

    }
    //场景：
    interface PersonCreator{
        Person getPerson();
    }

    interface PersonCreator1{
        Person getPerson(String name, int age);
    }
}

实例

实例1

在一个ArrayList中有若干个Person对象，将这些Person对象按照年龄降序排序

package com.louis.exercise;

import com.louis.data.Person;

import java.util.ArrayList;

/**
 * @author XRY
 * @date 2023年08月31日17:47
 */
public class Exercise1 {
    //集合排序ArrayList
    public static void main(String[] args) {
        //场景：已知在一个ArrayList中有若干个Person对象，将这些Person对象按照年龄降序排序
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("a", 10));
        list.add(new Person("b", 8));
        list.add(new Person("c", 3));
        list.add(new Person("d", 9));
        list.add(new Person("e", 7));
        list.add(new Person("f", 5));
        list.add(new Person("g", 1));

        list.sort(((o1, o2) -> o2.age-o1.age));

        System.out.println(list);
        /*[Person{name='a', age=10}, Person{name='d', age=9}, Person{name='b', age=8}, Person{name='e', age=7}, Person{name='f', age=5}, Person{name='c', age=3}, Person{name='g', age=1}]*/
    }
}

实例2

TreeSet:它是一个set集合，但它能够对集合中的内容进行自动排序，如果两个年龄相同只会保留一个，可以添加逻辑进行保留

package com.louis.exercise;

import com.louis.data.Person;

import java.util.ArrayList;
import java.util.TreeSet;

/**
 * @author XRY
 * @date 2023年08月31日17:47
 */
public class Exercise2 {
    //使用Lambda表达式实现Comparator接口
    // TreeSet:它是一个set集合，但它能够对集合中的内容进行自动排序，如果两个年龄相同只会保留一个，可以添加逻辑进行保留
    public static void main(String[] args) {
        TreeSet<Person> set = new TreeSet<>((o1, o2)->o2.age-o1.age);
        set.add(new Person("a", 10));
        set.add(new Person("b", 8));
        set.add(new Person("c", 3));
        set.add(new Person("d", 9));
        set.add(new Person("e", 7));
        set.add(new Person("f", 5));
        set.add(new Person("g", 1));

        System.out.println(set);
        /*[Person{name='a', age=10}, Person{name='d', age=9}, Person{name='b', age=8}, Person{name='e', age=7}, Person{name='f', age=5}, Person{name='c', age=3}, Person{name='g', age=1}]*/
    }
}

实例3

集合遍历

package com.louis.exercise;

import java.util.ArrayList;
import java.util.Collections;

/**
 * @author XRY
 * @date 2023年08月31日18:08
 */
public class Exercise3 {
    //遍历结合
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7, 8);

        //将集合中的每一个元素都带入到方法accept中
        list.forEach(System.out::print);
        /*12345678*/

        //输出集合中所有的偶数
        list.forEach(ele->{if(ele%2==0) System.out.print(ele + " ");});
        /*2 4 6 8*/
    }
}

实例4

removeIf：移除满足条件的元素

package com.louis.exercise;

import com.louis.data.Person;

import java.util.ArrayList;

/**
 * @author XRY
 * @date 2023年08月31日18:58
 */
public class Exercise4 {
    public static void main(String[] args) {
        //需求：删除集合中满足条件的元素
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("a", 10));
        list.add(new Person("b", 8));
        list.add(new Person("c", 3));
        list.add(new Person("d", 9));
        list.add(new Person("e", 7));
        list.add(new Person("f", 5));
        list.add(new Person("g", 1));
        
        //删除集合中年龄大于5的元素
        //将集合中的每一个元素都带入到test方法中，如果返回值是true则删除这个元素
        list.removeIf(ele->ele.age>5);
        System.out.println(list);
        
        /*[Person{name='c', age=3}, Person{name='f', age=5}, Person{name='g', age=1}]*/
    }
}

实例5

package com.louis.exercise;

import com.louis.data.Person;

import java.util.ArrayList;

/**
 * @author XRY
 * @date 2023年08月31日17:47
 */
public class Exercise5 {
    public static void main(String[] args) {
        //线程实例化
        Thread thread = new Thread(()->{
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        });

        thread.start();
        /*0 1 2 3 4 5 6 7 8 9 */
    }
}

函数式接口

系统内置的函数式接口

1、Predicate<T> ：参数T ，返回Boolean

​ IntPredicate<T> ：参数int ，返回Boolean

​ LongPredicate<T> ：参数long ，返回Boolean

​ DoublePredicate<T> ：参数double ，返回Boolean

2、Consumer<T>： 参数T，返回值void

​ IntConsumer 参数int，返回值void

​ LongConsumer 参数long，返回值void

​ DoubleConsumer 参数double，返回值void

3、Function<T， R>：参数T，返回值R–>指定类型的参数、指定类型的返回值

​ IntFunction< R>：参数int，返回值R

​ LongFunction< R>：参数long，返回值R

​ DoubleFunction< R>：参数double，返回值R

​ IntToLongFunction：参数int，返回值long

​ IntToDoubleFunction：参数int，返回值double

​ LongToIntFunction：参数long，返回值int

​ LongToDoubleFunction：参数long，返回值double

​ DoubleToIntFunction：参数double，返回值int

​ DoubleToLongFunction：参数double，返回值long

4、Supplier<T>：无参，返回值T

5、UnaryOperator<T>：参数T，返回值T

6、BinaryOperator<T> ：参数T，T，返回值T

7、BiFunction<T, U, R> ：参数T，U，返回值R

8、BiPredicate<T, U>：参数T、U 返回值boolean

9、BiConsumer<T, U>：参数T，U返回值void

Stream流

示例

场景：创建一个集合，存储多个字符串元素，完成集合的创建和遍历。

ArrayList<String> list = new ArrayList<>();
list.add("张三");
list.add("王大锤");
list.add("张三三");
list.add("张二三");
list.add("李斯");

要求：

• 把所有以"张"开头的元素存储到新集合中
• 把"张"开头，长度为三的元素再存储到新集合中
• 遍历打印最终结果

package com.louis.stream;

import java.util.ArrayList;

/**
 * @author XRY
 * @date 2023年08月30日19:07
 */
public class StreamDemo1 {
    public static void main(String[] args) {
        /**
         * 创建集合添加元素，完成以下需求
         * - 把所有以"张"开头的元素存储到新集合中
         * - 把"张"开头，长度为三的元素再存储到新集合中
         * - 遍历打印最终结果
         */

        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("王大锤");
        list.add("张三三");
        list.add("张三四");
        list.add("李斯");

/*        //1、把所有以"张"开头的元素存储到新集合中
        ArrayList<String> list1 = new ArrayList<>();
        for (String name : list) {
            if(name.startsWith("张")){
                list1.add(name);
            }
        }
        System.out.println(list1);

        //2、把"张"开头，长度为三的元素再存储到新集合中
        ArrayList<String> list2 = new ArrayList<>();
        for (String name : list1) {
            if(name.length() == 3){
                list2.add(name);
            }
        }

        //3、遍历打印最终结果
        for (String name : list2) {
            System.out.println(name);
        }*/

        list.stream()
                .filter(name->name.startsWith("张"))
                .filter(name->name.length() == 3)
                .forEach(name->System.out.println(name));
    }
}

stream流

流的思想

结合Lambda表达式，简化集合、数组的操作。

使用步骤

1. 先得到一条stream流(流水线)，并把数据放上去

   获取方式	方法名	说明
   单列集合	default Stream<E> stream()	Collecotion中的默认方法
   双列集合	无	无法直接使用stream流
   数组	public static<T> Stream<T> stream(T[] array)	Arrays工具类中的静态方法
   一堆零散数据	public static<T> Stream<T> of(T…values)	Stream接口中的静态方法

2. 使用中间方法对流水线上的数据进行操作

3. 使用终结方法对流水线上的数据进行操作

   中间方法–>方法调用完毕后，还可以调用其他方法（如：过滤、转换）

   终结方法–>最后一步，调用完毕之后，不能调用其它方法（如：统计、打印）

示例

单列集合

package com.louis.stream;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.function.Consumer;
import java.util.stream.Stream;

/**
 * @author XRY
 * @date 2023年08月30日19:07
 */
public class StreamDemo2 {
    public static void main(String[] args) {
        //1、单列集合获取Stream流
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "a", "b", "c", "d", "e");
        //因为Array是Collection中的实现类，所以可以直接使用

        //获取到一条流水线，并把集合中的数据放到流水线上
     /*  Stream<String> stream = list.stream();

        //使用终结方法打印流水线上的所有数据
       stream.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                //s:依次表示流水线上的每一个数据
                System.out.println(s);
            }
        });*/

        list.stream().forEach(s -> {
            System.out.println(s);
        });
        
        /*
        * a
          b
          c
          d
          e
        
        Process finished with exit code 0

        * */
    }
}

双列集合

package com.louis.stream;

import java.util.ArrayList;
import java.util.HashMap;

/**
 * @author XRY
 * @date 2023年08月30日19:07
 */
public class StreamDemo3 {
    public static void main(String[] args) {
       //双列集合   无             不能直接使用stream流

        //1、创建双列集合
        HashMap<Integer, String> map = new HashMap<>();
        //2、添加数据
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        map.put(4, "d");
        //3、获取stream流
        //方式一：获取键的单列集合
        map.keySet().stream().forEach(s-> System.out.println(s));
        /*
        1
        2
        3
        4
        * */
        
        //方式二：
        map.entrySet().stream().forEach(s-> System.out.println(s));
        /*
        1=a
        2=b
        3=c
        4=d
        * */
    }
}

数组

package com.louis.stream;

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

/**
 * @author XRY
 * @date 2023年08月30日19:07
 */
public class StreamDemo4 {
    public static void main(String[] args) {
       //数组     public static<T> Stream<T> stream(T[] array)     Arrays工具类中的静态方法

        //1、创建数组
        int[] arr = {1, 2, 3, 4, 5, 6};

        //2、获取stream流
        Arrays.stream(arr).forEach(s-> System.out.print(s + " "));
        /*1 2 3 4 5 6 */
    }
}

零散数据

需要注意的是，这些数据的类型必须相同。

package com.louis.stream;

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

/**
 * @author XRY
 * @date 2023年08月30日19:07
 */
public class StreamDemo5 {
    public static void main(String[] args) {
       //零散的数据
        Stream.of(1, 2, 3, 4, 5).forEach(re-> System.out.print(re + " "));
        /*1 2 3 4 5 */
    }
}

注意：

Stream接口中静态方法of的使用细节：

方法的形参是一个可变参数，可以传递一堆零散的数据，也可以传递数组。但是数组必须是引用类型，如果传递基本数据类型，会把整个数组当作一个元素，放到Stream当中。

stream流的中间方法

注意：

• 中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程
• 修改Stream流中的数据，不会影响原来集合中或者数组中的数据

filter

package com.louis.stream;

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Predicate;

/**
 * @author XRY
 * @date 2023年08月30日19:07
 */
public class StreamDemo6 {
    public static void main(String[] args) {
        //filter 过滤
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三", "张三三", "李斯", "王五");

        //把姓张的留下
        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                //如果返回值为true,表示当前数据留下
                //如果返回值为false, 表示当前数据舍弃
                return s.startsWith("张");
            }
        }).forEach(re-> System.out.print(re + " "));
        /*张三 张三三 */
        
        list.stream().filter(s->s.startsWith("张")).forEach(re->{
            System.out.print(re + " ");
        });
        /*张三 张三三 */
    }
}

limit

list.stream().limit(3).forEach(re-> System.out.print(re + " "));
/*张三 张三三 李斯 */

skip

list.stream().skip(2).forEach(re-> System.out.print(re + " "));
/*李斯 王五 */

distinct

list.add("张三");
System.out.println(list);
list.stream().distinct().forEach(re-> System.out.print(re + " "));
/*[张三, 张三三, 李斯, 王五, 张三]
  张三 张三三 李斯 王五 */

concat

ArrayList<String> list1 = new ArrayList<>();
Collections.addAll(list1, "louis", "khan");
Stream.concat(list.stream(), list1.stream()).forEach(re-> System.out.print(re + " "));
/*张三 张三三 李斯 王五 louis khan */

map

ArrayList<String> list2 = new ArrayList<>();
Collections.addAll(list2,"louis-21", "khan-23", "alex-24");
//获取集合中的数字

//第一个类型：表示流中原来的数据类型
//第二个类型：表示要转成的之后的类型

//apply的形参s:表示流中的每一个数据
//返回值：表示转换之后的数据
//当map方法执行完毕之后，流上的数据就变成了整数，所以在下面forEach当中，s依次表示流里面的每一个数据，但这个数据现在就是整数
    list2.stream().map(new Function<String, Integer>() {
    @Override
    public Integer apply(String s) {
        String tar = s.split("-")[1];
        return Integer.parseInt(tar);
    };
}).forEach(re -> System.out.print(re + " "));
*//*21 23 24 *//*

list2.stream().map(s -> Integer.parseInt(s.split("-")[1])).forEach(re-> System.out.print(re + " "));
/*21 23 24 */

stream流的终结方法

forEach

package com.louis.stream;

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Consumer;

/**
 * @author XRY
 * @date 2023年08月31日8:53
 */
public class StreamDemo7 {
    public static void main(String[] args) {

        /*
        *
        *   | void forEach(Consumer action) | 遍历                       |
            | long count()                  | 统计                       |
            | toArray()                     | 收集流中的数据，放到数组中 |
            | collect(Collector collector)  | 收集流中的数据，放到集合中 |*/
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三", "张三三", "李斯", "王五");

        //void forEach(Consumer action)
        //accept方法形参s:依次表示流里面的每一个数据
        //方法体：对每一个数据的处理操作(打印)
        list.stream().forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.print(s + " ");
            }
        });
        *//*张三 张三三 李斯 王五 *//*
        
        
        list.stream().forEach(s -> System.out.print(s + " "));
       /*张三 张三三 李斯 王五 */    
    }
}

count

//   long count()  统计

long count = list.stream().count();
System.out.println(count);
/*4*/

Array

//  toArray()                      收集流中的数据，放到数组中
Object[] arr1 = list.stream().toArray();
System.out.println(Arrays.toString(arr1));
/*[张三, 张三三, 李斯, 王五]*/

//指定类型
//IntFunction的泛型：具体类型的数组
//apply的形参：流中数据的个数，要跟数组长度保持一致
//apply的返回值：具体类型的数组
//方法体：就是创建数组
String[] arr2 = list.stream().toArray(new IntFunction<String[]>() {
    @Override
    public String[] apply(int value) {
        return new String[value];
    }
});

System.out.println(Arrays.toString(arr2));
/*[张三, 张三三, 李斯, 王五]*/

String[] arr3 = list.stream().toArray(value -> new String[value]);
System.out.println(Arrays.toString(arr3));
/*[张三, 张三三, 李斯, 王五]*/

collect

package com.louis.stream;

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * @author XRY
 * @date 2023年08月30日19:07
 */
public class StreamDemo8 {
    public static void main(String[] args) {
     ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "louis-男-23", "khan-男-24", "alex-女-21", "jonny-女-22");

        //场景1：收集List集合中所有的男性
        List<String> newList = list.stream()
                .filter(s -> "男".equals(s.split("-")[1]))
                .collect(Collectors.toList());
        System.out.println(newList);
        /*[louis-男-23, khan-男-24]*/

        //场景2：收集Set集合中所有的男性
        Set<String> newList1 = list.stream()
                .filter(s -> "男".equals(s.split("-")[1]))
                .collect(Collectors.toSet());
        System.out.println(newList1);

        //场景3：收集Map集合中所有的男性,键：姓名、值：年龄
        Map<String, Integer> map = list.stream().filter(s -> "男".equals(s.split("-")[1]))
                /*
                 * toMap:包含两个参数
                 * 参数一：表示键的生成规则
                 * 参数二：表示值的生成规则
                 *
                 * 参数一：
                 *   Function泛型一：表示流中每一个数据的类型
                 *           泛型二：表示Map集合中键的数据类型
                 *       方法apply形参：依次表示流里面的每一个数据
                 *           方法体：生成键的代码
                 *           返回值：已经生成的键
                 *
                 * 参数二：
                 *   Function泛型一：表示流中每一个数据的类型
                 *           泛型二：表示Map集合中键的数据类型
                 *       方法apply形参：依次表示流里面的每一个数据
                 *           方法体：生成值的代码
                 *           返回值：已经生成的值
                 *
                 * */
                .collect(Collectors.toMap(new Function<String, String>() {
                    @Override
                    public String apply(String s) {
                        return s.split("-")[0];
                    }
                }, new Function<String, Integer>() {
                    @Override
                    public Integer apply(String s) {
                        return Integer.parseInt(s.split("-")[2]);
                    }
                }));
        System.out.println(map);
        /*{khan=24, louis=23}*/
        //注意：收集到Map集合当中时，键不能重复，否则会报错

        Map<String, Integer> map1 = list.stream().filter(s -> "男".equals(s.split("-")[1]))
                .collect(Collectors.toMap(s -> s.split("-")[0], re -> Integer.parseInt(re.split("-")[2])));
        System.out.println(map1);
        /*{khan=24, louis=23}*/
    }
}

实例

package com.louis.practise;

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

/**
 * @author XRY
 * @date 2023年08月31日9:50
 */
public class Demo01 {
    public static void main(String[] args) {
        /*
         * 定义一个集合，并添加一些整数1、2、3、4、5、6、7、8、9、10
         * 过滤基数，只留下偶数
         * 并将结果保存起来
         * */
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        List<Integer> newList = list.stream().filter(s -> s % 2 == 0).collect(Collectors.toList());
        System.out.println(newList);
        /*[2, 4, 6, 8, 10]*/

        /*
        * 创建一个ArrayList集合，并添加以下字段，字符串中前面时姓名，后面是年龄
        * "张三, 23"
        * "李四, 24"
        * "王五, 25"
        * 保留年龄大于等于24，并将集合收集到Map集合中，姓名为键，年龄为值
        * */
        ArrayList<String> list1 = new ArrayList<>();
        Collections.addAll(list1, "张三, 23", "李四, 24", "王五, 25");
        Map<String, String> newList1 = list1.stream().filter(s -> Integer.parseInt(s.split(", ")[1]) >= 24)
                .collect(Collectors.toMap(s -> s.split(", ")[0], re -> re.split(", ")[1]));
        System.out.println(newList1);
        /*{李四=24, 王五=25}*/

        /*
        * 现在有两个ArrayList集合
        * 第一个集合中：存储6名男演员的名字和年龄， 第二个集合中：存储6名女演员的名字和年龄
        * 姓名和年龄之间使用逗号隔开。如：张三,23
        * 要求：
        * 1、男演员只要名字为三个字的前两个人
        * 2、女演员只要姓杨的，并且不要第一个
        * 3、把过滤后的男演员姓名和女演员姓名合并到一起
        * 4、将上面的演员信息封装成一个Actor对象
        * 5、将所有的演员对象都保存在List集合中
        * Actor类：只有：name、age
        * */
        ArrayList<String> list2 = new ArrayList();
        Collections.addAll(list2,"张三,23", "李四,24", "周杰伦,30", "刘德华,50", "王宝强,50", "胡歌,45");
        ArrayList<String> list3 = new ArrayList();
        Collections.addAll(list3, "杨幂,40", "杨紫,35", "朱丹,45", "柳岩,10", "夏紫,12", "杨演员,35");
        List<String> newList2 = list2.stream().filter(s -> s.split(",")[0].length() == 3).limit(2)
                .collect(Collectors.toList());
        List<String> newList3 = list3.stream().filter(s -> s.startsWith("杨")).skip(1)
                .collect(Collectors.toList());
        List<Actor> listAll = Stream.concat(newList2.stream(), newList3.stream())
                .map((String s) -> new Actor(s.split(",")[0], Integer.parseInt(s.split(",")[1])))
                .collect(Collectors.toList());
        System.out.println(listAll);
        /*[Actor(name=周杰伦, age=30), Actor(name=刘德华, age=50), Actor(name=杨紫, age=35), Actor(name=杨演员, age=35)]*/
    }
}

Actor文章来源地址https://www.toymoban.com/news/detail-694348.html

package com.louis.practise;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author XRY
 * @date 2023年08月31日10:30
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Actor {
    private String name;
    private Integer age;
}

到了这里，关于不可变集合、Lambda表达式、Stream流的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！