StringTest 클래스에 파일을 생성
기본적으로 비교될 배열과 문자 배열을 미리 초기화 시켜놓는다.
기본적으로 사용할 String str와 char[] 배열 선언
public class StringTest {
private String str = "abcdef";
private char[] charAry = new char[5];
@Before
public void setUp() {
charAry[0] = 'A';
charAry[1] = 'B';
charAry[2] = 'C';
charAry[3] = 'D';
charAry[4] = 'E';
}
} |
예외 확인 테스트
예외가 발생된것은 아래와 같이 테스트 할 수 있다
(annotation 옆에 괄호열고 expect = 예외명.class)
@Test(expected = StringIndexOutOfBoundsException.class)
public void charAtShouldThrowStringOutOfBoundException() {
str = "";
assertEquals('a', str.charAt(2));
} |
charAt메소드
@Test
public void charAt() {
str = "abcdef";
assertEquals('a', str.charAt(0));
assertEquals('b', str.charAt(1));
assertEquals('c', str.charAt(2));
} |
codePointAt메소드
@Test
public void codePointAt() {
str = "abcdef";
assertEquals('c', str.codePointAt(2));
assertEquals(str.charAt(2), str.codePointAt(2));
assertEquals(99, str.codePointAt(2));
} |
codePointBefore메소드
@Test
public void codePointBefore() {
str = "abcdef";
assertEquals(102, str.codePointBefore(6)); // 인덱스 바로 앞의 유니코드 값을 가져옴
// 문자가 아니라 숫자로 검사해야되는 이유는?
} |
codePointCount메소드
@Test
public void codePointCount() {
str = "aceg";
assertEquals(1, str.codePointCount(0, 1)); // 양 값의 인덱스의 위치 차이가 얼마인지
// 정수값으로 알려줌
assertEquals(2, str.codePointCount(1, 3));
} |
compareTo메소드
@Test
public void compareTo() {
str = "abcdef";
assertEquals(3, str.compareTo("abc")); // ??...
assertEquals(4, str.compareTo("ab"));
assertEquals(0, str.compareTo("abcdef"));
assertEquals(-1, str.compareTo("abcdefg"));
assertEquals(-2, str.compareTo("abcdefgh"));
assertEquals(6, str.compareTo(""));
} |
compareToIgnoreCase메소드
@Test
public void compareToIgnoreCase() {
str = "abcdef";
assertEquals(3, str.compareTo("abc")); // ??...
assertEquals(4, str.compareTo("ab"));
assertEquals(0, str.compareTo("abcdef"));
assertEquals(-1, str.compareTo("abcdefg"));
assertEquals(-2, str.compareTo("abcdefgh"));
assertEquals(6, str.compareTo(""));
} |
concat메소드
@Test
public void concat() {
str = "abcdef";
assertEquals("abcdef", str);
assertEquals("abcdefghijk", str.concat("ghijk")); // 뒤에 들어오는 문자열을 합쳐줌
} |
contains메소드
@Test
public void contains() {
str = "abcdef";
assertEquals(true, str.contains("a")); // 들어온 문자열을 포함하고 있으면 true 아니면
// false
assertEquals(true, str.contains("f"));
assertEquals(true, str.contains("ab"));
assertEquals(false, str.contains("g"));
assertEquals(false, str.contains("ac"));
} |
contentEquals메소드
@Test
public void contentEquals() {
str = "abcdef";
assertEquals(true, str.contentEquals("abcdef"));// 컨텐츠가 100% 동일해야 true
assertEquals(false, str.contentEquals("abcde")); // 하나라도 다르면 false
} |
copyValueOf메소드
@Test
public void copyValueOf() {
str = "abcdef";
char[] tmp = new char[5];
tmp[0] = 'A';
tmp[1] = 'B';
tmp[2] = 'C';
tmp[3] = 'D';
tmp[4] = 'E';
assertEquals("ABCDE", str.copyValueOf(tmp)); // 캐릭터 배열에 있는 값을 String으로 변환해줌
assertEquals("BCD", str.copyValueOf(tmp, 1, 3)); // 캐릭터 배열에 있는 값을 offset부터 count만큼잘라줌
assertEquals("C", str.copyValueOf(tmp, 2, 1));
} |
endsWith메소드
@Test
public void endsWith() {
str = "abcdef";
// 주어진 문자열이 파라미터로 끝나는지 체크한다.
assertEquals(true, str.endsWith("f"));
assertEquals(true, str.endsWith("ef"));
assertEquals(true, str.endsWith("abcdef"));
assertEquals(false, str.endsWith("e"));
} |
equals메소드
@Test
public void equals() {
str = "abcdef";
// 문자열이 주어진 파라미터와 동일한지 확인한다.
assertEquals(true, str.equals("abcdef"));
assertEquals(false, str.equals("abcdefg"));
}
@Test
public void equal() {
assertEquals("Hello", "Hello");
}
@Test
public void equal1() {
assertEquals(true, "Hello" == "Hello");
} |
equalsIgnoreCase메소드
@Test
public void equalsIgnoreCase() {
str = "abcdef";
// 비교 대상 문자열을 소문자로 치환한다음 비교한다
assertEquals(false, str.equals("ABcdEF")); // 그냥 equal은 형태가 다르기 때문에 false
assertEquals(true, str.equalsIgnoreCase("ABcdEF")); // ABcdEF도 전부 소문자로 변환해주고 비교하기때문에 true
} |
format메소드
@Test
public void format() {
str = "abcdef"; // format에 형태를 지정해줌 (c언어에서 printf쓸때와 같음) 다른 오버로드 형태는 모르겠다.
assertEquals("format 테스트 형식 지정 10, 0.500000 test", String.format("format 테스트 형식 지정 %d, %f %s", 10, 0.5, "test"));
} |
formatWithLocaleParameter메소드
@Test
public void formatWithLocaleParameter() {
str = "abcdef"; // format에 형태를 지정해주되 Locale에 지정된 나라의 단위법을 씀
assertEquals("format 테스트 형식 지정 10, 0.500000 test", String.format(
Locale.ENGLISH, "format 테스트 형식 지정 %d, %f %s", 10, 0.5, "test"));
assertEquals("format 테스트 형식 지정 10, 0,500000 test", String.format(
Locale.FRANCE, "format 테스트 형식 지정 %d, %f %s", 10, 0.5, "test"));
} |
getBytes메소드
@Test
public void getBytes() {
str = "abcdef"; // B@4d63e95와 같은 형태로 암호화시킨다. 매번 값이 달라진다
// System.out.println(str.getBytes());
} |
getChars메소드
@Test
public void getChars() {
str = "abcdef";
// 주어진 문자 배열로부터 문자 배열을 추출해낸다
char[] tmp2 = new char[5];
int srcBegin = 0; // srcBegin - 복제하기 위한 문자열에 있는 첫번째 문자의 인덱스
int srcEnd = 2; // srcEnd - 복제하기 위한 문자열에 있는 마지막 문자의 다음 인덱스
int dstBegin = 3; // dstBegin - 여기 써있는 인덱스부터 채워 넣는다는 것
str.getChars(srcBegin, srcEnd, tmp2, dstBegin);
// tmp2 - 복제되는 배열
} |
indexOf메소드
@Test
public void indexOf() {
str = "abcdef";
assertEquals(0, str.indexOf("a"));
assertEquals(1, str.indexOf("b"));
assertEquals(1, str.indexOf("bcd")); // 문자열로 넣으면 제일 첫번째 값과 매치되는 인덱스부터 찾음
assertEquals(0, str.indexOf(97));
assertEquals(0, str.indexOf('a'));
assertEquals(1, str.indexOf(98));
assertEquals(1, str.indexOf('b'));
//2개의 매개변수를 넣는다면?
int fromIndex = 2; // 여기서부터 탐색 시작
int ch = 100; // 찾고 싶은 값
int expectedIndex = 3; // 예상된 인덱스
assertEquals(expectedIndex, str.indexOf(ch, fromIndex));
} |
isEmpty메소드
@Test
public void isEmpty() {
// string이 비어있는지 그렇지 않은지 확인
str = "abcdef";
assertEquals(false, str.isEmpty());
str = ""; //빈 문자열
assertEquals(true, str.isEmpty());
} |
lastIndexOf메소드
@Test
public void lastIndexOf() {
// indexOf와 똑같지만, 뒤에서부터 탐색한다.
str = "abcba";
assertEquals(4, str.lastIndexOf(97));
assertEquals(0, str.indexOf(97));
// 응용하기
// "2015-03-17"에서 월 추출하기
String date = "2015-03-17";
assertEquals("03", date.substring(date.indexOf("-") + 1, date.lastIndexOf("-")));
// 일 추출하기
assertEquals("17", date.substring(date.lastIndexOf("-")+1, date.length()));
// 년 추출하기
assertEquals("2015", date.substring(0, date.indexOf("-")));
} |
length()메소드
@Test
public void length() {
// 문자열의 길이 반환
str = "abcba";
assertEquals(5, str.length());
assertEquals(4, "dasd".length()); //리터럴 문자열도 String Class처럼 메소드를 적용할 수 있다.
assertEquals(0, "".length());
} |
replace()메소드
@Test
public void replace() {
// 대상 문자열을 대체시켜줌
str = "abcba";
assertEquals("AbcbA", str.replace("a", "A"));
} |
replaceAll()메소드
@Test
public void replaceAll() {
// 문자열의 길이 반환
// replace와의 차이점 - replace 메소드는 모든 문자 혹은 CharSequence를 대체한다.
// 반면 replaceFirst, replaceAll에서의 String aregument들은 정규 표현식이다.
// 잘못된 함수를 사용하는것은 잡아내기 어려운 버그들을 읽어낼 수 있다.
str = "abcba";
assertEquals("AbcbA", str.replaceAll("a", "A"));
} |
split()메소드
split에서 limit의 의미
limit는 분할을 한 후 얻고자 하는 String[]의 개수
limit<0 일때는 제한 없음
limit==0 일때는 일반 split과 동일
limit>0일때는 배열의 개수가 limit 이내로 설정됨
limit가 있다면 공백도 데이터로 본다
@Test
public void split() {
// 문자열을 파라미터를 기준으로 분리함
String[] strAry;
str = "abCbaabCba";
strAry = str.split("C");
assertEquals("ab", strAry[0]);
assertEquals("baab", strAry[1]);
assertEquals("ba", strAry[2]);
strAry = str.split("Cb");
assertEquals("ab", strAry[0]);
assertEquals("aab", strAry[1]);
assertEquals("a", strAry[2]);
int limit = 2; // 분해를 한 후 얻고자 하는 String[]의 크기
strAry = str.split("Cb", limit);
assertEquals("ab", strAry[0]);
assertEquals("aabCba", strAry[1]);
} |
startWith()메소드
@Test
public void startWith() {
// 문자열을 파라미터를 기준으로 시작되는지를 확인
str = "abcba";
assertEquals(true, str.startsWith("abc"));
assertEquals(false, str.startsWith("bc"));
} |
subSequence()메소드
@Test
public void subSequence() {
// 문자열을 파라미터를 기준으로 범위를 지정해서 반환해줌 (subString과 뭐가 다른거지?) -> Char시퀀스 형태로 반환, 자동 형변환임.
str = "abcba";
assertEquals("abcb", str.subSequence(0, 4));
assertEquals("bc", str.subSequence(1, 3));
assertEquals("c", str.subSequence(2, 3));
} |
subString()메소드
@Test
public void subString() {
str = "abcba";
assertEquals("abcb", str.substring(0, 4));
assertEquals("bc", str.substring(1, 3));
assertEquals("c", str.substring(2, 3));
assertEquals("abcba", str.substring(0));
assertEquals("cba", str.substring(2));
} |
toCharArray()메소드
@Test
public void toCharArray() {
str = "abcba";
charAry = str.toCharArray();
assertEquals('a', charAry[0]);
assertEquals('b', charAry[1]);
assertEquals('c', charAry[2]);
assertEquals('b', charAry[3]);
assertEquals('a', charAry[4]);
} |
toLowerCase()메소드
@Test
public void toLowerCase() {
str = "ABCbA";
assertEquals("abcba", str.toLowerCase());
assertEquals("abcba", str.toLowerCase(Locale.TAIWAN)); // 다른나라 말의 규칙으로
} |
toUpperCase()메소드
@Test
public void toUpperCase() {
str = "ABCbA";
assertEquals("ABCBA", str.toUpperCase());
assertEquals("ABCBA", str.toUpperCase(Locale.TAIWAN)); // 다른나라 말의 규칙으로 바꿔줌
} |
toString()메소드
오버라이딩 문제 때문에 이름을 methodLikeToString으로 명명
@Test
public void methodLikeToString() {
// 문자열로 바꿔줌
str = "ABCbA";
assertEquals("ABCbA", str.toString());
} |
trim()메소드
@Test
public void trim() {
// 양쪽의 공백만 제거된다, 가운데 공백은 제거되지 않는다.
str = " AB C bA ";
assertEquals("AB C bA", str.trim());
} |
==과 equals 메소드 차이점 테스트
@Test
public void shouldEqualWhenStringIsAssignedFromSameLiteral() {
String str1 = "abcdef";
String str2 = "abcdef";
// == 연산자와 equal 메소드의 차이점
// == 연산자는 주소값을 비교하고, equal은 형태를 비교한다.
assertEquals(true, (str1 == str2));
// 형태도 같고 주소값이 같은 경우
assertEquals(true, str1.equals(str2));
}
@Test
public void shouldFalseWhenCompareObjectsCreatedWithSameLiteral() {
String str2 = "abcdef";
String str1 = new String(str2);
// 하지만 새로 생성된 객체와 형태는 같지만 주소값이 다르면 false
assertEquals(false, (str1 == str2));
assertEquals(true, (str1.equals(str2)));
}
@Test
public void equalWithNew() {
assertEquals(false, new String("Hello") == new String("Hello"));
} |
valueOf()메소드
valueOf를 쓰면 들어온 리터럴이 동일하면 객체를 새로 생성하지 않고 반환해준다
그러면 객체를 새로 생성하지 않기때문에 메모리는 절약할 수 있다.
하지만 계속 비교연산을 해야되기때문에 연산상의 낭비는 있을 수 있다.
@Test
public void valueOf() {
assertEquals(String.valueOf("Hello"), String.valueOf("Hello"));
}
@Test
public void equalWithValueOf() {
assertEquals(true, String.valueOf("Hello") == String.valueOf("Hello"));
}
String createString(char[] x) {
return new String(x);
}
String createLikeValueOf(char[] x) {
String y = map.get(x);
if (y != null)
return y;
y = new String(x);
map.put(x, y);
return y;
}
@Test
public void testValueOf() {
char[] x = { 'a', 'b', 'c' };
assertEquals(true, createLikeValueOf(x) == createLikeValueOf(x));
assertEquals(false, createString(x) == createString(x));
} |
getChars()메소드
@Test
public void getChars() {
str = "abcdef";
// 주어진 문자 배열로부터 문자 배열을 추출해낸다
char[] tmp2 = new char[5];
int srcBegin = 0;
int srcEnd = 2;
int dstBegin = 3;
str.getChars(srcBegin, srcEnd, tmp2, dstBegin);
for (int i = 0; i < tmp2.length; i++) {
System.out.println(tmp2[i]);
}
// srcBegin - 복제하기 위한 문자열에 있는 첫번째 문자의 인덱스
// srcEnd - 복제하기 위한 문자열에 있는 마지막 문자의 다음 인덱스
// dst - 복제되는 배열
// dstBegin - 복사 대상 배열을 해당 인덱스부터 채워 넣는다는 것
} |
getBytes()메소드
getChars와 getBytes 비교
Char형 배열, Byte형 배열에 각각 따로 저장
char형 배열은 '문자'로 표현하지만 Byte형은 -128 ~ 127까지의 정수로 표현한다.
@Test
public void getBytes() {
str = "한글"; // getChar랑 getByte랑 무엇이 다른가...
byte[] tmp = str.getBytes();
for (int i = 0; i < tmp.length; i++) {
System.out.println(tmp[i]);
}
String string = "한글";
for (int i = 0; i < string.length(); i++) {
System.out.print(String.format("U+%04X ", string.codePointAt(i)));
}
} |
댓글 영역