API
API(Application Programming Interface)란?
- 응용 프로그램에서 사용할 수 있도록 운영체제나 프로그래밍 언어가 제공하는 기능을 제어할 수 있게 만든
인터페이스 - 이전에 배운 인터페이스와는 다른 개념이다.
- API는 패키지 별로 묶여있다.
자바 API
- 자바 플랫폼 위에서 동작하는 애플리케이션 개발 시 활용 (유용한 클래스 및 인터페이스 제공)
- JDK를 설치하면 시스템을 제어하거나 편의 기능을 위한 API를 제공
Object
모든 클래스는 Object 클래스의 후손
- java.lang 패키지에 존재
- Obejct 클래스가 가진 메소드 중 관례상 많이 오버라이딩 해서 사용하는 메소드들이 존재
ex) toString(), equals(), hashCode() - java.lang 패키지는 자동으로 임포트 되기 때문에 따로 임포트 해 줄 필요없다.
- 제공하는 메소드
| toString( ) | 문자열로 변환 인스턴스 생성 시 사용한 full class name, @, 그리고 16진수 해쉬코드가 문자열로 반환 |
| equals( ) | 매개변수로 전달 받은 인스턴스와 == 연산하여 true 또는 false를 반환 동일 인스턴스인지를 비교, '같은지'를 물어보는데 '주소값'을 기준으로 물어보는 것 (동일 객체 : 주소가 동일한 인스턴스) (동등 객체 : 주소가 다르더라도 필드 값이 동일한 인스턴스) |
| hashCode( ) | 인스턴스의 주소값을 변환하여 생성한 인스턴스의 고유 값을 반환 |
class Book
public class Book {
/* 필드생성 */
private int number;
private String title;
private String author;
private int price;
/* 기본생성자 */
public Book() {
super();
}
/* 매개변수 생성자 */
public Book(int number, String title, String author, int price) {
super();
this.number = number;
this.title = title;
this.author = author;
this.price = price;
}
/* 게터와 세터 */
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
/* 우클릭 - source - Generate toString() 생성 */
@Override
public String toString() {
return "Book [number=" + number + ", title=" + title + ", author=" + author + ", price=" + price + "]";
}
/* toString()에 대해서 오버라이딩 */
// @Override
// public String toString() {
// return "Book [number=" + this.number
// + ", title=" + this.title
// + ", author=" + this.author
// + ", price=" + this.price
// + "]";
// }
/* equals------------------------------------------------ */
/* equals()에 대해서 오버라이딩 */
@Override
public boolean equals(Object obj) {
/* 두 인스턴스의 주소가 같으면 이후 다른 내용을 비교할 것 없이
* true 반환, 즉 주소가 동일한 인스턴스(동일 객체)인지 확인 */
if (this == obj)
return true;
/* this는 인스턴스가 생성되면 주소값이 저장된다. null일 수 없다.
* 따라서 전달 받은 레퍼런스 변수에 null값이 저장 돼 있다면
* 비교하려는 두개의 인스턴스는 서로 다른 인스턴스이다.
* */
if (obj == null)
return false;
/* 동일한지의 여부를 묻고싶은 것이므로
* this와 obj의 클래스가 같지 않다면 필드값을 비교할 필요가 없다. */
if (getClass() != obj.getClass())
return false;
/* 전달 받은 레퍼런스 변수를 Book 타입으로
* (강제)형변환하여 각 필드별로 비교를 시작한다. */
Book other = (Book) obj;
/* String 타입의 경우 null여부 먼저 확인 */
if (author == null) {
if (other.author != null)
return false; // this상 null other는 not null이므로 false
/* this가 null이 아닌 경우 String 클래스의 equals를 호출해서 값 비교 */
} else if (!author.equals(other.author))
return false;
/* 숫자값은 비교적 쉽게 바로 값 비교 가능 */
if (number != other.number)
return false;
if (price != other.price)
return false;
/* title도 String 타입이므로 author와 동일 */
if (title == null) {
if (other.title != null)
return false; // null
} else if (!title.equals(other.title))
return false;
/* 모든 조건을 통과하면 두 인스턴스의 모든 필드는 같은 값을
* 가지므로 true 반환 */
return true;
}
/* 객체의 동등성을 비교하기 위해서 equals를 오버라이딩 한다. */
// 두 인스턴스의 == 연산비교 : false
// 두 인스턴스의 == 연산비교 : true
/* hashCode------------------------------------------------ */
@Override
public int hashCode() {
/* 필드마다 곱해줄 소수값 선언
* 31은 소수이기 때문에 연산 시 동일한 hashCode 값이 나오지않을 확률을
* 증가시킨다.
* s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
*
* 31이 통상 적인 관례이며 String 클래스의 hashCode에도 사용한 값이다.
* 아주 낮은 확률로 같은 수가 나오는 경우가 있을 수 있지만 소수값은
* 그 확률을 최소화 시킨다.
*
* */
/* 필드값이 같으면 동일 해쉬코드를 반환한다 : 를 확인하기 위한 목적 */
final int prime = 31;
/* prime(31)과의 곱셉 연산을 result에 누적시킨 값 선언 */
int result = 1;
/* String 클래스의 hashCode메소드는 이미 재정의 되어있다.
* 같은 값을 가지는 문자열은 동일한 hashCode값을 반환한다.
* */
result = prime * result + ((author == null) ? 0 : author.hashCode());
result = prime * result + number;
result = prime * result + price;
result = prime * result + ((title == null) ? 0 : title.hashCode());
/* 동등 객체는 동일한 hashCode값을 반환하게 된다. */
return result;
// book1의 hashCode : 2010084336
// book2의 hashCode : 2010084336
}
}
class Application1
import com.greedy.section01.object.book.Book;
public class Application1 {
public static void main(String[] args) {
Book book1 = new Book(1, "홍길동전", "허균", 50000);
Book book2 = new Book(2, "목민심서", "정약용", 30000);
Book book3 = new Book(3, "칭찬은 고래를 춤추게 한다", "고래", 40000);
System.out.println("book1.toString : " + book1.toString());
System.out.println("book2.toString : " + book2.toString());
System.out.println("book3.toString : " + book3.toString());
/* java.lang.Object 클래스의 toString()메소드는
* 인스턴스가 생성될 때 사용한 full class name과 @ 그리고 16진수 해쉬코드가
* 문자열로 반환된다. 16진수 해쉬코드는 인스턴스의 주소를 가리키는 값으로
* 인스턴스마다 모두 다르게 반환된다. */
// return getClass().getName() + "@" + Integer.toHexString(hashCode());
// book1.toString : com.greedy.section01.object.book.Book@4926097b
// book2.toString : com.greedy.section01.object.book.Book@39ed3c8d
// book3.toString : com.greedy.section01.object.book.Book@71dac704
/*(+)
* 레퍼런스 변수만 출력하는 경우도 동일한 결과가 나온다.
* 이 경우도 자동으로 toString()메소드를 호출한다.
* 이러한 점을 이용해서 toString() 메소드를 재정의해서 사용하게된다. */
System.out.println("book1 : " + book1);
System.out.println("book2 : " + book2);
System.out.println("book3 : " + book3);
// book1 : com.greedy.section01.object.book.Book@4926097b
// book2 : com.greedy.section01.object.book.Book@39ed3c8d
// book3 : com.greedy.section01.object.book.Book@71dac704
/* toString을 오버라이딩 한 결과 */
// book1 : Book [number=1, title=홍길동전, author=허균, price=50000]
// book2 : Book [number=2, title=목민심서, author=정약용, price=30000]
// book3 : Book [number=3, title=칭찬은 고래를 춤추게 한다, author=고래, price=40000]
/* 상속관계이므로 Object의 모든 기능을 book도 이용할 수 있다.
* 오버라이드시 후손의 메소드를 호출하는 것이다.
* toString을 자식클래스에서 재정의했으므로
* 부모클래스인 오브젝트의 toString 호출시 book에서 재정의한 결과가 나온다. */
}
}
class Application2
import com.greedy.section01.object.book.Book;
public class Application2 {
public static void main(String[] args) {
/* java.lang.Object 의 equals는 매개변수로 전달받은
* 인스턴스와 == 연산하여 true or false 를 반환한다.
* 즉, 동일한 인스턴스인지 비교하는 기능을 한다.
*
* 동일 객체와 동등객체
* 동일객체 : 주소가 동일한 인스턴스를 동일객체라고 한다.
* 동등객체 : 주소는 다르더라도 필드 값이 동일한 객체를 동등객체라고 한다.
*
* equals() 메소드의 기본 기능은 동일객체 판단을 한다고 볼 수 있다.(동일성 확인)
* 그러한 경우 equals()를 오버라이딩하여 각각의 필드가 동일한 값을 가지는기 확인하고
* 모든 필드값이 같은 값을 가지는 경우 true, 아닌 경우 false를 반환하도록 작성한다.
*
* */
Book book1 = new Book(1, "홍길동전", "허균", 50000);
Book book2 = new Book(1, "홍길동전", "허균", 50000);
System.out.println("두 인스턴스의 == 연산비교 : " + (book1 == book2));
System.out.println("두 인스턴스의 == 연산비교 : " + (book1.equals(book2)));
/* 동일객체 비교 */
// 두 인스턴스의 == 연산비교 : false
// 두 인스턴스의 == 연산비교 : false
/* 오버라이딩 후 동등객체 비교 */
// 두 인스턴스의 == 연산비교 : false
// 두 인스턴스의 == 연산비교 : true
}
}
class Application3
import com.greedy.section01.object.book.Book;
public class Application3 {
public static void main(String[] args) {
/* Object 클래스의 명세에 작성 된 일반 규약에 따르면
* equals() 메소드를 재 정의하는 경우 반드시 hashCode() 메소드도
* 재정의하게 되어 있다.(hashCode와 equals는 같이 간다고 생각)
* 만약 hashCode()를 재정의하지 않으면 같은 값을 가지는 동등 객체는
* 같은 해시코드 값을 가져와야 한다는 규약을 위반하게 된다.
* (강제성은 없지만 규약대로 작성하는 것이 좋음)
*/
/* 동등 객체 생성 후 hashCode를 출력하면
* java.lang.Object 는 인스턴스 주소이므로 다른값이 나온다.
* 오버라이딩해서 동등 객체의 경우 같은 hashCode 를 리턴하도록 한다. */
Book book1 = new Book(1, "홍길동전", "허균", 50000);
Book book2 = new Book(1, "홍길동전", "허균", 50000);
System.out.println("book1의 hashCode : " + book1.hashCode());
System.out.println("book2의 hashCode : " + book2.hashCode());
/* 출력시 필드값은 같은 동등객체임을 알 수 있다. 주소값은 다르다. */
// book1의 hashCode : 1227229563
// book2의 hashCode : 971848845
/* 동등객체 판단을 위한 오버라이딩 */
/* hashCode 오버라이딩 후 동등객체로 판단되어 같은 주소값을 반환한다. */
// book1의 hashCode : 2010084336
// book2의 hashCode : 2010084336
}
}
String
Java.lang 패키지에 존재하는 클래스로 문자열을 처리하는 여러가지 메소드를 제공
- 제공하는 메소드
| charAt() | 해당 문자열의 특정 인덱스에 해당하는 문자 반환 |
| compareTo() | 두 문자열이 같은지 다른지에 따라 int 값을 반환 |
| compareToIgnoreCase() | 대소문자를 구분하지 않고 비교 후 int 값을 반환 |
| concat() | 문자열에 인자로 전달 된 문자열을 합침 |
| indexOf() | 문자열을 앞에서부터 탐색하여 일치하는 위치의 인덱스를 int 값으로 반환 |
| lastIndexOf() | 문자열을 뒤에서부터 탐색하여 일치하는 위치의 인덱스를 int 값으로 반환 |
| trim() | 문자열의 앞 뒤 공백을 제거 후 문자열을 반환 |
| toLowerCase() | 모든 문자를 소문자로 변환 후 문자열을 반환 |
| toUpperCase() | 모든 문자를 대문자로 변환 후 문자열을 반환 |
Application1
public class Application1 {
public static void main(String[] args) {
/* String 클래스의 자주 사용되는 메소드 */
/* chatAt() : 해당 문자열의 특정 인덱스에 해당하는 문자를 반환한다.
* 인덱스는 0부터 시작하는 숫자 체계를 의미하며
* 인덱스를 벗어난 정수를 인자로 전달하는 경우에는 IndexOutOfBoundsException
* 이 발생한다. */
String str1 = "apple";
for (int i = 0; i < str1.length(); i++) {
System.out.println("charAt(" + i + ")" + str1.charAt(i));
}
// charAt(0)a
// charAt(1)p
// charAt(2)p
// charAt(3)l
// charAt(4)e
/* compareTo() : 인자로 전달된 문자열과 사전 순으로 비교를 하여
* 두 문자열이 같아면 0을 반환, 인자로 전달된 문자열보다 작으면 음수를,
* 크면 양수를 반환한다.
* 단, 이 메소드는 대소문자를 구분하여 비교한다.
* */
String str2 = "java";
String str3 = "java";
String str4 = "JAVA";
String str5 = "oracle";
/* 같으면 0을 반환한다. */
System.out.println("compareTo() : " + (str2.compareTo(str3)));
// compareTo() : 0
/* 대문자와 소문자는 32만큼 차이가 난다. */
System.out.println("compareTo() : " + (str2.compareTo(str4)));
System.out.println("compareTo() : " + (str4.compareTo(str2)));
// compareTo() : 32
// compareTo() : -32
/* j부터 o까지 5만큼 차이가 난다. */
System.out.println("compareTo() : " + (str2.compareTo(str5)));
System.out.println("compareTo() : " + (str5.compareTo(str2)));
// compareTo() : -5
// compareTo() : 5
/* 목적 : 음수가 나오는지 양수가 나오는지를
* 파악하여 어느값이 앞 뒤에있는지 판단하기 위함
* 즉, 구체적으로 어떤 값이 나오는지보다 양수인지 음수인지를
* 판단할 목적으로 주로 사용된다.
* */
/* 대소문자를 구분하지않고 비교한다. */
/* 대소문자를 비교하는 메소드 : compareToIgnoreCase() */
System.out.println(str3.compareToIgnoreCase(str4));
// 0, 출력값 0, 즉 대소문자만 다른 java가 같은 값이란 얘기이다.
/* concat() : 문자열에 인자로 전달 된 문자열을 합치기
* 해서 새로운 문자열을 반환한다.
* 단 합쳐진 이후, 원본 문자열에는 영향을 주지 않는다.
* */
System.out.println("concat() : " + (str2.concat(str5)));
System.out.println("str2 : " + str2);
// concat() : javaoracle
// str2 : java
/* indexOf() : 문자열에서 특정 문자를 탐색하여 처음일치하는
* 인덱스 위치를 정수형으로 반환한다.
* 단, 일치하는 문자가 없는 경우 -1을 반환한다.
* */
String indexOf = "java oracle";
System.out.println("indexOf('a') : " + indexOf.indexOf('a'));
System.out.println("indexOf('z') : " + indexOf.indexOf('z'));
// indexOf('a') : 1
// indexOf('z') : -1 // 인덱스로 존재할 수 없는 정수값
/* lastIndexOf() : 문자열 탐색을 뒤에서부터 하고
* 처음 일치하는 위치의 인덱스를 반환한다.
* 단, 일치하는 문자가 없는 경우 -1을 반환한다.
* */
System.out.println("lastIndexOf('a') : " + indexOf.lastIndexOf('a'));
System.out.println("lastIndexOf('z') : " + indexOf.lastIndexOf('z'));
// lastIndexOf('a') : 7
// lastIndexOf('z') : -1
/* trim() : 문자열 앞 뒤에 공백을 제거한 문자열을 반환한다. */
String trimStr = " java ";
System.out.println("trimStr : #" + trimStr + "#");
System.out.println("trim() : #" + trimStr.trim() + "#");
/* 원본에 영향을 주지는 않는다. */
System.out.println("trimStr : #" + trimStr + "#");
// trimStr : # java #
// trim() : #java#
// trimStr : # java #
/* toLowerCase() : 모든 문자를 소문자로 변환시킨다.
* toUpperCase() : 모든 문자를 대문자로 변환시킨다.
* 원본에는 영향을 주지 않는다.
* */
String caseStr = "JavaOracle";
System.out.println("toLowerCase() : " + caseStr.toLowerCase());
System.out.println("toUpperCase() : " + caseStr.toUpperCase());
System.out.println("caseStr : " + caseStr);
// toLowerCase() : javaoracle
// toUpperCase() : JAVAORACLE
// caseStr : JavaOracle
/* substring() : 문자열의 일부를 잘라내어 새로운 문자열을 반환한다.
* 원본에는 영향을 주지 않는다.
* */
String javaoracle = "javaoracle";
System.out.println("substring(3,6) : " + javaoracle.substring(3,6));
System.out.println("substring(3) : " + javaoracle.substring(3));
System.out.println("javaoracle : " + javaoracle);
// substring(3,6) : aor // 인덱스 3,4,5 까지 추출한다는 의미
// substring(3) : aoracle // 시작인덱스 3부터 문자열의 끝까지 추출
// javaoracle : javaoracle
/* replace() : 문자열에서 대체할 문자열로 기존 문자열을 변경해서 반환한다.
* 원본에는 영향을 주지 않는다. */
System.out.println("replace() : " + javaoracle.replace("java", "python"));
System.out.println("javaoracle : " + javaoracle);
// replace() : pythonoracle // 자바를 파이썬으로 변경한다는 의미
// javaoracle : javaoracle
/* length() : 문자열의 길이를 정수형으로 반환한다. */
System.out.println("length() : " + javaoracle.length());
System.out.println("빈문자열길이 : " + ("".length()));
// length() : 10
// 빈문자열길이 : 0
/* isEmpty() : 문자열의 길이가 0이면 true를 반환, 아니면 false를 반환
* 길이가 0인 문자열은 null과는 다르다. */
System.out.println("isEmpty() : " + "".isEmpty());
System.out.println("isEmpty() : " + "abc".isEmpty());
// isEmpty() : true
// isEmpty() : false
}
}
Application2
public class Application2 {
public static void main(String[] args) {
/* 문자열 객체 사용하는 방법 */
/* "" 리터럴 형태 : 동일한 값을 가지는 인스턴스를
* 단일 인스턴스로 관리한다. (singleton)
* 즉, 같은 문자열에 대해선 더이상 인스턴스를 생성하지않는다.
*
* new String("문자열") : 매번 새로운 인스턴스를 생성한다.
*
* 즉 같은 리터럴이어도 생성 방식이 다르다.
* */
String str1 = "java";
String str2 = "java";
String str3 = new String("java");
String str4 = new String("java");
/* 리터럴 형대로 만든 문자열 인스턴스는 동일한 값을 가지는 인스턴스는 하나의
* 인스턴스로 관리한다.
* 따라서 주소값을 비교하는 == 연산으로 비교시 서로 동일한 주소를 비교하여
* true를 반환한다. */
System.out.println(" str1 == str2 " + ( str1 == str2 ));
// 리터럴이 같은경우 더이상 인스턴스를 생성하지않는다. 주소값이 같다고 간주한다.
/* new로 새로운 인스턴스를 생성하게 되면 기존 인스턴스를 두고 새로운 인스턴스를
* 할당했기 때문에 == 연산으로 비교 시 서로 다른 주소값을 가지게 되므로
* false 를 반환한다. */
System.out.println(" str2 == str3 " + ( str2 == str3 ));
/* 동일한 방식으로 인스턴스를 생성하고 값 또한 같더라도
* 새로운 인스턴스를 생성하는 방식은 서로 다른 주소를 가지기 때문에
* false를 반환한다. */
System.out.println(" str3 == str4 " + ( str3 == str4 ));
// str1 == str2 true
// str2 == str3 false
// str3 == str4 false
/* 하지만 4개의 문자열은 모두 동일한 hashCode 값을 가진다.
* 동일한 문자열은 동일한 hashCode값을 반환하도록 재정의 되어있기 때문이다. */
System.out.println("str1의 hashCode : " + str1.hashCode());
System.out.println("str2의 hashCode : " + str1.hashCode());
System.out.println("str3의 hashCode : " + str1.hashCode());
System.out.println("str4의 hashCode : " + str1.hashCode());
// str1의 hashCode : 3254818
// str2의 hashCode : 3254818
// str3의 hashCode : 3254818
// str4의 hashCode : 3254818
/* 실제 인스턴스는 다르지만 같은 값을 가지면 동일하다고 간주하도록
* 재정의가 되어있다. 같은 문자열일 경우 동일한 객체를 참조한다. */
/* 문자열은 불변이라는 특징을 가진다.
* 기존 문자열에 + 연산자를 수행하는 경우 문자열을 수정하는 것이 아닌
* 새로운 문자열을 할당하게 된다.
* 한번 할당된 문자열은 더이상의 변경이나 수정이 불가능하며
* 새로 힙 영역에 만들어 참조하는 수 밖에 없다.
* */
str2 += "oracle";
/* str 과 str2는 동일한 인스턴스였지만 수정 후에는 다른 인스턴스가
* 된 것을 알 수 있다. */
System.out.println("str == str2 : " + (str1 == str2));
// str == str2 : false
/* equals() : String 클래스의 equals메소드는 인스턴스 비교(주소값)가 아닌
* 문자열값을 비교하여 동일한 값을 가지는 경우 true, 다른 값을 가지는 경우
* false를 반환하도록 Object의 equals() 메소드를 재정의 해 두었다.
* 주소값 비교가 아닌 문자열 비교를 위해선 equals()를 써야한다.
* 인스턴스 생성방식과는 상관없이 문자열만을 비교한다.
* */
System.out.println("str1.equals(str3) : " + str1.equals(str3));
System.out.println("str1.equals(str4) : " + str1.equals(str4));
// str1.equals(str3) : true
// str1.equals(str4) : true
/* 참고로 Scanner 의nextLine() 등을 이용해 문자열을 읽어온 경우
* substring으로 잘라내기 해서 새로운 문자열을 생성 후 반환하기 때문에
* new String() 으로 인스턴스를 생성한 것과 동일한 것으로 볼 수 있다.
* 따라서 Scanner로 입력받은 문자열을 비교할 때에는 equals()를 써야한다.
* 구분하기 힘들면 그냥 문자열은 다 equals()로 비교하는 것이 가장 좋은 방법이다.
* */
}
}
String
String 메소드
- 문자열을 특정 구분자로 분리하는 방법
- 제공하는 메소드
| spilit() | 정규표현식을 이용하여 문자열을 분리하며 속도가 느림 |
| String str1 = "변수/연산자/메소드/제어문"; String[] strArr = str1.split("/"); |
|
| StringTokenizer | 문자열의 모든 문자들을 분리하며 split보다 속도가 빠름 구분자를 생략하는 경우 기본 구분자는 공백 |
| String str2 = "배열/객체/상속/다형성"; StringTokenizer st = new StringTokenizer(str2, "/"); while(st.hasMoreTokens()) { System.out.println(st.nextToken()); } |
class Application3
import java.util.StringTokenizer;
public class Application3 {
public static void main(String[] args) {
/* split()과 StringTokenizer */
/* 각 문자열의 의미는 사번/이름/주소/부서 를 의미한다. */
String emp1 = "100/홍길동/서울/영업부"; // 모든 값 존재
String emp2 = "200/유관순//총무부"; // 주소 없음
String emp3 = "300/이순신/경기도/"; // 부서 없음
/* 먼저 split을 이용해서 3명의 문자열을 정보별로 분리한다. */
String[] empArr1 = emp1.split("/");
String[] empArr2 = emp2.split("/");
String[] empArr3 = emp3.split("/");
for (int i = 0; i < empArr1.length; i++) {
System.out.println("empArr1 [" + i + "] : " + empArr1[i]);
} //정상출력
for (int i = 0; i < empArr2.length; i++) {
System.out.println("empArr2 [" + i + "] : " + empArr2[i]);
} // 중간 값 빈 문자열
for (int i = 0; i < empArr3.length; i++) {
System.out.println("empArr3 [" + i + "] : " + empArr3[i]);
} // 마지막 값 출력 안됨
// empArr1 [0] : 100
// empArr1 [1] : 홍길동
// empArr1 [2] : 서울
// empArr1 [3] : 영업부
// empArr2 [0] : 200
// empArr2 [1] : 유관순
// empArr2 [2] : // 슬래쉬가 두번 들어가서 비워둔 부분
// empArr2 [3] : 총무부
// empArr3 [0] : 300
// empArr3 [1] : 이순신
// empArr3 [2] : 경기도
/* 한계점 : 값을 비워두자 인덱스가 하나 적게 출력 */
/* 마지막 구분자 사이에 값이 존재하지 않는 경우 이후 값도 추출하고 싶을때
* 몇 개의 토큰으로 분리 할 것인지 한계치를 두번째 인자로 넣어줄 수 있다.
* 이때 음수를 넣게 되면 마지막 구분자 뒤의 값이 존재하지 않는 경우
* 빈 문자열로 토큰을 생성한다.
* */
String[] empArr4 = emp3.split("/", -1);
// 뒤의 리밋 숫자대로 '줄 수'로 출력 돼 나온다.
for (int i = 0; i < empArr4.length; i++) {
System.out.println("empArr4 [" + i + "] : " + empArr4[i]);
}
/* 반면 StringTokenizer의 경우 공백으로 존재하는 값을 무시해버린다. */
StringTokenizer st1 = new StringTokenizer(emp1, "/");
StringTokenizer st2 = new StringTokenizer(emp2, "/");
StringTokenizer st3 = new StringTokenizer(emp3, "/");
// java.util 에 있으며 임포트 해준다.
while (st1.hasMoreTokens()) {
System.out.println("st1 : " + st1.nextToken());
}
while (st2.hasMoreTokens()) {
System.out.println("st2 : " + st2.nextToken());
}
while (st3.hasMoreTokens()) {
System.out.println("st3 : " + st3.nextToken());
}
/* nextToken()으로 토큰을 꺼내면 해당 StringTokenizer의
* 토큰을 재사용하는 것이 불가능하다. */
while (st1.hasMoreTokens()) {
System.out.println("st1 : " + st1.nextToken());
}
/* nextToken으로 인해 토큰은 다음 커서로 이동하고
이전 토큰은 출력된다.
*/
/* 공백에 대해서는, 중복된 반복문은 무시된 결과를 확인할 수 있다. */
// st1 : 100
// st1 : 홍길동
// st1 : 서울
// st1 : 영업부
// st2 : 200
// st2 : 유관순
// st2 : 총무부
// st3 : 300
// st3 : 이순신
// st3 : 경기도
/* split()과 StringTokenizer의 차이점 */
/* split은 정규표현식 이용(문자열 패턴),
* StringTokenizer는 구분자 문자열 이용 */
String colorStr = "red*orange#blue/yellow green";
/* "*#/ " 이라는 문자열이 구분자로 존재하지 않아서 에러 발생함 */
// String[] colors = colorStr.split("*#/ ");
/* 대괄호로 묶은 문자열은 문자열이 아닌 각 문자들의 패턴으로 볼 수 있다.
* 따라서 순서 상관없이 존재하는 문자들을 이용해서 구분자로 사용할 수 있다.
* */
String[] colors = colorStr.split("[*#/ ]");
for (int i = 0; i < colors.length; i++) {
System.out.println("colors[" + i + "] : " + colors[i]);
}
// colors[0] : red
// colors[1] : orange
// colors[2] : blue
// colors[3] : yellow
// colors[4] : green
/* StringTokenizer의 두번째 인자 문자열 자체는 연속 된 문자열이
* 아닌 하나하나를 구분자로 이용하겠다는 의미이다. */
StringTokenizer colorStringTokenizer = new StringTokenizer(colorStr, "*#/ ");
while (colorStringTokenizer.hasMoreTokens()) {
System.out.println(colorStringTokenizer.nextToken());
}
// red
// orange
// blue
// yellow
// green
}
}
이스케이프(escape) 문자
- 문자열 내에서 사용하는 문자 중 특수문자를 표현하거나 특수기능을 사용할 때 사용하는 문자
| 특수문자 | 문자 리터럴 | 비고 |
| tab | \t | 정해진 공간만큼 띄어쓰기 |
| new line | \n | 출력하고 다음 라인으로 옮김 |
| 역슬래시 | \\ | 특수문자 사용지 백슬래시넣고 특수문자를 넣어야함 |
| 작은 따옴표 | \' | |
| 큰 따옴표 | \" | |
| 유니코드 | \u | 유니코드 표시할 때 사용 |
Application4
public class Application4 {
public static void main(String[] args) {
/* 개행문자 */
System.out.println("안녕하세요. \n저는 홍길동입니다.");
// 안녕하세요.
// 저는 홍길동입니다.
/* 탭문자 */
System.out.println("안녕하세요. \t저는 홍길동입니다.");
// 안녕하세요. 저는 홍길동입니다.
/* 홑따옴표 문자 */
System.out.println("안녕하세요. 저는 '홍길동'입니다."); // 이스케이스 쓰지않아도 됨
// System.out.println('''); // 홑따옴표 문자와 문자리터럴 기호가 중복됨
System.out.println('\''); // 이스케이프 문자를 사용해서 구분해 주어야함
// 안녕하세요. 저는 '홍길동'입니다.
// '
/* 쌍따옴표 문자 */
//System.out.println("안녕하세요. 저는 "홍길동"입니다.");
// 문자열 리터럴과 기호가 중복 됨
System.out.println("안녕하세요. 저는 \"홍길동\"입니다.");
// 안녕하세요. 저는 "홍길동"입니다.
/* 역슬래쉬 문자 사용 */
System.out.println("안녕하세요. 저는 \\홍길동\\입니다.");
// 역슬래쉬를 하나만 작성할 시 이스케이프 문자의 예약문자와 겹친다.
// 안녕하세요. 저는 \홍길동\입니다.
/* 이러한 특수문자나 특수한 기능을 표현하는 문자를 이스케이프 문자라고 한다. */
/* split시 이스케이프 문자를 사용해야하는 특수한 문자도 존재한다. */
/* 이스케이프 문자 사용 안하는 특수문자
* ~ ` ! @ # & % - _ = ; : ' \ " , < > /
*
* 이스케이프 문자 사용 하는 특수문자
* $ ^ * ( ) + | { } [ ] . ?
*
* */
String str = "java$oracle$jdbc";
String[] sarr = str.split("\\$");
for (String s : sarr) {
System.out.println(s);
}
//split("$") 사용시 다음과같이 출력된다. java/oracle/jdbc
// split("\\$") 사용시 정상적으로 잘 구분되어 출력된다.
// java
// oracle
// jdbc
}
}
StringBuilder와 StringBuffer
StringBuilder와 StringBuffer란?
- String과 유사하지만 String이 불변이라면 StringBuilder나 StringBuffer는 가변이라는 차이점이 있다
- StringBuilder와 StringBuffer는 기능적으론 거의 유사하다.
- StringBuilder : 스레드 동기화 기능을 제공하지 않음
- StringBuffer : 스레드 동기화 기능 제공
(스레드 동기화 유무의 차이 말고는 두 클래스가 의미하는 바가 동일함)
- 제공하는 메소드
| capacity() | 용량(현재 버퍼의 크기)을 int 값으로 반환 (문자열 길이 + 16이 기본 용량) |
| append() | 인자로 전달 된 값을 문자열로 변환 후 기존 문자열의 마지막에 추가 |
| delete() | 시작 인덱스와 종료 인덱스를 이용해서 문자열에서 원하는 부분의 문자열 제거 |
| insert() | 인자로 전달된 값을 문자열로 변환 후 지정한 인덱스 위치에 추가 |
| reverse() | 문자열 인덱스 순번을 역순으로 재배열 |
Application1
public class Application1 {
public static void main(String[] args) {
/* String과 StringBuilder */
/* String :
* 불변이라는 특성을 가지고 있다.
* 문자열에 + 연산으로 합치기 하는 경우, 기존 인스턴스를 수정하는 것이 아닌
* 새로운 인스턴스를 반환한다.
* 따라서 문자열 변경이 자주 일어나는 경우 성능 면에서 좋지않다.
* (매번 새로운 인스턴스를 만들어야 하기 때문)
* 하지만 변하지 않는 문자열을 자주 읽어들이는 경우에는 좋은 성능을 기대할 수 있다.
*
* StringBuilder :
* 가변이라는 특성을 가지고 있다.
* 문자열에 append() 메소드를 이용하여 합치기 하는 경우
* 기존 인스턴스를 수정하기 때문에 새로운 인스턴스를 생성하지 않는다.
* 따라서 잦은 문자열 변경이 일어나는 경우 String보다 성능이 높다.
* (새로 만드는게 아닌 기존것을 수정하기 때문)
*
* 단, JKD 1.5 버전부터 문자열의 + 연산이 StringBuilder의 append()로 컴파일 된다.
* 따라서 성능에 큰 차이를 보이지는 않는다.
* 하지만 반복문 에서 문자열의 + 연산을 수행하는 경우
* StringBuilder 인스턴스를 반복루프시 루프 마다 생성하기 때문에
* 역시 성능에는 좋지않은 영향을 준다.
*
*
* */
/* 원본 코드 */
// String str1 = "java";
// String str2 = "oracle";
//
// String str3 = str1 + str2;
// String str4 = "";
//
// for (int i = 0; i < 10; i++) {
// str4 += str1;
// }
/* JKD 1.4이하
* - 새로운 인스턴스를 매번 생성해서 할당 */
/* JKD 1.5이상 */
// String str1 = "java";
// String str2 = "oracle";
//
// String str3 = new StringBuilder(str1).append(str2).toString();
// String str4 = "";
//
//
// for (int i = 0; i < 10; i++) {
// str4 += new StringBuilder(str4).append(str1).toString();
// }
//
/* StringBuilder 인스턴스 생성 */
StringBuilder sb = new StringBuilder("java");
/* toString이 오버라이딩 되어 있다. */
System.out.println("sb : " + sb/*.toString()*/ );
System.out.println("sb의 hashCode : " + sb.hashCode() );
/* hashCode는 오버라이딩 되어 있지 않다.
* 즉, 동일한 값을 가지는 경우 같은 해쉬코드를 반환하는 것이 아닌,
* 인스턴스가 동일해야 같은 해쉬코드를 반환한다.
* */
// sb : java
// sb의 hashCode : 1101288798
/* 문자열 수정 */
sb.append("oracle");
System.out.println("sb : " + sb);
System.out.println("sb의 hashCode : " + sb.hashCode() );
/* hashCode를 다시 출력하면 기존 인스턴스와 동일한 것을 확인할 수 있다.
* 즉, 문자열을 변경했다고 해서 새로운 인스턴스가 생성된 것은 아니다. */
// sb : javaoracle
// sb의 hashCode : 1101288798
// 주소값이 똑같다는 의미? : 문자열을 추가했지만 새로운인스턴스가 생기지 않았다는 것
}
}
Application2
public class Application2 {
public static void main(String[] args) {
/* StringBuilder의 자주 사용되는 메소드 */
/* StringBuilder 기본 생성자로 인스턴스 생성 */
StringBuilder sb1 = new StringBuilder();
/* capacity() : 용량 (현재 버퍼의 크기)을 정수형으로
* 반환하는 메소드 (문자열 길이 + 16이 기본 용량) */
System.out.println(sb1.capacity());
// 예) 인자값으로 java 전달시 20 출력
/* append() : 인자로 전달 된 값을 문자열로 변환 후
* 기존 문자열의 마지막에 추가한다.
* 기본 용량을 초과하는 경우 :
* (기존 문자열 +1 ) * 2를 하여 용량을 확장 시킨다.
* */
for (int i = 0; i < 50; i++) {
sb1.append(i);
System.out.println("sb1 : " + sb1);
System.out.println("capacity : " + sb1.capacity());
System.out.println("hashCode : " + sb1.hashCode());
// 출력시 동일 인스턴스임을 알 수 있다.
// 스트링빌더는 처음부터 끝까지
// '동일한 인스턴스 안에서' 변화하고 있음을 관찰할 수 있다.
}
/* 새로운 StringBuilder 인스턴스 생성 */
StringBuilder sb2 = new StringBuilder("javaoracle");
/* delete() : 시작인덱스와 종료인덱스를 이용해서 문자열에서 원하는
* 부분의 문자'열'을 제거한다.
* deleteCharAt : 문자열 인덱스를 이용해서 문자 딱 하나를(at) 제거한다.
* 둘 다 원본에 영향을 미친다.
*
* */
System.out.println("delete() : " + sb2.delete(2, 5));
System.out.println("delete() : " + sb2.deleteCharAt(0));
System.out.println("sb2 : " + sb2);
// delete() : jaracle
// delete() : aracle
/* insert() : 인자로 전달 된 값을 문자열로 변환 후 지정한
* 인덱스 위치에 추가한다.
* 원본에 영향을 미친다.
* */
System.out.println("insert() : " + sb2.insert(1, "vao"));
// 인덱스 1자리에 넣겠다는 의미
// insert() : avaoracle
System.out.println("insert() : " + sb2.insert(0, "j"));
// insert() : javaoracle
System.out.println("insert() : " + sb2.insert(sb2.length(), "jdbc"));
// insert() : javaoraclejdbc
System.out.println("sb2 : " + sb2);
// sb2 : javaoraclejdbc
/* reverse() : 문자열 인덱스 순번을 역순으로 재배열한다.
* 원본에 영향을 미친다.
* */
System.out.println("reverse() : " + sb2.reverse());
System.out.println("sb2 : " + sb2);
// reverse() : cbdjelcaroavaj
// sb2 : cbdjelcaroavaj
/* String 클래스와 동일한 메소드도 있다.
* charAt(), indexOf(), lastIndexOf(), length(), replace(),
* substring(),
* */
}
}
Wrapper
Primitive Data Type을 인스턴스화 해주는 클래스
| Primitive Data Type | Wrapper Class |
| boolean | Boolean |
| byte | Byte |
| char | Character |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
Wrapper : String을 기본자료형으로 바꿀 시
byte b = Byte.parseByte("1");
short s = Short.parseShort("2");
int i = Integer.parseInt("3");
long l = Long.parseLong("4");
float f = Float.parseFloat("0.1");
double d = Double.parseDouble("0.2");
boolean bool = Boolean.parseBoolean("true");
char c = "abc".charAt(0);
Wrapper : 기본자료형을 String으로 바꿀 시
String b = Byte.valueOf((byte)1).toString();
String s = Short.valueOf((short)2).toString();
String i = Integer.valueOf(3).toString();
String l = Long.valueOf(4L).toString();
String f = Float.valueOf(0.1f).toString();
String d = Double.valueOf(0.2).toString();
String bool = Boolean.valueOf(true).toString();
String ch = Character.valueOf('a').toString();