java8数值流与对象流的相互转换

环境java8

准备工作:

数值流:就是基础数据类型构成的流

 数值流跟对象流之间可以相互转化
1. mapToDouble将 对象流转换为 数值流
2. 将数值流转换为对象流
    注意:.boxed()  等价于下面  
     .mapToObj(Double::valueOf||Integer::valueOf||Long::valueOf)
3数值流的相互转换
    eg:double数组转为int数组
 
 4.获取数值范围
  IntegerStream LongStream的2个方法
  range(包左不包右)  rangeClosed(包左包右)
 如果你要自定义生成规则呢,还可以使用无限流噢 Stream.generate

下面看例子:

    //获取数值范围
    //获取1-100的偶数流
    @Test
    public void test5()  {
    	IntStream.rangeClosed(0, 100)
    	         .filter(a->a%2==0)
    	         .forEach(System.out::println);
    	         
    }

//是否是质数
private static boolean isPrimes(int num) {
int res =(int) Math.sqrt((double)num);
return IntStream.rangeClosed(2, res)
                .noneMatch(i->num%i==0);
}

 //数值流跟对象流之间可以相互转化
    List<Employee> emps = Arrays.asList(
    new Employee(102, "李四aa", 59, 6666.66, Status.BUSY),
    new Employee(102, "李四aaa", 60, 6666.66, Status.BUSY),
    new Employee(101, "张三bb", 18, 9999.99, Status.FREE),
    new Employee(103, "王五cc", 28, 3333.33, Status.VOCATION),
    new Employee(104, "赵六dd", 8, 7777.77, Status.BUSY),
    new Employee(104, "赵六dd", 8, 7777.77, Status.FREE),
    new Employee(104, null, 25, 7777.77, Status.FREE)
);
    @Test
    public void test4() {
    	//推荐  这里返回的是double
    	double sum = emps.stream()
    	    .mapToDouble(Employee::getSalary)
    	    .sum();
    	System.out.println(sum);
    	
    	//这里返回的并不是double,因为有可能最大值不存在
    	OptionalDouble opmax = emps.stream()
	    .mapToDouble(Employee::getSalary)
	    .max();
    	if (opmax.isPresent()) {
    		System.out.println("最大值:"+opmax.getAsDouble());
		}else{
			System.out.println("没有最大值");
		}
    	
    	//也可以获取操作对象
    	 DoubleSummaryStatistics summaryStatistics = emps.stream()
        	    .mapToDouble(Employee::getSalary)  //获取数值流
        	    .summaryStatistics();
    	 System.out.println(summaryStatistics.getAverage());
    	
    	 
    	 //数值流转化为对象流
    	 long count = emps.stream()
 	    .mapToDouble(Employee::getSalary)
// 	    .boxed()  等价于下面
 	    .mapToObj(Double::valueOf)
 	    .count();
    }

//数值流的相互转换     eg:double数组转int数组的2种方法    其他的暂时没想到
    @Test
	public void test4_1() throws Exception {
		double nums[]={1,2,3.8};
		//方式1:
//		int[] array = IntStream.of((int)nums[0],(int)nums[1],(int)nums[2]).toArray();
		//方式2  DoubleStream存的是个序列  推荐
		int[] array = DoubleStream.of(nums)
		            //要使用方法转换,必须转换为对象流
		            .boxed()
		            .mapToInt(a->a.intValue()).toArray();
		//或者Arrays.stream 得到的也是DoubleStream流
//		Arrays.stream(nums)
//		      .boxed()
//		      .mapToInt(a->a.intValue()).toArray();
		System.out.println(Arrays.toString(array));
		
		
		//但是如果你是使用Stream呢,极不合适
		//此时存的是一个数组对象,你需要手动遍历获取每个元素,再转换
		//涉及的问题是怎么把Stream<double[]>转换为Stream<int[]>  有知道的跟我说下,谢谢
		 Stream<int[]> res = Stream.of(nums)
		      .map(a->{
		    	  int b[]=new int[a.length];
		    	  for (int i = 0; i < a.length; i++) {
					 b[i]=(int)a[i];
				  }
		    	  return b;
		      });
		res.forEach(s->System.out.print(Arrays.toString(s)));
	}

小应用:

 
    //获取 勾股数  比如1-100之间的    eg:3,4,5
    @Test
	public void test6()  {
    	//方式1  传统for循环
		int[] array = IntStream.rangeClosed(0, 100).toArray();
		List<int[]> list=new ArrayList<int[]>();
		
//		for (int i = 3; i < array.length; i++) {
//			 for (int j = i+1; j < array.length; j++) {
//				for (int k = j+1; k < array.length; k++) {
//					if (i*i+j*j==k*k) {
//						list.add(new int[]{i,j,k});
//					}
//				}
//			}
//		}
		//方式1优化
		for (int i = 3; i < array.length; i++) {
			 for (int j = i+1; j < array.length; j++) {
				 if (Math.sqrt(i*i+j*j)%1==0) {
					 list.add(new int[]{i,j,(int)Math.sqrt(i*i+j*j)});
				}
			 }
				
		}
		System.out.println("个数:"+list.size());
		list.forEach(s->System.out.println(Arrays.toString(s)));
		
		
		
		//方式2
		Stream<int[]> result = IntStream.rangeClosed(1, 100)
		         .filter(a1-> a1>=3)
		         .boxed() //转换为对象流,因为要存放数组对象呢,这个IntStream是不支持的
		         //将流扁平化,因为每个a都是一个流,而最终需要的是数组流
		         .flatMap(      a->
					         IntStream.range(a, 100)
					                  .filter(b->Math.sqrt(a*a+b*b)%1==0)
					                  //转化为对象流  boxed()与mapToObj(xx)等价
					                  .mapToObj(b-> new int[]{a,b,(int)Math.sqrt(a*a+b*b)})
		        		 );
		result.forEach(s->System.out.println(s[0]+","+s[1]+","+s[2]));
		System.out.println("============================================");
		
		//方式2优化,结果是个double[],尴尬了...
		Stream<double[]> result2 =IntStream.rangeClosed(1, 100)
		         .filter(a1-> a1>=3)
		         .boxed()
		         .flatMap( a->
		                     IntStream.rangeClosed(a, 100)
		                              .mapToObj(b->new double[]{a,b,Math.sqrt(a*a+b*b)})
		                              //此时获取的是一个double数组
		                              .filter(c->c[2]%1==0)
		        		 );
//		你是不是想得到int数组?  个人觉得只能手动遍历强制转换额
		result2.forEach(s->System.out.println((int)s[0]+","+(int)s[1]+","+(int)s[2]));
		
	}