Stream流中的常用方法:

  1. 逐一处理:forEach
  2. 过滤:filter
  3. 映射:map
  4. 统计个数:count
  5. 取用前几个:limit
  6. 跳过前几个:skip
  7. 组合:concat

逐一处理:forEach

package JDK8.Xin.Demo01Stream; 
 
import java.util.stream.Stream; 
 
/* 
    Stream流中的常用方法_forEach 
    void forEach(Consumer<? supper T> action); 
    该方法接收一个Consumer接口函数,会将每一个流元素交给该函数进行处理。 
    Consumer接口是一个消费型接口,可以传递Lambda表达式,消费数据。 
 
    简单记: 
        forEach方法,用来遍历流中的数据 
        是一个终结方法,遍历之后就不能继续调用Stream流中的其他方法 
 */ 
public class Demo01Stream_ForEach { 
    public static void main(String[] args) { 
        //获取一个Stream流 
        Stream<String> stream = Stream.of("张三", "李四", "王五", "麻六"); 
        //使用Stream流中的方法forEach对Stream流中的数据进行遍历 
        /*stream.forEach((name)->{ 
            System.out.println(name); 
        });*/ 
 
        //优化Lambda表达式 
        stream.forEach(name->System.out.println(name)); 
    } 
} 

运行结果:

张三 
李四 
王五 
麻六

 过滤:filter

package JDK8.Xin.Demo01Stream; 
 
import java.util.stream.Stream; 
 
/* 
    Stream流中常用方法_filter:用于对Stream流中的数据进行过滤 
    Stream<T> filter(Predicate<? super T> predicate); 
    filter方法的参数Predicate中的抽象方法: 
        Boolean test(T t); 
 */ 
public class Demo02Stream_filter { 
    public static void main(String[] args) { 
        //创建一个Stream流 
        Stream<String> stream = Stream.of("张三", "李四", "张五", "麻六"); 
        //对Stream流中的元素进行过滤,只要姓张的人 
        Stream<String> stream2 = stream.filter(name->name.startsWith("张")); 
        //遍历stream2流 
        stream2.forEach(name-> System.out.println(name)); 
    } 
} 

运行结果:

张三 
张五

映射:map

package JDK8.Xin.Demo01Stream; 
 
import java.util.stream.Stream; 
 
/* 
    如果需要将流中的元素映射到另一个流中,可以使用map方法。 
    <R> Stream<R> map(Function<? super T, ? extends R> mapper); 
    该接口需要一个Function函数式接口参数,可以将当前流中的T类型数据转换为另一种R类型的流。 
    Function中的抽象方法: 
        R apply(T t); 
 */ 
public class Demo03Stream_map { 
    public static void main(String[] args) { 
        //获取一个Stream类型的Stream流 
        Stream<String> stream = Stream.of("1","2","3","4","5","6"); 
        //使用map方法,把字符串类型的整数,转换(映射)为Integer类型的整数 
        Stream<Integer> stream2 = stream.map(s->Integer.parseInt(s)); 
        //遍历stream2流 
        stream2.forEach(i-> System.out.println(i)); 
    } 
} 

运行结果:

1 
2 
3 
4 
5 
6

统计个数:count

package JDK8.Xin.Demo01Stream; 
 
import java.util.ArrayList; 
import java.util.stream.Stream; 
 
/* 
    Stream流中的常用方法_count:用于统计Stream流中元素的个数 
    Long count(); 
    count方法是一个终结方法,返回值是一个Long类型的整数 
    所以不能再继续调用Stream流中的其他方法了 
 */ 
public class Demo04Stream_count { 
    public static void main(String[] args) { 
        //获取一个Stream流 
        ArrayList<Integer> list = new ArrayList<>(); 
        list.add(1); 
        list.add(2); 
        list.add(3); 
        list.add(4); 
        list.add(5); 
        list.add(6); 
        Stream<Integer> stream = list.stream(); 
        long count = stream.count(); 
        System.out.println(count); 
    } 
} 

运行结果:

6

取用前几个:limit

package JDK8.Xin.Demo01Stream; 
 
import java.util.stream.Stream; 
 
/* 
    Stream流中的常用方法_limit:用于截取流中的元素 
    limit方法可以对流进行截取,只取用前n个。 
    Stream<T> limit(long maxSize); 
        参数是一个lang型,如果集合当前长度大于参数则进行截取;否则不进行操作 
    limit方法是一个延迟方法,只是对流中的元素进行截取,返回的是一个新的流,所以可以继续调用Stream流中的其他方法 
 */ 
public class Demo05Stream_limit { 
    public static void main(String[] args) { 
        //获取一个Stream流 
        String[] arr = {"张三", "李四", "张五", "麻六"}; 
        Stream<String> stream = Stream.of(arr); 
        //使用limit对Stream流中的元素进行截取,只要前3个元素 
        Stream<String> stream2 = stream.limit(3); 
        //遍历stream2流 
        stream2.forEach(name-> System.out.println(name)); 
    } 
} 

运行结果:

张三 
李四 
张五

跳过前几个:skip

package JDK8.Xin.Demo01Stream; 
 
import java.util.stream.Stream; 
 
/* 
    Stream流中的常用方法_skip:用于跳过元素 
    如果希望跳过前几个元素,可以使用skip方法获取一个截取之后的新流: 
    Stream<T> skip(lang n); 
        如果流当前长度大于n,则跳过前n个;否则将会到的一个长度为0的空流。 
 */ 
public class Demo06Stream_skip { 
    public static void main(String[] args) { 
        //获取一个Stream流 
        String[] arr = {"张三", "李四", "张五", "麻六"}; 
        Stream<String> stream = Stream.of(arr); 
        //使用skip方法跳过前3个元素 
        Stream<String> stream2 = stream.skip(3); 
        //遍历stream2流 
        stream2.forEach(name-> System.out.println(name)); 
    } 
} 

运行结果:

麻六

组合:concat

package JDK8.Xin.Demo01Stream; 
 
import java.util.stream.Stream; 
 
/* 
    Stream流中的常用方法_concat:用于把流组合到一起 
    如果有两个流,希望合并成为一个流,那么可以使用Stream接口的静态方法concat 
    static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) 
 */ 
public class Demo07Stream_concat { 
    public static void main(String[] args) { 
        //创建一个Stream流 
        Stream<String> stream1 = Stream.of("张三", "李四", "张五", "麻六"); 
        //获取一个Stream流 
        String[] arr = {"田七", "老八", "小九"}; 
        Stream<String> stream2 = Stream.of(arr); 
        //把以上两个流组合为一个流 
        Stream<String> concat = Stream.concat(stream1, stream2); 
        //遍历concat流 
        concat.forEach(name-> System.out.println(name)); 
    } 
} 

运行结果:

张三 
李四 
张五 
麻六 
田七 
老八 
小九

发布评论
IT源码网

微信公众号号:IT虾米 (左侧二维码扫一扫)欢迎添加!

Java>Request获取请求参数通用方式、请求转发、共享数据、获取ServletContext讲解
你是第一个吃螃蟹的人
发表评论

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。