[Java] 총 정리

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

암묵적 형변환(Implicit casting) : 자바 언어가 자동으로 해주는 형변환

* primitive type 에서 implicit casting 방향

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

명시적 형변환(Explicit casting) : 프로그래머가 직접 타입을 변환하는 것

 ex) (변환하고자 하는 타입명)변수 / 값

* 강제로 형변환을 하면 데이터 손실이 생길 수 있다.

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

상수 : final, 관례적으로 상수값을 담는 상수명은 대문자로 작성

 ex) final int NUM = 1;

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

서식화된 문자열(formmatted string)

* 화면에 출력할때는 printf() → printf("서식문자열", 값1, 값2, ...)

* 문자열(String)으로 만들 때는 String.format() → String.format("서식문자열", 값1, 값2, ...)

* 서식 지정자(format specifier)

  %d : 십진수 정수로 출력

  %f : 실수 출력

  %s : 문자열 출력

  %c : '문자하나' 출력

  %x : 16진수 정수로 출력

  %% : % 출력

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

자바의 기본 자료형(primitive data type)

* 정수 타입 : byte(1바이트), short(2바이트), int(4바이트), long(8바이트)

* 실수 타입 : float(4바이트), double(8바이트)

* 문자 타입 : char(2바이트)

* 논리 타입 : boolean

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

* String.format() 을 사용하면 원하는 포멧으로 출력 가능 

 ex) String.format("%x", number); 

        String.format("%X", number); 

        String.format("o", number);

 

* Integer.toXXX(n) 메소드를 사용하여 원하는 포맷으로 출력 가능

 ex) Integer.toHexString(number); 

        Integer.toOctalString(number); 

        Integer.toBinaryString(number);

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

* 아스키 코드 A : 65, a : 97

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

표준 입력(Standard Input) : 키보드로 부터 입력,  Scanner 객체 사용

 ex) Scanner sc = new Scanner(System.in);   // import 필요!

 

* nextChar는 없으므로 ex) char a = sc.next().charAt(0); 이런식으로 사용

* nextLine() : ENTER 단위로 문자열 읽어드리기

* next() : 공백 단위로 문자열 읽기

 

* 숫자 입력 뒤 문자열 입력에서 문제가 발생된다. (키보드 버퍼)

 ex) int age = sc.nextInt();

        sc.nextLine();   // 숫자 입력 후 키보드 버퍼에 남아있는 ENTER(\n)를 제거(consume)하는 목적

        String st = sc.nextLine();

        sc.close();

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

일반적으로 프로그램에서 숫자 입력하는 것이 처음에는 "문자열(String)" 형태다.   ex) 웹, 모바일앱 ...

이를 숫자 타입으로 변환해야 산술 연산등이 가능해진다.

* Integer.parseInt("문자열")   // int로 변환

* Double.parseDouble("문자열")   // Double로 변환

* Byte.parseByte("문자열")

* Short.parseShort("문자열")

* Long.parseLong("문자열")

* Float.parseFloat("문자열")

* Boolean.parseBoolean("문자열")

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

비트 연산자(bit operator, bitwise operator)

* a & b (and) : a,b가 모두 1이면 결과도 1, 그 외에는 0

* a | b (or) : a가 1이거나 또는 b가 1이면 결과는 1, a,b 모두 0일 때만 0

* a ^ b (xor) : a와 b 둘 중 하나만 1이 있는 경우는 1, 그 외에는 0 결국 둘이 같으면 0, 다르면 1

* ~a (not) : a가 1이면 0, a가 0이면 1로 바꿔줌

 

* 비트 이동(shift) 연산자 : >>, <<

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

삼항 연산자(ternary operator) : (조건식) ? 선택1 : 선택2

* 조건식이 true면 선택1이 선택되고, false면 선택2가 선택된다.

* 삼항 연산자는 if~else를 이용하여 식을 세우는거보다 간단하게 세울 수 있는 장점이 있다.

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

String 비교, char 비교

* char는 기본적으로 정수값(아스키 코드값)이라 일반 산술 비교 가능

* 문자열 비교는 절대로 == 를 사용하지 말자.

* 문자열 비교는 equals(), equalsIgnoreCase() 사용!

* equals() : 대소문자 구분,  equalsIgnoreCase() : 대소문자 구분 안함

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

do ~ while : 무조건 1번은 수행하고 while을 실행한다. while이 true면 계속 반복

* do ~ while은 가급적 사용 자제

* while, for 로 전환 가능

* break : 순환문(for, while, do ~ while)안에서 break를 만나면 break를 감싸는 가장 가까운 순환문 종료

* continue : 순환문(for, while, do ~ while)안에서 continue를 만나면 continue를 감싸는 가장 가까운 순환문으로 돌아감

* continue 사용 시 주의사항 while안에 if안에 continue를 사용하였을 경우 if문 아래 증감식이 들어가면 무한루프가 됨.

* for 무한루프 : for(;;) 조건식에 ;;를 넣으면 무한루프다.

 

break 레이블; : 레이블(label)위치까지 순환문 탈출

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

ragged array : column(열)의 개수가 일정하지 않은 배열

* 가변 배열 선언 방법 : 행의 개수만 지정을 하고, 열의 개수는 비워둠

* 열(column)이 몇개가 될 지 모르기 때문에 메모리 할당이 되지 않는다.

 ex) int [][] arr = new int [3][];   // int[]이 3개짜리인 2차원 배열만 생성

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

향상된 for문(Enhanced for)

 ex) for(배열타입 변수 : 배열이름) {. . .}

 

* for와 Enhanced for의 차이점

: Enhanced for문에서는 배열의 원소를 꺼내서 변수에 복사(저장)해서 사용하는 것 이다.

  즉, 배열의 원소를 직접 변경하는 것은 불가능하다.

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

java.util.Arrays 클래스 : 배열을 다루는 유용한 메소드를 제공

* Arrays.toString() : 문자열 형태로 리턴

* Arrays.copyOf(원본배열, 복사할 length)

* Arrays.copyOfRange(원본배열, from, to)

* Arrays.fill() : 배열에 특정 값으로 채우기

* Arrays.sort(원본배열) : 오름차순으로 정렬

* Arrays.asList() : array → List로 변경

* Arrays.toArray() : List → array로 변경

* String.join() : 구분자를 지정해서 String으로 얻을 수 있다.

* split() : ""를 넣으면 한글자씩 구분한다.

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

메소드 중복 정의(Method OverLoading)

: 같은 이름으로 메소드를 매개변수 리스트를 달리하여 중복 정의,

  즉, 이름이 같아도 메소드 signature가 다르면 중복정의 가능

 

*  Method Signature란 : 메소드 이름 + 매개변수 리스트(parameter list)

1. 매개변수의 개수가 다르거나

2. 매개변수의 자료형이 다르거나

3. 매개변수의 순서가 다를 때 

위 3개를 "매개변수 리스트"라 한다.

* 메소드의 리턴 타입만 다른 경우는 중복 정의 할 수 없다!

 

* 메소드 오버로딩의 장점

: 동일한 동작을 하는 메소드에 대해 매개변수만 달리하여 중복정의하면

  이 메소드를 사용하는 입장에선 여러타입의 이름을 익힐 필요가 없다.

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

Math 클래스의 메소드

* Math.floor(num) : num을 넘지 않는 가장 큰 정수

* Math.ceil(num) : num보다 큰 가장 작은 정수

* Math.round(num) : num에서 반올림

* Math.random() : 난수 발생

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

재귀 호출(recursive call)

* StackOverFlowError : Stack 메모리 영역에 공간이 없어서 생기는 오류! 해결 불가능

* OutOfMemoryError : Heap 메모리 용량 초과

 

* 재귀호출을 이용한 factorial 연산 : n! = n * (n - 1)! ex) num * 메소드명(num - 1);   // 재귀호출

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

클래스 : 우리가 만든 클래스를 사용하려면, 그 클래스의 인스턴스(실체 instance)를 생성해야 한다.

* 클래스이름 변수이름 = new 생성자();

* 생성자() : 클래스의 이름과 동일, 클래스의 멤버변수들을 초기화

* new로 생성하는 instance들은 지역변수와 달리 인스턴스가 생성될 때 자동으로 초기화 된다.

  특별히 초기화를 할 값들이 지정되어 있지 않을 때는 각 변수 타입의 기본값(default)으로 초기화 된다.

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

생성자(Constructor)

* 생성자의 목적 : 인스턴스 생성시 멤버변수들의 초기화

* 생성자의 이름은 반드시 클래스의 이름과 동일

* 생성자는 리턴 타입이 없다.

* 생성자도 매개변수(argument)를 가질 수 있다.

* 생성자도 오버로딩(overload) 가능

 

* 클래스를 만들 때, 생성자를 따로 만들지 않으면 디폴트 생성자(default constructor)를 자동으로 만들어준다.

* 디폴트 생성자 : 매개변수가 없는 생성자, 모든 멤버변수는 기본값으로 초기화

* 주의! 클래스에서 하나 이상의 생성자를 만들게 되면, 자동으로 디폴트 생성자를 만들어 주지 않는다.

  그러므로 아무일도 안하더라도 디폴트 생성자는 반드시 만들어 주자.

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

캡슐화(encapsulation), 은닉(hiding), 추상화(abstraction)

: 클래스 안에 필요한 "속성"과 "행동"을 멤버로 묶고 외부에서의 "직접적인 접근을 제한"하여 객체의 데이터와

  메소드를 은닉하고, 사용자에게는 필요한 기능만 제공하여 추상화하는 객체지향 기술을 캡슐화라고 한다.

 

* 클래스의 멤버변수를 접근하기 위한 기능을 제공하는 메소드를 getter, setter 라 한다.

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

클래스 안에서 this : 객체 내에서 자기자신(인스턴스)를 가르킨다.

 

메소드 체이닝(Method chaining)

: 자기자신을 리턴하여, 연이어 메소드 호출을 가능케하는 메소드 설계,

  보통 setter와 이와 같은 동작을 수행하는 메소드들에 적용하면 좋다.

 

* this는 자기자신 인스턴스이다. 메소드에서 this를 return하면 호출한쪽에서 곧바로 연이어 호출이 가능하다.

 ex) 객체.메소드1().메소드2().메소드2()...

 

* 메소드체이닝을 사용하면, 반복되는 지루한 코딩을 줄여줄 수 있다.

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

접근권한 수식어(Access Modifier) 접근 제한자

1. 종류 : private, (default), protected, public

2. 기능 : 멤버변수, 멤버메소드에 대한 접근 권한을 제한

 

* private : "자기 자신"이 선언된 클래스에서만 사용 가능

* (default) : "자기 자신" + "같은 패키지"에 있는 클래스들에서는 사용 가능

* protected : "자기 자신" + "같은 패키지" + "상속받은 클래스"에서 사용 가능

                           다른 패키지의 클래스라도 "상속" 받으면 사용 가능하다.

*  public : 어디서든 사용 가능

 

3. 사용 범위 : private < (default) < protected < public

 

* 클래스에 붙는 접근제한자는 딱 두가지이다.

1. public class : 어디에서나 인스턴스 생성이 가능한 클래스

* public 클래스의 이름은 .java 파일 이름과 반드시 같아야 한다.

 

2. (default) class : 같은 패키지에 있는 클래스들에서만 인스턴스 생성 가능

* 다른 패키지의 (default) 클래스는 import 할 수 없다.

 

* final 멤버 변수는 선언과 동시에 반드시 초기화 해야 한다.

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

클래스에 선언된 멤버 변수/ 멤버 메소드는 static 여부에 따라 아래와 같이 불려진다.

* 인스턴스 변수 : static이 안붙은 변수, 인스턴스를 생성한 다음에(new 생성자(); 호출된 다음에) 사용할 수 있는 변수

* 인스턴스 메소드 : static이 안붙은 메소드, 인스턴스를 생성한 다음에(new 생성자(); 호출된 다음에) 사용할 수 있는 메소드

 

* 클래스 변수(static 변수) : 클래스의 멤버 변수들 중에서, 인스턴스를 생성하지 않아도 사용할 수 있는 변수

* 클래스 메소드(static 메소드) : 인스턴스를 생성하지 않아도 사용 할 수 있는 메소드

 

클래스 변수 / 메소드의 특징(static)

1. 메모리의 "메소드 영역"에 클래스가 로드 될 때(프로그램 시작될 때) "한번만" 생긴다.

2. 인스턴스가 생성되지 않아도 사용할 수 있다.

* 클래스이름.static변수,  클래스이름.static메소드()   이렇게 사용한다.

 

3. 모든 인스턴스는 하나의 static 변수 / 메소드를 "공유"한다.

 

* Singleton 디자인 패턴 : 반드시 "하나"의 인스턴스만 유지되어야 하는 객체 설계

* 객체를 new 를 사용하여 생성하지 않고, getInstance() 를 사용하여 생성한다.

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

상속(Inheritance)의 이점

: 상속을 통하여 기존의 객체를 그대로 활용하면서, 새로운 객체에서 추가, 변경되는 부분만 작성함으로 개발 효율을 높일 수 있다.

 

* 자바에선 오로지 "하나의 부모" 로부터 상속 받을 수 있다. (단일 상속, 다중 상속 허용하지 않음)

* 상위클래스를 상속받아서 하위클래스를 정의하는 방법 → class 하위클래스 extends 상위클래스

* sub class(하위 클래스)에서는 super class(상위 클래스)가 가지고 있는 멤버 변수들은 선언하지 않아도 사용할 수 있다.

* 자바의 모든 클래스는 java.lang.Object로부터 상속 받는다. 그러므로 java.lang.Object는 모든 클래스의 부모 클래스이다.

 

* 상속에서 생성자 호출 순서

1. 자식 클래스의 생성자에서 명시적으로 부모 클래스의 생성자가 호출되지 않으면,  자동으로 부모 클래스의 "디폴트 생성자"가 호출된다.

2. 자식 클래스의 생성자에서 명시적으로 부모 클래스의 생성자를 호출하기도 한다.

  1) super(...) 키워드 사용 → 부모 클래스의 생성자를 호출

  2) (주의) super는 항상 제일 처음에 호출되어야 한다.

  3) 부모 클래스에 디폴트 생성자가 없는 경우도 있을 수 있다. 그런 경우에는 다른 생성자를 "반드시 명시적으로 호출"해줘야만 한다.

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

메소드 재정의(Overriding)

: "상속" 관계에서 "부모 클래스에 있던 메소드"를 "재정의"하는 것,  부모 클래스에 있는 메소드와 매개변수 리스트가 동일해야 한다.

  부모 클래스에 있는 메소드와 접근권한 수식어가 동일 할 필요는 없지만, 접근권한의 범위가 축소될 수는 없다.

  즉, 접근권한은 같거나 더 넓은 수식어를 사용해야 한다.

 

* 메소드 오버로딩(Overloading)과 혼동하지 말자!

 

* final 메소드 : 더이상 오버라이딩 불가

* final 클래스 : 더이상 상속 불가

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

다형성(Polymorphism) : 하나의 이름의 클래스나 메소드가 "여러 가지 형태의 동작을 하는 능력"

 

클래스의 다형성

: 한 타입의 참조변수로 여러타입의 객체를 참조 가능,

  조상 클래스 타입의 참조변수로 자손 클래스의 인스턴스를 참조 가능한 것

 

메소드의 다형성 : 메소드 오버로딩, 메소드 오버라이딩

* 다형성의 유용성 : 다형성에 의해서, 자식타입 객체가 부모타입으로 자동 형변환 가능!

                                    부모 타입만으로도 상속된 모든 자손 타이블을 담을 수 있다.

 

* instanceof 연산자 : 객체 타입을 확인하는 연산자, true, false를 리턴한다.

   ex) 객체 + instanceof + 클래스

 

* 다형성의 어려움 OOP03 참고 (타입 및 인스턴스, casting 관련)

 

* 클래스의 구조 : 멤버 변수 (+ 생성자) + 메소드 → 데이터 타입

 

추상 클래스(abstract class)

: 추상 메소드를 가지고 있는 클래스, 클래스를 선언할 때 abstract 키워드를 반드시 써 줘야 한다.

* 추상 클래스는 인스턴스를 생성할 수 없다. (new 불가능)

 

추상 메소드(abstract method)

: 원형(prototype)만 선언되 있고, 메소드 본체가 정의되지 않은 메소드, 메소드 본체가 없기 때문에 {} 부분이 없다.

  메소드 원형 끝에 ; 으로 끝낸다. 메소드 이름 앞에 반드시 abstract 키워드를 써 줘야 한다.

 

* 추상 클래스 사용 목적

: 추상 클래스를 상속 받는 자식 클래스에 반드시 구현해야 할 메소드가 있을 경우,

  그 메소드를 추상메소드로 만들어서 반드시 override하도록 하는데 목적이 있다.

 

* 추상 클래스, 메소드 관련 OOP04 참고

 

인터페이스(interface)

: 모든 메소드가 public abstract로 선언되고, 모든 멤버 변수가 public static final로 선언된 특별한 종류의 추상 클래스

* 인터페이스는 interface라고 선언한다. ex) interface TestInterface{}

* 인터페이스를 구현(상속)하는 클래스에서는 implements 키워드를 사용한다. ex) class TestImp implements TestInterface{}

* 인터페이스를 구현(상속)할 때는 개수 제한이 없다.

* 메소드 선언에서 public abstract와 멤버 변수 선언에서 public static final은 생략 가능하다.

* 인터페이스는 인스턴스 생성이 불가능하다. (new 사용 불가)

* 추상 메소드만 implement하는 목적으로 설계되는 인터페이스의 이름은 보통 ~able로 작명하는 경우가 많다.

 

* 인터페이스 2개를 다중 상속한 경우 양쪽에 동일한 이름의 Method가 있다면 한번만 implement 하면 된다.

* 다중 상속받은 클래스를 객체화한 후 그 안에 변수를 호출할 때 동일한 변수명이라면 클래스명.변수명 으로 호출해야 에러가 발생하지 않는다.

ex) System.out.println(TestInterface.MIN);

       System.out.println(TestInterface2.MIN);

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

컴파일 에러 : 문법상 오류

 

예외(Exception)

: 문법상의 오류가 아닌 "실행중"에 발생되는 오류상황, (기본적으로) 예외가 발생되면 예외 관련 메시지를 출력하고 프로그램이 종료된다.

 

* 예외처리(Exception handling)에 try ~ catch 를 사용하는 이유

1. if문은 예외 처리 이외의 용도로 사용되기 때문에 프로그램 코드상에서 예외처리 부분을 구분하기가 쉽지 않다.

2. try {} 블럭은 "일반적인 흐름"을 catch {} 블럭은 "예외처리" 블럭으로 만듦으로 코드 분석이 훨씬 용이하다.

 

* 특히 시스템 자원(resource), HW(파일, DB..) 등을 사용하는 프로그래밍에선 "예외"가 언제든지 발생할 수 있으므로 try ~ catch가 필수적이다.

* try 블럭 안에서 선언된 변수는 try 블럭안에서만 사용되는 지역변수가 된다.

   catch 블럭 등 다른 블럭에서도 사용 가능하게 하려면 try 바깥에서 선언해야 한다.

 

* getMessage(), printStackTrace() 등의 메소드는 Throwable 클래스에 정의되어 있으며,

   자식 클래스들은 Throwable에 정의된 메소드들을 사용할 수 있다.

* catch문은 여러개를 사용할 수는 있지만 상위 예외 클래스를 하위 예외 클래스보다 먼저 사용할 수는 없다. (컴파일 에러)

 

* multi ~ catch : Java 7부터 하나의 catch문에서 여러개의 예외를 처리할 수 있는 방법을 제공한다.

* 주의! 같은 상속 레벨의 exception들만 multi ~ catch 해야한다. (예외 클래스 상속 관계 확인)

 

* finally : 예외(exception) 발생 여부와 상관없이 항상 실행되어야 할 코드들은 finally 블럭 안에서 작성한다.

   즉, finally 블럭 안에 있는 코드들은 항상 실행이 된다.

   예외가 발생하지 않을 때에는 try 블럭 안에 코드들이 모두 실행된 후 finally 블럭의 코드들이 실행된다.

   예외가 발생할 때는 해당 catch 블럭의 코드들이 실행된 후에 finally 블럭의 코드들이 실행된다.

* 주의! try 블럭이나 catch 블럭 안에 return이 있더라도 finally 블럭 안에 코드들이 다 실행된 후에 return이 실행된다.

* 주의! try 블럭, catch 블럭, finally 블럭등에서 두루두루 사용할 변수는 try 블럭전에 선언하고, 초기화까지 하면 좋다.

* 보통은 자원반납과 같은 것들을 할 때 finally 활용

 

throws

: 메소드 설계를 할 때 예외 처리를 직접 하지 않은 경우, 메소드 이름 뒤에 throws Exception을 추가하면 메소드를 호출한 곳으로 exception이 던져진다.

  "Exception" 및 이를 "직접 상속받은" Exception을 throws 하는 메소드의 경우 이 메소드를 호출하는 쪽에서 반드시 예외 처리(handling)해야 한다.

  반면 "RuntimeException" 및 이를 상속바은 예외를 throws하는 메소드는 굳이 호출하는 쪽에서 매번 예외 처리를 할 필요는 없다.

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

String 관련 메소드

* String.length() : 문자의 개수

* String.concat() : 문자열 연결 → 문자열(String)은 변경불가(immutable)이기 때문에 메소드를 수행해도 원본이 변경되지 않는다.

* String.charAt() : 문자열 안에 특정위치(index)의 문자 리턴, 인덱스는 0부터 시작

* String.indexOf() : 문자열 안에서 특정 문자(char)의 위치(index) 리턴, 발견 못하면 -1 리턴

* String.toUpperCase() : 대문자로 변환

* String.toLowerCase() : 소문자로 변환

* String.startWith() : 문자열이 주어진 prefix 문자열로 시작하는지 여부를 true, false로 리턴

* String.split(regex) : 문자열을 주어진 문자열로 쪼개어 String[] 리턴

* String.join() : 문자열들, 문바열 배열을 하나의 문자열로 합친다.

* String.substring(beginIndex, endIndex) : 문자열의 일부분 추출 beginIndex ~ endIndex 직전까지

* String.trim() : 좌우의 여백 제거

* String.replace(target, replacement) : 문자열 치환 target → replacement

* String.replaceAll(target, replacement) : 매칭되는것을 전부 치환

* String.replaceFirst(target, replacement) : 첫 매칭만 치환

* String.compareTo() : 두 문자열의 문자코드량을 비교, 유니코드 값을 비교한다. → 동일하면 0을 리턴

 

StringBuffer, StringBuilder

: String 클래스는 immutable 클래스이고, StringBuffer, StringBuilder는 mutable 클래스이다.

* StringBuffer : Java ver 1.0부터 있던 클래스이며, 쓰레드에 안전(thread-safe)하지만 속도가 느리다.

* StringBuilder : Java 5부터 생긴 클래스이며 쓰레드에 안전하지 않다(thread-unsafe). 하지만 속도가 빠르다.

* StringBuffer.append(data) : 데이터를 문자열 끝에 추가한다.

* StringBuffer.delete(start, end) : start에서 end까지의 문자열 삭제

* StringBuffer.deleteCharAt() : 해당 인덱스 문자열 삭제

* StringBuffer.insert(offset, data) : offset 위치에 data를 삽입한다.

* StringBuffer.replace(start, end, str) : start에서 end까지의 문자열을 str로 치환한다.

* StringBuffer.reverse() : 문자열 역순

 

StringTokenizer 클래스

ex) StringTokenizer tokenizer = new StringTokenizer(str, ":");

 

* token ? : "규칙"에 의해 구분된 더 이상 나눌 수 없는 문자요소(문자열)

* tokenizer.countTokens() : 토큰 개수

* tokenizer.hasMoreTokens() : 더 뽑아낼 토큰이 있는지 true,false 리턴

* tokenizer.nextToken() : 토큰 뽑아내기

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

Wrapper 클래스 : 기본 자료형(primitive type)의 데이터를 감싸는 클래스

* 기본 자료형 : boolean, char, byte, short, int, long, float, double

* Wrapper : Boolean, Character, Byte, Short, Integer, Long, Float, Double

* Wrapper 클래스는 String과 마찬가지로 immutable하다.

* Wrapper 클래스의 static 메소드 valueOf(primitive type or String) : 입력받은 인자 값을 지정된 객체형으로 변환하여 반환한다.

ex) Integer num1 = Integer.valueOf(100);

       Double num2 = Double.valueOf(100);

       Integer num3 = Integer.valueOf("100", 16); → 문자열 100을 16진수로 변환하여 Interger형으로 변환

 

Wrapper 클래스의 auto-boxing / unboxing

* boxing(포장) : 기본자료형의 값을 Wrapper 클래스에 저장

* unboxing(개봉) : Wrapper 클래스에 저장된 기본자료형 값을 꺼냄

ex) Integer num1 = 10; → auto-boxing, Integer.valueOf(10) 동작

       int n1 = num1; → auto-unboxing, num1.intValue() 동작

 

* BigInteger : 정수타입 기본자료형으로 담을 수 없는 한계 범위 밖에 값들을 다룰 때 사용하는 객체

* BigDecimal : 실수타입 기본자료형에서 발생하는 정밀도(오차)의 문제를 극복하기 위해 사용하는 객체

 

Wrapper 클래스의 유용성

1. Object 타입이 모든 타입(primitive 타입 포함)도 받을 수 있다.

2. Collection과 같은 Generic 클래스에선 primitive타입을 담을 수 없다. 하지만 Wrapper를 통해 가능하다.

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

Generic 클래스

: 클래스의 멤버변수나 혹은 메소드의 리턴 "타입", 매개변수등의 "타입"을 지정하지 않고 generic(일반적으로)하게 정의하는 클래스

* 동작은 같으나, 데이터 타입만 다른 경우 Generic으로 설계함으로 코드 생산성 향상

* Generic 클래스에서 사용되는 타입은 기본 자료형(primitive type)은 사용될 수 없고, Object타입의 자료형들만 사용할 수 있다.

 

* List 특징(ArrayList와 LinkedList의 공통점)

1. 중복 저장 허용

2. 저장 순서 유지(인덱스 존재)

 

* ArrayList

1. 저장 용량을 늘리는데 많은 시간 소요 - 단점

2. 데이터를 삭제하는데 많은 연산 - 단점

3. 데이터 참조가 매우 빠름 - 장점

 

* LinkedList

1. 저장 용량을 늘리는 과정이 매우 간단 - 장점

2. 데이터를 삭제하는 과정이 간단 - 장점

3. 데이터 참조가 불편 - 단점

 

List Method

* list.add(element) : 데이터 추가(저장)

* list.add(index, element) : index에 데이터 삽입

* list.get(index) : 데이터 참조(읽기, 검색)

* list.remove(index) : 데이터 삭제

* list.set(index, element) : 데이터 수정

* list.size() : List의 크기를 리턴

 

List 출력 방법

1. for 사용

2. Enhanced-for(향상된 for문) 사용

3. forEach() 사용

4. Iterator(반복자) 사용

* iterator() 메소드를 사용해서 인스턴스 생성 ex) Iterator<Integer> itr = list.iterator();

* hasNext() : iterator가 다음 원소를 가지고 있는 지(true, false 리턴)

* next() : 현재 iterator 위치의 원소 값을 리턴하고, iterator의 위치를 다음 원소의 위치로 변경

 

* Set의 특징

1. 자료의 중복 저장이 허용되지 않는다.

2. 저장 순서가 유지되지 않는다. (인덱스가 없다.)

 

* HashSet의 특징 : 매우 빠른 검색 속도

* HashXXX는 "검색 속도 향상"을 쓰는 자료구조이다.

 

* TreeSet의 특징 : 데이터가 정렬된 상태로 저장(오름차순, 내림차순)

* TreeXXX는 "정렬"에 특화된 자료구조이다.

 

Set Method

* set.add() : 데이터 저장

* set.size() : Set의 크기

* set에서 데이터 검색 : set은 index가 없기 때문에 get() 메소드를 제공하지 않는다.  따라서 iterator(반복자)를 사용해야 한다.

* set에서 순서없이 값만 출력할 때는 enhanced-for를 사용하면 된다.

* set.remove(element) : 데이터 삭제, element가 있으면 삭제 후 true 리턴, 없으면 false 리턴

* set.remove()는 index가 아니라element이다.

* set은 데이터 변경을 할 수 있는 set() 메소드를 제공하지 않는다. 따라서 remove 후 add를 해서 변경하는 효과를 내야한다.

 

* TreeSet, HashSet 둘 다 iterator() 메소드를 사용하면 오름차순으로 정렬된다.

* TreeSet에서 descendingIterator() 메소드를 사용하면 내림차순으로 정렬된다.

 

Map : key-value 저장 방식의 자료구조

1. key는 중복되지 않는 값만 허용

2. value는 같더라도 key값이 다르면 저장 가능

3. 검색, 수정, 삭제를 할 때 key를 사용

 

* HashMap : hash값에 의해 순서가 정해지지만 출력에는 순서가 없다.

* LinkedHashMap : HashMap과 다르게 순서가 있으며 입력한 순서대로 출력된다.

* TreeMap : key값이 알파벳 순서대로 자동 정렬(Sort)된다. 출력 또한 알파벳 순서대로 출력된다.

 

Map Method

* map.put(Key, Value) : 데이터 저장, 같은 key값으로 데이터를 put하면 기존 값이 수정(replace)된다.

* map.size() : 저장된 데이터 개수 확인

* map.remove(key) : 데이터 삭제, 없는 key값을 삭제하면 null 리턴

* map.get(key) : 데이터 읽기, 없는 key값은 null 리턴

* map.ketSet() : key값을 전부 가져온다. (Set 타입)

* map.entrySet() : key값과 value값을 전부 가져온다.

* map.values() : value값을 전부 가져온다. (Collection 타입)

 

방법1 : HashMap에서 Iterator를 사용하여 순서를 부여하여 출력하기.

1.  HashMap의 keySet() 메소드를 사용해서 저장된 key값들로만 이루어진 set을 만든다.

ex) Set<Integer> keySet = map.keySet();

 

2. 1에서 만든 Set을 iterator() 메소드를 사용해서 Iterator를 생성 이후 출력

방법2 : Map.Entry 사용

* entrySet()은 Set<Entry<T, T>>을 리턴해준다.

* TreeMap에만 있는 KeySet을 만들어 내는 메소드

ex) NavigableSet<T> navi = tmap.navigableKeySet();

 

* TreeMap도 keySet을 만든 후 descendingIterator()를 사용하여 내림차순(역순)으로 정렬할 수 있다.

 

Collections Method

* Collections.sort() : 오름차순 정렬, String 타입이면 알파벳 순으로 정렬, Date 타입이면 날짜순으로 정렬된다.

* Collections.reverseOrder() : 역순 정렬

ex) Collections.sort(E, Collections.reverseOrder());

 

* Collections.sort() 메소드는 두번째 인자로 Comparator 인터페이스를 받을 수 있도록 해놓았으며,

   필요에 따라서 Comparator 인터페이스의 compare 메소드를 오버라이드하여 사용하면 된다.

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

알고리즘의 성능, 프로그램의 성능을 가늠하는 대표적인 두가지 척도

1. 시간복잡도(Time Complexity) : 얼마나 시간이 많이 걸리는지

2. 공간복잡도(Space Complexity) : 얼마나 많은 메모리를 소모하는지

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

내부 클래스(Inner Class)

1. 멤버 내부 클래스(Member inner class) : 다른 클래스 내부에서 선언된 클래스

* 멤버 내부 클래스의 인스턴스 생성

ex) [외부클래스이름].[멤버내부클래스이름] 참조변수 = [외부클래스인스턴스].new 내부클래스생성자();

 

2. static 내부 클래스(Static inner class) : 다른 클래스의 내부에서 static으로 선언된 클래스

3. 지역 클래스(Local class)

 1) 지역 내부 클래스(Local inner class) : 메소드 내부에서 선언된 클래스

 2) 익명 내부 클래스(Anonymous inner class) : 이름이 없는 local class

 

* 내부 클래스로 설계하는 상황

: 상속 관계로 묶을 수는 없지만, A라는 객체가 생성된 이후에 존재할 수 있는 B라는 객체가 있다고 한다면 B를 A의 멤버 내부 클래스로 선언한다.

 

중첩 클래스(Nested Class)

: 다른 클래스의 내부에서 멤버로 정의된 클래스인데 static 키워드가 사용된 내부 클래스(static inner class)

* nested(static) class는 외부 클래스의 인스턴스를 생성하지 않았기 때문에 (외부 클래스에서)static으로 선언된 변수와 메소드만 사용 가능하다.

* nested class는 외부 인스턴스에서 생성할 수 없다.

* 중첩 클래스의 인스턴스 생성

ex) [외부클래스이름].[내부클래스이름] 참조변수 = new [외부클래스이름].내부클래스생성자();

 

* static

: 클래스의 인스턴스가 생성되지 않아도 사용될 수 있는 멤버(변수, 메소드)에 사용 따라서,

  nested class는 외부 클래스의 인스턴스를 생성하지 않고, 내부 클래스의 인스턴스를 생성할 수 있다.

 

Local Inner Class : 블록({...}) 내부에서 정의된 클래스

1. 정의가 된 블록(메소드) 내부에서만 사용 가능 → 참조변수 선언, 인스턴스 생성

2. 접근 수식어(public, protected, private)는 쓸 수 없다.

3. 외부 클래스의 멤버 변수(private 포함)는 모두 사용 가능

4. effectively final인 지역변수나 매개변수만 사용 가능

* effectively final 변수

: final로 선언된 변수, 또는 한번 초기화가 된 이후로 값이 변경되지 않은 변수(Java 8에서 도입)

 

* 지역 클래스는 메소드 실행이 끝나면 정의가 자체가 사라지는 클래스이다. 메소드 내부에서  정의된 지역 클래스 타입을 리턴하는 메소드는 만들 수 없다.

   경우에 따라서, 지역 클래스의 정의된 메소드를 외부에서 직접 사용하고자 하는 경우에는 인터페이스 + 다형성을 이용한 방법을 사용해야한다.

1. 외부에서 사용하고 싶은 메소드를 선언한 인터페이스를 작성한다.

2. 메소드의 리턴 타입은 정의한 인터페이스 타입으로 정의한다.

3. 로컬 클래스는 인터페이스를 구현(implement)하도록 정의한다.

4. 로컬 클래스의 인스턴스를 생성하고 리턴해준다.

* InnerClass06, Person 참고

 

익명 내부 클래스(Anonymous inner class)

: 이름이 없는 local inner class, 이름이 없기 때문에 생성자를 만들 수가 없다. 클래스의 정의와 동시에 인스턴스를 생성한다.

 

람다 표현식(Lambda-expression)

: Java8부터 도입 된 더 간략화한 표현식이며, 추상메소드가 하나인 인터페이스 구현에 쓰인다. 즉 익명 클래스 사용

ex) (매개변수 리스트) -> 리턴값

       (매개변수 리스트) -> {...} 수행코드

 

* 세가지 방법으로 자유자재로 구현할 수 있어야한다.

1. 클래스 implements 인터페이스 + 오버라이딩

2. 익명클래스

3. 람다 표현식(Lambda expression)

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

쓰레드(Thread) : 동일 프로세스 내에 "독립"적인 다중 수행 프로그램 단위

* 쓰레드(Thread) 사용 목적 :  병행성 증진, 처리율 향상, 응답속도 향상 목적

 

자바에서 쓰레드를 만들어서 사용하는 방법

1. Thread 클래스를 상속받는 클래스를 정의

2. 정의한 클래스에서 run() 메소드를 override 해 쓰레드에서 할 일을 구현한다.

3. Thread 클래스의 인스턴스 생성 ex) Thread th1 = new Thread(test);

4. 생성된 인스턴스에서 start() 메소드 호출

 

* Runnable 인터페이스는 run() 가상메소드 하나만 가지고 있는 인터페이스이기 때문에 Lambda-expression으로도 구현 가능하다.

 

Thread Method

* Thread.run() : 쓰레드가 실행할 부분 기술(오버라이딩 해야함)

* Thread.start() : 쓰레드 시작, run() 메소드 호출

* Thread.sleep() : ms단위로 딜레이를 준다.

* Thread.setPriority() : Thread 클래스가 가지고 있는 메소드이며, 쓰레드의 우선순위(priority)를 변경하는 기능

* Thread 클래스에 정의된 우선순위 : MAX_PRIORITY(10), MIN_PRIORITY(1), NORM_PRIORITY(5)

* Thread.join() : 지정한 시간 동안 쓰레드가 실행되도록 둔다. 지정한 시간이 지나거나, 작업이 종료되면 join()을 호출한 쓰레드로 돌아와 실행한다.

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

java.io 패키지의 주요 클래스

1. 바이트(byte) 단위 입출력 스트림 클래스

 1) java.io.InputStream : 프로그램이 "바이트 단위" 데이터를 읽어들이는(read) 통로

 2) java.io.OutputStream : 프로그램이 "바이트 단위" 데이터를 쓰는(write) 통로

* 위 두개 클래스는 추상클래스이다.

 

2. 문자(character) 단위 입출력 스트림 클래스

 1) java.io.Reader : 프로그램이 "문자 단위" 데이터를 읽어들이는(read) 통로

 2) java.io.Writer : 프로그램이 "문자 단위" 데이터를 쓰는(write) 통로

 

3. java.io.File : 파일 시스템의 파일정보를 얻기 위한 클래스

 

4. java.io.Console : 콘솔로부터 문자를 입출력하기 위한 클래스

 

＃-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------