728x90
Stream 이란 다양한 데이터 소스를 표준화된 방법으로 다루기 위한 것이다.
- 스트림은 데이터 소스로부터 데이터를 읽기만 할 뿐 변경하지 않는다.
- 스트림은 Iterator 처럼 1회용이다. (필요하면 다시 스트림을 생성해야 함)
- 람다식으로 처리할 수 있도록 도와주는 반복자이다. (JDK 1.8 이상)
|
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class StreamEX1 {
public static void main(String[] args) {
// Arrays.asList : 배열을 리스트로 바꾸기
List<Integer> list = Arrays.asList(1,2,3,8,9,10,4,5,6,7);
System.out.println(list);
// Stream : 다양한 데이터 소스를 표준화된 방법으로 다루기 위한 것
// ① 스트림 만들기 ② 중간 연산 ③ 최종 연산
// 스트림은 데이터 소스로부터 데이터를 읽기만 한다. (변경 하지 않음)
// 스트림은 Iterator처럼 1회용이다.
Stream<Integer> stream = list.stream(); // list를 stream 으로 변환
stream.forEach(System.out::print);
System.out.println();
Stream<Integer> stream2 = list.stream();
stream2.sorted().map(String::valueOf).forEach(i-> System.out.print(i+":"));
// 원하지 않는 결과를 출력한다.
System.out.println();
final String result = list.stream().
sorted().
map(String::valueOf).
collect(Collectors.joining(":")); // collect와 forEach 동시 사용 불가
System.out.println(result);
System.out.println();
System.out.println("********** 로또 번호 **************");
// 로또번호 출력
// IntStream : 오토박싱 & 언박싱의 비효율이 제거됨.
// Stream<Integer> 대신에 IntStream 사용
IntStream intStream = new Random().ints(1,46);
final String lotto_result = intStream.distinct().limit(6).sorted()
.mapToObj(String::valueOf).collect(Collectors.joining(","));
System.out.println(lotto_result);
// ********************************************************************
System.out.println();
System.out.println("******* String.valueof ***********");
// String.valueof
Map<String,Object> map = new HashMap<>();
map.put("param1", "3번");
map.put("param2", 2);
map.put("param3", null);
System.out.println(String.valueOf(map.get("param1")));
System.out.println(String.valueOf(map.get("param2")));
System.out.println(String.valueOf(map.get("param3"))); // null 반환
System.out.println(map.get("param3")); // null 반환
//System.out.println(map.get("param3").toString()); // 에러 발생
for(Map.Entry<String,Object> entry : map.entrySet()) {
System.out.println("Key : " + entry.getKey());
System.out.println("Value : " + entry.getValue());
}
}
}
|
결과
1 : 2 : 3 : 4 : 5 : 6 : 7 : 8 : 9 : 10
|
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Stream;
public class StreamEX2 {
public static void main(String[] args) {
// Arrays.asList : 배열을 리스트로 바꾸기
List<String> list = Arrays.asList("홍길동", "이순신", "강감찬");
System.out.println(list);
// Iterator 이용 (Java 7 이하)
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()) {
String name = iterator.next();
System.out.println(name);
}
System.out.println("********");
// for문 이용
for (String name : list) {
System.out.println(name);
}
System.out.println("********");
// Stream 은 컬렉션(배열포함)의 요소를 하나씩 참조해서 람다식으로 처리하는 반복자
// Stream 이용(Java 8)
Stream<String> stream = list.stream();
stream.forEach(name->System.out.println(name)); // 최종 연산
// 스트림은 데이터 소스로부터 데이터를 읽기만 한다. (변경 하지 않음)
// 스트림은 Iterator처럼 1회용이다.
}
}
|
|
import java.util.*;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class StreamEX3 {
public static void main(String[] args) {
ArrayList<Student> arr = new ArrayList<>();
arr.add(new Student("이순신", 3, 300));
arr.add(new Student("김재동", 1, 200));
arr.add(new Student("강감찬", 2, 170));
arr.add(new Student("소지섭", 2, 190));
arr.add(new Student("소유진", 1, 200));
arr.add(new Student("남궁성", 3, 270));
arr.add(new Student("신용권", 3, 280));
// HashSet(Set인터페이스를 구현한 대표적인 컬렉션 클래스)을 사용하여 중복 제거하기
Set<Student> arr2 = new HashSet<>(arr);
ArrayList<Student> resArr2 = new ArrayList<>(arr2);
Collections.sort(resArr2,Comparator.comparing(Student::getBan) // 반별 정렬
.thenComparing(Comparator.comparing(Student::getName))
.thenComparing(Comparator.naturalOrder())); // 기본 정렬
//System.out.println(resArr2);
for(Student s : resArr2){
System.out.println(s);
}
System.out.println("*****************");
Stream<Student> stream = arr.stream().
sorted(Comparator.comparing(Student::getBan).
thenComparing(Comparator.comparing(Student::getName)).
thenComparing(Comparator.naturalOrder()));
stream.forEach(System.out::println);
System.out.println("*****************");
Stream<Student> studentStream = Stream.of(
new Student("이순신", 3, 300),
new Student("김재동", 1, 200),
new Student("강감찬", 2, 170),
new Student("소지섭", 2, 190),
new Student("소유진", 1, 200),
new Student("남궁성", 3, 270),
new Student("신용권", 3, 280)
);
studentStream.sorted(Comparator.comparing(Student::getBan) // 반별 정렬
.thenComparing(Comparator.naturalOrder())) // 기본 정렬
.forEach(System.out::println);
}
}
class Student implements Comparable<Student> {
String name;
int ban;
int totalScore;
Student(String name, int ban, int totalScore) {
this.name =name;
this.ban =ban;
this.totalScore =totalScore;
}
public String toString() {
return String.format("[%s, %d, %d]", name, ban, totalScore);
}
String getName() { return name;}
int getBan() { return ban;}
int getTotalScore() { return totalScore;}
// 총점 내림차순을 기본 정렬로 한다.
public int compareTo(Student s) {
return s.totalScore - this.totalScore;
}
}
|
Stream map 예제
|
import java.io.File;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class StreamEX4 {
public static void main(String[] args) {
File[] fileArr = { new File("Ex1.java"), new File("Ex1.bak"),
new File("Ex2.java"), new File("Ex1"), new File("Ex1.txt")
};
Stream<File> fileStream = Stream.of(fileArr);
// map()으로 Stream<File>을 Stream<String>으로 변환
Stream<String> filenameStream = fileStream.map(File::getName);
filenameStream.forEach(System.out::println); // 모든 파일의 이름을 출력
System.out.println("-----------------------");
fileStream = Stream.of(fileArr); // 스트림을 다시 생성
// peek : 스트림의 요소를 소비하지 않고 엿보기
// map : 기존의 Stream 요소들을 변환하여 새로운 Stream을 형성하는 연산이다.
// distinct는 중복된 데이터를 검사하기 위해 Object의 equals() 메소드 사용한다
fileStream.map(File::getName) // Stream<File> → Stream<String>
.filter(s -> s.indexOf('.')!=-1) // 확장자가 없는 것은 제외
//.peek(s->System.out.printf("filename=%s%n",s))
.map(s -> s.substring(s.indexOf('.')+1)) // 확장자만 추출
//.peek(s->System.out.printf("extension=%s%n",s))
.map(String::toUpperCase) // 모두 대문자로 변환
.distinct() // 중복 제거
.forEach(System.out::println); // 메소드참조(MethodReferences)
System.out.println();
// filter : 특정조건으로 스트림의 컨텐츠를 필터링하는 것
// c로 시작하는 문자열만 필터링하도록 조건을 설정
List<String> list = Arrays.asList("a1","a2","b1","b2","c2","c1","c3");
Stream<String> stream1 = list.stream();
final String filtered = stream1.filter(s -> s.startsWith("c")).
collect(Collectors.joining(", "));
System.out.println(filtered);
}
}
|
'안드로이드 > Java 문법' 카테고리의 다른 글
| [java] Wrapper Class (0) | 2021.11.18 |
|---|---|
| [Java] Stream 예제 2 (0) | 2021.11.16 |
| [Java] Generics 예제1 (2) | 2021.11.10 |
| HashMap 예제 (0) | 2021.10.30 |
| [Java] HashSet 를 이용한 ArrayList 중복제거 및 정렬 (0) | 2020.12.12 |
Link2Me