'All Category'에 해당되는 글 502건

  1. 2016.12.02 Orika - the mapper
  2. 2016.12.02 Lombok
  3. 2016.12.01 Macbook 처음사용시
  4. 2016.11.23 Stream (java8) + Collectors
  5. 2016.11.15 Armeria
  6. 2016.10.23 F,P,S & FunctionalInterface 1
  7. 2016.10.12 mySql Tip
  8. 2016.10.11 구글 SLAM 공개
  9. 2016.10.07 auto login + data Add
  10. 2016.09.27 한국과 일본 LTE
  11. 2016.09.26 netty
  12. 2016.09.22 netty활용 사례(netflix zuul)
  13. 2016.09.12 Git advanced.
  14. 2016.09.12 spring 동작구조 및 web Tip
  15. 2016.08.28 AsyncFileChannel
  16. 2016.08.16 Message Digest
  17. 2016.08.15 HTTP 2.0
  18. 2016.08.10 유니코드
  19. 2016.08.06 객체지향 5원칙(SOLID)
  20. 2016.08.01 OSI 7 Layer
  21. 2016.07.21 (self-balanced) Tree
  22. 2016.07.20 enum
  23. 2016.07.19 java 1.8, FP functional programming
  24. 2016.07.17 sort 비교, & Heap / Trie
  25. 2016.06.30 Tree traverse (+Graph Search)
  26. 2016.06.30 Combination & Combination with repetition
  27. 2016.06.29 spring에서 bean은
  28. 2016.06.13 binary Search (ft. Arrays.binarySearch) 4
  29. 2016.06.11 Long변수와 float변수 초기화
  30. 2016.06.06 jvm & GC 3

Orika - the mapper

java core 2016. 12. 2. 15:54

http://orika-mapper.github.io/orika-docs/



1. mapperFactory.classMap(Aclass, Bclass)

         .byDefault()  - 이름이 같은애들 자동 매핑

         .register()  - MapperFactory()에 등록.


        - 그 외 exclude()나 1Direction으로 map하는 방법도 존재.

        - 한쪽이 array라도 매핑가능. (index or first, last 이용) 

        - 한쪽이 classB의 List<A> 라도 가능  Bfield{ fieldOfA }

        - 한쪽이 Map<blabla,blabla2>라도 가능.  field{key}, field{value}

        - null 매핑 on/off도 가능.

        

- in line property:   user:{getName('user')|setBlaBla .. }  지원.

- 프로그래매틱하게 할 수 있도록, Property.Builder 지원.

- 상당히 복잡한 경우를 위해  (Introspector)PropertyResolver  존재.



2. mapperFactory.getMapperFacade()

    B = bMapper.map (A)


3. BoundMapperFacade< A, B>  bMapper = mapperFactory.getMapperFacade ( A,B)  :  성능이 좋음. 

   B = bMapper.map (A)






Posted by yongary
,

Lombok

java core 2016. 12. 2. 15:53

https://projectlombok.org/


@Data  만 추가하면  Creator/Getter/Setter/toString/hashCode 메쏘드들이 다 있는 것으로 간주됨. (핵심)


그 외

@Getter, @Setter, @Cleanup (Finally로 제거해 주는 효과)




<Constructor 3가지 옵션 > REF


@AllArgsConstructor

@RequiredArgsConstructor - parameter있는 생성자 만들어 주는데, 해당 필드에 @NonNull 추가 필요.

@NoArgsConstructor




상속시에는 부모클래스의 Field들도, equals & hashCode()함수에 포함하기 위해서 아래가 필요.

  => 단, 부모클래스도 자식클래스도 @Data를 사용해야 한다. 

@EqualsAndHashCode(callSuper=true)


Posted by yongary
,

Macbook 처음사용시

Mac 2016. 12. 1. 21:31

<스크롤>

터치패드와 매직마우스의 스크롤을 "자연스럽게"를 끄면 window와 동일하게 동작한다.

스크롤은 손가락 2개로 할 수 있다.


<우측클릭>

터치패드에서 손가락 두개로 누르면 된다.. 마우스는 오른쪽 귀퉁이 누르게 설정가능.


<런치패드 : f4 >

 손가락 4개를 펼치면 실행. 끌때는 반대로.


<독 : Dock> 세로선을 잡아서 끌면 크기를 줄일 수 있다



<미션컨트롤 : f3> 손가락 3개를 쓸어올린다. 끌때는 반대로


<터미널>   spotligit( 옵션+스페이스) 에서 terminal입력. 

                 


<단축키>

  • +Q: 창 닫기(quit)
  • +,: (현재 프로그램에 대한) 설정
  •  Ctrl+Space: 한영전환
  • + Shift+4: 영역 스크린샷
  • + Shift+4Space: 창 스크린샷
  • command++: 화면 확대
  • command+-: 화면 축소
  • Ctrl+Option+Space: 검색 창 열기
  • command+Space: Spotlight 검색창


<Library 폴더가 안보일때>

Finder->Go menu->Home   select  --->    View menu -> Show View Option 에서 Library 선택. 


Posted by yongary
,

[java8 in action  일부 참고]

 

한마디로, Collection은 data라고 한다면 Stream은 computation이다.

 

 

<특징 2가지>

1. PipeLining

  Stream 은 unix명령어인 pipeline( "|" ) 과 같이 순차적으로 data를 처리한다. 

  (단, 실제로 unix에선 pipeline을 순차적으로 처리하지 않고, 몇줄이라도 조금씩 output이 있으면 동시처리를 한다)

 

2. Internal iteration 

  - 코드상 눈에 보이지는 않지만, 내부적으로 iteration이 일어난다.

  - 단 한번 traverse가 가능하다.  이게 끝나면 다시 new stream을 가져와야 한다.

 

 

<operation 종류> - Builder패턴과 유사하게 chain을 통해 중간단계를 여러개 거쳐 최종물 생성.

 

1. Intermediate Operation : Terminal Operation을 만나야만 동작을 한다. 

 - map, filter 등과 같이 중간에 데이타를 가공한다.

 - sorted, distinct  

 - limit, skip

 - 한꺼번에 처리가 되는만큼, 내부 동작 순서는 최적화해서 바뀐다. 

  (예: limit먼저 실행하고 다른 것 들 실행. map과 filter를 merge해서 실행)

  

 

2. Terminal Operation : 반드시 이걸로 끝나야 한다. 그래야만 intermediate Operation도 동작을 한다.

 - collect   (주로 List, Map, an Integer 리턴)

   

   ㅁ Map으로 변경

someList.stream() .collect(Collectors.toMap(AClassName::getMyCode, AClassName::getName))

   ㅁ GroupingBy

someList.stream().

.collect(Collectors.groupingBy(  AClassName::getName  ) )

 

=> Map<String, List<Person>> 형태로 리턴됨.

 

   

   ㅁ guava와 함께 쓰면:   .collect(GuavaCollectors.toImmutableList());

jp.skypencil.guava:helper:1.0.1
<dependency>
  <groupId>jp.skypencil.guava</groupId>
  <artifactId>helper</artifactId>
  <version>1.0.1</version>
</dependency>

 - forEach  (void 리턴)

 - count   ( long 숫자 return)

 

 

 

ofNullable함께 사용: REF

map으로 예제: REF

Function protoype 이용예제: REF

 

 

 

<철학>

java8에서는 stream을 이용해 multicore 개발의 복잡함과,  multihread로 인한 오류확률을 줄이고자 한다. 

          

 -> stream은 multicore에서도 parallel한 환경에서 transparent하게 작업이 가능하다. 

 일반적으로, .stream()에서 .parallelStream()으로만 바꾸면, 별도의 multithread코드 없이 parallel작업이 된다.

 

 

 

 

<forEach 예제>

 

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

  someStream.forEach (  (oneItem) -> {

oneItem.weight -= 1; 

oneItem.height += 10;

  }

 

단, 단순한  forEach는 Collector 에도 있으므로,  list.forEach( item -> blabla ); 가 가능함.

 

Posted by yongary
,

Armeria

network개발 2016. 11. 15. 14:58

<주로 사용하는 기능들>

HttpResponse.aggregate() : CompletableFuture로 전환.

예) httpClient.get(uri.getPath()).aggregate()


Decorator: req나 response를 살짝바꾸는 역할. SoC(Seperation of Concern)가 가능.

- req,res가 같을 때는 SimpleDecoratorService를 상속 - req나 res의 type의 바뀔때는 DecoratorService를 상속 - 간단한 decorate()용 lambda도 있음.

<유용한 class - armeria thrift용 개발시에도 사용가능>

com.linecorp.armeria.common.metric.MetricLabel
      - Collector같은 애들에게, 이름을 붙여서, lambda에서 사용시 지정할 수 있다.


common.util.Functions.voidFunction (Consumer or BiConsumer)   : Consumer를 Function으로 변환. 

                                    .compose (Func12, Func23) -> Func(1,3)으로 변환.   그 외에도 각종 compose들 존재. 


common.HttpHeaders;

common.RequestContext;

server.logging.LoggingService;


<기존 netty꺼긴 하지만..유용class>

io.netty.util.AsciiString;


<Connector>

armeria's TomcatService always create a Request/Response instance.
<-> Tomcat's Http11Processor create them only once and this processor instance will be recycled.




REF-github


- 기존의 netty와는 달리 Http2.0을 지원한다.   HTTP2.0-REF
    (기존의 HTTP1 서비스와 호환성도 유지)

- JNI-based socket I/O 

BoringSSL-based TLS connections

- (Apache) Thrift  호환
   THttpClient와 호환. (Thrift-Over-Http)   

    참고:  Thrift - Binary communication을 위한 IDL로서 RPC사용을 위해 facebook에서 개발.

- Java EE Web Application이랑 호환.  (same TCP/IP port)



Posted by yongary
,

F,P,S & FunctionalInterface

java8~ 2016. 10. 23. 11:20

  

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장 참조.




Posted by yongary
,

mySql Tip

BACK-END 2016. 10. 12. 17:00

참고: mySql에서 

  - Key키워드도 index를 의미한다.  

     (왜 key라고 부르면서 index와 동일한 건지? 이유가 있을텐데.. 아직은 모르겠음)


 

mySQL을 쓰면서 하면안되는 일들 17가지 blog : REF

 

요약하면

- 파티션/복제/Caching계획을 세우기

- Explain포함 Profile링과 벤치마크 쓰기

- 인덱스 layout과 쿼리 cach 이해하기

- Stored procedure보다는 Prepared구문&Dynamic SQL사용

  (MySQL은 한번 연결해서 여러번 사용해야 효율 적)

- AUTO_INCREMENT 꼭 사용

- ON DUPLICATE KEY UPDATE 꼭 사용

 

정도이다.

 

시간을 가지고 개인적인 의견 하나씩 추가 계획.

 

 

Posted by yongary
,

구글 SLAM 공개

IT 2016. 10. 11. 13:39

구굴이 SLAM(Simultaneous Localization and Mapping)용

오픈소스 지도기술 Cartographer를 공개하였다.



SLAM: 로봇이 위치를 인식해서 즉석해서 지도를 작성.

- 무인자동차, 로봇청소기, 드론등에서 활용



이제 일반인도 드론이나 로봇청소기 제작시 본 API를 활용해

야외나 실내의 맵을 실시간으로 만들어 

로봇의 탐색경로를 쉽게 최적화할 수 있을 것으로 보인다.



참고사이트: http://www.bloter.net/archives/265140

시연영상: https://youtu.be/DM0dpHLhtX0 

Cartographer GitHub: https://github.com/googlecartographer 

                  소개: https://opensource.googleblog.com/2016/10/introducing-cartographer.html 





Posted by yongary
,

auto login + data Add

java core 2016. 10. 7. 17:55

java로 web페이지에 login을 해서 session을 유지하면서

data를 form방식으로 입력하는 예제입니다. 


(login페이지는 ajax/json리턴 방식이고, data add 페이지는 일반적인 form방식을 가정)

login세션 유지는 cookie에서 JESSIONID를 읽어서 다시 세팅해야 합니다.



data는 file에서 하나씩 읽어서 web상으로 입력하는 형태입니다.


=========java source=====================

import java.io.BufferedReader;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.net.HttpURLConnection;

import java.net.URL;

import java.util.List;

import java.util.Map;

import java.util.Scanner;



public class LoginAndInsert {


public static void main(String[] args) throws Exception{

//LOG IN

URL url = new URL("http://221.100.200.180/loginProc");

HttpURLConnection conn = (HttpURLConnection)url.openConnection();

conn.setUseCaches( false );

conn.setConnectTimeout(1000);

conn.setRequestProperty("Accept", "*/*");

conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");

conn.setRequestMethod("POST");


//data setting

String postData = "user_id=admin" + "&user_pwd=" + "a123456789";

System.out.println(postData.toString());

conn.setRequestProperty("Content-Length", String.valueOf(postData.getBytes("UTF-8").length));

conn.setRequestProperty("X-Requested-With", "XMLHttpRequest");

conn.setDoOutput(true); //POST

conn.connect();

OutputStream outputStream = conn.getOutputStream();

outputStream.write(postData.getBytes("UTF-8"));

outputStream.close();

InputStream inputStream = null;

try { 

inputStream = conn.getInputStream();

}catch (IOException ioe){

ioe.printStackTrace();

}


String m_cookies = "";

String line3;

      BufferedReader reader = new BufferedReader(new 

                                    InputStreamReader( inputStream  ));

      while ((line3 = reader.readLine()) != null) {

         System.out.println(line3);

      }

   

      //save Cookie


      Map<String, List<String>> imap = conn.getHeaderFields( ) ;

      System.out.println(imap.size());

   

   

 if( imap.containsKey( "Set-Cookie" ) ) //"Set-Cookie"

 {

    List<String> lString = imap.get( "Set-Cookie"); //"Set-Cookie" );

    for( int i = 0 ; i < lString.size() ; i++ ) 

    m_cookies += lString.get( i ) ;

 }

   

       System.err.println("Cookie:"+ m_cookies);

   

 //find JSESSIONID

 String[] cookieTokens = m_cookies.split(";");

 String JSESSIONID = cookieTokens[1].substring( cookieTokens[1].indexOf("D=")+2 );

   

 System.err.println("JSESSIONID:"+ JSESSIONID);

   

 reader.close();

 Thread.sleep(500);


//Data process

Scanner in = new Scanner(new File("./dataFile.txt"));

int i=0;

while ( in.hasNextLine() ){

String line = in.nextLine();

//System.out.println(line);


String[] token = line.split(",");

String id = token[0];

String phone = token[1];

String name = token[2];

String pw = "tel" + phone.substring(3);

if (id.length() < 4) System.err.println(id);

if (pw.length() < 10) System.err.println(pw);


//INSERT by POST

url = new URL("http://221.148.199.79/admin/normalUserMng/registProc");

conn = (HttpURLConnection)url.openConnection();

conn.setUseCaches( false );

conn.setConnectTimeout(1000);

conn.setRequestProperty("Accept", "*/*");

conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");

conn.setRequestMethod("POST");

conn.setRequestProperty( "Cookie", "JSESSIONID="+JSESSIONID );

conn.setInstanceFollowRedirects(false); //For cookie


//data Setting

postData = "act=R" 

+ "&user_id=" + id

+ "&user_pwd=" + pw

+ "&user_name=" + name

+ "&user_phone=" + phone

+ "&is_active=1"

+ "&user_domain=ktait.com";

conn.setRequestProperty("Content-Length", String.valueOf(postData.getBytes("UTF-8").length));

System.out.println(i++ + "====== "+name + "," + id + "," + phone + "," + pw +",     "+ postData);

conn.setDoOutput(true); //POST

//conn.setDoInput(true); //POST

conn.connect();

outputStream = conn.getOutputStream();

outputStream.write(postData.getBytes("UTF-8"));

outputStream.close();


String line2;

reader = new BufferedReader(new 

                                    InputStreamReader(conn.getInputStream()));

while ((line2 = reader.readLine()) != null) {

     System.out.print(line2);

}

reader.close();

System.out.println("");

Thread.sleep(100);

}

  }

}



Posted by yongary
,

한국과 일본 LTE

통신 2016. 9. 27. 14:02

한국과 일본의 LTE 주파수가 겹치는 부분도 있고, 다른 부분도 있지만

대체적으로 겹치는 부분이 존재하기 때문에,

 

한국폰을 들고 일본에 가서 가입해서 사용할 수 있다.

(보통 APN을 설정해야 한다.

  - APN: AP의 명칭으로 data망을 잡을 때 사용하는 중계기이름) : 설정경험site

 

 

<주파수 설정>

주파수가 다르지만 자동으로 되는폰과 안되는 폰이 있는데, 자동으로 LTE가 안잡히는 폰은 설정을 할 수 있다.

 

KT스마트폰 삼성폰인 경우  자동으로 안되면

통화 dialer에서 319712358 입력하고 비번에서 774632 입력하면 된다.

 

=> 그 후, Network Setting -> Network Mode에가서

일본 LTE주파수 참고해서 고르면 된다.  도코모의 경우 B1으로 선택하면 된다. 아니면 자동으로

 

    LG폰:  5457#* + 모델명3자리 + #      (5457대신 3845인 폰도 존재)

    펜텍폰:  ##7788#

 

<일본 MVNO>

 

B모바일 = 도코모의 mvno  :  개통경험사이트

=> B모바일은 15년 2월 기준으로 속도가 느림: site

빅심(IIJmio) = 도코모의 mvno  : 좀 믿을만 하겠죠.

 

라인mobile = 도코모mvno : 라인free와 커뮤니케이션free(facebook포함) 요금제 존재. : site

               -> 라인mobile 정식오픈은 16년 10월 1일.  메신저 많이 쓰는 사람 이게 유리할 듯하네요
               요금제 + (월)700엔 내야지 전화번호까지 줌. 

 

 

<참고 사이트>

일본 LTE주파수 - 참고사이트

 

한국LTE 주파수-  참고사이트

 

일본 MVNO 비교 - 참고 사이트

 

SKT폰도 비번만 다르고 동일함 - 참고사이트

 

 

Posted by yongary
,

netty

network개발 2016. 9. 26. 13:49

netty =  Async전문 java network Library

   - UserGuide(4.0 wiki)  ,  한글번역본

 

   - 3.1 Chapter2 Architecture Overview

 

   - 4.0javadoc   5.0alpha2_javadoc

 

 

netty의 핵심 Interface

 - Channel

 - ChannelFuture

 - ChannelHandler

 - ChannelHandlerContext

 - ChannelPipeline

 - EventLoop

 

 [그 외]

 - ChannelBuffer

 기존 java nio의  ByteBuffer를 쓰지 않고, ChannleBuffer를 이용해
1. flip()호출이 필요없으며 사용자정의 buffer type이 가능하다.

2. zero-copy가 가능하다.(SG-DMA NIC필요) :  zeroCopyRef

zero-copy: disk->커널메모리->유저메모리->커널메모리->NIC  이던것을

               => disk->커널메모리->NIC 방식으로 copy. (File을 socket으로 쏠때 특히 유리)

3. StringBuffer처럼 dynamic Buffer이다.

 - ChannelFactory

NIO-TCP / OIO-TCP / OIO-UDP /Local 통신등을 ChannelFactory선택만으로 쉽게 swithcing가능.

 

기본예제: jdm.kr

 

 

Posted by yongary
,

[Netflix 블로그:  곧 open Source로 공개 예정]

http://techblog.netflix.com/2016/09/zuul-2-netflix-journey-to-asynchronous.html?m=1 

 

 

Posted by yongary
,

Git advanced.

springBoot gradle 2016. 9. 12. 15:21

git기본은: http://yongary.tistory.com/151




http://learngitbranching.js.org/   graphical 공부site


  - git의 commit은 매우 가볍다. 이전버전과 차이점 delta만 관리. 

  - local 관리버전을 master라고 부름.. (remote가 origin 인 듯)

  - branch는 단지 commit으로의 pointer이다. (storage/memory overhead없음)

git branch branchName해서 만들고 + git checkout branchName 한 다음에 git commit해야 함. 

: or  git checkout -b branchName 하면 branch를 만들면서 checkOut도 같이 함.

  - git merge 방법:

: git branch bugFix

:    git checkout bugFix

:    수정후 git commit

: git checkout master

:    git commit  (이 단계가 왜 필요한지?? 연구 중)

:    git merge bugFix

   

  - git rebase : 패러랠 branch작업을 sequential한 history로 변환시켜 줌. (대단하네요)

              현재 bugFix* checkout된 상태에서, 

: git rebase master 하면 sequential로 되고 그 후,  (현재 bugFix*가 계속유지됨.)

: git rebase bugFix   (master*가 current로 바뀜. sequential상에서의 merge효과가 생김. ) 

      


           

<기억할 명령어>

git checkout FileName  : 파일 하나 Revert

git checkout -- FileName  :  파일 하나 Revert from -- branch. (need test)  REF



git branch -v :  branch상태 확인가능.. 로컬이 앞서가면(commit 이 많으면 ahead 2 이런식으로 나옴)  : REF

==>  $ git fetch --all; git branch -w   이렇게 사용해야 최신 정보가 비교가 됨.



Posted by yongary
,

<동작구조>


Request --->  DispatcherServlet  ---------------------------> Haldlermapping

                                     ----------------------------> Controller

                                     <--Model & view name--

                                     ---------------------------->ViewResolver

                                     ----------------------------> View

      response <--------------------------------------------



<어노테이션>  annotation-Driven.   @Component로 하고,  component-scan으로 자동으로 Bean으로 등록. 

  @Controller

  @RequestMapping( { "/", "/homepage" } )   =>  controller에서 이 String array를 통해 여러 request 수용가능.

  public class myController {....


 

  -param 처리  /show?my_id=12345 URL처리하려면

   public String show( @RequestParam("my_id") long myId, Model model) {
   }

  - URL방식 param처리

   @RequestMapping(value="/{my_id}", method=RequestMethod.GET)
   public String show( @PathVariable("my_id") long myId, Model model) {

   }





<Spring's MockMVC>

  myRepository mockRepository =

     mock (myRepository.class);

   when (mockRepository.findData())

     .thenReturn(expectedData);


     .setSingleView  .build  .perform  .andExpect 등.   



<Web controller에>

 @Autowired 생성자. 가능.    #146 



  Model: View로 전달할 key,value Map.이며 아래와같이 사용함.

   <c:forEach  items="${modelName}" var="oneData">

<c:out value="${oneData.kv1}" />

   </c:forEach>

   => spring에서 만든 sf (spring form) tag library도 존재.
    sf:input 이런식으로 사용하며 Model과 연동이 잘된다. 

   => srping에서 만든 s tag library도 존재

    s:message   리소스 파일등에서 읽어서 메시지 출력.




<ViewResolver>

  InternalResourceViewResolver를 기본적으로 쓰는데, 그 외 UrlBasedViewResolver, XmlViewResolver, 

  TilesViewResolver (Apache Tiles를 이용해 Web페이지 구성, tiles는 t tagLib 사용.),

  ThymeleafViewRelolsver ( Tyhymeleaf = jsp 사용성 개선한 범용 template-th tag 사용하며 html처럼 막 편집가능
        즉, jsp안에 <> <c:> 이런거 섞어쓰면서 오는 <>개수 혼란 등을 피할 수 있음.)
  
  등 10개 이상의 용도에 따른 ViewResolver가 존재한다.

 

 

<기타 & Advanced>

WebApplicationInitializer

- DispatcherServlet 외에 추가적인 servlet나 filter를 등록해서 사용가능.

- onStartup & getServletFilters 메쏘드 override .   (#7.1)

 

multipart는 보통 StandardServletMultipartResolver 를 사용.

 

 

flash attribute: redirect시 Object전달 같은 일회성 data전달을 model을 이용해 지원.

-사용법: model.addFlashAttribute("spitter", spitter);

 


 Web Flow:  spring MVC확장 framework로 flow를 관리한다.

     - status, transitions, flow_Data 의 3개 요소로 구성됨.



Posted by yongary
,

AsyncFileChannel

java core 2016. 8. 28. 21:24

[오늘의 Tip] Java는 call by value이다. (Object의 경우는 reference주소=Pointer주소 가 전달된다)

c++은 call by reference가 있는데, 이 것은 실제로는 reference of reference가 전달된다.



[본론]


jdk 1.7 에 AsynchronousFileChannel class가 있다.  REF


그냥 java 의  NIO를 사용해도 될텐데.. 차이점이 무언인지 분석을 해보자.



..




Posted by yongary
,

Message Digest

IT 2016. 8. 16. 17:08

Message Digest는 간단히 말하면 Message Hashing이다.

- 단방향으로만 동작하고 역방향 유추는 불가.

- 암호 저장, file이 동일한 파일인지 비교하는데 쓰인다.

 

Java Ref - java.security.MessageDigest 존재.

 

 

좀 더 복잡하게 하기 위해서  Ref

Salting- 메시지 앞에 특수값을 삽입. (사용자별로 다르게 할 수도 있음)

Key Stretching-  Digest하고 그 값을 또 Digest하는 multi-chain형태의 Digest.

=> 위 둘을 잘 섞어서 Adaptive Key Derivation Functions 이라고 부른다.

대표적인 게 PBKDF2랑 bcrypt, scrypt가 있다.

이 존재한다.

 

 

Posted by yongary
,

HTTP 2.0

IT 2016. 8. 15. 16:54

REFwiki

 

HTTP1.1이 현재까진 대세인데

HTTP2.0은 2015년 5월에 spec이 발표되었고, 대부분의 브라우저에서 2015년 말부터 지원한다.

  - web site들은 10%미만이 이를 지원.

 

주요 특징.

 - HTTP2.0 서버 Push

: 기존에는 index.html을 파싱하고 나사 style.css, javascript.js를 받지만, HTTP 2.0에서는 서버가 index.html 을 내려주면서 같이 css와 js도 내려줄 수 있다.

 

 - HTTPS over TLS

:원래 https는 SSL기반인데,   2.0에서는 https가  TLS기반(SSL의 브랜치)으로 동작한다.

 

 (SSL vs TLS: REF1,  )

-같은 말이다. 네스케이프에 의해서 SSL이 발명되었고, 이것이 점차 폭넓게 사용되다가 표준화 기구인 IETF의 관리로 변경되면서 TLS라는 이름으로 바뀌었다. TLS 1.0은 SSL 3.0을 계승한다. 하지만 TLS라는 이름보다 SSL이라는 이름이 훨씬 많이 사용되고 있다.

( REF2-의심감)

 SSL - 7.Application Layer 와 4.Transport Layer 간에서의 보안.

 TLS -  서버인증은 선택사항, 반드시 공개키만 사용.

 

 - SPDY (pronounced like "speedy") : TCP pipe는 쓰면서도 TCP와 다른프로토콜을 사용하는데 HTTP2.0 초기에는 SPDY방식으로 HTTP가 바뀔 것으로 제안 되다가 몇가지 문제가 있어 빠진 것으로 보임.

 

Posted by yongary
,

유니코드

IT 2016. 8. 10. 18:02

<UnicCode> REFWiki  REF2

UTF 8  - 가변길이의 유니코드이다.   ASCII영역은 1Byte로 표현되고, 일반적으론 한글은 3Byte로 표현된다.. 드물게 4byte로 표현되는 언어도 있다.

 

UTF 16 - ASCII영역도 2Byte로 표현된다.

 

 

<다른 encoding>


EUC-KR (MS의 CP949는 EUC-KR을 확장) :  한글OS에서만 제대로 보이는 문제 존재. 영문-1Byte, 한글-2Byte 로 고정Length

Posted by yongary
,

SOLID라고 부르며: 굿 REF

 

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

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

 

REF: 

S- single responsibility principle

O- open-closed principle  :

 - 확장에는 open, 변경에는 close

 

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

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

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

 

 

 

Posted by yongary
,

OSI 7 Layer

IT 2016. 8. 1. 15:47

OSI 7계층을 아주 간단히 정리하면 다음과 같다.

REF

 

7: Application Layer (응용 계층)

- 텔넷 등

 

6: Presentation Layer

- Encoding/Decoding 압축/암호화 등이 이루어지는 Layer이다.

 

5: Session Layer

- 운용 체제에서 다루어주는 TCP/IP 세션 생성 및 해제.

 

4: Transport Layer(트랜스포트 계층)

- 쉽게 TCP를 이용하는 계층이라고 보면 된다.

- End-to-End간 통신을 다루는 최하위 계층이다.

- 오류검출, 흐름제어, 중복검사 등이 이루어진다.

 

3: Network Layer

- IP와 라우팅 기반으로 데이타 통신이 이루어진다.

- 패킷 생성이 이루어지며, QoS관리 등이 이루어진다.

 

2: Data Link Layer (데이터 링크 계층)

- MAC Address 기반으로 통신을 하는 계층.

- CRC 체크등 에러체크 가 이루어 진다.  (+재전송/흐름제어)

 

1: Physical Layer(물리계층)

- H/W Layer로서 가장 복잡한 계층이다.

Posted by yongary
,

<Self-Balanced Tree>

B-Tree:      2개 이상의 child를 가짐..    


2-3 B-Tree   (I think - 2 max, 3 Node) 

        • Every non-leaf node has either 2 or 3 children.
        • All leaves are at the same depth.
        • Information (keys and associated data) is stored only at leaves

        • 부모는 leftMax, middleMax를 저장. (left children's Max, middle children's Max)

        • non-leaf nodes have 2 or 3 children (never 1 )

        • Insert Operations: (value k)
          (2가지 예외)
          - T is empty일 때, 싱글 node with k 생성. 
          - T is 1 node(m) 일 때 : (1 parent, 2 child node로)
                                       => 1.node(n)k포함 생성,  
                                            2.new 내부node (with n,m are child node) 생성
                                             + leftMax,middleMax 세팅.
          (general)
          - insert(T,k) 



ㅁ 2-3-4 Tree : 3개의 data와 4개의 child node를 가질 수 있다. 



<Self-Balanced Binary Tree>

Red-Black Tree: Ref1 ,  

root는 블랙노드

레드노드(temp노드)가 항상 블랙child를 가짐.
삽입시에 레드노드를 삽입하는데, 레드-레드 될 경우 회전으로 해결.


특징: 최장거리 노드도 최단거리의 2배가 이하임. 


AVL Tree:  Refwiki - Height balanced 이진트리 - 각 two child간의 depth가 1 밖에 차이가 안남.
      - depth가 좋으 므로 Red-Black Tree보다 탐색속도가 좋음.

- 특징: 4가지 회전 방식이 존재함 (할아버지 노드까지만 보면 됨)

   LL/RR은 한번만 회전.  LR/RL은 2번 회전. 


Splay Tree  

         - self balanced이면서 속도도 빠름.  이 역시 위 둘과 같이 회전으로 balancing. 

         - 최근 access한 값을 다시 access 할 수 있도록 배치.

  - cache나 gc에 자주 쓰임.

  - zig (parent  root, x is child) , zig-zig (p!=root, p,x 같은 방향), zig-zag (p!=root p,x다른 방향) case 존재.   

 

         

      [기본 회전 알고리듬] Ref

  Root Pv C A B

Pivot = Root.OS (O=Opposite side) Pivot설정. Root.OS = Pivot.RS (R= Rotate side) Pivot.RS를 1.detach Pivot.RS = Root Pivot.RS를 2.Set Root = Pivot Root설정.

   
회전시 left,right가 계속 바뀌므로 java reflection을 쓰면 좋을 것 같네요.
   left, right child를 이름으로  가져오게...  reflection REF

Class aClass = MyObject.class Field field = aClass.getField("someField"); //for node : MyObject node = new MyObject(); Object value = field.get(node); field.set(node, value);



<other tree>

Cartesian Tree ref1txt

 - Heap Tree와 비슷하게 min(or max)값이 제일 위에 있으나, complete tree가 아님.

 - 한번 구성하면 끝날 듯( self balanced가 아님)



KD Tree : k dimensional Tree이다. left-child에 tree하나, right-child에 tree하나 가 관리되는데..
                 recurive하게 여러개의 tree가 계속 관리될 수 있다. 



Huffman Tree: 압축알고리듬 허프만 코드- (확률빈도가 높은 char을 짧은 bit로 관리하는 코드 방식. )
                         를 생성할때 사용하는 binary Tree이다. 

                          왼쪽이 0, 오른쪽이 1 간단하다. 빈도수가 낮은것부터 밑에서 tree를 만든다. 





Heap Tree:  complete binary tree (즉  포화트리에서 마지막 자식은 왼쪽노드부터 채움)

  - heap Tree Java 알고리듬: 

k 의 parent는  k/2;    k의 2자식은  2k 와 2k + 1.  (array로 구현하고 첫자리를 비움. array size는 2^(h+1) 이 되겠죠.)


  최상위 root에는 최소값(Min Heap)이나 최대값(Max Heap)을 관리.

  - complete binary tree는 배열로 관리 가능함.  h로 관리되겠죠. 2^(h+1) -1 개가 max 노드개수임.  

  -Priority Queue 가 Heap으로 구현됨. (단, 이 때는 중복 허용)


  

insert: 일단 마지막 leaf에 넣고.. 자리바꾸기. 

  removeMax:  최상위 삭제하고, 마지막 leaft를 최상위로 배치.. (그 후 자리바꾸기)

  




Posted by yongary
,

enum

java core 2016. 7. 20. 17:38

java의 enum은 c처럼 간단한 enum기능에, 약간의 static class같은 기능이 추가되었다.

new를 해서 쓰지는 못하고, 상수에 value가 매핑되어 있는 형태로 사용가능하며

Serializable,Comparable, Runnable 모두 구현가능하다.

추가로 EnumSet, EnumMap도 있다. 


REF-SITE


1. 간단한 java enum:

enum Day { MONDAY, TUESDAY, WEDNESDAY }

==> 항상 이값으로만 사용가능.  c처럼 숫자로 자동 대체되지 않음.



2. enum에 value를 추가시:

enum Coin {

  PENNY(1), NICKLE(5), DIME(10), QUARTER(25);

  private int value;

 

  private Coin(int v){

 value = v;

  }

  public int getValue(){

 return value;

  }


  //참고: toString()오버라이드 안해도 PENNY찍힘.

  public String toString(){

 return super.toString()+":"+value;

  }

}


public class EnumTest {


public static void main(String args[]){

for(Coin c : Coin.values())

System.out.println(c.toString());  //오버라이드안하면 c = c.toString();


    //비교시

    if (c == Coin.DIME) { }

    if (c.getValue() == Coin.DIME.getValue()) { } 

}

}



3. enum에 value,color를 추가시:

enum Coin {

  PENNY(1,"gold"), NICKLE(5,"white"), DIME(10,"silver"), QUARTER(25,"silver");

  private int value;

  private String color;

 

  private Coin(int v, String c){

 value = v;

 color = c;

  }

}

Posted by yongary
,

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());

Posted by yongary
,

 

http://bigocheatsheet.com/  참고

 

 

Merge sort(합병 소트):  O(nlogn)  단점 O(n)스페이스 필요.  Ref-Site

  - 반씩 분할하는 divide & conquer 소트의 일종.

  -  merge_sort (int[] arr, int low, int high) {

            int mid=0;

    if (low < high) {

        mid = (low+high) / 2;

        merge_sort(arr, low, mid);

        merge_sort(arr, mid+1, high);

        

        merge(arr, low, mid, high); // 이 안에서 스페이스 필요. 

    }

     }

  - qSort는 최악에 O(n^2)이지만 실제로는 평균적으로는 qSort가 20%정도 빠르다고 함.

     => qSort 최악의 경우:  pivot을 정할때.. pivot이 최대값이면..  글케 됨.

 

 

Radix sort(̧기수 정렬) :  Ref-Site

  - O(pN) 이며, 2^20(백만개)정도의 숫자를 소팅할때 16진수로 한다고 치면 4자리 수이므로
    4번 * N  정도로 할 수 있어  일반 정렬 O(n logn) =  O(n * 20) 보다 훨씬 빠른 경우가 발생한다.

 

 

 

Insertion Sort(삽입 정렬):  Ref-Site

 - O(N^2) 이지만 구현이 매우 간단하고,  길이가 짤을 때 속도가 좋고 안정적이라는 장점이 있다. 

 

c코드-참고 

void insertion_sort (int *data, int n ) { 
	int i, j, remember; 
    for ( i = 1; i < n; i++ ) { 
    	j=i; 
        remember = data[i]; 
        while ( --j >= 0 && data[j] > remember) 
        	data[j+1] = data[j]; //쭉 copy
            
        data[j+1] = remember; 
     }
 }

 

참고: 자바에서는 리스트의 기본 정렬 방식으로 

1) Merge Sort를 사용하거나 

2) tuned depending on the datatypes  Quick Sort를 사용 

+ 개체수가 7개 이하일 때 Insertion Sort 방식을 사용한다.

 

==============Data Structure=================

 

 

Heap:  complete binary tree (즉  포화트리에서 마지막 자식은 왼쪽노드부터 채움)

  최상위 root에는 최소값(Min Heap)이나 최대값(Max Heap)을 관리.

  - complete binary tree는 배열로 관리 가능함.  h로 관리되겠죠. 2^(h+1) -1 개가 max 노드개수임.

 

  -Priority Queue 가 Heap으로 구현됨.

  -median을 구하기에 가장 최적의 자료구조는

  바로
  Min Heap과 Max Heap을 동시에 하나씩 관리하는 것이다.

 

  예를 들어 100까지의 숫자가 있다면  Max Heap으로 50까지 관리하고,  Min Heap을 51부터 관리하면 
  median이 50 or 51 or 50.5 로 바로 구할 수 있다. 

 

 

Trie : REF2  Ref-Site   

    text 추천에 가장 많이 사용되는 변형된 Tree 로서, 마지막 노드에서만 숫자(접근빈도)를 관리한다.

    - 일반적으로 Root에는 데이타를 관리하지 않으며, mutliNary tree이다.
    - 마지막에 숫자를 관리하지 않아도 서치에는 유용하다. O(L)탐색, 생성은 O(M*L),  M은 단어수, L은 가장 긴 단어길이.

    

 

참고:

HashTable : O(1+N/B)  (B=bucket)

 

Posted by yongary
,

<Tree traverse>

java에서 binary tree는 간단히 node class로 구현이 된다.

그 후, traverse에는 2가지 방식이 있는데..

 

 

DFS: Depth First Search - 깊이 부터 서치하는 일반적인 방식.

이렇게 node로 구성된 BinaryTree 를 DFS로 traverse하는 방법에는 2가지가 있는데 

 

1. recursive   (좀 안좋은: 참고 )

       출력은: printInOrder(node) {
                        if (node!=null) {

                            printInOrder(node.left);

                            System.out.println(node.value);

                            printInOrder(node.right);
                        }      

 

2. loop 이용..    loop를 이용한 방법은 다음과 같다.  myREF  REF

 

    주로 stack이용.

 

BFS: Breadth First Search - 같은 depth에 있는 형제들 먼저 출력. (아래코드 참조) -Queue이용.

          q.add(root); 
          while (q.size() > 0) {
                node = q.poll();
                print ( node.value );
                if (node.left != null) q.add( node.left);
                if (node.right !=null) q.add (node. right);
           }

 

 

<Direct Graph Traverse>

 

Dijkstra :  Vertex(node)---edge--->  w 로 갈 때 각 Edge마다 Weight가 있는 경우, 적합.

 log(n^2)으로 vertex를 늘여가면서 가까운 Destination으로의 path를 찾아나간다.

핵심공식: distance[w] = min(distance[w], distance[u] + weight[u][w])

 

 

            (아래 표 참조 1에서 출발:)

           w    S               D(2)  D(3)  D(4)  D(5)

           1   S{1}            10    무한    30    100

           2   S{1,2}         10    60      30    100

 

   1에서 가까운 w를 하나씩 추가하면서 진행해 나가므로,  가까운 Vertex관리가 필요한데,

   A. (Linked)adjacent List 로 관리하거나

   B.  priority Queue로 관리할 수 있다.    (모든 Vertex에서 다해도 되지만, S 에 들어가는 거 위주로 해도 된다.)

 

 

 

BFS: tree에서 처럼 weight없이 탐색한다. 탐색방식은 Dijkstra와 근본적으로 같다.

 

 

 

<MST:min Spanning Tree>   REF

 

 

Prim 알고리듬:  O(n^2) => 보통 점만 주어질 땐,  link가 많으므로 이럴때 적합. 

  - 노드 하나를 기준으로  그 외부와 연결되는 가장 min 값을 연결한다.

  -  연결된 Set  과   그 외부 Set(외부를 전체 Set으로 보고) 또  가장 min 값을 연결한다.

   (구현이 간단함)


  내가 구현한 예제: disjointSet 이용.

더보기

 

int dist(int[] p1, int[] p2) {
        return Math.abs(p1[0] - p2[0]) + Math.abs(p1[1] - p2[1]);
    }

    class Node {
        int id; //1~5
        int dist;
        int pid1;
        int pid2;


        public Node(int pid1, int pid2,int id, int dist) {
            this.pid1 = pid1;
            this.pid2 = pid2;
            this.id = id;
            this.dist = dist;
        }
    }

    /** MAIN */
    public int minCostConnectPoints(int[][] points) {

        if (points.length <= 1 )  return 0;
        //4point case: 3*2 = 6개? (n-1!)

        int N = points.length;
        //20개 중 작은값 4개를 뽑아서 더하면 될듯. (단 이미연결된거 방지 체크)
        //int dists[] = new int[ N * (N-1)];

        PriorityQueue<Node> pq = new PriorityQueue<>(new Comparator<Node>() {
            @Override
            public int compare(Node n1, Node n2) {
                return n1.dist - n2.dist;
            }
        }
        );

        //10개 노드: 4 + 3+ 2+ 1
        int id = 0;
        for (int i = 0; i < N-1; i++) {
            for (int j = i+1; j < N; j++) {
                Node node = new Node( i, j, id++, dist(points[i], points[j]));
                pq.add(node);
            }
        }
        System.out.println( "Total NODE: :" + id);


        //필요 node는  (n-1)! -1 ///////////////////////
        int k = N - 1;


        int totDist = 0;

//        HashSet<Integer> hs = new HashSet<>();
        DjSet djSet = new DjSet(N);

        while (pq.size() > 0) {
            // while (k > 0) {
            Node node = pq.poll();
            System.out.println("node poll:" + k);

            //TODO check.
            if (!djSet.isConnected(node.pid1, node.pid2)) {

                //add node.pid1, node.pid2
                djSet.union(node.pid1, node.pid2);

                totDist += node.dist;
                k--;
            }
            //DjSet 도입이전 코드:  섬이 2개 생기면 이미 추가되어서 오류가 생김.
//            if ( !hs.contains(node.pid1) || !hs.contains(node.pid2)  ) {
//                //System.out.println(node.dist + "," + node.pid1 + "," + node.pid2 + ",");
//                hs.add(node.pid1);
//                hs.add(node.pid2);
//
//                totDist += node.dist;
//                k--;
//            }
        }

        return totDist;
    }

 


   구현에 DisjointSet(서로소 집합)과 union 이 필요할 것 같아서 링크 REF

 /////////// DjSet: find, union, isConnected ////////////////////////////
    class DjSet {

        int[] parent;
        int[] size;

        public DjSet(int n) {
            parent = new int[n];
            size = new int[n];
            for (int i = 0; i < n; i++) {
                parent[i] = i;
            }
        }

       
        //find parent //////////////
        int find(int x) { //union하면서 아직 update안된 parent들 udpate하면서 find
            if (parent[x] != x) {
                parent[x] = find(parent[x]); // 경로 압축: 부모를 찾아서 업데이트하면서 재귀적으로 호출
            }
            
            return parent[x];  // 노드 x의 부모 반환
        }

        boolean isConnected(int x, int y) {
            return find(x) == find(y);
        }

        void union(int x, int y) {
            int rootX = find(x);
            int rootY = find(y);

            if (rootX == rootY) return;

            if (size[rootX] > size[rootY]) parent[rootY] = rootX;
            else if (size[rootX] < size[rootY]) parent[rootX] = rootY;
            else {
                parent[rootY] = rootX;
                size[rootX]++;
            }

        }
    }


   구현에 DisjointSet(서로소 집합)과 union 이 필요할 것 같아서 링크 REF

 

Kruskal 알고리듬: O(eloge)    -  e 가 적당하다면 이 알고리듬이 훨씬 낫다. 

  - 일단 min Edge 들을 연결한다. (단 cycle이 안생기는 방식으로 연결)

 - 마지막엔   Set 과 Set 간 연결들이 필요.

 

 

<TSP: Travelling Salesman Problem>

모든 노드를 한번씩만 돌아서 다 돌때 최소 weight 찾는 문제로, 일반적으로 알고리듬이 없다. 

즉 모든 경우의 수를 다 해봐야 한다.  

 

 

 

 

   ====Tree BFS code  (순서없이 BFS Breadth First Search )======

위에 5줄이면 충분함.   detail을 포함한 세부구현은 아래 더보기 참조.

더보기
class Node{
    int value;
    Node left;
    Node right;

    public Node (){
        left=right=null;
    }

    public Node (int v){
        value = v;
    }
}

class Test {

    /* DFS */
    public void printInOrder(Node node){  //이함수는 DFS recursive test용 임.

        if (node != null){
            printInOrder(node.left);
            out(":" +node.value);
            printInOrder(node.right);
        }
    }
    
    /* simple class for Marking a New Line in the Queue
     */
    class NewLine extends Node{

    }
    
    /* print same depth nodes at the same line
     * @param binTree : root Node of binary Tree
     */
    public void printBFSTree(Node binTree){

        if (binTree == null) return;
        Queue<Node> queue = new LinkedList<Node>();
        
        queue.add( binTree );
        queue.add( new NewLine()); //depth seperator
        
        while (queue.size() > 0){

            Node node = queue.poll();
            
            if ( node instanceof NewLine) { //(Depth changed)
                System.out.println();   //print new Line
                if (queue.size() > 0)
                    queue.add(node);           //add NewLine for added sibling
            }else {                   //(general Node)
                //print Node's value
                System.out.print(node.value + " ");
            }
            
            if (node.left != null) {
                queue.add( node.left );
            }

            if (node.right != null) {
                queue.add( node.right );
            }
        }
    }
 

 

Posted by yongary
,

콤비네이션(C) 알고리듬 참조:  http://stackoverflow.com/questions/2201113/combinatoric-n-choose-r-in-java-math 

 

int nCk = 1;
       
for (int k = 0; k < K; k++) {
           
System.out.print(nCk + " ");
            nCk
= nCk * (n-k) / (k+1);
       
}

예) 5C3 =   5/1 * 4/2 * 3/3  =  10..

 

중복 콤비네이션(H) 참조: https://ko.wikipedia.org/wiki/%EC%A1%B0%ED%95%A9 

    개의 빈칸에 중복을 허용하여 개의 원소를 넣는 개수로 생각할 수 있다.?

      즉, 개의 칸막이를 두고 가지 경우를 임의의 순서로 배열하는 것.?

 

      nHk = (n+k-1)C(n-1) = (n+k-1)Ck

 

 

Posted by yongary
,

spring에서 bean은

Spring 2016. 6. 29. 16:48

spring에서 bean은 아무 생각없이 만들면

spring container에서 singleton 으로 만들어 준다.

(즉, 전체 sping container에서 항상 동일한 하나의 global instance로 bean을 만들어 준다)

 

따라서 immutable이고 status도 없이 만드는 것이 좋음.

 

만약, 다른 용도로 만드려면

 

Prototype Bean - 매번 생성

Session Bean  - WEB 세션별로 생성

Request  Bean - WEB Request별로 생성

이 존재하며..

 

 

@Component

@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)     과 같이 annotate 한다.

    - @Scope("prototype") 만 해도 되지만.. 위에 방식이 더 안전.

 

 

xml에서 할 경우에는
<baen id="note" class="my.Note" scope="prototype"> 으로 한다.




참고:  @Component는 autoscan이 되지만 @Bean의 경우에는 안되므로

@Bean을 직접 사용할 경우에는 method body에서 생성해서 return해야 한다.  REF


Posted by yongary
,

참고: java binarySearch예제

Comparator<Person> ageComparator = Comparator.comparingInt(Person::getAge);

int index = Arrays.binarySearch(people, new Person("Bob", 30), ageComparator);

(찾으면 >=0 못찾으면 -index-1 리턴)

 

 

아래는 없을땐 -1 리턴하는 java 코드들입니다.

 

<sort된 array내에서 exact매칭을 위한  BinSearch >

 

public int binSearch ( int A[],  int target ){

 

int low = 0;

int high = A.length -1;

int mid = 0;

 

while (low <= high ){

mid = (low+high)/2;

 

if       ( A[mid] < target)  low = mid+1;

else if ( A[mid] > target ) high = mid -1;

else 

return mid;

}

return -1;

}

 

<sort + rotate된 array내에서 exact매칭을 위한  BinSearch 
예) [4,5,6,7,8, 0,1,2,3] 에서 target이 2인경우 ==> 정 답: 7

public int search(int[] nums, int target) {
        int low = 0;
        int high = nums.length - 1;
        int mid = 0;

        while (low <= high) {
            mid = (low + high) /2;
            
            if (nums[mid] == target) return mid;
            
            //left half sorted
            else if (nums[low] <= nums[mid] ) {
                //target이 left 존재 (mid제외)
                if (nums[low] <= target && nums[mid] > target) {
                    high = mid - 1;
                } 
                else low = mid + 1;
            }
            //right half sorted
            else {
                //target이 right에 존재 (mid 제외)
                if (nums[mid] < target && nums[high] >= target )
                    low = mid + 1;
                else
                    high = mid - 1;     
            }
        }
        return -1;
    }

 

 

<LE를  위한  BinSearch >  : LE - lessthan or Equal을 만족하는 최대 index 리턴.  

 

// A:{1,2,5, 9, 10}, target:7 =>   index:2 return이 목표.

public int binSearchLE ( int A[],  int target ){    

int low = 0;

int high = A.length -1;

int mid = 0;

 

while (low <= high) {

mid = (low+high)/2;

 

if       ( A[mid] < target)  low = mid+1;

else if ( A[mid] > target ) high = mid -1;

else 

return mid;

}

 

if ( mid>0 ) {   

if (A[mid] < target )    //LE CHeck

return mid;

 

if (A[mid] > target && A[mid-1] < target ) 

return mid-1; 

}

if (mid==0){  //mid가 0일경우는 어떡하나?

if (A[0] < target) return 0;

}

 

return -1;

}

 

   ======> 마지막 2개의 if를 간단히 3줄로도 줄일 수 있음.

if (arr[mid] < target) return mid;

else if (mid > 0 && arr[mid] > target && arr[mid-1] < target)
return mid -1;

 

//// low,high trace ///////////////////////

0,4 -> mid:2   if

3,4 -> mid:3   else_if

3,3 -> (mid:3) else_if

=> low,high가 마지막 loop이므로 이때 one more check가 필요. 

   return -1;  

 

 

 

<GE를  위한  BinSearch >  : GE - grea than or Equal을 만족하는 최소 index 리턴. 

 

// A:{1,2,5, 9, 10}, target:7 =>   index:3  return이 목표.

public int binSearchGE ( int A[],  int target ){    

int low = 0;

int high = A.length -1;

int mid = 0;

 

while (low <= high) {

mid = (low+high)/2;

 

if       ( A[mid] < target)  low = mid+1;

else if ( A[mid] > target ) high = mid -1;

else 

return mid;

}

 

if ( mid < A.length-1 ) {  

      if ( A[mid] < target &&  A[mid+1] > target ) 

return mid+1;

 

if  (A[mid] > target )  //GE CHeck

return mid;

 }

 

if (mid==A.length-1){  //?

if (A[mid] > target) 

return (A.length-1);

}

return -1;

}

 

//// low,high trace ///////////////////////

0,4 -> mid:2   if

3,4 -> mid:3   else_if

3,3 -> (mid:3) else_if

=> low,high가 마지막 loop이므로 이때 one more check가 필요. 

   return -1;  

Posted by yongary
,

java 에서  int 와 double이 default 이다.


따라서


long 이나, float를 선언할 때는 주의 해야 하는데



long sum =2147483648;     //에러

    =>  long sum=2147483648L;  //근데 작은값 들은 자동으로  문제 없는것 같긴 하다.


float f = 23.1

   => float f = 23.1f; 


로 고쳐주어야 한다. (L,f는 대소문자는 상관없다)





array의 경우도

float[] a = new float[] {-1.3f, -4.5f} ; //이런식으로 해야  컴파일 에러가 안난다.

                      


< int +int => long>

  int a; int b; 

  a + b > c   하려면  a+ (long)b > c 로 해야지  좌변이 long으로 정확히 비교된다.

Posted by yongary
,

jvm & GC

java core 2016. 6. 6. 17:19

<참고사이트1>  <참고사이트2>

 

 

<메모리 분류>

  Young Gen  ( Eden ,  From, To)

            

  Old Gen  

 

  Perm Gen  :  static Object, Constant String,  Meta  가 저장되는데  GC가 되지 않는 영역이라서

                    메모리부족을 일으키는 요인 중 하나였는데,     JDK1.8 에서는 제거되었다..    Meta->native로,  static,String -> Heap으로 이동.

 

 

 

 

 <GC> minor GC 하다가 모자라면   Old로 promotion 하고.. 그래도 부족하면  Major GC or Full GC를 하게된다.

 

       1. minor GC (young GC) 가 할당된 survivor영역이 꽉차면 발생.

          Young Gen에서  unReferrence된  Object들을   GC하면서 

                => 비어있는 survivor영역으로 이동.  (공간부족시 Old영역으로 이동)

 

          from<->to 를 몇번(tenuringThreshold) 왔다갔다하면서도 살아남은 애들은 Old Gen 으로  옮긴다.
                                       

                                             CMS:Concurrent Mark & Sweep

        - Old GC (major GC) = parallel GC +  CMS GC + G1 GC  + (serial GC, parallel GC, parallel Comacting GC)  REF

           혹자는 Major GC=Full GC로 부르므로, 가능하면 Major GC란 용어는 사용하지 말자.

          

        2. Magor GC: 1 이후  CMS GC 가 일어나는데..
          CMS GC가  Old영역을 Compaction하지 않고 (즉, fragment를 해결하지 못하고) 따라서,  

          Full GC (전체 Heap clean) 를 유발: 즉, fragment가 많으면 Compaction(조각모음)도 수행한다.  ---> 이 때, STW 발생. '

                a. from, to 의 size를 늘이거나

                b. tenuringThreshold를 늘여서 old로 잘 안보내거나,  

                c. CMS 의 동작을 좀 빨리하도록 해서 compaction이 덜 일어나게 하거나??  (XX:CMSInitiatingOccupancyFraction)

          해서 해결한다. 

 

참고: Major GC vs Full GC - Full GC 는 전체 Heap을 clean .. Ref

 

        3.  old 나  Perm영역이 부족하면  Full GC가 일어나고, 
             이 대, 
 fragment가 많으면 Compaction(조각모음)도 수행한다.  ---> 이 때, STW 발생.         

                      혹자들(한국사이트들)은 old Generation이 꽉차면 이라고도 하는데.. 머 주로 compaction시 이것도 같이 발생할 것으로 보인다.


               

 

        

java 1.8 에서 permGen이 없어진 대신 metaSpace라는게 생겼다.
 metaSpace는 클래스Loader가 로드한 클래스들의 metaData과 관리되는 곳.
기존의 permGen은 Heap에서 관리했으나,  metaSpace는 native memory영역에서 관리함.
==> 그러므로 application이 STW할 확률은 낮아졌으나, OS전체 메모리가 부족할 수도 있으므로 --XXMetaSpace등으로 사이즈 조절필요.    참고: REF

 

Posted by yongary
,