IT & Mobile

springFramework의 BeanUtils말고 apache의 BeanUtils를 상속해서 NullAwareBeanUtils를 만들면 된다.

import org.apache.commons.beanutils.BeanUtilsBean;

public class NullAwareBeanUtilsBean extends BeanUtilsBean {

    @Override
    public void copyProperty(Object dest, String name, Object value) throws IllegalAccessException, InvocationTargetException {
        if(value == null) return; // null 값이면 복사를 수행하지 않음
        super.copyProperty(dest, name, value);
    }
}

사용법:
NullAwareBeanUtilsBean nullAwareBeanUtils = new NullAwareBeanUtilsBean();
nullAwareBeanUtils.copyProperties(destObject, sourceObject);

java8이후 17까지 업데이트된 기능들.

jshell

immutable Factory

var (추론 type)

javac+java -> java

람다형 switch  (--enable-preview -source 12 필요?)

다중문자열

record ( Lombok없이 setter getter자동 추가..)

casting없는 instanceof

sealed (class, interface ) : 상속 범위제한

Stream.toList() 직접변환 추가. (java 16)

람다형 switch : (break도 없어도 됨)

        String typeOfDay = switch (day) {
            case "MON", "TUE", "WED", "THU", "FRI" -> "Weekday";
            case "SAT", "SUN" -> "Weekend";
            default -> "Invalid day";
        };

Text Block 추가

String json = """
              {"name": "ChatGPT",
               "type": "AI"
              }
              """;

그 외 

java9의 모듈시스템  ( Project Jigsaw 의 결과물로 JPMS 탄생)   참고: https://limdevbasic.tistory.com/21 

참고: https://www.devkuma.com/docs/java/version/

students.stream()
                .sorted(Comparator.comparing(Student::getCgpa).reversed()
                        .thenComparing(Student::getFirstName)
                        .thenComparing(Student::getId))
                .map(Student::getFirstName)
                .collect(Collectors.toList());

Double을 Checker(Comparator)에서 비교시에는 *100 이런거 하면 안됨. (미세 소수 오류발생)

class Checker implements Comparator<Student> {

    @Override
    public int compare(Student p1, Student p2) { 
        return Double.compare(p2.getScore(),p1.getScore()); //DESC
    }    
}

anonymous Comparator 클래스 생성으로 비교하는 법. 1. => compare(int 아니고=> Integer인 부분 주의 필요)

int[] intArr = new int[] {1,2,6, 4, 9, 7};

        List<Integer> sortedInt = Arrays.stream(intArr).boxed()
                .sorted(new Comparator<Integer>() {
                    @Override
                    public int compare(Integer a, Integer b) {
                        return Integer.compare(a,b);
                    }
                 })
                .collect(Collectors.toList());


        log.info(""+sortedInt);

anonymous Comparator 클래스 생성으로 비교하는 법. 2

        int[] intArr = new int[] {1,2,6, 4, 9, 7};

        int maxInt = Arrays.stream(intArr).boxed()
//                .max(Integer::compare)
                .max(new Comparator<Integer>() {
                    @Override
                    public int compare(Integer a, Integer b) {
                        return Integer.compare(a,b);
                    }
                 })
                .orElse(-1);

1. array <-> stream

int array -> Arrays.stream(.. )으로 바꾸면 intStream()이 되므로 Integer stream으로 바꾸려면 .boxed()를 써야한다. 

    //cards {1,2,2, 7, 9, 9, 8} 중에 pair들 빼고 최대 값구하기
    public static int solutions(int[] cards) {


        Map<Integer, Long> counting = Arrays.stream(cards).boxed()  //intStream()을  stream()으로 바꿔야함
                .collect(Collectors.groupingBy( i->i, Collectors.counting()))  //<Integer, Long>
                ;

        Integer ret = counting.entrySet().stream()
                .filter( e -> e.getValue() == 1)
                .map( e -> e.getKey())
                .max( Integer::compare ) //need STUDY max(Comparator 임)
                .orElse(-1); //.intValue();

        //TEST code: 둘다 오류임 : study필요
//        Integer ret = Arrays.stream(cards).boxed()
//                .max(Comparator.comparingInt());
//                .max(Integer.compare());

        return ret;
    }

ERROR FIX:  Inreger.compare() => Integer::compare     & add.   .orElse(-1) 

Integer::compare 대신에 Comparator.comparing(e -> e) 도 됨. 

//summaryStatistics 를 이용한 통계방식 적용.
DoubleSummaryStatistics tpStat = list.stream().mapToDouble( log -> log.getTemp()).summaryStatistics();

이렇게 하면 다음과 같은 값들을 한번에 구할 수 있다. 사용법은 tpStat.getCount(), getSum() 등등

private long count;
private double sum;
private double min;
private double max;

1. Arrays.stream     

int[] arr = new int[] { 3, 5, 8} 

Arrays.stream( arr).filter(x -> x <=5).sum();

==> 근데 딱 한군데, arr -> List로 바꿀때는 잘 안됨.

List<Integer> list = IntStream.of(arr).boxed().collect(Collectors.toList())

           (boxed()가 primitive array를 단일 element로 잘라 줌)

참고: Stream<String> st = Stream.of("A", "B","C"); 등  다양한 Stream생성 방식:  https://codechacha.com/ko/stream-creation/

2. Arrays.sort 

int[][] arr = new int[][]{ {1,2,3} {4,5,2}}

Arrays.sort(arr,  (a, b) -> (a[2] - b[2]) ) ;   //Comparator를 functional로 바로 넣음..

3. Arrays.binSearch (arr, target)

  -> 찾으면 idx리턴, 못 찾으면 들어갈 자리  -idx-1 리턴..  :항상 음수를 리턴하기 위해..

====stream 통계=====

min/max/avg 등을 한꺼번에 구할때..

DoubleSummaryStatistics stat =  arr.stream().mapToDouble(x -> x).summaryStatistics();

stat = {counnt:10.0, sum:120.0, min:1.0, aveerage:10.11, max:19.0}

 REF1(KOR)     REF2(ENG)

AoT (Ahead of Time)컴파일러 도입.  안드로이드에선 이미  ART라는 이름으로 사용되고 있었으나 JDK에선 처음도입

  - application의 startup time 감소.

알파베틱 String을 1byte로 처리해서 메모리효율 + GC문제 감소

Modularity (Jigsaw프로젝트)

  - 키워드 module 을 package처럼 사용.. package 보단 밑.

  - 참고: 이 기능 때문에 기존코드 migration을 위해, java9에서만 한시적으로 illegal reflective access를 제공.

JShell (REPL : Real-Eval-Print-Loop) 제공.. shell에서 바로 문법테스트 등 가능

immutable Map/List/Set용 .of 함수 제공  (Guava좀 들 쓰겠군요)

Flow class (for Reactive) 제공 + CompletableFuture에 delayedExecute추가  (RxJava좀 들 쓰겠군요)

Stream API에  4개 API 추가

  -  takeWhile

  -  dropWhile

CodeCache 향상 - code cache가 segment단위로 되도록 함

JavaScript 서포트 향상 - Project Nashorn의 ECMAScript parser API추가

Optional::stream 추가.  

ProcessHandle class추가

Try with Resource 향상

----기타----  

Applet 제거

Http2 Client

Html5 Unicode지원 향상

Java platform Logging API & Service ?

Javadoc search? 

REF

java8에 여러가지 시간관련 클래스들이 추가되었다. - 매우 유용하다. 주로 이것만 쓰면되고

거기에 더해 기존 Date (millisec표시)정도만 쓰면 되지 않을까 싶다.

LocalDate, LocalTime, LocalDateTime

    - truncateTo함수 제공

Period, Duration  날짜/time간 차이계산..   .plus, .minus, .between

    -Duration.between( LocalDateTime1, LocalDateTim2)도 됨.  
          ===> function prototype은  between(Temporal, Temporal)이라서 공부가 좀 필요.  

ZonedDateTime, OffsetDateTime, OffsetTIme 등이 존사용시 유용.

REF:Mkong.com

[Stream:  one Group ]

.stream().collet(  Collectors.groupingBy(Function.identity(),  Collectors.count() ),

Grouping

 Map<BigDecimal, List<Item>> groupByPriceMap = 			items.stream().collect(Collectors.groupingBy(Item::getPrice)); 

 Map<BigDecimal, Set<String>> result =                 items.stream().collect(                         Collectors.groupingBy(Item::getPrice,                                 Collectors.mapping(Item::getName, Collectors.toSet())                         )                 );

Map<String, Choice> result =     choices.stream().collect(Collectors.toMap(Choice::getName,                                               Function.identity()));

[2 field Grouping]

Map<String, Map<String, Long>> multipleFieldsMap = employeesList.stream()
				.collect(
					Collectors.groupingBy(Employee::getDesignation, 
                                   Collectors.groupingBy(Employee::getGender, Collectors.counting())
                 ));

===========================O======================

.orElse(blabla)  empty일때 값지정.

.map( function)  존재할때 함수실행.

-boolean isPresent()

내부객체가 null이 아닌지 확인한다. null이면 false를 반환한다.

-void ifPresent(Consumer<T>)

Consumer<T>는 함수형 인터페이스 포스팅에서 봤듯 void 추상메서드를 갖고있다. null이 아닐때만 실행된다.

-Optional<T> filter(Predicate<T>)

스트림은 여러 데이터를 들고있는 객체다보니 filter로 걸러지는 데이터들이 반환됐지만, Optional은 내부객체가 단일객체인만큼 해당 조건을 만족하는지만 확인하는 정도로 사용할 수 있을 것 같다.

-Optional<U> map(Function<T, U>)

스트림과 같다. 내부 객체를 변환하는 용도로 사용한다.

-T get()

내부 객체를 반환한다. 다만 내부 객체가 null이면 NPE가 발생한다. null이 아니라는 확실한 경우에만 사용을 권장한다.

-T orElse(T)

내부 객체를 반환한다. 내부 객체가 null이면 인자로 들어간 기본값을 반환한다.

-T orElseGet(Supplier<T>)

orElse()와 동일한데 orElse()가 기본값 레퍼런스를 인자로 받는다면 orElseGet()은 내부 객체가 null일때 기본값을 반환할 객체를 인자로 받는다.

-T orElseThrow(Supplier<U>)

출처: http://multifrontgarden.tistory.com/131 [우리집앞마당]

java 8 경험자 Tip:   REF-SITE ,  http://okky.kr/article/357825  

1. Object리턴시에  null처리가 쉽도록, Optional.ofNullable() 사용.

   예제)  

           Optional<Soundcard> soundcard = Optional.ofNullable(mabyeSoundcard); 
           if(soundcard .isPresent())

   System.out.println (soundcard.get()); //get Real Value from Optional

또는

soundcard.ifPresent(System.out::println); 도 OK.

soundcard.ifPresent(card -> map.put(card)); 도 가능.

      Soundcard soundcard = mabyeSoundcard.orElse(new Soundcard("defaut"));

- orElseThrow(IllegalStateException::new); 도 가능

Optional.map(s->s.getID()).orElse()도 굿.  orElseGet( blabla) 도 있음. 

Optional.flatMap : content가 또 Optional일경우 벗김-  REF2번참조

2.  mutable인 String[]리턴 대신에, immutable인 Stream<String> 리턴.  REF-SITE

  Stream<String> words = Stream.of("Java", "Magazine", "is", "the", "best");
   or
  Stream<String> words = Arrays.stream(arrOfStr); //String[] arrOfStr = {"A","BB"}
 

   예제) "hey duke".chars().forEach (c -> System.out.println((char)c));

           Stream<Character> sch = "abc".chars().mapToObj(i -> (char)i);     (char)가 Character로 autobox됨.

3. Function Reference & Predicate Reference. (함수의 파라미터로도 넘길 수 있게 됨)

   Predicate의 경우 scala와 거의 유사한 방식으로. boolean리턴하는 method define후, 이 것들을 넘길 수 있음. 

  Function<String, Integer> f = Integer::parseInt;
  Integer result = f.apply("123");

  Predicate<String> p = str::equals;
  p.test("world");

 Supplier< > s = 

 s. get(); 

 4. interface  : 기존 interface를 좀 다르게 FunctionalInterface로 사용가능. @FunctionalInterface 도 존재.

   => 이걸 파라미터로 넘길수도 있다.  (function도 넘길 수 있듯이)  : 음 class도 넘길수 있으니 당연한 건가..

    FunctionalInterface REF -> abstract Method는 한개만 존재

    javaInAction8책에서는 Validator Strategy및 8.2장 참조.

SOLID라고 부르며: 굿 REF

경험적으론 이미 다 아는 내용이긴 하지만, 

다음과 같이 객체지향 5원칙을 정리한 사람들이 있다.. 글로 보니 새롭군요..

REF: 

S- single responsibility principle

O- open-closed principle  :

L- Liskov Substitution principle 

  - 어떤 함수 m(p)에서 P클래스의 p instance가 잘 동작하면,  그를 상속받은 C클래스의 c instance도 잘 동작해야 한다 m(c)
 (일반적으로 잘 동작함.   하위 클래스에 부모에게 있는 method가 없거나 다른일을 하거나 하면 문제..)

I- interface segregation principle 

 - I/F는 가능한한 기능별로 세분화해서 구현해야 한다.

D- dependency Inversion principe

  - 하위레벨 모듈의 변경이 상위레벨 모듈의 변경을 요구하던 관계를 끊음.

 - 상위 클래스에서는 하위클래스 일들을 전혀 할 필요가 없다.

java FP Ref_Site

 ::  (Double colon) : reduce에서 standard에 맞으면 사용할 수 있는 연산자.

      reduce( (int left, int right) -> Math.max(left, right) )  

     --> reduce(Math::max);   

List의 각 항목을 제곱해서 출력하기:

LinkedList<Integer> list = new LinkedList<Integer>();

list.add(0); list.add(10);list.add(2);

list.stream()

.map( i -> i*i )

.forEach(System.out::println);  //= forEach(i -> System.out.println(i));

Sum구하기:

int sum = list.stream()

   .reduce(0, (x,y) -> x+y );   //identity(sum variable), Operation

각항목을 제곱한 LinkedList 만들기

   LinkedList<Integer> list2 = 

list.stream()

.map( i -> i*i )

.collect(Collectors.toCollection(LinkedList::new));  //.collect(Collectors.toList());

java 5와 java8은 major release이다.

java 5에서  generic, concurrent, annotation, JMX, enum, boxing/unboxing, static import  등의 기능이  update되었다면

java8에서의 핵심update는 FP 이다. 참고사이트

1. <java.uitl.function 에 추가된 함수형 인터페이스>

• Function <T, R> - T를 입력으로 R을 출력으로 반환
• Predicate <T> - T를 입력으로 boolean을 출력으로 반환
• Consumer <T> - T를 입력으로 아무것도 반환하지 않는다
• Supplier <T> - 입력을 취하지 않고 T를 반환
• BinaryOperator <T> - 2 개의 T를 입력으로 하나의 T를 출력으로 반환 
  => c++의 unary operator override수준이 아니라서 별로 쓸일 없어 보이지만..
  minBy, maxBy는 사용하면 stream구문 없이 사용할 수 있어서 편할 듯 함.
  REF

2. <java.util.stream>

 - 배열,리스트,맵 등 Collection을 stream으로 다룰 수 있게 된다.

그리고

 -interface에 abstract method뿐 아니라 body추가.

 -OOM을 많이 유발하단 PermGen 이 사라짐. 

 - Date변환법이 좀 추가:   LocalDateTime 과 Duration이 쓰기 좋겠네요.  REF-SITE