Programming/국비학원
220512 - API - Object 클래스(equals, hashCode, toString, clone), StringTokenizer 클래스, StringBuilder 클래스, 정규표현식, Pattern 클래스, Arrays 클래스
지고르
2022. 5. 13. 10:55
Object 클래스
: 모든 클래스의 부모, 하단 메소드들 가짐
=> 별도 표시 없이 바로 오버라이드 가능
ex. public boolean equals (Object obj) {~}
- equals
|
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
|
public class StringEx6 {
public static void main(String[] args) {
String name1 = new String("홍길동");
String name2 = new String("홍길동");
if (name1==name2) { //참조값=주소번지
System.out.println("같은 이름입니다.");
}else {
System.out.println("다른 이름입니다.");
}
}
}
//
다른 이름입니다.
public static void main(String[] args) {
String name1 = new String("홍길동");
String name2 = new String("홍길동");
if (name1.equals(name2)) { //값내용
System.out.println("같은 이름입니다.");
}else {
System.out.println("다른 이름입니다.");
}
}
}
//
같은 이름입니다.
|
cs |
=>
String 클래스의 equals 메소드는 내용값 정보 가져오지만,
Object 클래스의 equals 메소드는 얕은 복사까지만 가능
- hashCode : 객체를 식별할 하나의 정수값
[기초부터자바] hashcode란? hashcode와 equals의 관계(2) { 오버라이드, 재정의 문제 포함}
저번 포스팅에서 hashcode가 무엇인지 알아보았습니다.이번 포스팅에서는 equals메소드와 비교하여 hashcod...
blog.naver.com
https://mangkyu.tistory.com/101
[Java] equals와 hashCode 함수
1. equals와 hashCode란? equals와 hashCode는 모든 Java 객체의 부모 객체인 Object 클래스에 정의되어 있다. 그렇기 때문에 Java의 모든 객체는 Object 클래스에 정의된 equals와 hashCode 함수를 상속받고 있다..
mangkyu.tistory.com
※HashMap
HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("김철수", 90);
map.put("이영희", 80);
sysout~ (map.get("김철수"));
sysout~ (map.get("이영희"));
//
90
80
=> key: "김철수", value: 90
- Key
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
public class Key {
//필드
public int number;
//생성자
public Key(int number) {
this.number=number;
}
//메소드
@Override
public boolean equals (Object obj) {
if (obj instanceof Key) {
//=매개변수로 들어오기 전 Key 타입이었다면 //객체타입 확인 Key compareKey = (Key)obj; //강제타입변환
if (this.number==compareKey.number) {
return true;
}
}
return false;
}
}
|
cs |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
import java.util.HashMap;
public class KeyEx1 {
public static void main(String[] args) {
HashMap<Key, String> hashMap = new HashMap<Key, String>();
Key key1 = new Key(1);
Key key2 = new Key(2);
hashMap.put(key1, "김철수");
hashMap.put(key2, "홍길동");
String value1 = hashMap.get(key1);
String value2 = hashMap.get(key2);
System.out.println(value1);
System.out.println(value2);
}
}
|
cs |
//
김철수
홍길동
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
import java.util.HashMap;
public class KeyEx1 {
public static void main(String[] args) {
HashMap<Key, String> hashMap = new HashMap<Key, String>();
Key key1 = new Key(1);
Key key2 = new Key(2);
hashMap.put(new Key(1), "김철수"); //새 객체
hashMap.put(new Key(2), "홍길동");
String value1 = hashMap.get(new Key(1)); //새 객체
String value2 = hashMap.get(new Key(2));
System.out.println(value1);
System.out.println(value2);
}
}
|
cs |
//
nullnull
|
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
37
38
39
40
41
42
43
44
45
46
|
public class Key {
//필드
public int number;
//생성자
public Key(int number) {
this.number=number;
}
//메소드
@Override
public boolean equals (Object obj) {
if (obj instanceof Key) {
Key compareKey = (Key)obj; //강제타입변환
if (this.number==compareKey.number) {
return true;
}
}
return false;
}
@Override
public int hashCode() {
return number;
}
}
import java.util.HashMap;
public class KeyEx1 {
public static void main(String[] args) {
HashMap<Key, String> hashMap = new HashMap<Key, String>();
Key key1 = new Key(1);
Key key2 = new Key(2);
hashMap.put(new Key(1), "김철수");
hashMap.put(new Key(2), "홍길동");
String value1 = hashMap.get(new Key(1));
String value2 = hashMap.get(new Key(2));
System.out.println(value1);
System.out.println(value2);
}
}
|
cs |
//
김철수
홍길동
=> Key 클래스에 hashCode 메소드 추가 -> 동일 예제에서 null->값 출력 변화
=> 개발자가 hashCode() 메소드 조건 추가하며 오버라이드 -> hashCode, 즉 주소번지에 대한 일치 조건 만듦
- toString : 객체 문자 정보
클래스명@16진수해시코드 리턴
=> 값어치없는 정보 -> 하위 클래스에서 toString() 메소드 오버라이딩 -> 유익한 정보 리턴함
ex.
Date obj = new Date();
sysout~(obj)
//
Wed Nov 13 09:33:33 KST 2022
예제에 맞춰 오버라이딩도 가능
- clone
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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
|
public class Member implements Cloneable { //복제할 수 있다는 표시
public String id;
public String name;
public String password;
public int age;
public boolean adult;
public Member(String id, String name, String password, int age, boolean adult) {
this.id=id;
this.name=name;
this.password=password;
this.age=age;
this.adult=adult;
}
public Member getMember() { //리턴형 메소드 => Member클래스 리턴
Member cloned = null;
try {
cloned=(Member) clone(); //clone 메소드 리턴 타입은 Object 이므로 강제 형변환
}catch(CloneNotSupportedException e) { //Cloneable 인터페이스 implement해야 함
}
return cloned;
}
}
public class MemberEx1 {
public static void main(String[] args) {
//Member 인스턴스 객체 생성
Member original = new Member("hong","홍길동","12345",50,true);
Member cloned = original.getMember(); //복제된 객체
cloned.password="56789";
//원본 객체 출력
System.out.println("아이디 : "+original.id);
System.out.println("이름 : "+original.name);
System.out.println("비밀번호 : "+original.password);
System.out.println("나이 : "+original.age);
System.out.println("어른인가요? "+original.adult);
//복제 객체 출력
System.out.println("아이디 : "+cloned.id);
System.out.println("이름 : "+cloned.name);
System.out.println("비밀번호 : "+cloned.password);
System.out.println("나이 : "+cloned.age);
System.out.println("어른인가요? "+cloned.adult);
}
}
|
cs |
//
아이디 : hong
이름 : 홍길동
비밀번호 : 12345
나이 : 50
어른인가요? true
아이디 : hong
이름 : 홍길동
비밀번호 : 56789
나이 : 50
어른인가요? true
|
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
public class Member2 implements Cloneable{
public String name;
public int age;
public int[] scores; //참조타입
public Car car; //참조타입
public Member2(String name, int age, int[] scores, Car car) {
this.name=name;
this.age=age;
this.scores=scores;
this.car=car;
}
public Member2 getMember() { //리턴형 메소드 => Member클래스 리턴
Member2 cloned = null;
try {
cloned=(Member2) clone();
}catch(CloneNotSupportedException e) {
}
return cloned;
}
}
public class Member2Ex1 {
public static void main(String[] args) {
//Member2 인스턴스 객체 생성
Member2 original = new Member2("홍길동",50,new int[] {80,90,100},new Car("소나타"));
Member2 cloned = original.getMember();
cloned.scores[1]=76;
cloned.car.model="그랜저";
cloned.age=30; //얕은 복제
//원본 객체 출력
System.out.println("[원본 객체]");
System.out.println("이름 : "+original.name);
System.out.println("나이 : "+original.age);
System.out.println("국어 : "+original.scores[0]);
System.out.println("영어 : "+original.scores[1]);
System.out.println("수학 : "+original.scores[2]);
System.out.println("모델 : "+original.car.model);
//복제 객체 출력
System.out.println("[복제 객체]");
System.out.println("이름 : "+cloned.name);
System.out.println("나이 : "+cloned.age);
System.out.println("국어 : "+cloned.scores[0]);
System.out.println("영어 : "+cloned.scores[1]);
System.out.println("수학 : "+cloned.scores[2]);
System.out.println("모델 : "+cloned.car.model);
}
}
|
cs |
//
[원본 객체]
이름 : 홍길동
나이 : 50
국어 : 80
영어 : 76
수학 : 100
모델 : 그랜저
[복제 객체]
이름 : 홍길동
나이 : 30
국어 : 80
영어 : 76
수학 : 100
모델 : 그랜저
=> 얕은 복제 시 참조타입은 원본도 변형됨 => 생성자에서 주소값 넘어가서
2. 깊은 복제 (참조타입)
: 참조 객체도 새로 복제
☆clone() 메소드 오버라이드 & 참조객체 복제하는 코드 직접 작성 필수
|
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
|
import java.nio.charset.CoderMalfunctionError;
import java.util.Arrays;
public class Member2 implements Cloneable{
public String name;
public int age;
public int[] scores; //참조타입
public Car car; //참조타입
public Member2(String name, int age, int[] scores, Car car) {
this.name=name;
this.age=age;
this.scores=scores;
this.car=car;
}
@Override
protected Object clone() throws CloneNotSupportedException{
//먼저 얕은 복제 (name, age)
Member2 cloned = (Member2)super.clone(); //부모생성자 호출 후 복제
//scores 깊은 복제
cloned.scores=Arrays.copyOf(this.scores, this.scores.length);
//car 깊은 복제
cloned.car=new Car(this.car.model);
return cloned;
}
public Member2 getMember() {
Member2 cloned = null;
try {
cloned=(Member2) clone();
}catch(CloneNotSupportedException e) {
}
return cloned;
}
}
public class Member2Ex1 {
public static void main(String[] args) {
//Member2 인스턴스 객체 생성
Member2 original = new Member2("홍길동",50,new int[] {80,90,100},new Car("소나타"));
Member2 cloned = original.getMember();
cloned.scores[1]=76;
cloned.car.model="그랜저";
cloned.age=30;
//원본 객체 출력
System.out.println("[원본 객체]");
System.out.println("이름 : "+original.name);
System.out.println("나이 : "+original.age);
System.out.println("국어 : "+original.scores[0]);
System.out.println("영어 : "+original.scores[1]);
System.out.println("수학 : "+original.scores[2]);
System.out.println("모델 : "+original.car.model);
//복제 객체 출력
System.out.println("[복제 객체]");
System.out.println("이름 : "+cloned.name);
System.out.println("나이 : "+cloned.age);
System.out.println("국어 : "+cloned.scores[0]);
System.out.println("영어 : "+cloned.scores[1]);
System.out.println("수학 : "+cloned.scores[2]);
System.out.println("모델 : "+cloned.car.model);
}
}
|
cs |
//
[원본 객체]
이름 : 홍길동
나이 : 50
국어 : 80
영어 : 90
수학 : 100
모델 : 소나타
[복제 객체]
이름 : 홍길동
나이 : 30
국어 : 80
영어 : 76
수학 : 100
모델 : 그랜저
StringTokenizer 클래스
: 문자열(토큰) 분리해주는 클래스
=> 문자로 구분
|
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
|
import java.util.StringTokenizer;
public class StringTokenizerEx1 {
public static void main(String[] args) {
String str = "홍길동*김철수*이영희";
StringTokenizer st = new StringTokenizer(str, "*");
int countTokens = st.countTokens(); //남아있는 토큰 수
for(int i=0;i<countTokens;i++) {
String name=st.nextToken(); //토큰 하나씩 꺼냄
System.out.println(name);
}
}
}
//
홍길동
김철수
이영희
import java.util.StringTokenizer;
public class StringTokenizerEx1 {
public static void main(String[] args) {
String str = "홍길동*김철수*이영희";
StringTokenizer st = new StringTokenizer(str, "*");
while(st.hasMoreTokens()) { //남아있는 토큰이 있는지 여부
String name = st.nextToken();
System.out.println(name);
}
}
}
//
홍길동
김철수
이영희
import java.util.StringTokenizer;
public class StringTokenizerEx1 {
public static void main(String[] args) {
String str = "홍길동#김철수*이영희";
StringTokenizer st = new StringTokenizer(str, "#|*");
int countTokens = st.countTokens();
for(int i=0;i<countTokens;i++) {
String name=st.nextToken();
System.out.println(name);
}
}
}
|
cs |
- split() 메소드 (정규 표현식으로 구분)
|
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
|
public class SplitEx1 {
public static void main(String[] args) {
String text = "김철수,이영희,홍길동,박찬호,이영표";
String[] names = text.split(",");
System.out.println(names[1]);
}
}
//
이영희
public class SplitEx1 {
public static void main(String[] args) {
String text = "김철수,이영희,홍길동,박찬호,이영표";
String[] names = text.split(",");
for (String na:names) {
System.out.println(na);
}
}
}
//
김철수
이영희
홍길동
박찬호
이영표
|
cs |
StringBuilder 클래스 (멀티스레드 환경에서는 StringBuffer 클래스)
: 문자열 변경
|
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
|
public class StringBuilderEx1 {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
sb.append("java ");
sb.append("Pregram Study");
System.out.println(sb);
sb.insert(12, "ming"); //12번째 위치에 문자열 대입
System.out.println(sb);
sb.setCharAt(7, 'o'); //7번째 위치 문자 변경
System.out.println(sb); //묵시적 호출(Object 클래스는 내부적으로 오버라이딩하고 있음)
sb.replace(5, 16, "API"); //5~15번째 문자열 대체
System.out.println(sb.toString());
sb.delete(4, 8);
System.out.println(sb.toString());
System.out.println("총 글자수 : "+sb.length());
String result = sb.toString(); //명시적 호출, 버퍼에 있는 것을 String타입으로 변환
System.out.println(result);
}
//
java Pregram Study
java Pregramming Study
java Programming Study
java API Study
java Study
총 글자수 : 10
java Study
|
cs |
정규 표현식
java.util.regex.Pattern 클래스
[] : 한 개의 문자 ([abc]: abc 중 하나 / [^abc]: abc 제외한 하나 / [a-zA-Z]: a~z, A~Z 중 하나)
\d : 한 개의 숫자 (=[0-9])
\s : 공백
\w : 한 개의 알파벳 또는 한개의 숫자 (=[a-zA-Z_0-9])
? : 없음 또는 한개
* : 없음 또는 한개 이상
+ : 한개 이상
{n} : 정확히 n개
{n,} : 최소한 n개
{n,m} : n개에서부터 m개까지
() : 그룹핑
(010|02) : 010 또는 02
\. : .
. : 한 개의 문자
Pattern 클래스
|
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
|
import java.util.Scanner;
import java.util.regex.Pattern;
public class PatternEx1 {
public static void main(String[] args) {
//전화번호 검증
Scanner sc = new Scanner(System.in);
String regExp="(02|010)-\\d{3,4}-\\d{4}";
System.out.print("전화번호 입력>> ");
String tel = sc.next();
boolean result = Pattern.matches(regExp, tel); //(정규식,검증할 문자열)
if (result) {
System.out.println("올바른 전화번호");
}else {
System.out.println("전화번호 형식이 틀림");
}
System.out.print("이메일 입력>> ");
String email = sc.next();
regExp = "\\w+@\\w+\\.\\w+";
boolean result2 = Pattern.matches(regExp, email);
if (result2) {
System.out.println("올바른 이메일");
}else {
System.out.println("이메일 형식이 틀림");
}
}
}
|
cs |
※replaceall
String intro ="내 나이는 25세이다.";
String newintro = intro.replaceAll("[0-9]", "*");
System.out.println(newintro);
//
내 나이는 **세이다.
String hello="안녕하세요. 반가워요. 잘 가세요.";
String newHello=hello.replaceAll(".", "^^"); //정규표현식으로 인식
System.out.println(newHello);
//
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
String hello="안녕하세요. 반가워요. 잘 가세요.";
String newHello=hello.replace(".", "^^"); //문자로 인식
System.out.println(newHello);
//
안녕하세요^^ 반가워요^^ 잘 가세요^^
Arrays 클래스
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
import java.util.Arrays;
public class ArraysEx1 {
public static void main(String[] args) {
int[] scores = {50,90,70,80,88};
Arrays.sort(scores);
for (int i=0;i<scores.length;i++) {
System.out.println(scores[i]);
}
String[] names = {"다","티","공"};
Arrays.sort(names);
for (int i=0;i<names.length;i++) {
System.out.println(names[i]);
}
}
}
|
cs |
//
50
70
80
88
90
공
다
티