stream流的获取
stream流的获取
单列集合:集合对象.stream();
双列集合:不能直接获取,需要间接获取
集合对象.keySet().stream();
集合对象.entrySet().stream();
数组 :
Arrays.stream(数组名);
同种类型的多个数据:
Stream(数据1,数据2,数据3…);
单列集合
1 2 3 4 5
| ArrayList<String> list = new ArrayList<>(); list.add("这是"); list.add("\t\t单列集合"); list.stream().forEach(s-> System.out.print(s));
|
双列集合
1 2 3 4 5 6 7 8 9 10 11 12 13 14
| HashMap<String,Integer> t = new HashMap<>(); t.put("\n这是",18); t.put("\t\t双列集合",17);
t.keySet().stream().forEach(s-> System.out.print(s));
t.entrySet().stream().forEach(s-> System.out.print(s));
|
数组
1 2 3
| String [] arr = {"\n这","\t是","\t数","\t组"}; Arrays.stream(arr).forEach(s-> System.out.print(s));
|
同种类型多个数据
1 2
| Stream.of("\n同种","\t类型","\t多个","\t数据").forEach(s-> System.out.print(s));
|
StreamFilter方法
1 2 3 4 5 6 7 8 9 10 11 12 13 14
| import java.util.ArrayList; import java.util.Arrays; import java.util.function.Predicate; import java.util.stream.Stream;
public class StreamFilter { public static void main(String[] args) { ArrayList<String> list = new ArrayList<>(); list.add("吴小白"); list.add("吴小白"); list.add("王炸"); list.add("冷檬"); } }
|
过滤流中的字符
1 2 3 4 5 6 7 8 9 10 11 12 13
| list.stream().filter( new Predicate<String>() { @Override public boolean test(String s) { boolean result = s.startsWith("吴"); return result; } } ).forEach(s-> System.out.println(s));
list.stream().filter(s->s.startsWith("吴")).forEach(s-> System.out.println(s));
|
四种方法:
Stream<T>limit(long maxSize)
: 截取指定参数个数的数据,提取前三个数据
Stream<T>skip(long n)
: 跳过指定参数个数的数据,跳过前三个对象
static<T>Stream<T>concat(Stream a,Stream b)
: 合并a
和b
两个流为一个流
Stream<T>distinct()
: 去除流中重复的元素。依赖hashCode
和equals
方法
案例
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
| import java.util.ArrayList; import java.util.Arrays; import java.util.function.Predicate; import java.util.stream.Stream;
public class StreamFilter { public static void main(String[] args) { ArrayList<String> list = new ArrayList<>(); list.add("吴小白"); list.add("吴小白"); list.add("小陈"); list.add("王大爷"); list.add("王炸"); list.add("冷檬"); } }
|
Streamlimit(long maxSize)
1 2
| list.stream().limit(3).forEach(s-> System.out.println(s));
|
Streamskip(long n)
1 2
| list.stream().skip(3).forEach(s-> System.out.println(s));
|
Streamdistinct()
1 2
| list.stream().distinct().forEach(s-> System.out.println(s));
|
staticStreamconcat(Stream a,Stream b)
1 2 3 4 5 6 7 8 9 10 11 12
| ArrayList<String> list2 = new ArrayList<>(); list.add("吴小白"); list.add("吴小白"); list.add("小陈"); list.add("王大爷"); list.add("王炸"); list.add("冷檬");
Stream.concat(list.stream(),list2.stream()).forEach(s-> System.out.println(s));
|
stream()流中的数据统计与操作
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
| import java.util.ArrayList; import java.util.function.Consumer;
public class forEachMethod {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>(); list.add("吴小白"); list.add("吴大王"); list.add("张大师"); list.add("王炸"); } }
|
统计流中的元素个数
1 2 3
| long conut = list.stream().count(); System.out.println(conut);
|
对流中的每个数据进行操作
void forEach(Consumer action)
:对此流的每个元素执行操作
Consumer
接口中的方法void accept(Tt)
:对给定的参数执行此操作
在forEach
方法的底层,会循环获取到流中的每一个数据,
并循环调用accept
方法,并把每一个数据传递给accept
方法
s
就依次表示了流中的每一个数据,
所以,我们只要在accept
方法中,写上处理的业务逻辑就可以了
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
| list.stream().forEach( new Consumer<String>() { @Override public void accept(String s) { System.out.println(s); } } );
System.out.println("------------------");
list.stream().forEach( (String s)->{ System.out.println(s); } );
System.out.println("------------------"); list.stream().forEach(s-> System.out.println(s));
|
将stream流中修改的数据保存
Stream流的收集方法
R collect(Collector collector)
工具类Collectors
提供了具体的收集方式
public static<T>Collector toList())
:把元素收集到List
集合中
public static<T>Collector toSet()
:把元素收集到Set
集合中
public static Collector toMap(Function keyMapper,Function valueMapper)
:把元素收集到Map
集合中
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
| import java.util.ArrayList; import java.util.List; import java.util.Set; import java.util.stream.Collectors;
public class changgeStream {
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList<>(); for (int i = 1; i <=10 ; i++) { list1.add(i); } list1.add(2); list1.add(2); list1.add(2); list1.add(2); list1.add(2);
Liststream(list1); Setsream(list1); } }
|
Liststream(list1)
1 2 3 4
| private static void Liststream(ArrayList<Integer> list1) { List<Integer> list = list1.stream().filter(number -> number %2 ==0).collect(Collectors.toList()); System.out.println(list); }
|
Setsream
1 2 3 4
| private static void Setsream(ArrayList<Integer> list1) { Set<Integer> set = list1.stream().filter(number ->number % 2== 0).collect(Collectors.toSet()); System.out.println(set); }
|
练习
Actor实体类
Actor实体类1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
| package Bean;
public class Actor { private String name; public Actor(){
}
public String getName() { return name; }
public Actor(String name) { this.name = name; }
public void setName(String name) { this.name = name; }
@Override public String toString() { return "Actor{" + "name='" + name + '\'' + '}'; } }
|
主函数
main函数1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
| import Bean.Actor;
import java.util.ArrayList; import java.util.stream.Stream;
public class Exercise { public static void main(String[] args) { ArrayList<String> manList = new ArrayList<>(); manList.add("闰土"); manList.add("茅台"); manList.add("蘑菇头"); manList.add("妹大爷"); manList.add("猪小明"); manList.add("王炸"); ArrayList<String> womanList =new ArrayList<>(); womanList.add("球球"); womanList.add("毛毛"); womanList.add("冷檬"); womanList.add("腿腿"); womanList.add("小美"); womanList.add("小丽");
Stream<String> list1 = manList.stream().filter(name ->name.length() == 3).limit(2);
Stream<String> list2 = womanList.stream().filter(name->name.startsWith("小")).skip(1);
Stream.concat(list1,list2).forEach(name -> { Actor actor =new Actor(name); System.out.println(actor); });
} }
|