'D Blog'에 해당되는 글 15건

JAVA Collections(Set, List, Map)

배열은 크기가 수정할 수 없기 때문에 Collections Framework을 사용하여 배열의 불편함을 줄일 수 있다. 하지만 데이터의 사이즈가 변동하는 경우에만 Collection계통의 클래스를 사용하며, 그외에는 배열을 사용하는 것이 시간, 공간 모든면에서 효율적이다.

 * 일반적으로 배열 접근(element[i])은 ArrayList를 사용했을 때(elements.get(i))에 비해 10배 이상 빠르다고 한다. 대부분의 경우 유연성 문제 때문에 배열보다는 다른 컬렉션을 사용하고, 프로그램의 일부에서 성능이 중요한 경우 배열을 사용하는 것도 고려하는 것이 좋을 듯

Collection

오브젝트 집합을 나타내는 가장 기본적인 인터페이스이며, Set과 List가 상속을 받아 하위 클래스를 구현 한다. 따라서 Set과 List는 Collection이 가지고 있는 공통의 조작 방법을 가지고 있다.

[출처 : https://prashantgaurav1.files.wordpress.com/2013/12/java-util-collection.gif]

Set

Collection 인터페이스를 상속받으며, 순서와 중복이 없다. SortedSet은 순서는 있으나 중복이 없다.

HashSet : HashMap 인터페이스를 기본으로 Set인터페이스를 구현한 것. 순서를 보장할 수 없다. Set의 기능만 필요한 경우 사용

TreeSet : TreeMap 인터페이스를 기본으로 Set인터페이스를 구현한 것. 올림순으로 소트된다. 요소를 올림차순으로 정렬하는 경우 사용

LinkedHashSet : 삽입된 순서를 기억한다. 같은 요소를 다시 삽입하면 이전 순서를 그대로 기억한다. 요소의 삽입순서를 기억할 필요가 있을 때 사용

List

Collection 인터페이스를 상속받으며, 일부 함수를 재정의 했다. 순서가 있고 중복이 허용된다. 

Vector : JAVA 1.1 이하 버전에서 사용되였으며, 동기화 처리가 되기 때문에 다른 List에 비해 성능이 떨어진다. 현재는 구버전 호환용.

 * 동기화가 필요 할 때에는 Collections.synchronized 시리즈를 사용하는 것이 성능상 바람직 하다.

ArrayList : List 인터페이스 속성을 갖고 배열크기를 변경할 수 있다. 배열크기를 조작하는 메소드를 제공한다. 내부적으로 자료를 Array(배열)구조로 가지고 있는 객체. 데이터 추가, 삭제 시 내부적으로 임시배열을 작성 후 데이터를 복사하는 방법을 사용.

장점 : 각 데이터에 대한 인덱스를 가지고 있기 때문에 검색이 빠르다.

단점 : 대량의 데이터 추가, 삭제를 하는 경우에는 배열의 복사가 빈번하게 일어나 성능저하를 가져온다.

LinkedList : ArrayList처럼 인덱스를 가지고 있는 것이 아니라 자신 다음에 오는 자료의 위치정보만 가지고 있다.

장점 : 삽입, 삭제는 데이터의 위치정보만 가지고 할 수 있기 때문에 데이터가 많은 경우 유리하다.

단점 : 인덱스를 가지고 있는 것이 아니기 때문에 데이터가 많은 경우 처음부터 해당 데이터까지 순차적으로 찾기 때문에 속도가 느리다.

Iterator

 기본적인 Collection 인터페이스로 순차열람(iteration)을 지원한다. 어떤 변수를 Iterator로 선언하는 것은 그 변수가 여러 개의 값을 갖고 있음을 뜻한다.Set과 List에서 동작이 가능하며 기본적으로 Iterator 인터페이스에서 지원하는 세가지 메소드 (hasNext(), next(), remove())를 사용할 수 있다. 

import java.util.HashSet;

import java.util.Iterator;

public class 이터레이터 {

public static void main(String[] args) {

HashSet<Integer> A = new HashSet<Integer>();

A.add(3);

A.add(2);

A.add(1);

Iterator hi = A.iterator(); //<- 오름차순으로 정렬된 값들임

while(hi.hasNext()){

System.out.println(hi.next());

}

}

}

출력값 

1

2

3

 hi에 A의 iterator를 넣게되면 값들이 오름차순으로 정렬이 된 상태의 배열(?)이 생성이 되고, hasNext()함수로 내부에 값들이 있는지 확인가능하며, next()함수를 첫번째 값이 리턴이되며 iterator안의 꺼낸 값은 사라지게 된다. 위 코드에서는 hi에 있는 값들을 모두 꺼내왔기 때문에 hi안에는 값이 없는 빈 상태가 된다.

Map

키(key)와 값(value)의 쌍으로 저장이 된다.

HashMap : 동기화되어 있지않다는 것과 Null을 허용한다는 것 이외에는 HashTable과 같다. Map의 기능만 필요한 경우 사용

TreeMap  : Red-Black Tree. 키의 올림순으로 소트된다. 키를 오름차순으로 정렬할 필요가 있을 때 사용

LinkedHashMap : 키가 맵에 삽입된 순서를 기억한다. 같은 키로 삽입해도 이전의 순서를 기억한다. 키의 삽입 순서를 기억할 필요가 있을 때 사용

HashTable : Vector와 마찬가지로 동기화 되어있기 때문에 성능면에서 다른 것들에 비해 떨어진다.

[출처]

https://opentutorials.org/module/516/6446

http://mousevm.tistory.com/221 

http://java-school.net/java/Collection

http://pracon.tistory.com/107

http://egloos.zum.com/dojeun/v/317868

http://bestalign.github.io/2015/09/02/top-10-mistakes-java-developers-make-2/

http://seeit.kr/36

[참고]

https://docs.oracle.com/javase/7/docs/api/java/util/Collections.html

1. 절차적 프로그래밍과 비교

기존 절차적 프로그래밍에서는 데이터가 함수 사이를 통과하면서 차츰 순서대로 가공돼 나가는 방식으로 이해한다면 객체 지향 프로그래밍에서는 데이터를 중심으로 메서드가 데이터에 접근해서 수정한다는 개념이다.

2. 객체지향개발(OOP)의 특성
 1)캡슐화

  - 캡슐화의 목적은 코드를 재활용 하는 것에 있기 때문에 기능(함수)과 특성(변수)을 한곳으로 모으는 것을 말한다.

  - 객체가 맡은 역할을 수행하기 위해 한데 묶는 것이며, 데이터를 외부에서 직접 접근하는 것이 아니라 메소드를 통하여 접근할 수 있도록 해야하는데 이것을 정보의 은닉화 또는 캡슐화라고 한다. 

 2)상속

  - 상위의 기능(함수)과 특성(변수)을 그대로 이어받아 사용하는 것을 말하며, 상속받은 자식 클래스에서 그 기능만을 다시 정의하여 사용하는 것을 "덮어쓰기(재정의:Override)"라고 한다

 3)다형성

  - A a = new B(); 처럼 다른 데이터 타입으로 받는 것을 말하며, 부모 클래스에서 물려받은 가상 함수를 자식 클래스 내에서 오버라이딩 되어 사용되는 것이다.

B obj = new B()로 객체를 생성을 해야 하지만 B는 A를 상속 받고 있기 때문에 A를 데이터형으로 삼을 수 있다. 또한 A클래스의 멤버만을 사용할 수 있기 때문에 B클래스의 y메소드를 사용할 수 없으며, B클래스의 x메소드와 같이 오버라이딩하여 내용을 수정정하여 사용가능하다. 즉, 오버라이딩한 맴버의 동작방식은 그대로 유지된다.

 다형성을 쓰는 이유를 예시를 들자면

Calculator로 데이터 형을 같게 해서 하나의 execute메소드로 통일시켜 불필요한 메소드 생성을 줄일 수 있으며, run의 기능을 execute메소드로 묶을 수 있기에 추후 run과 같이 실행하거나 무언가를 조작하는 경우 일일이 고칠 필요 없이 execute메소드를 수정함으로써 유지보수에 용이하다.

 4)추상화

  - 공통된 속성이나 기능을 묶어서 이름 붙인 것을 말하며, 기능은 없고 이름만 정의해 놓은 것

출처

 - http://88240.tistory.com/228

 - https://namu.wiki/w/%EA%B0%9D%EC%B2%B4%20%EC%A7%80%ED%96%A5%20%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%B0%8D

 - https://opentutorials.org/module/516/6127

import java.util.Scanner;

public class Main {

static Scanner in = new Scanner(System.in);

public static void main(String[] args){

//케이스횟수

int caseN = in.nextInt();

//각 케이스별 값

boolean[] caseT = new boolean[caseN];

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

//배열크기 N

int n = in.nextInt();

//테스트 후 결과값 저장

caseT[i] = test(n);

}

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

System.out.println(caseT[i]? "YES":"NO");

}

}

public static boolean test(int n){

in.nextLine();

String[] ai = in.nextLine().split(" ");

int sum = 0; //총 합

int leftSum = 0; //왼쪽 합

boolean sumCheck = false;

int[] arr = new int[n];

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

arr[i] = Integer.parseInt(ai[i]);

sum += arr[i]; 

}

//n번 돌거나 양쪽의 합이 같은 값이 될때까지 수행

for(int i=0 ; i<n && !sumCheck; i++){

//총합-(왼쪽+자신)=오른쪽 값이기 때문에 같지 않다면 leftSum에 자신을 더한다

if(sum-(leftSum+arr[i]) != leftSum){

leftSum += arr[i];

}else{

//값이 같기에 값을 참값으로 바꾼다

sumCheck = true;

}

}

return sumCheck;

}

}

import java.util.HashSet;

import java.util.Scanner;

import java.util.Set;

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

String[] nk = in.nextLine().split(" ");

int n = Integer.parseInt(nk[0]);

int k = Integer.parseInt(nk[1]);

int count = 0;

String[] arrN = in.nextLine().split(" ");

// n개가 아닐때 정수를 다시 받음

while(arrN.length != n){

arrN = in.nextLine().split(" ");

}

//HashSet의 contains는 시간복잡도가 O(1)이기에 사용

Set<Integer> arr = new HashSet<Integer>();

// int형으로 변환하여 리스트에 넣음

for(String s : arrN){

arr.add(Integer.parseInt(s));

}

for(int i=0 ; i<arr.size() ; i++){

// i번째 숫자와 차가 k인  정수를 조회

if(arr.contains(Integer.parseInt(arrN[i])-k)){

System.out.println(Integer.parseInt(arrN[i]));

count++;

}

}

System.out.println(count);

}

}

import java.util.Scanner;

public class Main{

public static void main(String[] args){

Scanner in = new Scanner(System.in);

String[] a = in.nextLine().split(" ");

for(int i=0;i<a.length;i++){

System.out.print(Integer.parseInt(a[i])+1 +(i==a.length-1 ? "":" "));

}

}

}

import java.util.Arrays;

import java.util.Scanner;

public class Main {

public static void main(String[] args){

Scanner in = new Scanner(System.in);

String[] arr = in.nextLine().split(" ");

Arrays.sort(arr);

System.out.println(arr[0]);

}

}

import java.util.Scanner;

public class Main {

public static void main(String[] args){

Scanner in = new Scanner(System.in);

char[] a = in.next().toCharArray();

int b=0;

boolean t = true;

for(int i=0;i<a.length&&t;i++){

if('A'<=a[i] && a[i]<='Z'){

b=i;

t=false;

}

}

System.out.println(a[b]);

}

}

import java.util.Scanner;

public class Main {

public static void main(String[] args){

Scanner in = new Scanner(System.in);

String[] arr = in.nextLine().split(" ");

int num = Integer.parseInt(arr[0], 2)*Integer.parseInt(arr[1], 2);

System.out.println(Integer.toBinaryString(num));

}

}

import java.util.ArrayList;

import java.util.List;

import java.util.Scanner;

public class Fibonacci {

/*

public static void main(String[] args){

Scanner in = new Scanner(System.in);

int n = in.nextInt();

int first = 1;

int second = 0;

int temp = 0;

for(int i=1 ; i<n ; i++){

temp = first;

first = first+second;

second = temp;

}

System.out.println(first);

}

*/

public static void main(String[] args){

Scanner in = new Scanner(System.in);

List<Integer> arr = new ArrayList();

arr.add(1);

arr.add(arr.get(0));

int n = in.nextInt();

for(int i=2 ; i<n ; i++){

arr.add(arr.get(i-1)+arr.get(i-2));

}

System.out.println(arr.get(n-1));

}

}

import java.util.Scanner;

public class Main {

public static void main(String[] args){

Scanner in = new Scanner(System.in);

int get = in.nextInt();

int floor = get/2+1;

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

floor--;

for(int j=0;j<get-Math.abs(floor);j++){

System.out.print(Math.abs(floor)<=j ? "*":" ");

}

System.out.println();

}

}

}