Java8———Stream接口

原创 2018年04月15日 19:41:34

今天我把Stream接口给大家介绍 一下:算是对上一篇博客的补充。-。-

串行Stream排序

  在整个Collection接口里面有一个取得Stream接口对象的方法:default Stream<E> stream();

    stream的操作:
1.Stream相当于是所有数据的流式数据分析工具,既然是数据的分析,那么就需要对数据执行
   2.一些简单的操作,例如:可能需要一些过滤,即:满足一些条件之后的数据可以进行分析
   3.我们使用filter进行过滤:filter方法的参数是一个Predicate<T>对象,即一个从T到boolean的函数

  4.即:public Stream<T> filter(Predicate<? super T> predicate);

话不多说,直接上代码:

/* @author maye_C
 *
 */
public class StreamDemo1 {

	public static void main(String[] args) {
		
		List<String> list = new ArrayList<String>();
		list.add("a1");
		list.add("a2");
		list.add("a3");
		list.add("b1");
		list.add("b2");
		list.add("b3");
		streamSortTest(list);
		
	}
	private static void streamSortTest(List<String> list) {
		
		//默认排序
		list.stream().filter(s->s.startsWith("a")).forEach(System.out::println);
		System.out.println("---------------华丽的分割线-----------------");
		
		//自定义排序
		list.stream().sorted((s, t1)->t1.compareTo(s)).filter(s->s.startsWith("a")).forEach(System.out::print);
		
	}
	
}
/**
 * Stream映射
 * 映射(map):结合Function接口,该操作能将流对象中的每一个元素映射为另一个元素,实现元素类型的转换
 * @author maye_C
 *
 */
public class StreamDemo2 {

	public static void main(String[] args) {
		
		List<String> list = new ArrayList<String>();
		
		 list.add("a1");
		 list.add("a2");
		 list.add("a3");
		 list.add("b1");
		 list.add("b2");
		 list.add("b3");
		 
		 streamMapTest(list);
	}

	private static void streamMapTest(List<String> list) {
		
		list.stream().map(String::toUpperCase).sorted((s, t1)->t1.compareTo(s)).forEach(System.out::println);
		System.out.println("---------------华丽的分割线-----------------");
		
		//自定义映射规则
		Function<String, String> func = s->{
			return s + ".docx";
		};
		list.stream().map(func).forEach(System.out::println);
	}
}
Lambda为java8带来了闭包,支持对集合对象的stream进行函数式操作, stream api被集成进了collection api  ,允许对集合对象进行批量操作。
 Stream表示数据流,它没有数据结构,本身也不存储元素,其操作也不会改变源Stream,而是生成新Stream.作为一种操作数据的接口,它提供了过滤、排序、映射、规约等多种操作方法,
 这些方法按照返回类型被分为两类:凡是返回Stream类型的方法,称之为中间方法(中间操作),其余的都是完结方法(完结操作)。完结方法返回一个某种类型的值,而中间方法则返回新的Stream。
 中间方法的调用通常是链式的,该过程会形成一个管道,当完结方法被调用时会导致立即从管道中消费值,这里我们要记住:Stream的操作尽可能以“延迟”的方式运行,也就是我们常说的“懒操作”,
 这样有助于减少资源占用,提高性能。对于所有的中间操作(除sorted外)都是运行在延迟模式下。

 Stream不但提供了强大的数据操作能力,更重要的是Stream既支持串行也支持并行,并行使得Stream在多核处理器上有着更好的性能。

**
 * Stream过滤器
 * 
 *  Stream的使用过程有着固定的模式:
 1.						1.创建Stream
 2.						2.通过中间操作,对原始Stream进行“变化”并生成新的Stream
 3.						3.使用完结操作,生成最终结果
 * @author maye_C
 *
 */
public class StreamDemo3 {

	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		
		 list.add("a1");
		 list.add("a2");
		 list.add("a3");
		 list.add("b1");
		 list.add("b2");
		 list.add("b3");
		streamFilterTest(list);
	}

	private static void streamFilterTest(List<String> list) {
		
		//将开头是a的全部过滤出来
		list.stream().filter(s->s.startsWith("b")).forEach(System.out::println);
		
		System.out.println("--------------------华丽的分割线---------------------");
		
		//等价于以上操作
		Predicate<String> predicate = (s) -> s.startsWith("a");
		list.stream().filter(predicate).forEach(System.out::println);
		
		System.out.println("--------------------华丽的分割线---------------------");
		
		//连续过滤
		Predicate<String> predicate1 = (s) ->s.endsWith("3");// 把结尾是1的元素过滤出来
		
		list.stream().filter(predicate1).forEach(System.out::println);
		
		
		
		
	}
	
}

/**
 * 
 * @author maye_C
 *
 */
public class StreamDemo4 {
	
	public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("a1");
        list.add("a2");
        list.add("a3");
        list.add("b1");
        list.add("b2");
        list.add("b3");
        
        streamMatchTest(list);
	}

	private static void streamMatchTest(List<String> list) {
		// TODO Auto-generated method stub
		
		//流对象中只要有一个元素匹配就返回true
		
		boolean anyStartWithA = list.stream().anyMatch(s->s.startsWith("a"));
		
		System.out.println("集合中a开头的元素:" + anyStartWithA);//true
		
		System.out.println("-------------------华丽的分割线----------------");
		
		//流对象中匹配所有元素才放回true
		boolean allStartWith = list.stream().allMatch(s->s.startsWith("a"));
		
		System.out.println("集合中每个元素都都是以a开头:" + allStartWith);//false
		
		System.out.println("-------------------华丽的分割线----------------");
		
		
		//流对象中没有匹配时返回true
		boolean noneStartWith = list.stream().noneMatch(s->s.startsWith("c"));
		
		System.out.println("集合中没有以c开头的元素:" + noneStartWith);//true
	}
	
	
}
Stream收集

     收集(collect):在对经过变换后,将变换的stream元素收集,比如将这些元素存在集合中,可以使用stream提供的collect方法

* @author maye_C
 *
 */
public class StreamDemo5 {

	public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("a1");list.add("a2");list.add("a3");
        list.add("b1");list.add("b2");list.add("b3");
        streamCollectTest(list);
    }

	private static void streamCollectTest(List<String> list) {
		
		//返回一个新的集合
		List<String> newList = list.stream().filter(s->s.startsWith("b")).collect(Collectors.toList());
		
		System.out.println(newList);
	}
	
}
/**
 * Stream接口之规约
 * @author maye_C
 *
 */
public class StreamDemo6 {

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("a1");list.add("a2");list.add("a3");
        list.add("b1");list.add("b2");list.add("b3");
        
        streamReduceTest(list);
    }

	private static void streamReduceTest(List<String> list) {
		
		Optional<String> optional = list.stream().sorted().reduce((s, s2)->{
			 
			System.out.println(s + ":" + s2);
			return s + ":" + s2;
			
		});
		
	}
}
/**
 * Stream计数
 * @author maye_C
 *
 */
public class StreamDemo7 {
	
	public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("a1");list.add("a2");list.add("a3");list.add("b1");list.add("b2");list.add("b3");
        streamCountTest(list);
    }

	private static void streamCountTest(List<String> list) {
		
		//返回值是一个long类型  long count();
		long count = list.stream().filter(s->s.startsWith("a")).count();
		
		System.out.println("以'b'开头的元素的数量:" + count);
		
		
		
	}
}
并行Stream:基于Fork-join并行分解框架实现,将大数据集合切分为多个小数据结合交给不同的线程去处理,这样在多核处理情况下,性能会得到很大的提高。
 这和MapReduce的设计理念一致:大任务化小,小任务再分配到不同的机器执行。只不过这里的小任务是交给不同的处理器。

 结果是性能提高50%,单核下还是串行流性能比较好,并行流的使用场景是多核+大数据 

/**
 * Stream并行
 * @author maye_C
 *
 */
public class StreamDemo8 {
	
	public static void main(String[] args) {
		
		//创建一个集合
		List<String> list = new ArrayList<String>();
		
		for(int i = 0;i<1000000;i++) {
			//获取随机数对象
			UUID uuid = UUID.randomUUID();
			
			list.add(uuid.toString());
			
		}
		parallelStreamSortedTest(list);
//		streamSortedTest(list);
		
	}

	//串行Stream
	private static void streamSortedTest(List<String> list) {
		// TODO Auto-generated method stub
		long startTime = System.nanoTime();//返回最准确的,可用系统计时器的当前值,以毫秒为单位
		
		long count = list.stream().sorted().count();
		
		long endTime = System.nanoTime();
		
		long millis = TimeUnit.NANOSECONDS.toMillis(endTime - startTime);
		

		//格式化输出
		System.out.printf("并行花费时间: %d ms", millis);
	}
	//并行Stream
	private static void parallelStreamSortedTest(List<String> list) {
		// TODO Auto-generated method stub
		
		long startTime = System.nanoTime();//返回最准确的,可用系统计时器的当前值,以毫秒为单位
		
		long count = list.parallelStream().sorted().count();
		
		long endTime = System.nanoTime();
		
		long millis = TimeUnit.NANOSECONDS.toMillis(endTime - startTime);
		
		//格式化输出
		System.out.printf("并行花费时间: %d ms", millis);
	}
}
/**
 * 懒操作
 * @author maye_C
 *
 */
public class StreamDemo9 {

	public static void main(String[] args) {
        streamCreateTest();
    }
	private static void streamCreateTest() {
		
		Stream<Long> stream = Stream.generate(new NatureSeq());
		
		System.out.println("元素的个数:" + stream.map((param)->{
			return param;
			
		}).limit(100).count());
		
				
	}

    //递增序列
    static class NatureSeq implements Supplier<Long> {
        long value = 0;

        @Override
        public Long get() {
            value++;
            System.out.println(value);
            return value;
        }
    }
}

在这里Java8lambda表达式的相关知识介绍就 先告一段落了。






Java8新特性之Stream API

在Java8中引进的Stream API是使用lambda的API之一。就像SQL如何帮助你在数据库中形象地查询数据,Stream在Java集合计算上提供了一个形象的声明式的高层抽象来表示计算。形象的...
  • u013291394
  • u013291394
  • 2016-09-22 22:03:45
  • 4302

Java 8 stream 中重要的Collector接口

Collector import java.util.*; import java.util.function.*; import java.util.stream.Collector; import...
  • qq_35864642
  • qq_35864642
  • 2017-10-10 15:52:43
  • 69

Java8系列--Java Stream进阶篇(收集器简介)

1 收集器简介1.1 个人定义  下面是个人总结的关于收集器的定义: 在Lambda表达式的基础上,调用collect()接口,使用Collector类提供的方法,将流中的元素累积成一个汇总结果。...
  • qq_33429968
  • qq_33429968
  • 2017-08-07 16:12:43
  • 352

详解Java8特性之Stream API并行流

在详解Java8特性之Stream API中,我用的例子使用的都是顺序流,即单线程执行的,其实Stream API还提供了并行流,即多线程执行操作。java.util.Collection新添加了两个...
  • TimHeath
  • TimHeath
  • 2017-05-07 19:50:28
  • 2080

JAVA8新特性[第四季]-强大的Stream API

相关源码地址:https://github.com/liudongdong0909/java8/tree/master/java8-Lambda/src/com/donggua 一什么是 St...
  • liudongdong0909
  • liudongdong0909
  • 2017-08-20 17:32:35
  • 1978

Java8系列--Java Stream入门篇(流的操作)

1 Stream接口1.1 接口情况java.util.stream接口下共有DoubleStream、LongStream、IntStream、Stream四个接口,如下图所示: 1.2 流的...
  • qq_33429968
  • qq_33429968
  • 2017-07-18 18:45:49
  • 254

Java8 常用的Stream流操作

概念:Steam 是Java8 提出的一个新概念,不是输入输出的 Stream 流,而是一种用函数式编程方式在集合类上进行复杂操作的工具。简而言之,是可以处理集合数据的操作。 在Java8以前,对集合...
  • u014519461
  • u014519461
  • 2017-09-12 06:52:09
  • 167

Java8实例代码

  • 2017年03月18日 09:31
  • 67KB
  • 下载

Java8 Stream 归约 使用示例

package com.expgiga.Java8; /** * */ public class Employee { private String name; private ...
  • u013063153
  • u013063153
  • 2017-08-06 14:56:46
  • 493

JAVA8之Stream总结(给自己)

一,Stream API 可以表达复杂的数据处理查询.常用操作如下 二,可以使用filter,distinct,skip和limit对流进行筛选和切片 三,可以使用map和flatMap提取或转换流中...
  • zhang89xiao
  • zhang89xiao
  • 2016-07-15 12:05:00
  • 1974
收藏助手
不良信息举报
您举报文章:Java8———Stream接口
举报原因:
原因补充:

(最多只允许输入30个字)