[JAVA]배열 (Array)

package com.example.demo;

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class ArraysApplication {
    /*
    * 1. 배열이란?
    * 동일한 자료형(Data Type)의 데이터를 연속된 공간에 저장하기 위한 자료구조이다.
    * 즉, 연관된 데이터를 그룹화하여 묶어준다고 생각하면 된다.
    *
    * 2. 배열의 장점
    * 연관된 데이터를 저장하기 위한 변수의 선언을 줄여주며, 
    * 반복문 등을 이용하여 계산과 같은 일련의 과정을 쉽게 처리할 수 있다.
    * */
    public static void main(String[] args){
        System.out.println("ArraysApplication Start");
        ArraysApplication application = new ArraysApplication();

        // 3. 배열의 선언 및 사용
        //application.arrayDeclaration();

        // 4. Arrays APIs
        application.arrayApi(new int[]{1,2,5,4,3});

        // 5. Arrays 정렬하기
        application.arraySorting();

    }

    public void arrayDeclaration(){
        /*
         * 3. 배열의 선언 및 사용
         * 3-1. 선언과 동시에 초기화도 함께 수행하는 방법: 
         * 		데이터들의 값을 미리 알고 있을 때 사용하면 편리함
         * */
        int[] numberArray = {1, 2, 3, 4, 5};
        System.out.println("3. 배열의 선언 및 사용 >>> " + Arrays.toString(numberArray));

        /*
         * 3-2. 배열의 크기만 지정하여 변수 선언 후 
         *		-> 향후 인덱스값으로 접근하여 데이터 값 저장
         *      -> 사용자로부터 배열 값을 입력받을때 사용할 수 있는 방법이다.
         * */
        int[] numberArray2 = new int[5];

        System.out.println("5개의 정수를 입력하시오.");
        Scanner sc = new Scanner(System.in);
        for(int i = 0; i < numberArray2.length; i++){
            numberArray2[i] = sc.nextInt();
        }
        System.out.println("3. 배열의 선언 및 사용 >>> " + Arrays.toString(numberArray2));
    }

    public void arrayApi(int[] numberArrays){

        /*
        * 4-1. binarySearch(배열, 찾는값) : 찾는 값에 일치하는 인덱스를 리턴한다.
        *          -> binarySearch는 정렬된 배열에서 찾고 싶은 값의 인덱스를 리턴해주기 때문에
        *             배열이 정렬되지 않았거나, 찾는 값이 없다면 음수를 출력한다.
        * */
        int[] array = {1, 2, 3, 4, 5};
        System.out.println("4-1. binarySearch >>> " + Arrays.binarySearch(array, 3));

        /*
        * 4-2. 배열 복사
        *   - copyOf(원본배열, 복사할 길이) : 원본배열의 인덱스 0에서부터 복사할 길이만큼 복사된 배열 리턴
        *   - copyOfRange(원본배열, 시작, 끝) : 시작 인덱스부터 끝 인덱스까지의 값을 복사한 배열 리턴
        * */
        int[] copiedArray = Arrays.copyOf(numberArrays, 3);
        System.out.println("4-2. copyOf >>> " + Arrays.toString(copiedArray));

        int[] copiedArray2 = Arrays.copyOfRange(numberArrays, 2, 4);
        System.out.println("4-2. copyOfRange >>> " + Arrays.toString(copiedArray2));

        /*
        * 4-3. 배열 비교
        *   - equals(배열, 배열) : 두 배열의 얕은 비교
        *   - deepEquals(배열, 배열) : 중첩배열의 비교
        * */
        System.out.println("4-3. equals >>> " + Arrays.equals(numberArrays, copiedArray));

        /*
         * 4-4. 배열 값 채우기
         *   - fill(배열, [시작, 끝], 값) : 배열의 시작부터 끝까지 동일한 값으로 채울 수 있는 메서드
         * */
        copiedArray = Arrays.copyOf(numberArrays, numberArrays.length);
        Arrays.fill(copiedArray, 0);
        System.out.println("4-4. fill >>> " + Arrays.toString(copiedArray));

        copiedArray = Arrays.copyOf(numberArrays, numberArrays.length);
        Arrays.fill(copiedArray, 0, 2, 0);
        System.out.println("4-4. fill >>> " + Arrays.toString(copiedArray));
    }

    public void arraySorting(){
        /*
         * 5-1. 배열 정렬
         *   - sort(배열) : 배열의 전체 항목을 오름차순으로 정렬
         *      배열 타입이 클래스일 경우 
         *   -> Comparable 인터페이스를 구현한 클래스가 있으면 된다. (compareTo 메서드 정의)
         * */
        int[] numberArray = {1, 2, 3, 4, 5};
        Arrays.sort(numberArray);
        System.out.println("5-1. sort >>> " + Arrays.toString(numberArray));

        /*
        * 5-2. Comparable
        *      Comparable 은 객체 간의 정렬에 있어서 
        *	   오름차순, 내림차순등의 일반적인 순서를 잡는 기준이 필요할 때 
        *      객체 클래스에 확장해서 사용한다.
        * */
        User[] users = {new User("Jayce", 30), new User("Hailey", 20), new User("Amy", 22)};
        Arrays.sort(users);
        System.out.println("5-2. Comparable >>> " );
        for(User user : users) {
            System.out.println(user.getName());
        }

        /*
        * 5-3. Comparator
        *      Comparator 는 일반적이지 않은 문자열의 길이 순으로 보고 싶다든지,
        *      Comparable 로 구현한 것 말고 다른 기준으로 정렬하고 싶다든지 할 때 사용한다.
        * */
        User[] users2 = {new User("Jayce", 30), new User("Hailey", 20), new User("Amy", 22)};
        Comparator<User> userComparator = new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                return o1.getAge() - o2.getAge();
            }
        };
        Arrays.sort(users2, userComparator);
        System.out.println("5-3. Comparator >>> " );
        for(User user : users2) {
            System.out.println(user.getName());
        }
    }
}

class User implements Comparable<User>{
    private String name;
    private int age;

    public User (){}

    public User(String name, int age){
        this.name = name;
        this.age = age;
    }

    public String getName(){
        return this.name;
    }

    public int getAge(){
        return this.age;
    }

    @Override
    public int compareTo(User o) {
        /*
         * compareTo는 int 타입을 반환하며, 파라미터로 비교대상이 되는 객체가 들어온다.
         * A.compareTo(B) 일 때 A<B 인 경우는 음수를 리턴하고, A=B일 때는 0을 리턴하고, A>B일 때 양수를 리턴
         *  -> 정렬에 있어서 앞에 오고 싶을 때 음수를 내보내면 된다
         */
        return this.name.compareTo(o.name); // 이름으로 정렬
        //return this.age - o.age; // 나이순으로 정렬
    }
}