20210813

public final class Optional<T> extends Object 

// 데이터가 없는 Optional 객체 생성 
Optional<String> emptyString = Optional.empty()
// null 추가 
Optional<String> nullableString = Optional.ofNullable(null);
// 반드시 데이터가 들어갈 수 있는 상황 
Optional<String> commonString = Optional.of("common");

private void getOptionalData(Optional<String> data) 
						throws Exception {
	String defaultValue = "default";
	String result1 = data.get();
	// 값이 없을 경우 기본값을 지정할 수 있다 
	String result2 = data.orElse(defaultValue);
	
	Supplier<String> stringSupplier = new Supplier<String>(){
		@Override
		public String get(){
			return "GodOfJava";
		}
	};
	String result3 = data.orElseGet(stringSupplier);

	Supplier<Exception> exceptionSupplier = 
    					new Supplier<Exception>(){
		@Override
		public  Exception get(){
			return new Exception(); 
		}
	};
	// 데이터가 없을 경우 예외 발생 
	String result4 = data.orElseThrow(exceptionSupplier);
}

public intetface DefaultStaticInterface{
	String getName();
	int Since();
	default String getEMail(){
		return "[email protected]";
	}
}

int[] intValues = new int[10];
Arrays.parallelSort(intValues);

// 배열의 구성요소 사이에 콤마만 넣고자 할 때 
public void joinStringOnlyComma(){
	String[] stringArray = 
    		new String[]{"StudyHard", "GodOfJava", "Book"};
	StringJoiner joiner = new StringJoiner(",");
	StringJoiner joiner2 = new StringJoiner(",","(",")");
	for(String string:stringArray){
		joiner.add(string);
		joiner2.add(string);
	}
	System.out.println(joiner);
	System.out.println(joiner2);
}

//출력값
StudyHard,GodOfJava,Book
(StudyHard,GodOfJava,Book)

// 이 어노테이션을 사용하면 
// 인터페이스에는 내용이 없는 하나의 메소드만 선언할 수 있다
@FuncctionalInterface
interface Calculate {
	int operation(int a, int b);
}
Calculate cal = (a, b) -> a+b;

// Runnable은 run()메소드 밖에 없기 때문에 람다 표현식 처리 가능
new Thread(()->{
	System.out.println("람다");
}).start();

or 

new Thread(() -> System.out.println("람다")).start();

Predicate<String> predicateLength5 = (a) -> a.length()>5;
Predicate<String> predicateContains = (a) -> a.contains("God");
Predicate<String> predicateStart = (a) -> a.startsWith("God");

String str = "GodOfJava"

// 데이터가 해당 조건에 맞는지 확인
predicateLength5.test(str)
// 데이터가 두개의 조건에 모두 맞는지 확인
predicateLength5.and(predicateContains).test(str)
// 데이터가 두개의 조건 중 하나라도 맞는지 확인
predicateLength5.or(predicateContains).test(str)
// 데이터가 조건과 다른지 확인
predicateLength5.negate().test(str)

list.stream().filter(x-> x>10).count()
    스트림생성    중개 연산     종단 연산

- 스트림 생성 : 컬렉션 목록을 스트림 객체로 변환 
- 중개 연산 : 생성된 스트림 객체를 사용해 중개 연산 부분에서 처리
             이 부분에서는 아무런 결과를 리턴하지 못한다
             0개 이상의 중개 연산이 존재 
- 종단 연산 : 중개 연선에서 작업된 내용을 바탕으로 결과 리턴 

// 배열 -> 리스트
Integer[] values = { 1, 3, 5 };
List<Integer> list = Arrays.stream(values).collect(Collectiors.toList());

public void printStudentNames(List<StudentDTO> students){
  // student = StudentDTO 객체
  students.stream()
  	.forEach(student -> System.out.println(student.getName()));

  // StudentDTO 객체를 사용하는게 아니라 String값 사용 
  students.stream().map(student->student.getNmae())
  		.forEach(name->System.out.println(name));
}

public class MethodReferenceSample {
   MethodReferenceSampel sample = new MethodReferenceSample();
   String[] stringArray = {"요다", "만두", "건빵"};
   sample.staticReference(stringArray);
} 

public void staticReference(String[] stringArray){
   // of() : 스트림 객체 생성 
   // String의 스트림이기 때문에 forEach() 문장 안에서는 String을 제공
   Stream.of(stringArray).forEach(MethodReferenceSample::printResult);
}

public static void printResult(String value){
   System.out.println(value);
}

private void objectReference(String[] stringArray){
	// 임의 객체 참조 
	Arrays.sort(stringArray, String::compareToIgnoreCase);
	// 인스턴스 메소드 참조 
	Arrays.asList(stringArray).stream().forEach(System.out::println);
}

public int compareToIgnoreCase(String str){
	return CASE_INSENSITIVE_ORDER.compare(this, str);
}

interface MakeString{
	String fromBytes(char[] chars);
}

private void createInstance(){
	// String 생성자 중에 char[]를 매개 변수로 받는 생성자가 
        // 있기 때문에 이렇게 사용 가능 
	MakeSring makeString = String::new;
	char[] chars = {'G','O','D'};
	String madeString = makeString.fromBytes(chars);
	System.out.println(madeString);
}

List<Integer> intList = Arrays.asList(1,2,3,4,5,6,7,8,9,10);

// initList 내용들 모두 x3하기
intList.stream().forEach(x->System.out.println(x*3)); 
// map() : 스트림에서 처리하는 값들을 중간에 변경할 수 있다. 
intList.stream().map(x->x*3).forEach(System.out::println);

//studentList에서 이름만 List로 뽑아 내고 싶을 경우 
List<StudentDTO> nameList = new ArrayList<>();
studentList.add(new StudentDTO("요다",43,99,10));
studentList.add(new StudentDTO("만두",30,49,90));
studentList.add(new StudentDTO("건빵",32,71,70));
List<String> nameList = studentList.stream().map(x->x.getName())
  			.collect(Collectors.toList());

private void filterWithScoreForLoop
  		(List<StudentDTO> studentList, int scoreCutLine){
  studentList.stream().filter(student->student.getScore()>scoreCutLine)
  	.forEach(student -> System.out.println(student.getName()));
}