출처: https://bumcrush.tistory.com/182 [맑음때때로 여름]

public int compareTo(String anotherString)

2개의 문자열을 비교하여(A coomparTo B) 같으면 0, A가 B보다 크면 양수, 적으면음수를 반환

맨 첫자리부터 차례대로 비교한다.

 

 (역주: "A"는 feff0041, "B"는 feff0042)
 비교는 스트링내의 각각의 문자의 Unicode 값에 근거해 행해집니다.
 String 객체에 의해 나타내지는 문자열이, 인자로 전달 받은 스트링의 문자열과 사전적으로 비교됩니다.
 String 객체가 사전적으로, 전달받은 스트링보다 전에 있는 경우는, 결과는 음의 정수가 됩니다.

 

equals(Object) 메소드가 true 를 돌려줄 때, compareTo 는 0 을 돌려줍니다.

"사전적의 순서"의 정의는 다음과 같습니다.
2 개의 스트링이 다르다고 한다면,
서로 다른 문자가 문자열 중에 있거나,
2 개의 스트링의 길이가 다르거나,
혹은 그 두 경우 다 해당되는 상황입니다.

 

만일 하나 또는 그 이상의 위치 (index) 에서 문자가 서로 다를 때,
index 중 가장 작은 숫자를 k 라고 가정합니다.
k 위치에 있는 두 문자를 < 연산자 로 비교하면, 두 문자중 하나는 다른 문자보다 작습니다.
이 문자를 가진 문자열을 사전적으로 (역주: "A"가 "B"보다 앞에 있는것 처럼) 앞에 있다고 합니다.
이 경우, compareTo 는 2 개의 스트링에서 위치 k 에 있는 2 개의 문자의 값의 차이를 돌려줍니다.
식으로 표현하면 다음과 같습니다.

this.charAt(k) - anotherString.charAt(k)

 


유효한 모든 인덱스 위치에 있어서의 문자가 같은 경우는, 짧은 길이의 스트링이 사전적으로 앞이 됩니다.
이 경우 compareTo 는 스트링의 길이의 차이를 돌려줍니다. 식으로 표현하면 다음과 같습니다.

 * this.length() - anotherString.length()

정의: compareTo in interface Comparable<string></string>
파라미터: 'anotherString - 비교 대상의 String'
반환값
인수 스트링이 스트링과 동일한 경우는 0.
스트링이 주어진 스트링보다 사전식에서 작은 경우는 음수.
주어진 스트링보다 스트링이 사전식에서 큰 경우는 양수.
 

 

package Chapter15_Overriding;
 
public class CompareTo {
 
    public static void main(String[] args) {
       
        String a = "ABC";
        String b = "ABC";
        String c = "BCD";
        String d = "ABCDEF";
       
        System.out.println(a.compareTo(b));
        //출력결과  : 0
       
        System.out.println(a.compareTo(c));
        //출력결과 : -1
       
        System.out.println(a.compareTo(d));
        //출력결과 : -3
       
    }
 
}
 
package Basic;

import java.util.StringTokenizer;

public class Token {

	public static void main(String[] args) {

		String s="11:22:33:44:55";
		StringTokenizer st = new StringTokenizer(s, ":");
		
		while(st.hasMoreTokens()) {
			System.out.println(st.nextToken());
		}
				
	}

}

11
22
33
44
55

 

import java.util.StringTokenizer;

public class Token {

	public static void main(String[] args) {
		

		System.out.println("-----------------------1번");
		String a = "11:22:33:44:55";
		StringTokenizer t = new StringTokenizer(a, ":"); // ":"가 true이면 출력
		while (t.hasMoreTokens()) {
			System.out.println(t.nextToken());
		}
		
		
		System.out.println("-----------------------2번");
		String s = "11:22:33:44:55";
		StringTokenizer st = new StringTokenizer(s, ":", true); // ":"가 true이면 출력
		while (st.hasMoreTokens()) {
			System.out.println(st.nextToken());
		}
		

		System.out.println("-----------------------3번");
		String pNum = "Tel 82-010-1234-5678";
		StringTokenizer st1 = new StringTokenizer(pNum);

		while (st1.hasMoreTokens()) {
			System.out.println(st1.nextToken());
		}

		
		System.out.println("-----------------------4번");
		StringTokenizer st2 = new StringTokenizer(pNum, " -"); // 구분자는 "-" " " 로 처리
		while (st2.hasMoreTokens()) {
			System.out.println(st2.nextToken());
		}

		
		System.out.println("-----------------------5번");
		StringTokenizer st3 = new StringTokenizer(pNum, "- ", true);
		while (st3.hasMoreTokens()) {
			System.out.println(st3.nextToken());
		}

	}

}

 

-----------------------1번
11
22
33
44
55
-----------------------2번
11
:
22
:
33
:
44
:
55
-----------------------3번
Tel
82-010-1234-5678
-----------------------4번
Tel
82
010
1234
5678
-----------------------5번
Tel
 
82
-
010
-
1234
-
5678

 

 

package Basic;

import java.math.BigDecimal;

public class BigDecimalTest {

	public static void main(String[] args) {

		
		double d1= 1.6;
		double d2= 0.1;
		System.out.println("d1 : " + d1);
		System.out.println("d2 : " + d2);
		System.out.println("d1 + d2 : "+ (d1+d2));
		System.out.println("d1 * d2 : "+ (d1*d2));
		
		BigDecimal e1 = new BigDecimal("1.6");
		BigDecimal e2 = new BigDecimal("0.1");
		
		System.out.println("두 실수의 덧셈결과: "+ e1.add(e2));
		System.out.println("두 실수의 곱셈결과: "+ e1.multiply(e2));
	}

}
​

 

최대 정수 표현 : 9223372036854775807
최소 정수 표현 : -9223372036854775808
덧셉 : -8999999999999999999999999
곱셈 : -9999999999999999999999999000000000000000000000000

 

package Basic;

import java.math.BigInteger;

public class BigIntergerTest {

	public static void main(String[] args) {

		System.out.println("최대 정수 표현 : " + Long.MAX_VALUE);
		System.out.println("최소 정수 표현 : " + Long.MIN_VALUE);
		
		BigInteger bigValue1 = new BigInteger("1000000000000000000000000");
		BigInteger bigValue2 = new BigInteger("-9999999999999999999999999");
		
		BigInteger addResult = bigValue1.add(bigValue2);
		BigInteger mulResult = bigValue1.multiply(bigValue2);
		
		System.out.println("덧셉 : " + addResult);
		System.out.println("곱셈 : " + mulResult);

	}

}

 

d1 : 1.6
d2 : 0.1
d1 + d2 : 1.7000000000000002
d1 * d2 : 0.16000000000000003
두 실수의 덧셈결과: 1.7
두 실수의 곱셈결과: 0.16

 

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 Wrapper1 {
 
    public static void main(String[] args) {
 
        Integer i1 = new Integer(100); // 인스턴스생성
        Integer i2 = new Integer(100); // 인스턴스 생성
        
        System.out.println("참조변수의 비교 : " + (i1==i2)); // 참조값비교
        System.out.println("저장값 비교 : " + i1.equals(i2)); // 저장값 비교
        
        System.out.println("il.toString() : "+ i1.toString());
        System.out.println("i2.toString() : "+ i2.toString());
        
        System.out.println("Integer.MAX_VALUE : " +Integer.MAX_VALUE);
        System.out.println("Integer.MIN_VALUE : "+Integer.MIN_VALUE);
        System.out.println("Type : " + Integer.TYPE);
        System.out.println("Siez : " + Integer.SIZE);
    
        
        int num = i2.intValue();
        System.out.println("int num = i2.intValue();" + num); 
        
        int num2=Integer.parseInt("10"); //String>int
        num2+=1;
        System.out.println("num2 : " + num2);
        
        // String > integer , int > integer        
        Integer i3 = Integer.valueOf("10");
        int num3=i3.intValue();
        System.out.println("num3 : " + num3);
        
    }
 
}
cs
참조변수의 비교 : false
저장값 비교 : true
il.toString() : 100
i2.toString() : 100
Integer.MAX_VALUE : 2147483647
Integer.MIN_VALUE : -2147483648
Type : int
Siez : 32
int num = i2.intValue();100
num2 : 11
num3 : 10​

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
    public static void main(String[] args) {
 
        Integer iValue=10// autoboxing
        // Integer iValue=new Integer(10)
        // Integer iValue=Integer.valueOf(10)
        Double dValue=3.14;
        //Double dValue=new Double(3.14)
        //Double dValue=Double.valueOf(3.14)
        
        System.out.println(iValue); // iValue.toString()
        System.out.println(dValue); // dValue.toString()
        
        int num1=iValue; // Integer > int Auto unboxing
        double num2= dValue;
        
        System.out.println(num1);
        System.out.println(num2);
 
    }
 
}
    
cs
10
3.14
10
3.14

A instanceof B

참조변수 A

Type B

A가 B로 변환이 가능한가

True / False

 

System.arraycopy (src, srcPos, dest, destPos, length)

[dest배열의 destpos번지에 src배열의 소스를 srcpos번지부터 length개 복사]

<삽입의 개념X 덮어씀O>

 

Object src : 복사하고자 하는 소스입니다. 원본

 

int srcPos  : 위의 원본 소스에서 어느 부분부터 읽어올지 위치를 정해줍니다.

                처음부터 데이터를 읽어올거면 0 을 넣어줍니다.

 

Object dest : 복사할 소스입니다. 복사하려는 대상입니다.

 

int destPos : 위의 복사본에서 자료를 받을 때, 어느 부분부터 쓸 것인지 시작 위치를 정해줍니다.

                 처음부터 데이터를 쓸 거면 0 을 넣어줍니다.

 

int length : 원본에서 복사본으로 데이터를 읽어서 쓸 데이터 길이입니다. 

               원본에서 복사본까지 얼마큼 읽어올 지 입력하는 것입니다.

 

 

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
    public static void main(String[] args) {
 
        int[] original = { 1234567891011 };
        int[] arr1 = new int[5];
        int[] arr2 = new int[6];
 
        System.arraycopy(original, 0, arr1, 0, arr1.length);
        System.arraycopy(original, arr1.length, arr2, 0, arr2.length);
 
        for (int i : arr1) {
            System.out.print(i + ", ");
        }
 
        System.out.println();
        System.out.println("====================");
 
        for (int i : arr2) {
            System.out.print(i + ", ");
        }
 
        
//        result
        
//        1, 2, 3, 4, 5, 
//        ====================
//        6, 7, 8, 9, 10, 11, 
        
        
    }
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
25
26
27
28
29
30
31
    public static void main(String[] args) {
        char[] abc = { 'A''B''C''D'};
        char[] number = { '0''1''2''3''4''5''6''7''8''9'};
        System.out.println(new String(abc));
        System.out.println(new String(number));
    
        // 배열 abc와 number를 붙여서 하나의 배열(result)로 만든다.
        char[] result = new char[abc.length+number.length];
        System.arraycopy(abc, 0, result, 0, abc.length);
        System.arraycopy(number, 0, result, abc.length, number.length);
        System.out.println(new String(result));
        
        // 배열 abc을 배열 number의 첫 번째 위치부터 배열 abc의 크기만큼 복사
        System.arraycopy(abc, 0, number, 0, abc.length);
        System.out.println(new String(number));
        
        // number의 인덱스6 위치에 3개를 복사        
        System.arraycopy(abc, 0, number, 63);
        System.out.println(new String(number)); 
        
 
         // 출력
        /*
        ABCD
        0123456789
        ABCD0123456789
        ABCD456789
        ABCD45ABC9
        */
 
    } 
cs
		String str="abcd-efgh-ijkl";
		
		System.out.println(str.substring(2, 6)); //cd-e
		System.out.println(str.substring(5)); //efgh-ijkl
				

substring

ex) substring(0,5) :  0번째 부터 5개 string값 가져오기

    substring(5)  : 5번째부터 끝까지 가져오기

 

 

		String str="abcd-efgh-ijkl";
		
		System.out.println(str.lastIndexOf("-")); // 9
				

lastIndexOf

ex) lastIndexOf("a") : 마지막으로 *문자가 존재하는 위치의 인덱스 값( 중복일 경우 제일 마지막번호)

 

 

		String str="abcd-efgh-ijkl";
		
		System.out.println(str.replace("-","")); //abcdefghijkl
        

replace("a","b") : string 값 중 a를 모두 b로 변경해라

ex) replace("a","b") : 존재하는 모든 a를 b로 변경함

 

 

		String str="abcd-efgh-ijkl";
		
		System.out.println(str.indexOf("-")); // 4

indexOf("a") : string 값 중 문자의 위치 찾기  // 앞에꺼만나옴

ex)  str.indexOf("-") 

 

 

 

 

StringBuffer : StringBuffer인스턴스가 갖고 있는 문자열과 같은 내용의 String 인스턴스 생성

char charAt(int index) : 지정된 위치에 있는 문자를 알려줌

int compareTo(String str) : 문자열과 사전순서로 비교. 같으면 0, 사전순으로 이전이면 음수, 이후면 양수 반환

String concat(String str) : 문자열을 뒤에 덧붙임

boolean contains(CharSequence s) : 지정된 문자열이 포함되었는지 검사

boolean endsWith(String suffix) : 지정된 문자열로 끝나는지 검사

boolean equals(Object obj) : 매개변수로 받은 문자열과 String인스턴스의 문자열 비교. obj가 String이 아니거

나 문자열이 다르면 false 반환

boolean equalsIgnoreCase(String str) : 문자열과 String인스턴스의 문자열을 대소문자 구분없이 비교

int indexOf(int ch) : 주어진 문자가 문자열에 존재하는지 확인하여 위치 알려줌. 못 찾으면 -1을 반환

int indexOf(int ch, int pos) : 주어진 문자가 문자열에 존재하는지 지정된 위치부터 확인. 못찾으면 -1 반환

int indexOf(String str) : 주어진 문자열이 존재하는지 확인하여 위치 알려줌. 못찾으면 -1 반환

String intern() : 문자열을 상수풀에 등록. 이미 상수풀에 같은 내용의 문자열이 있을 경우 문자열의 주소값 반환

int LastIndexOf(int ch) : 지정된 문자 또는 문자코드를 문자열의 오른쪽 끝에서 부터 찾아서 위치 알려줌.

int LastIndexOf(String str) : 지정된 문자열을 인스턴스의 문자열 끝에서부터 찾아서 위치 알려줌.

int length() : 문자열의 길이 알려줌

String replace(char old, char nw) : 문자열 중의 문자를 새로운 문자로 바꾼 문자열을 반환

String replace(CharSequence old, CharSequence nw) : 문자열 중의 문자열을 새로운 문자열로 모두 바꾼 문

자열 반환

String replaceAll(String regex, String replacement) : 문자열 중에서 지정된 문자열과 일치하는 것을 새로운

문자열로 모두 변경

String replaceFirst(String regex, String replacement) : 문자열 중에서 지정된 문자열과 일치하는 것 중 첫 번

째 것만 새로운 문자열로 변경

String[] split(String regex) : 문자열을 지정된 분리자로 나누어 문자열 배열에 담아 반환

String[] split(String regex, int limit) : 문자열을 지정된 분리자로 나누어 반환하는데 문자열 전체를 지정된 수로

자름

boolean startsWith(String prefix) : 주어진 문자열로 시작하는지 검사

String substring(int begin, int end) : 주어진 시작위치부터 끝 위치범위에 포함된 문자열을 얻는다. 이 때 시작

위치의 문자는 범위에 포함되지만, 끝 위치의 문자는 포함되지 않는다

String toLowerCase() : String인스턴스에 저장되어있는 모든 문자열을 소문자로 변환하여 반환

String toString() : String인스턴스에 저장되어 있는 문자열을 반환

String toUpperCase() : String인스턴스에 저장되어있는 모든 문자열을 대문자로 변환하여 반환

String trim() : 문자열의 왼쪽 끝과 오른쪽 끝에 있는 공백을 없앤 결과를 반환. 중간에 있는 공백은 제거되지 않음

static String valueOf(boolean b) : 지정된 값을 문자열로 변환하여 반환. 참조변수의 경우 toString()을 호출한

결과를 반환함

[출처] String 클래스 생성자, 메서드|작성자 려리

 

Blog : 네이버 블로그

당신의 모든 기록을 담는 공간

blog.naver.com

startWith : 문자열이 지정한 문자로 시작하는지 판단. 같으면 true 아니면 false를 반환 (대소문자 구별) 

- 결과값 : true 

 

endWith : 문자열 마지막에 지정한 문자가 있는지를 판단후 있으면 true, 없으면 false를 반환 (대소문자 구별) 

- 결과값 : true 

 

equlas : 두 개의 String에 값만을 비교해서 같으면 true, 다르면 false를 반환 (대소문자 구별)

- 결과값 : true

 

indexOf : 지정한 문자가 문자열에 몇번째에 있는지를 반환한다. (int)

- 결과값 : 3

 

lastindexOf : 문자열에 지정한 문자가 마지막 몇 번째에 있는지를 반환한다. (int)

- 결과값 : 7

 

length : 문자열의 길이를 반환

- 결과값 : 6

 

replace : 문자열에 지정한 문자가 있으면 새로 지정한 문자로 바꿔서 출력

- 결과값 : A-B-C-D

 

replaceAll : 정규표현식을 지정한 문자로 바꿔서 출력한다.

- 결과값 : AB*CD

 

split : 지정한 문자로 문자열을 나눌 수 있다. (배열로 반환)

- 결과값 : B

 

substring : 문자열에 지정한 범위에 속하는 문자열을 반환한다. (시작범위에 값은 포함, 끝나는 범위에 값은 미포함)

- 결과값 : AB

 

toLowerCase, toUpperCase : 문자열에 대문자를 소문자로 또는 소문자를 대문자로 변환한다.

(예제 생략)

 

trim : 문자열에 첫 공백과 마지막 공백을 없애준다.

- 결과값 : java java java

 

valueOf : 지정한 개체의 원시 값을 반환

- 결과값 : 

valueOf : 12345

valueOf : 1

valueOf : 1

 

compareTo : 두 개의 String을 앞에서 부터 순서적으로 비교.

- 문자열의 길이가 다른 경우 : 

(str1.length - str2.length)를 반환

- 문자열이 다른 경우 : 

문자열이 다른 부분이 i라면, (str1.charAt(i) - str2.charAt(i))를 반환

- 결과값 : A < B

 

contains : 두 개의 String을 비교해서 비교대상 String을 포함하고 있으면 true, 다르면 false를 반환한다.

- 결과값 : true 

 

charAt : 지정한 index번째에 문자를 반환한다.

(예제 생략)

 

concat : 문자열과 문자열을 결합해준다.

(예제 생략)

 

format : 서식 문자열을 이용해서 서식화된 문자열을 반환한다. (뒤에 인수는 객체 배열이어야 한다.)

- 결과값 : 123,456 ... 7

 

matches : 지정한 정규 표현과 일치할 때 true를 반환한다.

 

- 결과값 : false

 

replaceFirst : 문자열에 지정한 문자가 있으면 첫번째만 새로 지정한 문자로 바꿔서 출력한다. 

- 결과값 : superman

ex) trim으로 공백을 제거해 준 후 isEmpty를 사용 > true

 

 

🎈 trim은 앞 뒤 공백만 제거해줄 뿐 가운데는 제거해주지 않는다.

Math.abs()

- static int abs(int a)

- static double abs(double a)

- static float abs(float a)

- static long abs(long a)

- abs() 함수는 인자값에 대한 절대값을 반환하는 함수이다.


public class MathABSTest{

    

    public static void main(String[] args){

        int intNum = -15;

        double doubleNum = -3.14;

 

        //의미가 없으니 위에 두개만 예제로 듭니다.

        //float intNum = -123.2f;

        //long intNum = -18451354;

 

        System.out.println( Math.abs(intNum) );  // 15

        System.out.printlnMath.abs(doubleNum) );  //  3.14

 

    }

}

 

절대값이니 당연히 모든 음수값은 양수값으로 변경되며 절대값으로 반환된 값들은

해당 타입을 그대로 반환합니다.(int 는 int , double은 double 로 반환)

toLowerCase();  소문자로 바꿔주는 함수 

toUpperCase() ;  대문자로 바꿔주는 함수

 

대문자를 소문자로

ex) var a = document.frm.object_name.value;

      var a = a.toLowerCase();

      alert(a);

 

소문자를 대문자로

ex)  var b = document.frm.object_name.value;

      var b = b.toUpperCase();

      alert(b);

 

ParseInt

String > int

1
2
3
4
5
6
         int num;
         String s = "4";
         
         num = Integer.parseInt(s);
         System.out.println(num);
         
cs

 

toString

int > String

1
2
3
        int s=140;
        String str=Integer.toString(s);
        System.out.println(str);
cs
import java.util.Random;

public class RandomnumberGenerator {
	
	public static void main(String[] args) {
		
		Random r = new Random();
		
		System.out.println(r.nextBoolean());	// 논리값두개랜덤출력 t/f
		System.out.println(r.nextInt());		// Integer범위안의 랜덤
		System.out.println(r.nextLong());
		
		System.out.println(r.nextInt(45)); // 범위설정 랜덤 0~44
		System.out.println("이번주 번호예상");
		for(int i=0; i<6; i++) {
			System.out.print(r.nextInt(46)+"\t");
		}
		
		
		Random r2=new Random(10); //seed가잇어서 한번 나온 랜덤수가 계속 똑같이 출력됌
		System.out.println("이번주 번호예상");
		for(int i=0; i<6; i++) {
			System.out.print(r2.nextInt(46)+"\t");
		}
		
		System.out.println();
		
		System.out.println("System.currentTimeMillis()  : "+ System.currentTimeMillis()); // 바뀜
		System.out.println("System.nanoTime()  : " +System.nanoTime());
		Random r3=new Random(System.currentTimeMillis());
		System.out.println("이번주 번호예상");
		for(int i=0; i<6; i++) {
			System.out.print(r3.nextInt(46)+"\t");
		}
	
	}

}
​
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
        int r;
        r = (int) (Math.random() * 10); // 0~9
        // Math.random은 double형이기 때문
        // * n 은 0 ~ (n-1)까지 랜덤이라는 뜻
 
 
        
 
        
         // 랜덤으로 돌아다니는 몹(?)을 만드는 것
        
    int x;
    int y;
        
        x=(int)(Math.random()*3-1 ;
        y=(int)(Math.random()*3-1 ;
        // x = -1, 0, 1
        // y = -1, 0, 1
    
cs

 

1
2
3
4
5
6
7
8
9
10
11
12
13
    String str1 = "hello";
    String str2 = "hell";
    
    str2 = str2 + "o";
    System.out.println(str2); // hello로 출력
    
    if (str1==str2) {
        System.out.println("같다");  // 같다고 인식하지 않음
    }
    
    if (str1.equals(str2)) {
        System.out.println("같습니다"); // 같다고 인식함
    }
cs

+ Recent posts