[Java] API_ java.util (Arrays 클래스 - search, date, calendar, random)

 

JAVA API

: application programming interface

• 미리 만들어진 기능인 라이브러리
• API안에 많은 패키지들이 존재 (lang, util, IO 등)

메서드 모형 읽는 법
접근제어자 + (매개변수) + ;(결과) 반환 유형 - 클래스가 선언된 위치

접근제어자 구분
public private default protected

---

java.util 패키지

• 자바 프로그램 개발에 보조 역할을 하는 클래스들을 담은 패키지
• 컬렉션 관련 클래스들

---

Arrays

• 배열 조작 기능
• 순회(순서대로 접근, map), 복사(복사본에 작업 후 원본 덮기), 정렬, 검색, 필터링, 연산(reduce()) 등
  → 비교가 가능해짐
  ★ 정렬을 하려면 크기 비교하는 방법을 알아야 한다 ★
• try ~ catch 잊지 말기

array 클래스의 주요 메서드

메서드 이름	내용	기타
copyOf (원본배열, 복사할길이)	원본 배열의 0번 인덱스부터 복사할 길이만큼의 인덱스까지 복사한 배열을 리턴
clone()	복사 / Object 클래스
copyOfRange (원본배열, 시작인덱스, 끝인덱스)	원본 배열의 시작 인덱스에서 끝 인덱스까지 복사 한 배열 리턴	시작 인덱스는 포함 끝 인덱스는 포함X
sort (배열) - 실습 확인	배열의 전체 항목을 오름차순(ascending) 정렬.	내림차순(descending) 으로 바꾸기 가능
binarySearch (배열, 찾는값)	전체 배열 항목에서 찾는 값이 있는 인덱스를 리턴	반드시 배열이 정렬되어있어야 함
fill (배열, 넣을값)	배열의 모든 요소를 지정된 값으로 채움
equals(배열1, 배열2)	두 배열에 저장된 모든 요소를 비교	boolean
toString (배열)	배열의 값들을 "[값1, 값2,...]"와 같은 문자열 형식으로 리턴
asList(Object... a)	배열을 List에 담아서 반환
→ asList가 반환한 List의 크기를 변경X → 변경 가능하려면      List list = new ArrayList(Arrays.asList(1,2,3,4,5));

정렬 구현하는 방법

1. 알고리즘을 직접 적용해서 정렬
   → 코딩 테스트에서는 퀵 정렬 필수 + 설명 가능해야 함
2. API에서 제공하는 메서드 이용
   (각 요소 크기 비교가 가능하도록 정렬해야 함)

예제

Test2

package _api.util.arrays;

import java.util.Scanner;

public class Test2 {

	public static void main(String[] args) {
		
		Scanner scan = new Scanner(System.in);
		// 실수 문자열을 입력받아서 실수로 변경하고 출력하는 프로그램
		System.out.println("실수를 입력하세요> ");
		String su = scan.nextLine();
		
		try {
		// 실수 문자열을 실수로 변경
		Double silsu = Double.parseDouble(su);
		
		// 실수를 문자열로 변환
		String msg = silsu.toString();
		System.out.println(msg);
		} catch(Exception e) {
			System.out.println("변환 실패");
		}
		
		scan.close();
	}
}

ArrayTask

package _api.util.arrays;

import java.util.Arrays;

public class ArrayTask {

	public static void main(String[] args) {
		// 문자열 배열 생성
		String [] arr = {"카리나", "아이린", "윈터", "조이", "슬기"};

		// 배열을 순회하면서 출력
		for(String singer: arr) {
			System.out.println(singer); //카리나 / 아이린 /	윈터 / 조이 / 슬기
		}
		 
		// 문자열의 크기 비교하는 메서드: compareTo, compareToIgnorecase
		 System.out.println(arr[1].compareTo(arr[0])); // -2352

		//선택 정렬
		// 배열의 복제
		String[] copyArr = Arrays.copyOf(arr, arr.length);
		
		// 첫번째부터 n-1번째 데이터 까지
		for(int i = 0; i < copyArr.length; i++) {
			// 자신의 뒤에 있는 모든 데이터와 비교해서
			for(int j = i+1; j < copyArr.length; j++ ) {
				// 뒤에 있는 데이터가 더 크다면(작다면) 교환
				if(copyArr[i].compareTo(copyArr[j]) < 0 ) {
					String tmp = copyArr[i];
					copyArr[i] = copyArr[j];
					copyArr[j] = tmp;
				}
			}
		}
		System.out.println(Arrays.toString(copyArr)); // [카리나, 조이, 윈터, 아이린, 슬기]
	}
}

• 문자열 배열 생성 후 향상된 for문으로 배열을 돌면서 출력
• String 배열 copyArr 생성 & 배열 복제
  String[] copyArr = Arrays.copyOf(원래 배열, 배열 길이);
• 복사된 배열값 정렬: 이중 for문
  int i = 0 ~ copyArr.length -1 까지 (앞 데이터) int j = i+1 ~ copyArr.length -1 까지 (뒤 데이터)
  앞의 데이터가 더 작으면 음수 반환 → i와 j 교환하므로 오름차순 → 내림차순으로 변경
  if(copy[i].compareTo(copyArr[j]) < 0
  Strint tmp 변수 생성하여 배열값 바꿔주기 => 결과적으로 내림차순

PersonVO implements Comparable<PersonVO>

package _api.util.arrays;

public class PersonVO implements Comparable<PersonVO>{ // generic

	private int num;
	private String name;
	private int age; 
	
	// 매개변수가 없는 생성자 - Default Constructor 필수
	public PersonVO() {
		super();
	}
	
	// 속성을 전부 매개변수로 받는 생성자 - 인스턴스 생성 후 값을 빠르게 대입하기 위해서 생성
	public PersonVO(int num, String name, int age) {
		super();
		this.num = num;
		this.name = name;
		this.age = age;
	}

	// getter & setter - 속성의 값에 접근하고 변경하기 위한 메서드
	// 일반적으로 VO 클래스의 경우는 setter를 만들지 않음
	public int getNum() {
		return num;
	}

	public void setNum(int num) {
		this.num = num;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	// 데이터 출력을 편리하게 하기 위한 메서드
	// 출력하는 메서드에 인스턴스 이름을 대입하면 이 메서드가 호출되서 출력됨
	@Override
	public String toString() { // 3번 부를것 없이 toString()만 부르면 한꺼번에 나옴
		return "PersonVO [num=" + num + ", name=" + name + ", age=" + age + "]";
	}

	// 크기 비교하는 메서드: 정렬하기 위해서 사용
//	@Override
//	public int compareTo(PersonVO o) { // 오름차순
//		// 나이 비교 방법 설정
//		return this.age - o.age; // 음수를 리턴하면 자리를 바꿈, 양수가 리턴=앞이 큼, 음수가 리턴=뒤가 큼, 0=같음
//	}
	
//	@Override
//	public int compareTo(PersonVO o) { // 내림차순
//		// 나이 비교 방법 설정
//		return o.age - this.age; // 부호를 바꿔주면 됨, 이렇게 하던지 혹은 위의 메서드에서 *-1을 해주던지
//	}
	

//	@Override
//	public int compareTo(PersonVO o) { // 오름차순
//		// 문자열 비교 방법 설정
//		return this.name.compareTo(o.name);
//	}
	
	@Override
	public int compareTo(PersonVO o) { // 내림차순
		// 문자열 비교 방법 설정
		return o.name.compareTo(this.name);
	}
	
	
}

• Generic 미리 사용
• 멤버변수 생성, Default Constructor 생성, 매개변수가 있는 생성자 생성
• VO class 특징
   Value Object 값 객체, 생성자를 통해 한 번 생성되면 이후에는 내부의 값을 변경할 수  없어야 함
  Setter를 허용하지 않음, 동등성 검사를 해야하면 각각의 값이 같으면 두 VO 객체는 동일하다고 판단함

PersonVO - Main

package _api.util.arrays;

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

public class Main {

	public static void main(String[] args) { // 동적 - 바꿀수 있음
		// 배열생성
		PersonVO[] persons = {new PersonVO(1, "수지", 29),
							  new PersonVO(2, "아이유", 30),
							  new PersonVO(3, "카리나", 23),
							  new PersonVO(4, "아담", 46),
		};

		// 배열의 데이터 출력
		System.out.println(Arrays.toString(persons));

	}
}

--------------------------------출력---------------------------------
[PersonVO [num=1, name=수지, age=29], PersonVO [num=2, name=아이유, age=30], PersonVO [num=3, name=카리나, age=23], PersonVO [num=4, name=아담, age=46]]

PersonVO - 동적 Main

package _api.util.arrays;

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

public class Main {

	public static void main(String[] args) { // 동적 - 바꿀수 있음
		// 배열생성
		PersonVO[] persons = {new PersonVO(1, "수지", 29),
							  new PersonVO(2, "아이유", 30),
							  new PersonVO(3, "카리나", 23),
							  new PersonVO(4, "아담", 46),
		};
		
		// Arrays.sort() 메서드는 배열을 대입하면 부등호 또는 compareTo 라는 메서드를 호출해서
		// 크기 비교를 한 후 정렬을 수행해 줌
		// Arrays.sort(persons); // 실행하면 예외발생 - PersonVO에는 크기 비교를 할 수있는 메서드가 존재하지 X
		// PersonVO 클래스에 크기 비교하는 메서드(Comparable)를 만들어서 비교
		
// 		동적으로 크기 비교하는 메서드를 설정
//		Arrays.sort(persons, new Comparator<PersonVO>(){
//
//			@Override
//			public int compare(PersonVO o1, PersonVO o2) {
//				// return o1.getAge() - o2.getAge(); // 오름차순
//				return o2.getAge() - o1.getAge(); // 내림차순
//			}
//			
//		});
		
		// 동적으로 정렬하기
		// 1.이름의 오름차순 2.이름의 내림차순 3.나이의 오름차순 4.나이의 내림차순
		Scanner scan = new Scanner(System.in);
		System.out.println("1.이름의 오름차순 2.이름의 내림차순 3.나이의 오름차순 4.나이의 내림차순");
		String menu = scan.nextLine();

		switch (menu.trim()) {
		case "1":
			Arrays.sort(persons, new Comparator<PersonVO>(){
				@Override
				public int compare(PersonVO o1, PersonVO o2) {
					return o1.getName().compareTo(o2.getName());
				}
			});
			break;

		case "2":
			Arrays.sort(persons, new Comparator<PersonVO>(){
				@Override
				public int compare(PersonVO o1, PersonVO o2) {
					return o2.getName().compareTo(o1.getName());
				}
			});
			break;

		case "3":
			Arrays.sort(persons, new Comparator<PersonVO>(){
				@Override
				public int compare(PersonVO o1, PersonVO o2) {
					return o1.getAge() - o2.getAge();
				}
			});
			break;

		case "4":
			Arrays.sort(persons, new Comparator<PersonVO>(){
				@Override
				public int compare(PersonVO o1, PersonVO o2) {
					return o2.getAge() - o1.getAge();
				}
			});
			break;

		default:
			System.out.println("메뉴는 1-4번 중에서 선택하세요");
			break;
		}

		scan.close();


		// 배열의 데이터 출력
		// Arrays.toString()은 배열의 각 요소의 toString을 전부 호출해서
		// 하나의 문자열로 리턴하는 메서드
		System.out.println(Arrays.toString(persons));

		// 실제 해시코드 (해시코드는 운영체제가 결정함, ==는 해시코드를 비교하는 것)
		// System.out.println(System.identityHashCode(persons));

	}
}

• Arrays.sort() 메서드 - 배열을 대입하면 부등호 또는 compareTo 라는 메서드를 호출해서 크기 비교를 한 후 정렬을 수행해 줌
• Arrays.sort(persons); → 실행하면 예외발생 - PersonVO에는 크기 비교를 할 수있는 메서드가 존재하지 X
• PersonVO 클래스에 크기 비교하는 메서드(Comparable)를 만들어서 비교

 

• 실제 해시코드 (해시코드는 운영체제가 결정함, ==는 해시코드를 비교하는 것) System.out.println(System.identityHashCode(persons));
  

  // 동적으로 크기 비교하는 메서드를 설정
  		Arrays.sort(persons, new Comparator<PersonVO>(){
  
  			@Override
  			public int compare(PersonVO o1, PersonVO o2) {
  				return o1.getAge() - o2.getAge(); // 오름차순
  				return o2.getAge() - o1.getAge(); // 내림차순
  			}
  			
  		});​

---

Search [검색]

1. 순차 검색

데이터를 앞 → 뒤 순서대로 검색 (한 번만 할 경우 빠름)

2. 제어 검색

★ 정렬(Array)한 후 검색(Search) ★ (여러 번 할 경우 빠름)

1. Binary Search (이분 검색): 중앙값과 비교, 데이터가 존재하면 그 데이터의 위치를 리턴하고 존재하지 않으면 음수를 리턴 /  Arrays.toString()에 있음
2. Fibonacci Search: 무조건 첫 시작은 1 1, 세 번째부터는 앞의 2개 행의 합(규칙은 3번째부터) /  1 1 2 3 5 8 13 ...
   - 재귀를 이용한 해결 - 시간이 오래 걸리지 않지만 이해하기는 쉬움
   - 재귀를 이용하지 X 해결 - 시간을 단축할 수 있지만 이해하기 어려울 수 있음
                                              은행에서 많이 사용
3. Interpolation Search (보간 검색): 검색위치 계산
   
4. 트리 검색: 이분 검색과 비슷(이분법은 딱 절반!) 데이터에 따라 좌우 균형이 안 맞을 수 있음
5. 블록 검색: Block은 정렬되어 있지만 Block내부는 정렬하지 X. ex) 서점

3. 해싱 검색

• 해시함수 이용

{ 21,  14,  13,  10,  2 }
mod 5 → 5로 나눈 나머지
                    10 - 0 
                    21 - 1
                     2  - 2
                    13 - 3
                    14 - 4

계산을 한 번 하고, 들어가서 색인
무슨 검색을 하든지 검색 시간이 항상 같음
이미 있으면 저장하지 X
ex) 음악 어플

실습

ArraysMain - 문자열 배열에서 문자열의 위치 찾기 [이분검색]

package _api.util.arrays;

import java.util.Arrays;

public class ArraysMain {

	public static void main(String[] args) {
		// 문자열 배열 생성
		String[] singers = {"제니", "지수", "로제", "리사"};
		
		// 이분 검색 수행 - sort를 하지 않아서 잘못된 결과가 리턴됨
		int result = Arrays.binarySearch(singers, "로제");
		System.out.println(result); // -1
		
		// 데이터 정렬
		Arrays.sort(singers);
		// 정렬한 데이터 확인
		System.out.println(Arrays.toString(singers)); // [로제, 리사, 제니, 지수]
		int result2 = Arrays.binarySearch(singers, "로제");
		System.out.println(result2); // 0
		if(result2 >= 0) {
			System.out.printf("%s는 %d번째 존재\n", "로제", (result2+1));
            // 로제는 1번째 존재로 바꿔서 이해할 수 있게끔
		} else {
			System.out.printf("%s는 존재하지 않음\n", "로제");
		}
	
	}
}
-------------------------------------------출력---------------------------------------------------
-1
[로제, 리사, 제니, 지수]
0
로제는 1번째 존재

• Arrays.binnarySearch 하려면 우선 정렬이 되어 있어야 함
  정렬되지 않은 상태로 바로 result를 호출하면 -1로 잘못된 결과가 리턴됨
• Arrays.sort로 오름차순 정렬
• 정렬한 데이터 확인: Arrays.binarySearch(singers, "로제") 하고 println하면 인덱스 번호 출력
• if 조건문으로 몇번째에 있는지 확인

RecursionFibonacci - 재귀 이용 (시간 오래 걸림)

package _api.util.arrays;

public class RecursionFibonacci {

	// n번째 피보나치 수열의 값을 리턴해주는 메서드
	public static int fibonacci(int n) {
		// 첫번째 와 두번째는 1
		if(n == 1 || n == 2) {
			return 1;
		}
		// 세번째 부터는 앞의 2개의 항의 합
		else {
			return fibonacci(n-1) + fibonacci(n-2);
		}
	}
	
	public static void main(String[] args) {
		// 시간제한이 있는 경우 재귀는 사용하지 않는게 좋음
		System.out.println(fibonacci(100)); // 오버플로우 발생
	}
}

• n은 자리값 n = 1, 2 일때는 1을 리턴
• 세번째부터는 n-1 + n-2 앞의 두 항의 합
• 하나씩 돌아가면서 리턴해주므로 시간이 오래 걸림 - 오버플로우 발생

NoRecursionFibonacci - 재귀 이용X (시간 단축)

package _api.util.arrays;

public class NoRecursionFibonacci {

	// n번째 피보나치 수열의 값을 리턴해주는 메서드
	public static int fibonacci(int n) {
		// 이전 항의 값과 이전의 이전 항의 값을 저장할 변수
		int f1 = 1;
		int f2 = 1;

		// 피보나치 값을 저장할 변수
		int fibo = 1;

		// 첫번째 와 두번째는 처리할 필요가 없어서 반복문을 세번째부터 적용
		for(int i = 3; i <= n; i++) {
			fibo = f1 + f2;
			// 다음 부분 계산 준비
			f2 = f1;
			f1 = fibo;
		}
		return fibo;
	}

	public static void main(String[] args) {
		System.out.println(fibonacci(10));
	}
}

• 1, 2번째 값은 1이므로 f1, f2의 기본값은 1

다음 피보나치 값을 넣을 변수는 fibo 만들어서 fibo 값 리턴하고, f1은 f2에 fibo는 f1에 대입
반복

Date

• java.util.Date
• java.sql.Date  /  java.sql.Time
• java.util.Calendar  /  java.util.GregorianCalendar
• LocalDateTime

epoch time - 1970년 1월 1일

Java.util.Date

• 1970년 1월 1일 자정을 기준으로 지나온 시간을 밀리초 단위의 long 타입으로 관리
• 년도 설정할때는 1900년 이후 지나온 년수로 설정
• 월을 설정할때는 1을 빼서 설정 (0부터 시작하기 때문)
• toString메서드와 단위별로 추출하는 메서드 제공
• 출력을 할때는 java.text.SimpleDateFormat 클래스와 같이 사용하는 경우가 많음

SimpleDateFormat sdf = new SimpleDateFormat("날짜 서식");
sdf.format(Date 객체)를 이용해서 날짜 서식이 적용된 문자열을 리턴받을 수 있음

년도 - yy, yyyy
월 - M, MM, MMM
일 - d, dd
요일 - E, EE, EEE
시간 - H, HH
오전/오후 - a (12시간제)
분 - m, mm
초 - s, ss

실습

DateCreate

package _api.util.arrays;

import java.text.SimpleDateFormat;
import java.util.Date;

public class DateCreate {

	public static void main(String[] args) {
		// 현재 시간을 갖는 Date 인스턴스 생성
		Date currentTime = new Date();
		
		// 출력
		System.out.println(currentTime);
	
		// 원하는 날짜를 가지고 생성: 1995년 1월 1일 16:08:00 으로 설정
		// 원하는 년도 - 1900, 원하는 월은 하나 밀려서 -1을 해야 함
		Date firstMeetingTime = new Date(1995-1900, 1-1, 1, 16, 8, 0);
		
		// 출력 - 년월일 시분초 출력
		System.out.println(firstMeetingTime);
		
		// 년도 만 추출해서 출력, 웬만하면 쓰지 마라
		System.out.println(firstMeetingTime.getYear() + 1900);
		
		// 원하는 포맷으로 출력
		// 1995년 1월 1일 ?요일이라고 출력
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy년 M월 d일 E요일");
		System.out.println(sdf.format(firstMeetingTime));
	
		Date LastdayTime = new Date(2022-1900, 10-1, 24, 10, 58, 0);
		Date TodayTime = new Date(2022-1900, 10-1, 25, 10, 58, 0);
		Date TodayTimeNow = new Date();
		
	}
}

# 연습해볼만 과제

=>년월일을 비교해서 년월일이 같으면 시간 과 분을 그렇지 않으면 년월일을 출력

Java.sql.Date / Java.sql.Time

• 날짜와 시간이 분리된 클래스로 관계형 데이터베이스와 연동할 때 사용할 수 있는 클래스

---

Calendar

Java.util.Calendar / Java.util.GregorianCalendar

• java.util.Calendar는 날짜 관련된 메서드를 가진 추상클래스 (abstract class: 인스턴스를 생성할 수 없는 클래스)
• java.util.gregorianCalendar 클래스는 Calendar 클래스의 메서드를 구현한 하위 클래스

인스턴스 생성
Calendar calendar = new GregorianCalendar();

여러 종류의 생성자가 제공되서 날짜  및 시간을 설정해서 생성하는 것도 가능
Date 클래스에 비해서 많은 양의 정보를 제공

LocalDateTime

• 최근에 데이터베이스의 날짜 및 시간 데이터에 매핑할 때 많이 이용하는 클래스
• 월을 계산할 때 -1을 하지 않아도 됨
• 날짜와 시간 데이터를 많이 사용할 것 같으면 학습이 필요

package _api.util.arrays;

import java.time.LocalDateTime;
import java.util.Calendar;
import java.util.GregorianCalendar;

public class DateETC {

	public static void main(String[] args) {
		
		//날짜와 시간을 다른 형태로 사용하는 클래스
		Calendar calendar = new GregorianCalendar();
		
		//Date보다 많은 정보를 출력
		System.out.println(calendar); 
		
		//특정한 데이터를 조회 - 년,월,일 추출
		//1월을 0부터 시작하므로, 필요시에 월의 값에 1을 더해줘야 함
		System.out.println(calendar.get(Calendar.YEAR)); // 2022
		System.out.println(calendar.get(Calendar.MONTH)+1); // 9+1 
		System.out.println(calendar.get(Calendar.DATE)); // 25
		
		//최근에 많이 사용하는 날짜 타입
		//LocalDateTime은 월-1을 하지 않음, 그냥 월
		LocalDateTime meetingTime = LocalDateTime.of(2022, 10, 27, 18, 50);
		System.out.println(meetingTime);
	}
}
-------------------------------------출력------------------------------------
java.util.GregorianCalendar[time=1667122468143,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Seoul",offset=32400000,dstSavings=0,useDaylight=false,transitions=30,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2022,MONTH=9,WEEK_OF_YEAR=45,WEEK_OF_MONTH=6,DAY_OF_MONTH=30,DAY_OF_YEAR=303,DAY_OF_WEEK=1,DAY_OF_WEEK_IN_MONTH=5,AM_PM=1,HOUR=6,HOUR_OF_DAY=18,MINUTE=34,SECOND=28,MILLISECOND=143,ZONE_OFFSET=32400000,DST_OFFSET=0]
2022
10
30
2022-10-27T18:50

# 날짜와 시간에서 조금 더 학습해 볼만한 내용
=>Calendar 클래스 나 LocalDateTime 클래스에서 시간의 연산 부분(특히 뺄셈)
=>Calendar 클래스 나 LocalDateTime 클래스에서 지역이나 시간대 설정하는 부분

---

 

2023.09.01 - [프로그래밍 언어/Java] - [Java] Date, Calendar

---

Random

Random클래스

• seed를 만든 후 seed에서 숫자를 하나씩 추출하는 클래스
• 생성자()
  Random() seed를 현재 시간에 생성 - 어느 정도 랜덤 보장
  Random(long seed) seed를 고정 - 랜덤이 아니고 일정한 패턴의 숫자를 가져옴
• 데이터를 추출하는 메서드
  next(자료형)
  nextInt(int n): 0부터 n보다 작은수까지 범위에서 추출

UUID

• 랜덤한 문자열을 만들어주는 클래스
• UUID.randomUUID().toString()을 이용해서 랜덤한 문자열을 만들어줌
• 고유한 식별자를 생성할 때 주로 이용

사용이유
1. 실제로 ID를 만들기 위해
2. 사진 업로드를 할 때 중복되면 덮어씌우는데 파일 업로드 할 때 앞에 추가됨 → 중복 제거

실습

RandomTest

seed를 사용하는 경우와 그렇지 않은 경우를 구분하고 배열 안에서 랜덤한 요소를 추출해보고 UUID 실행

package _api.util.arrays;

import java.util.Random;
import java.util.UUID;

public class RandomTest {

	public static void main(String[] args) {
		
		//seed를 사용하지 않는 경우와 사용하는 경우의 차이
		//여러번 실행해보고 확인
		//java에서는 seed를 설정하지 않으면 seed가 랜덤
		
		Random r = new Random();
		System.out.println(r.nextInt());
		
		//seed를 설정하면 고정된 패턴이 숫자가 리턴
		r = new Random(42);
		System.out.println(r.nextInt()); // -1170105035
		
		//
		r = new Random();
		//윷놀이
		int[] arr = {-1, 1, 2, 3, 4, 5};
		for(int i = 0; i < 10; i++) {
			System.out.println(arr[r.nextInt(arr.length)]);
		}
		
		//메뉴
		String[] menu = {"한식", "중식", "일식", "양식", "분식", "아시안식"};
		for(int i = 0; i < 5; i++) {
			System.out.println(menu[r.nextInt(menu.length)]);
		}
		
		//주사위 게임
		for(int i = 0; i < 10; i++) {
			System.out.println(r.nextInt(6) + 1);
		}
		
		//랜덤한 문자열 추출
		System.out.println(UUID.randomUUID().toString()); // 57522c85-19fa-4757-b48a-8d7efa84fcf1
	}
}

---

오늘 하루

기억에 남는 부분

- Arrays 클래스의 메서드 사용방법

- search 검색은 정렬 후에 가능함. 정렬할 기준이 없는 경우 sort를 이용해야 함

 

어려운 부분

- 피보나치 수열에서 재귀를 이용하지 않고 해결하는 부분

- Array의 검색 부분 어디에서 써야할지 아직은 감이 잘 안옴

 

문제 해결 부분

- 날짜와 시간에서 해 볼만한 과제 아직 안해봄