文章目錄
- ①. Stream 流的常見生產方式
- ②. forEach Consumer
- ③. filter Predicate
- ④. map Function
- ⑤. limit 和 skip
- ⑥. concat 、distinct
- ⑦. sorted? 排序
- ⑧. collect
- ⑨. 題目實戰
①. Stream 流的常見生產方式
-
①. Collection體系的集合可以使用默認方法stream?()生成流
default Stream<E> stream?() -
②. Map體系的集合間接的生成流
-
③. 陣列可以通過Stream介面的靜態方法of?(T… values)生成流
public class StreamDemo {
public static void main(String[] args) {
//Collection體系的集合可以使用默認方法stream?()生成流
List<String> list = new ArrayList<String>();
Stream<String> listStream = list.stream();
Set<String> set = new HashSet<String>();
Stream<String> setStream = set.stream();
//Map體系的集合間接的生成流
Map<String,Integer> map = new HashMap<String, Integer>();
Stream<String> keyStream = map.keySet().stream();
Stream<Integer> valueStream = map.values().stream();
Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();
//陣列可以通過Stream介面的靜態方法of?(T... values)生成流
String[] strArray = {"hello","world","java"};
Stream<String> strArrayStream = Stream.of(strArray);
Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");
Stream<Integer> intStream = Stream.of(10, 20, 30);
}
}
②. forEach Consumer
-
①. 然方法名字叫forEach ,但是與for回圈中的“for-each”昵稱不同
void forEach(Consumer<? super T> action); -
②. java.util.function.Consumer
<T>介面是一個消費型介面，Consumer介面中包含抽象方法void accept(T t),意為消費一個指定泛型的資料，
Stream<String> st1 = Stream.of("張三","李四","王二","麻子");
st1.forEach(System.out::println);
// 等同于如下代碼
// st1.forEach(s -> System.out.println(s));
③. filter Predicate
-
①.
Stream<T> filter?(Predicate predicate):用于對流中的資料進行過濾 -
②. Predicate介面中的方法
boolean test?(T t):對給定的引數進行判斷,回傳一個布林值 -
③. java.util.stream.Predicate函式式介面唯一的抽象方法為boolean test(T t);,該方法將會產生一個boolean值結果,代表指定的條件是否滿足，如果結果為true,那么Stream流的filter方法將會留用元素；如果結果為false,那么filter方法將會舍棄元素
public class StreamDemo01 {
public static void main(String[] args) {
//創建一個集合,存盤多個字串元素
ArrayList<String> list = new ArrayList<String>();
list.add("林青霞");
list.add("張曼玉");
list.add("王祖賢");
list.add("柳巖");
list.add("張敏");
list.add("張無忌");
//需求1:把list集合中以張開頭的元素在控制臺輸出
// list.stream().filter((String s) -> {
// return s.startsWith("張");
// }).forEach(System.out::println);
list.stream().filter(s -> s.startsWith("張")).forEach(System.out::println);
System.out.println("--------");
//需求2:把list集合中長度為3的元素在控制臺輸出
list.stream().filter(s -> s.length() == 3).forEach(System.out::println);
System.out.println("--------");
//需求3:把list集合中以張開頭的,長度為3的元素在控制臺輸出
list.stream().filter(s -> s.startsWith("張")).filter(s -> s.length() == 3).forEach(System.out::println);
}
}
④. map Function
-
①. 如果需要將流中的元素映射到另一個流中,可以使用map方法,方法簽名:
<R>Stream<R>map(Function<? super T, ? extends R> mapper); -
②. 該介面需要一個Function函式式介面,可以將當前流中的T型別資料轉換為另一種R型別的流
此前我們已經學習過 java.util.stream.Function 函式式介面,其中唯一的抽象方法為:R apply(T t);,這可以將一種T型別轉換成為R型別,而這種轉換的動作,就稱為“映射”
// map 方法的引數通過方法參考,將字串型別轉換成為了int型別(并自動裝箱為 Integer 類物件)
Stream.of("1","2","3","4","5","6")
.map(Integer::parseInt)
.forEach(s -> System.out.println(s*10));
⑤. limit 和 skip
-
①.
Stream<T> limit?(long maxSize):回傳此流中的元素組成的流,截取前指定引數個數的資料 -
②.
Stream<T> skip?(long n):跳過指定引數個數的資料,回傳由該流的剩余元素組成的流
public class StreamDemo02 {
public static void main(String[] args) {
//創建一個集合,存盤多個字串元素
ArrayList<String> list = new ArrayList<String>();
list.add("林青霞");
list.add("張曼玉");
list.add("王祖賢");
list.add("柳巖");
list.add("張敏");
list.add("張無忌");
//需求1:取前3個資料在控制臺輸出
list.stream().limit(3).forEach(System.out::println);
System.out.println("--------");
//需求2:跳過3個元素,把剩下的元素在控制臺輸出
list.stream().skip(3).forEach(System.out::println);
System.out.println("--------");
//需求3:跳過2個元素,把剩下的元素中前2個在控制臺輸出
list.stream().skip(2).limit(2).forEach(System.out::println);
}
}
⑥. concat 、distinct
-
①.
static <T> Stream<T> concat?(Stream a, Stream b):合并a和b兩個流為一個流 -
②.
Stream<T> distinct?():回傳由該流的不同元素(根據Object.equals(Object) )組成的流
public class StreamDemo03 {
public static void main(String[] args) {
//創建一個集合,存盤多個字串元素
ArrayList<String> list = new ArrayList<String>();
list.add("林青霞");
list.add("張曼玉");
list.add("王祖賢");
list.add("柳巖");
list.add("張敏");
list.add("張無忌");
//需求1:取前4個資料組成一個流
Stream<String> s1 = list.stream().limit(4);
//需求2:跳過2個資料組成一個流
Stream<String> s2 = list.stream().skip(2);
//需求3:合并需求1和需求2得到的流,并把結果在控制臺輸出
// Stream.concat(s1,s2).forEach(System.out::println);
//需求4:合并需求1和需求2得到的流,并把結果在控制臺輸出,要求字串元素不能重復
Stream.concat(s1,s2).distinct().forEach(System.out::println);
}
}
⑦. sorted? 排序
-
①.
Stream<T> sorted?():回傳由此流的元素組成的流,根據自然順序排序 -
②.
Stream<T> sorted?(Comparator comparator):回傳由該流的元素組成的流,根據提供的Comparator進行排序Comparator介面中的方法 int compare?(T o1, T o2)
public class StreamDemo04 {
public static void main(String[] args) {
//創建一個集合,存盤多個字串元素
ArrayList<String> list = new ArrayList<String>();
list.add("linqingxia");
list.add("zhangmanyu");
list.add("wangzuxian");
list.add("liuyan");
list.add("zhangmin");
list.add("zhangwuji");
//需求1:按照字母順序把資料在控制臺輸出 sorted()是正序
// list.stream().sorted().forEach(System.out::println);
//需求2:按照字串長度把資料在控制臺輸出
// list.stream().sorted((s1, s2) -> s1.length() - s2.length()).forEach(System.out::println);
list.stream().sorted((s1,s2) -> {
int num = s1.length()-s2.length();
int num2 = num==0?s1.compareTo(s2):num;
return num2;
}).forEach(System.out::println);
}
}
⑧. collect
-
①. toList:將流中的元素放置到一個串列集合中去，這個串列默認為ArrayList
-
②. toSet:將流中的元素放置到一個無序集set中去，默認為HashSet，
-
③. joining:joining的目的是將流中的元素全部以字符序列的方式連接到一起,可以指定連接符,甚至是結果的前后綴
public class CollectorsTest {
public static void toListTest(List<String> list) {
List<String> ll = list.stream().collect(Collectors.toList());
}
public static void main(String[] args) {
List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
toListTest(list);
}
}
public class CollectorsTest {
public static void toSetTest(List<String> list) {
Set<String> ss = list.stream().collect(Collectors.toSet());
}
public static void main(String[] args) {
List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
toSetTest(list);
}
}
public class CollectorsTest {
public static void joiningTest(List<String> list){
// 無參方法
String s = list.stream().collect(Collectors.joining());
System.out.println(s);
// 指定連接符
String ss = list.stream().collect(Collectors.joining("-"));
System.out.println(ss);
// 指定連接符和前后綴
String sss = list.stream().collect(Collectors.joining("-","S","E"));
System.out.println(sss);
}
public static void main(String[] args) {
List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
joiningTest(list);
}
}
/*
1234567891101212121121asdaa3e3e3e2321eew
123-456-789-1101-212121121-asdaa-3e3e3e-2321eew
S123-456-789-1101-212121121-asdaa-3e3e3e-2321eewE
*/
⑨. 題目實戰
/**
* @Description: 題目:請按照給出資料,找出同時滿足以下條件的用戶,也即以下條件全部滿足
* 偶數ID且年齡大于24且用戶名轉為大寫且用戶名字母倒排序
只輸出一個用戶名字
*/
public class StreamDemo {
public static void main(String[] args) {
User u1 = new User(11, "a", 23);
User u2 = new User(12, "b", 24);
User u3 = new User(13, "c", 22);
User u4 = new User(14, "d", 28);
User u5 = new User(16, "e", 26);
List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
list.stream()
.filter(s->s.getId()%2==0)
.filter(s->s.getAge()>24)
.map(s->s.getUserName().toUpperCase())
.sorted((s1,s2)->s2.compareTo(s1))
.limit(1)
.forEach(System.out::print);
}
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/290646.html
標籤：java