문자열이 정해진 날짜 포맷에 맞는지 확인해야하는 로직이 종종 필요하다

문자열이 날짜 형식인지 유효성 검사하기

    /**
     * 입력받은 문자열이 날짜형식으로 변환이 가능한지 확인한다.
     *
     * @param str2cmp    날짜형식 변환 가능여부 확인 대상
     * @param dateFormat 비교할 날짜 형식
     * @return
     */
    public static boolean isDateFormat(String str2cmp, String dateFormat) {
        try {
            //  검증할 날짜 포맷 설정
            SimpleDateFormat dateFormatParser = new SimpleDateFormat(dateFormat);
            //  parse()에 잘못된 값이 들어오면 Exception을 리턴하도록 setLenient(false) 설정
            dateFormatParser.setLenient(false);
            // 대상 인자 검증
            dateFormatParser.parse(str2cmp);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    public static boolean isDateFormat(String str2cmp) {
        return isDateFormat(str2cmp, "yyyyMMdd");
    }

setLenient( false );로 설정하면, 잘못된 형식의 데이터가 들어올 경우 Exception을 리턴하도록 설정함.

성능을 고려한 try-catch 문

try-catch 문을 사용하면 예외 처리는 쉽지만, 에러객체.printStackTrace() 로 출력한 stack 이 시스템의 성능을 저하시킬 수 있다.
따라서 에러객체에서 다음과 같이 필요한 정보만 뽑아서 출력하는게 시스템 성능에 좋다.
어떻게 보면 긴 에러 출력보다는 아래와 같이 필요한 부분만 뽑아 보는게 디버깅에 효율 적 인것 같기도 하고...

        try {
            // 예외가 발생할 수 있는 로직
        } catch (Exception e) {
            StackTraceElement[] ste = e.getStackTrace();
            String className  = ste[0].getClassName();
            String methodName = ste[0].getMethodName();
            int lineNumber = ste[0].getLineNumber();
            String fileName = ste[0].getFileName();
            logger.error(">>> ERROR ON {} <<<", fileName);
            logger.error("{} >> {}() : {}", className, methodName, lineNumber);
            logger.error("MSG : {}", e.getMessage());
            logger.error("CUZ : {}", e.getCause());
        }

Java 에서 Map 안의 요소 반복문으로 꺼내기.

package dev.jeaha.practice;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class MapIterationPractice {

  public static void main(String[] args) {
    Map<String, String> map = new HashMap<>();

    map.put("k00", "v00");
    map.put("k01", "v01");
    map.put("k02", "v02");
    map.put("k03", "v03");
    map.put("k04", "v04");
    map.put("k05", "v05");
    map.put("k06", "v06");
    map.put("k07", "v07");
    map.put("k08", "v08");
    map.put("k09", "v09");
    map.put("k10", "v10");

    System.out.println(">>>> SOLUTION 01-1 <<<<");
    /**
     * Generic 미사용.
     * Java 버젼이 낮을 경우 사용할 수 있는 방법.
     */
    Iterator entries = map.entrySet().iterator();
    while( entries.hasNext() ) {
      Map.Entry entry = (Map.Entry) entries.next();
      String key = (String) entry.getKey();
      String val = (String) entry.getValue();
      System.out.println( String.format("key : %s, value : %s", key, val ) );
    }


    System.out.println("\n\n>>>> SOLUTION 01-2 <<<<");
    /**
     * Generic, Entry 사용
     */
    Iterator<Map.Entry<String, String>> entriex = map.entrySet().iterator();
    while( entriex.hasNext() ) {
      Map.Entry<String, String> entry = entriex.next();
      System.out.println( String.format("key : %s, value : %s", entry.getKey(), entry.getValue() ) );
    }

    System.out.println("\n\n>>>> SOLUTION 01-3 <<<<");
    /**
     * Generic 사용, Entry 미사용
     */
    Iterator<String> keys = map.keySet().iterator();
    while( keys.hasNext() ) {
      String key = keys.next();
      System.out.println( String.format("key : %s, value : %s", key, map.get(key)) );
    }

    System.out.println("\n\n>>>> SOLUTION 02 <<<<");
    /**
     * Entry에 for-each loop 사용.
     * 가장 일반적이고 많은 경우에 사용됨.
     * 반복문 안에서 key 값과 value 값이 전부 필요할 때 사용.
     * Java 1.5 이상부터 사용 가능. NullPointerException 발생 가능.
     */
    for( Map.Entry<String, String> entry : map.entrySet() ) {
      System.out.println( String.format("key : %s, value : %s", entry.getKey(), entry.getValue() ) );
    }

    System.out.println("\n\n>>>> SOLUTION 03 <<<<");
    /**
     * entry 대신에 key 값이나 value 값만 필요할 때 사용.
     * entrySet을 사용할 때보다 약 10% 빠르다고 함.
     */
    for( String key : map.keySet() ) {
      System.out.println( String.format("key : %s", key ) );
    }
    for( String value : map.values() ) {
      System.out.println( String.format("value : %s", value ) );
    }

    System.out.println("\n\n>>>> SOLUTION 04 <<<<");
    /**
     * 코드상으로는 깔끔해 보이지만 비효율 적이고 성능면에서 좋지 않은 방법.
     * key 값을 이용해서 value 를 찾는 과정에서 시간 소모가 많음.
     * SOLUTION 02에 비해 20~200% 성능 저하 유발.
     */
    for( String key : map.keySet() ) {
      System.out.println( String.format("key : %s, value : %s", key, map.get(key) ) );
    }

    System.out.println("\n\n>>>> SOLUTION 05 <<<<");
    /**
     * stream을 사용한 forEach.
     */
    map.entrySet()
    .stream()
    .forEach(System.out::println);

    System.out.println("\n\n>>>> SOLUTION 06 <<<<");
    /**
     * forEach 및 Lambda를 사용한 반복.
     * forEach() 내에서 람다 표현식 사용.
     */
    map.forEach( (key, val) -> {
      System.out.println( String.format("key : %s, value : %s", key, val ) );
    });
  }
}

종종 특수한 이유로 Java 구 버젼을 설치해야 할 일이 있음.

오라클 공식 사이트에서는 1.7이하 버젼은 더 이상 다운로드를 지원하지 않지만.
잘 찾아보면 각 버젼별로 다운 받을 수 있음.

한참 헤매다 따로 링크를 저장해 두기로 하고 포스트를 작성함.

JDK 1.5
JDK 1.6
JDK 1.7
JDK 1.8

Java ArrayList Sort

개요

한동안 JS 만 만지다 Java ArrayList를 sort 해야 하는 일이 생김.
DB 에서 이미 ORDER BY 해서 꺼내온 두 개의 List를 merge 한 List 였는데,
요소들은 항적 데이터 { 선박 ID(ship_id), 위치정보(geom), 항적 시간(date(초)) } 로 이루어 져 있고, 시간으로 정렬 해야 했음.

  public class Record {
    String  tbship_id;
    String  geom;
    int     sec;
  }

하도 JS 만 만졌더니 간단한 로직인데 1시간 정도 삽질 했고 블로그에 남기기로 함.

방법 1

Record 객체를 Comparable 상속 받게 한 뒤, compareTo 메소드를 오버라이드, 필요한 곳에서 정렬 메소드를 호출.
compareTo 메소드는 int를 반환해야 하며 오름차순 정렬일 경우, 다음을 반환해야 함.

• 기준점이 비교대상보다 크다면 양수.
• 기준점이 비교대상과 같다면 0.
• 기준점이 비교대상보다 작다면 음수.

Record.java

  public class Record implements Comparable<Record> {
    String  tbship_id;
    String  geom;
    int     sec;

    /* ... */

    @Override
    public int compareTo(Record o) {
      if( this.cal < o.cal ) return -1;
      else if (this.cal == o.cal ) return 0;
      else return 1;
    }
  }

TrackDAOImpl.java

  /* ... */
  Collections.sort(mergedList);

방법 2

정렬이 필요한 곳에서 Comparator 객체를 생성한 뒤, compare 메소드를 오버라이드 후, 정렬 메소드를 호출.
compare 메소드는 int를 반환하며, 앞의 방법과 같이 기준점 대비 비교점으로 짜야함.

• 기준점이 비교대상보다 크다면 양수.
• 기준점이 비교대상과 같다면 0.
• 기준점이 비교대상보다 작다면 음수.

  Comparator<Record> compare = new Comparator<Record>() {

  @Override
  public int compare(Record prev, Record curr) {
    if( prev.getCal() < curr.getCal() ) return -1;
    else if (prev.getCal() == curr.getCal() ) return 0;
    else return 1;
    }
  };

  Collections.sort(mergedList, compare);

방법 3

Collection.sort() 메소드의 두번째 인자로 익명 객체를 넣어 줌..
방법 1, 2를 보면 쉽게 이해할 수 있음.

  Collections.sort(mergedList, (Comparator<Record>) (Record prv, Record cur) -> {
    if( prv.getCal() < cur.getCal() ) return -1;
    else if (prv.getCal() == cur.getCal() ) return 0;
    else return 1;
  });

그 외

개인적으로는 세번째 방법이 낫겠다 싶은데 이유는 객체의 compareTo 메소드에 다른 필드 값 대한 비교가 필요할 경우가 있기 때문.
메소드를 구현 할때, 다른 비교 구분이 필요할 경우가 있기 때문.