본문 바로가기
BACK-END/JAVA

JAVA | 20251118 연산자

by codechu 2025. 11. 19.

 

문자열 비교는 == 이 아닌 equals( 대소문자 구분함)

pubic static int sum(int first, int nums){

}
위 구조는 가변 인자 nums가 마지막 매개 변수 임으로 구조상 문제가 없다.

public static int sum(int first , int ... nums, boolean unsafe){

}
위 구조는 가변 인자 nums 가 마지막 매개변수가 아님으로 올바르지 않은 구조이다.

연산자

할당 연산자

  • 일반 할당(=) : X = Y 꼴에서 X에  Y를 대입한다.
  • 더하기 복합 대입 연산(+=) : X += Y 꼴에서 X에서 Y 를 더한 값을 X 에 재할당한다.
  • 빼기 복합 대입 연산(-=) : X -= Y 꼴에서 Y를 뺀 값을 X 에 재할당한다.
  • 곱하기 복합 대입 연산 ( *=) : X *= Y꼴에서 Y를 곱한 값을  X에 재할당한다.
  • 나누기 복합 대입 연산 (/=) : X /= Y꼴에서 Y를 나눈 값을  X에 재할당한다.
  • 나머지 복합 대입 연산(%=) : X %= Y꼴에서 Y를 나눈 나머지 값을  X에 재할당한다.

 

비교 연산자

  • 동등 (==) : X ==Y 꼴에서 X 와 Y의 (스택)값이 같은가의 여부이다.
  • 부등(!=) : X != Y 꼴에서 X와Y의 (스택 ) 값이 다른가의 여부이다.
  • 초과(>) : X > Y 꼴에서 X와Y의 (스택 ) 값이 큰가의 여부이다.
  • 미만(<) : X < Y 꼴에서 X와Y의 (스택 ) 값이 작은가의 여부이다.
  • 이상(>=) : X >= Y 꼴에서 X와Y의 (스택 ) 값이 크거나 같은가의 여부이다.
  • 이하(<=) : X <= Y 꼴에서 X와Y의 (스택 ) 값이 작거나 같은가 여부이다.
  • 초과,미만,이상,이하 연산자의 피연산자는 그 두 피연산자의 타입이 같거나, 하나가 다른 하나의 타입으로 묵시적 형변환이 가능한 형태의 논리값(boolean)을 제외한 숫자이거나 이를 감싸는 참조 타입(byte,short,integer,long,float,double 등) 이어야 한다.
  • 동등, 부등 연산자의 피연산자는 그 두 피연산자의 타입이 같거나 하나가 다른 하나의 타입으로 묵시적 형변환이 가능한 형태여야 한다.

 

산술 연산자

  • 더하기(+) : x + y  꼴에서 x 와 y 의 합이다.
  • 빼기(-) : x - y  꼴에서 x 와 y 의 차이다.
  • 곱하기(*) : x * y  꼴에서 x 와 y 의 곱이다.
  • 나누기(/) : x / y  꼴에서 x 와 y 의 나눈 몫이다.
  • 나머지(%) : x  % y  꼴에서 x 와 y 의 나눈 나머지이다.
  • 단항 양수(+) : +x 꼴에서 변수x 의 부호를 강조한다.
  • 단항 음수(-) :  -x 꼴에서 변수x 가 가지는 값의 부호를 반전한다.
  • 증가(++) : 
    • 전위 증가 : ++x  꼴에서 구문 실행 전 x 에 1을 더한다.
    • 후위 증가 : x++ 꼴에서 구문 실행 후 x 에 1을 더한다.
  • 감소(--) 
    • 전위감소 : --x 꼴에서 구문 실행 전 x 에서 1을 뺀다.
    • 후위감소 :  x-- 꼴에서 구문 실행 후 x 에서 1을 뺀다
  • 숫자 타입간의 사칙 연산 중, 두 피연산자의 타입이 가타면 반드시 동일 타입으로 연산된다.
  • 숫자 타입간의 사칙 연산 중, 두 피연산자의 타이이 다르다면, 보다 큰 타입으로 연산된다.
  • 단, 사칙 연산의 두 피연산자 혹은 일부 산술 연산자의 피연산자 타입이 int 미만 의 정수타입(byte,short)일 경우 그 연산 결과는 int 이다.

 

삼항 연산자

  • 삼항 연산자( ? : ) : c ? t :F 꼴에서 조건 c 가 참 true이라면  t ,거짓 false 이라면 f 가 된다.

기타 연산자

  • 멤버 접근(.) : ㅌx = y 꼴에서 x의 멤버인 y 에 접근하기 위해 사용한다.
  • 배열 인자 접근([] ) :x[y] 꼴에서 배열 x의 인자 중 인덱스가 y 인 인자에 접근하기 위해 사용한다.
  • 객체화 new : new T 꼴에서 타입 T 를 객체화 하기 위해 사용한다.
  • 메서드 호출 ( () ) : F() 꼴에서 메서드 F 를 호출하기 위해 사용한다.
  • 우선 연산  (()) : (X ) 꼴에서 연산 X 를 우선하기 위해 사용한다.
  • 단항 형 변환 ((t)) : (T) X 꼴에서 X의 타이을 강제로(명시적으로) T 로 변환한다.
  • 타입 비교 :  ( INSTANCE OF ) X INSTANCE OF  T 꼴에서 기초타입이 아닌 값 X 가 참조 타입 T로 형변환될수 있는가의 여부이다.

 

연산자의 우선 순위

1. 우선연산, 메서드 호출, 배열인자 접근, 멤버 접근

2. 후위증가 , 후위감소

3. 전위 증가, 전위 감소, 단항 양수, 단항 음수, 논리not

4.객체화 new'

5. 곱하기 나누기 나머지

6.더하기 빼기

7. 초과, 미만, 이상,이하,타입 비교

7. 동등 부등

9. 논리 adn

10 논리 or

11 삼항 연산자

12 할당 복합 대입 연산

 

반복문

for

  • for반복문은 반복의 기준이 되는 변수(주로 인덱스)를 활용해 특정 구현부를 반복 실행하고자 할때 사용한다.
for ([변수 선언 및 초기화]: [반복 조건] ; [변수 가감 및 할당]} {
[구현부]
}

1. for 반복문을 위한 변수 선언 및 초기화를 실행한다.
2.  반복 조건 이 참(true)인지 확인한다.
    - 반복 조건이 참(true)이라면 구현부를 1회 실행하고 3으로 이동한다.
    - 반복 조건이 거짓이라면 for 반복문 실행을 즉시 종료한다.
3. 변수 가감 및 할당을 실시하고 2로 돌아간다

 

향상된 for 문 enhanced for

향상된 for 반복문은 반복 할 수 있는 대상이 가지는 인자에 대해반복하기 위해 사용한다.

인덱스가 필요 없을 경우 인덱스 범위 오류 범위 최소화 및

 

 

while

while 반복문은 주어진 조건이 참true 일때횟수와 관계 없이 구현부를 실행하기 위해 사용한다

while ([조건]) {

[구현부]

}

만약 조건이 하앙 참이거나 거짓으로 변하는 경우의 수가 없다면, 혹은 break 혹은 return 등의 중단 키워드가 없는 경우 우연히 반복됨으로 유의해야 한다.

 

 do while

  • do–while문은 반드시 최소 한 번은 실행되는 반복문이다.
    코드 구조상 조건 검사보다 실행 블록이 먼저 실행되기 때문이다.
  •  기본 구조
    • do { // 반복 실행될 코드 } while (조건);
    • do { } 내부 코드 → 무조건 1회 실행
    • 그 이후 while(조건)을 체크하여 true면 반복, false면 종료
 
  • 실행 순서
  1. do 블록 실행
  2. 조건 검사
  3. 조건이 true → 다시 do 실행
  4. 조건이 false → 반복 종료

→ "실행 → 검사" 순서임 (while문은 "검사 → 실행")

  • 언제 사용하는가?
    • 최초 1회 실행이 반드시 필요한 경우
    • 예: 메뉴 입력, 사용자 입력 처리
    • 예: 최초에 값을 받아야 반복 조건을 결정할 때
int num = 1;

do {
    System.out.println(num);
    num++;
} while (num <= 3);

 

스윗치

  • switch 문은 하나의 표현식(값)을 기준으로 여러 경우(case)를 분기 처리하는 조건문이다.
    여러 if-else 문을 깔끔하게 정리할 때 사용한다.
switch (변수 or 표현식) {
    case 값1:
        // 실행 코드
        break;

    case 값2:
        // 실행 코드
        break;

    default:
        // 어느 case에도 해당하지 않을 때 실행
}

 

 

배열 

  • 배열은 하나의 변수로 동일하거나 호환되는(묵시적 형변환이 가능한) 타입의 값을 여러개 가질 수 있또록 하기 위해 사용한다.
  • 배열은 비록 이가 가질 인자의 타입이 기초 타입이라 하더라고 메모리의 작동 방식은 참조 타입과 같다. 고로 null 값을 가질 수 있다.
  • 변수 선언 시 타입에 대괄호([]) 를 활용해 해당 변수가 배열임을 나타낸다.
  • 배열의 이름은 주로 복수형으로 짓거나, 접미어로 array를 붙여 짓는다.
T [] 이름 ;
- 가령 정수 (INT ) 배열인 NUMS는 아래와 같이 선언한다.
INT NUMS[ ];

 

 

초기화

  • 배열의 초기화는 인자의 나열 혹은 배열의 길이 지정 중 하나여야 한다.
  • 배열이 초기화된 후에는 다시 초기화하는 방법 외에 배열이 가질 수 있는 인자의 개수를 줄이거나 늘릴 수 없음에 유의한다.
  • 배열이 가질 인자의 나열은 아래 방식으로 한다.
T [ ] ts = new T [ ] (,...);
- 가령 정수(INT) 배열에 대해 인자로 1,2,3을 가지는 배열의 초기화는 아래와 같이 할 수 있다.

int [ ] NUMS = new int [ ] {1,2,3};
 - 혹은 아래와 같이 문맥상 그 타입이 명확한 경우 객체화 연산자를 생략할 수 있다.
int [ ] nums = {1,2,3};

 

 

배열의 길이 지정은 아래 방식으로 한다.

t [ ] ts = new t[ n ];
 -  가령 정수 int 배열에 대해 길이가 3인 배열의 초기화는 아래와 같이 할 수 있다.

int [ ] nums = new int [3];
 - 길이 지정을 통해 초기화된 배열이 가지는 모든 인자는 기본 값으로 초기화 되며 기본 값은 아래와 같다.
    - 정수 및 실수 등 숫자 기초 타입 : 0
    - 문자 기초 타입 : \0
    - 논리 기초타입 : false 
    - 모든 참조 타입 : null

 

인자의 나열과 배열의 길이 지정을 동시에 사용하여서는 안된다.

int  [ ] nums = new int [3] {1,2,3};

 - 위와 동시에 배열의 길이도 지정하고 (3) 인자도 나열 9 { 1,2,3 } 하여서는 안된다

 

인자

  • 배열은 배열이 가지는 각 인자에 대해 인덱스를 가지고 있는데, 이 인덱스는 반드시 0 부터 시작하여 1씩 증가한다.
  • 배열이 가지고 있는 인자의 값을 재할당하고자 할 때 그 인덱스로 접근해 재할당할 수 있다.
int odds = { 1,2,5,7,9};
sout (odds[1]); //2
odds[1] = 3;
sout (odds[1]) // 3

 

배열이 가지고 있는 인자의 개수를 가지고 있는 속성은 length이다

int [ ] odds = { 1,3,5,7,9 }
sout (odds.length) // 5

• 인자를 가지는 모든 배열의 Length 속성 값에서 1 을 뿐 값은 항상 마지막 인자의 인덱스이다.
• 배열이 가지고 있는 인자의 인덱스 범위를 벗어난 인자에 접근할 경우 ArrayIndexoutoffoundsException 예외( Exception )가 발생함으로 유의한다.

 

 

메서드

  • 메서드(메소드 method)는 클래스 혹은 인터페이스 등의 구성요소가 가지는 멤버(member)중 하나이며, 호출 (call, invoke)가능한 동작 단위인 대상이다.
  • 메서드 구현부 작성시, 메서드의 이름에 따라 최소한의 역할만 하도록 로직을 작성하는 것이 중요하다.
  • 명명법: 카멜 케이스 (v + v.0 ( be) + adj)
  • 메서드의 구조는 아래와 같다. 
[접근 제한자] [abstract] [final] [static] ? [반환 타입][void] [메서드 이름] ([매개변수 ,...]) {
[구현부]
}
  •  abstract : 해당 메서드가 추상 메서드임을 의미한다.
    • 추상 메서드의 접근 제한자는 private 일 수 없다.추상 메서드는 정적(static)일 수 없다.
    • 추상 메서드는 구현부를 가지지 않아야 한다.
    • 추후 해당 메서드를 멤버로 가지는 클래스를 상속 받거나 인터페이스를 구현하는 대상으로 하여금 해당 메서드의 구현부를 직접 구현하도록 하여야 한다.
    • 추상 메서드를 멤버로 가지는 대상은 추상 클래스 이거나 인터페이스이여야 한다.
  • final : 해당 메서드가 최종적임을 의미한다.
    • 최종적인 메서드는 재정의(override) 할 수 없다.
    • 최종적인 메서드는 추상적일수 없다.
    • 해당 메서드의 구현부가 절대적이고 앞으로 변하여서는 안 되는 로직을 가지는 경우 이를 최종적으로 만들어 보호한다.
  • static : 해당 메서드가 정적임을 의미한다. 정적인 메서드는 주로 유틸리티성을 가지며 객체가 아닌 타입의 이름으로 접근 할 수 있다.
    • 정적인 메서드는 추상적일 수 없다.
    • 정적인 메서드는 제정의 대상이 아님으로 최종적일 필요가 없다.
    • 정적인 메서드는 이를 가지고 있는 타입이 객체화되지 않아도 프로그램이 실행될 때 그 존재가 메모리에 등록된다.
  • void : 해당 메서드의 반환 값이 없음을 의미한다. 호출 결과로 어떠한 값도 반환( return ) 할 수 없다. ( 단, 메서드 종료를 위한 단순 return 은 사용 가능)
    • 반환 타입이 있는 경우 명시적으로 예외를 던지는 throw 경우를 제외하고 모든 경우의 수에서 값을 반환 return 하여아 한다.

매개변수

  • 매개변수는(parameter) 메서드가 요구하는 변수 구성이다.
  • 해당 메서드를 호출할 때 요구되는 매개 변수에 대해 전달되는 값을 전달 인자 (argument)라고 한다.
  • 명명법 : 카멜 케이스
  • 매개 변수의 구조는 아래와 같고 쉼표(,)로 구분해 여러개 작성할 수 있다.
[final] ? [타입] [이름]

 

가변 인자

  • 가변 인자는 실질적으로 배열이지만 호출자로 하여금 단순히 쉼표 (,) 로 구분하여 전달 인자를 쉽게 전달 할 수 있게 하기 위해 사용한다.
[final] ? [타입]...[이름]
위와 같이 타입 뒤에 ...을 붙여 가변 인자임을 지정한다.

 

  • 단, 매개변수 구조상 가변 인자는 반드시 마지막에 위치하여야 한다.

 

 

진입점 ( 한번 더 적음)

 

정적 ( 메인메서드를 실행하면 실행하기 전 static 키워드가 붙은 애들을 찾아서 실행함) 

  • 자바에서 정적(static) 인 리소스는 프로그램이 실행되는 순간, 진입점(main 메서드) 이 실행되기 전, 모두 선언된다.
  • 반대로 비정적인(non - static) 리소스는 해당 리소스를 포함하는 구성 요소가 객체화될 때 혹은 메서드가 실행될 때 선언된다.
  • 정적인 리소스는 메모리 상에서 유일하다. 이를 포함하는 구성 요소가 객체화 되더라도 정적인 대상은 제외된다.
  • 따라서, 비정적인 대상이 정적인 대상에 접근하는 것은 항상 허용되지만, 정적인 대상이 비정적인 대상에(객체화 없이) 접근하는 것은 허영되지 않을 수 있다.

 

public class Study {

    static int height = 177; // 👉 공유 공간(static)
    int age = 22;           // 👉 개인 공간(non-static)

    public static void main(String[] args) {

        Study s1 = new Study();
        Study s2 = new Study();

        System.out.println(s1.age);  // 22
        System.out.println(s2.age);  // 22
        System.out.println(Study.height); // 177
    }
}

📌 정리

자바 프로그램이 실행되면, main 메서드가 실행되기 전에 먼저 static 영역을 로딩한다.
JVM은 클래스를 로드하면서 static 키워드가 붙은 변수나 블록이 있는지 확인하고,
먼저 메모리에 생성하고 초기화한다.

반대로 non-static(인스턴스) 자원은 main 메서드가 실행된 이후,
main 안에서 new 키워드를 통해 객체가 생성될 때 메모리에 만들어진다.

그렇기 때문에 main 메서드 안에서 객체를 생성하기 전에
바로 System.out.println(non-static변수)처럼
non-static 변수를 직접 접근하려고 하면 오류가 발생한다.
(static 영역에서 아직 생성되지 않은 인스턴스 영역에 접근하려 했기 때문)

 

public class Study1 {

    int age = 22;          // 인스턴스 변수 (non-static)
    static int height = 177; // 정적 변수 (static)

    public static void main(String[] args) {

        // 인스턴스 생성 → 이 시점에서 non-static 멤버(age)가 메모리에 만들어짐
        Study1 s = new Study1();

        // ----------------------------- 
        // ❌ 틀린 코드 1
        // String.length();  
        // -----------------------------
        // 🔥 오류 이유:
        // length()는 String "인스턴스"가 가진 메서드임.
        // String 클래스 자체에 static length() 메서드는 없다.
        // 즉, 문자열 객체가 있어야 length() 호출 가능.
        // 예: "hello".length();  (O)

        // ----------------------------- 
        // ❌ 틀린 코드 2
        // message.format();
        // -----------------------------
        // 🔥 오류 이유:
        // format()은 static 메서드이며,
        // String 인스턴스(객체)에서 호출하는 메서드가 아니다.
        // 즉, message.format() 같은 인스턴스 사용은 불가능.
        // 올바른 사용: String.format("...")

        // -------------------------------------
        // ✔ 올바른 사용 예시
        // -------------------------------------

        String message = "hello";

        // length() — 문자열 인스턴스 메서드
        int len = message.length();   // OK

        // format() — static 메서드
        String formatted = String.format("메시지: %s", message);  // OK

        System.out.println("문자 길이: " + len);
        System.out.println("포맷 결과: " + formatted);
    }
}

 

 

string 클래스

  • string(java.lang.string) 클래스는 문자열 리터럴이며, 문자열과 관련된 기능을 제공한다.

정적 메서드

  • copyValueOf( char[] c ) : 문자 배열c가 가진 문자(char) 들을 이어 붙인 문자열을 반환한다. valueOf( char[]c)와 같음.
  • format(String s,Object os) : 주어진 형식 s 에 맞도록 하나 이상의 값 os를 순차적으로 대입한 문자열을 반환한다. 형식s 에는 아래와 같은 표현식을 사용할 수 있다.
    • %d : 정수형 (byte,short,int,long) 대입
      • %,d : 천 자리 단위를 쉼표로 구분하여 대입
      • %xd : 자리수를 x 자로 맞추어 , 부족한 자리수만큼 선행하는 공백을 추가해 대입
      • %0xd : 자리수를 x 자로 맞추어, 부족한 자리수 만큼 선행하는 0을 추가해 대입.
      • %-xd : 등의 형태로 조합해 사용할 수 있다. 단 , 천 자리 단위를 구분하기 위한 쉼표 또한 자리수(x)에 포함한다.
    • %f : 실수형 ( float , double) 대입
      • %,f :  천 자리 단위를 쉼표로 구분해 대입.
      • %xf : 자리수를 x자로 맞추어, 부족한 자리수만큼 선행하는 공백을 추가해 대입 단, 소수점을 표현하기 위한 마침표 또한 자리수(x) 에 포함된다.
      • %0xf : 자리수를 x 자로 맞추어 부족한 자리수 만큼 선행하는 0을 추가해 대입, 단, 소수점을 표현햐기 위한 마침표 자리수(x)에 포함된다.
      • %xf : 소수점을 n 까지만 표시하고 나머지는 반올림하여 대입
      • (%nf),(%0x.nf) , (%-x,nf),(%,x-nf),(%0,x,nf) , (%,-x.nf) : 등의 형태로 조합해 사용할 수 있다. 단, 천 자리 단위를 구분하기 위한 쉼표 또한 자리수 (x)에 포함딘다.
    • %n : 개행자 대입 (\n 과 동일 ) 갓을 대입받지 않는다.
    • %s : 문자열 ( string) 대입
      • %xs :  자리수를 x  자로 맞추어, 부족한 자리수 만큼 선행하는 공백을 추가해 대입
      • %-xs: 자리수를 x 자로 맞추어, 부족한 자리수 만큼 후행하는 공백을 추가해 대입
      • %.xs : 최대로 출력 할 수 있는 문자열의 길이를 n으로 제한해 대입
public class FormatExample {
    public static void main(String[] args) {

        int number = 1234;
        int smallNumber = 7;
        double pi = 3.14159265;
        String text = "Hello";

        // ----------------------------------------
        // 1) %d : 정수 대입
        // ----------------------------------------
        System.out.println(
            String.format("%%d → %d", number)
        );
        // 출력: %d → 1234

        // ----------------------------------------
        // 2) %,d : 천 단위 콤마
        // ----------------------------------------
        System.out.println(
            String.format("%%,d → %,d", number)
        );
        // 출력: %,d → 1,234

        // ----------------------------------------
        // 3) %xd : x자리 확보 (앞 공백)
        // ----------------------------------------
        System.out.println(
            String.format("%%8d → '%8d'", number)
        );
        // 출력: %8d → '    1234'
        // (총 8자리 → 앞에 공백 4칸)

        // ----------------------------------------
        // 4) %0xd : 모자란 자릿수 0으로 채우기
        // ----------------------------------------
        System.out.println(
            String.format("%%08d → '%08d'", number)
        );
        // 출력: %08d → '00001234'

        System.out.println(
            String.format("%%08d (작은수) → '%08d'", smallNumber)
        );
        // 출력: %08d (작은수) → '00000007'

        // ----------------------------------------
        // 5) %-xd : 왼쪽 정렬
        // ----------------------------------------
        System.out.println(
            String.format("%%-8d → '%-8d'", number)
        );
        // 출력: %-8d → '1234    '
        // (뒤에 공백 4칸)

        // ----------------------------------------
        // 6) %f : 실수 출력
        // ----------------------------------------
        System.out.println(
            String.format("%%f → %f", pi)
        );
        // 출력: %f → 3.141593   (기본 소수점 6자리)

        System.out.println(
            String.format("%%.2f → %.2f", pi)
        );
        // 출력: %.2f → 3.14

        // ----------------------------------------
        // 7) %s : 문자열 출력
        // ----------------------------------------
        System.out.println(
            String.format("%%s → %s", text)
        );
        // 출력: %s → Hello

        // ----------------------------------------
        // 8) %n : 개행 (줄바꿈)
        // ----------------------------------------
        System.out.println(
            String.format("여기까지 출력%n다음 줄입니다.")
        );
        /* 출력:
           여기까지 출력
           다음 줄입니다.
        */

        // ----------------------------------------
        // 9) %, 과 자리수 조합 (%,8d)
        // ----------------------------------------
        System.out.println(
            String.format("%%,8d → '% ,8d'", number)
        );
        // 출력: %,8d → '   1,234'
        // 8자리 확보 + 천 단위 콤마 포함 → 앞 공백 3칸
    }
}
  • join(CharSequnce d,CharSequence ...c ) : 가변인자 c 의 인자를 d 로 이어붙인 문자열을 반환한다.
  • valueOf(char [] c ) : 문자열 c 가 가진 문자char 들을 이어 붙인 문자열을 반환한다. copyValueOf(char[]c)와 같음.
  • valueOf(byte | short | int | long | float | double | boolean | char x ) : 기초 타입의 값 x 가 가진 내용을 분자열로 반환한다.
  • valueOfObject : 

객체 메서드

  • charAt(int i) : 호출 대상인 문자열이 가지는 문자 중 i 번째 문자 (char)을 반환한다. 인덱스는 0번부터 시작함에 유의.
  • concat(String s): 호출 대상인 문자열이 가지는 내용 끝에 전달 받은 문자열 s 를 이어 붙인 새로운 문자열을 반환한다. 호출 대상인 문자열과 전달 받은 문자열의 내용에는 변화가 없음에 유의.
  • contains(CharSequence c ) : 호출 대상인 문자열의 내용에 인자 s 가 포함되어 있는가의 여부를 반한한다.
  • endsWith(string s ) : 호출 대상인 문자열의 내용이 s 로 끝나는가의 여부를 반환한다.
  • startsWith(String s ) :  호출 대상인 문자열의 내용이 s로 시작하는가의 여부를 반환한다.
  • equals(object o) : 전달 받은 인자o 가 문자열이라면, 호출 대상인 문자열이 가지는 내용과 o가 가지는 내용이 같은가의 여부를 반환한다. 
  • equalsIgnoreCase(string s ) : 위와 동일하나 대소문자를 구분하지 않음.
  • indexOf(string s) : 호출 대상인 문자열이 가지는 내용 중 s 와 일치하는 첫번째 인덱스를 반환한다. 일치하는 내용이 없다면 -1을 반환한다.
  • lastIndexOf( String s ) :  호출 대상인 문자열이 가지는 내용 중 s 와 일치하는 마지막 인덱스를 반환한다. 일치하는 내용이 없다면 -1을 반환한다.
  • length() : 호출 대상인 문자열의 길이를 반환한다. ( 배열의 길이를 할땐 ()없음 -> int nums [] , nums.length 이걸로 끝.)
  • matchers(String s ) : 호출 대상인 문자열의 내용이 정규표현식 p를 만족하는가의 여부를 변환한다. -> 논리값으로 반환
  • repeat(int n ) : 호출 대상인 문자열의 내용을 n번 반복한 새로운 문자열을 반환한다.
  • replace ( charsequence f,charsequence t ) :  호출 대상인 문자열이 가지고 있는 내용 중 f를 찾아 t 로 치환한 새로운 문자열을 변환한다.
  • replaceAll(string r, string t) 호출 대상인 문자열이 가지고 있는 내용 중 정규 표현식r 을 만족하는 내용을 찾아t 로 치환한새로운 문자열을 반환한다. 
  • split(String s ) : 호출 대상인 문자열이 가지는 내용에서 정규표현식 p 를 기준으로 나눈 문자열 배열을 반환한다.
  • strip() : 호출 대상인 문자열의 내용에서 선후행 공백을 모두 제거한 새로운 문자열을 반환한다.
  • stripleading(): 호출 대상인 문자열의 내용에서 선행 공백을 모두 제거한 새로운 문자열을 반환한다.
  • stripTrailing() : 호출 대상인 문자열의 내용에서 후행 공백을 모두 제거한 새로운 문자열을 반환한다.
  • substring(int f , int t ) : 호출 대상인 문자열이 가지는 내용에서 인덱스가 f  이상이고 t 미만인 문자열을 반환한다. 인덱스는 0부터 시작한다.
  • toCharArray(): 호출 대상인 문자열이 가지는 내용을 문자 배열 (char [] ) 로 변환해 반환한다.
  • toLowerCase(): 호출 대상인 문자열이 가지는 내용 중 모든 라틴 문자를 소문자화해 반환한다.
  • toUpperCase(): 호출 대상인 문자열이 가지는 내용 중 모든 라틴 문자를 대문자화해 반환한다.

 

Integer 클래스 ( int 는 널을 넣을 수 없어서 int 값에 널을 넣을 경우 integer 사용하면 됨) 

  • Integer( java.lang.Integer ) 클래스는 일반 정수 int 와 관련된 편의 기능을 제공하고, 해당 타입 자체가 int 타입의 리터럴로 작동할 수 있는 일반 정수 int 의 래퍼(wrapper)클래스이다.

long 클래스

  • Long(java.lang.long)클래스는 큰 정수(long)와 관련된 편의 기능을 제공하고, 해당 타입 자체가 long 타입의 리터럴로 작동할 수 있는 큰 정수(long) 의 래퍼(wrapper) 클래스이다.
  • long 클래스가 가지는 실직적인 값은 long이지만, long과 달리 참조 타입임으로 null을 할당받을 수 있다.

정적 멤버 변수

  • MAX_VALUE : int 타입이 가질 수 있는 가장 큰 값
  • MIN_VALUE : int 타입이 가질 수 있는 가장 작은 값
  • NaN : 숫자가 아닌 값(Not a Number) 내부적으로 0.0/0.0 연산으로 구현되어 있다.
  • MEGATIVE_INFINITY : 음의 무한대. 내부적으로 -1.0/ 0.0 연산으로 구현되어 있다.
  • POSITIVE_INFINITY : 양의 무한대. 내부적으로 1.0/0.0 연산으로 구현되어 있다.

정적 메서드

  • parseInt(String s) : 전달된 문자열 s를 일반 정수 ( int ) 로 변환해 반환한다. 변환할 수 없는 문자열일 경우 numberFormatException 예외가 발생한다.
  • parseInt(String s, int r) : 전달된 문자열 s를 r 진법으로 인식해 10진버으로 변환한 일반 정수( int ) 를 반환한다.
  • toBinaryString(int i) : 전달된 일반 정수 ( int ) i 를 2진법의 문자열로 변환해 반환한다. 
  • toHexString(int i): 전달된 일반 정수 ( int ) i 를 16진법의 문자열로 변환해 반환한다.
  • toOctocalString(int i) : 전달된 일반 정수 ( int ) i 를 8진법의 문자열로 변환해 반환한다.
  • toString(int i ) : 전달된 일반 정수를 문자열로 변환해 반환한다.
  • isFinite(double d) : d 가 유한한가의 여부를 반환한다. 양/음수를 구분하지 않는다.
  • isInfinite(double d): d가 무한한가의 여부를 반환한다. 양/음수를 구분하지 않는다.
  • isNaN(double d) : d가 double.NaN 인가의 여부를 반환한다. 어떠한 값이 NaN 인가를 검사할 때에는 절대로 등/부등(==,!=) 연산을 하지 않는다.
  • parseDouble(string s) :문자열 s 를 double로 변환하여 반환한다. 변환 할 수 없는 문자열일 경우 memberFormatExeption 예외가 발생한다.
  • toString(double d ) : d 를 문자열로변환해 반환한다.

 

객체 메서드 

  • byteValue() : 호출 대상이 가진 일반 정수 int 값을 byte 타입으로 변환해 반환한다. 오버/언더 플로우가 발생할 수 있음
  • shortValue() : 호출 대상이 가진 일반 정수 int  값을 short 타입으로 변환해 반환한다.  오버/언더 플로우가 발생할 수 있음
  • intValue() : 호출 대상이 가진 일반 정수 int  값을 int 타입으로 변환해 반환한다.  
  • longValue() : 호출 대상이 가진 일반 정수 int  값을 long 타입으로 변환해 반환한다. 
  • floatValue() : 호출 대상이 가진 일반 정수 int  값을 float 타입으로 변환해 반환한다.  
  • doubleValue() : 호출 대상이 가진 일반 정수 int  값을 double 타입으로 변환해 반환한다.  
  • toString() : 호출 대상이 가진 큰 정수 (long) 값을 문자열로 변환해 반환한다.
  • isInfinite(): 호출 대상이 가진 값이 무한한가의 여부를 반환한다.
  • isNaN(): 호출 대상이 가진 값이 NaN 인가의 여부를 반환한다.

 

'BACK-END > JAVA' 카테고리의 다른 글

JAVA | 20251120  (0) 2025.11.20
JAVA | 251119  (1) 2025.11.20
JAVA | 20251117  (0) 2025.11.17
[자바] 계산기 과제 TIL  (0) 2025.04.23
[자바 프로그래밍 기초] 예외(Exception)와 예외처리 (try- catch)  (0) 2025.04.17

관련글

티스토리툴바