Java8新特性 Stream流式思想(三)

刚刚开始写博客，有一些不到位的地方还请各位论坛大佬多多指点，谢谢！

• forEach()方法

package cn.com.cqucc.demo02.StreamMethods.Test02.StreamMethods;

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

/*
 *       forEach方法练习
 *          void forEach​(Consumer<? super T> action) 对此流的每个元素执行操作。
 *              参数 ：
 *                  Consumer 是一个函数式接口，会将每一个流元素交给该函数去处理；
 *                  它是一个消费型函数式接口，由于是一个函数是接口，所以可以使用Lambda表达式。
 *               作用：
 *                  遍历数据。
 *               注意：
 *                  它是一个终结方法，使用之后就不能再使用Stream流中的其他方法了，否则会抛出异常。
 * */
public class Test01StreamForeach {

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六");
        list.add("田七");
        list.add("王八");
//        1、先将list转换为Stream流
        Stream<String> stream = list.stream();
//        2、使用Stream的forEach方法遍历集合
        stream.forEach(s -> System.out.print(s + "  "));// 输出结果 ：张三  李四  王五  赵六  田七  王八
//        3、如果在此使用该流会怎样？
        stream.filter(s -> s.startsWith("张"));
//        将抛出这个异常 ： java.lang.IllegalStateException: stream has already been operated upon or closed
    }
}

　　

• filter()方法

package cn.com.cqucc.demo02.StreamMethods.Test02.StreamMethods;

import java.util.stream.Stream;

/*
*   Stream的filter()方法的使用
*       Stream<T> filter​(Predicate<? super T> predicate) 返回由与此给定谓词匹配的此流的元素组成的流。
*       参数 ：
*           该方法的参数接收的是一个函数式接口，所以可以使用Lambda表达式
*       作用：进行元素的过滤
*
*       Stream流的特点 ：
            1、属于管道流 只能被消费（使用）一次
            2、第一个Stream 流调用完毕方法数据就会流转到下一个Stream流上 此时第一个 Stream 已经使用完毕就会关闭了
                此时第一个stream流就不能调用方法类了
                我们的stream流只能使用一次
* */
public class Test02StreamFilter {

    public static void main(String[] args) {
//        创建一个流
        Stream<String> streamA = Stream.of("张三", "李四", "王五", "赵六", "田七", "王八");
//        我只需要姓 “张”的 所以 调用 Stream流的方法 filter进行过滤
        streamA.filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));// 输出结果 ：张三

//        注意
        Stream<String> streamB = Stream.of("小明", "李华", "王二");
        Stream<String> streamC = streamB.filter(s -> s.startsWith("李"));
//        streamB.forEach(s-> System.out.println(s));//此时在使用之前的流会抛出异常 IllegalStateException
        streamC.forEach(s -> System.out.println(s));// 输出结果 ：李华
    }
}

　　

• map()方法

package cn.com.cqucc.demo02.StreamMethods.Test02.StreamMethods;

import java.util.stream.Stream;

/*
 *     <R> Stream<R> map​(Function<? super T,? extends R> mapper) 返回由给定函数应用于此流的元素的结果组成的流。
 *              参数 ：
 *                一个 函数式接口 Function ，可以将函数中T类型的数据类型转换为R类型的流
 *                可以将一种类型转换为另一种类型，就叫映射。
 *              作用：
 *                  map 映射 ： 如果需要将流中的元素映射到另一个流中 ， 就使用map方法
 * */
public class Test03StreamMap {

    public static void main(String[] args) {
//      需求 ： 将字符串类型的整数转换为 Integer类型的整数
        Stream<String> stringStream = Stream.of("1", "2", "1", "3");
        Stream<Integer> integerStream = stringStream.map(s -> Integer.parseInt(s));
        integerStream.forEach(s -> System.out.println(s));
    }
}

　　

• count()方法

package cn.com.cqucc.demo02.StreamMethods.Test02.StreamMethods;

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

/*
 *       Stream流中的方法 long count​() 返回此流中的元素数。
 *
 *          作用：
 *               用于统计Stream流中元素的个数
 *          注意：
 *               count方法是一个终结方法，使用完它之后就不能在使用 Stream流中的其他方法
 *
 * */
public class Test04StreamCount {

    public static void main(String[] args) {

        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六");
        list.add("田七");
        list.add("王八");

        Stream<String> streamList = list.stream();
//        long count = streamList.count();
        long count = streamList.count();//调用它之后就不能再调用流中的其他方法了
        System.out.println(count);//6
    }
}

　　

• limit()方法

package cn.com.cqucc.demo02.StreamMethods.Test02.StreamMethods;

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

/*
 *       Stream 方法中的 Stream<T> limit​(long maxSize) 返回由此流的元素组成的流，截短长度不能超过 maxSize 。
 *              参数：
 *                  参数是一个long类型的数据 如果 集合的长度大于 参数的长度 则进行截取 否则不进行任何操作
 *              作用：
 *                  limit方法可以对 流中的元素进行截取 只取前n个
 * */
public class Test06StreamLimit {

    public static void main(String[] args) {
        //        获取一个Stream流
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六");
        list.add("田七");

        Stream<String> stream = list.stream();
//        使用limit方法对stream流中的元素进行截取，只要前2个元素 并对流进行遍历
        stream.limit(2).forEach(s-> System.out.println(s));
    }
}

　　

• skip()方法

package cn.com.cqucc.demo02.StreamMethods.Test02.StreamMethods;

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

/*
 *   Stream 方法中的 Stream<T> skip​(long n) 在丢弃流的第一个 n元素后，返回由该流的剩余元素组成的流。
 *           参数 ：
 *               是一个long类型的数据
 *            作用：
 *               如果希望跳过前n个元素就是用Stream的skip方法 获取一个截取之后的流
 *               如果流的当前长度大于n，则跳过前n个否则的到一个长度为0的流。
 * */
public class Test06StreamSkip {

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("赵四");
        list.add("王五");
        list.add("赵六");
        list.add("田七");
        list.add("王八");

        Stream<String> stream = list.stream();
        stream.skip(3).forEach(s -> System.out.print(s + "  "));//输出结果：赵六  田七  王八
    }
}

　　

• concat方法

package cn.com.cqucc.demo02.StreamMethods.Test02.StreamMethods;

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

/*
 *      Stream接口中的static <T> Stream<T> concat​(Stream<? extends T> a, Stream<? extends T> b)
 *          创建一个懒惰连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。
 *         参数：
 *              两个流
 *         作用：
 *              如果你有两个流，你希望合并为一个流，那么就可以使用Stream流的静态方法concat
 * */
public class Test07StreamConcat {

    public static void main(String[] args) {

        List<String> listA = new ArrayList<>();
        listA.add("张三");
        listA.add("李四");
        listA.add("王五");
        listA.add("赵六");
        listA.add("田七");
        listA.add("王八");

        List<String> listB = new ArrayList<>();
        listB.add("小明");
        listB.add("张强");
        listB.add("李华");

        Stream<String> streamA = listA.stream();
        Stream<String> streamB = listB.stream();

        Stream<String> concatAB = Stream.concat(streamA, streamB);

        concatAB.forEach(s -> System.out.print(s + "   "));//张三   李四   王五   赵六   田七   王八   小明   张强   李华
    }
}

　　

原文：https://blog.csdn.net/qq_41319058/article/details/90321251