무언가 작업을 할 때, 적절한 도구가 있다는 건 참 감사한 일이다.

프로그램을 만들 때도 마찬가지다. 프로그램을 만들기 위해 제공되는 적절한 도구. 자바 API에 대해 알아보자.
자바 API
패키지
자바 API 사용 예

Java api

자바 API란, 프로그램을 만들기 위한 도구이다. 이를 사용하면 더 편리한 프로그래밍이 가능하다. 자바 API는 패키지로 제공된다.

Package

package >> 패키지란 일종의 디렉터리(폴더)이다. 자바 API는 이곳에 담겨 제공된다.

for what >> 패키지는 관련 코드를 하나로 묶어, 관리를 수월하게 한다.

또 같은 이름의 코드를 다른 패키지로 나누어, 분류하기도 한다.

Example of java api

math class

// 불러오기
import java.lang.Math;
// 사용 예
double r = Math.random(); // 0.0 <= r < 1
double a = Math.abs(-9.81); // 9.81
double greater = Math.max( 3.14, 12.7); // 12.7
double smaller = Math.min(3.14, 12.7); // 3.14

random class

// 불러오기
import java.util.Random;
// 사용 예
Random rand = new Random(); // 객체 생성
int a = rand.nextInt(10); // 0 <= a < 10
double b = rand.nextDouble(); // 0.0 <= b < 1.0
boolean c = rand.nextBoolean(); // true or false

arraylist class

// 불러오기
import java.util.ArrayList;
// 사용 예
ArrayList<String> names = new ArrayList<String>();
names.add("Kim"); // names -> {"Kim"}
names.add("Lee"); // names -> {"Kim", "Lee"}
names.add("Park"); //  names -> {"Kim", "Lee", "Park"}
System.out.println(names.get(2)); // "Park"
names.remove(1); // names -> {"Kim", "Park"}
System.out.println(names.size()); // 2

1) get java api-random

import random class >> 자바 API를 사용하기 위해서는 먼저 해당 클래스를 가져와야 합니다. 이때 import 키워드를 사용합니다.

// java.util 패키지의 Random 클래스를 불러옴
import java.util.Random;

make random object >> Random 클래스로 객체를 만들면, 다양한 난수 생성이 가능합니다.

Random random = new Random(); // 객체 생성

make random number >> 임의의 정수 및 실수 또는 참/거짓 값을 만들 수 있습니다.

// 0 이상 N 미만인 임의의 정수
int N = 10;
int randInt = random.nextInt(N); // 0, 1, 2, ..., 9 중 택 1
// 0.0 이상 1.0 미만의 임의의 실수
double randDouble = random.nextDouble();
// 임의의 참 또는 거짓
boolean randBoolean = random.nextBoolean();

더 자세한 내용은 자바 API 문서를 통해 확인할 수 있습니다.
(https://docs.oracle.com/javase/8/docs/api/)
CODE

// 자바 API를 불러옴
import java.lang.Math;
import java.util.Random;
public class RandomTest {
  public static void main(String[] args) {
    // 변수 생성 및 주사위 던지기
    int a = DieA.roll();
    int b = DieB.roll();
    // 결과 출력
    System.out.printf("A: %d\n", a);
    System.out.printf("B: %d\n", b);
  }
}
class DieA {
  // 1 부터 6사이 정수를 반환 [참고] https://cloudstudying.kr/challenges/348
  public static int roll() {
    double r = Math.random() * 6; // 0.0 <= r < 6.0
    int randInt = (int) r;        // 0, 1, 2, ..., 5
    return randInt + 1;           // 1, 2, 3, ..., 6
  }
}
class DieB {
  public static int roll() {
    /* Random 클래스를 활용하여 주사위의 눈값(1 ~ 6)을 반환하시오.*/
    double r = Math.random() * 6;
    int randInt = (int)r;
    return randInt + 1;
  }
}

2) dice statistics

CODE

// 자바 API를 불러옴
import java.lang.Math;
import java.util.Random;
public class RandomTest {
  public static void main(String[] args) {
    // int array
    int[] counts = new int[13]; // 0 ~ 12 index
    // 변수 생성 및 주사위 던지기 >> for
    for (int i = 0; i < 100; i ++){
      int a = DieA.roll();
      int b = DieB.roll();
      counts[(a+b)]++;
    }
    // 결과 출력
    for(int row = 2; row < counts.length; row++){
      System.out.printf("%d => ", row);
      // # print
      for(int col=0;col<counts[row]; col++){
        System.out.printf("#");
      }
      System.out.println();
    }
  }
}
class DieA {
  // 1 부터 6사이 정수를 반환 [참고] https://cloudstudying.kr/challenges/348
  public static int roll() {
    double r = Math.random() * 6; // 0.0 <= r < 6.0
    int randInt = (int) r;        // 0, 1, 2, ..., 5
    return randInt + 1;           // 1, 2, 3, ..., 6
  }
}
class DieB {
  public static int roll() {
    // 1 부터 6사이 정수를 반환 [참고] https://cloudstudying.kr/challenges/404
    Random rand = new Random();
    int randInt = rand.nextInt(6); // (0 ~ 5)
    return randInt + 1;
  }
}

3) arraylist-add(), size()

import arraylist >> ArrayList는 객체를 담기 위한 클래스입니다. 해당 클래스는 java.util 패키지에 존재합니다. 이를 사용하기 위해서는 import를 통해 해당 클래스를 가져와야 합니다.

// ArrayList 불러오기
import java.util.ArrayList;

make object and generic >> ArrayList를 사용하기 위해서는 객체를 만들어야 하는데, 저장할 객체의 타입을 꺾쇠(<>) 안에 적어 주어야 합니다. 이러한 기법을 제네릭(generic)이라고 합니다.

// String 저장을 위한 객체 생성
ArrayList<String> names = new ArrayList<String>();

ArrayList 객체가 만들어지면 객체를 추가하거나, 가져오늘 등의 동작을 할 수 있습니다.

// 객체 추가
names.add("Park");
names.add("Kim");
names.add("Paul");
// 객체 획득
System.out.println(names.get(0)); // Park
System.out.println(names.get(1)); // Kim
System.out.println(names.get(2)); // Pual
// 객체 수 반환
System.out.println(names.size()); // 3

더 자세한 내용은 API 문서를 참조하세요.(https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html)
CODE

/* 1. ArrayList 클래스를 java.util 패키지에서 import 하시오. */
import java.util.ArrayList;
public class ArrayListTest {
  public static void main(String[] args) {
    /* 2. String을 담을 수 있는 리스트 객체를 만드시오. */
    ArrayList<String> names = new ArrayList<String>();
    /* 3. 리스트에 이름을 추가하시오. */
    names.add("Kim");
    names.add("Lee");
    names.add("Park");
    names.add("Choi");
    names.add("Hong");
    names.add("No");
    /* 4. 반복문을 통해 모든 이름을 출력하시오. */
    for (int i = 0; i < names.size(); i++) {
      System.out.printf("names.get(%d) -> %s\n", i, names.get(i));
    }
  }
}

4) arraylist-get()

push what kind of object type in arraylist? >> ArrayList에 객체를 담기 위해서는, 생성 시 담기위한 객체의 타입(클래스 타입)을 명시해야 합니다.

// Employee 객체를 담기 위한 ArrayList 생성
ArrayList<Employee> list = new ArrayList<Employee>();

how to push data? >> 명시된 타입의 객체를 담는 메소드는 add()입니다. 이를 통해 추가된 객체는 ArrayList 제일 뒤쪽에 위치하게 됩니다.

// Employee 객체 생성
Employee emp1 = new Employee();
Employee emp2 = new Employee();
Employee emp3 = new Employee();
// ArrayList에 담기
list.add(emp1); // list -> { emp1 }
list.add(emp2); // list -> { emp1, emp2 }
list.add(emp3); // list -> { emp1, emp2, emp3 }

더 자세한 내용은 API 문서를 참조하세요.
https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html
CODE

import java.util.ArrayList;
public class BookTest {
  public static void main(String[] args) {
    /* 1. Book을 담기 위한 ArrayList 객체를 만드시오. */
    ArrayList<Book> list = new ArrayList<Book>();
    /* 2. Book 객체를 생성하시오. */
    Book onePiece = new Book("원피스", 4500);
    Book naruto = new Book("나루토", 4000);
    Book java = new Book("자바 프로그래밍", 24000);
    /* 3. ArrayList 객체에 Book 객체들을 담으시오. */
    list.add(onePiece); // 원피스 객체 담기
    list.add(naruto);   // 나루토 객체 담기
    list.add(java);     // 자바 객체 담기
    /* 4. 리스트에 담긴 모든 책 정보 출력 */
    for (int i = 0; i < list.size(); i++) {
      Book book = list.get(i);
      System.out.printf("list.get(%d) -> %s\n", i, book.toString());
}
  }
}
class Book {
  // 필드
  private String title;
  private int price;
  // 생성자
  public Book(String title, int price) {
    this.title = title;
    this.price = price;
  }
  // 메소드
  public String toString() {
    return String.format("Book { name: %s, price: %d }", this.title, this.price);
  }
}

5) arraylist-set()

set element >> set(int index, E element) 메소드는, index 위치 요소를 element로 변경합니다.

ArrayList<String> names = new ArrayList<String>(); // names -> {}
names.add("Kim"); // names -> { "Kim" }
names.add("Lee"); // names -> { "Kim", "Lee" }
names.add("Choi"); // names -> { "Kim", "Lee", "Choi" }
// 0번째 요소를 "Park"으로 변경: "Kim" => "Park"
names.set(0, "Park"); // names -> { "Park", "Lee", "Choi" }

CODE

import java.util.ArrayList;
public class MonsterTest {
  public static void main(String[] args) {
    // Monster 객체를 저장할 ArrayList 생성
    ArrayList<Monster> list = new ArrayList<Monster>();
    // Monster 객체 생성
    Monster slime = new Monster("슬라임", 1);
    Monster orc = new Monster("오크", 3);
    Monster golem = new Monster("골렘", 8);
    // ArrayList에 객체 담기
    list.add(slime);
    list.add(orc);
    list.add(golem);
    // 전체 출력
    System.out.println("=== 변경 전 ===");
    for (int i = 0; i < list.size(); i++) {
      Monster m = list.get(i); // i번째 요소 반환
      System.out.println(m.toString());
    }
    /* 1. 레벨 1의 토끼 객체를 생성하세요. */
    Monster rabbit = new Monster("토끼", 1);
    /* 2. ArrayList의 첫 요소인 슬라임을 토끼로 변경하세요. */
    list.set(0, rabbit);
    // 전체 출력
    System.out.println("=== 변경 후 ===");
    for (int i = 0; i < list.size(); i++) {
      Monster m = list.get(i); // i번째 요소 반환
      System.out.println(m.toString());
    }
  }
}
class Monster {
  // 필드
  private String name;
  private int level;
  // 생성자
  public Monster(String name, int level) {
    this.name = name;
    this.level = level;
  }
  // 메소드
  public String toString() {
    return String.format("Monster { name: %s, level: %d }", name, level);
  }
}

6) sum of ramen

CODE

import java.util.ArrayList;
public class RamenTest {
  public static void main(String[] args) {
    // Ramen 객체를 담기 위한 ArrayList 생성
    ArrayList<Ramen> list = new ArrayList<Ramen>();
    // Ramen 객체 생성
    Ramen shin = new Ramen("신라면", 800);
    Ramen jin = new Ramen("진라면", 700);
    Ramen bibim = new Ramen("비빔면", 600);
    /* 1. Ramen 객체를 ArrayList에 담으세요. */
    list.add(shin);  // 신라면
    list.add(jin);   // 진라면
    list.add(bibim); // 비빔면
    /* 2. ArrayList에 담긴 모든 객체 정보를 출력하세요. */
    for (int i = 0; i < list.size(); i++) {
      Ramen ramen = list.get(i); // i 번째 요소 가져오기
      System.out.printf("%s\n", ramen.toString());
    }
    /* 3. ArrayList에 담겨진 객체의 총합을 계산하세요. */
    int sum = 0;
    for (int i = 0; i < list.size(); i++) {
      Ramen ramen = list.get(i); // i 번째 요소 가져오기
      sum += ramen.getPrice(); // 라면 가격을 누적하여 더하기
    }
    System.out.println("================================");
    System.out.printf("합계 : %d원", sum);
  }
}
class Ramen {
  // 필드
  private String name;
  private int price;
  // 생성자
  public Ramen(String name, int price) {
    this.name = name;
    this.price = price;
  }
  // 메소드
  public String toString() {
    return String.format("Ramen { name: %s, price: %d }", name, price);
  }
  /*4. price에 대한 게터를 작성하세요. */
  public int getPrice(){
    return price;
  }
}

7) review: make lotto number

arraylist random mix >> ArrayList 요소를 무작위로 섞으려면 어떻게 해야할까요? Collections 클래스의 shuffle() 메소드를 활용하면 됩니다.

// 불러오기
import java.util.Collections;
// 리스트 섞기
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
Collections.shuffle(list);

print array ez way >> 또, 배열을 간편하게 문자열로 만드는 법! 뭐 없을까요? 있습니다!

// 불러오기
import java.util.Arrays;
// 배열의 문자열화
int[] arr = { 1, 2, 3, 4 };
String result = Arrays.toString(arr); // "[1, 2, 3, 4]"

CODE

import java.util.Arrays;
import java.util.Collections;
import java.util.ArrayList;
public class SimpleLottoMachine {
  public static void main(String[] args) {
    // 45개의 공을 만든다
    ArrayList<Integer> list = new ArrayList<Integer>();
    int[] arr = new int[6];
    for (int i = 1; i < 46; i++){
      list.add(i);
    }
    // 섞는다
    Collections.shuffle(list);
    // 뽑는다
    for(int i = 0; i < 6; i++){
        arr[i] = list.get(i);
    }
    // 결과 출력
    String result = Arrays.toString(arr);
    System.out.println("자동 생성 번호: "+result);
  }
}