java_스트림_221205(11일차)

1. 스트림

컬렉션 프레임워크(배열)

각각의 요소를 하나씩 참조해서 람다로 처리

표준화를 위해 사용한다.

 

- 원본을 변경하지 않음

- for -> 외부 반복 / 스트림 -> 내부 반복

- 재사용 불가

- 병렬 처리 지원

 

처리 순서

1. 생성

2. 가공(중개 연산 - 변환)

3. 결과

 

hasNext = it배열의 0번방부터 다음방에 내용이있으면  true없으면 false true면 반복

 

package 스트림;

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class Sample01 {

	public static void main(String[] args) {
		
		List<String> list = Arrays.asList(new String[] {"홍", "김", "이", "유"});
		
		int i = 0;
		
		System.out.println("for문 이용");
		for(i = 0; i<list.size(); i++) {
			System.out.println(list.get(i));
		}
		
		//Iterator <-- 반복자 / list, set, map을 다 사용이 가능
		System.out.println("외부 반복자 이용");
		Iterator<String> it = list.iterator();
				while(it.hasNext()) {
			System.out.println(it.next());
		}
				
				//.forEach <-- 반복시켜주는 메서드
			System.out.println("내부 반복자");
			list.stream().forEach(s -> System.out.println(s));
	

	}

}

(병렬 처리 기능은 위 코드에서는 없음)

---

package 스트림;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class StuMain {

	public static void main(String[] args) {
		
		List<Student> list = Arrays.asList(
					new Student("홍길동", 90),
					new Student("고길동", 80)
				);
		
		Stream<Student> str = list.stream();
		
		str.forEach(s -> {
				String name = s.getName();
				int score = s.getScore();
				System.out.println("이름 : " + name + ", 점수 :  " + score);
		});
	}
}

package 스트림;

public class Student {
	
	String name;
	int score;
	
	
	public Student(String name, int score) {
		this.name = name;
		this.score = score;
	}
	
	
	public String getName() {
		return name;
	}
	public int getScore() {
		return score;
	}
	
	

}

---

package 스트림;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class Sample02 {
	
	static void print(String str) {
		
		System.out.println(str + " : " + Thread.currentThread().getName());
	}

	public static void main(String[] args) {
		
		List<String> list = Arrays.asList("김", "이", "박", "최", "양", "남궁");
		//순차처리 과정
		Stream<String> stream = list.stream();
		stream.forEach(Sample02::print);
		
		System.out.println("==========");
		
		//병렬처리 과정 parallelStream()<-- 병렬처리스트림
		Stream<String> stream2 = list.parallelStream();
		stream2.forEach(Sample02::print);

	}

}

---

package 스트림;

import java.util.Arrays;
import java.util.List;

public class Sample03 {

	public static void main(String[] args) {
		
		List<Student> list = Arrays.asList(
					new Student("홍길동", 90),
					new Student("고길동", 70),
					new Student("김유신", 88)
				);
		//           list.stream() 스트림 생성 / .mapToInt(Student::getScore).average().getAsDouble(); 가공
		double avg = list.stream().mapToInt(Student::getScore).average().getAsDouble();
		//.mapToInt <-- 정수형 스트림으로 변환시켜준다. 1차 가공
		//.average() <-- 스트림 내부에 있는 값들에 평균을 구해준다.
		//.getAsDouble <-- 마지막으로 소수점을 표시해야 되기 때문에 실수형으로 다시 변환 시켜준다.
		
		System.out.println("평균 : " + avg);

	}

}

package 스트림;

public class Student {
	
	String name;
	int score;
	
	
	public Student(String name, int score) {
		this.name = name;
		this.score = score;
	}
	
	
	public String getName() {
		return name;
	}
	public int getScore() {
		return score;
	}
	
	

}

---

package 스트림;

import java.util.Arrays;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Sample04 {
	
	static int sum = 0;

	public static void main(String[] args) {


		String[] arr = {"김", "박", "이", "최", "남"};
		
		Stream<String> na = Arrays.stream(arr);
		na.forEach(a -> System.out.print(a + " "));
		
		System.out.println();
		
		//							 배열 index 1번 방 부터 4번 방 전!까지
		Stream<String> na2 = Arrays.stream(arr, 1, 4);
		na2.forEach(a -> System.out.print(a + " "));
		
		
		
		IntStream na3 = IntStream.rangeClosed(1,  100);
		na3.forEach(n -> sum += n);
			
		System.out.println("합 : " + sum);
		
	}

}

---

package 스트림;

import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;

public class Sample05 {

	public static void main(String[] args) {
		
		List<String> list = Arrays.asList("홍길동", "김유신", "홍길동", "이순신", "홍길동", "유관순");
		
		//중복제거 .distinct <--데이터베이스에서 활용
		list.stream().distinct().forEach(n -> System.out.println(n));

		
		System.out.println("=====");
		
		
		//필터처리
		list.stream().filter(n -> n.startsWith("홍")).forEach(n -> System.out.println(n));
		
		System.out.println("=====");
		
		
		//.forEach <-- 다른 메서드를 이용해 조합해서 사용도 가능
		list.stream().filter(n -> n.startsWith("홍")).distinct().forEach(n -> System.out.println(n));
		
		
		//홀수를 구하고 싶을 때
		IntStream s = IntStream.of(1,2,3,4,5,6,7,8,9,10);
		s.filter(n -> n % 2 == 1).forEach(n -> System.out.println(n));

	}

}

---

split

package 스트림;

import java.util.Arrays;
import java.util.List;
import java.util.stream.DoubleStream;
import java.util.stream.Stream;

public class Sample06 {

	public static void main(String[] args) {
		
		List<String> list1 = Arrays.asList("동해 물과", "백두 산이", "마르고 닳도록");
		
		//.split(" ") <-- 띄어쓰기 한 곳을 나눠서 출력을 해준다.
		list1.stream().flatMap(data -> Arrays.stream(data.split(" ")))
		.forEach(System.out::println);
		
		System.out.println();
		
		list1.stream().flatMap(data -> Stream.of(data.split(" ")))
		.forEach(System.out::println);
		
		System.out.println();
		
		//data.length <-- 글자수를 세어줌
		//map은 정수로만 리턴을 시켜줌
		list1.stream().map(data -> data.length())
		.forEach(System.out::println);

---

		//실수
		List<String> list2 = Arrays.asList("1.1, 2.2, 3.3", "4.4, 5.5, 6.6");
		DoubleStream ds = list2.stream().flatMapToDouble(data -> {
					String[] arr = data.split(",");
					double[] darr = new double [arr.length];
					
					for(int i=0; i<darr.length; i++) {
						darr[i] = Double.parseDouble(arr[i].trim());
					}
					return Arrays.stream(darr);
		});
		
		ds.forEach(System.out::println);

---

		//실수
		List<String> list2 = Arrays.asList("1.1, 2.2, 3.3", "4.4, 5.5, 6.6");
		DoubleStream ds = list2.stream().flatMapToDouble(data -> {
					String[] arr = data.split(","); //.split , 기준으로 나눠줌
					double[] darr = new double [arr.length];
					//arr 방이 6개가 만들어진걸 .length <--이 기능이 처리해주고 6개 생성된 실수형을 보관할 배열방이 darr로 대입
					
					for(int i=0; i<darr.length; i++) {
						darr[i] = Double.parseDouble(arr[i].trim()); //.trim <-- 공백 제거해주는 메서드
					} //darr.length가 배열방이 6개니 i는 6보다 작을때 까지 반복
					  //arr[i] 배열 방에 있는 첫 번째 값을 darr[i] 배열방 첫 번째 값으로 대입
					  //반복문 조건이 완료될 때 까지 순서대로 반복
					return Arrays.stream(darr);
					//darr 배열값이 실수로 처리되어 ds로 리턴
			
		});
		
		ds.forEach(System.out::println);

---

- 제한걸어둘때 .skip / .limit

package 스트림;

import java.util.stream.IntStream;

public class Sample07 {

	public static void main(String[] args) {
		
		IntStream s = IntStream.range(0, 10);
		
		s.skip(4).forEach(n -> System.out.print(n + " "));

	}

}

---

s.limit(4).forEach(n -> System.out.print(n + " "));

---

s.skip(3).limit(4).forEach(n -> System.out.print(n + " "));

---

s.limit(4).skip(3).forEach(n -> System.out.print(n + " "));

---

.sorted() <-- 오름차순 정렬 메서드

package 스트림;

import java.util.Arrays;
import java.util.List;

public class Sample08 {

	public static void main(String[] args) {
		
		List<String> list = Arrays.asList("홍길동", "김유신", "이순신", "유관순");
		
		//.sorted() <-- 오름차순 정렬 메서드
		list.stream().sorted().forEach(System.out::println);

	}

}

---

Comparator.reverseOrder() 내림차순 정렬 메서드

list.stream().sorted(Comparator.reverseOrder()).forEach(System.out::println);

---

.count() / .sum() / .findFirst()

		int[] arr = new int[100];
		for(int i = 0; i<100; i++) {
			arr[i] = i + 1;
		}
		
		//count는 long으로 처리
		//배열을 스트림으로 하고 카운트 해준다.
		long c = Arrays.stream(arr).count();
		System.out.println("count : " + c);
		
		int s = Arrays.stream(arr).sum();
		System.out.println("sum : " + s);

---

Optional???

Optional 클래스 NPE (null point exception) 예외 - 공백에 관련된 예외처리

 

Optional 클래스 널값 (null) 감싸는 Warpper 클래스 

 

OptionalInt

OptionalDouble 등등

 

		OptionalInt first = Arrays.stream(arr).findFirst();
		System.out.println("first : " + first.getAsInt());
		
		OptionalInt max = Arrays.stream(arr).max();
		System.out.println("최대값 : " + max.getAsInt());
		
		OptionalInt min = Arrays.stream(arr).min();
		System.out.println("최대값 : " + min.getAsInt());

---

.anyMatch <- true / false

		int[] arr = new int[100];
		for(int i = 0; i<100; i++) {
			arr[i] = i + 1;
		}
		
		System.out.println(Arrays.stream(arr).anyMatch(n -> n > 80));
		System.out.println(Arrays.stream(arr).anyMatch(n -> n > 1000));

---

.allMatch

		int[] arr = new int[100];
		for(int i = 0; i<100; i++) {
			arr[i] = i + 1;
		}
		
		System.out.println(Arrays.stream(arr).allMatch(n -> n >= 1));
		System.out.println(Arrays.stream(arr).allMatch(n -> n >= 100));

---

★문제

package 스트림;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashSet;

public class Sample09 {

	public static void main(String[] args) {
		
		// 짝수만 중복 제거 해서 내림차순으로 정렬 출력
		int[] data = {5, 6, 7, 8, 9, 1, 5, 5, 9, 1, 2, 2};
		
		ArrayList<Integer> list = new ArrayList<>();
		for(int i = 0; i<data.length; i++) {
			if(data[i] % 2 == 0) {
				list.add(data[i]);
			}
			System.out.print(", " + data[i]);
		}
	
		
		
		
		//HashSet 중복 걸려줌
		HashSet<Integer> set = new HashSet<>(list);
		
		System.out.println("\n" + set);
		

		ArrayList<Integer> dlist = new ArrayList<>(set);
		
		dlist.sort(Comparator.reverseOrder());
		
		System.out.println(dlist);
		
		int[] result = new int[dlist.size()];
		
		for(int i = 0; i<result.length; i++) {
			result[i] = dlist.get(i);
		}
		
		for(int i = 0; i<result.length; i++) {
			System.out.println(result[i]);
		}
	}

}

---

리펙토링

package 스트림;

import java.util.Arrays;
import java.util.Comparator;

public class Sample10 {

	public static void main(String[] args) {
		
		
		int[] data = {5, 6, 7, 8, 9, 1, 5, 5, 9, 1, 2, 2};
		int[] result = Arrays.stream(data)
				.boxed() //IntStream -> Stream<Integer>
				.filter(n -> n % 2 == 0) //2로 나누었을때 0이 되는 것들만 골르는 것 필터 메서드
				.distinct() //중복제거 메서드
				.sorted(Comparator.reverseOrder())//내림차순 정렬 메서드
				//int자체로 처리를 못함 Integer 랩퍼 클래스로 전환 시켜 작업을 해줘야 됨
				
				.mapToInt(Integer::intValue) //Integer -> int로 변환
				.toArray(); //배열로 형변환
		for(int i = 0; i<result.length; i++) {
			System.out.println(result[i]);
		}

	}

}

---

---

package 문제풀이13;

import java.util.stream.Stream;

//스트림 사용
	
public class Main {

	public static void main(String[] args) {

		String[] strArr = {"aaa", "bbb", "c", "dddd"};
		
		Stream<String> s = Stream.of(strArr);
		int len = s.mapToInt(a -> a.length()).sum();
		
		System.out.println(len);

	}

}

int len = s.mapToInt(String::length).sum();

위 방법으로도 가능하다

---

package 문제풀이14;

import java.util.Arrays;

/**
 * 홀수만 2를 곱해서 result에 저장한 후 출력
 */

public class Main {

	public static void main(String[] args) {
		int[] n = {1,2,3,4,5};
		int[] result = Arrays.stream(n)
				.filter(a -> a % 2 == 1)
				.map(a -> a * 2)
				.toArray();

				
		System.out.println(Arrays.toString(result));

	}

}

---

package 문제풀이15;

import java.util.Random;

//로도번호 출력
public class Main {

	public static void main(String[] args) {
		
		new Random().ints(1, 46)
				.distinct() //중복값 제거
				.limit(6) //일정 개수만큼만 가져와서 새로운 스트림을 리턴
				.sorted() //요소들을 정렬하여 새로운 스트림을 생성
				.forEach(System.out::println); //출력
	}
}

---