@Controller

public class CaculatorController {

@Autowired

private CaculatorService caculatorService;

@RequestMapping(value="welcome")

public String welcome() {

return "Caculator";

}

@RequestMapping(value="caculatorResult",method = RequestMethod.POST)

@ResponseBody

public BigDecimal caculatorResult(@RequestParam("inputStr")String inputStr) {

CaculatorDto caculatorDto = new CaculatorDto();

caculatorDto.setInputStr(inputStr);

caculatorDto = caculatorService.getResult(caculatorDto);

System.out.println(caculatorDto.getResult());

return caculatorDto.getResult();

}

}

==========================================================

@Service
public class CaculatorServiceImpl implements CaculatorService{

@Override
public CaculatorDto getResult(CaculatorDto caculatorDto) {
ArrayList postFixArray = infixToPostFix(getToken(caculatorDto.getInputStr()));
BigDecimal result = getCaculator(postFixArray);
caculatorDto.setResult(result);
return caculatorDto;
}

@Override
public ArrayList getToken(String beforeToken) {
int beginIndex=0,endIndex = 0;
ArrayList tokenArray = new ArrayList();
HashMap<String,Integer> operMap = new HashMap<>();
operMap.put("*", 3);
operMap.put("/", 3);
operMap.put("^", 3);
operMap.put("%", 3);
operMap.put("^", 3);
operMap.put("+", 2);
operMap.put("-", 2);
operMap.put("(", 1);
operMap.put(")", 0);

//10+2/3
for(int i=0;i<beforeToken.length();i++) {
if(operMap.containsKey(String.valueOf(beforeToken.charAt(i)))) {
endIndex = i;
if(!beforeToken.substring(beginIndex, endIndex).isEmpty()) {
tokenArray.add(beforeToken.substring(beginIndex, endIndex));
}
tokenArray.add(String.valueOf(beforeToken.charAt(i)));
beginIndex = endIndex +1;
}else {
if(i+1 == beforeToken.length()) {
tokenArray.add(beforeToken.substring(beginIndex, i+1));
}
}
}
return tokenArray;
}

@Override
public ArrayList infixToPostFix(ArrayList infixArray) {
Stack operStack = new Stack();
ArrayList postFixArray = new ArrayList();
HashMap<String,Integer> operMap = new HashMap<>();
operMap.put("*", 3);
operMap.put("/", 3);
operMap.put("^", 3);
operMap.put("%", 3);
operMap.put("^", 3);
operMap.put("+", 2);
operMap.put("-", 2);
operMap.put("(", 1);
operMap.put(")", 0);

for(Object o : infixArray) {
if(o.equals("(")) {
operStack.push(o);
}else if(o.equals(")")) {
while(!operStack.peek().equals("(")) {
Object temp = operStack.pop();
if(!temp.equals("(")) {
postFixArray.add(temp);
}
}
operStack.pop();
}else if(operMap.containsKey(o)) {
if(operStack.isEmpty()) {
operStack.push(o);
}else {
if(operMap.get(operStack.peek())>=operMap.get(o)) {
postFixArray.add(operStack.pop());
operStack.push(o);
}else {
operStack.push(o);
}
}
}else {
BigDecimal bigDecimal = new BigDecimal(o.toString());
postFixArray.add(bigDecimal);
}
}

while(!operStack.isEmpty()) {
postFixArray.add(operStack.pop());
}

return postFixArray;
}

@Override
public BigDecimal getCaculator(ArrayList postFixArray) {
Stack valueStack = new Stack();

for(Object o : postFixArray) {
if(o instanceof BigDecimal) {
valueStack.push((BigDecimal) o);
}else if(o.equals("+")) {
BigDecimal num1 = valueStack.pop();
BigDecimal num2 = valueStack.pop();
valueStack.push(num2.add(num1));
}else if(o.equals("-")) {
BigDecimal num1 = valueStack.pop();
BigDecimal num2 = valueStack.pop();
valueStack.push(num2.subtract(num1));
}else if(o.equals("/")) {
BigDecimal num1 = valueStack.pop();
BigDecimal num2 = valueStack.pop();
valueStack.push(num2.divide(num1));
}else if(o.equals("%")) {
BigDecimal num1 = valueStack.pop();
BigDecimal num2 = valueStack.pop();
valueStack.push(num2.remainder(num1));
}else if(o.equals("*")) {
BigDecimal num1 = valueStack.pop();
BigDecimal num2 = valueStack.pop();
valueStack.push(num2.multiply(num1));
}else if(o.equals("^")) {
BigDecimal num1 = valueStack.pop();
BigDecimal num2 = valueStack.pop();
valueStack.push(num2.pow(num1.intValue()));
}


}
return valueStack.pop();
}



}

INTRO

JSP를 사용하여 웹 개발을 할 경우 자주 접하는 용어지만, 항상 헷갈리는 것 같아 정리해놓으려고 한다.

포워딩(Forwarding)과 리다이렉트(Redirect)는 JSP 환경에서 다른 페이지로 이동하는 페이지 전환 기능들이다. 이 두가지의 차이점은 페이지 이동이 어떻게 이루어지는가에 있다.

포워딩(Forwarding)

웹 컨테이너(Web Container) 차원에서 페이지 이동만 있는 것이다. 실제로 클라이언트는 다른 페이지로 이동을 했는지 알 수 없다. 그렇기 때문에 웹 브라우저에는 최초에 호출한 URL이 표시되며 이동한 페이지의 URL 정보는 볼 수 없다. 동일한 웹 컨테이너에 있는 페이지로만 이동 할 수 있다.

포워딩은 클라이언트와 통신없이 서버에서만 처리되는 것이기 때문에 리다이렉트보다 나은 성능을 보여준다.

그리고 현재 실행중인 페이지와 Forwarding에 의해 호출될 페이지는 Request와 Response 객체를 공유한다. 객체를 요청에 담고 해당 요청을 사용할 다음 자원에 전송한다는 뜻이다.

간단히 말하여 말 그대로 Forward(건내주기)한다는 것이다. 따라서 사용자가 최초로 요청한 요청정보는 다음 URL에서도 유효한 것이다.

리다이렉트(Redirect)

웹 컨테이너(Web Container)는 sendRedirect() 메서드가 호출되어 리다이렉트(Redirect) 명령이 들어오면 웹 브라우저에게 다른 페이지로 이동하라고 명령한다. 이 명령에는 브라우저가 웹 컨테이너의 응답을 받은 후 다시 요청을 보낼 새로운 URL을 포함한다. 그러면 웹 브라우저는 URL을 지시된 주소로 바꾸고 그 주소로 이동한다. 다른 웹 컨테이너에 있는 주소로 이동이 가능하며 새로운 페이지에서는 Request와 Response 객체가 새롭게 생성된다.

리다이렉트는 추가적으로 발생한 처리 때문에 포워딩보다 느리다. 중요한 것은 마지막으로 수행하는 작업은 새로운 요청에 의한 것이고, 이것을 클라이언트가 알고있기 때문에 브라우저창의 주소가 처음 요청한 주소가 아닌 다시 요청을 보낼 새로운 주소값으로 변한다.

간단히 말하여 최초 요청을 받은 첫 번째 URL에서 클라이언트에 Redirect할 두 번째 URL을 리턴하고, 클라이언트는 전혀 새로운 요청을 생성하여 두 번째 URL에 다시 요청을 보낸다. 따라서 처음 보냈던 요청정보는 더이상 유효하지 않는 것이다.

출처: http://sdevstudy.tistory.com/26 [SDev]

 서블릿이란 자바를 사용하여 웹을 만들기 위해 필요한 기술입니다. 그런데 좀더 들어가서 설명하자면 

클라이언트가 어떠한 요청을 하면 그에 대한 결과를 다시 전송해주어야 하는데, 이러한 역할을 하는 자바 프로그램입니다. 

예를 들어, 어떠한 사용자가 로그인을 하려고 할 때. 사용자는 아이디와 비밀번호를 입력하고, 로그인 버튼을 누릅니다. 

그때 서버는 클라이언트의 아이디와 비밀번호를 확인하고, 다음 페이지를 띄워주어야 하는데, 이러한 역할을 수행하는 

것이 바로 서블릿(Servlet)입니다. 그래서 서블릿은 자바로 구현 된 *CGI라고 흔히 말합니다.

C로 구현한 스택

#include<stdio.h>
#include<string.h>
 
#define TRUE 1            //1반환 
#define FALSE 0           //0반환 
#define MINUS -1          //-1반환 
#define MAX_SIZE 10000    //스택 배열 사이즈 
 
typedef struct _stack{    //스택 구조체. 
    int arr[MAX_SIZE];
    int top;
} Stack;
 
void StackInit(Stack * sp){    //스택 초기화 함수 
    sp->top = -1;
}
 
int IsEmpty(Stack * sp){    //스택이 비어있는지 확인 
    if(sp->top == -1) return TRUE;
        
    return FALSE;
}
 
int Size(Stack *sp){    //스택의 size 반환 
    return sp->top + 1;
}
 
 
int IsFull(Stack * sp){        //스택이 꽉 차있는지 확인 
    if(sp->top + 1 >= MAX_SIZE) return TRUE;
    
    return FALSE;
}
 
void Push(Stack * sp, int data){    //스택의 push 
    if(IsFull(sp)==TRUE) return;
    
    //top을 하나 올린 후 data 삽입
    sp->arr[++(sp->top)] = data;    
}
 
int Pop(Stack * sp){    //스택의 pop. 
    if(IsEmpty(sp) == TRUE) return MINUS;
 
    //top이 가리키는 값을 반환 후 top을 하나 내림.
    return sp->arr[(sp->top)--];
}
 
int Peek(Stack *sp){    //스택의 맨위의 인자를 반환합니다. 
    if(IsEmpty(sp) == TRUE) return MINUS;
    
    return sp->arr[sp->top];
}


int main(void){
    int i;
    char str[6];
    Stack stack;
    int n, num;
    
    scanf("%d", &n);
    fgetc(stdin);    //버퍼 비우기 
    StackInit(&stack);    //stack 초기화. 
    
    
    for(i=0; i<n; i++){
    
        scanf("%s", str);
        fgetc(stdin);    //버퍼 비우기. 
 
        if(!strcmp(str, "push")){    //push 인 경우 
            
            scanf("%d", &num);
            fgetc(stdin);    //버퍼 비우기. 
            Push(&stack, num);    
            
        }else if(!strcmp(str, "pop")){    //pop인 경우 
        
            printf("%d\n", Pop(&stack));
        
        }else if(!strcmp(str, "empty")){    //empty인경우 
            
            printf("%d\n", IsEmpty(&stack));
            
        }else if(!strcmp(str, "size")){        //size인 경우  
        
            printf("%d\n", Size(&stack));
        
        }else if(!strcmp(str, "top")){        //top인 경우 
        
            printf("%d\n", Peek(&stack));
        
        }
    }
    
    
    return 0;    
}

JAVA 로 구현한 스택

import java.util.Scanner;
import java.util.Stack;

public class p1 {

	public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        Stack<Integer> stack = new Stack<Integer>();
        for (int i = 0; i < n; i++) {
            String str = sc.nextLine();
 
            String instruction[] = str.split(" ");
 
            switch (instruction[0]) {
            case "push":
                stack.push(Integer.parseInt(instruction[1]));
                break;
 
            case "pop":
                if(stack.isEmpty()){
                    System.out.println(-1);
                }
                else{
                    System.out.println(stack.pop());
                }
                break;
 
            case "size":
 
                    System.out.println(stack.size());
                break;
 
            case "empty":
                if(stack.isEmpty()){
                    System.out.println(1);
                }
                else{
                    System.out.println(0);
                }
                break;
 
            case "top":
                if(stack.isEmpty()){
                    System.out.println(-1);
                }
                else{
                    System.out.println(stack.peek());
                }
                break;
 
            }
 
        }
	}
}

오늘은 자료구조은 스택(STACK)  에 대해서 알아보도록 하겠습니다.

스택이란 ? 사전적 의미로는 '쌓다'인데 말그대로 정말 쌓는것을 의미를 합니다. 바구니(공간)에 물건(데이터)을 쌓은뒤, 나중에 다시 물건을 뺴는 구조입니다. 

따라서 물건을 계속 쌓다가 나중에 처음에 넣은 물건을 빼려고 할때는, 마지막에 넣은 물건부터 차례차례 뺴야지 처음에 넣음 물건을 뺄 수 있겠죠? 이러한 방법이 자료구조에 '스택' 이라고 정의를 할 수 있습니다. 

그래서 스택의 구조는 먼저들어간 데이터는 나중에 나온다 => 선입후출 (First-In,Last-Out --> FILO)구조라고도 불립니다.

스택의 특징

(1) 삽입 (Push) : 그림과 같이 물건을 집어 넣는 것을 Push라 합니다. Push는 스택의 구조상 마지막 데이터 위치에 삽입이 됩니다. 나중에 코딩 할 때, 마지막 데이터 위치를 기억하기 위해 top이라는 변수를 만듭니다. 삽입을 한다면 top은 +1이 되겠죠?

(2) 삭제 (Pop) : Push와 반대로 물건을 빼는 것을 Pop이라 합니다. Pop도 Push와 마찬가지로 마지막 데이터 위치에서 삭제가 됩니다. Pop을 하게 된다면 top의 위치는 -1이 됩니다. 

(3) 읽기 (Peek) : 마지막 위치(top)에 해당하는 데이터를 읽습니다. 이 때, top의 변화는 없습니다.

이러한 자료구조의 스택을 구현을 할때, JAVA같은 경우는 java.util.stack이 구현이 되어 있어서 쓰기 편하지만.. 그래도 본인이 직접 스택을 구현을 해보는 것이 좋겠죠? ㅎㅎ

알고리즘 카테고리에 C로 구현한 스택과 JAVA로 구현한 스택을 공유 하도록 하겠습니다~

안뇽하세요 ㅎ 이번시간에는 Map 컬렉션에 대해서 알아보도록 하겠습니다.

Map 컬렉션은 앞서 소개한 List 컬렉션과 Set 컬렉션과는 또 다른 기능이 숨겨져 있습니다.

Map 컬렉션은 키(Key)와 값(Value)로 구성된 Entry객체를 저장하는 구조로서 하나의 키에 값이 저장이 되어 있습니다. 또한 Map 컬렉션의 특징으로는 키의 값이 중복저장이 안된다는 특징이 있습니다.

Map 컬렉션의 대표적인 클레스로는 HashMap, HashTable, TreeMap, Property가 있지만, TreeMap같은경우는 다음 포스팅떄 따로 TreeSet과 함께 포스팅을 하도록 하겠습니다.

* HashMap

HashMap의 특직으로는 앞서 포스팅한 HashSet의 특징과 같습니다. 다만 HashMap에서 equals()와 hashCode()를 Override를 할 경우에는 HashMap의 Key값을 가지고 비교를 하게 됩니다.

그렇다면 HashMap을 통한 소스코드를 보겠습니다.

public class HashMapExample {
	public static void main(String[] args) {
		Map<String,Integer> map = new HashMap<String,Integer>();
		
		map.put("지승훈", 90);
		map.put("지자바", 85);
		map.put("지가나", 70);
		map.put("지코인", 90);
		map.put("지이더", 80);
		map.put("지하라", 65);
		System.out.println("총 Entry 개수 : " + map.size());
		
		//1번쨰 방법
		Set<String> set = map.keySet();
		Iterator<String> iterator = set.iterator();
		while(iterator.hasNext()){
			String key = iterator.next();
			int value = map.get(key);
			System.out.println("key : " + key + ", value : " + value);
		}
		System.out.println();
		
		//2번쨰 방법
		Set<Map.Entry<String, Integer>> set2 = map.entrySet();
		Iterator<Map.Entry<String, Integer>> iterator2 = set2.iterator();
		while(iterator2.hasNext()){
			Map.Entry<String, Integer> entry = iterator2.next();
			String key = entry.getKey();
			int value = entry.getValue();
			System.out.println("key : " + key + ", value : " + value);
		}
	}
}

HashMap에서도 마찬가지로 객체를 가져와야 할경우에는 Iterator를 씁니다. 따라서 Iterator를 통하여 값을 처리를 하는 경우가 2가지가 있습니다. 첫번째로는 HashMap의 key값을 Set타입으로 받은 다음, 그 Set을 이용을 하여서 Iterator에 접목을 시키고 나머지는 Set에 저장되어 있는 Key값을 이용해 mapping을 하여 Key값에 대한 데이터를 처리를 합니다. 

두번째 방법으로는 첫번째 방법과 비슷한데, Map(Key,value) 전체 (즉, Entry)를 가져와서 Iterator를 처리를 하는 방법입니다.

* HashTable

HashTable 같은경우는 HashMap과 동일한 구조를 가지고 있습니다. 다만 차이점이 있다면 HashTable은 동기화(synchronized) 메소드로 구성되어 있기 떄문에, 멀티스레드 환경에서 데이터 처리를 안전하게 할수 있습니다.(Thread Safe)

이번시간은 Set 컬렉션에 대해서 다뤄보도록 하겠습니다.ㅎㅎ

Set 컬렉션은 앞서 List 컬렉션과는 다르게 index로 관리되어지는 것이 아니라서 저장순서가 유지되어 지지 않습니다. 마치 하나의 주머니안에 데이터(객체)를 담는거라고 생각하시면 좋을꺼 같습니다 ㅎ

Set 컬렉션의 특징은 앞서 소개한 바로 순서가 보장되지 않고, 중복 저장이 되지 않는 것이 특징입니다.

따라서 Set 인터페이스의 메소드들은 기존의 List 인터페이스를 구현한 메소드들 중에서 인덱스와 관련된것은 뺴고 모두 동일하다고 생각하시면 됩니다.

Set 인터페이스를 구현한 대표적인 클레스로는 HashSet, TreeSet이 있습니다. 먼저 이 포스팅에서는 HashSet에서만 다루겠습니다. TreeSet같은경우에는 다음 포스팅에 나올 TreeMap과 함꼐 다루도록 하겠습니다. 

* HashSet

HashSet클레스 같은경우는 객체를 순서없이 저장을하고, 동일한 객체는 저장을 하지 않는 부분에 있어서 Set 인터페이스를 구현한 클레스 입니다.

HashSet 클레스는 객체를 저장을 하기전에 먼저 HashCode()를 통해서 해시코드를 얻어내고, 그 해시코드의 값을 가지고 동일한 객체가 저장이 되어 있는지 없는지에 대해서 조사를 하게 됩니다. 만약 동일한 해쉬코드가 나오면 다시 equals()를 통해서 한번더 점검을 한 후, 저장을 할지 말지에 대한 결정을 하게 됩니다.

HashCode()와, equals()메소드의 부분은 제 블로그에 나와 있으니 한번 참고를 해보시면 좋을꺼 같네요^^

그렇다면, 순서도 없이 저장된 객체를 어떻게 꺼내서 처리를 할 수 있을까요? 

결론부터 말하면 Set 인터페이스의 iterator() 라는 메소드 즉 반복자를 통해서 이용을 할 수 있습니다.  그럼 Iterrator 인터페이스를 보도록 하겠습니다.

public interface Iterator<E> {
    /**
     * Returns {@code true} if the iteration has more elements.
     * (In other words, returns {@code true} if {@link #next} would
     * return an element rather than throwing an exception.)
     *
     * @return {@code true} if the iteration has more elements
     */
    boolean hasNext();

    /**
     * Returns the next element in the iteration.
     *
     * @return the next element in the iteration
     * @throws NoSuchElementException if the iteration has no more elements
     */
    E next();

    /**
     * Removes from the underlying collection the last element returned
     * by this iterator (optional operation).  This method can be called
     * only once per call to {@link #next}.  The behavior of an iterator
     * is unspecified if the underlying collection is modified while the
     * iteration is in progress in any way other than by calling this
     * method.
     *
     * @implSpec
     * The default implementation throws an instance of
     * {@link UnsupportedOperationException} and performs no other action.
     *
     * @throws UnsupportedOperationException if the {@code remove}
     *         operation is not supported by this iterator
     *
     * @throws IllegalStateException if the {@code next} method has not
     *         yet been called, or the {@code remove} method has already
     *         been called after the last call to the {@code next}
     *         method
     */
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    /**
     * Performs the given action for each remaining element until all elements
     * have been processed or the action throws an exception.  Actions are
     * performed in the order of iteration, if that order is specified.
     * Exceptions thrown by the action are relayed to the caller.
     *
     * @implSpec
     * <p>The default implementation behaves as if:
     * <pre>{@code
     *     while (hasNext())
     *         action.accept(next());
     * }</pre>
     *
     * @param action The action to be performed for each element
     * @throws NullPointerException if the specified action is null
     * @since 1.8
     */
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

이제 Iterator를 통해서 HashSet 클레스의 객체를 처리해보도록 하겠습니다.

public class Member {
	private String name;
	private int age;
	
	public Member(String name, int age){
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	@Override
	public int hashCode() {
		return name.hashCode() + age;
	}
	
	@Override
	public boolean equals(Object obj) {
		if(obj instanceof Member){
			Member member = (Member)obj;
			return (member.name.equals(this.name))&&(member.age==this.age);		
		}else{
			return false;
		}
	}
	
	@Override
	public String toString() {
		return name + " : " + age;
	}
}

public class HashSetExample {

	public static void main(String[] args) {
	
		Set<String> StringSet = new HashSet<String>();
		
		StringSet.add("지승훈");
		StringSet.add("홍길동");
		StringSet.add("지자바");
		StringSet.add("지후니");
			
		
		Iterator<String> iterator = StringSet.iterator();
		
		System.out.println("Set Size : " + StringSet.size());
		while(iterator.hasNext()){
			System.out.println(iterator.next().toString());
		}
		
		Set<Member> member = new HashSet<Member>();
		
		
		member.add(new Member("지승훈",27));
		member.add(new Member("홍길동",30));
		
		Iterator<Member> iterator2 = member.iterator();
		
		while(iterator2.hasNext()){
			System.out.println(iterator2.next().toString());
		}
	}

}

오늘은 컬렉션 프레임워크 중에서 List 컬렉션에 대해서 알아보도록 하겠습니다.

List 컬렉션은 객체를 일렬로 늘어 놓은 구조로써, 객체를 인덱스로 관리를 하기 떄문에, 객체를 저장하면 자동으로 인덱스를 부여 하게 됩니다. 또한 리스트 컬렉션은 객체 자체를 저장하는 것이 아니라 객체의 참조 번지를 저장함으로써 힙영역에 객체를 가르키게 됩니다.

List 컬렉션의 특징으로는 앞서 컬렉션 프레임워크를 설명했을 때 처럼 순서를 유지하고 저장, 중복저장 가능하기 떄문에 같은 객체를 저장하게 되면 인덱스의 참조 번지는 같은 객체를 가르키게 되어 있고, null을 저장을 할 경우에는 인덱스에 있는 객체 참조 번지가 아무것도 가르키지 않게 됩니다.

* ArrayList

ArrayList 클레스에 객체를 저장을 하게 되면, 인덱스로 관리를 하게 됩니다. 일반 배열과 공통점은 인덱스로 관리한다는 점이지만, 배열과 ArrayList는 아주 큰 차이점이 있습니다.

바로 객체를 담을 크기가 유동적이라는 것입니다.!!

public class ArrayListExample {
   
	public static void main(String[] args) throws Exception {
		List<String> lists = new ArrayList<String>();
		
		
		//String 객체를 저장
		lists.add("java");
		lists.add("JDBC");
		lists.add("servlet/jsp");
		lists.add(2,"database");
		lists.add("ibaties");
		lists.set(4, "MyBatis");
		
		for(String list : lists){
			System.out.println(list.toString());
		}
		System.out.println();
		
		System.out.println("java라는 단어 있나요? " + lists.contains("java"));
		for(int i = 0; i<lists.size();i++){
			System.out.println(lists.get(i));
		}
		System.out.println();
		
		lists.remove(0);
		lists.remove("MyBatis");
		if(!lists.isEmpty()){
			lists.clear();
		}
		
		System.out.println("size : " + lists.size());
		
	}
}

ArrayList는 객체의 저장용량(capacity)을 default로는 10으로 설정이 되어 있다. 하지만 이 저장 용량을 초과하여 객체를 추가로 저장하게되면 자동적으로 값이 증가를 한다. 그렇다고 해서 다시 객체를 삭제를 한다고 해서 저장용량(capacity)이 줄어들지는 않는다.

public class ArrayListExample {
	 
    static int findCapacity(List<String> al) throws Exception {
        Field field = ArrayList.class.getDeclaredField("elementData");
        field.setAccessible(true);
        return ((Object[]) field.get(al)).length;
    }
   
	public static void main(String[] args) throws Exception {
		List<String> list = new ArrayList<String>();
		
		for(int i=0;i<100;i++){
			list.add(i+"");
			System.out.println("list_size : " + list.size() + ", list_ capacity : " + findCapacity(list));
		}
		
		System.out.println();
		
		for(int i=0;i<100;i++){
			list.remove(0);
			System.out.println("list_size : " + list.size() + ", list_ capacity : " + findCapacity(list));
		}
		
	}
}

* Vector

Vector클레스는 ArrayList 클레스의 구조와 비슷하지만 이 둘의 차이점은 멀티스레드의 환경에서 데이터를 처리를 하는지 입니다.. Vector클레스는 동기화된(synchronized)  메소드로 구성이 되어 있습니다. 따라서 멀티 스레드 환경에서 동시에 이 메소드를 접근을 할 수 없도록 구성 되어 있으며, 이를 스레드 안전 (Thread safe)라고 합니다

* LinkedList

linkedList 같은경우는 ArrayList와 사용 방법이 같습니다. 하지만 안의 내부구조가 다릅니다. ArrayList같은경우는 index에 의해서 관리가 되어 진다고 하면, LinkedList 같은경우는 인접해있는 노드를 연결해서 체인처럼 연결이 되어 있습니다. 따라서 중간의 데이터를 제거 하고싶다면 중간의 양쪽노드를 서로 이어주면 자동적으로 중간의 데이터는 없어지게 되는 것입니다.

예를 들어서 A->B->C 이렇게 연결이 되어 있을떄, B를 제거 하고싶으면 A에 연결되어있는 참조를 B가아닌 C로 이동을하여 A->C로 만들어주면 되겠죠? 

* ArrayList vs LinkedList

그렇다면 ArrayList와 LinkedList의 차이점은 무엇일까요? 둘은 쓰이는 곳이 다릅니다. 예를들어 수만개의 데이터가 있는데, 중간의 데이터를 추가하고 삭제하게되면 ArrayList값은 찾아서 데이터를 추가 삭제하고 그 다음칸에 있는 데이터는 한칸씩 뒤로 물러나게(index증가)됩니다. 그런데 이런 작업을 많이 하게되면 성능 저하의 원인이 되겠죠? 따라서 이런 작업이 많을 경우에는 LinkedList를 이용하는것이 좋습니다. 또한 검색/순차적으로 삭제&추가를 할 경우에는 ArrayList가 성능이 좋습니다.

정리 하자면, 

오늘은 컬렉션의 List 컬렉션 에 대해서 알아보도록 하겠습니다.

먼저 Collection이란?

많은 응용프로그램을 개발을 하다보면, 수많은 데이터를 처리(추가, 삭제 검색..등등) 하게 됩니다.

하지만 이러한 처리에 대해서 어떻게 하면 가장 효율적으로 할수 있을까? 라는 생각으로 접근을 할 수 있습니다. 데이터를 가장 간단하게 처리하는 방법이 무엇이 있을까여? 바로 "배열" 입니다. 데이터를 담을 공간을 어느정도 담을지 선언을 하고, 처리를한다. 무척 간단하죠? ㅋㅋㅋ

근데 배열은 많은 문제점이 있습니다. 일단 데이터를 얼마나 처리를 할지에 대한 불문명함과 또한 그런거를 모르고 아주 크게 데이터 공간을 선언을하면, 불필요한 공간이 남게 됩니다. 그리고 어떠한 인덱스 자리에 데이터를 삭제를 하게되면..그 공간은 비어있게 되는 것이지요.. 이러한 많은 문제점등이 있기 떄문에.. JAVA에서는 배열의 문제점을 해결하고 자료구조(Data Structure)를 바탕으로 컬렉션 프레임워크(Collection FrameWork)를 만들었습니다.

그렇다면,, JAVA 컬렉션에는 어떠한 것들이 있는지 살펴보도록 하겠습니다.

 * JAVA Collection FrameWork 주요 인터페이스 및 클레스

LinkedList, Stack, Vector, ArrayList 는 List인터페이스를 구현한 클레스들이고, HashSet, TreeSet은 Set인터페이스를, 그리고 HashTable, HashMap, TreeMap, Property 는 Map 인터페이스를 구현한 클레스 입니다.

 * JAVA Collection FrameWork 주요 인터페이스의 특징