함수 식 인터페이스 와 Stream 흐름 의 완벽 한 조합
115007 단어 Java프로 그래 밍 기술자바 새로운 기능스 트림 흐름 조작
함수 식 인터페이스:추상 적 인 방법 만 있 는 인터페이스
1.2 함수 식 인 터 페 이 스 를 방법의 매개 변수 로 한다.
/*
（RunnableDemo），
：startThread(Runnable r) Runnable
， startThread
*/
public class RunnableDemo {
public static void main(String[] args) {
//
startThread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+" ");
}
});
//Lambda
startThread(()->System.out.println(Thread.currentThread().getName()+" "));
}
private static void startThread(Runnable r){
//Thread t = new Thread(r,"stratThread");
//t.start();
new Thread(r,"stratThread").start();
}
}
：stratThread
만약 방법의 매개 변수 가 함수 식 인터페이스 라면,우 리 는 Lambda 표현 식 을 매개 변수 로 전달 할 수 있 습 니 다.
1.3 함수 식 인 터 페 이 스 를 방법 으로 되 돌려 줍 니 다.
/*
（ComparatorDemo），
：Comparator getComparator() Comparator
： getComparator()
： ，
*/
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class ComparatorDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("aaaa");
list.add("bbb");
list.add("sss");
list.add("c");
list.add("cddf");
System.out.println(list); //
Collections.sort(list,getComparator());// ，
System.out.println(list); //
}
// ，
private static Comparator<String> getComparator() {
// Comparator
/*Comparator c = new Comparator() {
@Override
public int compare(String s1, String s2) {
return s1.length() - s2.length();
}
};
return c;*/
/* return new Comparator() {
@Override
public int compare(String s1, String s2) {
return s1.length() - s2.length();
}
};*/
//Lambda
return (s1, s2) -> s1.length() - s2.length();
}
}
1.4 상용 함수 식 인터페이스
1.4.1 Supplier 인터페이스
Supplier 인 터 페 이 스 는 주로 데 이 터 를 생산 하 는 데 사용 되 며,인삼 이 없 는 방법 을 포함한다.
import java.util.Arrays;
import java.util.function.Supplier;
public class SupplierDemo {
public static void main(String[] args) {
Integer[] arr = {12,43,22,67,34,99};
//
/*Integer max = getMax(new Supplier() {
@Override
public Integer get() {
Arrays.sort(arr);
return arr[arr.length - 1];
}
});
*/
//Lambda
Integer max = getMax(()->{
Arrays.sort(arr);
return arr[arr.length - 1];
});
System.out.println(max);
}
// Supplier ，
private static Integer getMax(Supplier<Integer> s){
return s.get();
}
}
： 99
1.4.2 소비자 인터페이스
Consumer:두 가지 방법 포함
accept 사용 하기(T t)
public class ConsumerDemo {
public static void main(String[] args) {
String[] strings = {" ,19"," ,22"," ,21"," ,19"};
//
/*useString(strings, new Consumer() {
@Override
public void accept(String s) {
String[] split = s.split(",");
System.out.println(" ；"+split[0]+", ："+split[1]);
}
});*/
//Lambda
useString(strings,s-> System.out.println(" ；"+s.split(",")[0]+", ："+s.split(",")[1]));
}
/**
* @param strarr
* @param con
*/
private static void useString(String[] strarr, Consumer<String> con){
// ，
for (String s : strarr) {
con.accept(s);// String[] strarr ，
}
}
}
： ； , ：19
； , ：22
； , ：21
； , ：19
Consumer and Then 사용 하기(Consumer after)
public class ConsumerDemo {
public static void main(String[] args) {
String[] strings = {" ,19"," ,22"," ,21"," ,19"};
// Consumer
//
/* useString2(strings, new Consumer() {
@Override
public void accept(String s) {
System.out.print(" ；"+s.split(",")[0]);
}
}, new Consumer() {
@Override
public void accept(String s) {
System.out.println(", ："+s.split(",")[1]);
}
});
*/
//Lambda
useString2(strings,
s ->System.out.print(" ；"+s.split(",")[0]),
s -> System.out.println(", ："+s.split(",")[1])
);
}
/**
* @param strarr
* @param con1
* @param con2
* andThen Consumer ，
*/
private static void useString2(String[] strarr,Consumer<String> con1,Consumer<String> con2){
for (String s : strarr) {
con1.andThen(con2).accept(s);// Consumer s
}
}
}
1.4.3 Predicate 인터페이스
Predicate 인 터 페 이 스 는 매개 변수 가 지정 한 조건 에 만족 하 는 지 판단 하 는 데 사 용 됩 니 다.
Predicate:자주 사용 하 는 네 가지 방법
booleantest(T t):주어진 매개 변 수 를 판단 합 니 다(판단 논 리 는 Lambda 표현 식 으로 이 루어 집 니 다).불 값public class Demo {
public static void main(String[] args) {
/* boolean result = usePredicate("hello", new Predicate() {
@Override
public boolean test(String s) {
return s.length()>8;
}
});*/
boolean b1 = usePredicate("hello", s -> s.length()>8);
System.out.println(b1);
boolean b2 = usePredicate("hellowrold", s -> s.length() < 15);
System.out.println(b2);
}
//
//
private static boolean usePredicate(String str,Predicate<String> p){
// boolean test = p.test(str);
// return p.test(str);
return p.negate().test(str);
}
}
： true
false
② and(Predicate other),or(Predicate other)방법 사용
public class Demo2 {
public static void main(String[] args) {
boolean b = checkString("hello", s -> s .length() > 8, s -> s.length() < 15);
System.out.println(b);
}
// ，
private static boolean checkString(String s, Predicate<String> p1, Predicate<String> p2) {
// boolean b1 = p1.test(s);
// boolean b2 = p2.test(s);
// return b1&&b2;
// and、or
// return p1.and(p2).test(s);
return p1.or(p2).test(s);
}
}
：true
연습 하 다.
public class PredicateDemo1 {
public static void main(String[] args) {
String[] strArr = {" ,30", " ,43", " ,35", " ,28", " ,33"};
// usePredicate
//
/* usePredicate(strArr, new Predicate() {
@Override
public boolean test(String s) {// 3
return s.split(",")[0].length() > 3;
}
}, new Predicate() {
@Override
public boolean test(String s) {// 33
return Integer.parseInt(s.split(",")[1]) > 33;
}
});*/
//Lambda
usePredicate(strArr,
s -> s.split(",")[0].length() > 2, // 2
s -> Integer.parseInt(s.split(",")[1]) > 33 // 33
);
}
private static void usePredicate(String[] strings, Predicate<String> pre1, Predicate<String> pre2) {
//
ArrayList<String> list = new ArrayList<>();
//
for (String string : strings) {
boolean test = pre1.and(pre2).test(string); //
if (test) {// test true， strings list
list.add(string);
}
}
// ArrayList
for (String s : list) {
System.out.println(s);
}
}
}
： ,35
1.4.4 함수 인터페이스
Function 인 터 페 이 스 는 보통 매개 변 수 를 처리 하고 변환(처리 논 리 는 Lambda 표현 식 으로 이 루어 집 니 다)한 다음 에 새로운 값 이 자주 사용 하 는 두 가지 방법 을 되 돌려 줍 니 다.
public class Demo2 {
public static void main(String[] args) {
// ， int ，
// convert("100",s->Integer.parseInt(s));
// ， int ，
// convert(12,integer -> String.valueOf(integer+21));
// ， int ， int ，
convert("12", s -> Integer.parseInt(s), i -> String.valueOf(i + 21));
}
// ， int ， int ，
private static void convert(String s, Function<String, Integer> f1, Function<Integer, String> f2) {
// Integer i = f1.apply(s);
// String ss = f2.apply(i);
// System.out.println(ss);
String apply = f1.andThen(f2).apply(s);
System.out.println(apply);
}
// ， int ，
private static void convert(Integer i, Function<Integer, String> f) {
String result = f.apply(i);
System.out.println(result);
}
// ， int ，
private static void convert(String s, Function<String, Integer> f) {
Integer result = f.apply(s);
System.out.println(result);
}
}
2.Stream 흐름
2.1 Stream 흐름 의 생 성 방법
public class Demo2 {
public static void main(String[] args) {
//Collection stream（）
List<String> list = new ArrayList<>();
Stream<String> listStream = list.stream();
Set<String> set = new HashSet<String>();
Stream<String> setStream = set.stream();
//Map
Map<String,Integer> map = new HashMap<>();
Stream<String> keyStream = map.keySet().stream();
Stream<Integer> vlaueStream = map.values().stream();
Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();
// Stream of(T...values)
String[] strArray = {"hello","world","java"};
Stream<String> strArray1 = Stream.of(strArray);
Stream<String> strArray2 = Stream.of("hello", "world", "java");
}
}
2.2 Stream 흐름 에서 흔히 볼 수 있 는 중간 조작 방법
2.1.1 filter(Predicate p)
Stream filter(Predicate predicate):흐 르 는 데 이 터 를 걸 러 내 는 데 사용 합 니 다.
Predicate 인터페이스 에서 의 방법 Boolean test(T t):주어진 매개 변 수 를 판단 하여 불 값 을 되 돌려 줍 니 다.
public class Demo1 {
public static void main(String[] args) {
ArrayList<String> names = new ArrayList<>();
names.add(" ");
names.add(" ");
names.add(" ");
names.add(" ");
names.add(" ");
names.add(" ");
//
ArrayList<String> zhangs = new ArrayList<>();
for (String name : names) {
if(name.startsWith(" ")){
zhangs.add(name);
}
}
// 3
ArrayList<String> three = new ArrayList<>();
for (String zhang : zhangs) {
if(zhang.length()==3){
three.add(zhang);
}
}
//
for (String s : three) {
System.out.println(s);
}
System.out.println("----------");
// stream
names.stream().filter(s->s.startsWith(" ")).filter(s->s.length()==3).forEach(System.out::println);
/**
* names.stream(): stream
* filter(s->s.startsWith(" "))： “ ”
* filter(s->s.length()==3)： ，
* forEach(System.out::println)：
*/
}
}
2.1.2 limit(long n)
Stream limit(long n):캡 처 한 n 개의 요소 로 구 성 된 흐름 을 되 돌려 줍 니 다.
2.1.3 skip(long n)
Stream skip(long n):지정 한 매개 변수 개수 의 요 소 를 건 너 뛰 고 나머지 요소 로 구 성 된 흐름 을 되 돌려 줍 니 다.
public class Demo3 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add(" ");
list.add(" ");
list.add(" ");
list.add(" ");
list.add(" ");
list.add(" ");
// 4
list.stream().limit(4).forEach(System.out::println);
System.out.println("----------");
// 2 ，
list.stream().skip(2).forEach(System.out::println);
System.out.println("----------");
// 2 ， 2
list.stream().skip(2).limit(2).forEach(System.out::println);
}
}
：
----------
----------
2.1.4 concat(Stream a, Stream b)
Static Stream concat(Stream a,Stream b):a 와 b 두 개의 흐름 을 합 쳐 하나의 흐름 으로 합 칩 니 다.
2.1.5 distinct（）
Stream distinct():이 흐름 의 다른 요소(Object.equals(Object o)로 구 성 된 흐름 을 되 돌려 줍 니 다.
public class Demo4 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add(" ");
list.add(" ");
list.add(" ");
list.add(" ");
list.add(" ");
list.add(" ");
// 1： 4
Stream<String> stream1 = list.stream().limit(4);
// 2： 2 ，
Stream<String> stream2 = list.stream().skip(2);
// 3： ,
// Stream.concat(stream1, stream2).forEach(System.out::println);
// 4： 1 2 ，
Stream.concat(stream1, stream2).distinct().forEach(System.out::println);
}
}
2.1.6 sorted()
Stream sorted():이 흐름 의 요소 로 구 성 된 흐름 을 되 돌려 주 고 자 연 스 럽 게 정렬 합 니 다.
Stream sorted(Comparator comparator):이 흐름 의 요소 로 구 성 된 흐름 을 되 돌려 주 고 제 공 된 Comparator 에 따라 정렬 합 니 다.
public class Demo5 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("aas");
list.add("acbds");
list.add("sccd");
list.add("cbffe");
list.add("scce");
// 1：
// list.stream().sorted().forEach(System.out::println);
// 2：
// list.stream().sorted((s1, s2) -> s1.length()-s2.length()).forEach(System.out::println);
// 3： ， ，
list.stream().sorted((s1,s2)->{
int num = s1.length()-s2.length();
return num==0?s1.compareTo(s2):num;
}).forEach(System.out::println);
}
}
： aas
sccd
scce
acbds
cbffe
2.1.7 map(Function m)
Stream map(Function m):주어진 함수 가 이 흐름 에 적용 한 요소 의 결과 로 구 성 된 흐름 을 되 돌려 줍 니 다.
IntStream mapToInt(ToIntFunction m):주어진 함 수 를 이 흐름 에 적용 하 는 요 소 를 포함 하 는 IntStream 을 되 돌려 줍 니 다.
인 트 스 트림 인터페이스
public class Demo6 {
public static void main(String[] args) {
//
ArrayList<String> list = new ArrayList<>();
list.add("2");
list.add("3");
list.add("4");
list.add("5");
list.add("6");
list.add("7");
// 1：
// list.stream().map(s->Integer.parseInt(s)).forEach(System.out::println);
// list.stream().map(Integer::parseInt).forEach(System.out::println);
//int sum() 。
int sum = list.stream().mapToInt(Integer::parseInt).sum();
System.out.println(sum);
//list.stream() stream
//mapToInt(Integer::parseInt) IntStream
//sum() IntStream ，
}
}
2.3 Stream 흐름 의 흔 한 종료 동작
public class Demo7 {
public static void main(String[] args) {
ArrayList<String > list = new ArrayList<>();
list.add(" ");
list.add(" ");
list.add(" ");
list.add(" ");
list.add(" ");
// 1：
// list.stream().forEach(System.out::println);
// 2： “ ” ，
long count = list.stream().filter(s -> s.startsWith(" ")).count();
System.out.println(count);
}
}
： 3
종합 연습
/*
ArrayList ， 6 ， ：
，
Actor ， ， ， get、set
*/
import java.util.ArrayList;
import java.util.stream.Stream;
class Actor {
private String name;
public String getName() {
return name;
}
@Override
public String toString() {
return "Actor{" +
"name='" + name + '\'' +
'}';
}
public void setName(String name) {
this.name = name;
}
public Actor(String name) {
this.name = name;
}
}
public class Test_02 {
public static void main(String[] args) {
ArrayList<String> maleList = new ArrayList<>();
ArrayList<String> femaleList = new ArrayList<>();
maleList.add(" ");
maleList.add(" ");
maleList.add(" ");
maleList.add(" ");
maleList.add(" ");
maleList.add(" ");
femaleList.add(" ");
femaleList.add(" ");
femaleList.add(" ");
femaleList.add(" ");
femaleList.add(" ");
femaleList.add(" ");
//
Stream<String> manStream = maleList.stream().filter(s -> s.length() == 3).limit(3);
//
Stream<String> womanStream = femaleList.stream().filter(s -> s.startsWith(" ")).skip(1);
//
Stream<String> concatStream = Stream.concat(manStream, womanStream);
// ，
concatStream.map(s->new Actor(s)).forEach(System.out::println);
// concatStream.map(Actor::new).forEach(a-> System.out.println(a.getName()));
}
}
： Actor{name=' '}
Actor{name=' '}
Actor{name=' '}
Actor{name=' '}
Actor{name=' '}
2.4 Stream 흐름 의 수집 작업
데이터 에 대해 Stream 흐름 을 사용 하 는 방식 으로 조작 이 끝 난 후에 저 는 흐름 속 의 데 이 터 를 집합 에 수집 하고 싶 습 니 다.어떻게 해 야 합 니까?
stream 흐름 수집 방법
도구 류 Collectors 는 구체 적 인 수집 방법 을 제공 합 니 다.
public class Demo8 {
public static void main(String[] args) {
// List
List<String> list = new ArrayList<>();
list.add(" ");
list.add(" ");
list.add(" ");
list.add(" ");
// 1： 3
Stream<String> lenStream = list.stream().filter(s -> s.length() == 3);
// 2： List ,
List<String> names = lenStream.collect(Collectors.toList());
names.forEach(System.out::println);
// Set
Set<Integer> set = new HashSet<>();
set.add(10);
set.add(20);
set.add(30);
set.add(40);
// 3： 20
Stream<Integer> num = set.stream().filter(i -> i > 20);
// 4： Set ,
Set<Integer> numStream = num.collect(Collectors.toSet());
numStream.forEach(System.out::println);
// ，
String[] strArray = {" ,12"," ,20"," ,22"," ,18"};
// 5： 18
Stream<String> stringStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) > 18);
// 6： Map ， ，
Map<String, String> student = stringStream.collect(Collectors.toMap(s -> s.split(",")[0], s -> s.split(",")[1]));
//
Set<Map.Entry<String, String>> entries = student.entrySet();
entries.forEach(s-> System.out.println(" ："+s.getKey()+", ："+s.getValue()));
}
}
：
40
30
： , ：22
： , ：20
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
JPA + QueryDSL 계층형 댓글, 대댓글 구현(2)이번엔 전편에 이어서 계층형 댓글, 대댓글을 다시 리팩토링해볼 예정이다. 이전 게시글에서는 계층형 댓글, 대댓글을 구현은 되었지만 N+1 문제가 있었다. 이번에는 그 N+1 문제를 해결해 볼 것이다. 위의 로직은 이...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.
좋은 웹페이지 즐겨찾기
