자바 새로 알게된 것들2

- 배열의 내림차순 정렬

+ int[] -> Integer[]로의 변환

int[] 는 객체가 아닌 primitive type 이기 때문에 Integer[] 로 변환 후 사용해야 한다.

import java.util.Arrays;
import java.util.Collections;

public class SortExample {
	
	public static void main(String[] args) {
		int[] arr1 = {10, 30, 20, 50, 40};
		String[] arr2 = {"가", "다", "나", "마", "라"};
		
		//내림차순 정렬(DESC)
		System.out.println("내림차순 정렬 결과");
		//int -> integer
		Integer[] arr3 = Arrays.stream(arr1).boxed().toArray(Integer[]::new);
		Arrays.sort(arr3, Collections.reverseOrder());
		//String 타입
		Arrays.sort(arr2, Collections.reverseOrder());
		for(int desc : arr3) {
			System.out.print(desc + " ");
		}
		System.out.println("");
		for(String desc : arr2) {
			System.out.print(desc + " ");
		}
		
	}
}

+++ Integer[] 배열 없이 내림int[] 내림차순 정렬

int[] a = {1,2,3,4,5,6};
 
a = Arrays.stream(a).boxed().sorted(Collections.reverseOrder()).mapToInt(Integer::intValue).toArray();
 
// a = {6,5,4,3,2,1}

새로운 방법을 알게돼서 추가한다!!!

- int를 자릿수별 int 배열로 분할하기

import java.util.Arrays;
import java.util.stream.Stream;
public class MyClass {
    public static void main(String args[]) {
        int number = 12345;
        int[] digits = Stream.of(String.valueOf(number).split("")).mapToInt(Integer::parseInt).toArray();
        System.out.print( Arrays.toString(digits) ); // [1, 2, 3, 4, 5]
    }
}

import java.util.Arrays;
public class MyClass {
    public static void main(String args[]) {
        int number = 12345;
        String temp = Integer.toString(number);
        int[] digits = new int[temp.length()];
        for (int i = 0; i < temp.length(); i++) digits[i] = temp.charAt(i) - '0';
        System.out.print( Arrays.toString(digits) ); // [1, 2, 3, 4, 5]
    }
}

내가 더 친근한 방법은 아래의 방식인데....뭔가 위의 방식이 세련돼보인다.

- String + int = String

String 타입과 숫자를 더하면 String 타입으로 변해서 Integer.toString 과 같은 효과를 낸다!

- StringBuilder

• StringBuilder sb = new StringBuilder(): 객체 선언
• StringBuilder sb = new StringBuilder("aaa"): 문자열을 바로 넣을 수도 있다.

import java.lang.StringBuilder;

public class sb {
    public static void main(String[] args) throws IOException{
        StringBuilder sb = new StringBuilder("aaa");

        // 문자열 추가
        System.out.println(sb.append("bbb")); // aaabbb
        System.out.println(sb.append(4)); // aaabbb4

        // 문자열 삽입
        System.out.println(sb.insert(2, "ccc")); // aacccabbb4
        
        // 문자열 치환, 문자열 교체
        System.out.println(sb.replace(3, 6, "ye")); // aacyebbb4

        // 인덱싱, 문자열 자르기
        System.out.println(sb.substring(5)); // bbb4
        System.out.println(sb.substring(3, 7)); // yebb

        // 문자 삭제
        System.out.println(sb.deleteCharAt(3)); // aacebbb4

        // 문자열 삭제
        System.out.println(sb.delete(3, sb.length())); // aac

        // 문자열 변환
        System.out.println(sb.toString()); // aac

        // 문자열 뒤집기
        System.out.println(sb.reverse()); // caa

        // 문자 대체, 문자 교체, 문자 치환
        sb.setCharAt(1, 'b');
        System.out.println(sb); // cba

        // 문자열 길이 조정
        sb.setLength(2);
        System.out.println(sb); // cb
    }
}

- 배열을 List로 변환하기

1. Arrays.asList(배열);

2. Stream.of(배열).collect(Collectors.toList());

- List를 배열로 변환하기

toArray()

import java.util.ArrayList;
import java.util.Arrays; 
public class ArrayListConversion {   
	public static void main(String[] args) {  
    // ArrayList 준비 
    ArrayList<String> arrList = new ArrayList<String>();
    arrList.add("A");
    arrList.add("B");
    arrList.add("C");
    // ArrayList를 배열로 변환
    int arrListSize = arrList.size();
    String arr[] = arrList.toArray(new String[arrListSize]);
    // 변환된 배열 출력
    System.out.println(Arrays.toString(arr));    
    }
 }
 
 [A, B, C]

- List<Integer> 리스트를 int[] 배열로 바꾸기

public static void main(String args[]) {
    List<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(2);
    list.add(3);
    
    // 방법 1
    int[] arr1 = new int[list.size()]
    for (int i = 0 ; i < list.size() ; i++) {
        arr1[i] = list.get(i).intValue();
    
    // 방법 2
    int[] arr2 = list.stream()
                .mapToInt(i -> i)
                .toArray();
    
    // 방법 3
    int[] arr3 = list.stream()
                .mapToInt(Integer::intValue)
                .toArray();

    // 방법 4
    int[] arr4 = list.stream()
                .filter(i -> i != null)
                .mapToInt(i -> i)
                .toArray();
}

mapToInt 메소드를 사용한다!

- 배열의 인덱스의 요소 지우기

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
 
class Main
{
    public static int[] remove(int[] a, int index)
    {
        if (a == null || index < 0 || index >= a.length) {
            return a;
        }
 
        List<Integer> result = IntStream.of(a)    // IntStream
                                        .boxed()
                                        .collect(Collectors.toList());
        result.remove(index);
 
        return result.stream()
                    .mapToInt(Integer::intValue)
                    .toArray();
    }
 
    public static void main(String[] args)
    {
        int[] a = { 1, 2, 3, 4, 5 };
        int index = 2;
 
        a = remove(a, index);
        System.out.println(Arrays.toString(a));
    }
}

이런 코드도 있다.

public static void main(String[] args) {
 
 int list_size = 5; // 배열 사이즈
 int[] list = new int[list_size]; // 배열의 크기가 5인 배열을 생성
 int count = 0; // 배열 원소가 이동할 때 마다 count
 
 for(int j = 0; j < 5; j++) { 
  list[j] = j+1; // 인덱스가 i일 때 배열 값은 i+1을 넣는다.
 }
 
 for(int i = 1; i < list.length-1; i++) { // 우리가 삭제하고 싶은 인덱스 값부터 마지막 인덱스까지 반복문을 돌린다.
  list[i] = list[i+1];  // 인덱스 i+1의 값을 인덱스 i로 이동
  count++;  // 이동할 때마다 count 증가
 }