Profile

Casting

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
        // 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);

    }
}

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); // xxx

3. "" 이용하기

  • 내가 좋아하는 방법

    • 근데 속도는 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)number

Array -> 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()]);

PreviousListNextStack/Queue

Last updated