1、java中获取流的两种方式
- java8中的“流”实际上是Stream接口的对象
- JDK中提供了一个流接口，java.util.stream.Stream，java.util.stream.Stream 是Java 8新加入的最常用的流接口。(这并不是一个函数式接口。)
获取一个流非常简单，有以下几种常用的方式：
- 所有的 Collection 集合都可以通过 stream 默认方法获取流;
集合对象名.stream（）； - Stream 接口的静态方法 of 可以获取数组对应的流。
Stream.of(数组名称)；
package Stream;
/*
* java8中的“流”实际上是Stream接口的对象
* JDK中提供了一个流接口，java.util.stream.Stream
*
* 如何获取流：
* （1）根据集合获取流 , 集合对象名.stream（）；
* （2）根据数组获取流 ,Stream.of(数组名称)；
*
* */
import java.util.ArrayList;
import java.util.Arrays;
import java.util.stream.Stream;
public class Demo01GetStream {
public static void main(String[] args) {
//根据集合获取流
ArrayList<String> list=new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");
Stream<String> stream1 = list.stream();
//2、根据数组获取流，数组中的元素必须是引用类型的才可以
String[] StringArrays=new String[]{"Hello","world"};
Stream<String> stream2= Stream.of(StringArrays);
//如果不是引用类型，使用包装类
Integer[] IntegerArrays=new Integer[]{10,20,30};
Stream<Integer> stream3=Stream.of(IntegerArrays);
}
}2、Stream中的map映射
例：1、普通情况：将集合中无特殊字符串转整形
package Stream;
/*
* 获取流之后，可以使用映射方法：map(用于转的lambda表达式)
*
* 映射：就是将一个对象映射到另一个对象上，将老对象映射到新对象
*
* */
import java.util.ArrayList;
import java.util.Arrays;
import java.util.stream.Stream;
public class Demo02StreamMap01 {
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<>();
//list集合当中存放的是字符串
list.add("100");
list.add("200");
list.add("300");
//用循环实现字符类型的转换
for (int i = 0; i <list.size() ; i++) {
int value = Integer.parseInt(list.get(i));
System.out.println("集合中的第"+(i+1)+"个元素的值为："+value);
}
System.out.println("=====================================");
//用Stream流式思想转换集合当中的数据类型
Stream<Integer> stream= list.stream().map((String str)->{
int value=Integer.parseInt(str);
return value;
});
//尝试输出集合中的数据
Object[] objects = stream.toArray();
System.out.println("流中的元素输出："+Arrays.toString(objects));
//Lambda表达式的写法1:
//只有一个参数，参数的返回值类型可以去掉
Stream<Integer> stream1=list.stream().map(str->{
int value=Integer.parseInt(str);
return value;
});
//Lambda表达式的写法2:
Stream<Integer> stream2=list.stream().map(str->{
return Integer.parseInt(str);
});
///Lambda表达式的写法3:
Stream<Integer> stream3=list.stream().map(Integer::parseInt);
}
}
2、集合中有特殊字符，利用split方法
package Stream;
/*
* 功能分析：
* 带有分隔符的集合元素转换成流式操作
*
* */
import java.util.ArrayList;
import java.util.stream.Stream;
public class Demo02StreamMap02 {
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<>();
list.add("张三,18");
list.add("李四,20");
list.add("王五,34");
//用for循环方式实现转换
ArrayList<String> list1=new ArrayList<>();
for (int i = 0; i <list.size() ; i++) {
String[] split = list.get(i).split(",");
String result=split[1];
list1.add(result);
}
System.out.println("集合list1的值:");
for (int i = 0; i <list1.size() ; i++) {
System.out.println("list["+i+"]"+"="+list1.get(i));
}
//Lambad表达式简洁写法1
Stream<String> stream=list.stream().map((String str)->{
String[] split = str.split(",");
String result=split[1];
return result;
});
//Lambad表达式简洁写法2
Stream<String> stream1=list.stream().map(s->{
String[] split = s.split(",");
return split[1];
});
//Lambad表达式简洁写法3
Stream<String> stream2=list.stream().map(s->{
return s.split(",")[1];
});
//Lambad表达式简洁写法4
Stream<String> stream3=list.stream().map(s->s.split(",")[1]);
}
}
3、Stream中的Filter
package Stream;
/*
* 如果希望对流中的数据进行过滤，可以使用:
* Filter(能产生Boolean类型的Lambda结果的表达式)；如果结果为true,就要，如果结果为false，就不要
*
* */
import java.util.ArrayList;
import java.util.stream.Stream;
public class Demo03StreamFilter {
public static void main(String[] args) {
ArrayList<Integer> list=new ArrayList<>();
list.add(92);
list.add(85);
list.add(70);
Stream<Integer> stream = list.stream().filter((Integer num)->{
boolean b=num>80;
return b;
});
Stream<Integer> stream1 = list.stream().filter( num->{
boolean b=num>80;
return b;
});
Stream<Integer> stream2 = list.stream().filter( num->{
return num>80;
});
//花括号中只有一个表达式，return和花括号可以去掉
Stream<Integer> stream3 = list.stream().filter(num->num>80);
System.out.println("===================================");
ArrayList<String> list1=new ArrayList<>();
list1.add("张三");
list1.add("李四");
list1.add("王五");
//用Lambda过滤，只要姓名为张三的
Stream<String> streamA=list1.stream().filter((String str)->{
boolean b=str.equals("张三");
return b;
});
Stream<String> streamB=list1.stream().filter(s->{
return s.equals("张三");
});
Stream<String> streamC=list1.stream().filter(s->s.equals("张三"));
}
}4、Stream流的ForEach（遍历）操作
package Stream;
/*
* 如果希望在流中对数据进行遍历操作，可使用forEach:
* forEach(Lambda表达式)，对流中的每一个表达式进行操作
*
* 参数Lambda表达式必须是一个可以消费一个参数，并且不产生一个数据结果的Lambda
*
* 例如：
*Lambda： s->System.out.println(s)
* 方法引用： System::println;
* */
import java.util.ArrayList;
import java.util.stream.Stream;
public class Demo04StreamForEach {
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");
//写法1
Stream<String> stream1=list.stream();
stream1.forEach((String str)->{
System.out.println(str);
});
//写法2
list.stream().forEach(str->{
System.out.println(str);
});
//写法3
list.stream().forEach(System.out::println);
}
}5、并发的Stream流
一个进程进行操作：
package Stream;
/*
* 流中的元素特别多，让一个人挨个处理，肯定特别慢
* 让多个人同时去处理，效率提高，这就是“并发”
*
* 如何才能获取“并发流”（支持并发操作的流）
* .paralleStream()
*
* 注意事项：
* 1、使用并发流进行操作时，到底有几个人在同时进行操作，不用管，直接用即可
* 2、在使用时，绝对不会出现两个人抢到同一个元素
*
* 如果以及获取到一个普通的流，调用paralle方法，也可以变成并发流
*
* */
import java.util.ArrayList;
import java.util.stream.Stream;
public class Demo05StreamBingfa {
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<>();
for (int i = 0; i <10 ; i++) {
list.add("Hello----"+i);
}
//一个流进行操作
Stream<String> streamA=list.stream();
streamA.forEach((String str)->{
System.out.println(str);
});
/* //使用并发流进行操作
Stream<String> streamB = list.parallelStream();
streamB.forEach((String str)->{
System.out.println(str);
});
//如果以及获取到一个普通的流，调用paralle方法，也可以变成并发流
list.stream().forEach(System.out::println);
*/
}
}一个人进行操作，按顺序输出。
多个进程进行操作时：
package Stream;
/*
* 流中的元素特别多，让一个人挨个处理，肯定特别慢
* 让多个人同时去处理，效率提高，这就是“并发”
*
* 如何才能获取“并发流”（支持并发操作的流）
* .paralleStream()
*
* 注意事项：
* 1、使用并发流进行操作时，到底有几个人在同时进行操作，不用管，直接用即可
* 2、在使用时，绝对不会出现两个人抢到同一个元素
*
* 如果以及获取到一个普通的流，调用paralle方法，也可以变成并发流
*
* */
import java.util.ArrayList;
import java.util.stream.Stream;
public class Demo05StreamBingfa {
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<>();
for (int i = 0; i <10 ; i++) {
list.add("Hello----"+i);
}
/*
//一个流进行操作
Stream<String> streamA=list.stream();
streamA.forEach((String str)->{
System.out.println(str);
});*/
//使用并发流进行操作
Stream<String> streamB = list.parallelStream();
streamB.forEach((String str)->{
System.out.println(str);
});
/* //如果以及获取到一个普通的流，调用paralle方法，也可以变成并发流
list.stream().forEach(System.out::println);*/
}
}并发流执后的结果是无序的。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
