[JAVA] 자료형과 연산자

자바는 정적 자료형을 가지고 있습니다. 따라서 변수나 값을 선언할때는 반드시 자료형을 먼저 입력해야합니다.

 

예컨대 a라는 변수가 정수형이라면 int a; 라고 선언할 수 있습니다.

 

이러한 자료형에는 여러가지가 있습니다. 

 

1. 정수형

정수형의 크기나 표현범위를 표로 표현해보면 아래와 같습니다.

자료형	크기	표현 범위
byte	1바이트 (8비트)	-128 ~ 127 (-2^7 ~ 2^7-1)
short	2바이트	-32,768 ~ 32,767
int	4바이트	-2,147,483,648 ~ 2,147,483,647
long	8바이트	-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807

1) byte,short

byte와 short는 아주 작은 수를 표현할때 사용합니다.

 

따라서 표현범위도 매우 작으며 아래 처럼 범위를 벗어나면 오류가 발생합니다.

byte byte1 = 127;
byte byte2 = 128; //에러 발생
byte byte3 = -128;
byte byte4 = -129; // 에러발생

 

2) int

int형은 가장 많이 사용하는 연산자입니다. 자바외의 다른 프로그래밍언어에서도 기본 자료형으로 int를 많이 사용하기 때문에 호환성이 좋고 연산속도도 다른 자료형보다 빠릅니다. 그리고 int는 32비트(4바이트)이기 때문에 대부분의 CPU에서 처리하기에도 적합합니다. 이러한 이유로 int보다 작은 타입의 연산의 결과로서 int형이 반환됩니다.

 

byte b1 = 1;
byte b2 = 2;
short s1 = 1;
short s2 = 2;

byte b3 = b1 + b2; //에러
short s3 = b1 + b2; //에러
short s4 = b1 + s2; //에러
short s5 = s1 + s2; //에러


int i1 = b1 + b2; // 3
int i2 = s1 + s2; // 3
int i3 = b1 + s1; // 2

 

3)long

long 타입은 아주 큰수를 다룰 때 사용합니다. long의 특징으로는 숫자옆에 L을 붙여야한다는 것입니다.

long l1 = 123143546354L;
long l2 = 123143546354; //에러

4) 형변환

형변환에는 자동으로 타입을 변환해주는 묵시적 형변환과 강제로 타입을 변경해야하는 명시적 형변환이 있습니다.

 

큰 타입으로 변환하려고할때는 묵시적 형변환이 발생하지만 작은 타입으로 변환하려고 할 때에는 강제형 변환을 해야합니다.

 

byte b1= 1;
               
short s1 = b1;

byte b2= s1; //에러

byte b3= (byte) s1;

 

5) 연산

1] 산술연산자

int a = 1 + 2; //산술 덧셈
System.out.println("a = " + a); //a = 3
int b = a - 1; //산술 뺄셈
System.out.println("b = " + b); //b = 2
int c = b * a; //산술 곱셈
System.out.println("c = " + c); //c = 6
int d = a + b * c / 3; //b와 c를 곱한 후 3으로 나눈 후 a를 더함
System.out.println("d = " + d); //d = 7
int e = (a + b) * c / 3; //a와 b를 더한 후 c를 곱하고 3으로 나눔
System.out.println("e = " + e); //e = 10
int f = e % 4; // e를 4로 나눈 나머지 -> 10 / 4 -> 나머지 2
System.out.println("f = " + f); //f = 2

byte int1 = 5/2; // 5를 2로 나눴지만 정수형이라므로 소수점을 버림
System.out.println("int1 = " + int1); //int1 = 2
int int2 = 10;
int int3 = 3;
int int4 = int2 / int3;
System.out.println("int4 = " + int4); //int4 = 3

2] 대입연산자

int a = 1;

        //아래 두개는 동일한 기능
        a = a + 2;//1+2 =3
        a += 2; //3+2=5

        //아래 두개는 동일한 기능
        a = a -1; // 5-1=4
        a -=1; // 4-1=3

        //아래 두개는 동일한 기능
        a = a * 3; // 3*3 =9
        a *= 3; // 9*3 = 27

        //아래 두개는 동일한 기능
        a = a / 3; // 27 / 3 = 9
        a /= 3; // 9/3 = 3

        // 연산자의 값을 반환해서 사용도 가능
        int b = a += 4; // a=3+4=7=b

        int i1 = 0;
        int i2 = 1;
        int i3 = i1 = i2; // i1에 i2를 대입했으므로 i1=i2=1, 반환값을 i3에 대입했으므로 i3도 1

3] 단항연산자

int i1 = 3;

//++나 --가 앞에 붙는 것과 뒤의 붙는 것의 차이는 반환값으로 확인가능함
int i2 = i1++; // i2에 i1값을 대입하고 i1 증가 -> i1 = 4, i2 = 3
int i3 = ++i1; // i1을 1증가하고 i3에 대입 -> i1=5, i3=5
int i4 = -(i2-- * --i3); // i2 * (i3-1) = 3*4 = 12에 부호 반대로 처리하므로 -12
int x = 1;

//  메서드 안으로도 '반환'되어 사용되는 것
System.out.println(x++); //1 -> 1출력하고 x변수 1증가
System.out.println(++x); //3 -> x변수 1증가하고 출력
System.out.println(x); //3 -> x값 그대로 출력

4] 비교연산자

비교 연산자의 결과값은 무조건 불리언값으로 반환됩니다. 비교를 할때는 참과 거짓밖에 없기 때문입니다.

int i1 = 3;
int i2 = 3;

//  다른 정수 자료형끼리 사용 가능
boolean b1 = i1 == i2; System.out.println(b1); // true
boolean b2 = i1 != i2; System.out.println(b2); //false

boolean b3 = i1 > i2; System.out.println(b3); //false
boolean b4 = i1 >= i2; System.out.println(b4); //true

boolean b5 = i1 < i2; System.out.println(b5); //false
boolean b6 = i1 <= i2; System.out.println(b6); //true

boolean b7 = i1 * i2 > i1 + i2; System.out.println(b7); //true

 

2.실수형

1) 표현 및 크기

자료형	크기
float	4바이트
double	8바이트

 

double은 float보다 단순히 크기만 큰게 아니라 보다 정밀하게도 표현가능합니다.

 

 //  float은 뒤에 f 또는 F를 붙여 표현
float f1 = 3.14f;
double d1 = 3.14;

float f2 =(float) d1; // 강제 형변환을 해야 float에 담을 수 있음
double d2 = f1; // 묵시적 형변환을 통해서도 double에 담을 수 잇음

// double이 더 정밀함
double d3 = 0.123456789123456789;
System.out.println(d3); // 출력: 0.12345678912345678
float f3 = 0.123456789123456789f;
System.out.println(f3); // 출력: 0.12345679

long l1 = 123;

//정수형은 실수형에 담을 때 묵시적 형변환으로 가능함. 단 크기에 따라 결과는 동일하지 않을 수 있음
float f4 = l1;
double d4 = l1;

long l2 = Long.MAX_VALUE; // long형의 최대값

float f5 = l2;
double d5 = l2;

System.out.println("l2="+ l2); //출력: l2=9223372036854775807
System.out.println("f5="+ f5); //출력: f5=9.223372E18
System.out.println("d5="+ d5); //출력: d5=9.223372036854776E18
//크기가 달라서 값이 변함

 

2) 연산

float f1 = 4.124f;
float f2 = 4.125f;
double d1 = 3.5;

// float끼리의 연산은 float 반환
float f3 = f1 + f2;

System.out.println("f3="+f3); //출력: f3=8.249001
//  float과 double의 연산은 double 반환
double f4 = f1 + d1;

//  부동소수점 방식상 오차 자주 있음
double d2 = 0.2 + 0.3f;
double d3 = 0.2f * 0.7f;
double d4 = 0.4 - 0.3;
double d5 = 0.9f / 0.3;
double d6 = 0.9 % 0.6;

System.out.println("d2="+d2); //출력: d2=0.5000000119209289
System.out.println("d3="+d3); //출력: d3=0.14000000059604645
System.out.println("d4="+d4); //출력: d4=0.10000000000000003
System.out.println("d5="+d5); //출력: d5=2.9999999205271406
System.out.println("d6="+d6); //출력: d6=0.30000000000000004

//  소수부가 2의 거듭제곱인 숫자간 연산은 오차 없음
double d7 = 0.25 * 0.5f;
double d8 = 0.5 + 0.25 + 0.125 + 0.0625;
double d9 = 0.0625f / 0.125;

System.out.println("d7="+d7); //출력: d7=0.125
System.out.println("d8="+d8); //출력: d8=0.9375
System.out.println("d9="+d9); //출력: d9=0.5

 

실수형은 부동소수점을 사용하기 때문에 단순 연산시 오차가 발생합니다. 이러한 오차 문는  BigDecimal 클래스를 이용하면 해결할 수 있습니다.

 

부동소수점에 대한 개념은 아래사이트를 참고하시면 됩니다.

https://ko.wikipedia.org/wiki/%EB%B6%80%EB%8F%99%EC%86%8C%EC%88%98%EC%A0%90

부동소수점 - 위키백과, 우리 모두의 백과사전

 

3) 정수와의 연산

int i1 = 5;
float f1 = 2f;
double d1 = 3;
double d2 = 7;

// 정수 자료형과 실수 자료형의 계산은 실수 반환
double d3 = i1 / d1;
double d4 = d2 / f1;

System.out.println("d3="+d3); //출력: d3=1.6666666666666667
System.out.println("d4="+d4); //출력: d4=3.5
// double임을 명시하려면 .0을 붙여줄 것
double d5 = 5 / 2;
System.out.println("d5="+d5); //출력: d5=2.0
double d6 = 5.0 / 2;
System.out.println("d6="+d6); //출력: d6=2.5
double d7 = (double) 5 / 2;
System.out.println("d7="+d7); //출력: d7=2.5

float f_1 = 4.567f;
double d_1 = 5.678;

// 정수 자료형에 강제로 넣으면 소수점이하를 버림
int i2 = (int) f_1;
System.out.println("i2="+i2); //출력: i2=4
int i3 = (int) d_1;
System.out.println("i3="+i3); //출력: i3=5

4) 비교연산

int i1 = 5;
float f1 = 5f;
double d1 = 5.0;
double d2 = 7.89;

//  정수/실수간, 다른 숫자 자료형간 사용 가능
boolean b1 = 123 == 123F; //true

boolean b2 = i1 == f1; //true
boolean b3 = f1 == d1; //true
boolean b4 = i1 == d2; //false

boolean b5 = i1 > d2; //false
boolean b6 = f1 >= d2; //false
boolean b7 = d1 < d2; //true

3.문자형(char)

문자형은 특정 하나의 글자를 의미합니다. 문자형은 2바이트를 사용합니다. 이러한 문자형으로 아스키코드 및 유니코드도 표현가능합니다. 아스키 코드는 영문자와 특수문자정도를 표현하며 유니코드는 그외에 한글등의 언어도 표현하는 코드입니다.

 

아스키코드에 대한 개념과 문자표는 아래 사이트를 참고하시면 됩니다.

https://ko.wikipedia.org/wiki/ASCII

ASCII - 위키백과, 우리 모두의 백과사전

 

유니코드에 대한 내용은 유니코드 테이블을 검색하셔서 찾아보시면 됩니다.

 

//자바에서 문자 타입은 ''를 사용함-> ""는 문자열임
// 각 문자는 상응하는 정수를 가짐
char ch1 = 'A';
System.out.println("ch1="+ch1+",(int)ch1="+(int)ch1); //출력: ch1=A,(int)ch1=65
char ch2 = 'B';
System.out.println("ch2="+ch2+",(int)ch2="+(int)ch2); //출력: ch2=B,(int)ch2=66
char ch3 = 'a';
System.out.println("ch3="+ch3+",(int)ch3="+(int)ch3); //출력: ch3=a,(int)ch3=97
char ch4 = 'a' + 1;
System.out.println("ch4="+ch4+",(int)ch4="+(int)ch4); //출력: ch4=b,(int)ch4=98
char ch5 = '가';
System.out.println("ch5="+ch5+",(int)ch5="+(int)ch5); //출력: ch5=가,(int)ch5=44032
char ch6 = '가' + 1;
System.out.println("ch6="+ch6+",(int)ch6="+(int)ch6); //출력: ch6=각,(int)ch6=44033
char ch7 = '가' + 2;
System.out.println("ch7="+ch7+",(int)ch7="+(int)ch7); //출력: ch7=갂,(int)ch7=44034
char ch8 = '가' + 3;
System.out.println("ch8="+ch8+",(int)ch8="+(int)ch8); //출력: ch8=갃,(int)ch8=44035
char ch9 = '나';
System.out.println("ch9="+ch9+",(int)ch9="+(int)ch9); //출력: ch9=나,(int)ch9=45208

char ch10 = 'A';
int i1 = ch10; // 묵시적으로 정수형으로 변환이 가능
int i2 = ch10 +0;
int i3 = ch10++; //정수형으로 변환이되기 때문에 ++,--도 가능


char ch11 = 'A';
char ch12 = 65;
char ch13 = '\u0041'; //유니코드 표기방식으로 표현

boolean b1 = ch11 == ch12;
boolean b2 = ch11 == ch13;
System.out.println("b1="+b1); //출력: b1=true
System.out.println("b2="+b2); //출력: b2=true

char ch14 = 'A';
char ch15 = 'A'+1;
//char ch16 = ch14+1; // char 변수를 사용해서 더하는 것은 문자형에 넣을 수 없음
int i4 = ch14+1;

// '1'은 숫자가 아니라 문자 1임, 따라서 실제 값은 다름
char ch16 = '1'; // 49
char ch17 = '2'; // 50

int i5 = ch16+ch17;
System.out.println("i5="+i5); //출력: i5=99

//문자를 정수화하는 방법 -> '0'도 문자임을 이용
int ch18 = '1' - '0';
System.out.println("ch18="+ch18); //출력: ch18=1
int ch19 = '2' - '0';
System.out.println("ch19="+ch19); //출력: ch19=2

4. 불리언

불리언형은 참, 거짓을 판단하는 자료형으로 true와 false만 존재합니다.

일반적으로 비교,논리연산이나 제어문에 많이 사용합니다.

boolean b1 = true; //true
boolean b2 = false; //false

//부정 연산자 -> !를 붙이면 값이 반대로 바뀜
boolean b3 = !true; //false
boolean b4 = !false; //true

boolean b5 = !b3; //true
boolean b6 = !!b3; //false
boolean b7 = !!!b3; //true

boolean b8 = !(1 > 2); //true
boolean b9 = !((5 / 2) == 2.5); //true
boolean b10 = !((3f + 4.0 == 7) != ('A' < 'B')); //true

//논리연산자 -> && 은 and연산, ||는 or연산 -> &&은 둘 모두 true일 때 true, or은 둘중 하나만 true라면 true
boolean b11 = true && true; //true
boolean b12 = true && false; //false
boolean b13 = false && true; //false
boolean b14 = false && false; //false

boolean b15 = true || true; //true
boolean b16 = true || false; //true
boolean b17 = false || true; //true
boolean b18 = false || false; //false

int num = 6;

//  &&가 ||보다 우선순위 높음
boolean b19 = (num % 3 == 0) && (num % 2 == 0) || (num > 0) && (num > 10);
// true and true or true and false -> true or false -> true
boolean b20 = (num % 3 == 0) && ((num % 2 == 0) || (num > 0)) && (num > 10);
// true and (true or false) and false -> true and true and false -> false

//단축평가 short circuit -> 자원 절약
//&& -> 앞이 false면 뒤를 평가할 필요없음
//|| -> 앞이 true면 뒤를 평가할 필요없음
int a = 1, b = 2, c = 0, d = 0, e = 0, f = 0;

boolean b21 = a < b && c++ < (d += 3); //true -> &&이고 앞이 true이기 때문에 뒤도 평가함
System.out.println("c="+c+",d="+d); //출력: c=1,d=3 -> 뒤를 평가했기 때문에 c,d는 증가함
boolean b22 = a < b || e++ < (f += 3); //true -> ||이고 앞이 true이기 때문에 뒤는 평가안함
System.out.println("e="+e+",f="+f); //출력: e=0,f=0 -> 뒤를 평가하지 않았기 때문에 e,f는 증가하지 않음
boolean b23 = a > b && c++ < (d += 3); //false -> &&이고 앞이 false이기 때문에 뒤는 평가안함
System.out.println("c="+c+",d="+d); //출력: c=1,d=3 -> 뒤를 평가하지 않았기 때문에 c,d는 증가하지 않음
boolean b24 = a > b || e++ < (f += 3); //true
System.out.println("e="+e+",f="+f); //출력: e=1,f=3 -> 뒤를 평가했기 때문에 e,f는 증가함

5. 문자열

1) 표현

//선언 및 초기화
String str1 = "Hello";
String str2 = "Hello";
String str3 = "hello";

//인스턴스 형태로 선언 및 초기화
String str4 = new String("Hello");
String str5 = new String("Hello");
String str6 = str5;

// 이런형식으로도 가능하다 잘 사용하지 않음
boolean b1 = str1 == str2; //true
boolean b2 = str1 == str2; //true

//선언방식에 따라서 똑같은 형태의 문자열이지만 false로 표시됨
// 즉 ==는 타입까지도 비교한다고 볼 수 있음
boolean b3 = str1 == str4; //false

//  인스턴스와 비교하려면 .equals 메소드를 사용해야 함
//   위와 같은 이유로 문자열은 .equals로 비교함
boolean b4 = str4 == str5; //false

boolean b5 = str1.equals(str2); //true
boolean b6 = str1.equalsIgnoreCase(str3); //true -> equalsIgnoreCase 메서드는 대소문자를 구분하지않고 일치여부를 비교
boolean b7 = str1.equals(str4); //true
boolean b8 = str4.equals(str5); //true

//문자열을 변수선언하지 않고 비교하는 것도 가능
boolean b9  = "hello".equals(str3); //true

//  같은 곳을 참조하는 인스턴스들
boolean b11 = str5 == str6; //true

//  각각의 메모리상 주소 식별자 비교
int str1Hash = System.identityHashCode(str1);
int str2Hash = System.identityHashCode(str2);
int str3Hash = System.identityHashCode(str3);
int str4Hash = System.identityHashCode(str4);
int str5Hash = System.identityHashCode(str5);

System.out.println(str1Hash); //189568618
System.out.println(str2Hash); //189568618
System.out.println(str3Hash); //793589513
System.out.println(str4Hash); //1313922862
System.out.println(str5Hash); //495053715

2) 연산

String str1 = "Hello, ";
String str2 = "World!";

// + 연산자: 이어붙여진 결과를 반환
String str3 = str1 + str2;

System.out.println(str3); //출력: Hello, World!

str1 += str2;
System.out.println(str1); //출력: Hello, World!

String str4 = "hello, ";
str4 += "world!";

System.out.println(str4); //출력: hello, world!

//상수 final에서는 사용불가

final String str5 = "헬로";
//str5 += "월드"; //java: cannot assign a value to final variable str5

// 문자열에 다른 자료형을 더하면 문자열로 이어붙여짐
int intNum = 123;
float fltNum = 3.14f;
boolean bool = true;
char character = '가';
String str_d1 = "문자열 더하기 ";

String str6 = str_d1 + intNum + fltNum + bool + character;
System.out.println(str6); //출력: 문자열 더하기 1233.14true가

3) 형변환

// 문자열로 형변환  
String str1 = String.valueOf(true); //"true"
String str2 = String.valueOf(false); //"false"
String str3 = String.valueOf(123); //"123"
String str4 = String.valueOf(3.14f); //"3.14"
String str5 = String.valueOf('가'); //"가"

String str6 = true + ""; //"true"
String str7 = 123.45 + ""; //"123.45"

System.out.println(str1.equals(str6)); //출력: true

String str123 = "123"; // "123"

//  문자열을 정수 자료형으로 변환하기
byte bytNum = Byte.parseByte(str123); //123
short srtNum = Short.parseShort(str123); //123
int intNum = Integer.parseInt(str123); //123
long lngNum = Long.parseLong(str123); //123

double doubleNum = Double.parseDouble("1234.56"); // 1234.56

//  대소문자 무관 'true'일 때 true 반환
boolean bool1 = Boolean.parseBoolean("TRUE"); //true
boolean bool2 = Boolean.parseBoolean("true"); //true
boolean bool3 = Boolean.parseBoolean("T"); //false

//문자 타입(char)은 메소드를 사용해야 형변환이 가능함

4) 이스케이프 문자열

String str = "문자열에 역슬래쉬+\"큰따옴표\"를 해야 문자열 내부에 큰따옴표 기능이 가능,\n역슬래쉬+n은 줄바꿈 기능";
System.out.println(str);
String table = "역슬래쉬 + t는 tab만큼 띄어쓰기\t입니다.";
System.out.println(table);
char singleQuote = '\'';
System.out.println(singleQuote);

//경로를 지정할때는 \\를 사용 -> \하나만 사용하면 에러 발생
String path = "C:\\Document\\MyCodings";
System.out.println(path);