개발자/JAVA
[JAVA 6일차]wrapper/tpUppercase/chatAt/Math(반올림등)/equals/switch
GoGo개발
2022. 8. 15. 19:40
wrapper 클래스
프로그램에 따라 기본 타입의 데이터를 객체로 취급해야 하는 경우가 있습니다.
예를 들어, 메소드의 인수로 객체 타입만이 요구되면, 기본 타입의 데이터를 그대로 사용할 수는 없습니다.
이때에는 기본 타입의 데이터를 먼저 객체로 변환한 후 작업을 수행해야 합니다.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
=== *** wrapper 클래스 *** ===
------------------------------------------------
기본자료형(원시형, primitive) wrapper 클래스
------------------------------------------------
byte Byte
short Short
int Integer
long Long
char Character
float Float
double Double
boolean Boolean
------------------------------------------------
기본자료형(원시형)은 데이터 저장 및 4칙연산 에서만 사용하는 것이고,
wrapper 클래스는 데이터 저장 및 4칙연산 뿐만아니라
아주 다양한 기능의 메소드가 제공되므로 다방면으로 사용되어진다.
|
cs |
1. 방식,언박싱
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
Boxing(박싱, 포장을 하는 것)이란?
=> 기본자료형(boolean, byte, short, int, long, char, float, double)으로 되어진 변수를
객체타입인 Wrapper 클래스(Boolean, Byte, Short, ▶Integer, Long, ▶Character, Float, Double) 타입의 객체로 만들어 주는 것을 말한다.
int a1 = 10;
Integer a2 = new Integer(a1); // Boxting(박싱)
System.out.println("a2 => "+ a2); //a2
int b1 = 10;
Integer b2 = b1; // Auto Boxing(박싱) 클래스라 new 해줘야하는데 자동적으로 해준다. b2 => 10
System.out.println("b2 => "+ b2);
UnBoxing(언박싱, 포장을 푸는 것)이란?
=> rapper 클래스(Boolean, Byte, Short, ▶Integer, Long, ▶Character, Float, Double)로 되어진 객체를
기본자료형(boolean, byte, short, int, long, char, float, double)으로 만들어 주는 것
Integer a3 = new Integer(20); //원칙
int a4 = a3.intValue(); // UnBoxing(언박싱)
System.out.println("a4 => " + a4); // a4 => 20
int a5 = new Integer(20);// Auto UnBoxing(언박싱) int a4 = a3.intValue(); 생략 // a5 => 10
System.out.println("a5 =>" +a5); // a5 => 20
Double db1 = new Double(1.234567); // 원칙
double db2 = db1.doubleValue();//UnBoxing (언방싱)
System.out.println("db2 => " +db2); //db2 => 1.234567
double db3 = new Double(1.234567); // Auto UnBoxing(언박싱)
System.out.println("db3 =>" +db3); // db2 => 1.234567
|
cs |
<오토언박싱 이렇게도 가능>
double db4 = db1; // Auto UnBoxing(언박싱)
System.out.println("db4 =>" +db4); // db4 => 1.234567
참고 블로그
http://www.tcpschool.com/java/java_api_wrapper
코딩교육 티씨피스쿨
4차산업혁명, 코딩교육, 소프트웨어교육, 코딩기초, SW코딩, 기초코딩부터 자바 파이썬 등
tcpschool.com
2.toUppercase / toLowerCase
toUpperCase : 소문자는 대문자로 바꾸어 준다.
toLowerCase: 대문자를 소문자로 바꾸어 준다.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
Character chr = 'a';
System.out.println("chr =>" + chr); // chr -> a
System.out.println(chr + １); // (int) chr + 1 ==> (int)'a' + 1 =>97 + 1 =>98
System.out.println((char)(chr - 32)); // A
System.out.println((char)('a'-32)); // A
System.out.println(Character.toUpperCase('a')); // A 소문자를 대문자로
System.out.println(Character.toUpperCase('A')); // A
System.out.println(Character.toUpperCase(97)); // 65 파라미터 int 라서 'a'에 해당하는 int값을를 대문자 A의 int 값으로 알려준다
System.out.println(Character.toUpperCase(65)); // 65 65는 대문자A다.
System.out.println(Character.toLowerCase('A')); // a 대문자를 소문자로
System.out.println(Character.toLowerCase('a')); // a
System.out.println(Character.toLowerCase(65)); // 97 96은 소문자 a이다.
System.out.println(Character.toLowerCase(97)); // 97
|
cs |
3.대문자인지 소문자 인지 구별
3-1 첫번째 방법
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
char ch2 = 'C'; // 67 5,#c,C 넣어보기
if( 65 <= ch2 && ch2 <= 90 ) { // 대문자인지 알아본다.
// char 타입은 비교연산자( == ! > < >= <= )를 만나면 자동적으로 int 타입으로 형변환 되어진다.
System.out.println(ch2 + "는 대문자 입니다.");
}
else if( 97 <= ch2 && ch2 <= 122 ) { //소문자 인지 알아본다.
System.out.println(ch2 + "는 소문자 입니다.");
}
else if( 48 <= ch2 && ch2 <= 57 ) { //숫자 인지 알아본다.
System.out.println(ch2 + "는 숫자 입니다.");
}
else {
System.out.println(ch2 + "는 특수문자 입니다.");
}
|
cs |
3-2 두번째 방법
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
char ch1 = 'C'; // 67 5,#c,C 넣어보기
if( Character.isUpperCase(ch1) ) { // 대문자인지 알아본다. UpperCase
System.out.println(ch1 + "는 대문자 입니다.");
}
else if( Character.isLowerCase(ch1) ) { //소문자 인지 알아본다.LoweCase
System.out.println(ch1 + "는 소문자 입니다.");
}
else if( Character.isDigit(ch1)) { //숫자 인지 알아본다. Digit
System.out.println(ch1 + "는 숫자 입니다.");
}
else {
System.out.println(ch1 + "는 특수문자 입니다."); // 나머지
}
// C는 대문자 입니다. --------------
|
cs |
isUpeerCase : 입력받은 인자가 영문 대문자인지를 판단하여 true false 값을 리턴한다
4.charAt
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
String str = "Korea";
// 01234
char ch3 = str.charAt(0); // 'K' return 값은 char로 나온다
System.out.println(ch3); // 'K'
ch3 = str.charAt(3); // 'e'
System.out.println(ch3);// 'e'
Scanner sc = new Scanner(System.in);
System.out.println("한 글자만 입력하세요 ==> ");
// sc.nextLine() ==> "Seoul koea"
ch3 = sc.nextLine().charAt(0); // 's'
if( Character.isUpperCase(ch3) ) { // 대문자인지 알아본다. UpperCase
System.out.println(ch3 + "는 대문자 입니다.");
}
else if( Character.isLowerCase(ch3) ) { //소문자 인지 알아본다.LoweCase
System.out.println(ch3 + "는 소문자 입니다.");
}
else if( Character.isDigit(ch3)) { //숫자 인지 알아본다. Digit
System.out.println(ch3 + "는 숫자 입니다.");
}
else {
System.out.println(ch3 + "는 특수문자 입니다."); // 나머지
}
// S 는 대문자입니다.
|
cs |
charAt : 문자열에서 지정된 위치에 존재하는 문자를 찾아서 반환하는 함수
사용법 : "[문자열]".charAt([문자 위치]);
시작은 0부터 한다
math 클래스
1. 반올림
math.round(객체);
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
// 1. >>> 반올림에 대해서 알아본다. <<<
double db1=93.45678, db2=86.87654;
System.out.println("\n=== 반올림 한 후 ===");
System.out.println("db1=>" + Math.round(db1) + ", db2 =>" + Math.round(db2));
db1=>93, db2 =>87
Math.round(double 타입의 실수) ==> 리턴값이 long 타입의 정수가 나온다.
Math.round(float 타입의 실수) ==> int 타입의 정수
Math.round(실수) ==> 입력한 실수의 정수 일의 자리까지만 보여주고 나머지 소수부는 반올림하면서 삭제된다.
Math.round(93.45678) ==> 93
Math.round(86.87654) ==> 86
== 특정 소수부 자리에서 반올림을 하고자 한다. ==
db1 => 93.45678 ==> 93.5 (소수부 첫째 자리까지 나타내면서 반올림)
db2 => 86.87654 ==> 86.88 (소수부 둘째 자리까지 나타내면서 반올림)
93.45678 * 10 ==> 934.5678 ==> Math.round(934.5678) ==> 935 ==> 935/10.0 ==> 93.5
86.87654 * 100 ==> 8687.654 ==> Math.round(8687.654) ==> 8688 ==> 8688/100.0 ==> 86.88
System.out.println("\n=== 소수부 첫째 자리까지 나타내면서반올림 한 후 ===");
System.out.println("db1=>" + Math.round(db1*10)/10.0 + ", db2 =>" + Math.round(db2*10)/10.0);
db1 => 93.5 db2 => 86.9
System.out.println("\n=== 소수부 둘째 자리까지 나타내면서반올림 한 후 ===");
System.out.println("db1=>" + Math.round(db1*100)/100.0 + ", db2 =>" + Math.round(db2*100)/100.0);
db1 => 93.46 db2 => 86.88
|
cs |
2.올림
Math.ceil(객체);
|
1
2
3
4
5
6
7
8
9
|
// 2. >>> 올림에 대해서 알아본다. <<<
// 54.0 ==> Math.ceil(54.0) ==> 54.0
// 54.1 ==> Math.ceil(54.1) ==> 55.0
// 54.9 ==> MAth.ceil(54.9) ==> 55.0
double db3=54.0, db4=54.1, db5=54.9;
System.out.println("\n=== 올림 한 후 ===");
System.out.println("db3=>" + Math.ceil(db3) + ", db4=> " + Math.ceil(db4) + ", db5=>" + Math.ceil(db5));
// db3=>54.0, db4=> 55.0, db5=>55.0
|
cs |
3. 게시판 페이지 수 계산
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
웹페이지 게시판에서 보여줄 게시물이 32개 있다. 1페이지당 10개를 보여주고자 한다.
이러한 경우 총페이지수는 몇페이지 일까요?
10개 10개 10개 2개
1 2 3 4
총페이지수는 4페이지 이어야 한다.
totalCount = 32;
sizePerPage = 10;
totalPage = (double)totalCount/sizePerPage; // 실수로 만들기
System.out.println("totalPage => " + Math.ceil(totalPage));
//totalPage => Math.ceil(3.2) ==> 4.0
System.out.println("totalPage => " + (int) Math.ceil(totalPage)); // 올림 한뒤(Math.ceil()) 소수부 절삭(int)
//totalPage ==> 4
totalPge = (int) Math.ceil((double)totalCount/sizePerPage);
System.out.println("totalPge =>" + totalPge);
//totalPge => 4
|
cs |
4.내림
Math.floor(객체);
|
1
2
3
4
5
6
7
8
|
db3=54.0; db4=54.1; db5=54.9; // db3=54.0, db4=54.1, db5=54.9 콤마(,)는 맨처음 초기화 할때만 가능하다.
System.out.println("\n=== 내림 한 후 ===");
System.out.println("db3=>" + Math.floor(db3) + ", db4=> " + Math.floor(db4) + ", db5=>" + Math.floor(db5));
// db3=>54.0, db4=> 54.0, db5=>54.0
System.out.println("db3=>" + (int)Math.floor(db3) + ", db4=> " +(int) Math.floor(db4) + ", db5=>" + (int)Math.floor(db5));
// db3=>54, db4=> 54, db5=>54
|
cs |
5.절대값
Math.abs(객체);
|
1
2
3
4
5
6
7
8
9
10
|
System.out.println("\n=== 절대값 ===");
int a=20, b=-30;
System.out.println("a => " + a + " , b => "+b);
// a => 20 , b => -30
System.out.println("a => " + Math.abs(a) + " , b => "+ Math.abs(b)); //abs = absolute 절대값
// a => 20 , b => 30
|
cs |
equals
== 는 원시형 데이터들 사이에서 값을 비교하는 것이다.
|
1
2
3
4
5
6
7
8
|
int n1 = 10;
int n2 = 20;
if(n1 == n2) {
원시형(primitive) 데이터 사이에서 == 는 값을 비교하는 것이다.
}
|
cs |
==을 객체들사이에서 사용할때는 메모리상의 주소값을 비교해준다
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
Member mbr1 = new Member();
Member mbr2 = new Member();
System.out.println("mbr1 => " + mbr1);
//mbr1 => my.day06.c.IF.Member@15db9742
System.out.pritln("mbr2 => " + mbr2);
//mbr2 => my.day06.c.IF.Member@6d06d69c
if(mbr1 == mbr2) {
//객체 사이에서 == 는 메모리상에 올라가 있는 주소를 비교하는 것이다.
System.out.println(mbr1 + "는(은)" + mbr2 + "과(와) 메모리상의 주소가 같습니다.");
}
else {
System.out.println(mbr1 + "는(은)" + mbr2 + "과(와) 메모리상의 주소가 같지 않습니다.");
}
|
cs |
equals 는 객체들 사이의 값을 비교할 때 사용한다
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
tring name1 = new String("엄정화");
String name2 = new String("엄정화");
System.out.println("name1 => " + name1);
// name1 => 엄정화
System.out.println("name2 => " + name2);
// name2 => 엄정화
if( name1.equals(name2)) { //equals는 어떤 객체든 값을 비교한다.
//String name1 객체의 값("엄정화")과 String name2 객체의 값("엄청화")이 같으면 true
//String name1 객체의 값("엄정화")과 String name2 객체의 값("엄청화")이 같지 않으면 false
System.out.println(name1 + "의 값과" + name2 + "의 값은 같습니다.");
}
else {
System.out.println(name1 + "의 값과" + name2 + "의 값은 같지 않습니다.");
}
// 엄정화의 값과엄정화의 값은 같습니다.
|
cs |
<권장사항>
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
String name3 = "이순신";
String name4 = "이순신";
if( name3 == name4) { //위랑 다르게 new가 없다
// name3과 name4 생성시 new String()을 사용하지 않고 막바로 값을 넣었을 경우에는
// name3 == name4 값을 비교하는 것이다.
// 이것은 값을 비교하는 것이지만 권장하지 않는다.
System.out.println(name3 + "의 값과" + name4 + "의 값은 같습니다.");
}
else {
System.out.println(name3 + "의 값과" + name4 + "의 값은 같지 않습니다.");
}
// 이순신의 값과이순신의 값은 같습니다.
// String에 바로 값을 넣으면 값비교, new를 하면 메모리 주소를 비교한다.
if( name3.equals(name4)) { // String의 값을 비교할때는 이것을 권장한다!!! equals는 new가 있는 없든 값을 비교한다
System.out.println("euals 이용했을때 :" + name3 + "의 값과" + name4 + "의 값은 같습니다.");
}
else {
System.out.println(name3 + "의 값과" + name4 + "의 값은 같지 않습니다.");
}
// 이순신의 값과이순신의 값은 같습니다.
|
cs |
<equal 사용시 주의>
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
!!!! 주의 !!!!
String name5 = "강동원";
String name6 = null;
if(name5.equals(name6) ) {
System.out.println(name5 + "의 값과" + name6 + "의 값은 같습니다.");
}
else {
System.out.println(name5 + "의 값과" + name6 + "의 값은 같지 않습니다.");
}
// 강동원의 값과null의 값은 같지 않습니다.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (name6.equals(name5) ) { // name6 이 null 이므로 NullpointerException 오류가 발생함.
System.out.println(name5 + "의 값과" + name6 + "의 값은 같습니다.");
}
else {
System.out.println(name5 + "의 값과" + name6 + "의 값은 같지 않습니다.");
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if("호호"equlas(null)) {
이 것은 오류가 아님
}
if(null.equlas.("하하")) {
이것은 오류임.
}
그러므로 상수값.equals(변수)와 같이 사용해야 하지
변수.equals(상수값)와 같이 사용할 경우 변수에 null이 들어올 확률이 있으므로
이것은 별로 좋지 않은 방법이다.
|
cs |
switch 문
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
witch (operator) { // switch() 괄호 속에는 byte 타입, short 타입, int 타입, char타입, String 타입은 가능하다.
// switch() 괄호 속에는 long타입, float 타입, Sting을 제외한 객체타입은 불가함.
case "+": // operator 값이 "+"와 같다라면
result = String.valueOf(num1+num2); // int타입을 string 타입으로 바꿔준다
break; // break; 뜻은 switch (operator) { } 부분을 빠져나가라는 뜻이다.
case "-": // operator 값이 "-"와 같다라면
result = String.valueOf(num1-num2);
break;
case "*": // operator 값이 "*"와 같다라면
result = String.valueOf(num1*num2);
break; // break; 뜻은 switch (operator) { } 부분을 빠져나가라는 뜻이다.
case "/": // operator 값이 "/"와 같다라면
if(num2 != 0) {
result = String.valueOf((double)num1/num2);
}
else
result = "분모에는 0 이 올 수 없습니다.";
break; // break; 뜻은 switch (operator) { } 부분을 빠져나가라는 뜻이다.
default: // operator 값이 "+" 도 아니고 "-"도 아니고 "*"도 아니고 "/" 도 아닌 경우
System.out.println(">>사칙연산자 ( + - * /)만 선택하세요!! <<");
// break; // break; 뜻은 switch (operator) { } 부분을 빠져나가라는 뜻이다.
sc.close();
return; // main() 메소드 안에서 return; 을 만나면 프로그램을 종료해라는 뜻이다.
//또는
System.exit(0); // 프로그램을 종료하라는 뜻이다. 0은 정상종료. 456 이런건 좀 찝찝한 종료
} // end of switch (operater)-------------
|
cs |