<element와 accumulate 차이점>
 
두 개다 name(key)와 value로 데이터를 넣어주는 형식이다.
 
사용 방식은 같으나 
accumulate는 같은 key가 들어왔을 때 배열 식으로 계속해서 value를 붙여주는 형식을 띄고
element는 같은 key가 들어왔을 때 value를 이전 value에 덮여씌워 주는 형식이다.
ex)
소스:
 
               JSONdata data1 = new JSONdata("data1");
               JSONdata data2 = new JSONdata("data2");
               JSONdata data3 = new JSONdata("data3");
               JSONdata data4 = new JSONdata("data4");
              
               // 추가
               jsonByDTO.accumulate("ticketIDList", data1);
               jsonByDTO.accumulate("ticketIDList", data2);
               jsonByDTO.element("ticketIDList1", data3);
               jsonByDTO.element("ticketIDList1", data4);
              
 
               logger.info("DTO 사용: " + jsonByDTO.toString());
 
 
결과화면:
 
INFO : kr.co.mcom.JSONController - DTO 사용: {"ticketIDList":[{"ticketID":"data1"},{"ticketID":"data2"}],"ticketIDList1":{"ticketID":"data4"}}





 
 
결과화면을 보면 ticketIDList에 accumulate를 사용한 것을 볼 수 있는데, 중복된 key값을 사용했을 경우 배열로 결과가 나오는 것을 확인 할 수 있다. 하지만 element를 사용했을 때, 중복된 key값을 사용한 경우 마지막에 대입한 value가 들어가 있는 것을 볼 수 있다.


출처: http://javafactory.tistory.com/814 [FreeLife의 저장소]
블로그 이미지

가카리

소프트웨어와 하드웨어 프로그래밍, 취업 및 직장생활 전문 블로그

Tag java, 자바

StringBuilder는 StringBuffer와 같은 역활을 합니다. 

차이점은 StringBuilder는 스레디 세이프하지 않기 때문에 단일 스레드 환경에서만 사용을 해야 합니다. 

대신 StringBuffer보다는 좀 더 빠른 성능을 보여 줍니다. 

public static void main(String[] args) { 
    StringBuilder sb = new StringBuilder(); 
    sb.append(true); 
    System.out.println(sb); 
     
    sb.append('a'); 
    System.out.println(sb); 
     
    char[] chars = new char[] { 'd', 'e', 'f' }; 
    sb.append(chars); 
    System.out.println(sb); 
     
    int i = 105; 
    sb.append(i); 
    System.out.println(sb); 
     
    Object obj = new String("Obj"); 
    sb.append(obj); 
    System.out.println(sb); 
     
    String str = new String("Str"); 
    sb.append(str); 
    System.out.println(sb); 


출력 결과는 아래와 같습니다. 

true 
truea 
trueadef 
trueadef105 
trueadef105Obj 
trueadef105ObjStr


String, StringBuffer, StringBuilder에 관한 실험 글


출처 : http://tip.daum.net/openknow/59160272

블로그 이미지

가카리

소프트웨어와 하드웨어 프로그래밍, 취업 및 직장생활 전문 블로그

     public void flush() throws IOException;

 
            스트림 버퍼에 저장되어 있는 데이터를 강제적으로 출력시킵니다. 기본적인 출력 스트림은
            버퍼에 데이터가 가득 차면 그때 데이터를 출력시키는데 이 메소드를 사용하면 저장된 데이터의
            크기에에 관계없이 바로 출력됩니다.
 
            OutputStream 클래스에서는 아무일도 수행하지 않습니다.
블로그 이미지

가카리

소프트웨어와 하드웨어 프로그래밍, 취업 및 직장생활 전문 블로그

안녕하세요 돼지왕 왕돼지입니다

오늘은 Weak Reference 와 Soft Reference 에 대해 알아보았습니다.


WeakReference.

Object 를 참조하는 형태 세 가지 중의 하나입니다. GC 가 발생할 때 어떤 object 가 weakly-reachable 이라면 다음과 같은 일이 발생합니다.

1. Weakly-reachable object "를" 참조하는 모든 reference 를 모은다.
2. Weakly-reachable object "가" 참조하는 모든 reference 를 모은다. ( 참조형태는 strong 이든 weak 이든 상관없다. )
3. 1, 2 를 통해 모은 모든 reference 를 한번에 다 해제한다.
4. reference 가 해제된 object 들은 finalization 단계에 들어가며 메모리가 해제된다.

이 Weak Reference 는 밖에서 strong 하게 참조하던 참조가 끊어졌을 때, GC 의 대상이 되도록 하는 데 쓰이면 좋습니다. 즉 그 중요성이 그렇게 크지 않은 경우에 주로 쓰이기 때문에 Cache 에 적합한 녀석이라고 볼 수 있습니다.




 

SoftReference.

Object 를 참조하는 형태 세 가지 중의 하나입니다. GC 가 발생할 때 어떤 object 가 softly-reachable 이라면 다음과 같은 일이 발생합니다.

1. Softly-reachable object "를" 참조하는 모든 reference 를 모은다.
2. Softly-reachable object "가" 참조하는 모든 reference 를 모은다. ( 이 때 참조형태는 strong reference 이다. )
3. 1, 2 를 통해 모은 모든 reference 를 한번에 다 해제한다. ( VM 에 따라 다르며, 최대한 늦춥니다. )
4. reference가 해제된 object 들은 finalization 단계에 들어가며 메모리가 해제된다.

3번 단계에서는 VM 에 따라 다르지만 대부분 이 해제 시점을 최대한 늦춥니다. 최대한의 시점은 OutOfMemoryError 입니다. 이 녀석도 Weak Reference 처럼 Cache 에 적합한 녀석인데, 그 생명력이 더 길다는 장점이 있습니다. ( 단점일수도.. )

 

 




 

WeakReference와 SoftReference 의 차이점

둘의 가장 큰 차이점은 언제 GC 가 되느냐입니다.
WeakReference 의 경우는 strong reference 가 모두 끊기고 GC 타이밍이 되었을 때 바로 GC routine 을 타게 됩니다.반면 SoftReference 는 최대한 GC routine 을 늦게 탑니다. 즉, strong reference 가 모두 끊겼다고 해도, 메모리에 여유가 있으면 GC 가 수행되지 않는 것이죠. 메모리에 여유가 없다는 것은 OutOfMemoryError 직전을 이야기하지요. 

 

 

출처 : http://aroundck.tistory.com/477

블로그 이미지

가카리

소프트웨어와 하드웨어 프로그래밍, 취업 및 직장생활 전문 블로그

각각에 개념부터.

  • WeakReference
    • 말그대로, '약한' 참조 이다. '약한' 참조는 해당 객체에 대한 소멸을 막지 않는다. 즉, 어떤 객체에 대한 참조가 WeakReference 밖에 남아있지 않다면 그 객체는 gc(Garbage Collection) 의 대상이 된다.
    • 펼치기 - J2SE 5.0 api 문서의 설명 원문

  • SoftReference
    • WeakReference 보다는 약간 강한 참조이다. Soft reference 만 남아있는 객체는 메모리의 요청에 의한 gc 의 대상이 된다. 메모리의 남은 공간이 넉넉하다면 gc되지 않을 것이며, 메모리의 남은 공간이 얼마 없거나 하다면 gc 의 대상이 될 것이다.
      확실한건 vm 이 OutOfMemoryError 를 발생시키기 전에는 Soft reference 만 남아있는 객체가 gc의 대상이 된다는 점 정도고, 그 이외에는 vm 의 구현에 따라 다를 수 있다.
    • 펼치기 - J2SE 5.0 api 문서의 설명 원문


샘플 코드를 보자.

public class referenceTest {
 //테스트용 클래스. 별거 없다.
 public static class Inner {
  public String str;
  public Inner(String value) {
   this.str = value;
  }
    
  public String getStr(){
   return this.str;
  }
  
  public String toString() {
   return this.str;
  }
 }
  
 public static void main(String[] args) {
  try{
   
   //일반 참조. 객체를 그냥 생성해서 리스트에 넣고 gc 한다.
   List<Inner> tmpList = new ArrayList<Inner>();
   tmpList.add(new Inner("simple reference is alive."));
   System.gc();
   
   // gc 후 객체가 살아있는지 확인한다.
   for (Inner refer : tmpList) {
    if (refer == null) {
     System.out.println("refer is null.");
    }else {
     System.out.println(refer.getStr());
    }
   }
   
   //WeakReference.
   List<WeakReference> list = new ArrayList<WeakReference>();
   WeakReference<Inner> wr = new WeakReference<Inner>( new Inner("weak reference test obj is alive."));
   list.add(wr);
   
   //gargage collention 발생.
   System.gc();
   
   //gc 후 객체가 살아있는지 확인한다.
   for (WeakReference<Inner> refer : list) {
    if (refer == null) {
     System.out.println("refer is null.");
    }else {
     Inner inner = refer.get();
     if (inner == null) {
      System.out.println("referenced obj is null.");
     }else
      System.out.println(inner.getStr());
    }
   }
   
   //SoftReference.
   List<SoftReference> slist = new ArrayList<SoftReference>();
   SoftReference<Inner> sr = new SoftReference<Inner>( new Inner("soft reference test obj is alive."));
   slist.add(sr);
   //gargage collention 발생.
   System.gc();
   
   //gc 후 객체가 살아있는지 확인한다.
   for (SoftReference<Inner> refer : slist) {
    if (refer == null) {
     System.out.println("refer is null.");
    }else {
     Inner inner = refer.get();
     if (inner == null) {
      System.out.println("referenced obj is null.");
     }else
      System.out.println(inner.getStr());
    }
   }
  } catch (Exception e) {
    e.printStackTrace();
  }
}
}


위 코드는 간단한 테스트 코드로, 리스트에 일반적인 참조, WeakReference, SoftReference 로 add 한후, gc 를 실행시킨뒤 리스트에 객체에 대한 참조가 남아있는지 (생성한 객체가 gc 되었는지) 를 확인하는 코드이다.

실행시켜보면 다음과 같이 찍힌다.

simple reference is alive.
referenced obj is null.
soft reference test obj is alive.


WeakReference 로 참조한 객체만 gc 되서 null 이 찍힌다. jdk 버전등에 따라 결과가 다를 수도 있겠지만, 테스트코드만 돌리는 상황이라면 메모리 여유공간은 아마 넉넉할 것이므로, 대체로 같은 결과일 것이다.

출처 : http://jaguarmk.tistory.com/25

 

블로그 이미지

가카리

소프트웨어와 하드웨어 프로그래밍, 취업 및 직장생활 전문 블로그

ListIterator Iterator를 상속받아서 기능을 추가한 것, 양방향으로 이동이 가능.

 

ArrayList LinkedList와 같이 List 인터페이스를 구현한 컬렉션만 사용가능.

 

Enumeration Iterator의 구버젼격.

 

예제 첫번째

package kch;

 

import java.util.ArrayList;

import java.util.ListIterator;

 

public class ListIteratorEx1 {

               public static void main(String[] args){

                      

                       ArrayList list = new ArrayList();//리스트를 선언하고

                       list.add("1");

                       list.add("2");

                       list.add("3");

                       list.add("4");

                       list.add("5");

              

                       ListIterator it = list.listIterator();//Iterator 받아옴.

                      

                       while(it.hasNext()){//다음이 있다면 출력함

                              System.out.print(it.next());

                       }

                      

                       System.out.println();

                      

                       while(it.hasPrevious()){//이전이 있다면 출력함.

                              System.out.print(it.previous());

                       }

               }

}

 

 

 

 

 

예제 두번째

 

package kch;

 

import java.util.ArrayList;

import java.util.Iterator;

 

public class ListIteratorEx2 {

 

        public static void main(String [] args){

              

               ArrayList original = new ArrayList(10);

               ArrayList copy1 = new ArrayList(10);

               ArrayList copy2 = new ArrayList(10);

              

               //값 추가함

               for(int i=0; i < 10; i++){

              

                       original.add(i + "");

              

               }

              

               //Iterator 가져옴

               Iterator it = original.iterator();

              

               //다음이 있다면 copy1에 추가함.

               while(it.hasNext()){

                       copy1.add(it.next());//복사함

               }

              

               System.out.println("= original에서 copy1로 복사 (copy) =");

               System.out.println("original: " + original);

               System.out.println("copy1 : " + copy1);

               System.out.println();

              

               it = original.iterator();

              

               while(it.hasNext()){

                       copy2.add(it.next());

                       it.remove();//remove사용시 반드시 next 한다음에 해야됨,.

               }

              

               System.out.println("= original에서 copy2로 이동(move) =");

               System.out.println("original:" + original);

               System.out.println("copy2 : " + copy2);

        }

       

}

 

 

 

블로그 이미지

가카리

소프트웨어와 하드웨어 프로그래밍, 취업 및 직장생활 전문 블로그