使用Java 8 stream处理数据 -解道Jdon
使用Java 8 stream处理数据
　　如果没有集合Collection你如何处理数据？几乎所有的Java应用程序都要使用Collection处理数据。他们是十分重要的编程工作：例如，您可能想要创建银行交易的集合Collection，这个集合代表客户的状态。然后，你可能要处理整个集合来找出的顾客花了多少钱。尽管集合如此重要，但是在Java中处理集合的技术还远远不够完善。
首先，对集合的典型处理模式是类似SQL操作，比如&finding&（例如，找到具有最高价的交易）或&grouping& （例如，将相关的杂物所有交易合并组） 。大多数数据库让您这样的声明方式指定的操作。例如，下面的SQL查询可以让您找到交易ID最高值： &SELECT id, MAX(value) from transactions& 。
正如你所看到的，我们并不需要实现如何具体计算最大值（例如，使用循环和一个变量来跟踪的最高值） 。我们只能表达我们所期望的要求(获得最大值)。只要我们显式发出这样的查询，数据库就会为我们去处理。可是为什么我们不能在集合Collection中实现类似的东西？多少次，你会发现自己使用循环一遍又一遍的反复遍历集合？(如：for Object o: myLists{ ..})
其次，如何才能有效地处理真正的大数据集合？在理想的情况下，你想利用多核架构加快处理，。然而，编写并行代码很难而且容易出错。
Java 8 API的设计者重新提出了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。此外，数据流可以充分利用多核架构而无需编写多线程的一行代码。这听起来不错，不是吗？
首先，我们看看在Java 7中，如何发现typegrocery 的所有交易，然后返回以交易值降序排序好的交易ID集合？
List&Transaction& groceryTransactions
= new Arraylist&&();
for(Transaction t: transactions){
if(t.getType() == Transaction.GROCERY){
groceryTransactions.add(t);
Collections.sort(groceryTransactions, new
Comparator(){
public int compare(Transaction t1, Transaction t2){
return t2.getValue().compareTo(t1.getValue());
List&Integer& transactionIds = new
ArrayList&&();
for(Transaction t: groceryTransactions){
transactionsIds.add(t.getId());
而在Java 8使用Stream：
List&Integer& transactionsIds =
transactions.stream()
.filter(t -& t.getType() ==
Transaction.GROCERY)
.sorted(comparing(Transaction::getValue).reversed())
.map(Transaction::getId)
.collect(toList());
我们首先从交易数据列表中获得一个stream对象，这是通过使用List的stream()方法实现的，下一步几个操作 (filter, sorted, map, collect)是以链式排列成一个管道，形成对数据的查询操作。
那么这段代码如何并行操作呢？那么只要更换transactions.stream()为transaction.parallelStream()即可，请注意lambda表达式(t-& t.getCategory() == Transaction.GROCERY)和方法引用(Transaction::getId)将在下一章详细讲解。
Stream起步
首先，定义一下Stream，Stream是一个来自支持聚合操作源的元素的序列。如下特点：
1. 所谓元素的序列，一个Stream向外提供了一个这样的接口：特定元素类型的值的序列，但是Stream并不实际持有也就是存储这些元素，它们是在有需求时才会被计算。
2. 源：以提供Stream进行计算消费的源，这些源有Collection集合 Array数组或I/O资源等。
3.聚合操作：Stream支持类似SQL操作和函数式编程的大部分操作，比如：filter, map, reduce, find, match, sorted。
此外，Stream操作不同于Collection操作有两个根本的地方：
1.管道Pipelining: 许多流Stream操作返回流Stream自身，这就允许对其操作可以像链条一样排列，变成一个管道，这其中也会激活比如懒加载和short-circuiting操作。
2.内部迭代：相比于集合Collection是显式迭代(需要我们编码完成迭代)，Stream操作是在其内部完成迭代操作。
下面我们看看前面Stream代码的内部工作流程：
我们首先从交易transactions这个列表中获得Stream对象，数据源就是交易列表，其中提供了一系列元素集合，这些元素都是供Stream操作的，下一步，我们使用了一系列对这个Stream的聚合操作，包括过滤filter (用我们指定的谓词条件predicate过滤元素，也就是代码t -& t.getType() ==
Transaction.GROCERY), 排序(用指定的比较器comparator对元素进行排序), 以及 map (为了释放获取信息). 所有这些操作除了最后的collect操作，都是返回一个Stream对象，这样就能被前后链接在一起变成一个长的管道，可以看成是基于源数据集合的一个查询操作。如同SQL基于数据表的有条件查询语句一样。
最后到collect被调用操作， collect操作开始处理这个管道以返回一个结果，不再是一个结果流了，这里一个结果是List一个对象，我们看到collect接受一个recipe输入函数然后累计Stream中元素到一个汇总结果，这里输入函数是toList()，它是一个将将Stream转换为List对象。
Stream与Collection比较
Stream和Collection集合有什么区别？Collection是关于静止的数据结构，而Stream是有关动词算法和计算的。前者是主要面向内存，存储在内存中，后者主要是面向CPU，通过CPU实现计算的。
举例将一个影片存储在DVD盘上，这是一个集合，因为它包含整个电影的字节数据结构，而这个影片被放在互联网上，我们通过视频软件去观看它时，它实际是被流化了，它变成了一个字节流，流是与时间有关的概念，而数据结构是与时间无关，不会随着时间变化变化，流正好相反，随着时间不断地动态变化，如同水流一样潺潺不断。
所以，集合与流的主要区别是是否需要被计算，集合是一个内存数据结构，集合中每个元素在加入到集合之前已经被计算了，相反，流是在即时要求即时计算。
使用集合需要开发者主动去遍历，使用一个遍历循环，这称为外部遍历。
而使用一个流库使用内部遍历，它自己为你遍历元素，然后将结果保存在某处，你只要提供一个函数，它就会用这个函数对元素处理完成。内外遍历的区别如下代码:
List&String& transactionIds = new
ArrayList&&();
for(Transaction t: transactions){
transactionIds.add(t.getId()); //外部遍历
List&Integer& transactionIds =
transactions.stream()
.map(Transaction::getId) //内部遍历
.collect(toList());
以后我们看看如何详细使用Stream来处理流。
企业级软件架构解决之道
如有意见请与我们联系 Powered by JdonFramework如何将0转为8个字节的字节数组？用java_百度知道
如何将0转为8个字节的字节数组？用java
答题抽奖
首次认真答题后
即可获得3次抽奖机会，100%中奖。
zhuniadi82
zhuniadi82
采纳数：118
获赞数：252
public static void main(String[] args) {
String s = &0&;
Long longNumber = Long.parseLong(s);
byte[] b =longToBytes(longNumber);
for (byte c : b) {
System.out.print(c+&\t&);
} } public static byte[] longToBytes(long l) {
byte[] b = new byte[8];
b[0] = (byte) (l &&& 56);
b[1] = (byte) (l &&& 48);
b[2] = (byte) (l &&& 40);
b[3] = (byte) (l &&& 32);
b[4] = (byte) (l &&& 24);
b[5] = (byte) (l &&& 16);
b[6] = (byte) (l &&& 8);
b[7] = (byte) (l);
}你是要这样吗？
为你推荐：
其他类似问题
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。Java8 学习笔记(二)——Stream流 - 简书
Java8 学习笔记(二)——Stream流
1.简单使用
Arrays.asList(1, 4, 2, 3, 5, 6, 7, 9, 0, 8)
.sorted()// 排序
.filter(x -& x & 3)// 过滤
.forEach(System.out::print);
运行结果：
4,5,6,7,8,9
Stream(流)和InputStream/OutputStream并没有关系
Stream提供了很多Lambda表达式方法
重点在于对数组的操作
Stream不存储数据
Stream不会修改源数据，无论怎么操作源数据并不会改变
Stream是单向的，不可以重复使用
Stream的部分操作是延迟的
只要Stream的方法返回的对象是Stream，这些方法就是延迟执行的方法
延迟执行的方法，一定要等到一个迫切方法执行的时候，才会执行。一般在Stream流中，一个方法返回的不是Stream，基本就是迫切方法
Stream可以执行并行操作
2.创建Stream
数组和集合创建Stream流方法不一样
2.1数组创建Stream
一般可以通过：Arrays.stream()和Stream.of()
int [] ints = new int[]{1,3,4,2,5};
IntStream intStream= Arrays.stream(ints);
intStream.forEach(System.out::print);
运行结果：13425
注意：不能直接把简单数据类型的数组直接作为Stream.of()的参数
int [] ints = new int[]{1,3,4,2,5};
Stream&int[]&stream= Stream.of(ints);
stream.forEach(System.out::print);```
运行结果为：
`[I@1218025c`
Stream&Integer&stream2 = Stream.of(1,3,4,2,5);
stream2.sorted().forEach(System.out::print);
运行结果为：
Stream&Integer&和IntStream不是同一个对象
2.2集合创建Stream
集合可以通过：集合对象.stream()
List&Integer&list = (List&Integer&) Arrays.asList(1,2,4,3,5);
Stream&Integer&stream = list.stream();
2.3创建并行Stream
通过集合对象.parallelStream()
List&Integer&list = (List&Integer&) Arrays.asList(1,2,4,3,5);
Stream&Integer&stream = list.parallelStream();
2.4 创建大量数据的Stream
初始化一个无限重复字符串的Stream
Stream.generate(()-&"Hello World!!!").forEach(System.out::println);
运行结果：
无限打印出Hello World!!!
初始化一个有限的数据的Stream
可以通过limit()方法来限制创建数据的数量
Stream.generate(()-&"Hello World !!!").limit(5).forEach(System.out::println);
运行结果：
打印出5个Hello World!!!
2.5创建一个规律数据的Stream
例如，创建一个从开始1到10的数列的Stream
Stream.iterate(1, x -& x +1).limit(10).forEach(System.out::print);
运行结果：
iterate()方法中，有两个参数，第一个为初始数据，第二个为一个Operator接口
Stream.iterate("a", UnaryOperator.identity()).limit(10).forEach(System.out::print);
运行结果：aaaaaaaaaa
UnaryOperator.identity()自己返回自己
3.Stream常见的操作
过滤操作filter,distinct
变换操作map,flatMap
拆分合并流操作limit,skip,concat,peek
排序操作sorted,unordered
操作符方法内往往需要一个函数式接口
Java8函数式接口
3.1过滤操作
例:找出所有开头为大写字母的字符串
Arrays.asList("Abc","Bc","ac","op","IQ")
.filter(s-&Character.isUpperCase(s.charAt(0)))
.forEach(System.out::println);
运行结果：
distinct去除重复元素
Arrays.asList("a","c","ac","c","a","b")
.distinct()
.forEach(System.out::println);
运行结果：
3.2变换操作
把一种类型的Stream变为另一种类型的Stream,map方法内需要一个Function接口，Function&? super String, ? extends String& mapper
例：将字符串全部变为大写
Arrays.asList("hdfa","adfc","aedc","yui")
.map(s-&s.toUpperCase()+" ,")
.forEach(System.out::print);
HDFA ,ADFC ,AEDC ,YUI ,
flatMap方法也需要Function接口，只是Function接口的泛型不同，Function&? super T, ? extends Stream&? extends R&& mapper,返回的是Stream对象
private static void flatMapStream() {
String [] strs1 = {"a","b","c"};
String [] strs2 = {"d","e","f"};
String [] strs3 = {"a","g","h"};
Arrays.asList(strs1,strs2,strs3)
.flatMap(str -& Stream.of(str))
.map(s -& s+",")
.forEach(System.out::print);
运行结果：
a,b,c,d,e,f,a,g,h,
flatMap是把高纬度流变为低纬度流。
flatmap变换
str1,str2,str3作为Stream&String[]&中的元素，可以看做是二维的数组，经过flatMap变换，Stream&String[]&就变为了Stream&String&，由二维变为了一维。
3.3拆分合并流操作
限制，返回 Stream 的前面 n 个元素
Arrays.asList(1,2,3,4,5)
.forEach(System.out::print);
运行结果：123
跳过Stream前的n个元素
Arrays.asList(1,2,3,4,5)
.forEach(System.out::print);
运行结果：345
static &T& Stream&T& concat(Stream&? extends T& a, Stream&? extends T& b)
将两个Stream合并成一个，这个方法一次只能用来合并两个Stream，不能一次多个Stream合并。
private static void concatStream() {
Stream&Integer&stream1=Arrays.asList(1,2,3).stream();
Stream&String&stream2=Arrays.asList("a","b","c").stream();
Stream.concat(stream1,stream2).forEach(System.out::print);
运行结果：123abc
3.4流的排序
sorted()方法是个元素相关的方法，和整体的数据有关系。
sorted()，无参方法
Arrays.asList(3,1,4,5,2)
.forEach(System.out::print);
运行结果：123456
使用sorted()这个方法，要求Stream中的数据必须实现了Comparable接口
sorted(Comparator& ? super T & comparator)
例:按照字符串长度进行排序
Arrays.asList("ae","f","gqet","ertyu","zxc")
.sorted((s1,s2)-& Integer.compare(s1.length(), s2.length()))
.forEach(System.out::println);
运行结果：
f ae zxc gqet ertyu
若两个字符串长度相同，按照字母顺序排列，可以用Comparator的thenComparaimg()
Arrays.asList("ae", "f", "gqet", "abcd", "ertyu", "zxc")
Comparator.comparing(String::length)
.thenComparing(String::compareTo)
.forEach(System.out::println);
运行结果：
f ae zxc abcd gqet ertyu
反转排序：Comparator的reversed()
Arrays.asList(2,3,4,1,5)
.sorted(Comparator.reverseOrder())
.forEach(System.out::print);
Arrays.asList("ae", "f", "gqet", "abcd", "ertyu", "zxc")
.sorted(Comparator.comparing(String::length).reversed())
.forEach(System.out::println);
如果Comparator.comparing()方法中是非方法引用的Lambda表达式，就无法直接使用.reversed()
parallel().sorted()之后，不能直接使用forEach()，要使用forEachOrdered()。并行Stream和sorted()并不会冲突。
使用forEach()
Arrays.asList(1,4,5,2,3,6,8,9,7)
.parallel()
.forEach(System.out::print);
运行结果：
使用forEachOrdered():
Arrays.asList(1,4,5,2,3,6,8,9,7)
.parallel()
.forEachOrdered(System.out::print);
运行结果：
4.Stream的结果处理
遍历forEach
聚合reduce
Optional类型
收集collect
4.1聚合reduce
reduce()可以实现从一组数据中生成一个数据,这个方法有三种形式：
Optional&T& reduce(BinaryOperator&T& accumulator)
T reduce(T identity, BinaryOperator&T& accumulator)
&U& U reduce(U identity,BiFunction&U,? super T,U& accumulator,BinaryOperator&U& combiner)
例：求累加和
Arrays.asList(1,2,3)
.reduce((sum,i)-& sum = sum+i)
.ifPresent(System.out::print);
4.2Optional
Optional是一种容器，可以存储一些值和null。利用这个类，可以进行null的判断，能够有效的避免NullPointerException
get(),可以拿到Optional中的值，没有值则抛出空指针异常
isPresent(),有非空的值，返回true，否则返回false
ifPresent(),public void ifPresent(Consumer&? super T& consumer)这个方法中需要一个Consumer接口。如果有非空的值，就执行指定的Consumer的方法来处理这个非空的值；如果为空，则啥都不做
reduce()操作返回的就是Optional
4.3收集collect
collect()可以将Stream流转变成集合
List&Integer&list= Arrays.asList(1,2,3,4,5)
.filter(i-& i&3)
.collect(Collectors.toList());
list.forEach(System.out :: print);
Java8 常见的函数式接口多看看。
Android 开发
水平：青铜5
Int Double Long 设置特定的stream类型， 提高性能，增加特定的函数 无存储。stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。 为函数式编程而生。对stream的任何修改都不会修改背后...
Streams 原文链接： Streams 原文作者： shekhargulati 译者： leege100 状态： 完成 在第二章中，我们学习到了lambda表达式允许我们在不创建新类的情况下传递行为，从而帮助我们写出干净简洁的代码。lambda表达式是一种简单的语法结构...
前言： 讲Stream之前，先来用个小需求带入本文。毕竟代码看的最清楚。 正文： 项目某个页面有个需求，将关键词和集合比对，判断是否存在关键词，这种需求想必是再普通不过，最简单的就是循环迭代了。上来就干，普通for循环，判断： for (SkiModel skiModel ...
Jav8中，在核心类库中引入了新的概念，流（Stream）。流使得程序媛们得以站在更高的抽象层次上对集合进行操作。今天，居士将主要介绍Steam类中对应集合上操作的几个重要的方法。 1、 Steam举例 对使用Java的程序媛们，当需要处理集合里的每一个数据时，通常是使用迭...
从不称呼你的名字 愿意借以各种秘密的代号 有时是一种动物或音调 有时是一个名词或形容词 也可以是语气词 这是一种快乐的发明 使我像一个热情的诗人 像一个在爱里长不大的孩子 乐此不疲 在众多的奇怪的词汇里 我总能轻易地找到，好听的音符 是些书面语从未见过的词儿 却又总是那么准...
比起戊戌六君，你少了几分铮铮铁骨；比起维新康梁，你少了几分高瞻远瞩。那是一个战火连天、硝烟四起的年代，那是一个软弱无能、备受欺凌的年代，洋人的坚船利炮击碎清廷的金戈铁马，一个女人的手腕左右了历史的进程。 值此多事之秋，历史舞台上出现了一个你。受任于败军之际，奉命于危难之间。...
我们在职场都没办法独立的活下来。职场归根结底就是一个大的团体，共同协作。 我们要做的是跟不同职级的人打交道，实现目标。这里面会涉及到，跟直接领导，跟直接下属和跟同级别的同事沟通。而沟通过程中，最重要的就是感知对方情绪的能力。 情绪感知力里面，最大的陷阱是话语。 很多沟通能力...
一，凡是学过的知识终将成为积累 周一，因应另一个单位同事的邀请，我做了2017年的首次五部分享。自我感觉还好，最起码在分享时我把气氛活跃起来了，几个幽默惹得大家口哄堂大笑。 会后部门的同事都一致好评，特别是助理，她拿了实在的案例来证明，她说人资的同事听我分享的时候都在点头。...
人心有黑白 别让不应有的占据人心拒绝访问 | www.ggdoc.com | 百度云加速
请打开cookies.
此网站 (www.ggdoc.com) 的管理员禁止了您的访问。原因是您的访问包含了非浏览器特征(44cd146cab01437c-ua98).
重新安装浏览器，或使用别的浏览器把一个8位的数组，每2位组成一组新的数组组，不重复，怎么做？ - ITeye问答
比如： int[1,2,3,4,5,6,7,8]
这样的程序改怎么写，如果8位和2位都是变量，又该怎么做。
用JAVA语言哦。
问题补充：如果是int[a,b,c,d,e,f,g]& 里面全是变量又该怎么做。
int[] a={1,2,3,4,5,6,7,8,9};
for(int i=0;i&m;i+=n){
int end=i+n&m?m:i+n;
int [] t=org.apache.commons.lang.ArrayUtils.subarray(a, i, end);
System.out.println(ArrayUtils.toString(t));
打印：
{1,2}
{3,4}
{5,6}
{7,8}
{9}
这是个排列的问题,相当于从8个元素中取2个元素进行排列.
下面是代码,没有考虑元素重复的情况
public void permutation(List&int[]& result, int[] arr, int index, int num){
if (index == num){
int[] newArr = new int[num];
System.arraycopy(arr, 0, newArr, 0, num);
result.add(newArr);
for (int i = i & arr. i++) {
swap(arr, index, i);
permutation(result, arr, index + 1, num);
swap(arr, index, i);
private void swap(int arr[], int i, int j){
if(i != j){
arr[i] ^= arr[j];
arr[j] ^= arr[i];
arr[i] ^= arr[j];
public void testPermutation() throws Exception {
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8};
List&int[]& result = new ArrayList&&();
permutation(result, arr, 0, 2);//从arr中取两个元素排列
System.out.println(result.size());
for (int[] is : result) {
System.out.println(Arrays.toString(is));
如果确定一定是8位，那就直接下面这样最简单
int[] a={1,2,3,4,5,6,7,8};
int[][] b={{a[0],a[1]},{a[2],a[3]},{a[4],a[5]},{a[6],a[7]}};
可以试试用封装一个数组类,里面2个属性都是set&&()
如果是你需要的数据，则可以用一个集合将他们装起来的，然后需要用的时候在取出来就OK了。
你好！执行以下下面的main函数，看看是不是你需要的。
public static void main(String[] args){
int[] a={1,2,3,4,5,6,7,8};
int[] b=new int[2];
for (int i = 0; i & a. i++) {
b[0]=i+1;
for (int j = i+2; j & a.length+1; j++) {
System.out.println(b[0]+"--"+b[1]);
}
&&&& }
}
已解决问题
未解决问题