Java #1-1 자바 기초-변수, 문자열, 연산자, 입출력

1. 변수

[변수] : 값을 저장할 수 있는 메모리 공간을 확보하고, 사람이 식별할 수 있는 이름을 붙인 것.

[변수 선언] : 저장하고자 하는 값의 데이터 타입, 변수 이름에 할당하는 것.

 

[값 할당] : 변수에 값을 저장하는 것.

좌항 = 우항;과 같은 형식으로 사용하며, [우항]에는 값이, [좌항]에는 변수가 위치해야 한다.

이와 같이 대입 연산자를 사용하면, 우항의 값이 좌항의 변수에 할당됩니다.

 

[초기화] : 변수를 선언하고 값을 할당하는 것.

 

[상수] : 변하지 말아야할 데이터를 임시적으로 저장하기 위한 수단으로 변수명 앞에 final 이라는 키워드를 사용한다.

상수를 저장하면 값을 저장하고 있는 상수명을 값으로 사용할 수 있기 때문에 코드 가독성이 향상된다.

ex) final int PI = 3.14; 다음부턴 3.14대신 PI ; 로 사용가능

 

[타입] : 값의 유형 및 종류를 의미하며, 타입에 따라 값이 가질 메모리 공간의 크기, 값이 저장되는 방식이 결정된다.

타입은 저장하고자 하는 값을 그대로 저장하는 기본타입과

저장하고자 하는 값을 임의의 메모리 공간에 저장한 후, 그 공간의 주소를 저장하는 참조타입으로 분류된다.

 

-       기본타입

1.      값을 저장할 때, 데이터의 실제 값이 저장.

2.      정수 타입, 실수 타입, 문자 타입, 논리 타입

 

-       참조타입

1.      값을 저장할 때, 데이터가 저장된 곳을 나타내는 주소 값을 저장.

2.      객체의 주소를 저장, 8개의 기본형을 제외한 나머지 타입.

*객체 : 어떤 사물의 특성과 동작을 하나로 묶어놓은 것.

Ex)

class Example {

            public static void main(String[] args) {

                        기본타입변수 = 1;

                        참조타입변수 = 객체;

 

                        출력(기본타입변수);

                        출력(참조타입변수);

 

먼저, 기본타입변수는 1이라는 값 그 자체를 저장합니다. 여기에서 1은 타입으로 분류했을 때, 정수형의 값이며,

정수형은 데이터 타입 상으로는 기본 타입에 해당합니다. 기본타입은 값 그 자체가 변수에 저장되기 때문에

출력(기본타입변수);의 결과는 기본타입변수가 저장하고 있는 값 1이 그대로 출력됩니다.

 

 참조타입변수는 무언가를 저장할 때, 저장하고자 하는 것이 존재하는 위치를 저장합니다.

예제의 객체는 참조타입의 데이터에 해당하며, 따라서 객체를 어떤 변수에 저장한다면 그 변수에는

객체가 존재하는 메모리 주소를 값으로 가집니다. 즉, 객체의 주소값이 변수에 저장되어 있는 것.

따라서, 출력(참조타입변수);의 결과는 참조타입변수를 저장하고 있는 주소값인 @35bbe5e8의 형식으로 출력된다.

Ex)

[리터럴] : 문자가 가르키는 값 그 자체. ( 값 = 리터럴 ).

Ex)

[정수 타입] : 숫자를 나타내는 타입으로 byte, short, int, long 4가지 타입으로 분류.

 

타입	메모리	표현 범위
byte	1byte	-128(-27) ~ 127(27 - 1)
short	2byte	-32,768(-215) ~ 32,767(215 - 1)
int	4byte	-2,147,483,648(-231) ~ 2,147,483,647(231 - 1)
long	8byte	-9,223,372,036,854,775,808(-263) ~ 9,223,372,036,854,775,807(263 - 1)

 

l  오버 플로우

자료형이 표현할 수 있는 범위 중 최대값 이상의 값을 표현한 경우 발생.

최대값을 넘어가면 해당 데이터 타입의 최소값으로 값이 순환.

 

l  언더 플로우

자료형이 표현할 수 있는 범위 중 최소값 이하의 값을 표현한 경우 발생.

최소값을 넘어가면 해당 데이터 타입의 최대값으로 값이 순환.

 

[실수 타입] : 실수는 소수점을 가지는 값을 의미하며, float, double 으로 분류됨.

 

타입	메모리	표현 범위	정밀도
float	4byte	음수 : -3.4 * 1038 ~ -1.4 * 10-45 양수 : 1.4 * 10-45 ~ 3.4 * 1038	7자리
double	8byte	음수 : -1.8 * 10308 ~ -4.9 * 10-324 양수 : 4.9 * 10-324 ~ 1.8 * 10308	15자리

l  오버 플로우 : 값이 음의 최소 범위/ 양의 최대 범위를 넘을 때 발생, 값은 무한대가 된다.

 

l  언더 플로우 : 값이 음의 최소 범위/ 양의 최소 범위를 넘을 때 발생, 값은 0이 된다.

[논리 타입] : 논리 타입의 종류는 boolean형 한가지 뿐. boolean형은 참 or 거짓만 저장할 수 있는 데이터 타입.

[1bit만 있으면 되지만, JVM이 다루는 데이터의 최소 값은 1byte이므로 boolean형은 8bit 를 가진다.

Boolean A = true;

 

[문자 타입] : 문자 타입은 2byte 크기의 char형 한가지 뿐. 작성 시 “”가 아닌 ‘’으로 저장해야 한다.

문자 타입은 유니코드 로 문자를 저장하여 각 문자별로 동일한 숫자 코드 번호를 부여한다.

Ex) char letter1 = ‘a’; 라면 letter1의 변수에 할당된 리터럴 a의 유니코드 숫자 값이 할당된다.

또한 연산부호도 char형으로 가능하며 ‘’으로 적으면된다.

Ex)

char letter = 65;

System.out.print(letter); // 출력 결과 : A

char타입의 변수 letter에 숫자 65를 직접적으로 할당할 수 있지만,

추후 변수 letter를 참조할 때는 최초 할당한 리터럴 65에 해당하는 유니코드 값인 문자로 변환한다.

 

[유니코드 URL : https://ko.wikipedia.org/wiki/%EC%9C%A0%EB%8B%88%EC%BD%94%EB%93%9C]

 

 

[의사코드 – 슈도코드(pseudo code)]

의사 코드(슈도코드)는 우리가 앞으로 배울 프로그래밍 언어로 코드를 작성하기 전에,

무엇을 어떤 과정을 통해 만들지 사람의 언어로 먼저 작성하는 것입니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

[타입 변환] : boolean을 제외한 기본 타입 7개 (char, byte, short, int, long, float, double )는 서로 타입을 변환할 수 있으며,

자동으로 타입이 변환되는 경우도 있고, 수동으로 변환해주어야만 하는 경우도 있습니다.

 

* 자동 타입 변환 *

A. 바이트 크기가 작은 타입에서 큰 타입으로 변환할 때 (Ex: byte -> int)

B. 덜 정밀한 타입에서 더 정밀한 타입으로 변환할 때 (Ex: 정수 -> 실수)

 

[자동 타입 변환 순서도]
byte(1) -> short(2)/char(2) -> int(4) -> long(8) -> float(4) -> double(8)

 

// float이 long보다 정밀하므로, 자동으로 타입이 변환됩니다.

long  longValue  = 12345L;

float floatValue = longValue;

System.out.println(floatValue); // 12345.0이 출력됩니다.

 

* 수동 타입 변환 * (=캐스팅)  : 차지하는 메모리 용량이 큰 타입에서 작은 타입으로는 자동이 안되므로 수동으로 진행해야 함.

수동으로 타입을 변환할 때에는 캐스팅 연산자 () 를 사용하며, 괄호 안에 변환하고자 하는 타입을 적어주면 된다.

Ex)

//int 타입으로 선언된 변수 intValue를 더 작은 단위인 byte로 변환합니다.

int intValue = 128;

byte byteValue = (byte)intValue;

System.out.println(byteValue); // -128

// byte 범위는 -128 ~ 127 까지 이므로, 128은 byte의 최대치를 넘어섰기에 -128이 된다. / 오버플로우

 

[char > int 변환] : [문자형 to 정수형 변환]

 

int 변수명1;

char 변수명2;

변수명1 = Character.getNumericValue(변수명2);

 

 

[int > char 변환] : [정수형 to 문자형 변환]

 

int 변수명1;

char 변수명2;

 

변수명2 = Character.forDigit(변수명1, 표현하고자하는 진수)

 

 

[ int > String ] : [정수형 to 문자열 변환]

 

Int 변수명1 = 123;

String 변수명 2 = Integer.toString(변수명1);

System.out.println (변수명2);

 

[String to int ] : [ 문자열 to 정수형 변환]

String 변수명1 = “123”;

int 변수명2 = Integer.parseint(변수명1);

System.out.println (변수명2);

[문자열] : 문자열은 String 클래스를 통해 다루어지고 그 안의 메소드를 통해 문자열과 관련된 유용한 기능을 가지고 있다.

[String 타입의 변수 선언과 할당 2가지]

·         String 타입의 변수는 String 변수명;으로 선언할 수 있다.

·         선언한 변수에 문자열을 할당하는 방법은 두 가지가 있다.

1.      문자열 리터럴을 할당하는 방법 : 변수 = “문자열”;

2.      String 클래스의 인스턴스를 생성하여 할당하는 방법 : 변수 = new String(”문자열”);

EX)

String name1 = “Kim coding”;

String name2 = new String (“Kim coding”);

 

-공통점-

참조 타입의 변수에 할당. 즉 name1, name2는 실제 문자열의 내용을 값으로 가지고 있는 것이 아니라,

문자열이 존재하는 메모리 공간 상의 주소 값을 저장하고 있다.

 

-차이점-

String name1 = "Kim Coding";

String name2 = "Kim Coding";

String name3 = new String("Kim Coding");

String name4 = new String("Kim Coding");

                                                    // 맞춰보자

boolean comparison1 = name1 == "Kim Coding";      // ?

boolean comparison2 = name1 == name2;             // ?

boolean comparison3 = name1 == name3;             // ?

boolean comparison4 = name3 == name4;             // ?

boolean comparison5 = name1.equals("Kim Coding"); // ?

boolean comparison6 = name1.equals(name3);        // ?

boolean comparison7 = name3.equals(name4);        // ?

==연산자와 equals()메소드의 가장 큰 차이점은 == 연산자는 비교하고자 하는 두개의 대상의 주소값을 비교하는데 반해 String클래스의 equals 메소드는 비교하고자 하는 두개의 대상의 값 자체를 비교한다는 것입니다

 

name1, name2는 1번의 방법, 즉 문자열 리터럴을 String 타입의 변수에 직접 할당하는 방법을 사용.

동일한 문자열 리터럴을 두 변수에 할당하는 경우, 두 변수는 같은 문자열의 참조값을 공유. (주소값)

name3, name4는 2번의 방법, 즉 String 클래스의 인스턴스를 통해 String 타입 변수에 할당하는 방법.

이처럼 String 클래스의 인스턴스를 생성하면 문자열의 내용이 같더라도 별개의 인스턴스가 따로 생성됨.

name3, name4가 할당받게 되는 인스턴스의 참조값은 서로 다르다.

 

 

comparison1

o    name1은 Kim Coding이라는 문자열 리터럴을 직접 할당받았으며, 비교의 대상이 되는 우항 또한 Kim Coding이라는 내용이 같은 문자열입니다. 문자열 리터럴은 내용이 같다면 같은 주소값을 가지기 때문에 true가 반환됩니다.

comparison2

o    name1과 name2는 내용이 같은 문자열 리터럴을 직접 할당받은 변수입니다. 따라서 두 변수는 같은 문자열의 참조값을 가지므로, true가 반환됩니다.

comparison3

o    name1은 문자열 리터럴을 할당 받은 변수이며, name3은 String 클래스를 통해 인스턴스를 생성하여 할당받은 변수입니다. String 클래스로 인스턴스를 생성하면 항상 별개의 인스턴스가 생성됩니다. 따라서 name1과 name3은 다른 주소값을 저장하고 있게 되므로 false가 반환됩니다.



comparison4

o    name3과 name4는 둘 다 String 클래스로 인스턴스를 생성하여 할당받은 변수입니다. String 클래스로 인스턴스를 생성하면 항상 별개의 인스턴스가 생성되므로 두 변수는 서로 다른 주소값을 저장하게 됩니다. 따라서 결과값으로 false가 반환됩니다.

comparison5

o    equals() 메서드를 활용하여 name1과 “Kim Coding"의 내용이 같은지 비교하고 있습니다. 이 둘은 참조값도 같고 내용도 같습니다. equals() 메서드는 내용이 같은지만을 비교합니다. 따라서 결과값으로 true가 반환됩니다.

comparison6 :

o    equals() 메서드를 활용하여 name1과 name3의 문자열 내용이 같은지 비교하고 있습니다. name1과 name3은 참조값은 서로 다르지만 내용은 같습니다. 따라서 결과값으로 true가 반환됩니다.

comparison7

o    equals() 메서드를 활용하여 name3과 name4의 문자열 내용이 같은지 비교하고 있습니다. comparison6의 경우와 마찬가지로, name3과 name4는 서로 다른 참조값을 가지지만, 이 둘이 가리키고 있는 인스턴스의 내용은 같습니다. 따라서 결과값으로 true가 반환됩니다.

 

 

 

 

[String 클래스의 메소드]

 

*Z*       .equals()

.앞의 변수가 저장하고 있는 문자열의 내용과 ()안의 문자열의 내용, 변수가 같은지 비교해 같으면 true, 다르면 false 반환.

코드 작성 예시 : 변수명.equals(비교하고자하는변수명,”string값”);

 

*A*       charAt()                                                          

해당 문자열의 특정 인덱스에 해당하는 문자를 반환. 만약 해당 문자열의 길이보다 큰 인덱스/음수 >> 오류

코드 작성 예시 ) 변수명.charAt(인덱스번호);

EX)

String str = new String("Java");

System.out.println("문자열 : " + str); // "문자열 : Java"

System.out.println(str.charAt(0)); // 'J'

System.out.println(str.charAt(1)); // 'a'

System.out.println(str.charAt(2)); // 'v'

System.out.println(str.charAt(3)); // 'a'

System.out.println("\ncharAt() 메서드 호출 후 문자열 : " + str);

 

*B*       compareTo()                                                                                      // 비교 메소드

해당 문자열을 인수로 전달된 문자열과 사전 편찬 순으로 비교. 문자열을 비교할 때 대소문자를 구분하여 비교.

두 문자열이 같다면 0을 반환하며, 해당 문자열이 인수로 전달된 문자열보다 작으면 음수, 크면 양수를 반환.

대소문자를 구분하기 싫으면 compareToIgnoreCase(); 메소드 사용 가능.

코드 작성 예시 ) 기준값의 변수명.compareTo(“비교값인 내용”); // 기준값의 변수명.compareIgnoreTo(“비교값인 내용”);

 

EX)

String str = new String("abcd");

System.out.println("문자열 : " + str); >> 문자열 : abcd

System.out.println(str.compareTo("bcef")); >> -1

System.out.println(str.compareTo("abcd") + "\n"); >> 0

System.out.println(str.compareTo("Abcd")); >> 32

System.out.println(str.compareToIgnoreCase("Abcd")); 0

 

*C*      concat()                                                                          // 문자 부분 추가

해당 문자열의 뒤에 인수로 전달된 문자열( 괄호 안의 내용) 을 추가한 새로문 문자열을 반환.

만약 인수로 전달된 문자열의 길이가 0이면, 해당 문자열을 그대로 반환.

코드 작성 예시) 변수명.concat(“내용”);

EX)

 

String str = new String("Java");

System.out.println(str.concat("수업")); >> Java수업.

 

 

*D*      indexOf()

해당 문자열에서 특정 문자나 문자열이 처음으로 등장하는 위치의 인덱스를 반환.

만약 해당 문자열에 전달된 문자나 문자열이 포함되어 있지 않으면 -1을 반환.

코드 작성 예시) 변수명.indexOf(‘문자’ or “문자열”);

EX)

String str = new String("Oracle Java");

System.out.println(str.indexOf('o')); >> -1

System.out.println(str.indexOf('a')); >> 2

System.out.println(str.indexOf("Java")); >> 7

 

*E*       trim()

해당 문자열의 맨 앞과 맨 뒤에 포함된 모든 공백 문자를 제거.

                                                                                코드 작성 예시) 변수명.trim()

EX)

String str = new String(" Java     ");

System.out.println(str + '|'); >> Java      |

System.out.println(str.trim() + '|'); >>>> Java|

 

*F*       toLowerCase() / toUpperCase()

해당 문자열의 모든 문자를 대/소문자로 변경.

                                                                                코드 작성 예시) 변수명.toLowerCase();/ toUpperCase();

 

*G*    replace()

특정 문자열의 내용을 변경하는 메소드.

코드 작성 예씨) String 새로운변수명 = 변경하고자하는 기존변수명.replace(“변경하려는기존문자”, “변경하려는신규문자”);

 

*H*    isEmpty  // 변수명.isEmpty() è true or false로 반환됨

해당 문자열이 빈 문자열인지 확인 가능한 메소드

 

*I*

-substring : 기존 문자열에서 부분 문자열을 뽑아주는 메소드.

코드 활용 예시)

변수명.substring(출력하고싶은 문자열이 시작하는 인덱스 번호,원하는 문자열이 끝나는 인덱스+1);

 

String Method Referece : https://www.javatpoint.com/understanding-toString()-method

 

 

 

 

[StringTokenizer]                                                     // 문자열을 단어별로 나누는 토큰

 

StringTokenizer 클래스는 문자열을 우리가 지정한 구분자로 문자열을 쪼개주는 클래스.

쪼개어진 문자열을 토큰(Token)이라고함. 이를 사용하기 위해서는 java.util.StringTokenizer를 import 해야함.

코드 작성 예시)

StringTokenizer 변수명2 = new StringTokenizer(변수명1); >> 변수명 1의 저장 위치를 나타냄 / 참조타입변수.

변수명.countTokens(); >> 참조타입변수의 남아있는 token의 개수.

EX)

import java.util.StringTokenizer;

public static void main(String[] args){

         String str = "This is a string example using StringTokenizer";

         StringTokenizer tokenizer = new StringTokenizer(str);

         System.out.println(str);

         System.out.println();

         System.out.println("total tokens:"+tokenizer.countTokens());

         while(tokenizer.hasMoreTokens()){

                 System.out.println(tokenizer.nextToken());

         }

         System.out.println("total tokens:"+tokenizer.countTokens());

}

Int countTokens() : 남아있는 token의 개수를 반환. 전체 token의 개수가 아닌 현재 남아있는 token의 개수.

 

Boolean hasMoreElements(),  boolean hasMoreTokens();

두 메서드의 성능적인 차이는 없음. 둘다 동일한 값을 반환.

메서드는 현재 위치 뒤에 있는 문자열에서 하나 이상의 토큰을 사용할 수 있는 경우 true, 그렇지 않으면 false 반환

 

Object nextElement(), String nextToken()

이 두 메서드는 다음의 토큰을 반환. 두가지 모두 같은 객체를 반환하지만 반환형이 다름.

nextElement는 Object, nextToken은 String 반환.           

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

[StringBuilder]                                   // String 인스턴스에 수정이 많을 것 같을 때 사용.

한번 생선된 String 클래스의 인스턴스는 여러 개의 문자열을 더할 때 매번 새로운 인스턴스를 생성해야 한다.

만약 100만개의 문자열이 있는데 모두 더하는 작업이 필요하다면 매우 비효율적. 이를 위해 StringBuilder를 사용.

EX)

public class Main {

    public static void main(String[] args) {

        StringBuilder stringBuilder = new StringBuilder();

        stringBuilder.append("문자열 ").append("연결"); 

// stringBuilder라는 참조변수 객체생성 이후 append()로 연결 하고자하는 문자열을 넣음.

String str = stringBuilder.toString(); // 변수 str에 문자열을 할당할 때 .toString(); 붙임.

        System.out.println(stringBuilder); >> 위에 append 2번 추가한 대로 출력 : 문자열 연결

        System.out.println(str); 

>> stringBuiler 참조변수에 append 2번 추가되고나서 .toString으로 할당받은 str 이므로 위와 동일출력.

stringBuilder.append(“하지말까”);  // 위에 한번 출력된 이후 새로 append로 문자열 추가.

String str2 = stringBuilder.toSting(); // str2변수 또한 새롭게 추가된 append 내용 이후 .toString으로 할당받았으므로 처음 str과는 다른 출력 값이 나옴.

// StringBuilder는 String 클래스 인스턴스에 append로 추가할때마다 수정이 가능함. 

str같은 변수도 stringBuilder를 수정할때마다 새로 변수명 만들고 .toString을 할당해주면 수정 가능함.

    }

}

 

[StringBuffer]                                    // String과 달리 선언된 변수에 그때 그때 변경함.

String 클래스의 인스턴스는 한 번 생성되면 그 값을 읽기만 할 수 있고, 변경할 수는 없습니다.

하지만 StringBuffer 클래스의 인스턴스는 그 값을 변경할 수 있고, 추가할 수 있습니다.

이를 위해 StringBuffer 클래스는 내부적으로 버퍼(buffer)라는 독립적인 공간을 가진다.

버퍼의 기본 크기 : 16개의 문자를 저장할 수 있는 크기이며, 생성자를 통해 그 크기를 설정할 수 있다.

하지만 인스턴스 생성시 사용자가 설정한 크기보다 항상 16개의 문자를 더 저장할 수 있도록 생성됨.

 

문자열의 데이터가 많이 변경될 경우, String보다는 StringBuffer 가 적합.

StringBuffer의 경우, 기존 데이터가 변경 되도 객체가 새로 만들어지는 것이 아니라 기존의 객체에 데이터를

이어서 변경하는 거에 반해 String의 경우, 데이터의 변화가 생길 때 마다 새로운 객체를 만들어서 거기에 데이터를 만들어서 사용하는거라 객체가 여러개 만들어진다는건 메모리생성이 여러번된다는거고 시스템 딜레이로 이어짐.

 

// 코드 작성 예시

StringBuffer 변수명 = new StringBuffer(“문자열”); // 변수명의 return 리터럴은 () 안의 내용

 

 

 

 

 

 

 

 

 

 

 

 

 

 

[StringBuffer] 메소드

 

*A*  append()                                                                          // 기존 변수에 내용 추가.

인수로 전달된 값을 문자열로 변환 후 해당 문자열의 마지막에 추가.

String클래스의 concat()과 같지만 내부적인 처리 속도가 훨씬 빠르다.

 

// 코드 작성 예시 ) 변수명.append(“추가하고싶은 문자열”);

 

EX)

StringBuffer str = new StringBuffer("Java");

System.out.println("문자열 : " + str); >> Java 출력.

System.out.println(str.append(" programming")); >> Java Programming 출력.

 

*B* capacity()

StringBuffer 인스턴스의 현재 버퍼 크기를 반환함.

 

// 코드 작성 예시) 변수명.capacity();

 

EX)

StringBuffer str01 = new StringBuffer();

StringBuffer str02 = new StringBuffer("Java");

System.out.println(str01.capacity());  >> 버퍼의 최소 크기는 기본적으로 문자 16개 저장값이라 16.

System.out.println(str02.capacity());  >> 16+Java(4) = 20.

 

*C* delete()

전달된 인덱스에 해당하는 부분 문자열을 해당 문자열에서 제거한다.

또한 deleteCharAt() 사용하면 특정 위치 문자1개만 제거 가능.  // ()는 인덱스 번호.

 

// 코드 작성 예시

변수명.delete(A, B);  >> A ~ B-1 인덱스까지 삭제.

변수명.delete(A); >> A번 인덱스만 삭제.

 

EX)

StringBuffer str = new StringBuffer("Java Oracle");

System.out.println("문자열 : " + str);

System.out.println(str.delete(4, 8));  // 인덱스4 ~ 7 까지 삭제.

System.out.println(str.deleteCharAt(1));

System.out.println("deleteCharAt() 메소드 호출 후 문자열 : " + str);

 

*D* insert()

인수로 전달된 값을 문자열로 변환한 후, 해당 문자열의 지정된 인덱스 위치에 추가.

전달된 인덱스가 해당 문자열의 길이와 같으면, append() 메소드와 같은 결과를 반환.

 

// 코드 작성 예시

변수명.insert(N, “내용”);  >> N번 인덱스에 “내용”추가.

 

EX)

StringBuffer str = new StringBuffer("Java Programming!!");

System.out.println("문자열 : " + str);

System.out.println(str.insert(4, "Script")); // 4번 인덱스에 “Script” 추가.

System.out.println("insert() 메서드 호출 후 문자열 : " + str);

Reference : https://docs.oracle.com/javase/7/docs/api/java/lang/StringBuffer.html

[연산자]

하나의 값 또는 여러 개의 값을 피연산자로 하여 새로운 값을 만들어내는 기호.

 

A. [산술 연산자]

사칙연산에 사용되는 연산자(+,-,*,/)와 나머지 연산자(%)를 포함.

좌항과 우항이 모두 int형 이면 결과 값 또한 정수형으로만 반환되며 하나라도 실수 타입이 있다면 소수점으로 반환.

 

Ex) 7+3, 7-3, 7*3, 7/3, 7%3

int num1 = 1;

int num2 = num1 + 2; // num2 -> 3

int num3 = num2 - 1; // num3 -> 2

int num4 = num3 * 3; // num4 -> 6

int num5 = num4 / 2; // num5 -> 3

int num6 = num5 % 3; // num6 -> 0

 

1. [증감 연산자]

변수의 값을 1씩 증가시키거나 감소시키는 연산자를 증감연산자 라고 한다.

주의할 점은 증감연산자의 연산 순서가 증감연산자의 위치에 따라 달라질 수 있다는 점.

증감연산자가 피연산자보다 앞에 있으면 전위형 증감연산자, 뒤에 있으면 후위형 증감연산자 라고 한다.

 

전위형 증감연산자 : 증감 연산을 먼저 수행한 후, 결과값을 적용.

후위형 증감연산자 : 기존의 값을 먼저 적용시키고 그 다음 증감 연산을 수행.

 

Ex)

int num1 = 1;

int prefix = ++num1;

>> num1 = 1이라 초기화되었고 ++num1 전위연산자이므로 바로 1+1이 prefix에 할당

num1에 바로 적용되어 출력. 즉 num1=2/prefix=2

int num2 = 1;

int postfix = num2++;

>> num2 = 1이라 초기화 되었고, num2++ 후위연산자이므로 초기값 먼저 적용되고 postfix 할당,

postfix 는 1, 그 다음 num2적용이므로 num2=2/postfix=1

 

2. [복합 대입 연산자]

대입 연산자는 사칙 연산자와 함께 조합하여 복합 대입 연산자로 활용할 수 있다.

num1 = num1 + 1;

num2 = num2 - 1;

1씩 늘리고 싶을 경우에는 증감연산자로 사용 가능하지만 2 이상씩 증가, 감소 시킬 때는 불가능.

num1 += 2;

num2 -= 2;

복합 대입 연산자로 간략하게 표현 가능.

num1~5 : 10;

num1 += 3; // 13 16 19 22

num2 -= 3; // 7 4 1

num3 *= 3; // 30 90 270

num4 /= 3; // 3 1 0

num5 %= 3; // 1 

int A += B // 

[복합 대입 연산자] : 정해진 연산을 수행한 후에 변수에 저장해주세요

ex) i += 10; // i = i + 10; // i값에 + 10을 적용 후 그 값을 i에 대입해달라.

i -= 5; // i = i - 5; // i값에 - 5 적용 후 i값에 기입.

B. [비교 연산자]

boolean 타입으로 평가될 수 있는 조건식 에 사용되며, 크게 대소 비교 (>,<,<=,>=)와 등가 비교(==,!=)로 분류된다.

 

1. [대소 비교 연산자]

대소 비교 연산자는 boolean을 제외한 나머지 기본 타입에 모두 사용할 수 있다.

주의 사항은 이항 비교만 가능하다는 것.

즉 x가 1보다 크고 5보다 작다를 표현할때는 1 < x < 5가 아닌 1 < x && x < 5 로 해야한다.

 

2. [등가 비교 연산자]

등가 비교 연산자는 모든 타입에 사용할 수 있는 연산자로, 두 항의 값이 동등한지의 여부를 판단할 때 사용.

단, 기본 타입과 참조 타입 간에는 등가 비교 연산자를 사용할 수 없다. 등가 비교 연산자는 동등하면 true, 아니면 false.

 

C. [논리 연산자]

논리연산자는 AND 연산자 (&&), OR 연산자 (||), NOT 연산자 ! 를 포함하며, 공통적으로 boolean 타입을 반환한다.

 

1. AND 연산자 // && : 피연산자 두 개가 모두 true일 때, true 반환. 둘 중 하나라도 true가 아니면 false.

2. OR 연산자 // || : 피연산자 두 개 중 단 하나라도 true면 true를 반환, 피연산자 모두 false인 경우에면 false.

 

 

3. NOT 연산자 // ! : true 와 false를 반대로 바꾸는 연산자.

// 아래의 비교 연산 결과는 모두 true입니다. 

!true == false 

!false == true

!!true == true

 

C. [연산자 우선순위]

 

Ex)

참 또는 거짓) ? 참일 때 결과 : 거짓일 때 결과

int num = (1 + 2 == 3 && 4 + 1 * 2 == 6) ? 3 + 4 : 5 + 6;

System.out.println(num);

 

1. * 연산자 먼저 진행.

int num = (1 + 2 == 3 && 4 + 1 * 2 == 6) ? 3 + 4 : 5 + 6;

>> int num = (1 + 2 == 3 && 4 + 2 == 6) ? 3 + 4 : 5 + 6;

2. + 연산자 진행

>> int num = (3 == 3 && 6 == 6) ? 7 : 11;

3. == 등가연산자 진행

>> int num = (true && true) ? 7 : 11;

4. && AND연산자 진행.

>> int num = true ? 7 : 11;

5. ? : 조건 연산자 진행

>> int num = 7;

6. = 대입 연산자 진행

>> 출력 값 7

 

연산자 우선순위를 암기할 필요는 없다. 수학 규칙과 비슷. 괄호를 먼저 연산, 곱셉, 나눗셈이 덧셈, 뺼셈보다 먼저 연산.

 

 

 

[콘솔 입출력 (I/O)]

 

A. [콘솔 출력]

콘솔에 출력하기 위해서는 System.out.prin(), System.out.prinln(), System.out.prinf() 총 3가지 메소드를 활용한다.

 

System.out.prin() : 괄호 안의 내용들을 출력하는데 줄바꿈이 없이 이어서 나옴.

System.out.prinln(), : 괄호 안의 내용을 출력하는데, 한 줄이 끝나면 다음줄로 출력한다.

System.out.prinf() : 정해진 형식대로 출력하기.

변수의 값을 여러 형식으로 출력해주는 메소드.

 

%b : 불리언,         %d : 10진수

%o : 8진수,           %x, %X : 16진수

%c : 문자,            %s : 문자열,         %n : 줄바꿈

 

B. [콘솔 입력] == Scanner

‘컴퓨터의 이해’에서 컴퓨터는 데이터를 입력 받아 어떤 처리를 수행하고 그것을 저장하거나 출력하는 전자 장치.

 

import java.util.Scanner;                 // Scanner 클래스를 가져옵니다.

Scanner scanner = new Scanner(System.in); // Scanner 클래스의 인스턴스를 생성합니다.

String inputValue = scanner.nextLine();   // 입력한 내용이 inputValue에 저장됩니다.

System.out.println(inputValue);           // 입력한 문자열이 출력됩니다.

1. [import java.util.Scanner;]

데이터를 입력받는 기능을 작은 프로그램으로 만들어둔 것이 Scanner. 이 Scanner는 java.util이라는 위치에 저장됨.

Scanner를 사용하려면 소스코드 안으로 Scanner를 불러와야 한다.

즉 import java.util.Scanner; 는 java.util에 있는 Scanner를 이 소스코드로 불러와라 라는 의미.

 

2. [Scanner 객체명 = new Scanner(System.in);]

위에서 불러온 Scanner는 클래스. 클래스는 객체를 찍어내는 틀.

우리가 사용하고자 하는 Scanner 클래스의 데이터 입력 기능은 Scanner 클래스 자체가 아니라

그것을 통해 만들어낸 객체에 존재한다. 따라서 데이터 입력 기능을 사용하려면 Scanner 클래스를 통해 객체를

만들어야 한다. 클래스를 통해 객체를 만들어 낼 떄에는 new 연산자를 사용하며,

그 결과물로 만들어진 객체를 인스턴스 라고 한다. 위의 코드는 불러온 Scanner 클래스를 new 연산자를 통해

인스턴스 생성을 하고, 생성된 인스턴스를 변수 N에 할당하는 코드.

 

3. [String inputValue = scanner.nextLine();]

Scanner 클래스를 인스턴스화한 N 에는 nextLine() 이라는 메소드가 존재. 이 메소드는 콘솔을 통해 문자열 데이터를 입력받는 기능을 수행. 즉 scanner.nextLine()은 문자열을 받기 위한 코드이며, 입력받은 문자열은 inputValue라는 변수에 할댕되어 저장된다.

Scanner에서 데이터 타입에 따라 사용할 수 있는 코드

문자열 : nextLine(); 정수형 : nextInt(); 실수형 : nextFloat(); nextDouble(); 문자형 :next().charAt(0);

 

4. char 를 Scanner로 바로 받을 수 있는 메소드가 없다.

Scanner sc = new Scanner(System.in);

sc.next().charAt(0);로 바꿈.