IT & Mobile

Object class에 기본 포함되는 함수는

• public boolean equals(Object o) 
• public String toString()
• finalize() : 가비지 콜렉션이 정리할 때 사용
• public native int hashCode()  - 대략적인 hashCode 이며
• clone()
  (그 외 wait, notify 등)

Vector 와  ArrayList의 차이
- Vector는 synchronized라서 Thred Safe하고 좀 늦다는 게 가장 큰 차이이고
- 둘 다 고정 사이즈이고 내부적으로는 array를 사용하며,  size를 증가시킬 때 Vector는 100%씩 증가, ArrayList는 50%씩 증가. 

Scanner sc = new Scanner(System.in);
String s = sc.nextLine();


첫번재 n을 숫자로 읽고 라인 쭉 읽는 방법.
int n=sc.nextInt();
String []s=new String[n+2];

for(int i=0;i<n;i++){
   s[i]=sc.next();
}
      
기존 방식. 
try {
            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
            int k = 5;
            
            List<Integer> ret = new ArrayList<>();
            while ( k-- > 0) {
                String st = br.readLine();
           }

대부분의 iterator는 fail-fast이다.

작업중 데이터가 바뀐다면 ConcurrentModification Exception이 발생한다.

ConcurrentHashMap같은 몇몇 컬렉션타입은 fail-safe iterator를 지원하는데

이는 복제본을 가지고 작업을 하는 방식이라서

메모리 리소스 단점과 데이타가 부정확할 수 있다는 단점이 있다.

대표적으로 Serializable, Clonable 등과 같이 실제로는 완전히 비어있는  마크전용 interface를 Mark interface라고 부른다.

목적은 type 체크를 위해서라고 보면 좋을것 같다.    Mark Annotation이라는 것도 있는데 -> REF

String <<< StringBuffer < StringBuilder 

StringBuffer와 StringBuilder의 차이는 synchronized 함수지원해서 Thread Safe인지,  아닌지 차이이다.  StringBuilder가 synchronized가 아닌만큼 더 빠르다.   Java 1.5부터는 간단한 String concat은  컴파일시에 StringBuilder로 대체해준다.   REF

 StringBuilder sb = new StringBuilder();
 sb.append("문자열 ").append("연결");
 String st = sb.toString();

좀 오래된 기술이고 요즘 잘 쓰진 않지만, 복습용으로 기록!

rmi (remote procedure call)의 layer구조:

rmi는 Object의 Serialize를 기반으로 이루어지므로,

client에서 refrerence해서 사용하는 object가 다 사용되면, server에서 client의 Object를 gc(garbage collection)하게 되는데 이를 분산GC = DGC라고 부른다.

Applet:  flash를 거쳐 html5 canvas등으로 대체되면서 잘 안쓰고 있는 것으로 보이지만 처음 나올 당시에는 획기적인 기술이었음.
=> Life cycle은   init -> start -> paint(g) -> stop -> destroy로 이루어져 이후 많은 플랫폼들의 기초가 되었다고 생각된다.
 stop과 start는 브라우저가 최소화, 최대화 될때마다 발생한다. 

Builder는 간단히 말하면 setter가 다 끝나고 생성자를 호출해 주는 패턴이다. 

개념은 간단한데 왜 필요한가에 대한 답은 :  복잡한 생성자와 복잡한 setter가 섞여있는 경우 유용하다. REF 

예) PersonInfo personInfo = new Builder("Mommoo").setAge(12).setPhonNumber(119).build( );

Factory는 여러개의 subClass가 있을경우 생성자가 각각 생기는 복잡한 문제가 있는데..

이를 하나의 생성자로 통일해 주는 큰 장접이 있다.   REF

REF

제한된 thread개수를 이용하여 여러개의 작업을 하고 싶을때 Worker Thread와 Pool을 이용하면 된다.

REF:myBlog

내가 많이 쓰는 간단한 방식은

String pattern = "[Tt]he";                                          // [A-Za-z]   \\s \\w \\d

boolean matched = "the".matches(pattern);  //=> true : 시작^ 끝$까지 포함해서정확히 일치해야 함.

(참고: https://codechacha.com/ko/java-regex/)

알파벳/숫자/언더바만 포함되었는지 체크하려면..
String pattern = "^[\\w]*$";
boolean a = "abc123".matches(pattern);

알파벳/숫자 만 체크하려면..
String pattern = "^[a-zA-Z0-9]*$";
boolean a = "abc123".matches(pattern);

그룹에서 \1 즉 "\\1"은 첫번째 엘리먼트를 뜻함. = m.group(1)
\\b (바운더리) 는 이스케이프 캐릭터로서 단어를 찾을때 앞뒤에 넣으면 좋음.

중복된 단어 하나로 만들기 예제
        // String regex = "\\b(\\w+)\\b(?=.*\\b\\1\\b)";
        // String regex = "(\\b\\w+)(\\W\\1\\b)+";
        
        //이것도 잘되나 String regex = "\\b(\\w+)(\\s\\1)+\\b";
        String regex = "(\\w+)(\\s\\1)+"; //이게 제일 심플하면서 어느정도 동작 확인. 
          //스페이스 제외하고 앞부분만을 word로 보는듯. 
        
        Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);

            String input = in.nextLine();
            
            Matcher m = p.matcher(input);
           
            // Check for subsequences of input that match the compiled pattern
            while (m.find()) {
                //  System.out.println("==" + m.group() + "," + m.group(1)+".");
                input = input.replaceAll(m.group() , m.group(1));
            }
            // Prints the modified sentence.
            System.out.println(input);

Regex Test 사이트는  https://regex101.com/

java API:  https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html 

Regex자료는 여기서 참고: Ref

▲ 출처 : http://lng1982.tistory.com/141

private 함수를 테스트 할 경우, java의 reflection기능을 사용해서 test할 수 있다.

import java.lang.reflect.Method;

Map<String, Long> repeatMap = null;
try {
    Method method = ChatRankingService.class.getDeclaredMethod("getRepeatCount", List.class);
    method.setAccessible(true);
    repeatMap = (Map<String, Long>)method.invoke(chatRankingService, serviceCodes);
} catch (Exception e) {
}

이와 같이 method.setAccessible(true)를 하면 private함수도 실행이 가능하다. 

REF

위의 REF를 참조해서 아래와 같이 string으로 변경하면

mySql에서 바로 사용이 가능하다. 

Clock clock;
DateTimeFormatter DB_TIME_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

String alarmTime = dateTime.format(DB_TIME_FORMAT);

String alarm2 = LocalDateTime.now(clock).format(DB_TIME_FORMAT)

그리고, LocalDateTime을 바로 MySQL에 저장도 가능한데.. (음 이게 더 나아보인다)

단, 이때 String 을  LocalDateTime으로 변환필요시가 있을때에는

"yyyy-MM-ddTHH:mm:ss") 형태를 사용해야 한다.   ( T가 중요)

Unit 테스트시에 가짜 object를 만든다.

Template을 이용해서, class를 기본으로 object 데이타를 만든다.  REF

 Template을 이용하거나

     ClientTemplateLoader implements TemplateLoader{

@Override

public void load(){

}

Fixture.of(My.class).addTemplate("valid", new Rule(){{

}});

     }

 Fixture class안에서 ObjectFactory를 이용하게 되고.

     class Fixture {

        @Override

         ObjectFactory from(class<?> class){

    return new ObjectFactory(of(clazz)); 

}

Test시에는 아래와 같은 방법으로..  object를 만들어서 사용할 수 있게 된다.

  Fixture.from(My.class).gimme("new")    

- (물론)위처럼 소스에서 하나씩 생성할 수 있지만...

- Regex를 이용한 Rule을 이용해서도 만들 수도 있다. 

- Fixture 를 YAML로 저장해 놓고 일괄 생성할 수도 있다.

guava-api

Guava는 열대과일로서 분홍색 빛을 띤 주스로 즐기기기도 하는데,

구글에서는 guava library를 통해, java 에 없는 편리한 기능들을 진작부터 만들어왔고,

일부가 java7, java8등에 반영되기도 하였다.

거론되는 장점들은 다음과 같다. (추후 test후 재정리 예정)

1. MultiMap

 - 기존 Map이 <key,value>인데 반해,  MultiMap은 <key,v1,v2,v3,v4...>라고 볼 수 있다. 

   여러모로 편리하다. 속도도 구글이 만들었으니 빠를것 같긴 한데...   

2. ImmutableMap  : 

  - ImmutableMap.of( "A", ImmutableMap.of("A-1","A-2") )  ; 

  이런식으로 사용해서, data가 바뀌지 않는 Map 이 있어 test시에 유용하다.

  => ImmutableList.of("A","B");　도 유용하다. (이거도 guava)

3. Ordering이 아주 편리하다고 한다. 

4. Maps.uniqueIndex  - 중복없는 Index 제공해주므로 편리.

    Maps.newHashMap() - nested Map 을 한번에 생성해서 편리.  REF (이전글이라 test필요) 

5. CharMatcher 가 아주편리하다고 한다.  regex를 대체할 수 있나 본데....

스트림에서 유용

 .stream().collect(GuavaCollectors.toImmutableMap

Java 용 json parser로 가장 많이 사용되는 것이 jackson이 아닐까 싶다. : REF

jackson2 가 spring 4에 포함되면서,  RestController같은 경우 Object만 return 하면 자동으로

    MappingJackson2HttpMessageConverter에 의해 json으로 변환된다. : REF 

    ( 단, 모든 member변수에 getter와 setter가 있어야 한다 - 이게 귀찮으니.. Lombok이 쓸만하다)

(복잡한 List<Object> 사용시에는 는)

     itemList = objectMapper.readValue(StringData, new TypeReference<List<MenuItemVo>>() {});

간단한 사용법은 다음과 같다. 

클래서 선언이 다음과 같을 때,

class MyObject{

String name;

int age;

}

import com.fasterxml.jackson.databind.ObjectMapper;

<json ->  java Object 방법>

   ObjectMapper mapper = new ObjectMapper();

   MyObject my = mapper.readValue ( file or URL or String , myObject.class);

<java Object -> json 방법>

  MyObject my = new MyObject("name", 12 );

  String jsonStr = mapper.writeValueAsString ( myObject )

  결과는 

  {"name":"name", "age":12 } 로 되는데

  좀 이쁘게 개행도 포함하고 싶으면

  String jsonStr = mapper.writeWithDefaultPrettyPrinter().writeValueAsString ( myObject );   으로 한다.

<변수명이 좀 다를때>

objectMapper.setPropertyNamingStrategy(     PropertyNamingStrategy.CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES);

20년에 위에껀 deprecated되고. 아래와 같이 하면 snake_case 를 camelCase로 변환됨. 단 snake_case는 소문자임.

    @Data
    public static class Camel {
        String userName;
    }

    @Test
//    @Tag("excludeBuild") //테스트시 comment 필요.
    public void mapperTest() throws Exception{
        
        ObjectMapper mapper1 = new ObjectMapper().setPropertyNamingStrategy(
                PropertyNamingStrategy.SNAKE_CASE);
        Camel camel1 = mapper1.readValue ("{\"user_name\":\"Kim\"}", Camel.class );

        log.info("Camel1:" + camel1);

개선: 아래로 하면 대문자도 되는 듯

+        mapperDome.setPropertyNamingStrategy(new PropertyNamingStrategies.SnakeCaseStrategy());

spring등에선 @JsonProperty로 변환용 변수명을 설정할 수 있지만,여러개일 경우 PropertyNameStrategy 설정이 매우 유용하다.

<null은 제외>

@JsonInclude(JsonInclude.Include.NON_NULL) 

<LocalDateTime 변환>

@JsonSerialize(using = LocalDateTimeJsonSerializer.class) : Custom Serializer 이용. 

public class LocalDateTimeJsonSerializer extends JsonSerializer<LocalDateTime> {
    private static final DateTimeFormatter YYYY_MM_DD_HH_MM_SS =
            DateTimeFormatter.ofPattern("uuuu-MM-dd HH:mm:ss");

    @Override
    public void serialize(LocalDateTime localDateTime,
                          JsonGenerator jsonGenerator,
                          SerializerProvider serializerProvider) throws IOException {
        jsonGenerator.writeString(localDateTime.format(YYYY_MM_DD_HH_MM_SS));
    }
}

<Object Copy>

import org.apache.phoenix.shaded.org.apache.commons.beanutils.BeanUtils;

try {

 //멤버type과 이름이 딱맞는 애들만 쭉 copy해준다.

BeanUtils.copyProperties(destObj, srcObj);  

} catch (Exception e) {

e.printStackTrace();

} 

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)

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)

[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 ); 가 가능함.

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

}

  }

}

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

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

[본론]

jdk 1.7 에 AsynchronousFileChannel class가 있다.  REF

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

..

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;

  }

}

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으로 정확히 비교된다.

<참고사이트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

java의 abstract class 나 interface가  instance 화가 될 수 있냐? 고 질문한다면

답은  1. 일반적으론 안된다.  

          2. 그렇지만 anonymous class 방식으로는 된다. REF(Runnable 참조)

       이렇게 둘 다 답하면 best 이다.

참고로 
 abstract class : 추상 method가 하나이상 존재--> 상속시 추상 method구현을 강제함.
 Interface : 추상 method만으로 이루어진 class   but jdk1.8에서는  구현된 method도 허용함.  

     REF-SITE:

[char array->String]

char cArr[] ;  

String s = String.valueOf(cArr);

1. Array에 특정한 Object가 있는지 Check:

Arrays.asList(yourArray).contains(yourValue)

Warning: this doesn't work for arrays of primitives (see the comments).

2. LinkedList 에서 삭제 및 data Set.

Size()가 변하는 loop안이라면 Iterator를 사용하여 삭제하는 게 안전.

아니면 뒤에서부터 앞으로 Loop돌면서 삭제. (테스트 필요)

Iterator<String> iter = list.iterator();
while (iter.hasNext()) {  
     String s = iter.next(); //꼭 next먼저 호출.
     if (s.equals("a"))  iter.remove();  //원래 remove는 가장최근 return()한 걸 삭제하는 이상한 함수임.
}

ListIterator의 경우에는 iter.set() 함수도 매우 쓸만하다. //이 역시, 가장 장최근 return()한 걸 치환.

3. LinkedList  에 특정위치에 data 넣고 싶을때?

    LikedList<String> list = new LinkedList<String>();

    list.add("a");list.add("c");

    <a,c사이에 b를 넣고 싶으면>

    list.add(1,"b");   // index를 이미 안다면,  방법을 쓰거나..

    list.add ( getIndex("a")+1, "b"); //모른다면.. 이방법. 근데이게 getIndex가 속도가 의심이 됨..  

     최상의 방법은? 뭘까요?  
     자가 List라면  node.next.next = node.next;  node.next = new Node(); 하면 되는데.. 
     

     이런방법 없을까요?

public static void main(String[] args) {

    long used1 = memoryUsed();
    int[][] array = new int[200][2];

    long used2 = memoryUsed();
    int[][] array2 = new int[2][200];

    long used3 = memoryUsed();
    if (used1 == used2) {
        System.err.println("You need to turn off the TLAB with -XX:-UseTLAB");
    } else {
        System.out.printf("Space used by int[200][2] is " + (used2 - used1) + " bytes%n");
        System.out.printf("Space used by int[2][200] is " + (used3 - used2) + " bytes%n");
    }
}

public static long memoryUsed() {
    Runtime rt = Runtime.getRuntime();
    return rt.totalMemory() - rt.freeMemory();
}

출처: stackoverflow peter lawrey 

Hotspot VM. (JIT의 일종. SUN의 JIT임)  REF-SITE

      JIT는 그때 그때 OS에 맞게 bytecode를 변환하지만,   AOT는 미리 변환해 놓는다.  

     Android LolliPop부터 ART(anroid Run Time)이라고 부르는 AOT 사용.

JDK1.2부터 HostSpot VM 등장. ( Hot=선택적으로 메서드를 선택해서 컴파일하여 성능을 높이는 VM)

3개의 Generation으로 Heap구성.

1. Young Generation

2. Old Gen

3. Permanent Gen (Perm Gen)

 일반적으로 처음 Heap생성하면 Young Gen.  (Young Gen도 3분류. 처음 Eden -> 나중에 From or  To[=Survivor Space] ) 

 시간이 지나거나 공간부족시 Young Gen----> Old Gen으로 이동.

GC가 끝나면 From, To가 바뀜. (즉, From이 Survivor space가 됨)

각종 옵션

-Xss  : statck Size 

-Xmx -Xms : heap 최대 , 최소 size

-XX:NewSize  (Young Gen 최초 사이즈)

-XX:NewRatio  (Young /Old 비율, x/4, 즉 2면 반반)

-XX:SurvivorRatio  ( Eden과 Survivor비율.  x/9  )

-XX:MaxPermSize    (default=64M or 64bit 머신에서는 +30%)

-XX:+HeapDumpOnOutOfMemoryError

-XX:OnOutOfMemoryError="<cmd args>;<cmd args>"

-XX:OnError="<cmd args>;<cmd args>"

maven is project management tool for  autobuild & dependency management.

INSTALL: just download and unzip.  add bin path to $PATH.

RUN:  $mvn archetype:generate

=> defalt select.

=> groupID,package..etc:  com.ky

$cd com.ky

$mvn compile exec:java -Dexec.mainClass=com.ky.App

Eclipse에서 프로젝트를 하나 골라서

-> Export  ->  General 밑에 Ant Buildfiles 로 하면  build.xml 이 생성된다.

Windows -> Show View메뉴에서 -> Ant를 고르면 우측에 Ant 작업창이 뜨고,

그곳으로 build.xml을 drag하면 build.xml로 빌드가 가능하다

장점: jenkins와 연동한 자동 build가 가능하다.  

Jenkins연동 시에  Build->Add Build Step ->Invoke Ant.

Ref-Site:

1. 

array를 ArrayList로 전환시:

ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr));

(설명)

Collection인 java.util.ArrayList 는

java.util.Arrays.ArrayList와 다름.List list = Arrays.asList(anArray)  하면  static class인

   Arrays.ArrayList가 return됨: 쓰지 말것

2. array안에 value존재하는지 check시

Arrays.asList(arr).contains(targetValue);

3. List에서 element하나 삭제시.

Size()가 변하는 loop안이라면 Iterator를 사용하여 삭제하는 게 안전.

아니면 뒤에서부터 앞으로 Loop돌면서 삭제. (테스트 필요)

Iterator<String> iter = list.iterator();
while (iter.hasNext()) {  
     String s = iter.next(); //꼭 next먼저 호출.
     if (s.equals("a"))  iter.remove();  //원래 remove는 가장최근 return()한 걸 삭제하는 이상한 함수임.
}

ListIterator의 경우에는 iter.set() 함수도 매우 쓸만하다. //이 역시, 가장 장최근 return()한 걸 치환.

4. 보통은 HashMap을 쓰자.  HashTable도 동일하지만 이건 synchronized가 걸려있어 조금 늦음.

Ref-Site: top 10 Q about Map

5. Default 생성자는 생성자가 없을경우에만 자동으로 compiler가 넣어 줌.

   => default생성자 없는 class를 상속받을 경우 super()가 필요한데 없으므로 컴파일 에러가 남.

6. Sort   Ref-Site:

   => Collections.sort( list, Comparator  ),  Arrays.sort( array, Comparator  ) 사용

        // 역순으로 정렬하기 위한 Comparator 객체 생성
        Comparator<String> reverseComparator = new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s2.compareTo(s1);
            }
        };
        
        /**참고 */
        따라서, Comparator 클래스를 구현할 때에는 compare() 메서드를 반드시 구현해야 합니다. compareTo() 메서드는 Comparable 인터페이스에서 정의되어 있는 메서드로, 객체를 자신과 비교하여 정렬 순서를 결정하는 메서드입니다. Comparable 인터페이스를 구현하면서 compareTo() 메서드를 구현해야 하며, Comparator 클래스를 구현할 때에는 compare() 메서드를 구현해야 합니다.

   => Set이나 Map의 경우에는 TreeSet, TreeMap 생성 후 add하면 자동 정렬 : complexity of O(logN)

REF-Site:

 - 필요시: 생성시에 Comparator 공급.

 - Sync필요시:  SortedMap m = Collections.synchronizedSortedMap(new TreeMap(...));

(Sometiems ArrayList is better when no synchronize, Sometimes Vector is better because of Size doubling )

ArrayList : Resizable Array - fast because of index.  Add/Delete is Slow for data Copy. ==> 50% increase its array size

Vector : Similar to ArryList..  a little heavy because of synchronize processing. ==> doubles its array size

LinkedList: Fast for ADD/Delete.  But No Index so sequential search is slow.

HashSet, SortedSet,

HashMap

DelayQueue,  - - - |> BlockingQueue

Stack

several I/F like:

  Queue, - 보통  new LinkedList<T>();

  Deque, - 상동.    

  BlockingQueue : (waiting in some cases)

put은 queue가 꽉 차 있을 경우, take

는 queue가 비어있을 경우가 블로킹 조건이다. 

  TransferQueue

<class> 

  ConcurrentXX  Collections : thread-Safe

-ConcurrentHashMap : synchronize detail이 HashTable과 약간 다름.

  - SynchronousQueue: 초기 size가 0이고.. 다른Thread에서 빼려고 할때만 삽입이 가능한 놈이므로 peek도 안됨..

TreeMap -  red-black Tree 기반의 sorted NavigableMap

TreeSet   -  TreeMap기반.

PriorityQueue - Heap자료구조 기반..

PriorityQueue 클래스는 기본적으로 작은 값이 우선순위가 높은 것으로 취급합니다. 따라서, 1에서 100까지의 숫자를 PriorityQueue에 추가하면, 1이 가장 높은 우선순위를 갖게 되고, 100이 가장 낮은 우선순위를 갖게 됩니다. 따라서 poll() 메서드를 호출하면, 가장 높은 우선순위를 갖는 1이 먼저 반환됩니다.  => 체육복 코딩테스트에 사용 됨.

ThreadLocal은 jdk1.2부터 있었다고 하는데, 그 동안 이런게 있는지 잘 몰랐다.

용도는 2가지인데

1. Thread별로 싱글턴 같은 global(local)변수를 생성/관리되므로, Thread별로 분리된 변수를 사용가능.

=> REF : per-thread Singleton.

 
    ==> synchronized없이도 Lock이 자동으로 방지 될 걸로 예상 됨..(이건 좀 토론이 필요함)

1.1. 하나의 Thread안에서 여러 class가 공용메모리 처럼 사용가능. (왜냐하면 Thread안에서 global이니깐)

관련사이트1 , 관련사이트2

 File f = File.createTempFile("aaa",".tmp")  도 유사한 성격으로 동시 접근을 피할 수 있다.

 write다한 후에 보통 f.setReadOnly();

==> 똑같은 파일명으로 만들어도 알아서 숫자가 붙는 방식임. 따라서 .deleteOnExit() 설정을 꼭 해주는 게 좋다.