1017,19 JAVA - String 메서드

728x90

split() : 특정 기준으로 문자열 분리 분리된 문자열은 배열로 관리됨 분리에 사용되는 기준 문자열을 구분 자(= 분리 자, Delimeter) 구분자를 지정하는 규칙은 정규표현식을 따름

String s3 = "자바/JSP/안드로이드"; => 문자열을 "/" 기호를 기준으로 분리하여 배열로 관리 가능

String[] subjectArr = s3.split("/");

문자열을 “/” 기호 기준으로 분리하여 Stringp[] 배열 타입으로 리턴

“자바”, “JSP”, “안드로이드” 형태로 분리되어 배열에 저장됨

for(int i = 0; i< subjectArr.length; i++ {
		System.out.println(subjectArr[i]);
}

만약, “.”기호를 구분자로 지정하는 경우

정규 표현식에서 특수기호로 사용되어 모든 문자를 구분자로 지정하게 됨

⇒ 모든 문자가 분리 기준이 되어 제거 됨

String s4 = "안녕하세요. 자바 프로그래밍입니다.";
String[] strArr = s4.split(".");    //모든 문자열이 제거되므로 사용 불가

\\. 이렇게 써야 . 이 나온다.

String[] strArr = s4.split("\\\\.");
for(int i = 0; i<strArr.length; i++){
		System.out.println(strArr[i]);
}

String.format() 메서드

특정 문자열을 형식 지정 문자(%?) 와 결합하여 형식을 갖춘 문자열로 리턴

⇒ println() 메서드와 형식 지정문자 동일

String name = "홍길동";
int age = 20;
double height = 180.7;

위의 세가지 데이터를 형식 지정문자를 사용하여 출력

System.out.printf("이름 : %s, 나이 : %d, 키 : %.1f\\n", name, age, height);

위의 세가지 데이터를 결합한 문자열을 리턴 받아 저장

String formatStr = 
	String.format("이름 : %s, 나이 : %d, 키 : %.1f\\n", name, age, height);

System.out.println("생성된 회원 정보는 " + formatStr);

toCharArray() : 문자열을 char[] 배열로 리턴

String s5 = "admin123!";
char[] chArr = s5.toCharArray(); // a, d, m, i, n, 1, 2, 3, ! 로 분리 됨.
for(int i = 0; i < chArr.legnth; i++){
		System.out.println(chArr[i]);
}

Arrays.toString() : 배열 내의 모든 데이터를 문자열로 결합하여 리턴

System.out.println(Arrays.toString(chArr));    // [a, d, m, i, n, 1, 2, 3, !]

String 클래스 메서드 연습

💡 1. 주민등록번호(jumin)을 입력 받아 성별(남 또는 여) 및 외국인 판별

입력 형식 : "XXXXXX-XXXXXXX"

판별 조건

 1) 뒷자리 첫번째 숫자(문자)가 1 or 3 : "남성"

 2) 뒷자리 첫번째 숫자(문자)가 2 or 4 : "여성"

 3) 뒷자리 첫번째 숫자(문자)가 5 or 6 : "외국인"

if문을 사용하는 경우

주민등록번호 뒷자리 첫번째 숫자 추출 => 문자로 저장

char genderNum = jumin.charAt(7);
		
		if(genderNum == '1' || genderNum == '3') {
			System.out.println(jumin + " : 남성!");
			
		}else if(genderNum == '2' || genderNum == '4') {
			System.out.println(jumin + " : 여성!");
		}else if(genderNum == '5' || genderNum == '6') {
			System.out.println(jumin + " : 외국인");
		}else {
			System.out.println(jumin + " : 잘못된 주민번호");
		}

Switch ~ case 문

switch(genderNum) {
		case 1 : 
		case 3 : System.out.println(jumin + " : 남성!"); break;
		case 2 : 
		case 4 : System.out.println(jumin + " : 여성!"); break;
		case 5 : 
		case 6 : System.out.println(jumin + " : 외국인!"); break;
		default : System.out.println(jumin + " : 잘못된 주민번호!");

subString() 메서드 활용

💡 문자열에 포함된 내용(주소)중에서 실제 주소 부분만 추출하여 출력

입력 형식 : ‘Address:주소….’
ex) “Address : 부산 광역시 부산진구 동천로109 삼한 골든 게이트”
출력 형식 : “Address” 부분을 제외한 나머지 주소만 추출해서 출력
ex) “부산광역시 부산진구 동천로109 삼한 골든 게이트 출력

String address = "Address : 부산광역시 부산진구 동천로109 삼한골든게이트";
System.out.println(address.substring(8));

split() 메서드 활용

💡 문자열에 포함된 정보를 특정 기준 문자열(구분 자)을 기준으로 분리하여 항목별로 출력하기

콤마(,) 를 기준으로 각 항목 분리하기

String address2 = "Address:부산광역시 부산진구 동천로109, floor:7층, Tel:051-803-0909";

String [] strArr = address2.split(",");
		for(int i = 0; i<strArr.length; i++) {
			System.out.println(strArr[i]);
		}

💡 2. 1번의 결과에서 콜론(:)을 기준으로 항목명과 항목 내용을 분리하여 내용 부분(주소, 층, 전화번호) 만 출력

ex) 부산광역시 부산진구 동천 로 109 7층 051-803-0909 출력

String [] strArr = address2.split(",");
		for(int i = 0; i<strArr.length; i++) {
			System.out.println(strArr[i]);
		}
		
		for(int i = 0; i<strArr.length; i++) {
			String[] strArr2 = strArr[i].split(":");
			//분리된 문자열의 1번 인덱스가 실제 데이터이므로
			System.out.println(strArr2[1]); //1번 인덱스 데이터를 반복 출력
			}

[console]
floor:7층
 Tel:051-803-0909
부산광역시 부산진구 동천로109
7층
051-803-0909

분리된 결과를 별도의 배열에 저장하지 않고 1번 인덱스 데이터를 바로 출력
//1회성으로 접근 후 제거해도 무관 할 경우 사용

System.out.println(strArr[i].split(":")[1]);
//분리된 결과의 1번 인덱스 문자열을 출력

StringBuffer , StringBuilder

String 클래스는 한번 생성되면 내부의 문자열이 바뀌지 않음

String 클래스를 사용하여 문자열을 계속 연결하거나 변경하는 프로그램을 사용하면 메모리 낭비가 심하다.

이 때 StringBuffer 또는 StringBuilder를 활용하여 문자열을 변경하거나 연결

두 클래스는 크게 차이가 없음.

스레드가 동작하는 멀티 스레드 프로그램이라면 문자열의 안전한 변경을 보장하는 StringBuffer 클래스를 사용하고

스레드가 동작하지 않는 프로그램이라면 실행 속도가 좀 더 빠른 StringBuilder 클래스를 사용.

String str = new String("Java");
	System.out.println("str 문자열 주소 : " + System.identityHashCode(str));
	// => 인스턴스가 처음 생성 될 때의 메모리 주소 41903949
	System.out.println(str);
	
	str = str + " and";
	System.out.println("str 문자열 주소 : " + System.identityHashCode(str));
	System.out.println(str); // Java and 

	//=> "Java and" 의 문자열을 갖는 메모리 영역이 새로 생성되었음을 
	//=> 기존의 "Java" 문자열을 갖는 메모리 영역은 참조 하는 변수가 없을 경우 
	//	 자바에서 제공하는 가비지 컬렉터에 의해서 자동으로 사라짐

str = str + " android";
	System.out.println("str 문자열 주소 : " + System.identityHashCode(str));
	
	str = str + " programming is fun!!!";
	System.out.println("str 문자열 주소 : " + System.identityHashCode(str));

StringBuilder buffer = new StringBuilder(str);
	// => String으로부터 StringBuilder 생성
	System.out.println("연산 전 buffer 메모리 주소 : " + System.identityHashCode(buffer));
	
	buffer.append(" and");
	System.out.println("연산 후 buffer 메모리 주소 : " + System.identityHashCode(buffer));
	
	buffer.append(" android");
	System.out.println("연산 후 buffer 메모리 주소 : " + System.identityHashCode(buffer));
	
	buffer.append(" programming is fun!!!");
	System.out.println("연산 후 buffer 메모리 주소 : " + System.identityHashCode(buffer));
	
	//toString()을 통해 String 클래스로 변환
	str = buffer.toString();
	System.out.println(str);
	System.out.println("새로만들어진 str문자열 주소 : " +System.identityHashCode(str));

Wrapper_class

기본 데이터 타입을 객체 형태로 관리해주는 클래스의 모음

⇒ java. lang 패키지에 위치.

기본 데이터 타입과 1:1로 대응하는 8개의 클래스를 제공

(Byte, Short, Integer, Long, Float, Double, Boolean, Char)

Wrapper 클래스에서 제공하는 상수와 메서드 등을 활용하여 기본 데이터타입 데이터를 다양하게 처리 할 수 있음

Byte

System.out.println("byte 타입 메모리 크기 (bit) : " + Byte.SIZE);
System.out.println("byte 타입 메모리 크기 (byte) : " + Byte.BYTES);
System.out.println("byte 타입 최소값 : " + Byte.MIN_VALUE);
System.out.println("byte 타입 최소값 : " + Byte.MAX_VALUE);

----------------------------------------------------------------

byte 타입 메모리 크기 (bit) : 8
byte 타입 메모리 크기 (byte) : 1
byte 타입 최소값 : -128
byte 타입 최소값 : 127

Short

System.out.println("short 타입 메모리 크기 (bit) : " + Short.SIZE);
System.out.println("short 타입 메모리 크기 (byte) : " + Short.BYTES);
System.out.println("short 타입 최소값 : " + Short.MIN_VALUE);
System.out.println("short 타입 최소값 : " + Short.MAX_VALUE);

----------------------------------------------------------------

short 타입 메모리 크기 (bit) : 16
short 타입 메모리 크기 (byte) : 2
short 타입 최소값 : -32768
short 타입 최소값 : 32767

Char

System.out.println("Char 타입 메모리 크기 (bit) : " + Character.SIZE);
System.out.println("Char 타입 메모리 크기 (byte) : " + Character.BYTES);
System.out.println("Char 타입 최소값 : " + Character.MIN_VALUE);
System.out.println("Char 타입 최소값 : " + Character.MAX_VALUE);

----------------------------------------------------------------

Char 타입 메모리 크기 (bit) : 16
Char 타입 메모리 크기 (byte) : 2
Char 타입 최소값 :

💣Char타입은 문자이기 때문에, 최소값 최대값을 출력하려면 형변환이 필요하다.

System.out.println("Char 타입 최소값 : " + (int)Character.MIN_VALUE);
System.out.println("Char 타입 최소값 : " + (int)Character.MAX_VALUE);

----------------------------------------------------------------

Char 타입 최소값 : 0
Char 타입 최소값 : 65535

Integer

System.out.println("int 타입 메모리 크기 (bit) : " + Integer.SIZE);
System.out.println("int 타입 메모리 크기 (byte) : " + Integer.BYTES);
System.out.println("int 타입 최소값 : " + Integer.MIN_VALUE);
System.out.println("int 타입 최소값 : " + Integer.MAX_VALUE);

----------------------------------------------------------------

int 타입 메모리 크기 (bit) : 32
int 타입 메모리 크기 (byte) : 4
int 타입 최소값 : -2147483648
int 타입 최소값 : 2147483647

Long

System.out.println("long 타입 메모리 크기 (bit) : " + Long.SIZE);
	System.out.println("long 타입 메모리 크기 (byte) : " + Long.BYTES);
	System.out.println("long 타입 최소값 : " + Long.MIN_VALUE);
	System.out.println("long 타입 최소값 : " + Long.MAX_VALUE);

----------------------------------------------------------------

long 타입 메모리 크기 (bit) : 64
long 타입 메모리 크기 (byte) : 8
long 타입 최소값 : -9223372036854775808
long 타입 최소값 : 9223372036854775807

float

System.out.println("float 타입 메모리 크기 (bit) : " + Float.SIZE);
System.out.println("float 타입 메모리 크기 (byte) : " + Float.BYTES);
System.out.println("float 타입 최소값 : " + Float.MIN_VALUE);
System.out.println("float 타입 최소값 : " + Float.MAX_VALUE);

----------------------------------------------------------------

float 타입 메모리 크기 (bit) : 32
float 타입 메모리 크기 (byte) : 4
float 타입 최소값 : 1.4E-45
float 타입 최소값 : 3.4028235E38

double

System.out.println("double 타입 메모리 크기 (bit) : " + Double.SIZE);
System.out.println("double 타입 메모리 크기 (byte) : " + Double.BYTES);
System.out.println("double 타입 최소값 : " + Double.MIN_VALUE);
System.out.println("double 타입 최소값 : " + Double.MAX_VALUE);

----------------------------------------------------------------

double 타입 메모리 크기 (bit) : 64
double 타입 메모리 크기 (byte) : 8
double 타입 최소값 : 4.9E-324
double 타입 최소값 : 1.7976931348623157E308

오토 박싱(Auto Boxing)

기본 데이터 타입 → Wrapper 클래스 타입의 객체로 자동으로 변환하는 기능

(ex. int → Integer, char → Character)

오토 언박싱(Auto Unboxing)

Wrapper 클래스 타입 객체 → 기본 데이터 타입으로 자동으로 변환하는 기능

(ex. Integer → int, Character → char)

기본 데이터 타입 변수 선언

int num1 = 10; //정수 데이터 10을 기본 데이터타입 변수 num1에 저장 
int num2;
	
	//기본 데이터 타입 변수는 그대로 출력하면 저장된 정수데이터가 출력됨
	//즉, 변수에 저장된 데이터가 실제 사용하는 데이터 
System.out.println("기본 데이터타입 변수 num1의 값 = " + num1);

//Integer 타입 변수 선언 및 객체 생성 => 생성자 파라미터로 저장할 변수를 저장 
	
	Integer n1;
//	Integer n2 = new Integer(20);
	//정수 20을 갖는 인스턴스를 생성하고 해당 주소값을 Integer 타입 참조변수 n2에 저장 
	Integer n2 = new ~~Integer~~("20");
	
	//참조데이터타입변수는 그래도 출력하면 원래 주소값이 출력되어야 하지만 Wrapper 클래스에는 toString() 메서드가 오버라이딩 되어 있으므로
	//객체가 저장한 값을 문자열로 리턴하므로 데이터 출력 가능함
	System.out.println("참조타입 변수 n2의 값 = " + n2); //toString() 생략

기본데이터타입은 Stack공간에 실제데이터 형태를 직접 관리하지만, 객체는 heap 공간에 실제 데이터가 저장 되고, 해당 주소 값을 Stack 공간에서 관리함.

따라서, 기본 데이터 타입 변수와 참조 데이터 타입 변수는 호환이 불가능하다.

int 형 데이터를 Integer 타입 객체로 변환하여 저장

n1 = Integer.valueOf(num1);

System.out.println(num1 + ", " + n1);

--------------------------------------------------

10, 10

Java 1.5부터 기본형 → Wrapper 클래스 타입으로 변환 시 메서드 호출하는 변환 과정을 생략해도 자동으로 변환을 수행하도록 변경 됨.

즉, 대입 연산자를 통해 직접 대입이 가능하도록 바뀌었음.

n1 = num1;
//기본 데이터를 자동으로 Integer 타입으로 변환하여 저장.

이 것을 오토 박싱 (Auto Boxing) 이라고 함!!

Heap 공간에 생성된 Wrapper 클래스 타입 객체를 기본형 변수에 저장 할 경우

num2 = n2.intValue(); //Integer 객체 -> int 타입으로 변환하는 메서드 
// => 오토 언박싱을 활용할 경우 자동으로 변환됨 

num2 = n2; //Integer 타입 객체 -> 기본 데이터타입으로 자동 변환 
// => 오토 언박싱 (Auto Unboxing)

System.out.println(num2 + ", " + n2); 

-------------------------------------------

20, 20

기본 데이터 타입과 Wrapper 클래스 타입 간의 연산 수행할 경우, Wrapper 클래스 타입 객체를 오토 언박싱 후 연산을 수행 함.

int num3 = 10;
Integer n3 = 20;
System.out.println(num3 + n3);

---------------------------------------------

30

Object 타입 변수에 기본 데이터타입 저장 가능하다!

단, 기본 데이터 타입 → Wrapper 클래스 타입으로 오토 박싱 후 다시 Wrapper 클래스 타입 객체 → Object 타입으로 업캐스팅이 일어난 것.

Object o = 10;
System.out.println(o); //toString() 메서드 호출 생략되어 있음 

---------------------------

10

문자열 → 기본 데이터 타입으로 변환

주로 웹에서 form 태그의 input 태그로 데이터를 입력 받거나 자바, 안드로이드 등의 GUI 환경으로 데이터를 입력 받을 때 수치 데이터를 입력하더라도 모두 문자열로 취급 됨

⇒ 따라서, 해당 문자열을 실제 연산을 하기 위해 기본 데이터타입으로 변환하려면 Wrapper 클래스에서 제공하는 메서드를 통해 변환을 수행해야 한다.

<aside> 💡 < 기본 문법 규칙 > Wrapper 클래스명. parse기본데이터타입명(문자열 변수 또는 데이터)

</aside>

ex) 정수형으로 변환 할 경우 Integer.parseInt()

실수형으로 변환 할 경우 Double.parseDouble()

Error!

String strNum = "100.0";

int iNum = Integer.parseInt(strNum);  

에러남! 
String 타입 문자열 실수를 int 형으로 변환하려 할 경우, 실제 데이터가 실수이므로 정수형으로 변환이 불가능한 관계이다. 
문법적으로는 문제가 없지만, 실행 시점에서 오류가 발생한다. 
=> NumberFormatException 예외 발생 

int i = 100.0; //int 형 변수에 실수를 저장하지 못하는 것과 동일한 에러이다.

double dNum = Double.parseDouble(strNum);
System.out.println(dNum);

------------------------------------------------

100.0    (문자열 100.0이 아니라 실수값 100.0임)

기본 데이터 타입이 아닌 Wrapper 클래스 타입으로도 변환이 가능함.

Double dNum2 = new ~~Double~~(strNum);  //생성자에 문자열 전달 
System.out.println(dNum2);

strNum = "1234";
//int 형 변수 iNum에 문자열 "1234"를 변환하여 저장 
int iNum = Integer.parseInt(strNum);
System.out.println(iNum);

Wrapper 클래스의 다양한 메서드

기본 데이터 타입들을 다양하게 처리하기 위한 메서드가 제공됨

주로 static 메서드 형태로 호출하여 사용 (클래스명.메서드명() 형태로 호출)

기본 데이터 타입과 Wrapper 클래스 객체 모두 활용 가능

int num1 = 10, num2 = 20;
Integer n1 = 10, n2 = 20;

max()

두 정수의 최대값을 계산하는 메서드

System.out.println(Integer.max(num1, num2));  //기본데이터타입과
System.out.println(Integer.max(n1,n2)); //***Wrapper*** 클래스 타입 모두 사용

min()

두 정수의 최소값을 계산하는 메서드

System.out.println(Integer.min(num1, num2)); 
System.out.println(Integer.min(n1, n2));

10진수 정수를 다양한 형태의 진법으로 변환할 경우

Integer.toXXXString() 메서드를 호출하여 해당 진법으로 변환 가능

⇒ XXX는 각 진법 이름 지정 (2진법 : Binary, 8진법 : Octal, 16진법 : Hex)

System.out.println("정수 10을 2진수로 변환 : " + Integer.toBinaryString(num1));
System.out.println("정수 10을 8진수로 변환 : " + Integer.toOctalString(num1));
System.out.println("정수 10을 16진수로 변환 : " + Integer.toHexString(num1));

----------------------------------------------------------------------------------

[c o n s o l e]
정수 10을 2진수로 변환 : 1010
정수 10을 8진수로 변환 : 12
정수 10을 16진수로 변환 : a

Character 클래스를 활용한 문자 데이터 처리

char ch = 'R';
System.out.println("원본 데이터 : " + ch);

입력 받은 문자 ch에 대한 대문자, 소문자, 숫자, 기타문자 판별

⇒ 대문자 : 문자 ch가 ‘A’(65) 이상이고, 문자 ch가 ‘Z’(90) 이하

if(ch >= 'A' && ch <= 'Z') {
	system.out.println(ch + " : 대문자!");
} else if(ch >= 'a' && ch <= 'z') {
	system.out.println(ch + " : 소문자!");
} else if(ch >= '0' && ch <= '9') {
	system.out.println(ch + " : 숫자!");
} else {
	system.out.println(ch + " : 기타문자!");

Character 클래스의 isXXX() 메서드를 활용하여 각 판별을 대체하고 toXXX() 메서드를 활용하여 변환을 수행

ch = 'r';
if(Character.isUpperCase(ch)) {
	System.out.println(ch + " : 대문자!");
	
	//대문자 -> 소문자 변환
	//ch += 32;
	//System.out.println("소문자로 변환한 결과 : " + ch);

	System.out.println("소문자로 변환 한 결과 : " + Character.toLowerCase(ch));
} else if(Character.isLowerCase(ch)) {
	System.out.println(ch + " : 소문자!");
	System.out.println("대문자로 변환 한 결과 : " + Character.toUpperCase(ch));
} else if(Character.isDigit(ch)) {
	System.out.println(ch + " : 숫자!");

} else if(Character.isWhiteSpace(ch)) {
	System.out.println(ch + " : 공백문자!");
} else {
	System.out.println(ch + " : 기타문자!");
}

Character.isSpace(ch)는 사용하지 않는다.

💡 char 타입 배열 chArr에 'A' 'b' '5' '공백' '#' 문자 5개를 저장 반복문을 활용하여 각 각의 문자에 대한 판별 수행하여 결과 출력 (대문자, 소문자, 숫자, 기타문자)

1.chArr 배열 선언 초기화

2.for문을 통해 if문을 통해 결과를 출력

char chArr[]= {'A','b','5','\\0','#'};

for (int i = 0; i < chArr.length; i++) {
			if (Character.isUpperCase(chArr[i])) {
				System.out.println(chArr[i] + " : 대문자!");
			} else if (Character.isLowerCase(chArr[i])) {
				System.out.println(chArr[i] + "  : 소문자!");
			} else if (Character.isWhitespace(chArr[i])) {
				System.out.println(chArr[i] + " : 공백!");
			} else {
				System.out.println(chArr[i] + " : 기타문자!");
			}
		}

💡 문자열을 char[] 배열에 분리하여 저장 후 해당 문자열에 대한 간단한 암호화 작업

-문자열을 분리하여 저장한 배열을 encrypt()에 전달

-전달 받은 배열의 문자에 대해 아스키코드 값 3 만큼 증가한 문자를 별도의 배열에 저장 한 후 문자열로 변환하여 리턴

ex) ‘A’ (65) ⇒ ‘D’ (68)

ex) “Hello” ⇒ ‘H’, ‘e’, ‘l’, ‘l’, ‘o’ 형태로 배열에 저장 됨

암호화 작업 결과물 : ‘K’, ‘h’, ‘o’, ‘o’, ‘r’

리턴 되는 데이터 : “Khoor”

String 타입 문자열을 char 타입 배열로 변환 : toCharArray() 사용

💡 enrypt() 메서드 암호화 작업 수행 전달받은 배열 내의 모든 문자 값을 +3, 새 배열에 저장 후 문자열로 결합해서 리턴 전달받은 배열의 크기를 새 배열의 크기로 지정 Hint) new 키워드를 사용, 배열의 크기는 기존 배열의 개수

package wrapper_class;

import java.util.Arrays;

public class Test5 {

	public static void main(String[] args) {
		

		String str = "jeoniee";
		char[] chArr = str.toCharArray();
		
		String encryptResult = encrypt(chArr);
		
		System.out.println("암호화 전 : " + Arrays.toString(chArr));
		System.out.println("암호화 후 : " + encryptResult);
	}

//enrypt() 메서드
	public static String encrypt(char[] chArr) {
		// 암호화 작업 수행
		// 전달받은 배열 내의 모든 문자 값을 +3, 새 배열에 저장 후 문자열로 결합해서 리턴
		// 전달받은 배열의 크기를 새 배열의 크기로 지정
		// Hint) new 키워드를 사용, 배열의 크기는 기존 배열의 개수
		char[] enryptedArr = new char[chArr.length];

		for (int i = 0; i < chArr.length; i++) {
			// 각 배열의 문자 + 3 하는 결과를 새 배열에 저장
			enryptedArr[i] = (char) (chArr[i] + 3);
		}
		return Arrays.toString(enryptedArr);
				
	}

-------------------------------------------

암호화 전 : [j, e, o, n, i, e, e]
암호화 후 : [m, h, r, q, l, h, h]

1. String 생성자

문자형태로 나오게 하기*

//1. String 생성자 
//문자형태로 나오게 하기 
		String str = new String(enryptedArr);
		return str;

------------------------------------------

암호화 전 : [j, e, o, n, i, e, e]
암호화 후 : mhrqlhh

2. String.valueOf();

//2. String.valueOf();
		String str = String.valueOf(enryptedArr);
		return str;

3. StringBuilder 사용

StringBuilder buffer = new StringBuilder();
for(char ch : enryptedArr) {
	buffer.append(ch);
}
String encryptedStr = buffer.toString();
return encryptedStr;

Math_class

java.lang.Math 클래스

수학적인 다양한 기능을 상수와 메서드로 제공

모든 상수와 메서드는 클래스명만으로 접근 가능

ex) Math.PI , Math.random()

int num = -10;
		
System.out.println("num의 절대값 : " + Math.abs(num));
System.out.println("num과 20 중 큰 값 : " + Math.max(num, 20));
System.out.println("num과 20 중 작은 값 : " + Math.min(num, 20));
System.out.println("4의 제곱근 : " + Math.sqrt(4));

double dNum = 3.141592;
System.out.println(Math.ceil(dNum)); //소수점 첫째자리 올림
System.out.println(Math.floor(dNum)); //소수점 첫째자리 버림 
System.out.println(Math.round(dNum)); //소수점 첫째자리 반올림 (정수 리턴)

round() 메서드는 항상 소수점 첫째자리에서 반올림이 수행되는데 x번째 자리 반올림을 수행하기 위해서는 반올림할 숫자를 소수점 첫째자리에 위치하도록 변형 해야 한다.

Math.random()

난수(임의의 수)발생을 위한 메서드

0.0 <= x<1.0 범위의 double 타입 난수 발생

< 난수 발생 기본 공식 >

(정수화)(Math.random() * 상한값) : 0 ~ 상한값 - 1(0<=x<상한값)
(정수화)(Math.randon() * 상한값) + 1 : 1 ~ 상한값 (1<=x<=상한값)

for(int i = 1; i<=10; i++) {
	System.out.println(Math.random()); //0.0 <= x < 1.0

	//정수 1자리 범위 (0~9) 난수 발생시키기 위해서는
	//소수점 첫째자리 숫자를 정수 위치로 이동시키고
	//남은 소수점 이하 숫자들은 제거를 위해 정수화
	System.out.println((int)(Math.random()*10)); // 0<= x < 10

	//만약, 0을 제외하고 1부터 특정 상한값까지 난수 발생을 위해서는
	//난수 발생 결과에 +1 수행
	System.out.println((int)(Math.random()*10)+1);
	// 1<= x < 11 또는 1 <= x <= 10 (즉, 1~10 사이의 난수)

	System.out.println("-------------------------------------------");
	//연습) 1~20 사이의 난수 발생
	for(int j = 1; j<=20; j++){
		System.out.println((int)(Math.random()*10));
	}

728x90

저작자표시 (새창열림)

'BackEnd > Java' 카테고리의 다른 글

1024 JAVA - java.util.Random (0)	2022.10.24
1020 JAVA - Exception ~ java_util_package (0)	2022.10.20
1013 JAVA - String 객체 (문자열) (0)	2022.10.13
1013 JAVA - 오브젝트 클래스 Object Class (equals 메서드) (0)	2022.10.13
1012 JAVA - Interface 인터페이스 - 문제 (0)	2022.10.12

archive

1017,19 JAVA - String 메서드

String.format() 메서드

toCharArray() : 문자열을 char[] 배열로 리턴

Arrays.toString() : 배열 내의 모든 데이터를 문자열로 결합하여 리턴

subString() 메서드 활용

split() 메서드 활용

StringBuffer , StringBuilder

Wrapper_class

오토 박싱(Auto Boxing)

오토 언박싱(Auto Unboxing)

Wrapper 클래스의 다양한 메서드

Character 클래스를 활용한 문자 데이터 처리

Math_class

Math.random()

'BackEnd > Java' 카테고리의 다른 글

티스토리툴바

1017,19 JAVA - String 메서드

String.format() 메서드

toCharArray() : 문자열을 char[] 배열로 리턴

Arrays.toString() : 배열 내의 모든 데이터를 문자열로 결합하여 리턴

subString() 메서드 활용

split() 메서드 활용

StringBuffer , StringBuilder

Wrapper_class

오토 박싱(Auto Boxing)

오토 언박싱(Auto Unboxing)

Wrapper 클래스의 다양한 메서드

Character 클래스를 활용한 문자 데이터 처리

Math_class

Math.random()

'BackEnd > Java' 카테고리의 다른 글

'BackEnd/Java' Related Articles

티스토리툴바