공부해서 남주자

[Java] JDK, JRE

맛간동자 — Sat, 27 Feb 2021 20:30:26 +0900

JDK
- Java Devlopment Kit의 약자
- 자바 컴파일 및 패키징에 필요한 도구
- JRE + 개발도구
JRE
- Java Runtime Enviroment의 약자
- 자바 바이트 코드를 실행 할 수 있는 런타임 환경

쉽게 예로 든다면 Java로 만들어진 특정 프로그램을 실행하기 위해서는 JRE만 설치하면 되고 그 특정 프로그램을 개발하기 위해서는 JDK가 필요하다.

[Java] 빌더패턴 Builder Pattern

맛간동자 — Sat, 5 Nov 2016 23:04:28 +0900

빌더패턴

필드가 많은 객체를 생성할 경우 생성자를 이용하면 다루기 어렵고 헷갈릴 수 있다.

public class Pet {
    private final Animal animal;
    private final String petName;
    private final String ownerName;
    private final String address;
    private final String telephone;
    private final String emailAddress; //선택사항
    private final Date dateOfBirth; //선택사항
}

Pet 객체를 만들려면 필요한 모든 필드와 조합할 수 있는 옵션 필드를 포함하도록 매개변수를 갖는 생성자가 4개 이상 필요하다.

여기에 더 많은 옵션이 생긴다면 관리하기가 무척 어려워 질 것이다.

해결 방법 1 - 자바빈즈 패턴

final 키워드를 제거하고 Setter를 사용할 수 있다. 단 유효하지 않은 Pet 객체를 생성할 수 있다는 점에 주의해야 한다.

final Pet p = new Pet();
p.setEmailAddress("test@test.com");

해결 방법 2 - 빌더 패턴

빌더 패턴은 원하는 객체를 바로 생성하는 대신 클라이언트는 모든 필수 매개변수를 갖는 생성자(또는 static 팩토리 메소드)를 호출하여 빌더 객체를 얻고 그 다음에 빌더 객체의 세터 메소드를 호출하여 필요한 선택 매개변수들의 값을 설정해주는 방식이다.

public class Pet {
    public static class Builder {
        private String animal;
        private String petName;
        private String ownerName;
        private String address;
        private String telephone;
        private Date dateOfBirth; //선택사항
        private String emailAddress; //선택사항

        public Builder withAnimal(final String animal) {
            this.animal = animal;
            return this;
        }

        public Builder withPetName(final String petName) {
            this.petName = petName;
            return this;
        }

        public Builder withOwnerName(final String ownerName) {
            this.ownerName = ownerName;
            return this;
        }

        public Builder withAddress(final String address) {
            this.address = address;
            return this;
        }

        public Builder withEmailAddress(final String emailAddress) {
            this.emailAddress = emailAddress;
            return this;
        }

        public Builder withTelephone(final String telephone) {
            this.telephone = telephone;
            return this;
        }

        public Builder withDateOfBirth(final Date dateOfBirth) {
            this.dateOfBirth = dateOfBirth;
            return this;
        }

        public Builder BuilderwithEmailAddress(final String emailAddress) {
            this.emailAddress = emailAddress;
            return this;
        }

        public Pet build() {
            if (animal == null || petName == null || ownerName == null ||
                    address == null || telephone == null) {
                throw new IllegalStateException("Cannot create Pet");
            }

            return new Pet(animal, petName, ownerName, address,
                    telephone, dateOfBirth, emailAddress);
        }
    }

    private final String animal;
    private final String petName;
    private final String ownerName;
    private final String address;
    private final String telephone;
    private final Date dateOfBirth;
    private final String emailAddress;

    public Pet(String animal, String petName, String ownerName, String address,
               String telephone, Date dateOfBirth, String emailAddress) {
        this.animal = animal;
        this.petName = petName;
        this.ownerName = ownerName;
        this.address = address;
        this.telephone = telephone;
        this.dateOfBirth = dateOfBirth;
        this.emailAddress = emailAddress;
    }


}

Builder 클래스는 Pet 클래스의 일부이며 Pet 객체를 생성하는 전적인 권한이 있다.

생성자를 사용하면 어떤 매개변수를 사용할지를 매개변수의 순서가 결정했다.

하지만 빌더패턴을 사용함으로써 각 값을 정확히 어떻게 사용하는지 이해가 쉽고, 순서에 상관없이 호출하고 싶은 데로 호출할 수도 있다.

테스트 코드

@Test
public void legalBuild() {
    final Pet.Builder builder = new Pet.Builder();
    final Pet pet = builder
            .withAnimal("CAT")
            .withPetName("Squidge")
            .withOwnerName("Simon Smith")
            .withAddress("123 High Street")
            .withTelephone("07777777770")
            .withEmailAddress("test@email.com")
            .build();
}

@Test
public void illegalBuild() {
    final Pet.Builder builder = new Pet.Builder();
    final Pet pet = builder
            .withAnimal("DOG")
            .withPetName("Fido")
            .withOwnerName("Simon Simith")
            .build();
  
}

[Java] 자료구조

맛간동자 — Fri, 4 Nov 2016 21:33:10 +0900

리스트 - ArrayList와 LinkedList 일반적으로 사용

리스트 크기가 작아지면 메모리 용량이 작아지고 크기 지정에 한계가 없다.

배열과의 차이

@Test
public void arrayDefinitions() throws Exception {
    final int[] integers = new int[3];
    final boolean[] bools = {false, true, false, true};
    final String[] strings = new String[] {"one", "two"};

    final Random r = new Random();
    final String[] randomArrayLength = new String[r.nextInt(100)];

    assertEquals(true, bools[1]);
}

배열을 정의하기 위해서는 크기를 지정해야한다.

위 코드는 int 배열을 명시적으로 지정하였고 boolean은 암시적으로 지정하였다.

배열의 원소에는 인덱스 값을 사용하여 직접 접근할 수 있다. 이를 랜덤 접근이라고 한다.

배열이 메모리의 특정 위치에 직접 접근할 수 있으므로 빠르게 접근할 수 있다.

assertEquals(true, bools[1]);

bools의 두번째원소는 true인것을 확인할 수 있다.

배열 전체를 사용 중일 때 원소를 추가하려면 배열 크기를 늘려야 하는데 System클래스 객체의 arrayCopy라는 메소드를 사용해 복사 할 수 있게 된다.

@Test
public void arrayCopy() {
    int[] integers = {1, 2, 3, 4, 5};

    int[] newIntegers = new int[integers.length + 1];
    System.arraycopy(integers, 0, newIntegers, 0, integers.length);
    integers = newIntegers;
    integers[5] = 6;

    assertEquals(6, integers[5]);
}

ArrayList - 리스트의 데이터로 배열을 사용하는 List 인터페이스의 구현

크기를 지정하지 않으면 default값 10으로 생성된다.

배열의 시작 위치나 중간 위치에 새로운 원소를 추가해야한다면 그 뒤에있는 모든 원소는 공간을 만들기 위해 이동해야 한다. 배열의 크기가 클수록 연산량은 점점 늘어날 것이다.

만약 원소의 개수가 계속 변경이된다면 LinkedList 클래스로 배열을 생성하는 것이 더 적합할 수 있다.

LinkedList - 배열을 이용하지 않고 리스트 안에서 다음 원소를 가르키는 내부 객체를 이용

ArrayList클래스에서 배열 재할당 과정으로 인해 발생하는 손실을 막아준다.

public void linkedDefinitions() {
    LinkedList<Integer> linked = new LinkedList<Integer>();
    //데이터 추가
    linked.add(1);
    linked.add(2);
    linked.add(3);
    //데이터 삭제
    linked.remove(0);
    //데이터 갯수
    linked.size();
    System.out.print(linked);
}

큐(Quere)- First in First out 자료구조를 구현한 자바 인터페이스

3가지 메소드

add => 새 원소를 추가

remove => 오래된 원소를 제거

peek => 가장 오래된 원소를 반환

@Test
public void queueInsertion() {
    final Queue<String> queue = new LinkedList<String>();
    queue.add("first");
    queue.add("second");
    queue.add("third");

    assertEquals("first", queue.remove());
    assertEquals("second", queue.remove());
    assertEquals("third", queue.peek());
    assertEquals("third", queue.remove());
}

트리(Tree) - 부모-자식관계로 이루어지며 계층적 구조, 서로 다른 원소를 많이 나열할 수 있는 자료구조

기본 이진트리를 사용하며 각 원소는 최대 두개의 자식을 갖는다. 정확히 왼쪽과 오른쪽으로 구분한다.

Comparable 인터페이스 타입의 원소를 저장 할 수 있고 Comparator 인터페이스 타입을 이용할 수도 있다.

public class SimpleTree <E extends Comparable> {

    //노드값, 노드의 왼쪽, 노드의 오른쪽 정의
    private E value;
    private SimpleTree<E> left;
    private SimpleTree<E> right;
  public E getValue() {
      return value;
  }

  public SimpleTree<E> getLeft() {
      return left;
  }

  public SimpleTree<E> getRight() {
      return right;
  }
    /**
     *
     * @param toFind 값
     * @param left 왼쪽 노드
     * @param right 오른쪽 노드
     */
    public SimpleTree(E toFind, SimpleTree<E> left, SimpleTree<E> right) {
        this.value = toFind;
        this.left = left;
        this.right = right;
    }

    /**
     * 이진 검색 트리에서 값 찾기
     * @param toFind 찾고자 하는 노드
     * @return
     */
    public boolean search(final E toFind) {

        // 찾는 값이 같다
        if (toFind.equals(value)) {
            return true;
        }

        // 찾는 값이 현재 노드보다 작고 왼쪽 자식 노드가 null이 아니면 왼쪽 검색
        if (toFind.compareTo(value) < 0 && left != null) {
            return left.search(toFind);
        }

        //오른쪽노드가 null이 아니면 오른쪽 노드를 검색해 값을 반환한다.
        return right != null && right.search(toFind);
    }

    public void insert(final E toInsert) {

        // 음수이면 왼쪽에 삽입
        if (toInsert.compareTo(value) < 0) {
            if (left == null) {
                // 노드가 비어있을때
                left = new SimpleTree<E>(toInsert, null, null);
            } else {
                // 노드가 있을때
                left.insert(toInsert);
            }
        } else {
            // 0 이거나 양수이면 오른쪽에 삽입
            if (right == null) {
                // 노드가 비어있을때
                right = new SimpleTree<E>(toInsert, null, null);
            } else {
                // 노드가 있을때
                right.insert(toInsert);
            }
        }
    }
}

테스트 코드 작성

@Test
public void createTree() {
    final SimpleTree<Integer> root = new SimpleTree<Integer>(3, null, null);
    root.insert(5);
    root.insert(8);
    root.insert(10);

    assertTrue(root.search(3));
    assertEquals(Integer.valueOf(10), root.getRight().getRight().getRight().getValue());
}

맵 - 해시라고 하며, 키-값 형태의 저장소 키를 통해 원하는 값을 찾을 수 있음

@Test
public void overwriteKey() {
    final Map<String, String> preferences = new HashMap<String, String>();
    preferences.put("like", "jacuzzi");
    preferences.put("dislike", "steam room");

    assertEquals("jacuzzi", preferences.get("like"));

    //키를 다시 삽입하면 원본 키에 있던 값은 덮어씌운다
    preferences.put("like", "sauna");
    
    assertEquals("sauna", preferences.get("like"));
}

집합 - 중복을 허용하지 않는 순서 없는 객체들의 모음

@Test
public void setExample() {
    final Set<String> set = new HashSet<>();
    set.add("hello");
    set.add("welcome");
    set.add("goodbye");
    set.add("bye");
    set.add("hello");
    
    //중복을 허용하지 않기떄문에 사이즈는 4이다.
    assertEquals(4, set.size());
}

[Java] 이진탐색 Binary Search

맛간동자 — Fri, 4 Nov 2016 16:00:19 +0900

이진검색 - 데이터가 정렬되어있다는 전제하에 중간값을 계속 비교하면서 원하는 값을 찾는 방식

public void binarySearch(int num[], int find) {

    if (num.length == 1) return;
    int start = 0;
    int end = num.length - 1;
    boolean check = true;
    while(check && start <= end) {
        int center = (start + end) / 2;
        if (num[center] == find) {
            System.out.println("찾았습니다 : " + center + "번쨰 자리 위치");
            check = false;
        } else if (num[center] > find) {
            end = center - 1;
        } else {
            start = center + 1;
        }

    }
}

[Java] 합병정렬 Merge Sort

맛간동자 — Thu, 3 Nov 2016 00:07:08 +0900

합병정렬 - 배열을 두 부분으로 계속 나눈 뒤 다시 나눠진 배열을 비교해 나가면서 합치면서 정렬된다. 재귀적

시간복잡도 O(n log n)

각각의 병합 시간 O(n)

각 재귀 호출은 주어진 리스트 숫자의 절반만큼 발생

public void mergeSort(int num[], int length) {
    int center = length / 2;
    int leftNum[] = new int[center];
    int rightNum[] = new int[length - center];

    if (length == 1) return;


    //왼쪽배열
    for (int i = 0; i < center; i++) {
        leftNum[i] = num[i];
    }
    //오른쪽배열
    for (int i = 0; i < length - center; i++) {
        rightNum[i] = num[center + i];
    }
    //배열체크
    System.out.println("leftArray" + Arrays.toString(leftNum));
    System.out.println("rightArray" + Arrays.toString(rightNum));

    // 왼쪽 오른쪽 배열 나눔 재귀
    mergeSort(leftNum, leftNum.length);
    mergeSort(rightNum, leftNum.length);

    merge(leftNum, rightNum, num);

}

private void merge(int[] leftNum, int[] rightNum, int[] num) {
    int left = 0;
    int right = 0;
    int merge = 0;

    while (leftNum.length != left && rightNum.length != right) {
        if (leftNum[left] < rightNum[right]) {
            num[merge] = leftNum[left];
            merge++;
            left++;
        } else {
            num[merge] = rightNum[right];
            merge++;
            right++;
        }
    }

    while (leftNum.length != left) {
        num[merge] = leftNum[left];
        merge++;
        left++;
    }

    while (rightNum.length != right) {
        num[merge] = rightNum[right];
        merge++;
        right++;
    }

}

[Java] 퀵 정렬 Quick Sort

맛간동자 — Wed, 2 Nov 2016 22:31:57 +0900

퀵 정렬 - pivot 이라는 임시원소를 하나 설정하고 pivot에 의해 작은원소 큰 원소들로 정렬된다. 재귀적

pivot은 어떤걸 지정해도 상관이 없다. 밑의 코드는 중간에 위치한 원소를 pivot으로 지정하였다.

두개의 리스트로 분리하는 시간복잡도는 O(n) 이고

각각의 재귀 호출은 각 리스트 숫자의 절반만큼 발생한다

평균 복잡도 O(n log n)

최악의 경우 O(n^2)

public void sort(int num[], int start, int end) {

    if (start >= end) return;

    int left = start;
    int right = end;
    int pivot = num[(left + end) / 2];

    do {
        while (num[left] < pivot) left++;
        while (num[right] > pivot) right--;
       
        if (left <= right) {
            int temp = num[left];
            num[left] = num[right];
            num[right] = temp;
            System.out.println(Arrays.toString(num));
            left++;
            right--;
        }
    } while (left <= right);
    
    if (start < right) sort(num, start, right);
    if (end > left) sort(num, left, end);

}

[Java] 삽입정렬 Insertion Sort

맛간동자 — Sat, 29 Oct 2016 16:14:19 +0900

삽입정렬 - 현재 위치에서 그 이하의 배열들을 비교하여 자신이 들어갈 위치를 찾아 삽입하는 방법

최악의 경우 : 역순으로 정렬되어 있는 경우

평균 시간 복잡도 O(n^2)

1
2
3
4
5
6
7
8
9
10
11
12
public static void insertionSort(int[] numbers) {
        int i, j;
        for (i = 1; i < numbers.length; i++ ) {
            int tmp = numbers[i];
            for (j = i; j > 0; j--) {
                if (numbers[j-1] > tmp) {
                    numbers[j] = numbers[j-1];
                    numbers[j-1] = tmp;
                }
            }    
        }
}
Colored by Color Scripter
cs

중간에 원소를 삽입하면 그 뒤에 있는 모든 원소를 한칸씩 뒤로 이동시켜야 한다.

몇백만개의 원소가 있는 배열이라면 이런 부분은 큰 부담이다.

=>LinkedList를 사용

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static List<Integer> insertSort(final List<Integer> numbers) {
        final List<Integer> insertList = new LinkedList<>();
        
        original : for (Integer number : numbers) {
            for (int i = 0; i < insertList.size(); i++) {
                if (number < insertList.get(i)) {
                    insertList.add(i, number);
                    continue original;
                }
            }
            insertList.add(insertList.size(), number);
        }
        
        return insertList;
    }
Colored by Color Scripter
cs

[Java] 버블정렬 Bubble Sort

맛간동자 — Sat, 29 Oct 2016 13:59:15 +0900

버블 정렬 - 인정한 원소를 검사하여 정렬해나가는 방식

구현하기 간단하지만 비효율적

최선의 경우 : 자료가 이미 정렬되어 있는 경우

최악의 경우 : 역순으로 정렬되어 있는 경우

평균 시간 복잡도 O(n^2)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    public void bubbleSort(int[] numbers) {
        boolean check_switch;
        do {
            check_switch = false;
            for (int i = 0; i < numbers.length - 1; i++) {
                if (numbers[i] > numbers[i+1]) {
                    int tmp = numbers[i+1];
                    numbers[i+1] = numbers[i];
                    numbers[i] = tmp;
                    check_switch = true;
                }
            }    
        } while (check_switch);
    }
Colored by Color Scripter
cs

[Android] RecylerView Header와 Footer

맛간동자 — Fri, 28 Oct 2016 20:23:48 +0900


public class Job_Adapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {

    //1은 아이템 2는 푸터
    private static final int TYPE_ITEM = 1;
    private static final int TYPE_FOOTER = 2;
    private List<test> test_list;


    //생성자
    public Job_Adapter(Context context, List<test> objects) {
        this.context = context;
        this.test_list = objects;
    }

    //뷰 타입에따라 2가지를 인플레이트시킨다.
    @Override
    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        if (viewType == TYPE_FOOTER) {
            //푸터인 경우 
            View v = LayoutInflater.from(parent.getContext()).inflate(R.layout.recyclerview_footer, parent, false);
            Dlog.d("푸터");
            return new FooterViewHolder(v);
        } else if (viewType == TYPE_ITEM) {
            //아이템인 
            View v = LayoutInflater.from(parent.getContext()).inflate(R.layout.card_item_job, parent, false);
            Dlog.d("아이템");
            return new ViewHolder(v);
        }
        return null;
    }

    //여기서 뷰 셋팅
    @Override
    public void onBindViewHolder(RecyclerView.ViewHolder holder, final int position) {

        if (holder instanceof ViewHolder) {
        //뷰 타입이 아이템일 경우
            ViewHolder item_holder = (ViewHolder) holder;
        } else if (holder instanceof FooterViewHolder) {
        //뷰타입이 푸터 생성하기 버튼일 경우
            FooterViewHolder footerHolder = (FooterViewHolder) holder;
        }

    }

    //아이템 사이즈 +1 한다. 마지막에 푸터를 추가하기 위함이다.
    @Override
    public int getItemCount() {
        return test_list.size() + 1;
    }

    //뷰타입 정하기
    @Override
    public int getItemViewType(int position) {
        if (isPositionFooter(position)) {
            return TYPE_FOOTER;
        }
        return TYPE_ITEM;
    }

    //true가 반환되면 리스트의 끝임을 알수있다.
    private boolean isPositionFooter(int position) {
        int num = getSub2List.size();
        Dlog.d(String.valueOf(position) + "==" + String.valueOf(num));
        return position == getSub2List.size();
    }

    //푸터 뷰 홀더
    public class FooterViewHolder extends RecyclerView.ViewHolder {

        public FooterViewHolder(View itemView) {
            super(itemView);
        }

    }

    //아이템 뷰 홀더
    public class ViewHolder extends RecyclerView.ViewHolder {

        public ViewHolder(View itemView) {
            super(itemView);
        }

    }
}

참조 : http://takeoffandroid.com/android-customview/header-and-footer-layout-for-recylerview/

무료 백터 아이콘

맛간동자 — Fri, 28 Oct 2016 20:08:49 +0900

http://www.flaticon.com/

Flaticon, the largest database of free vector icons

Download all icons in SVG, PSD, PNG, EPS format or as webfonts