API -> 응용프로그램에서 사용할 수 있도록 운영체제나 프로그래밍 언어가 제공하는 기능을 제어할 수 있게 만든 인터페이스
Object -> java.lang 패키지에 존재
toString() : 인스턴스 생성시 사용한 full class name과 @그리고 16진수 해쉬코드가 문자열로 반환
equals() 매개변수로 전달 받은 인스턴스와 == 연산하여 true 또는 false를 반환
동일 인스턴스인지를 비교
(동일객체 : 주소가 동일한 인스턴스)
String 클래스
alt shift S override toString
.toString은 주소값이 나오는데
주소값보다는 안에 값을 보는 메소드로 더 자주사용하기 때문에 재정의해서 사용
getinformation이 아니라 굳이 toString을 오버라이딩 해서 사용하는 이유
.toString()을 명시적으로 붙이지 않아도 주소값이 반환하여 나오기 때문
주소값보다는 해당 필드의 무슨값이 들어있는지가
더 자주 사용하기 때문에 오버라이딩해서 사용
레퍼런스 변수만 사용해도 toString()을 자동으로 호출하기 때문에 간편하다
toString()은 Object가 가지고 있는 메소드
클래스에 extends가 없으면 무조건 object 클래스를 상속하겠다는 의미
equals 오버라이딩 ㄱ
부모타입이 자식클래스 타입을 다 받아주겠다
=upcasting 다형성 적용해서 매개변수를 받겠다.
주석달아서 쓰기! 목적이 뭔징..
package com.greedy.section01.object.model.dto;
public class BookDTO {
private int number;
private String title;
private String author;
private int price;
public BookDTO() {
super();
}
public BookDTO(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;
}
@Override
public String toString() {
return "BookDTO [number="
+ number + ", title="
+ title + ", author="
+ author + ", price="
+ price + "]";
}
@Override
public boolean equals(Object obj) {
/* 두 인스턴스가 주소가 같으면 이후 다른 내용을 비교할 것 없이 true를 반환한다. */
if(this == obj) {
return true;
}
/* this는 인스턴스가 생성되면 주소값이 저장된다. null일 수 없다.
* 따라서 전달받은 레퍼런스 변수에 null값이 저장되어 있다면 비교하려는 두개의
* 인스턴스는 서로 다른 인스턴스이다.
* */
if(obj == null) {
return false;
}
/* 전달받은 레퍼런스 변수를 BookDTO 타입으로 형변환하여 각 필드별로 비교를 시작*/
BookDTO other = (BookDTO) obj; //다운캐스팅(down-casting) 대입연산자는 타입이서로 같아야하므로
/* number필드의 값이 서로 같지 않은 경우 서로 다른 인스턴스이다.*/
if(this.number != other.number) {
return false;
}
if(this.title == null) {
/* title필드가 null인 경우 다른 인스턴스의 title이 null이 아니면 false반환*/
if(other.title != null) {
return false;
}
} else if(!this.title.equals(other.title)) {
/* String 클래스의 equals()는 이미 해당 기능을 오버라이딩 해 두었기 때문에
* 같은 값을 가지는지 비교를 한다.
* */
return false;
}
if(this.author == null) {
if(other.author != null ) {
return false;
}
} else if(!this.author.equals(other.author)) {
return false;
}
/* price 필드가 서로 다른 값을 가지면 false반환*/
if(this.price != other.price) {
return false;
}
/*모든 조건을 통과하면 두 인스턴스의 모든 필드는 같은 값을 가지므로 true반환*/
return true;
}// @Override
// public int hashCode() {
//
// / 곱셈 연산을 누적시켜야 하기 때문에 0이 아닌 값으로 초기화 /
// int result = 1;
//
// / 필드마다 곱해줄 소수값을 선언
// 31은 소수이기 때문에 연산 시 동일한 hashCode값이 나오지 않을 확률을 증가시킨다.
// 31이 통상적인 관례이며 String 클래스의 hashCode에서도 사용한 값이다.
// /
// final int PRIME = 31;
//
// result = PRIME result + this.number;
// result = PRIME result + this.title.hashCode();
// result = PRIME result + this.author.hashCode();
// result = PRIME * result + this.price;
//
//
// return result;
// }
}
package com.greedy.section01.object.run;
import com.greedy.section01.object.model.dto.BookDTO;
public class Application1 {
public static void main(String[] args) {
/* 모든 클래스는 Object 클래스의 후손이다.
*
* 따라서 Object 클래스가 가진 메소드를 자신의 것처럼 사용할수 있다.
* 또한 부모 클래스가 가지는 메소드를 오버라이딩 해서 사용하는 것도 가능하다.
*
* 대표적으로 많이 사용하는 메소드 toString(), equals(), hashCode() 이다.
*
* */
BookDTO book1 = new BookDTO(1, "홍길동전", "허균", 50000);
BookDTO book2 = new BookDTO(2, "목민심서", "정약용", 30000);
BookDTO book3 = new BookDTO(3, "목민심서", "정약용", 30000);
System.out.println("book1.toString() : " + book1.toString());
System.out.println("book2.toString() : " + book2.toString());
System.out.println("book3.toString() : " + book3.toString());
/* 동일한 값을 가지고 있는 인스턴스도 다른 해쉬코드값을 가지고 있고 표현은
* 풀클래스 이름과 @ 그리고 16진수 해쉬코드를 반환한다.
*
* toString()을 호출하지 않고 레퍼런스 변수만 출력하는 경우 동일하게 결과가 나온다.
* 이 경우 자동으로 toString() 메소드를 호출해준다.
* 그래서 이런 편리한 점을 이용하여 toString() 메소드를 재정의해서 사용하게된다.
* */
System.out.println("book1 : " + book1);
System.out.println("book2 : " + book2);
System.out.println("book3 : " + book3);
}}
package com.greedy.section01.object.run;
import com.greedy.section01.object.model.dto.BookDTO;
public class Application2 {
public static void main(String[] args) {
/* equals() 메소드 오버라이딩
*
* equals 메소드는 매개변수로 전달받은 인스턴스와 == 연산하여 true of false를 반환한다.
* 즉, 동일한 인스턴스인지를 비교하는 기능을 한다.
*
* 동일객체와 동등객체
* 동일객체 : 주소가 동일한 인스턴스를 동일객체라고 한다.
* 동등객체 : 주소는 다르더라도 필드값이 동일한 객체를 동등객체라고 한다.
*
* equals() 메소드의 기본 기능은 동일객체 판단을 한다(동일성확인)
* */
BookDTO book1 = new BookDTO(1, "홍길동전", "허균", 50000);
BookDTO book2 = new BookDTO(1, "홍길동전", "허균", 50000);
System.out.println("두 인스턴스의 == 연산 비교 : " + (book1 == book2));
System.out.println("두 인스턴스의 equals() 비교 : " + (book1.equals(book2)));
}}
package com.greedy.section01.object.run;
import java.util.HashMap;
import java.util.Map;
import com.greedy.section01.object.model.dto.BookDTO;
public class Application3 {
public static void main(String[] args) {
/* Object 클래스의 명세에 작성된 일반 규약에 따르면
* equals()메소드를 재정의 하는 경우 반드시 hashCode()메소드도 재정의 하도록 되어 있다.
*
* 만약 hashCode()를 재정의 하지 않으면 같은 값을 가지는 동등 객체는
* 같은 해쉬코드값을 가져야 한다는 규약에 위반되게 된다.
* */
BookDTO book1 = new BookDTO(1, "홍길동전", "허균", 50000);
BookDTO book2 = new BookDTO(1, "홍길s동전", "허균", 50000);
System.out.println("book1의 hashCode : " + book1.hashCode());
System.out.println("book2의 hashCode : " + book2.hashCode());
Map<BookDTO, String> map = new HashMap<>();
map.put(new BookDTO(1,"홍길동전","허균", 50000), "selled");
String str = map.get(new BookDTO(1, "홍길동전", "허균", 50000));
System.out.println(str);
}}
book1의 hashCode : 1865127310
book2의 hashCode : 1586600255
null
String 클래스
String은 불변객체이다. StringBuilder와 StringBuffer는 가변이다.
package com.greedy.section02.string;
public class Application1 {
public static void main(String[] args) {
/* String 클래스의 자주 사용하는 메소드 */
/* charAt() : 해당 문자열의 특정 인덱스에 해당하는 문자를 반환한다.
* index는 0부터 시작하는 숫자 체계를 의미하며,
* index를 벗어난 정수를 인자로 전달하는 경우에는 IndexOutOfBoundsException이 발상한다.
* */
String str1 = "apple";
for(int i = 0; i < str1.length(); i++) {
System.out.println("charAt(" + i + ") : " + str1.charAt(i));
}
/* compareTo() : 인자로 전달된 문자열과 사전 순으로 비교를 하여
* 두 문자열이 같다면 0을 반환, 인자로 전달된 문자열보다 작으면 음수를,
* 크면 양수를 반환한다.
* 단, 이 메소드는 대소문자를 구분하여 비교한다.
* */
String str2 = "java";
String str3 = "java";
String str4 = "JAVA";
String str5 = "oracle";
/* 같으면 0을 반환 */
System.out.println("compareTo() : " + (str2.compareTo(str3)));
/* 대문자와 소문자는 32만큼 차이가 난다. */
System.out.println("compareTo() : "+ (str2.compareTo(str4)));
System.out.println("compareTo() : "+ (str4.compareTo(str2)));
/* jklmno j부터 o까지는 5만큼 차이가 난다.*/
System.out.println("compareTo() : "+ (str2.compareTo(str5)));
System.out.println("compareTo() : "+ (str5.compareTo(str2)));
/* compareToIgnoreCase() : 대소문자를 구분하지 않고 비교한다. */
System.out.println("compareToIgnoreCase() : " + (str3.compareToIgnoreCase(str4)));
/* concat() : 문자열에 인자로 전달된 문자열을 합치기해서 새로운 문자열을 반환한다.
* 원본 문자열에는 영향을 주지 않는다.
* */
System.out.println("concat() : " + (str2.concat(str5)));
System.out.println("str2 : " + str2);
/* indexOf() : 문자열에서 특정 문자를 탐색하여 처음 일치하는 인덱스 위치를 정수형으로 반환한다.
* 단, 일치하는 문자가 없는 경우 -1을 반환한다.
* */
String indexOf = "java oracle";
System.out.println("indexOf('a') : " + indexOf.indexOf('a'));
System.out.println("indexOf('z') : " + indexOf.indexOf('z'));
/* test@test.com test1234@1234.com test.png helloworld.jpg */
/* lastIndexOf() : 문자열 탐색을 뒤에서 부터 하고 처음 일치하는 위치의 인덱스를 반환한다.
* 단, 일치하는 문자가 없는 경우 -1을 반환한다.
* */
System.out.println("lastindexOf('a') : " + indexOf.lastIndexOf('a'));
System.out.println("lastindexOf('z') : " + indexOf.lastIndexOf('z'));
/* trim() : 문자열의 앞 뒤에 공백을 제거한 문자열을 반환한다. */
String trimStr = " java ";
System.out.println("trimStr : #" + trimStr + "#");
System.out.println("trim() : #" + trimStr.trim() + "#");
/* 원본에 영향을 주지는 않는다.*/
System.out.println("trim() : #" + trimStr + "#");
/* toLowerCase() : 모든 문자를 소문자로 변환시킨다.
* toUpperCase() : 모든 문자를 대문자로 변환시킨다.
* 원본에는 영향을 주지 않는다.
* */
String caseStr = "JavaOracle";
System.out.println("toLowerCase() : " + caseStr.toLowerCase());
System.out.println("toUpperCase() : " + caseStr.toUpperCase());
System.out.println(" caseStr : " + caseStr);
/* substring() : 문자열의 일부분을 잘라내어 새로운 문자열을 반환한다.
* 원본에 영향을 주지 않는다.
* */
String javaoracle = "javaoracle";
System.out.println("substring(3, 6) :" + javaoracle.substring(3, 6)); //3부터 6전까지
System.out.println("substring(3) : " + javaoracle.substring(3)); //3부터 끝까지
System.out.println("javaoracle : " + javaoracle);
/* replace() : 문자열에서 대체할 문자열로 기존 문자열을 변경해서 반환한다.
* 원본에 영향을 주지 않는다.
* */
System.out.println("replace() : " + javaoracle.replace("java", "phyton"));
System.out.println("javaoracle : " + javaoracle);
/* length() : 문자열의 길이를 정수형으로 반환 */
System.out.println("length() : " + "javaoracle".length()); // 문자열에 점찍어도 가능
System.out.println("빈 문자열의 길이 : " + ("".length()));
/* isEmpty() : 문자열의 길이가 0이면 true를 반환, 아니면 false를 반환
* 길이가 0인 문자열과 null과는 다르다.
* */
System.out.println("isEmpty() : " + "".isEmpty());
System.out.println("isEmpty() : " + "abc".isEmpty());
}}
charAt(0) : a
charAt(1) : p
charAt(2) : p
charAt(3) : l
charAt(4) : e
compareTo() : 0
compareTo() : 32
compareTo() : -32
compareTo() : -5
compareTo() : 5
compareToIgnoreCase() : 0
concat() : javaoracle
str2 : java
indexOf('a') : 1
indexOf('z') : -1
lastindexOf('a') : 7
lastindexOf('z') : -1
trimStr : # java #
trim() : #java#
trim() : # java #
toLowerCase() : javaoracle
toUpperCase() : JAVAORACLE
caseStr : JavaOracle
substring(3, 6) :aor
substring(3) : aoracle
javaoracle : javaoracle
replace() : phytonoracle
javaoracle : javaoracle
length() : 10
빈 문자열의 길이 : 0
isEmpty() : true
isEmpty() : false
package com.greedy.section02.string;
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");
/* 리터럴 형태로 만든 문자열 인스턴스는 동일한 값을 가지는 인스턴스는 하나의 인스턴스로 관리한다.
* 따라서 주소값을 비교하는 == 연산으로 비교 시 서로 동일한 stack에 저장된 주소를
* 비교하여 결과가 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));
/* 하지만 4개의 문자열 모두 동일한 hashCode값을 가진다.
* 동일한 문자열은 동일한 hashCode값을 반환하도록 이미 재정의가 되어 있기 때문이
* */
System.out.println("str1의 hashCode : " + str1.hashCode());
System.out.println("str2의 hashCode : " + str2.hashCode());
System.out.println("str3의 hashCode : " + str3.hashCode());
System.out.println("str4의 hashCode : " + str4.hashCode());
System.out.println("str1의 hashCode : " + System.identityHashCode(str1.hashCode()));
System.out.println("str2의 hashCode : " + System.identityHashCode(str2.hashCode()));
System.out.println("str3의 hashCode : " + System.identityHashCode(str3.hashCode()));
System.out.println("str4의 hashCode : " + System.identityHashCode(str4.hashCode()));
/* 문자열은 불변이라는 특징을 가진다. */
str2 += "oracle";
System.out.println("str1 == str2 : " + (str1 == str2));
/* 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));
/* new java.util.Scanner(System.in).nextLine();을 이용해 문자열을 입력받은 경우
* substring으로 잘라내기해서 새로운 문자열을 생성 후 반환하기 때문에
* new String()으로 인스턴스를 생성한것과 동일한 것으로 볼 수 있다.
*
* 따라서 Scanner로 입력받은 문자열을 비교할 때에는 equals()를 써야한다.
*
*
* */
}}
str1 == str2 : true
str2 == str3 : false
str3 == str4 : false
str1의 hashCode : 3254818
str2의 hashCode : 3254818
str3의 hashCode : 3254818
str4의 hashCode : 3254818
str1의 hashCode : 1365202186
str2의 hashCode : 1651191114
str3의 hashCode : 1586600255
str4의 hashCode : 474675244
str1 == str2 : false
str1.equals(str3) : true
str1.equals(str4) : true
package com.greedy.section02.string;
import java.util.StringTokenizer;
public class Application3 {
public static void main(String[] args) {
/* split()과 StringTokenizer
*
* 문자열을 특정 구분자로 하여 분리한 문자열을 반환하는 기능을 한다.
*
* split() : 정규표현식을 이용하여 문자열을 분리한다.
* 비정형화된 문자열을 분리할 때 좋지만(공백 문자열 값 포함)
* 정규표현식을 이용하기 때문에 속도가 느리다는 단점을 가진다.
* StringTokenizer : 문자열의 모든 문자들을 구분자로 하여 문자열을 분리한다.
* 정형화된 문자열 패턴을 분리할 때 사용하기 좋다(공백 문자열 무시)
* split()보다 속도면에서 더 빠르다.
* 구분자를 생략하는 경우 공백이 기본 구분자이다.
* */
String emp1 = "100/홍길동/서울/영업부"; //모든값 존재함
String emp2 = "200/유관순//총무부"; // 주소 없음
String emp3 = "300/이순신/경기도/"; // 부서 없음
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]);
}
/* 마지막 구분자 사이에 값이 존재하지 않은 경우 이후 값도 추출하고 싶을 때
* 몇 개의 토큰으로 분리할 것인지 한계치를 두번째 인자로 넣어줄 수 있다.
* 이때 음수를 넣게 되면 마지막 구분자 뒤의 값이 존재하지 않는 경우 빈 문자열로 토큰을 생성한다.
* */
String[] empArr4 = emp3.split("/", -1);
for(int i = 0; i < empArr4.length; i++) {
System.out.println("empArr4[" + i + "] : " + empArr4[i]);
}
/* StringTokenizer */
System.out.println("===========================================");
/* split()과 다르게 공백으로 존재하는 값을 무시해버린다. */
StringTokenizer str1 = new StringTokenizer(emp1, "/");
StringTokenizer str2 = new StringTokenizer(emp2, "/");
StringTokenizer str3 = new StringTokenizer(emp3, "/");
while(str1.hasMoreTokens()) {
System.out.println("str1 : " + str1.nextToken());
}
while(str2.hasMoreTokens()) {
System.out.println("str2 : " + str2.nextToken());
}
while(str3.hasMoreTokens()) {
System.out.println("str3 : " + str3.nextToken());
}
/* nextToken()으로 토큰을 꺼내면 해당 StringTokenuzer의 토큰을 재사용하는 것이 불가능하다.*/
while(str3.hasMoreTokens()) {
System.out.println("str3 : " + str3.nextToken());
}
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]);
}
/* StringTokenizer의 두 번째 인자 문자열 자체는 연속된 문자열이 아닌
* 하나하나를 구분자로 이용하겠다는 의미이다.
* */
StringTokenizer colorStringTokenizer = new StringTokenizer(colorStr, "*/ ");
while(colorStringTokenizer.hasMoreTokens()) {
System.out.println(colorStringTokenizer.nextToken());
}
}}
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] : 경기도
empArr4[0] : 300
empArr4[1] : 이순신
empArr4[2] : 경기도
empArr4[3] :
str1 : 100
str1 : 홍길동
str1 : 서울
str1 : 영업부
str2 : 200
str2 : 유관순
str2 : 총무부
str3 : 300
str3 : 이순신
str3 : 경기도
colors[0] : red
colors[1] : orange
colors[2] : blue
colors[3] : yellow
colors[4] : green
red
orange#blue
yellow
green
String 문자열은 불변
java
java + oracle
java + oracle + phython
StringBuilder : 스레드 동기화 기능을 제공하지 않음
StringBuffer : 스레드 동기화 기능 제공
(스레드 동기화 유무의 차이 말고는 두 클래스가 의미하는 바가 동일함)
-제공하는 메소드
capacity():용량(현재 버퍼의 크기)을 int값으로 반환(문자열 길이 +16이 기본 용량)
append() : 인자로 전달 된 값을 문자열로 변환 후 기존 문자열의 마지막에 추가
delete() : 시작 인덱스와 종료 인덱스를 이용해서 문자열에서 원하는 부분의 문자열 제거
package com.greedy.section02.string;
public class Application4 {
public static void main(String[] args) {
/* 이스케이프(escape) 문자
* 문자열 내에서 사용하는 문자 중 특수문자를 표현하거나 특수기능을 사용할 때 사용하는 문자이다.
*
* 이스케이프 문자 의미
* \n 개행(줄바꿈)
* \t 탭
* \' 작은따옴표
* \" 큰따옴표
* \\ 역슬래쉬 표시
* */
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("안녕하세요. 저는 \홍길동\ 입니다.");
System.out.println("안녕하세요. 저는 \홍길동\ 입니다.");
System.out.print("안녕하세요");
System.out.print("반갑습니다");
System.out.println();
System.out.println("안녕하세요");
System.out.println("반갑습니다.");
/* 문자열 일때는 %s
* 정수 일때는 %d
* 실수 일때는 %f
* */
// 입력하신 이름은 홍길동이고, 나이는 20살이고 몸무게는 65.8 입니다.
// "입력하신 이름은" + name +"이고, 나이는 " + age + "살이고 몸무게는 " + weight + "입니다.";
// "입력하신 이름은 %s이고, 나이는 %d살이고 몸무게는 %.2f 입니다"
System.out.printf("%s %s %d살이고, 몸무게는 %.1f", "안녕하세요", "반갑습니다.", 20, 65.12);
}}
안녕하세요.
저는 홍길동입니다.
안녕하세요. 저는 홍길동입니다.
안녕하세요. 저는'홍길동'입니다.
'
안녕하세요 저는 " 홍길동 " 입니다.
안녕하세요. 저는 \홍길동\ 입니다.
안녕하세요반갑습니다
안녕하세요
반갑습니다.
안녕하세요 반갑습니다. 20살이고, 몸무게는 65.1
package com.greedy.section03.stringbuilder;
public class Application1 {
public static void main(String[] args) {
/* StringBuilder와 StringBuffer
* 두 클래스는 스레드 동기화 기능 제공 여부에 따라 차이점이 있다.
* StringBuilder : 스레드 동기화 기능 제공하지 않는다.
* 스레드 동기화처리를 고려하지 않은 상황에서 StringBuffer보다 성능이 좋다.
* StringBuffer : 스레드 동기화 기능 제공함
* 성능면에서는 StringBuilder보다 느리다.
*
* 두 개의 차이는 스레드 동기화 유무이고, 현재 우리는 스레드를 고려하지 않기 때문에
* StringBuilder를 이용할 것이다.
* */
/*
* String과 StringBuilder
* String : 불변이라는 특성을 가지고 있다.
* 문자열에 + 연산으로 합치기 하는 경우, 기존 인스턴스를 수정하는 것이 아닌
* 새로운 인스턴스를 반환한다.
* 따라서 문자열 변경이 자주 일어나는 경우 성능 면에서 좋지않다.
* 하지만 변하지 않는 문자열을 자주 읽어 들이는 경우에는 오히려 좋은 성능을 기대할 수 있다.
* StringBuilder : 가변이라는 특성을 가지고 있다.
* 문자열에 append() 메소드를 이용하여 합치기 하는 경우
* 기존 인스턴스를 수정하기 때문에 새로운 인스턴스를 생성하지 않는다.
* 따라서 잦은 문자열 변경이 일어나는 경우 String보다 성능이 좋다.
*
* 단,jdk 1.5버전에서는 문자열의 + 연산이 StringBuilder의 append()로 컴파일이 된다.
* 따라서 성능에 큰 차이를 보이지는 않는다.
*
* 하지만 반복문에서 문자열의 +연산을 수행하는 경우 StringBuilder인스턴스를 반복 루프 시마다
* 생성하기 때문에 성능에 좋지 않은 영향을 준다.
* */
StringBuilder sb = new StringBuilder("java");
/* toString이 오버라이딩 되어있어서 주소값이 아니라 입력값이 출력된다.*/
System.out.println("sb : " + sb);
/* hashCode는 오버라이딩 되어 있지 않다.
* 즉, 동일한 값을 가지는 경우 같은 해쉬코드를 반환하는 것이 아니라,
* 인스턴스가 동일해야 같은 해쉬코드를 반환한다.
* */
System.out.println("sb의 hashCode : " + sb.hashCode());
/* 문자열 수정 */
sb.append("oracle");
System.out.println("sb : " + sb);
System.out.println("sb의 hashCode : " + sb.hashCode());
}}
package com.greedy.section03.stringbuilder;
public class Applicaiton2 {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
/* capacity() : 용량(현재 버퍼의 크기)을 정수형으로 반환하는 메소드 (문자열 길이 + 16이 기본용량)*/
System.out.println(sb.capacity());
/* append() : 인자로 전달된 값을 문자열로 변환 후 기존 문자열의 마지막에 추가한다.
*
* 기본 용량을 초과하는 경우 (기존문자열 + 1) * 2를 하여 용량을 확장시킨다.
* */
for(int i = 0; i < 50; i++) {
sb.append(i);
System.out.println("sb : " + sb);
System.out.println("capacity : " + sb.capacity()); //16, 34, 70-> 2n +2씩 증가
System.out.println("hashCode : " + sb.hashCode());
}
StringBuilder sb2 = new StringBuilder("javaoracle");
/*delete() : 시작 인덱스와 종료 인덱스를 이용해서 문자열에서 원하는 부분의 문자열 제거한다.
* deleteCharAt() : 문자열 인덱스를 이용해서 문자 하나를 제거한다.
* 원본에 영향을 끼친다.
* */
System.out.println("delete(): " + sb2.delete(2, 5));
System.out.println("deleteCharAt() : " + sb2.deleteCharAt(0));
System.out.println("sb2 : " + sb2);
/* insert() : 인자로 전달된 값을 문자열로 변환 후 지정한 인덱스 위치에 추가한다.
* 원본에 영향을 끼친다.
* */
System.out.println("insert() : " + sb2.insert(1, "vao"));
System.out.println("insert() : " + sb2.insert(0, "j"));
System.out.println("insert() : " + sb2.insert(sb2.length(), "jbdc"));
System.out.println("sb2 : " + sb2);
/* reverse() : 문자열 인덱스 순번을 역순으로 재배열한다.
* 원본에 영향을 끼친다.
* */
System.out.println("reverse() : " + sb2.reverse());
System.out.println("sb2 : " + sb2);
}}
16
sb : 0
capacity : 16
hashCode : 1365202186
sb : 01
capacity : 16
hashCode : 1365202186
sb : 012
capacity : 16
hashCode : 1365202186
sb : 0123
capacity : 16
hashCode : 1365202186
sb : 01234
capacity : 16
hashCode : 1365202186
sb : 012345
capacity : 16
hashCode : 1365202186
sb : 0123456
capacity : 16
hashCode : 1365202186
sb : 01234567
capacity : 16
hashCode : 1365202186
sb : 012345678
capacity : 16
hashCode : 1365202186
sb : 0123456789
capacity : 16
hashCode : 1365202186
sb : 012345678910
capacity : 16
hashCode : 1365202186
sb : 01234567891011
capacity : 16
hashCode : 1365202186
sb : 0123456789101112
capacity : 16
hashCode : 1365202186
sb : 012345678910111213
capacity : 34
hashCode : 1365202186
sb : 01234567891011121314
capacity : 34
hashCode : 1365202186
sb : 0123456789101112131415
capacity : 34
hashCode : 1365202186
sb : 012345678910111213141516
capacity : 34
hashCode : 1365202186
sb : 01234567891011121314151617
capacity : 34
hashCode : 1365202186
sb : 0123456789101112131415161718
capacity : 34
hashCode : 1365202186
sb : 012345678910111213141516171819
capacity : 34
hashCode : 1365202186
sb : 01234567891011121314151617181920
capacity : 34
hashCode : 1365202186
sb : 0123456789101112131415161718192021
capacity : 34
hashCode : 1365202186
sb : 012345678910111213141516171819202122
capacity : 70
hashCode : 1365202186
sb : 01234567891011121314151617181920212223
capacity : 70
hashCode : 1365202186
sb : 0123456789101112131415161718192021222324
capacity : 70
hashCode : 1365202186
sb : 012345678910111213141516171819202122232425
capacity : 70
hashCode : 1365202186
sb : 01234567891011121314151617181920212223242526
capacity : 70
hashCode : 1365202186
sb : 0123456789101112131415161718192021222324252627
capacity : 70
hashCode : 1365202186
sb : 012345678910111213141516171819202122232425262728
capacity : 70
hashCode : 1365202186
sb : 01234567891011121314151617181920212223242526272829
capacity : 70
hashCode : 1365202186
sb : 0123456789101112131415161718192021222324252627282930
capacity : 70
hashCode : 1365202186
sb : 012345678910111213141516171819202122232425262728293031
capacity : 70
hashCode : 1365202186
sb : 01234567891011121314151617181920212223242526272829303132
capacity : 70
hashCode : 1365202186
sb : 0123456789101112131415161718192021222324252627282930313233
capacity : 70
hashCode : 1365202186
sb : 012345678910111213141516171819202122232425262728293031323334
capacity : 70
hashCode : 1365202186
sb : 01234567891011121314151617181920212223242526272829303132333435
capacity : 70
hashCode : 1365202186
sb : 0123456789101112131415161718192021222324252627282930313233343536
capacity : 70
hashCode : 1365202186
sb : 012345678910111213141516171819202122232425262728293031323334353637
capacity : 70
hashCode : 1365202186
sb : 01234567891011121314151617181920212223242526272829303132333435363738
capacity : 70
hashCode : 1365202186
sb : 0123456789101112131415161718192021222324252627282930313233343536373839
capacity : 70
hashCode : 1365202186
sb : 012345678910111213141516171819202122232425262728293031323334353637383940
capacity : 142
hashCode : 1365202186
sb : 01234567891011121314151617181920212223242526272829303132333435363738394041
capacity : 142
hashCode : 1365202186
sb : 0123456789101112131415161718192021222324252627282930313233343536373839404142
capacity : 142
hashCode : 1365202186
sb : 012345678910111213141516171819202122232425262728293031323334353637383940414243
capacity : 142
hashCode : 1365202186
sb : 01234567891011121314151617181920212223242526272829303132333435363738394041424344
capacity : 142
hashCode : 1365202186
sb : 0123456789101112131415161718192021222324252627282930313233343536373839404142434445
capacity : 142
hashCode : 1365202186
sb : 012345678910111213141516171819202122232425262728293031323334353637383940414243444546
capacity : 142
hashCode : 1365202186
sb : 01234567891011121314151617181920212223242526272829303132333435363738394041424344454647
capacity : 142
hashCode : 1365202186
sb : 0123456789101112131415161718192021222324252627282930313233343536373839404142434445464748
capacity : 142
hashCode : 1365202186
sb : 012345678910111213141516171819202122232425262728293031323334353637383940414243444546474849
capacity : 142
hashCode : 1365202186
delete(): jaracle
deleteCharAt() : aracle
sb2 : aracle
insert() : avaoracle
insert() : javaoracle
insert() : javaoraclejbdc
sb2 : javaoraclejbdc
reverse() : cdbjelcaroavaj
sb2 : cdbjelcaroavaj
