Type Casting
1. 기본 타입 간 형 변환
정수형 -> 실수형 변환
정수형을 실수형으로 변환:
java코드 복사int i = 10;
double d = (double) i; // 정수형(int)을 실수형(double)으로 변환실수형 -> 정수형 변환
실수형을 정수형으로 변환 (소수점 이하 값 제거):
java코드 복사double d = 10.5;
int i = (int) d; // 실수형(double)을 정수형(int)으로 변환 (소수점 이하 값 제거)2. 문자열 <-> 숫자 형 변환
문자열 -> 숫자형 변환
문자열을 정수형으로 변환 (
Integer.parseInt()):
java코드 복사String str = "123";
int num = Integer.parseInt(str); // 문자열을 정수형(int)으로 변환문자열을 실수형으로 변환 (
Double.parseDouble()):
java코드 복사String str = "123.45";
double num = Double.parseDouble(str); // 문자열을 실수형(double)으로 변환숫자형 -> 문자열 변환
숫자를 문자열로 변환 (
String.valueOf()):
java코드 복사int num = 123;
String str = String.valueOf(num); // 정수형(int)을 문자열(String)로 변환3. 문자 <-> 숫자 변환
문자 -> 정수형 변환 (아스키 값)
문자를 정수형(아스키 값)으로 변환:
java코드 복사char c = 'A';
int ascii = (int) c; // 'A'의 아스키 값을 정수형으로 변환정수형 -> 문자 변환
정수형을 문자로 변환 (아스키 값 사용):
java코드 복사int ascii = 65;
char c = (char) ascii; // 정수형을 아스키 값에 대응하는 문자로 변환 ('A')4. 객체 타입 간 형 변환 (캐스팅)
다운 캐스팅
상위 클래스 객체를 하위 클래스 객체로 변환:
java코드 복사class Animal {}
class Dog extends Animal {}
Animal animal = new Dog(); // 업캐스팅 (Animal 타입으로 Dog 저장)
Dog dog = (Dog) animal; // 다운캐스팅 (Animal을 Dog로 변환)업 캐스팅
하위 클래스 객체를 상위 클래스 타입으로 변환:
java코드 복사Dog dog = new Dog();
Animal animal = dog; // 업캐스팅 (Dog를 Animal로 변환)5. 배열 타입 변환
기본 타입 배열 -> 래퍼 클래스 배열 변환
기본 타입 배열을 래퍼 클래스 배열로 변환:
java코드 복사int[] intArray = {1, 2, 3};
Integer[] integerArray = Arrays.stream(intArray).boxed().toArray(Integer[]::new); // int[] -> Integer[]래퍼 클래스 배열 -> 기본 타입 배열 변환
래퍼 클래스 배열을 기본 타입 배열로 변환:
java코드 복사Integer[] integerArray = {1, 2, 3};
int[] intArray = Arrays.stream(integerArray).mapToInt(Integer::intValue).toArray(); // Integer[] -> int[]6. 컬렉션 타입 변환
리스트 -> 배열 변환
리스트를 배열로 변환 (
toArray()):
java코드 복사List<String> list = Arrays.asList("apple", "banana", "cherry");
String[] array = list.toArray(new String[0]); // List -> 배열배열 -> 리스트 변환
배열을 리스트로 변환 (
Arrays.asList()):
java코드 복사String[] array = {"apple", "banana", "cherry"};
List<String> list = Arrays.asList(array); // 배열 -> List7. 자동 박싱 및 언박싱
정수형 -> 래퍼 클래스 변환 (자동 박싱)
기본 타입을 래퍼 클래스로 자동 변환:
java코드 복사int num = 10;
Integer wrappedNum = num; // 자동 박싱 (int -> Integer)래퍼 클래스 -> 정수형 변환 (자동 언박싱)
래퍼 클래스를 기본 타입으로 자동 변환:
java코드 복사Integer wrappedNum = 10;
int num = wrappedNum; // 자동 언박싱 (Integer -> int)8. 비트 단위 형 변환
정수 -> 비트 문자열 변환
정수를 비트 문자열로 변환 (
Integer.toBinaryString()):
java코드 복사int num = 10;
String binary = Integer.toBinaryString(num); // 10 -> "1010"비트 문자열 -> 정수 변환
비트 문자열을 정수로 변환 (
Integer.parseInt()):
java코드 복사String binary = "1010";
int num = Integer.parseInt(binary, 2); // "1010" -> 10import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Main
{
public static void main(String[] args)
{
// Type Casting in Java
// 1. Implicit Type Casting
// 2. Explicit Type Casting
// Implicit Type Casting
// byte -> short -> int -> long -> float -> double
// char -> int
// boolean -> No implicit type casting
// byte -> short
byte byteValue = 10;
short shortValue = byteValue;
System.out.println("Short Value: " + shortValue);
// short -> int
short shortValue2 = 100;
int intValue = shortValue2;
System.out.println("Int Value: " + intValue);
// int -> long
int intValue2 = 1000;
long longValue = intValue2;
System.out.println("Long Value: " + longValue);
// long -> float
long longValue2 = 10000;
float floatValue = longValue2;
System.out.println("Float Value: " + floatValue);
// float -> double
float floatValue2 = 100000;
double doubleValue = floatValue2;
System.out.println("Double Value: " + doubleValue);
// char -> int
char charValue = 'A';
int intValue3 = charValue;
System.out.println("Int Value: " + intValue3); // ASCII Value of 'A' is 65
// Explicit Type Casting
// double -> float -> long -> int -> short -> byte
// int -> char
// boolean -> No explicit type casting
// double -> float
double doubleValue2 = 100.04;
float floatValue3 = (float) doubleValue2;
System.out.println("Float Value: " + floatValue3);
// float -> long
float floatValue4 = 100.04f;
long longValue3 = (long) floatValue4;
System.out.println("Long Value: " + longValue3);
// long -> int
long longValue4 = 1000;
int intValue4 = (int) longValue4;
System.out.println("Int Value: " + intValue4);
// int -> short
int intValue5 = 100;
short shortValue3 = (short) intValue5;
System.out.println("Short Value: " + shortValue3);
// short -> byte
short shortValue4 = 10;
byte byteValue2 = (byte) shortValue4;
System.out.println("Byte Value: " + byteValue2);
// int -> char
int intValue6 = 65;
char charValue2 = (char) intValue6;
System.out.println("Char Value: " + charValue2); // ASCII Value of 65 is 'A'
// boolean -> int
boolean booleanValue = true;
// int intValue7 = (int) booleanValue; // Compile Time Error
// int -> boolean
int intValue8 = 1;
boolean booleanValue2 = intValue8 > 0;
System.out.println("Boolean Value: " + booleanValue2);
// int -> boolean
int intValue9 = 0;
boolean booleanValue3 = intValue9 > 0;
System.out.println("Boolean Value: " + booleanValue3);
}
}import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Main
{
public static void main(String[] args)
{
// Type Casting in Java
// List to Array
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
Integer[] array = list.toArray(new Integer[0]);
for (Integer i : array)
{
System.out.println(i);
}
// Array to List
List<Integer> list2 = new ArrayList<>();
Collections.addAll(list2, array);
for (Integer i : list2)
{
System.out.println(i);
}
// Integer to String
Integer integer = 123;
String string = integer.toString();
System.out.println(string);
// String to Integer
String string2 = "123";
Integer integer2 = Integer.parseInt(string2);
System.out.println(integer2);
// Integer to Double
Integer integer3 = 123;
Double double1 = integer3.doubleValue();
System.out.println(double1);
// Double to Integer
Double double2 = 123.0;
Integer integer4 = double2.intValue();
System.out.println(integer4);
// Integer to int
Integer integer5 = 123;
int int1 = integer5;
System.out.println(int1);
// int to Integer
int int2 = 123;
Integer integer6 = int2;
System.out.println(integer6);
// String to char
String string3 = "abc";
char char1 = string3.charAt(0);
System.out.println(char1);
// char to String
char char2 = 'a';
String string4 = String.valueOf(char2);
System.out.println(string4);
// String to int
String string5 = "123";
int int3 = Integer.parseInt(string5);
System.out.println(int3);
// int to String
int int4 = 123;
String string6 = String.valueOf(int4);
System.out.println(string6);
// String to CharArr
String str = "Soobin";
char[] c = new char[str.length()];
for (int i = 0; i < str.length(); i++)
{
c[i] = str.charAt(i);
System.out.println(c[i]);
}
String str2 = "soobin";
char[] arr = str2.toCharArray();
for (char value : arr) {
System.out.println(value);
}
}
}Integer -> int
Integer a = new Integer(10);
int i = a.intValue();
// 혹은
Integer a = new Integer(10);
int k = Integer.parseInt(a.toString());String Array -> char Array
1. charAt() + for() {}
String s = "sk kinghts";
char[] arr = new char[s.length()];
for (int i = 0; i < s.length(); i++) {
arr[i] = s.charAt(i);
}공백도 포함된다.
2. toCharArray()
String s = "sk kinghts";
char[] arr = s.toCharArray();
for (char c : arr) {
System.out.println(c);
}char Array -> String Array
1. valueOf()
char[] arrCh = {'s', 'k', 'k', 'i'};
String[] arrStr = new String[arr.length];
for (int i = 0; i < arrCh.length; i++) {
arrStr[i] = String.valueOf(arrCh.charAt(i));
}char[] arrCh = {'s', 'k', 'k', 'i'};
String str = String.valueOf(arrCh);2. toString()
char[] arrCh = {'s', 'k', 'k', 'i'};
String[] arrStr = new String[arr.length];
for (int i = 0; i < arrCh.length; i++) {
arrStr[i] = Character.toString(arrCh.charAt(i));
}Character.toString() 사용 시 char[] 배열은 반환이 불가능하다.
char[] arrCh = {'s', 'k', 'k', 'i'};
Character.toString(arrCh); // xxx3. "" 이용하기
내가 좋아하는 방법
근데 속도는 valueOf()이 더 빠르다.
char c = 's';
String str = ch + "";Array는 arr[idx]로 접근하고, String은 str.charAt(idx)로 접근한다.
String array -> Int array
import java.util.Arrays;
import java.util.stream.Stream;
public class Main
{
public static void main(String[] args) {
String[] strings = { "1", "2", "3", "4", "5"};
int[] values = Stream.of(strings)
.mapToInt(Integer::parseInt)
.toArray();
System.out.println(Arrays.toString(values));
}
}
import java.util.Arrays;
public class Main
{
public static void main(String[] args) {
String[] strings = { "1", "2", "3", "4", "5"};
Integer[] values = Arrays.stream(strings)
.map(Integer::parseInt)
.toArray(Integer[]::new);
System.out.println(Arrays.toString(values));
}
}문자형 -> 숫자형
Integer.valueOf(str);
Double.valueOf(str);
Float.valueOf(str);
Integer.parseInt(str);
Long.parseLong(str);
Short.parseShort(str);숫자형 -> 문자형
String.valueOf(num);
Integer.toString(num);
Float.toString(num);
Double.toString(num);정수형 <-> 실수형
(int)number
(double)number
(float)numberArray -> List
(Reference Type) Array -> List
// 1
Arrays.asList(arr);
// 2
new ArrayList<>(Arrays.asList(arr));
// 3
Stream.of(arr).collect(Coolectors.toList());(Primitive Type) Array -> List
// 1
int[] arr = new int[10];
List<Integer> intList = new ArrayList<>();
for (int e : arr) {
intList.add(e);
}
// 2
List<Integer> intList = Arrays.stream(arr)
.boxed()
.collect(Collectors.toList());List -> Array
arrList.toArray(new String[arrList.size()]);Last updated