StudyServer
web, server, java, spring 등.. 공부한 것을 기록하는 장소 입니다. 공부하면서 정리하였기 때문에 틀린 내용이 있을 수 있습니다. 이야기 해주시면 수정하겠습니다.
HOME /About /algorithmus /db /front /git /java /ml /search /server /spring

junit

2018-11-20 00:00:00 +0000

TDD( Test Driven Development )

  • 테스트 주도 개발
  • JUnit은 단위 테스트를 도와주는 프레임워크

JUnit

  • JUnit test case 파일을 생성한다
  • class under test에 테스트할 함수를 찾아서 넣어준다
  • assertEquals 로 내가 원하는 값이 알맞게 나오는지 확인한다
  • 값이 정상이면 초록색, 비정상이면 붉은색 바가 뜬다

JUnit 테스트 함수

  • assertEquals : 결과값이 예상결과와 같은지 체크
  • assertTrue : 예상값이 true인지 체크(true여야 성공, 아니면 실패)
  • assertFalse : 예상값이 false인지 체크
  • assertNull : 예상값이 NULL인지 체크
  • assertNotNull : 예상값이 NULL이 아닌지 체크
  • assertSame : 두 객체가 동일한 객체인지 체크
  • assertNotSame : 두 객체가 동일한 객체가 아닌지 체크

Main.java

package testtdd;
public class Main {
     
     public int Add(int value1, int value2){
           return value1+value2;
     }
}

TddTest.java

import static org.junit.Assert.*;
import org.junit.Test;
public class TddTest {
     @Test
     public void test() {
           Main m = new Main();
           assertEquals(4, m.Add(1, 3));
     }
}

json

2018-11-20 00:00:00 +0000

JSON(JavaScript Object Nation)

  • XML 같은 테이터 표현 방법
  • name과 value의 값으로 구성
  • 이기종간의 데이터 전달을 위해서 사용
  • XML보다 JSON이 크기가 적다(XML태그가 없어서)
  • 사람이 읽고 쓰기에 용이하다
  • 개발 언어와 OS에 구애 받지 않는다
  • 사용예제 {“name” : “google”, “url”:”www.google.com”}

json 라이브러리 세팅

  • commons-beanutils.jar
  • commons-collections-3.2
  • commons-lang-2.4
  • commons-logging-1.1
  • ezmorph-1.0.6
  • json_simple-1.1
  • json-lib-2.3-jdk13

Source

  • 객체 ->JSON , JSON -> 객체로 변환

JsonExam.java


import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;


public class JsonExam {

    // JSONObject => json code
    // {"name" : "홍길동", "address" : "가산동", "age":20}
    public JSONObject creatJsonObject(){
        JSONObject obj = new JSONObject();
        obj.put("name", "홍길동");
        obj.put("address", "가산동");
        obj.put("age", 20);
        
        return obj;
    }
    
    public JSONObject creatJsonObject2(){
        JSONObject obj2 = new JSONObject();
        obj2.put("name", "좌길동");
        obj2.put("address", "강남");
        obj2.put("age", 40);
        
        return obj2;
    }
    
    public static void main(String[] args){
        // 일반코드->json 객체로
        JsonExam exam = new JsonExam();
        JSONObject obj = exam.creatJsonObject();
        JSONObject obj2 = exam.creatJsonObject();
        //System.out.println("result:"+obj.toJSONString());
        //System.out.println("result:"+obj2.toJSONString());
    
        // json 데이터를 배열에 담는다
        JSONArray ja = new JSONArray();
        ja.add(obj);
        ja.add(obj2);
        
        // JSONArray => json code
        System.out.println(ja.toJSONString());
        
        // List => json code 변환 [{"key:",value},{"key":value}]
        List<Member> list = new ArrayList<>();
        list.add(new Member("홍길동", "가산동", 20));
        list.add(new Member("동길이", "구로동", 40));
        System.out.println(net.sf.json.JSONArray.fromObject(list).toString());
        
        // Json 데이터 -> String
        String jsonCode = net.sf.json.JSONArray.fromObject(list).toString();    // list객체를 json으로 변환
        JSONParser parser = new JSONParser();
        Object re = null;
        
        try{
            re = parser.parse(jsonCode);// json 코드를 파싱하겠다
        }catch(Exception e){
            e.printStackTrace();
        }
        
        if(re instanceof JSONArray){
            JSONArray array = (JSONArray)re;
            Iterator iter = array.iterator();
            List<Member> list2 = new ArrayList<>();
            
            while(iter.hasNext()){
                JSONObject jo = (JSONObject)iter.next();
                String name = (String)jo.get("name");
                String address = (String)jo.get("address");
                int age = ((Long)jo.get("age")).intValue();
                
                //int age2 = (int)jo.get("age"); java.lang.Long cannot be cast to java.lang.Integer 에러난다
                //System.out.println("age:"+age2);
                
                list2.add(new Member(name, address, age));
            }
            
            System.out.println(list2);
        }
    }
}

Member.java

public class Member {
     private String  name;
     private String  address;
     private int     age;
     
     public Member(){}
     public Member(String name, String address, int age) {
           super();
           this.name = name;
           this.address = address;
           this.age = age;
     }
     public String getName() {
           return name;
     }
     public void setName(String name) {
           this.name = name;
     }
     public String getAddress() {
           return address;
     }
     public void setAddress(String address) {
           this.address = address;
     }
     public int getAge() {
           return age;
     }
     public void setAge(int age) {
           this.age = age;
     }
     @Override
     public String toString() {
           return "Member [name=" + name + ", address=" + address  + ", age=" + age + "]";
     }
}

algorithmus basic

2018-11-20 00:00:00 +0000

알고리즘 1>

고전게임을 잘하기로 소문난 두 형제 종현이와 종원이는 요새 갤러그라는 게임에
푹 빠져 있다. 현재 종현이와 종원이의 점수는 각각 A점과 B점이고, 종현이의 점수는
A는 종원이의 점수 B보다 높거나 같다. 조현이는 매주 점수가 2배씩 상승하지만,
노력파인 종원이는 종현이를 이기기 위해 쉬지 않고 연습한 결과 매일 점수가 3배씩
상승하는 능력을 갖추었다.
이때 며칠이 지나야 종원이가 종현이의 점수보다 높아질 수 있을까?

[입력]
첫 번째 줄에 테스트케이스의 수 T(1<= T<=50)가 주어진다.
각 테스트케이스마다 최초 종현이의 점수 A와 종원이의 점수 B가 각각 공백을 두고
주어진다. 단 최초 종현이의 점수 A는 종원잉의 점수 B보다 크거나 같으면 1점
이상 5천점 이하의 점수이다. (A>=B, 1<=B<=5000)

[출력]
각 줄마다 “#T”(T는 테스트케이스 번호)를 출력한 뒤, 종원이의 점수가 종현이의 점수를
추월하게 되는데 필요한 일수를 출력한다.

[sample input]
4
7 1
8 3
4 4
4500 2

[sample output]
#1 5
#2 3
#3 1
#4 20

Soruce


package kosta.algorithm;

import java.util.Scanner;

public class Algo1 {
	
	public static long GetDay(long a, long b){
		
		long day = 1;
		while(true){
			a *= 2;
			b *= 3;
		
			if(a < b) 
				break;
			
			++day;
		}
		
		return day;
	}
	
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);	
		int whileCount = (sc.nextInt())*2;
		int[] arr = new int[whileCount];
		
		for(int i = 0 ; i < whileCount; i+=2){
			arr[i] = sc.nextInt();
			arr[i+1] = sc.nextInt();
		}
		
		int count = 1;
		for(int i = 0; i < whileCount; i+=2, ++count){
			long result = GetDay(arr[i], arr[i+1]);
			System.out.println("#"+count+" "+result);
		}
	}

}

circular queue(원형큐)

2018-11-19 00:00:00 +0000

원형 큐 (Circular Queue)

  • Queue란 먼저 들어간 데이터가 먼저 나가는 선입선출 자료구조이다
  • Queue는 데이터가 들어오면 사용할 수 있는 데이터 공간이 줄어들게 된다
  • Queue의 데이터를 앞으로 당기는 것도 데이터 양에 비례해 시간이 걸린다
  • Circular Queue란 원형 큐의 단점을 보완해 마지막 배열과 첫번째 인덱스가 붙어져 원형으로 사용되는 것을 말한다
  • 첫번째 배열이 비어있다면 값을 배열 끝까지 써도 다시 첫번째 배열에 돌아와 값을 넣는다

Source

CircularQueue.java

public class CircularQueue {
       private final int max;            // 큐의 용량
       private int front;                // 첫 번째 요소 커서
       private int rear;                 // 마지막 요소 커서, max랑 만나면 0으로  돌아가기
       private int num;                  // 현재 데이터 수
       private int[] que;                // 큐 본체
       
       public CircularQueue(final int max) {
              this.max = max;
              que = new int[max];
              front = rear = num = 0;
       }
       
       public final int enque(final int value) {
              if(true == isFull())
                     return -1;
              que[rear++] = value;                            // 맨 첫번째 값을  저장한 후 rear은 다음을 가르킨다
              rear %= max;                                           // 나머지  계산하면 0~max-1 값이 나온다
              ++num;
              
              return value;
       }
       
       public final int deque() {
              if(true == isEmpty())
                     return -1;
              
              int value = que[front++];
              front %= max;
              --num;
              
              return value;
       }
       
       public final boolean print() {
              if(true == isEmpty())
                     return false;
              
              for(int i = 0; i < num; ++i)                           // num만큼  queue에 저장된 값을 출력한다
                     System.out.println("["+(front+i)%max+"]:"+que[(front+i)%max]);
              
              return true;
       }
       
       private final boolean isFull() {
              return max <= num ? true : false;
       }
       
       private final boolean isEmpty() {
              return 0 >= num ? true : false;
       }
}

Main.java

import java.util.Scanner;
public class Main {
       public static void main(String[] args) {
              Scanner sc = new Scanner(System.in);
              CircularQueue circularQueue = new CircularQueue(10);
              int value = 0;
              try {
                     while(value != 4) {
                           System.out.println("1.enque 2.deque 3.print 4.exit");
                           value = sc.nextInt();
                           switch(value) {
                           case 1:
                                  System.out.println("input value:");
                                  int input = sc.nextInt();
                                  if(-1 == circularQueue.enque(input))
                                         System.out.println("queue pull");
                                  break;
                           case 2:
                                  int deque = circularQueue.deque();
                                  if(-1 == deque)
                                         System.out.println("queue empty");
                                  else
                                         System.out.println("deque:"+deque);
                                  break;
                           case 3:
                                  circularQueue.print();
                                  break;
                           }
                     
                     }
              }catch(Exception e) {
                     System.out.println(e.getLocalizedMessage());
              }
              
              System.out.println("종료");
       }
}

binary search(이진탐색)

2018-11-19 00:00:00 +0000

이진탐색

  • 오름차순으로 정렬되어있는 배열에 임의의 중간값을 정한다.
  • 찾는 값이 임의의 중간값보다 작으면 큰 쪽(오른쪽) 영역을 탐색에서 제외한다
  • 찾는 값이 임의의 중간값보다 크면 작은 쪽(왼쪽) 영역을 탐색에서 제외한다
  • 탐색 영역 왼쪽, 오른쪽 key가 서로 만날 때 까지 반복한다

source

public class Main {
       // 배열, 찾는 값, 크기
       static int search(final int[] arr, final int searchValue, final int size) {
              int lp = 0; // left pivot
              int rp = size - 1; // right pivot
              while (rp >= lp) {// lp, rp가 만날 때 까지 반복한다
                                         
                     int key = (lp + rp) / 2;   // 중간 값을 구한다 이를 key라고  한다
                     if (searchValue == arr[key])
                           return key;
                     if (arr[key] < searchValue) // key값 보다 찾는 값이 크다면 왼쪽  범위를 삭제한다
                           lp = key + 1;
                     else                        // key값 보다 찾는  값이 작다면 오른쪽 범위를 삭제한다
                           rp = key - 1;
              
              }
              return -1;
       }
       public static void main(String[] args) {
              int[] arr = { 1, 2, 5, 6, 7, 8, 10, 11, 20, 31 }; // 오름차순 정렬되어있는 배열만 이진 탐색을 할 수 있다 
              int searchNum = 0;                                   // 찾을 값을 넣는다
              System.out.println(searchNum + "은 " + search(arr, searchNum,  arr.length) + "인덱스에 있습니다");
       }
}

Posts

subscribe via RSS