exp_blog

1.String 클래스

-대소문자 변환

• toUpperCase 메소드 : 모든 글자를 대문자로
• toLowerCase 메소드 : 모두 소문자로 변환
• myString 자체를 바꾸는 것이 아니라 새로운 문자열로 리턴시켜주는 것 

String myString = "aBc";
System.out.println(myString.toUpperCase()) // 모두 대문자로
System.out.println(myString.toLowerCase()) // 모두 소문자로
System.out.println(myString)               // 그대로

ABC
abc
aBc

-문자열 비교

->참조형 비교 연산자(==)는 가리키는 인스턴스가 같은 인스턴스인지 확인하는 역할

두 문자열의 내용이 같은지 비교하려면 equals 메소드를 사용

String myString = "aBc";
System.out.println(myString.toLowerCase().equals("abc"));

true

2.숫자 도구

-Math 클래스

   -절대값

import java.lang.Math;

public class Driver {
    public static void main(String[] args) {
        System.out.println(Math.abs(-10));
        System.out.println(Math.abs(8));
    }
}

10
8

  -최소값, 최대값

import java.lang.Math;

public class Driver {
    public static void main(String[] args) {
        System.out.println(Math.min(4, 10));  // 최솟값
        System.out.println(Math.max(4, 10));  // 최댓값
    }
}

4
10

-Random 클래스

-> 인스턴스를 생성해서 사용해야함

import java.util.Random;

public class Driver {
    public static void main(String[] args) {
        Random rand = new Random();
        System.out.println(rand.nextInt(10));   // 0 이상 9 이하의 랜덤한 값
    }
}

-a ~ b 사이의 랜덤 값

import java.util.Random;

public class Driver {
    public static void main(String[] args) {
        Random rand = new Random();
        int min = 10;
        int max = 30;

        System.out.println(rand.nextInt((max - min) + 1) + min);   // 10 이상 30 이하의 랜덤한 값
    }
}

3.Wrapper Class

-> 기본 자료형을 객체 형식으로 감싸는 역할

->Integer 클래스는 int형을, Double 클래스는 double을, Long 클래스는 long을, Boolean 클래스는 boolean을 감쌈

-> ArrayList 같은 컬렉션을 사용할 때 꼭 참조형을 사용해야 함

-> 인스턴스는 생성자로 생성할 수도 있고, 리터럴로 생성할 수도 있음

Integer i = new Integer(123);
Integer i = 123;

-주의할 점

System.out.println(123 == 123);
System.out.println(new Integer(123) == new Integer(123));

true
false //참조형의 비교 연산자는 가리키는 객체가 같읕지 비교하기 때문입니다. 두 생성자를 통해 만든 다른 객체이기 때문에 

두 String 인스턴스를 비교할 때 처럼 equals 메소드를 쓰면 '값'이 같은지 확인

System.out.println(new Integer(123).equals(new Integer(123)));

true

4.ArrayList

import java.util.*
import java.util.ArrayList

• 객체들을 삽입, 삭제, 검색 할 수 있는 컨테이너 클래스
• 배열의 길이 제한 단점을 극복할 수 있다
• 삽입되는 객체의 수가 많아지면 자동으로 크기가 조절된다
• 아이템을 벡터의 맨 마지막이나 중간에 삽입할 수 있다
• ArrayList 맨 뒤에 객체 추가 : 벡터 공간이 모자라면 자동 늘림
• ArrayList 중간에 객체 삽입 : 뒤에 존재하던 객체는 한칸씩 뒤로 이동
• 임의의 위치에 있는 개체 삭제 : 객체 삭제 후 한칸씩 앞으로 자동 이동

선언 방식

ArrayList<test> myList = new ArrayList<test>(); //선언방식

<> 안에 들어가는 것 : List 타입

<주요 메소드>

myList.add(Object elem)
     객체 매개변수(elem)를 목록에 추가

myList.remove(int index)
     index 매개변수로 지정한 위치에 있는 객체를 제거

myList.remove(Object elem)
     주어진 객체가 List에 있으면 그 객체를 제거

myList.contains(Object elem)
     객체 매개변수 elem에 매치되는 것이 있으면 '참'을 리턴

myList.isEmpty()
     목록에 아무 원소도 없으면 '참'을 리턴

myList.indexOf(Object elem)
     객체 매개변수(elem)의 인덱스 또는 -1을 리턴

myList.size()
      현재 목록에 들어있는 원소의 개수를 리턴

get(int index)
      주어진 index 매개변수 위치에 있는 객체를 리턴

5.HashMap

->  'value(원소)'와, 그 원소를 가리키는 'key' 값을 같이 저장

-사용

   ->HashMap의 키로는 String을 쓰는 것이 가장 일반적

-선언하기

HashMap<String, Pokemon> pokedex = new HashMap<>();

-key-Value 쌍 추가하기(put 메소드)

pokedex.put("피카츄", new Pokemon("피카츄"));
pokedex.put("파이리", new Pokemon("파이리"));
pokedex.put("이상해씨", new Pokemon("이상해씨"));
pokedex.put("이상해풀", new Pokemon("이상해풀"));
pokedex.put("이상해꽃", new Pokemon("이상해꽃"));

-값 꺼내기(get 메소드)

Pokemon pikachu = pokedex.get("피카츄");

-원소 덮어쓰기

pokedex.put("피카츄", new Pokemon("라이츄");

-반복문을 통해 HashMap 탐색하기

• HashMap의 keyset메소드는 모든 key를 담고 있는 Set을 리턴
• Set은 List나 Map과 같이 원소를 담고 있는 자료형 중 하나이며 'for each'문으로 탐색이 가능

for (String key : pokedex.keySet()) {
    System.out.println(pokedex.get(key));
}

(심화) 동작원리

HashMap의 key는 'hashcode'라는 것으로 관리

hashcode는 모든 클래스의 인스턴스가 가진 고유한 값인데, 인스턴스마다 다르기 때문에 HashMap이 key를 구분하는 값으로 사용

(여러 인스턴스가 같은 hashcode를 가질 수 있으며, 이 경우 HashMap에선 key.equals(anotherKey) 메소드로 구분).

일반적인 클래스는 인스턴스 생성시 hashcode 값이 결정

즉, 같은 정보를 담고 있는 두 인스턴스가 서로 다른 hashcode를 가질 수 있다

그런데 String은 서로 다른 인스턴스라도 안의 내용이 같으면 같은 hashcode를 가짐.

그렇기 때문에 HashMap의 key로서 String이 매우 적합.

Key는 실제 인스턴스보다는 안에 담긴 의미, 내용으로 구분하는 것이 좋기 때문!!

1. 기본형 vs 참조형

-기본형 : int / boolean / char / double 

int a = 3;
int b = a;

System.out.println(a);  // 3 출력
System.out.println(b);  // 3 출력

a = 4;
System.out.println(a);  // 4 출력
System.out.println(b);  // 3 출력

b = 7;
System.out.println(a);  // 4 출력
System.out.println(b);  // 7 출력

-참조형 : Person, String , int[] 등 클래스 기반 자료형

Person p1, p2;
p1 = new Person("김신의", 28);

p2 = p1;
p2.setName("문종모");

System.out.println(p1.getName()); //문종모
System.out.println(p2.getName()); //문종모

p1은 '김신의'라는 이름을 가진 Person 인스턴스가 저장되어있음

p2 = p1 => p2에게 같은 영역을 가리키라

p2.setName("문종모") 를 하면 그 영역에 있는 인스턴스의 name -> 문종모  로 바뀜

p2, p1은 모두 같은 영역을 가리키고 있으니 두 출력 값은 모두 '문종모'

배열 또한 객체이기에 참조형

int[] a = new int[3];
int[] b = a;

a[0] = 1;
b[0] = 2;

System.out.println(a[0]); //2
System.out.println(b[0]); //2

2. null 

비어있음 -> null 로 표현

단, null은 참조형 변수(Reference Type)만 가질 수 있는 값

Person p1 = null;
System.out.println(p1); //null

//만약, null을 보관하고 있는 변수의 메소드를 호출하려고 하면 오류 발생
Person p1 = null;
p1.getName(); //Exception in thread "main" java.lang.NullPointerException

//대처법
Person[] people = new Person[5];
people[0] = new Person("김신의", 28);
people[2] = new Person("문종모", 26);
people[3] = new Person("서혜린", 21);

for (int i = 0; i < people.length; i++) {
    Person p = people[i];
    if (p != null) {
        System.out.println(p.getName());
    } else {
        System.out.println(i + "번 자리는 비었습니다.");
    }
}

/*김신의
1번 자리는 비었습니다.
문종모
서혜린
4번 자리는 비었습니다.*/

3. 숏서킷 연산(Short-Circuit Evaluation)

-> 실의 결과값이 이미 결정된 경우 미리 멈추는 것

-And (&&)

boolean newBoolean = m1() && m2() && m3();

-> newBoolean이 true가 되기 위해서는  m1(), m2(), m3()가 모두 true를 리턴해야함

-Or (||)

boolean newBoolean = m1() || m2() || m3();

-> newBoolean이 false이기 위해서는 m1(), m2(), m3()의 리턴값이 모두 false이어야 함

4. 변수 안전하게 만들기(final)

-변수 정의 시 final을 써주면, 그 변수는 상수가 됨 -> 한번 정의하면 다시 바꿀 수 없음

-참조형

public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    public static void main(String[] args) {
        final Person p1 = new Person("김신의");
        p1.setName("문종모");
        System.out.println(p1.getName());
    }
}
//문종모

->p1의 이름을 못 바꾸도록 만들고 싶으면 Person 클래스 내에서 name을 final로 정의해주면 됨.

5. 인스턴스 변수 vs 클래스 변수

-인스턴스 변수

public class Person {
    int count;
}

//새로운 Person 인스턴스를 생성할 때마다 각 인스턴스의 count변수를 계속 바꿔야함
public static void main(String[] args) {
    Person p1 = new Person();
    p1.count++;

    Person p2 = new Person();
    p1.count++;
    p2.count = p1.count;

    Person p3 = new Person();
    p1.count++;
    p2.count++;
    p3.count = p2.count;

    Person p4 = new Person();
    p1.count++;
    p2.count++;
    p3.count++;
    p4.count = p3.count;

    System.out.println(p1.count); //4
    System.out.println(p2.count); //4
    System.out.println(p3.count); //4
    System.out.println(p4.count); //4
}

-클래스 변수 버전

public class Person {
    static int count;
}

//count는 특정 인스턴스에 해당되는게 아니라, Person 클래스 전체에 해당되는 것
//count 부를 때 대문자로 쓴 클래스 이름을 사용해서 Person.count 써준다

public static void main(String[] args) {
    Person p1 = new Person();
    Person.count++;

    Person p2 = new Person();
    Person.count++;

    Person p3 = new Person();
    Person.count++;

    Person p4 = new Person();
    Person.count++;

    System.out.println(Person.count);
} //4

-> Person.count++ 매번해주는 것을 개선시켜주자 

public class Person {
    static int count;

    public Person() {
        count++;
    }
}

public static void main(String[] args) {
    Person p1 = new Person();
    Person p2 = new Person();
    Person p3 = new Person();
    Person p4 = new Person();

    System.out.println(Person.count);
}//4

-> 변수가 클래스 자체에 해당될 때는 static 써서 클래스 변수로 만들어주자!

-상수

상수는 인스턴스에 해당되는 것이 아니며, 여러 복사본 대신 한 값만 저장해둔다

public class CodeitConstants {
    public static final double PI = 3.141592653589793;
    public static final double EULERS_NUMBER = 2.718281828459045;
    public static final String THIS_IS_HOW_TO_NAME_CONSTANT_VARIABLE = "Hello";

    public static void main(String[] args) {
        System.out.println(CodeitConstants.PI + CodeitConstants.EULERS_NUMBER);
    }
}//5.859874482048838

6.인스턴스 메소드 vs 클래스 메소드 

-클래스 메소드 : 인스턴스가 아닌 클래스에 속한 메소드

-> 인스턴스를 생성하지 않고도 바로 실행할 수 있다

<클래스 메소드 예시>

-Math 클래스 

import java.lang.Math;

public class Driver {
    public static void main(String[] args) {
        System.out.println(Math.abs(-10));   // 절댓값
        System.out.println(Math.max(3, 7));  // 두 값 중 최댓값
        System.out.println(Math.random());   // 0.0과 1.0 사이의 랜덤값
    }
}

10
7
0.40910432549890663

Math 클래스에 있는 abs(), max(), random() 등의 메소드가 바로 '클래스 메소드'

-main 메소드

public static void main(String[] args) {
    ...
}

-클래스 변수를 다룰 때

public class Counter {
    static int count;

    public static void increment() {
        count++;
    }

    public static void main(String[] args) {
        System.out.println(Counter.count);

        Counter.increment();
        System.out.println(Counter.count);

        Counter.increment();
        System.out.println(Counter.count);

        Counter.increment();
        System.out.println(Counter.count);
    }
}
0
1
2
3

언제 클래스 메소드를 쓰나?

-> 생성된 인스턴스가 하나도 없더라도 메소드를 호출하고 싶다면 -> static메소드 사용