{ BLog: "heyoon2j" }

Git fork & Pull request

heyoon2j — Tue, 13 Oct 2020 13:10:17 +0900

Git fork & Pull requset

Fork vs Clone 차이

Fork

- 하나의 Remote Repository를 복사한다. 변경 권한이 없어 기존 Remote Repository에 영향을 주지 못한다.

- Pull Request를 통해 변경을 요청하게 된다.

Clone

- Remote Repository를 Local Repository로 복사한다.

- 권한이 없으면 push를 하지 못한다.

Pull request 순서

1. Project를 자신의 Github로 Fork 한다.

- Github에 해당 Project Repository에 들어가 Fork를 누르면 된다.

- 그렇게 되면 자신의 Repository를 확인하면, 복사가 된 것을 확인할 수 있다.

2. Fork 한 Repostiry를 자신의 Local Repository에 복사한다.

- Code 버튼을 클릭하면 Clone 할 수 있는 주소가 나온다.

- 해당 주소는 복사한다.

git clone https://github.com/heyoon2j/maze-game.git

- 자신의 터미털을 켜고, 다음과 같이 명령어를 입력한다(Windows를 쓰시는 분은 Git bash와 같은 터미널 프로그램을 설치하는 것을 추천한다)

3. branch 생성, 이동

- 기존 코드에 영향을 주지 않고, 독립적으로 개발을 진행하기 위해서는 branch가 필요하다.

# git checkout -b <branch Name>
$ git checkout -b dev

$ git branch -a

- $ git checkout -b dev : dev라는 branch를 생성하고, 해당 branch로 이동

- $ git branch -a : 모든 branch의 리스트를 출력

* 만약 Fork를 통해 기존에 생성되어 있는 branch로 이동하려면, 위의 checkout 명령어에서 "-b" 옵션을 제거하면 된다.

4. 개발 진행 후

1) Add, Commit 작업을 통해 Local Repository에 저장한다.

$ git add README.md

$ git commit -m "docs: Initialization README.md"

2) 원하는 Remote Repository에 Push 작업을 한다.

# 연결된 Repository list 출력
$ git remote -v

# git push [Remote Repository Name] [Branch Name]
$ git push origin dev

- $ git push [Repository Name] [Branch] : 해당 Repository의 Branch에 Push 한다.

5. Pull request 보내기

- push 후에 자신의 github 저장소에 Compare & pull request 버튼이 활성화되어 있는 것을 확인할 수 있다.

- 버튼을 클릭하고, Pull request를 생성한다.

6. Code Review 및 Merge pull request

- Pull Request를 받은 Project 관리자가 Merge를 할지 말지 결정한다.

7. 동기화

- Project는 여러 사람이 계속 업데이트를 하기 때문에 작업 후에 최신 버전으로 업데이트할 필요가 있다.

1) 최신 업데이트를 하기 위해 실제 Project Repository를 Remote Repository를 추가한다.

$ git remote add upstream https://github.com/heyoon2j/maze-game.git

$ git remote -v
origin	https://github.com/theVebper/maze-game.git (fetch)
origin	https://github.com/theVebper/maze-game.git (push)
upstream	https://github.com/heyoon2j/maze-game.git (fetch)
upstream	https://github.com/heyoon2j/maze-game.git (push)

- $ git remote add [Repository Name] [Remote Repository Address] : 해당 주소의 Remote Repositoy를 Repository Name으로 추가한다.

- 리스트를 확인하면 추가되어 있는 것을 확인할 수 있다.

2) upstream repository로부터 최신 데이터를 업데이트한다.

$ git fetch upstream
remote: Enumerating objects: 5, done.
remote: Counting objects: 100% (5/5), done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 3 (delta 1), reused 3 (delta 1), pack-reused 0
오브젝트 묶음 푸는 중: 100% (3/3), 1.34 KiB | 686.00 KiB/s, 완료.
https://github.com/heyoon2j/maze-game URL에서
 * [새로운 브랜치]   main       -> upstream/main

- $ git fetch [Repository Name] : 해당 Name을 가진 Repository를 업데이트한다.

3) 업데이트한 최신 데이터와 자신의 branch와 병합한다.

$ git checkout main

- 먼저 병합할 branch로 이동한다.

- $ git checkout [Branch Name] : 해당 branch로 이동한다.

$ git merge upstream/main
업데이트 중 a7894a5..f53f3b7
Fast-forward
 README.md | 76 ++++++++++++++++++++++++++++++++++++++++++---------------------
 1 file changed, 51 insertions(+), 25 deletions(-)

- $ git merge [Branch Name] : 현재 Branch와 입력한 Branch와 병합한다.

* 2)과 3)번을 한 번에 할 수 있다.

 $ git pull [Remote Repository Name]
 # Remote Repository의 fetch 후 merge 한다.

- $ git pull [Remote Repository Name] [Branch]: Remote Repository의 Branch를 현재 Branch로 가지고 온다.

참고 사이트

* https://milooy.wordpress.com/2017/06/21/working-together-with-github-tutorial/

* velog.io/@hyunju-song/202010-%ED%94%84%EB%A1%9C%EC%A0%9D%ED%8A%B8git-workflow

* velog.io/@imacoolgirlyo/Git-fork%EC%99%80-clone-%EC%9D%98-%EC%B0%A8%EC%9D%B4%EC%A0%90-5sjuhwfzgp

* wayhome25.github.io/git/2017/07/08/git-first-pull-request-story/

Java Wrapper Class

heyoon2j — Mon, 12 Oct 2020 03:43:59 +0900

■ Java Wrapper Class

* 기본형 타입을 객체로 쓰기 위해 있는 클래스

기본형	Wrapper Class
byte	Byte
char	Character
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean

• Wrapper Class 생성 방법

valueOf() 이용

Integer integer1 = Integer.valueOf(10);

new 키워드 이용

Integer integer = new Integer(10);

• Autoboxing & unboxing

1. Autoboxing

* 기본 자료형을 Wrapper Class로 자동 변환 시킴

Integer integer2 = 10;
Character character2 = 'A';

2. Unboxing

* 기본 자료형이 필요한 자리에 Wrapper Class를 사용하는 경우, 자동으로 변환

public static Integer add(Integer x, Integer y){
    return x + y;   // UnBoxing, 클래스는 덧셈이 안 된다.
                    // 자동으로 기본 자료형으로 변형되어서 계산
                    // 여기서 반환 시에는 다시 Autoboxing이 이루어짐
}

3. Wrapper Class의 값 비교

* Wrapper Class는 Reference Type이므로 == 연산자를 이용하여 비교할 수 없다.

Integer intOne = new Integer(100);
Integer intTwo = new Integer(100);

System.out.println(intOne == intTwo); // false
System.out.println(intOne.equals(intTwo)) // true
System.out.println(intOne == 100) // true (Unboxing)

4. 문자열 <-> 기본 자료형

* parse+자료형 정적 메서드 사용하여 문자열 -> 기본 자료형

  int x = Integer.parseInt("123");

* valueOf 이용하여 문자열 -> Wrapper Class

Integer y = new Integer("100"); // 오버로딩되어 있음
Integer z = Integer.valueOf("5555");

Java Collection Framework

heyoon2j — Thu, 8 Oct 2020 23:59:15 +0900

■ Java Collection Framework

* java.utils에 속한 일련의 클래스로, 자료구조를 담당

* 잘 짜인 인터페이스를 기반으로 다양한 자료구조를 구현

* 제네릭 클래스로 되어있어, 다양한 객체를 요소로 담을 수 있다.

• JCF 인터페이스

1. List 인터페이스

* Collection 인터페이스를 상속

* 순서가 있는 데이터의 집합으로, 데이터의 중복을 허용

* 데이터의 순서(index)가 유일한 데이터의 구분자(identifier)로 사용

- Ex> [1, 3, 2, 5, 6, 2, 1] : 같은 값이 있으나, index가 다름

2. Set 인터페이스

* Collection Interface 상속

* 순서가 없는 데이터 {집합}을 다루는 인터페이스

* 중복되는 데이터를 효율적으로 제거하는 데 사용 가능

* 중복을 검사하는 수단으로 hashCode(), equals()

- hash를 빠르게 계산해서 hash만 비교

- 그 다음에 판정이 나지 않으면, equasl()로 추가 비교

3. Map 인터페이스

* Collection Interface 상속하지 않는다.

* Key, Value 쌍으로 구성된 자료의 집합을 다루는 인터페이스

- Map.Entry<K, V> 형태로 저장

* Key는 중복될 수 없으며, Value는 중복이 가능

- Key가 identifier 역할을 한다.

• Collection 인터페이스

Collection 인터페이스 주요 메서드

메서드	설 명
boolean add(E e)	요소 e를 컬렉션에 추가한다.
boolean addAll(Collection<? extends E> c)	다른 컬렉션 c의 모든 요소를 컬렉션에 추가한다.
void clear()	컬렉션의 모든 요소를 제거한다.
boolean contains(Object o)	컬렉션에 요소 o가 존재하는 확인한다.
boolean containsAll(Collection<?> c)	컬렉션 c의 모든 요소가 컬렉션에 포함되는지 확인한다.
boolean isEmpty()	컬렉션이 비어있는지 확인한다.
Iterator iterator()	컬렉션의 Iterator를 반환한다.
boolean remove(Object o)	컬렉션에서 요소 o를 제거한다.
boolean removeAll(Collection<?> c)	컬렉션 c에 속한 모든 요소를 컬렉션에서 제거한다.
boolean retainAll(Collection<?> c)	컬렉션 c에 포함된 객체만 남기고 나머지 요소를 제거한다.
int size()	컬렉션에 속한 요소의 개수를 반환한다.
T[] toArray()	컬렉션의 요소들을 T[] 배열로 반환한다.

Iterator

* iterator()로 반환되는 객체로, Collection에 저장된 요소에 접근하기 위해 사용

메서드	설 명
boolean hasNext()	다음 요소가 있는지 확인
E next()	다음 요소가 있을 경우 반환
void remove()	현재 위치의 요소를 삭제

* Iterator 활용

Iterator<String> iter = collection.iterator();
while (iter.hasNext()) {
  String string = iter.next();
  System.out.println(string);
}

for (String string: collection) {
  System.out.println(string);
}

• List 인터페이스

List 인터페이스 주요 메서드

메서드	설 명
void add(int index, E element)	index 위치에 요소 element를 삽입한다.
boolean addAll(int index, Collection<? extends E> c)	index 위치부터 컬렉션 c의 모든 요소를 추가한다.
E get(int index)	index 위치에 저장된 요소를 반환한다.
int indexOf(Object o)	객체 o가 저장된 첫번째 인덱스를 반환한다. 없을 경우 -1을 반환한다.
int lastIndexOf(Object o)	객체 o가 저장된 마지막 인덱스를 반환한다. 없을 경우 -1을 반환한다.
ListIterator listIterator()	ListIterator 객체를 반환한다.
E remove(int index)	index에 위치한 객체를 제거하고, 반환한다.
E set(int index, E element)	index에 위치한 요소를 element로 대체한다.
List subList(int fromIndex, int toIndex)	fromIndex에 위치한 요소부터 toIndex의 직전에 위치한 요소까지 포함한 List를 반환한다.

List 인터페이스의 구현체

* List Collection

List<String> stringList = new ArrayList<>();    // 가장 많이 쓰이는, 배열 기반의 리스트
List<String> stringList1 = new LinkedList<>();  // 노드의 연결로 구성된 리스트
List<String> stringList2 = new Vector<>();      // 멀티스레드 환경에서 안전하게 동작하나... 너무 느리다!!!
List<String> stringList3 = new Stack<>();       // Vector를 더 제한한 방법, Stack 자료구조 구현

* ArrayList

- 제네릭 클래스로 구현된 자료구조

- 배열을 기반으로 구현된 클래스로, 가장 자주 활용되며 활용도가 높다.

- ArrayList의 생성자는 세 종류가 주어진다.

public ArrayList()
public Arraylist(int initialCapacity)
public ArrayList(Collection<? extends E>)

* LinkedList

- 제네릭 클래스로 구현된 자료구조

- 연결리스트를 기반으로 구현된 클래스로, 배열의 단점을 극복하기 위한 구현체

- ArrayList vs LinkedList

구현체	순차 추가/수정/삭제	비순차 추가/수정/삭제	조 회
ArrayList	빠름	느림	빠름
LinkedList	느림	빠름	느림

List 정렬

* Collections 클래스의 sort() 메서드 사용

* public static <T extends Comparable<? super T> void sort(List<T> list)

- 객체에 선언된 public int compareTo(T t) 메소드로 비교하여 정렬

* public static <T> void sort(List<T> list, Comparator<? super T> c)

- Comparator 객체 c에 정의된 public int compare(T o1, T o2) 메소드로 비교하여 정렬

ListIterator

* listIterator()로 반환되는 객체로, 양방향 사용이 가능

* Iterator를 상속받은 클래스

메서드	설 명
boolean hsaPrevious()	이전 요소가 있는지 확인
E previous()	이전 요소가 있을 경우 반환

• Set 인터페이스

Set의 구현체

* HashSet

- Set의 대표적인 구현체로, 기본적인 기능이 구현되어 있다.

* TreeSet

- NaviableSet 인터페이스를 구현하며, 이진 탐색 트리 자료구조이다.

- 객체를 삽입하는 동시에 정렬되는 특성상, 비교가 가능해야 한다.

- TreeSet 메서드

메서드	설 명
public E first()	정렬된 첫 요소를 반환
public E last()	정렬된 마지막 요소를 반환
public E lower(E e)	e 객체의 바로 이전 객체를 반환
public E higher(E e)	e 객체의 바로 다음 객체를 반환
public E floor(E e)	e 또는 e 보다 이전 객체를 반환
public E ceiling(E e)	e 또는 e 보다 이후 객체를 반환
public E pollFirst()	정렬된 첫 요소를 제거하고 반환
public E pollLast()	정렬된 마지막 요소를 제거하고 반환
public NavigableSet descendingSet()	내림차순으로 정렬하는 객체를 반환
public NavigableSet headSet(E toElement, boolean inclusive)	toElement 이전 요소로 구성된 객체 반환
public NavigableSet tailSet(E fromElement, boolean inclusive)	fromElement 이후 요소로 구성된 객체 반환
public NavigableSet subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)	fromElement 이후, toElement 이전 요소로 구성된 객체 반환

• Map 인터페이스

Map<K, V>의 구현체

* HashMap<K, V> : 가장 많이 사용되는 Map의 구현체

* TreeMap<K, V> : 정렬 기준이 더해진 NavigableMap을 구현한 구현체

* Hashtable<K, V> : HashMap과 유사하지만 성능이 떨어지는 대신 멀티스레드에 안전한 구현체

* Properties : 속성 파일을 손쉽게 관리하는, Hashtable<K, V>의 하위 클래스 구현체

Map<K, V>의 주요 메서드

메서드	설 명
void clear()	Map의 모든 요소를 삭제
boolean containsKey(Object key)	key가 존재하는지 여부를 반환
boolean containsValue(Object value)	value가 존재하는지 여부를 반환
Set<Map.Entry<K,V>> entrySet()	Map의 Entry 요소를 Set에 담아 반환
V get(Object key)	key에 해당하는 value 객체 반환
Set keySet()	key 요소를 Set 형태로 반환
V put(K key, V value)	key와 value 쌍으로 구성된 Entry 추가. 기존에 등록된 key라면 해당 value를, 없으면 null을 반환
void putAll(Map<? extends K, ? extends V> m)	m에 속한 모든 Entry를 추가
V remove(Object key)	key에 해당하는 Entry를 제거하고 반환. 등록되지 않은 key라면 null 반환
Collection values	value 객체들을 Collection에 담아 반환
Collection values	value 객체들을 Collection에 담아 반환
int size()	Map에 포함된 Entry 객체의 수 반환
boolean isEmpty()	Map에 데이터가 없는지 여부 반환

TreeMap<K, V>의 주요 메서드

메서드	설 명
public Map.Entry<K, V> firstEntry()	정렬된 첫 Entry 반환
public Map.Entry<K, V> lastEntry()	정렬된 마지막 Entry 반환
public Map.Entry<K, V> lowerEntry(K key)	key 바로 이전 Entry 반환
public Map.Entry<K, V> higherEntry(K key)	key 바로 다음 Entry 반환
public Map.Entry<K, V> floorEntry(K key)	key 또는 key 보다 이전 Entry 반환
public Map.Entry<K, V> ceilingEntry(K key)	key 또는 key 보다 이후 Entry 반환
public Map.Entry<K, V> pollFirstEntry()	정렬된 첫 Entry를 제거하고 반환
public Map.Entry<K, V> pollLastEntry()	정렬된 마지막 Entry를 제거하고 반환
public NavigableSet descendingKeySet()	내림차순으로 정렬하는 Set 반환
public NavigableSet descendingKeyMap()	내림차순으로 정렬하는 Map 반환
public NavigableMap<K, V> headMap(K toKey, boolean inclusive)	toKey 이전 Entry로 구성된 객체 반환
public NavigableMap<K, V> tailMap(K fromKey, boolean inclusive)	fromKey 이후 Entry로 구성된 객체 반환
public NavigableMap<K, V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)	fromKey 이후, toKey 이전 Entry로 구성된 객체 반환

Properties의 주요 메서드

메서드	설 명
getProperty()	key에 해당하는 속성 값을 반환
stringPropertyNames()	key의 목록을 Set으로 반환
setProperty()	key로 value를 등록하고 기존 value 값을 반환
load()	reader를 이용해 속성을 읽어온다. (.properties)
loadFromXML()	XML 형식으로 저장된 속성을 읽어온다.
store()	writer를 이용해 속성을 저장한다.
storeToXML()	XML 형식으로 속성 파일을 저장한다.

Java I/O Stream

heyoon2j — Thu, 8 Oct 2020 23:58:38 +0900

■ Java I/O Stream

* Decorator Pattern으로 구현되어 있다.

* Java의 I/O 방식은 Node - Stream

* Node : 데이터의 소스 또는 데이터의 목적지

- Node는 키보드(입력), 모니터(출력), 파일(입출력) 등을 말한다.

* Stream : Node로부터 데이터를 주고받는 통로

- 입력으로 사용되는 스트림과 출력으로 사용되는 스트림은 별개

- 입출력을 함께하는 것을 채널(Channel) : NIO(New Input/Output)

• I/O Stream 구분

* I/O 대상 기준 : Input Stream, Output Stream

* 자료의 종류 : Byte 단위 Stream, 문자 단위 Stream

* Stream 기능 : 기반 Stream, 보조 Stream

• 표준 입출력

* System 클래스의 표준 입출력 멤버

public class System{
    public static PrintStream out;
    public static InputStream in;
    public static PrintStream err;
}

• 기본 Stream 종류

1. Byte 단위 Stream

* Byte 단위로 자료를 읽고 씀(동영상, 음악 파일 등)

* InputStream : 입력 스트림

* OutputStream : 출력 스트림

* Method(Input)

메소드	설명
int read()	byte 하나를 읽어서 int로 반환. 읽을 값이 없으면 -1 반환
int read(byte[] b)	데이터를 읽어 b에 저장하고, 읽은 바이트 수를 반환
int read(byte[] b, int offset, int len)	최대 len개의 바이트를 읽어 b의 offset 위치부터 채운다.
void close()	스트림을 종료하고 자원을 반납
int available()	읽을 수 있는 데이터의 크기를 반환
long skip(long n)	스트림에서 n 만큼 건너 뛴다.
void mark(int readLimit)	reset()으로 돌아갈 위치를 표시한다. readLimit은 돌릴 수 있는 최대 바이트 수
void reset()	mark()가 호출된 지점으로 돌아간다.
boolean markSupported()	mark, reset 메소드의 지원 여부를 반환

* Method(Output)

메소드	설명
void write(int b)	b의 끝 1byte를 출력 버퍼에 보낸다.
void write(byte[] b)	배열 b의 모든 Byte를 보낸다.
void flush()	출력 버퍼를 비운다.
void close()	스트림 종료. 내부적으로 flush() 호출한다.

* Example

public class InputOutputStream {
    public static void main(String[] args) {

        System.out.println("입력 ");
        try {
            int i;
            InputStreamReader isr = new InputStreamReader(System.in);
            while((i = isr.read()) != '끝') {
                System.out.print((char) i);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. 문자 단위 Stream

* Character(2 Btye) 단위로 자료를 읽고 씀

* Reader : 입력 스트림

* Writer : 출력 스트림

* Method(Input)

메소드	설명
int read()	char 하나를 읽어서 int로 반환. 읽을 값이 없으면 -1 반환
int read(char[] cbuf)	데이터를 읽어 cbuf에 저장하고, 읽은 char 수를 반환
int read(char[] cbuf, int offset, int len)	최대 len개의 char를 읽어 cbuf의 offset 위치부터 채운다.
int read(java.nio.CharBuffer target)	NIO target에 데이터를 저장한다.
void close()	스트림을 종료하고 자원을 반납
int available()	읽을 수 있는 데이터의 크기를 반환
long skip(long n)	스트림에서 n 만큼 건너 뛴다.
void mark(int readLimit)	reset()으로 돌아갈 위치를 표시한다. readLimit은 돌릴 수 있는 최대 바이트 수
void reset()	mark()가 호출된 지점으로 돌아간다.
boolean markSupported()	mark, reset 메소드의 지원 여부를 반환

* Method(Output)

메소드	설명
void write(int c)	c 내용을 char로 출력
void write(char[] cbuf)	배열 cbuf의 모든 char를 보낸다.
void write(char[] cbuf, int off, int len)	cbuf의 off부터 (off + len - 1) 만큼을 문자열로 변환하여 출력
void write(String str)	str을 출력한다.
void write(String str, int off, int len)	str의 off부터 (off + len - 1) 만큼을 출력
Writer append(CharSequence csq)	csq를 출력하고 Writer 반환
Writer append(CharSequence csq, int start, int end)	csq의 start부터 end까지를 출력하고 Writer 반환
Writer append(char c)	c를 출력하고 Writer 반환
void flush()	출력 버퍼를 비운다.
void close()	스트림 종료. 내부적으로 flush() 호출한다.

• File Stream

1. FileInputStrea, FileOutputStream

* 파일명이나 File 객체를 이용하여 입출력 스트림 생성 가능

* FileOutputStream에서 boolean append를 true로 하면 기존 파일에 이어서 쓴다.

2. FileReader, FileWriter

* 파일명이나 File 객체를 이용하여 입출력 Reader 생성 가능

* FileWriter에서 boolean append를 true로 하면 기존 파일에 이어서 쓴다.

* Example

public class ReaderWriterStream {
    public static void main(String[] args) throws IOException {
        FileReader fis = new FileReader("src/reader.txt");
//        FileInputStream fis = new FileInputStream("src/reader.txt");
//        InputStreamReader isr = new InputStreamReader(fis);
        int i;
        while((i = fis.read())!= -1){
            System.out.println((char)i);
        }
        fis.close();
    }
}

3. File Constructor & Method

생성자 및 메소드	설명
File(String pathname)	pathname에 해당하는 파일 생성. 기본 경로는 애플리케이션의 시작 경로
File(String parent, String child)	parent 경로 아래 child 파일 생성
File(File parent, String child)	parent 경로 아래 child 파일 생성
File(URI uri)	file로 시작하는 URI 객체를 이용해 파일 생성
boolean createNewFile()	새로운 파일을 생성
boolean mkdir()	새로운 디렉토리를 생성
boolean mkdirs()	경로상의 모든 디렉토리를 생성
boolean delete()	파일/디렉토리 삭제
void deleteOnExit()	애플리케이션 종료시 자동으로 삭제
boolean exist()	해당 파일이 존재하는지 여부

* RandomAccessFile Class

- 입출력 클래스 중 유일하게 파일 입출력을 동시에 할 수 있는 클래스

- 파일 포인터가 있어서 읽고 쓰는 위치의 이동이 가능하다.

* Example

// File.separator를 이용하여 "\" 표현할 수 있다.
String filePath = "D:" + File.separator + "Temp" + File.separator + "MyTemp";

File fileOne = new File(filePath);
fileOne.mkdir();

File fileTwo = new File(filePath, "file2.txt");
fileTwo.createNewFile();

File fileThree = new File(fileOne, "file3.txt");
fileThree.createNewFile();

File fileFour = new File(new URI("file:///d:/Temp/MyTemp/file4.txt"));
fileFour.createNewFile();
fileFour.deleteOnExit();

4. 그 외 File 클래스의 주요 메소드

메소드	설명
getName()	파일 이름 반환
getPath()	입력된 경로 반환
isAbsolute()	절대 경로를 사용하는지? 여부 확인
getAbsolutePath()	절대 경로 반환
getCanonicalPath()	상위 경로 기호("..")가 없어진 절대 경로 반환
isDirectory()	해당 File이 Directory인지? 여부 확인
isFile()	해당 File이 File인지? 여부 확인
list()	해당 Path의 리스트 반환, String Array로 출력
listFiles()	해당 Path의 리스트 반환, File 객체 Array로 출력

• 보조 Stream

* 실제로 읽고 쓰는 Stream이 아닌 보조적인 기능을 추가하는 Stream

* FilterInputStream과 FilterOutputStream이 보조 Stream의 상위

- protected FilterInputStream(InputStream in)

- public FilterOutputStream(OutputStream out)

1. Byte -> char Stream

* Byte를 문자 기반으로 변환시킨다.

- InputStreamReader(InputStream is)

- OutputStreamWriter(OutputStream os)

* 스트림 자료형 변경

- Character Set : utf-8, ms949, euc-kr

InputStreamReader readerOne = new InputStreamReader(System.in);
InputStreamReader readerTwo = new InputStreamReader(System.in, "utf-8");

OutputStreamWriter writerOne = new OutputStreamWriter(System.out);
OutputStreamWriter writerTwo = new OutputStreamWriter(System.out, "ms949");

2. Buffered Stream

* 내부에 8192byte 배열을 가지고 있어, 읽거나 쓸 때의 속도를 향상(Throughput 향상)

- throughtput : 평균 전송량 / 파일의 입출력 등 한 번에 많은 양을 보내는 것이 효율적일 때 신경 쓴다.

- delay : 지연 시간 / 게임, 반응성이 중요한 경우, 버퍼링을 쓰게 되면 오히려 안 좋을 수 있다.

- BufferedInputStream(InputStream is)

- BufferedOutputStream(OutputStream os)

- BufferedReader

- BufferedWriter

* String readLine() : Line Feed(\n)와 Carriage Return(\n)을 제거해주고 한 줄을 읽어 들인다.

File src = new File("./src.txt");
try (BufferedReader buffReader = new BufferedReader(new FileReader(src));) {
  String line = null;
  while ((line = br.readLine()) != null) {
    System.out.println(line);
  }
} catch (IOException e) {
  e.printStackTrace();
}

3. Data Stream

* 자료가 저장된 상태 그대로 자료형을 유지하며 읽기, 쓰기 기능을 제공하는 Stream

- DataInputStream

- DataOutputStream

- readByte(), readShort(), writeInt(), writeUTF() 등 메서드가 있다.

File src = new File("c:/Temp/data.dat");
try (DataOutputStream out = new DataOutputStream(new FileOutputStream(src))) {
  out.writeUTF("UTF-8");
  out.writeInt(15);
  out.writeFloat(14.23);
}

try (DataInputStream in = new DataInputStream(new FileInputStream(src))) {
  String string = in.readUTF();
  int integer = in.readInt();
  float floatNum = in.readFloat();
  System.out.println(string + " " + integer + " " + floatNum);
}

4. Print Stream

* 문자열 표현 Stream

- PrintReader

- PrintWriter

public class SubStream{
    public static void main(String[] args){
        try(FileOutputStream fos = new FileOutputStream("data.txt");
                DataOutputStream dos = new DataOutputStream(fos);
                FileInputStream fis = new FileInputStream("data.txt");
                DataInputStream dis = new DataInputStream(fis)){

            dos.writeByte(100);
            dos.write(100);
            dos.writeChar('A');
            dos.writeUTF("안녕하세요");

            System.out.println(dis.readByte());
            System.out.println(dis.read());
            System.out.println(dis.readChar());
            System.out.println(dis.readUTF);

        }catch(Exception e){
            e.printStackTrace();            
        }
    }
}

5. 직렬화(Serialization

* 인스턴스의 상태를 그대로 저장하거나 Network로 전송하고, 이를 다시 복원(Deserialization)하는 방식

* 보조 Stream으로 Object Stream 사용

- ObjectInputStream

- ObjectOutputStream

- readObject(), writeObject() 메소드 이용

* 직렬화를 위해서는 해당 클래스에 Serializable Interface를 사용하여 명시해야 한다.

* HAS-A 관계인 경우, 관계 Class들 모두 Serialization 해야 한다.

class Foo implements Serializable { // has-a 관계의 모든 클래스가 Serializable이어야 함
  static final long serialVersionUID = 1L; // 객체의 버전 관리
  // 클래스 버전을 따로 관리하는 이유는 클래스 내용 자체가 바뀔 수 있기 때문에
  // 객체를 저장할 때와 불러올 때 같은지 체크하여
  // serialVersionUID가 일치하지 않으면 실패

  String userName;
  int id;

  transient String passWord; // transient 키워드, 해당 코드는 직렬화하지 말라는 의미
  // Password는 중요 정보이기 때문에 포함시키지 않기 위해서

  @Override
  public String toString() {
    return userName + " " + id + " " + passWord;
  }
}

class FooTest {
  public static void main (String [] args) {
    File dst = new File("C:/Temp/obj.data");
    Foo foo = new Foo();
    foo.userName = "yoon";
    foo.id = 142;
    foo.passWord = "qwer1234";

    try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(dst));
        ObjectInputStream in = new ObjectInputStream(new FileInputStream(dst));) {
      out.writeObject(foo);
      Object read = in.readobject();
      if (read != null && read instanceof Foo) {
        Foo readFoo = (Foo)read;
        System.out.println(readFoo);
      }
    } catch (IOException | ClassNotFoundException e) {
      e.printStackTrace();
    }
  }
}

* 부모 클래스가 Serializable이 아닌 경우 자식 클래스에서 직접 처리해야 한다.

- readObject(), writeObject()를 자식 클래스에서 직접 구현

class ParentFoo {
  int memVarOne;
  double memVarTwo;
}

class ChildFoo extends ParentFoo implements Serializable {
  @Override
  private void writeObject(ObjectOutputStream out) throws IOException {
    out.writeInt(memVarOne);
    out.writeDouble(memVarTwo);
    out.defaultWriteObject();
  }
  
  @Override
  private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
    memVarOne = in.readInt();
    memVarTwo = in.readDouble();
    in.defaultReadObject();
  }
}

* Externalizable Interface를 이용하여 읽기, 쓰기에 대해 정의할 수 있다.

- writeExternal, readExternal 함수 Override

Java 코드 작성 습관

heyoon2j — Thu, 8 Oct 2020 23:44:15 +0900

1. 반복문을 줄여야 한다.

=> 리소스를 계속 사용하기 때문에

2. Dynamic Lookup을 줄인다.

=> instanceOf()와 같은 메서드

3. 필요시 순수 함수 형식으로 코드 짜기(객체뿐만 아니라 함수도 모듈화가 된다)

=> 당연히 필요시에는 OOP 준수(Real-Time과 같은 쓰레딩 부분 등 Critical 한 부분)

4. Stream과 Collection, 기본적인 속도는 for 문이 Stream 보다 빠르다.

=> 기존 Collection을 재사용해야 되는데, Collection의 변경이 필요한 경우

=> Prototype으로

5. Object 클래스의 메서드 Overriding

=> 자주 사용하는 메소드 : equals(), hashCode(), clone(), toString()

6. 배열 복사할 때, System.arraycopy() 사용

=> native로 되어있기 때문에 좀 더 최적화가 되어있다.

7. Comparator & Comparable Interface 사용

=> compare(T o1, T o2) & copareTo(T o) 메서드 이용

=> 배열 Sort : Arrays.sort()

=> Collection Sort : Collection.sort()

8. 문자열의 추가, 수정, 삭제가 빈번한 경우, StringBuffer & StringBuilder

=> String은 immutable 속성을 가지기 때문에 변경이 불가

=> StringBuffer는 동기화 키워드를 지원하므로, 멀티스레드 환경에서 안전하다.

=> StringBuilder는 동기화를 지원하지 않기 때문에, 단일 스레드 환경에서 성능이 더 좋다.

=> Example

public class Main {
    static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
            int k = Integer.parseInt(br.readLine());
            System.out.println(((int)Math.pow(2, k) - 1));
            move(k, 1, 2, 3);
            bw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void move(int k, int src, int mid, int dst) throws IOException {
        if (k > 0){
            move(k-1, src, dst, mid);
            bw.write(src + " " + dst + "\n");
            move(k-1, mid, src, dst);
        }
    }
}

9. String <-> 기본 자료형 변경할 때

=> 기본 자료형으로 변경 : Integer.parseInt()

=> 클래스형으로 변경 : Integer.valueOf()

10. Math 클래스 메소드 활용을 줄이자

1) *2 or /2의 경우, Shift 연산자 활용

=> * 2 : <<

=> / 2 : >> 또는 * 0.5를 이용하자

2) Math.floor()과 Math.ceil 대신 int 활용

=> Math.floor() : int(3.5)

=> Math.ceil() : int(3.5) + 1

3) Math.abs() 대신 * -1 활용

=> Math.abs() : (a > 0) ? a : a * -1

=> 출처 : rockonflash.wordpress.com/2007/08/11/optimizations-for-as3-calculations/

* 계속 추가될 예정

Java Code Convention(Google Java Style 정리)

heyoon2j — Wed, 7 Oct 2020 02:55:25 +0900

■ Code Java Code Convention

* Google Java Code Convention 정리
* 공식 문서 : https://google.github.io/styleguide/javaguide.html

Google Java Style Guide

1 Introduction This document serves as the complete definition of Google's coding standards for source code in the Java™ Programming Language. A Java source file is described as being in Google Style if and only if it adheres to the rules herein. Like ot

google.github.io

1. Source file 기본 사항

1.1. File name

* Source file은 대소문자를 구분한 이름을 가지고, 확장자는 .java로 지정한다.

1.2. File encoding: UTF-8

* Source file의 인코딩은 UTF-8을 사용한다.

1.3. Special characters

1.3.1. Whitespace characters

* 공백문자(0x20)는 Source file에서 아무렇게나 쓸 수 있는 유일한 문자이다.

* 문자열 및 문자 리터럴의 다른 모든 공백 문자는 이스케이프 된다.

* Tab 문자는 들여쓰기에 사용되지 않는다.

1.3.2. Special escape sequences

* 특수 이스케이프 문자를 사용할 때는 이스케이프 시퀀스(\b, \t, \n, \f, \r, \" , \'과 \\ )를 사용한다.
* 진수 표현(\012) 또는 유니코드(\u000a)는 추천하지 않는다.

1.3.3. Non-ASCII characters
* 비 ASCII 문자의 경우, 실제 유니코드 문자 또는 동등한 유니코드 이스케이프가 사용된다.

2. Source file structure

* 파일 구조 순서는 다음과 같다.
1) 라이센스 또는 저작권 정보(있는 경우)
2) package
3) import
4) 하나의 최상위 클래스

/*
* Copyright ...
*/
package kr.co.example;
import java.io.File;
public class ClassName{
	// ...
}

2.1. License or copyright information, if present

* 라이센스 또는 저작권 정보가 있는 경우, 여기에 속한다.

2.2. Package statements

2.3. Import statements

* Wildcard Import는 사용되지 않는다.
* Import 문은 줄 바꿈이 되지 않는다.

2.3.1 Ordering and spacing

* Imports의 순서는 다음과 같다.
1. 단일 블록에서 모든 static imports
2. 단일 블록에서 모든 non-static imports

* static과 non-static이 모두 있는 경우, 하나의 빈 줄이 두 블록을 구분한다.
* import 문 사이에는 다른 빈 줄이 없다.
* 각 블록 내에는 이름이 ASCII 정렬 순서로 정렬된다.

2.3.2. No static import for classes

* 정적 중첩 클래스에는 정적 가져오기가 사용되지 않는다.
* 해당 클래스는 일반 imports로 가져온다.

3. Formatting

3.1. Braces

3.1.1. Braces are used where optional

* if, else, for, do 및 while문에는 중괄호가 사용돼야 한다(몸이 비어있거나 단 하나의 문이 포함된 경우에도)

3.1.2. Nonempty blocks: K & R style

* 중괄호는 Kernighan 와 Ritchie style을 따른다.
1. 여는 중괄호 앞에는 줄 바꿈이 없다.
2. 여는 중괄호 뒤는 줄 바꿈.
3. 닫는 중괄호 앞에는 줄 바꿈.
4. 닫는 중괄호 뒤에는 줄 바꿈(else, catch 등이 있는 경우에는 줄 바꿈을 하지 않는다.)
* 열거형 클래스의 경우에는 예외가 존재한다.
* Example

return () -> {
	while (condition()) {
		method();
	}
};

return new MyClass() {
	@Override public void method() {
		if (condition()) {
			try {
				something();
			} catch (ProblemException e) {
				recover();
			}
		} else if (otherCondition()) {
			somethingElse();
		} else {
			lastThing();
		}
	}
};

3.1.3. Empty blocks: may be concise
* 빈 블록인 경우, 줄 바꿈 없이 사용할 수 있다.
* 다중 블록 명령문인 경우에는 줄 바꿈을 해야 된다.

// This is acceptable
void doNothing() {}

// This is equally acceptable
void doNothingElse() {
}

// This is not acceptable: No concise empty blocks in a multi-block statement
try {
	doSomething();
} catch (Exception e) {}

3.2. Block indentation: +2 spaces

* 새 블록이 열릴 때마다, 들여쓰기가 두 칸씩 증가한다.
* 다른 곳에서는 +4 spaces or Tab을 사용하는 경우도 있다.

3.3. Column limit: 100

* Java 코드의 열 제한은 100자이다.

3.4. Line-wrapping

* 줄 바꿈의 주요 지침은 더 높은 구문 수준에서 중단하는 것을 선호한다.
* 포괄적이고 결정적인 공식은 없다.
1. 비 할당 연산자에서 줄이 끊어지면 기호 앞에서 끊어진다.
2. 할당 연산자의 경우, 보통 기호 뒤에서 끊어진다.
3. 매서드 또는 생성자 이름 뒤에 오는 여는 괄호( "(" )는 연결된 상태를 유지한다.
4. 쉼표는 앞에 토큰에 계속 붙어 있는다.
5. 람다의 본문이 중괄호가 없는 단일 식으로 구성된 경우 화살표 바로 뒤에 줄 바꿈이 있을 수 있다는 점을 제외하고는 람다의 화살표 옆에서 줄이 끊어지지 않는다.

MyLambda<String, Long, Object> lambda =
    (String label, Long value, Object obj) -> {
        ...
    };

Predicate<String> predicate = str ->
    longExpressionInvolving(str);
    
System.out.println(a + b
	+ c);

3.4.1. Indent continuation lines at least +4 spaces

* 줄 바꿈 시 연속 줄인 경우, 최소 +4 공백의 들여쓰기를 한다.

3.5. Whitespace

3.5.1. Vertical Whitespace

* 수평 공백은 다음과 같다.

1. if, for, catch 뒤에 오는 괄호 ( 와는 분리
2. else, catch 앞에 오는 } 와는 분리
3. { 여는 중괄호 앞에 공백이 사용
* 예외 @SomeAnnotation({a, b})
* 예외 String[][] x = {{"foo"}}
4. , : ; 다음이나 닫는 괄호 ) 뒤에 공백 사용
5. 선언의 유형과 변수 사이: List<String> list

3.6. Grouping parentheses: recommended

* 선택적 그룹화 괄호는 코드가 잘못 해석될 가능성이 없는 경우 생략한다.

3.7. Specific constructs

3.7.1. Enum classes

* Enum 상수 뒤에 오는 쉼표 뒤 줄 바꿈은 선택 사항이다.

private enum Answer {
	YES {
		@Override public String toString() {
			return "yes";
		}
	},
	NO,
	MAYBE
}

3.7.2. Variable declarations

3.7.2.1. One variable per declaration

* 모든 변수 선언은 하나의 변수만 선언한다.

* int a, b; 은 사용되지 않는다.

* for 루프 헤더의 경우는 허용된다.

3.7.2.2. Declared when needed

* 지역 변수는 시작 부분에서 습관적으로 선언하지 않는다.

* 처음 사용되는 지접에 가깝게 선언하여 사용한다.

3.7.3. Arrays
* C Style을 사용하지 않는다 : String args[]
* 다음과 같이 사용한다 : String[] args

3.7.4. Switch statements

3.7.4.1. Indentation

* 다른 블록과 마찬가지로 스위치 블록의 내용은 +2로 들여쓰기를 한다.

3.7.4.2. Fall-through: commented

* Fall-through가 발생하는 경우, 주석을 단다.
* // fall through

3.7.4.3. The default case is present

* default 문의 경우, Code가 없더라도 존재해야 된다.

* Example

switch (input) {
	case 1:
	case 2:
		prepareOneOrTwo();
		// fall through
	case 3:
		handleOneTwoOrThree();
		break;
	default:
		handleLargeNumber(input);
}

3.7.5. Annotations

* 각 Annotation은 자체 줄에 나열된다(즉, 한 줄에 하나의 Annotation)
* 파라미터가 없는 Annotation의 경우는 한 줄로 사용 가능하다.
* 필드에 적용되는 Annotation의 경우도 보통 한 줄에 하나씩 적용할 수 있으나, 여러 개의 Annoation을 적용하는 경우 한 줄로 표현할 수 있다.
* Example

@Override
@Nullable
public String getNameIfPresent() { ... }

@Override public int hashCode() { ... }

@Partial @Mock DataLoader loader;

3.7.6. Comments

* 블록 주석은 주변 코드와 동일한 수준에서 들여쓰기 한다.

3.7.7. Modifiers

* Modifier는 다음 순서를 따른다.

public protected private abstract default static final transient volatile synchronized native strictfp

3.7.8. Numeric Literals

* long 정수 리터럴의 경우, 소문자가 아닌 대문자 L을 사용하여 표기한다.

4. Naming

4.1. Rules by identifier type

4.1.1. Package names

* 패키지 이름은 모두 소문자이며, 연속된 단어는 단순히 함께 연결한다(밑줄 없음)

package com.example.deepspace
// package com.example.deepSpace : not use
// package com.example.deep_space : not use

4.1.2. Class names

* UpperCamelCase로 작성

* 클래스 이름은 일반적으로 명사 또는 명사구이다(Ex> Character, ImmutableList 등)

* 인터페이스 이름은 명사 또는 명사구, 형용사 또는 형용사구이다(Ex> Readable 등)

* 테스트 클래스는 테스트 중인 클래스의 이름으로 시작하여 Test를 붙인다(Ex> HashTest, HashIntegrationTest)

4.1.3. Method names

* lowerCamelCase로 작성

* 메서드 이름은 일반적으로 동사 또는 동사구이다(Ex> sendMessage, stop 등)

4.1.4. Constant names

* 상수 이름은 모두 대문자를 사용되며, 각 단어는 단일 밑줄로 구분한다(Ex> CONSTANT_CASE)

* 이름은 일반적으로 명사 또는 명사구이다.

4.1.5. Non-constant field names

* 상수가 아닌 필드 이름은 lowerCamelCase로 작성된다.

* 이름은 일반적으로 명사 또는 명사구이다(Ex> computedValues, index)

4.1.6. Parameter names

* 매개변수 이름은 lowerCamelCase로 작성된다.

4.1.7. Local variable names

* 지역 변수 이름은 lowerCamelCase로 작성된다.

5. Programming Practices

5.1. @Override: always used

* @Override Annotation은 항상 사용한다.

* 예외로 부모 메서드가 @Deprecated 인 경우, 생략 가능하다.

5.2. Caught exceptions: not ignored

* 아래에 언급된 경우를 제외하고는 포착된 예외에 대한 응답으로 아무것도 하지 않는 것은 거의 옳지 않다.

try {
	int i = Integer.parseInt(response);
	return handleNumericResponse(i);
} catch (NumberFormatException ok) {
	// it's not numeric; that's fine, just continue
}
return handleTextResponse(response);

5.3. Static members: qualified using class

* 정적 클래스 멤버에 대한 참조는 클래스를 사용하여 정규화한다.

5.4. Finalizers: not used

* Object.finalize를 재정의하는 것은 거의 드물다.

추가 내용

* 좋은 코드는 80자 또는 130자를 생각한다.

* 옛날 터미널 크기가 80*25 이어서 고정폭 폰트로 80자는 딱 터미널 사이즈에 맞았다.

* 옛날 프린터 용지가 132자였다.

java.lang 패키지

heyoon2j — Tue, 29 Sep 2020 23:32:23 +0900

■ java.lang 패키지

- Java에서 가장 기본적이며, 자주 사용되는 클래스를 모아놓은 패키지

- 별도로 import를 하지 않아도 사용이 가능한 기본 중의 기본

• Object Class

- 모든 클래스의 조상 클래스

- 클래스의 기본 기능을 제공

- 필요한 경우, Object 클래스에 구현된 메서드를 Override

메소드	설명
public final native Class<?> getClass()	현재 객체의 클래스를 반환한다.
public native int hashCode()	현재 객체의 해시코드 값을 반환한다.
public boolean equals()	현재 객체와 대상이 같은 객체를 참조하는지 여부를 반환한다.
public String toString()	객체를 문자열로 변환하여 반환한다.
proteted native clone() throws CloneNotSupportedException	객체를 복사하여 새로운 객체로 반환한다.

1. equals()

- 동일한 객체를 가리키는지 여부 확인

- Object 클래스의 equals() 메소드 구현

* 객체의 참조만을 비교

public boolean equals(Object obj) {
    return (this == obj);
}

- String 클래스의 equals() 메소드 구현(Overriding)

* 효율적으로 객체의 내용이 동일한지 비교

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String aString = (String)anObject;
        if (!COMPACT_STRINGS || this.coder == aString.coder) {
            return StringLatin1.equals(value, aString.value);
        }
    }
    return false;
}

2. hashCode()

- 객체를 구분하기 위해 사용하는 정수 값(해시코드)을 반환

* 프로그램 내에서 객체마다 유일하므로 주소값처럼 사용 가능

* 메모리 주소는 JVM에서 관리

- native 메소드이다.

- hashCode() 제약 사항

* 필수 - 한 객체의 hashCode()를 여러 번 호출할 경우, equals()에 사용하는 값이 변하지 않으면 동일한 값을 반환해야 한다.

* 필수 - equals() 메서드가 같다고 판단한 두 객체의 hashCode() 반환 값은 같아야 한다.

* 권고 - equals() 메소드가 다르다고 판단한 두 객체의 hashCode()가 반드시 다를 필요는 없으나, 다른 값이 나오면 HashTable 성능이 향상된다.

public class Member{
	public String id;
    
    public Member(String id){
    	this.id = id;
    }
    
    @Override
    public boolean equals(Object obj){
    	if(obj instanceof Member){
        	Memeber member = (Member)obj;
            if(id.equals(member.id){
            	return true;
            }
        }
    	return false;
    }
    
    @Override
    public int hashCode(){
    	return id.hashCode();
    }
}

3. clone()

- 자신을 복제하여 새로운 객체를 생성하는 메소드

- 배열을 복제할 경우 새로운 객체를 생성하므로 원본을 훼손하지 않을 수 있음

- clone() 메서드를 Overriding 할 시, Cloneable Interface를 구현해야 함

* Deep Copy 필요시, Overriding 해야 한다.

int [] ints = {1, 2, 3, 4, 5};
int [] ints2 = ints.clone();

4. getClass()

- 현재 객체의 Class 클래스를 반환

class Foo {
    public void methodA() {
        System.out.println("method A called.");
    }
}

class FooTest {
    public static void main(String[] args) throws Exception {
        Foo foo = new Foo();
        Class fooClass = foo.getClass();

        System.out.println(fooClass.getName());
        System.out.println(fooClass.getDeclaredMethods().length);
        System.out.println(Foo.class.getDeclaredMethod("methodA").invoke(foo));
    }
}

• System Class

- OS와 Interaction 하기 위한 클래스

- 정적 변수와 정적 메서드만으로 구성된 클래스

메소드	설명
arraycopy()	src 배열의 내용을 dst 배열로 복사
currentTimeMillis()	현재 시스템 시간을 ms로 반환
exit()	프로그램을 종료
gc()	GC를 요청
getenv()	환경 변수의 값을 반환
getProperties()	시스템 속성을 반환
getProperty()	시스템 속성 값을 문자열로 반환한다. 없을 경우 null 또는 def를 반환
identityHashCode()	객체의 해시코드 값을 반환
lineSeparator()	시스템의 줄넘김 문자열을 반환한다. UNIX: \n, WINDOWS: \r\n
nanoTime()	시스템 시간을 ns로 반환
setProperties()	시스템 속성을 한번에 설정
setProperty()	시스템 속성을 하나씩 설정

1. in, out, err 정적 변수

- in : InputStream 객체, 표준 입력

- out : PrintStream 객체, 표준 출력

- err : PrintStream 객체, 표준 에러

System.in.read();       // in: InputStream 객체, 표준 입력
System.out.println();   // out: PrintStream 객체, 표준 출력
System.err.println();   // err: PrintStream 객체, 표준 에러

2. System.arraycopy()

- Array를 Shallow Copy

- native로 되어있기 때문에 좀 더 최적화가 되어있다고 생각하면 된다.

* 그렇기 때문에 for문 보다 더 효율적이다.

int[] ints = {1, 2, 3, 4};
int[] ints1 = new int[10];
System.arraycopy(ints, 0, ints1, 0, ints.length);

3. currentTimeMillis(), nanoTIme() : 시간

System.out.println(System.currentTimeMillis());
System.out.println(System.nanoTime());  // RTOS가 아니기 때문에 정확하지 않을 수 있음(Real Time OS), 보통 참고용으로만 사용

4. exit()

- 프로그램 강제 종료

- status == 0 : 정상 종료

- status != 0 : 비정상 종료 (보통 1 사용)

System.exit(0);

5. gc()

- Garbage Collection 호출

- 하지만 바로 호출이 아닌, 원하는 타이밍에 좀 더 빨리 처리해달라고 요청하는 정도라고 생각하면 된다.

System.gc();

6. getenv(), getProperties(), getProperty()

- getenv() : 환경변수 호출

- getProperties() : 모든 속성 값 호출

- getProperty() : 특정 속성 값 호출

System.out.println(System.getenv());
System.out.println(System.getenv("JAVA_HOME"));
System.out.println(System.getenv("Path"));
System.out.println(System.getProperties());
System.out.println(System.getProperty("user.country"));
System.out.println(System.getProperty("java.io.tmpdir"));
System.out.println(System.getProperty("line.separator"));   // windows \r\n, linux \n
System.out.println(System.getProperty("file.separator"));   // windows \ linux

• Math Class

- 수학 계산에 필요한 메서드를 가진 final 클래스

- 모든 메서드가 static 메서드로 구현되어 있다.

메소드	설 명
abs()	절대값을 반환
ceil()	올림 값을 double로 반환
floor()	내림 값을 double로 반환
max()	두 값 중 더 큰 값을 반환
min()	두 값 중 더 작은 값을 반환
random()	0 이상 1.0 미만의 임의의 값을 반환
round()	소수점 첫째자리에서 반올림한 정수 값을 반환
addExact()	덧셈 연산으로, Overflow 발생 시 ArithmaticException 발생
subtractExact()	뺄셈 연산으로, Overflow 발생 시 ArithmaticException 발생
multiplyExact()	곱셈 연산으로, Overflow 발생 시 ArithmaticException 발생

- Example

// abs() : 절대 값, int long float double Overriding
System.out.println(Math.abs(-4));       // 4

// ceil() : 올림, double 입력, double 출력
System.out.println(Math.ceil(1.2));     // 2.0

// floor() : 내림, double 입력, double 출력
System.out.println(Math.floor(1524.4)); // 1524.0

// max(), min() : 2개의 값만을 비교하게 되어 있음
System.out.println(Math.max(4, 2));     // 4
System.out.println(Math.min(4, 2));     // 2

// random() : 0.0 이상, 1.0 미만의 값을 임의로 출력
System.out.println(Math.random());
System.out.println(Math.random() > 0.7);    // 30퍼센트 확율인 경우, 보통 이런 식으로 사용

// 확률 표현
int count = 0;
for(int i = 0; i < 1000; i++){
    if (Math.random() < 0.3) {
        count += 1;
    }
}

int minVal = 2;
int maxVal = 10;
int randInt = (int)(Math.random() * (maxVal - minVal + 1) + minVal);    // 2 이상 ~ 9 미만
System.out.println(randInt);


// round() : 반올림, float -> int, double -> long 변환
System.out.println(Math.round(1.4f));   // 1

// addExact() : 덧셈 연산으로, Overflow 발생 시 ArithmaticException 발생.
// subtractExact() : 뺄셈 연산으로, Overflow 발생 시 ArithmaticException 발생.
// multiplyExact() : 곱셈 연산으로, Overflow 발생 시 ArithmaticException 발생.
try {
    System.out.println(Math.addExact(Integer.MAX_VALUE, 10));
    System.out.println(Math.subtractExact(Integer.MIN_VALUE, 10));
    System.out.println(Math.multiplyExact(Integer.MAX_VALUE, 4));
} catch(ArithmeticException e) {
    e.printStackTrace();
}

Java Stream API

heyoon2j — Mon, 28 Sep 2020 01:44:02 +0900

■ Stream API

- Java 8에 추가된 java.util.stream 패키지

- 컬렉션 요소를 람다식으로 처리할 수 있도록 돕는 함수형 프로그래밍 도구

• Stream API 특징

- 간결한 코드로 작성할 수 있다.

- 하지만 일반적으로 Stream으로 반복문을 실행하는 것보다 for문을 이용하는 방법이 빠르기 때문에, 무작정 사용하는 것은 속도를 느리게 만들 수 있다.

// JAVA 7
List<String> list = Arrays.asList("fast", "campus", "rocks");
List<String> newList = new ArrayList<>();

for (String s: list) {
    newList.add(s.toUpperCase());
}

for (String s: newList) {
    System.out.println(s);
}

// JAVA 8
List<String> list = Arrays.asList("fast", "campus", "rocks");
Stream<String> stream = list.stream();
stream.map(String::toUpperCase).forEach(System.out::println);

- 데이터 소스에 대한 공통된 접근 방식 제공, Stream으로 변경해주고 나면 List, Set, Map 모두 동일한 방식으로 데이터를 처리할 수 있다.

- 중간 처리와 최종 처리를 지원

• Stream 생성 방식

1. Collection의 인스턴스 메소드

- Stream stream() 메소드 이용

List<String> list1 = Arrays.asList("fast", "campus", "rocks");
Stream<String> stream1 = list1.stream();

2. Arrays를 이용하는 방법

- Arrays.stream() 메소드 이용

- IntStream, LongStream, DoubleStream 가능

int[] ints = {4, 6, 2, 19, 2, 58, 4, 6, 5};
IntStream intStream = Arrays.stream(ints);

3. Stream 클래스의 클래스 메소드

- Stream.of() 메소드 이용

DoubleStream doubleStream = DoubleStream.of(0.4, 0.6, 0.2, 1.2);

4. Stream의 range를 이용하는 방법

IntStream intStream1 = IntStream.range(0, 10);  // 10은 포함되지 않는다.
intStream1.forEach(System.out::println);
IntStream intStream2 = IntStream.rangeClosed(0, 10); // 10이 포함된다.
// LongStream도 range, rangeClosed가 있다.

5. Random 객체를 이용한 방법

- ints(), longs(), doubles() 메소드

- ints(streamSize, randomNumberOrigin, randomNumberBound)

Random random = new Random();
LongStream longStream = random.longs(100);  // 100개 제한
longStream.forEach(System.out::println);

LongStream longStream2 = random.longs(100, 0, 1000); // 0 부터 1000개

• Stream API 종류

1. Stream 종류

종류	처리 대상
Stream	일반적인 객체를 처리
IntStream	기본 자료형 int를 처리
LongStream	기본 자료형 long를 처리
DoubleStream	기본 자료형 double를 처리

2. 중간 처리 메소드

1) Filtering 메소드

- Stream distinct() - 스트림에 같은 요소가 있을 경우, 하나만 남기고 삭제하는 메소드

stringStream.distinct().forEach(System.out::println);

- Stream filter(Predicate<? super T> predicate) - Predicate 계열을 입력받아, true인 요소를 남긴다.

stringStream = Stream.of("Java", "Is", "Fun", "Isn't", "It", "?", "Java", "Java");
stringStream.filter(s -> s.length() >= 3)
   .forEach(System.out::println);

2) Cutting 메소드

- Stream limit(long maxSize) : 스트림의 최대 요소 개수가 maxSize인 스트림 반환

- Stream skip(long n) : 스트림의 최초 n개를 생략하는 메소드

3) Sorting 메소드

- compareTo() 또는 입력받은 Comparator를 이용해 정렬

- Stream sorted() : Comparator 객체를 정렬한 스트림 반환

- Stream sorted(Comparator<? super T> comparator) : Comparator를 이용하여 정렬

stringStream = Stream.of("abc", "fwf", "dnmov", "work");
stringStream.sorted().forEach(System.out::println);         // String 객체의 comateTo를 사용

stringStream = Stream.of("abc", "fwf", "dnmov", "work");
stringStream.sorted((o1, o2) -> o1.length() - o2.length())   // Comparator 인터페이스를 람다식으로 구현
        .forEach(System.out::println);
System.out.println();

4) Mapping 메소드

- Function 계열의 인터페이스를 사용하여 스트림의 각 요소를 매핑

- Stream map(Function<? super T, ? extends R> mapper) : 기존 스트림의 T 타입 요소를 R 타입으로 변환하여 새로운 스트림 반환

- PStream mapToP(ToPFunction<? super T> mapper) : R이 기본형 타입으로 제한된 map()

stringStream = Stream.of("abc", "fwf", "dnmov", "work");
// Function 계열로 String -> Integer로 변환하는 매핑, Function<String, Integer>
Stream<Integer> stream2 = stringStream.map(s -> s.length());
stream2.forEach(System.out::println);

- Stream flatMap(Function<? super T, ? extends Stream<? extends R>> mapper) : 스트림의 T 타입 요소가 n개의 R 타입 요소로 매핑된 새로운 스트림을 반환

- PStream flatMapToP(Function<? super T, ? extends PStream> mapper) : R이 기본형 타입으로 제한된 flatMap()

List<String> list2 = Arrays.asList("java", "backend", "best", "course");
System.out.println(list2.stream().flatMap(data -> {
   return Arrays.stream(data.split(""));
}).distinct().count());

5) Peek(조회) 메소드

- 중간 결과를 출력해 볼 수 있는 메소드(디버깅 기능)

- Stream peek(Consumer<? super T> action) : Consumer 계열의 람다식으로 입력받아 입력 요소를 소비

list2 = Arrays.asList("java", "backend", "best", "course");
list2.stream().flatMap(data -> {
   return Arrays.stream(data.split(""));
}).peek(s -> {
   System.out.println(s);
}).distinct().forEach(System.out::println);

3. 최종 처리 메소드

1) Maching 메소드

- boolean 타입의 값을 리턴

- boolean allMatch(Predicate<? super T> predicate) : 모든 요소가 true일 경우, true를 리턴

- boolean anyMatch(Predicate<? super T> predicate) : 하나라도 요소가 true일 경우 true를 리턴

- boolean noneMatch(Predicate<? super T> predicate) : 모든 요소가 false인 경우, true 리턴

Stream<String> st0 = Stream.of("avc", "def", "gop");
System.out.println(st0.allMatch(s -> s.equals("avc"))); // false

st0 = Stream.of("avc", "def", "gop");
System.out.println(st0.anyMatch(s -> s.equals("avc"))); // true

st0 = Stream.of("avc", "def", "gop");
System.out.println(st0.noneMatch(s -> s.equals("avc"))); // false

2) 집계(통계)

- 기본형 스트림(Int, Long, Double) : count(), sum(), average(), min(), max()

- Stream<T> 스트림 : count(), min(), max() -> (min과 max는 Comparator 구현 필요)

- T reduce(T identity, BinaryOperator accumulator) : identity를 초기값으로 하여, accumulator를 이용해 누적 집계 연산

* sum()이 실제로도 reduce로 구현되어 있다

IntStream.range(0, 10).reduce(0, (value1, value2) -> value1 + value2);

3) 반복 메소드

- void forEach(Comsumer<? super T> action) : Consumer 계열의 람다식을 입력받아, 각 요소를 소비

4) 수집 메소드

- Collectors 클래스의 정적 메소드를 이용하는 방법

- <R, A> R collect(Collector<? super T, A, R> collector) : Collection으로 변환시키는 메소드

- Collectors.toList() : ArrayList 반환

- Collectors.toSet() : HashSet 반환

- Collectors.toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper) : Map<K, U> 반환

- Collectors.toCollection(Supplier collectionFactory) : 입력 값으로 Collector로 변환

// Collectors 클래스의 정적 메소드를 이용하는 방법
// toList() 메소드를 쓸 경우, ArrayList로 Collect하는 Collector 반환
String[] array = {"Collection", "Framework", "is", "so", "cool"};
Stream<String> stream3 = Arrays.stream(array);
List<String> collected = stream3.filter(s -> s.length() >= 3)
//                         .collect(Collectors.toList());
                           .collect(Collectors.toCollection(LinkedList::new));
System.out.println(collected);

// toSet() 메소드를 쓸 경우, HashSet으로 collect하는 Collector 반환
Stream<String> stream4 = Arrays.stream(array);
Set<String> collected2 = stream4.filter(s -> s.length() >= 3)
                            .collect(Collectors.toSet());
System.out.println(collected2);

// toMap() : Map<K, V> -> Map.Entry<K, V> - Key, Value를 정해줘야 된다.
Stream<String> stream5 = Arrays.stream(array);
Map<String, Integer> collected3 = stream5.filter(s -> s.length() >= 3)
                            .collect(Collectors.toMap(s->s, String::length));
System.out.println(collected3);

5) 그룹화/분리 메소드

- Map<R, List> groupingBy(Function<? super T, ? extends K> classifier) : Key 값으로 Function을 입력받고, Key를 기준으로 List 타입으로 그룹화한다.

- Map<Boolean, List> partitioningBy(Predicate<? super T> predicate) : Key 값으로 Predicate를 입력받고, true, false에 따라 List 타입으로 분리된다.

String[] arr = {"Python", "is", "aweful", "lame", "not", "good"};
Map<Integer, List<String>> map = Arrays.stream(arr)
        .collect(Collectors.groupingBy(s -> s.length()));
System.out.println(map);

Map<Boolean, List<String>> map2 = Arrays.stream(arr)
        .collect(Collectors.partitioningBy(s -> s.length() < 4));

- 그룹화 + Downstream collector

- Collector 중에도 counting(), summingP(), averagingP(), maxBy(), minBy(), reducing() 이 있다.

Map<Integer, Long> map3 = Arrays.stream(arr)
                .collect(Collectors.groupingBy(String::length,Collectors.counting()));

6) 병렬 스트림

- 생성 방법

a. stream() 대신 parallelStream()으로 변경

b. stream 생성 후 parallel()으로 병렬화

Stream<String> parStream = Arrays.stream(arr).parallel();
System.out.println(parStream.map(String::length).count());

List<String> list4 = List.of("atew", "bff", "cqqwq", "dassa");
Stream<String> stream6 = list4.parallelStream();    // 병렬이기 때문에 연산 순서가 달라질 수도 있다! 내부적으로 여러 쓰레드가 계산하기 때문에
stream6.map(String::length)
        .peek(s -> System.out.println("A:" + s))
        .filter(value -> value > 3)
        .peek(s -> System.out.println("B:" + s))
        .forEach(System.out::println);

Terraform 시작하기

heyoon2j — Fri, 25 Sep 2020 00:18:05 +0900

■ Terraform Start

• Terraform Insatll (설치하기)

1. Download Terraform

- https://www.terraform.io/downloads.html

- 해당 OS에 맞는 버전 설치

wget https://releases.hashicorp.com/terraform/0.13.3/terraform_0.13.3_linux_amd64.zip
unzip terraform_0.13.3_linux_amd64.zip
mv terraform /usr/bin/terraform && sudo chmod +x
vi ~/.profile
   export PATH="$PATH:/usr/bin/terraform"

2. Version Check

terraform --version

• Basic (Terraform 기초)

1. Provider

- Terraform과 외부 서비스를 연결해주는 기능을 하는 모듈

- AWS, Azure, GCP와 같은 Public Cloud 뿐만 아니라, MySQL, DOcker와 같은 Local Service 등을 지원

- 서비스 종류는 공식 문서에서 확인 가능

* https://www.terraform.io/docs/providers/index.html#inner

2. HCL

- Hashicorp Configuration Language 약어

- Terraform에서 사용하는 설정 언어

- HCL 파일의 확장자는 .tf를 사용

3. Plan

- Terraform Project Directory 아래의 모든 .tf 파일의 내용을 실제로 적용 가능하지 확인하는 작업

- terraform plan 명령어를 제공하며, 해당 명령어 실행 시, 어떤 리소스가 생성, 수정, 삭제될지를 보여준다.

4. Apply

- Terraform Project Directory 아래의 모든 .tf 파일의 내용대로 리소스를 생성, 수정, 삭제하는 일을 적용이라 한다.

- terraform apply 명령어를 제공

• Using Terraform

- 동작을 위한 기본 Step은 다음과 같다.

1) HCL을 이용하여, .tf 파일에 Infra Resources을 정의한다.

2) terraform plan 명령어를 통해 Resources를 확인한다.

3) terraform apply 명령어를 통해 Resources를 적용한다.

Step 1. Provider Definition & Intialization

- Hashicorp Configuration Language 약어

- Terraform에서 사용하는 설정 언어

- HCL 파일의 확장자는 .tf를 사용

- 공식 문서 : https://registry.terraform.io/providers/hashicorp/aws/latest/docs#argument-reference

1. Make Project Directory

- 먼저 Project에 사용될 Directory 생성

mkdir ~/terraform_aws

2. Make Provider.tf

- Provider 정의

touch provider.tf
// 내용
terraform {
 required_providers {
   <PROVIDER_NAME> = {
    source  = "<SOURCE_PATH>"
     version = "~> 3.0"
  }
 }
}
provider "<PROVIDER_NAME>" {
 <ATTR_NAME> = "<ATTR_VALUE>"
}

- Example

terraform {
  required_providers {
    aws = {
      source  = "~/terraform_aws"
      version = "~> 3.0"
    }
  }
}
 provider "aws" {
  access_key = "<AWS_ACCESS_KEY>"
  secret_key = "<AWS_SECRET_KEY>"
  region = "ap-northeast-2"
 }

- AWS 설정 값은 보통 Provider에 쓰지 않고, 환경변수 또는 파일 설정을 통해서도 가능하다.

a. 환경변수 설정

#export AWS_ACCESS_KEY_ID="<AWS_ACCESS_KEY_ID>"         // access_key
#export AWS_SECRET_ACCESS_KEY="<AWS_SECRET_ACCESS_KEY>" // secret_key
#export AWS_DEFAULT_REGION="ap-northeast-2"             // region

b. 파일 설정

vi ~/.aws/config
[default]
region = ap-northeast-2

vi ~/.aws/credentials
[default]
aws_secret_access_key = <SECRET_KEY>
aws_access_key_id = <KEY_ID>

3. Terraform Project Initialization

- 이제 Provider를 기준으로 Project를 초기화시켜준다.

- terraform init 명령어 사용

Step 2. Write Modules

- Terraform에서는 Directory 하나가 모듈의 단위가 되기 때문에, 공용으로 사용되는 Infra 구성은 모듈화하여 관리한다.

- 모듈화하면, 재사용이 용이해진다.

- 공식 문서 : https://www.terraform.io/docs/modules/index.html

1. Module의 기본 구조

- 기본적으로 Module은 "Root Module"과 "Child Module"이 있다.

- Root Module에서는 다른 Child Module을 호출하여 출력 값을 다른 Child Module의 입력 값으로 전달하여 Module들을 연결시킬 수 있다.

- 중첩 Module의 경우는 "modules/"의 하위에 위치해야 한다.

a. Input variables

- 다른 Module로부터 입력받을 입력 값들을 관리

- variables.tf 파일에 저장

b. Output variables

- 다른 Module에게 반환할 출력 값들을 관리

- output.tf 파일에 저장

c. Resources

- Infrastructure Object들을 관리

- main.tf 파일에 저장

d. terraform.tfstate 및 terraform.tfstate.backup

- Terraform 상태를 포함하며, Terraform의 구성과 프로비저닝 된 인프라 간의 관계를 추적할 수 있다.

e. .terraform

- 인프라를 프로비저닝 하는데 사용되는 모듈과 플러그인이 포함되어 있다.

- .tf 파일에 정의된 인프라 구성이 아닌 Terraform의 특정 인스턴스에 한정된다.

f. *.tfvars

- Direcotry Structure

$ tree complete-module/
.
├── README.md
├── main.tf
├── variables.tf
├── outputs.tf
├── ...
├── modules/
│   ├── nestedA/
│   │   ├── README.md
│   │   ├── variables.tf
│   │   ├── main.tf
│   │   ├── outputs.tf
│   ├── nestedB/
│   ├── .../
├── examples/
│   ├── exampleA/
│   │   ├── main.tf
│   ├── exampleB/
│   ├── .../

2. Root Module

- 필수 요소인 Module

- 파일의 위치는 Project Root Directory에 위치해야 한다.

- Root Module은 다른 Module의 기본 진입점이다.

- main.tf에는 Child Module의 Source 위치 또는 Module들의 연결을 정의한다.

3. Child Module

- Resource들을 정의한다.

- main.tf Example

* 다른 Resource의 Argument에 접속하기 위해서는 <RESOURCE_TYPE>로 접근

# Syntax
resource "<RESOURCE_TYPE>" "<NAME>"{
  <ATTRIBUTE> = <VALUE>
}

# Example
resource "aws_vpc" "myVPC" {
  cidr_block = "${var.vpc_cidr}"
  tags = {
    Name = "${var.name}"
  }
  enable_dns_hostnames = "true"
}

- variables.tf Example

variable "name" {
  description = "VPC Name"
  type = "string"
}

- output.tf Example

output "myPub-id" {
  value = "${aws_subnet.myPubC.id}"
}

Step 3. Calling Modules

- Calling Child Module

* 자식 모듈 호출하는 방법

# INPUT_VARIABLE은 Module의 variables.tf 파일에 정의되어 있어야 한다.
# 다른 Module의 값을 사용하기 위해서는 다른 Module의 output.tf 파일에 정의되어 있거나, 해당 파일에 정의되어 있어야 한다. 
module "<MODULE_NAME>" {
 source = "<SOURCE_PATH>"
 <INPUT_VARIABLE> = "<STRING_VALUE>"
 <INPUT_VARIABLE> = <INTEGER_VALUE>
}

# example
module "ec2" {
 source = "./modules/ec2"

 vpc_id = "${module.vpc.spoonVPC}"
}
module "vpc" {
 source = "./modules/vpc"

 name = "spoonVPC"
 vpc_cidr = "192.168.0.0/16"
}

Step 4. Terraform Plan & Apply

1. terraform plan 명령어

- terraform plan 명령어를 실행하면, Terraform Code와 현재 Infra 상태를 비교하여 생성/변경/삭제할 Resource 항목들을 나열한다.

- 원하는 대로 결과가 출력이 되지 않으면 Code를 수정한다.

$ terraform paln

2. terraform apply 명령어

- terraform plan 명령어를 통해 원하는 결과가 확인되면, 결과를 현재 Infra에 적용해야 한다.

- terraform apply 명령어를 실행하면, 생성/변경/삭제할 Resource 항목들을 현재 Infra에 적용한다.

$ terraform apply

Step 5. Terraform Destroy

- terraform destroy 명령어

* 해당 명령어를 통해 Infra를 삭제한다.

$ terraform destroy [options] [dir]

Reference

- https://www.44bits.io/ko/post/terraform_introduction_infrastrucute_as_code

- Terraform 공식 사이트 : https://www.terraform.io/

참고하기 좋은 사이트

- https://github.com/futurice/terraform-examples

Terraform 이란?

heyoon2j — Thu, 24 Sep 2020 15:26:42 +0900

■ Terraform

- Terraform은 HashiCorp에서 만든 Infra Resource의 Modeling 및 Provisionin을 도와주는 Tool 이다.

• IaC (Infrastructure as Code)

- Code를 이용해 Infra를 관리한다는 의미

- IaC를 위한 Tool로는 Terraform, AWS CloudFormation 등이 있다.

• 멱등성

- 연산을 여러 번 적용하더라도 결과가 달라지지 않는 성질을 의미

- 기존 Script 같은 경우, 조건문을 이용하여 결과가 같아지도록 만들 수 있지만, 일반적으로 여러 번 실행에 대한 동일한 결과를 보장하지 않는다.

- 요즘에 나오는 Tools(Terraform, Ansible 등)은 멱등성을 제공한다.