자바/스프링 부트캠프 14일차( collection )

1) 컬렉션 프레임워크

 

   1-1) List

 

    1-2 ) set

 

---

1) 컬렉션 프레임워크

 

---

 

* Collection 인터페이스 : 객체를 여러개저장할 수 있는 객체]

 

* List : Collection 인터페이스의 하위

* 객체들 저장할 때 저장된 순서를 유지 -> 인덱스 사용 가능

* 구현클래스 : ArrayList , Vector , LinkedList..

* Vector : Collection프레임워크 이전의 클래스/

* Collection프레임워크에서 제공되는 함수ㅘ 기존에사용했던함수 혼합

 

* Set : Collection 인터페이스의 하위

* 객체 중복저장 불가능

* 구현클래스 : HashSet , TreeSet , LinkedHashSet

 

---

1-1) List

* List : Collection 인터페이스의 하위

* 객체들 저장할 때 저장된 순서를 유지 -> 인덱스 사용 가능

* 구현클래스 : ArrayList , Vector , LinkedList..

* Vector : Collection프레임워크 이전의 클래스/

* Collection프레임워크에서 제공되는 함수ㅘ 기존에사용했던함수 혼합

package ex1_List;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

public class ListEx1 {
	public static void main(String[] args) {
		/*
		 * <Integer> : 제네릭.(String객체 등은 들어올 수없음)
		 * (자료형이 틀릴 시 오류발생)
		 */
		ArrayList<Integer> list = new ArrayList<>();
		list.add(1);list.add(2);;list.add(5);
		list.add(4);list.add(3);;list.add(0);
		list.add(3);
//		list.add("4");
		System.out.println(list);
		
		//인덱스로 값 찾기
		for (int i = 0; i < list.size(); i++) {
			System.out.println
			(i+" : "+list.get(i));
		}
		
		//정렬하기
		//Collection : 인터페이스
		//Collections : 클래스( Collection 객체의  기능 보조)
		Collections.sort(list);
		System.out.println("sort "+list);
		
		Collections.sort(list,Collections.reverseOrder());//내림차순
		System.out.println("reverseOrder : "+list);
		
		Collections.shuffle(list);//섞기
		System.out.println("Shuffle : "+list);
		
		//인덱스 범위지정해 객체조회
		System.out.println("1번 인덱스부터 3번 인덱스의 객체조회 : "+
							list.subList(1,4));
		
		//1~3번인덱스로 리스트생성 ( but 둘은 같은곳을 참조하지만)
		//list2는 1~3번인덱스만을 참조함
		//list2에 추가하면 list에도 영향이있는것!!
		List<Integer> list2 = list.subList(1, 4);
		System.out.println(list2);
		list2.add(100);
		System.out.println("list :"+list);
		System.out.println("list2 : "+list2);
		
		System.out.println("==새로운 객체를 만들어서 반환==");
		list2 = new ArrayList<>(list.subList(1, 4));
		list2.add(222);
		System.out.println("list : "+list);
		System.out.println("list2 : "+list2);	
	}
}

[1, 2, 5, 4, 3, 0, 3]

0 : 1

1 : 2

2 : 5

3 : 4

4 : 3

5 : 0

6 : 3

sort [0, 1, 2, 3, 3, 4, 5]

reverseOrder : [5, 4, 3, 3, 2, 1, 0]

Shuffle : [3, 3, 2, 1, 4, 5, 0]

1번 인덱스부터 3번 인덱스의 객체조회 : [3, 2, 1]

[3, 2, 1]

list :[3, 3, 2, 1, 100, 4, 5, 0]

list2 : [3, 2, 1, 100]

==새로운 객체를 만들어서 반환==

list : [3, 3, 2, 1, 100, 4, 5, 0]

list2 : [3, 2, 1, 222]

---

예제

 

 * 화면에서 정수를 입력받아 입력받은 숫자의 합계 , 평균, 중간값 출력
 * 999숫자 입력된경우 입력종료

package ex1_List;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class Exam1 {
	public static void main(String[] args) {
		ArrayList<Integer> list = new ArrayList<>();
		Scanner scan = new Scanner(System.in);
		
		int sum=0;
		double avg= 0;
		
		while(true) {
			System.out.println(" 정수를입력 :(999 종료)");
			int num = scan.nextInt();
			if(num==999) {
				break;
			}
			list.add(num);
		}
		
		for (Integer i : list) {
			sum+=i;
		}
		avg = sum/list.size();
		
		Collections.sort(list);//정렬
		double mid = 0;
		if(list.size()%2==0) {
			mid = list.get(list.size()/2)+ list.get(list.size()/2-1);
			mid = mid/2;
		}
		
		else {
			mid = list.get(list.size()/2);
		}
		System.out.println("입력 수 :"+list);
		System.out.println("sum : "+sum);
		System.out.println("avg : "+avg);
		System.out.println("중간값 : "+mid);

	}

}

정수를입력 :(999 종료)

42

정수를입력 :(999 종료)

10

정수를입력 :(999 종료)

5

정수를입력 :(999 종료)

3

정수를입력 :(999 종료)

6

정수를입력 :(999 종료)

1

정수를입력 :(999 종료)

7

정수를입력 :(999 종료)

999

입력 수 :[1, 3, 5, 6, 7, 10, 42]

sum : 74

avg : 10.571428571428571

중간값 : 6.0

 

Collections.sort() 를 이용해 리스트를 오름차순으로 정렬한 후

입력한 리스트의 size 가 홀수일경우에는 그냥 크기를 반으로 나눈값의 인덱스가 중간값이 되는데

 

그게 아닌경우는

(짝수인경우)

size/2 로 인덱스를 추출하고

그 앞의 값(size/2 - 1)과 더한 후 

2로나누어 줘야 중간값

 

---

 * Vector클래스

 *  - Collection 프레임워크 이전의 클래스
 *  - List 의 구현클래스
 *  - 이전의 메서드와 혼합되어 있음.

package ex1_List;

import java.util.ArrayList;
import java.util.List;
import java.util.Vector;


public class ListEx2 {
	public static void main(String[] args) {
		
//		List<Double> list = new Vector<>();
		Vector<Double> list = new Vector<>();
		list.add(0.3);
		list.add(Math.PI);
		list.addElement(5.0);
		//구버전의 메서드임 (그냥 add를 쓰자 Vector에는 있지만 List에는 존재X)
		System.out.println(list);
		
		int index = list.indexOf(5.0);
		int index2 = list.indexOf(4.0);
		System.out.println("5.0의 인덱스 "+index);
		System.out.println("없는 숫자의 인덱스 : "+index2);
		
		//요소존재확인
		boolean contains = list.contains(3.0);
		System.out.println("3.0은 list에 존재하는가? : "+contains);
		
		//요소 제거
		System.out.println("list 크기 : "+list.size());
		list.remove(0); //remove(int n) : n번 인덱스요소 제거
		list.remove(0.3);//remove(Object o ) : o 객체 제거
		System.out.println("list 목록 : "+list);
		
		System.out.println("==list2==");
		ArrayList<Integer> list2 = new ArrayList<>();
		for (int i = 0; i < 10; i++) {
			list2.add(i+1);
		}
		Integer num = 1;
//		int num = 1;
		System.out.println(list2);
		list2.remove(num);
		//int num : 1을 지우는게아니라 index1번을 지우게 됨
		//Integer num : 1을 지운다..
		System.out.println(list2);
	}

}

[0.3, 3.141592653589793, 5.0]

5.0의 인덱스 2

없는 숫자의 인덱스 : -1

3.0은 list에 존재하는가? : false

list 크기 : 3

list 목록 : [3.141592653589793, 5.0]

==list2==

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

[2, 3, 4, 5, 6, 7, 8, 9, 10]

 

---

객체와 정렬 ( List)

 

 * List 정렬하기

 * -- Collections.sort(List<Comparable>)
 *  - List객체를 정렬하기 위해서는 요소 객체가 Comparable 인터페이스의 구현객체여야함
 

 *  정렬관련 인터페이스

 *  Comparable<T> 인터페이스는 Functional 인터페이스임
 *   클래스로 구현해서 , 해당클래스의 기본정렬 방식 설정위해
 *    int compareTo(T t)
 *    결과 : 음수 : 현재객체 앞
 *     양수 : 현재객체 뒤
 
 *  Comparator<T> 인터페이스는 Functional 인터페이스임
 *   정렬 실행 시 동적으로 정렬방식을 설정할 떄 사용
 *    int compare(T t1,T t2)
 *    결과 : 음수 : 현재객체 t1이 앞
 *     양수 : 현재객체 t1 뒤

package ex1_List;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
class Data implements Comparable<Data>{
	int value;
	Data(int value){
		this.value = value;
	}
	public String toString() {
		return value+"";
	}
	int getValue(){
		return value;
	}
	
	@Override
	//comareTo 메서드 구현하지않는다면 비교할수없어!!
	public int compareTo(Data o) {
//		return this.value < o.value?-1:(this.value==o.value)?0:1;
		return value - o.value;
		// 1 - 3 == -2 (음수)이므로 앞에있는거다
	}
	
}

class Data2{
	int value;
	Data2(int value){
		this.value = value;
	}
	public String toString() {
		return value+"";
	}
}

public class ListEx3 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		list.add("a");list.add("c");
		list.add("d");list.add("b");
		list.add("f");
		System.out.println(list);
		Collections.sort(list);
		System.out.println(list);
		System.out.println("Comparator.reverseOrder()");
		Collections.sort(list,Comparator.reverseOrder());
		System.out.println(list);
		
		System.out.println("== list2 ==");
		List<Data> list2 = new ArrayList<>();
		list2.add(new Data(1));list2.add(new Data(3));
		list2.add(new Data(5));list2.add(new Data(2));
		list2.add(new Data(4));
		
		System.out.println(list2);
		
		Collections.sort(list2);
		System.out.println(list2);
		
		//내림차순
		Collections.sort(list2,Comparator.reverseOrder());
		System.out.println(list2);
		
		System.out.println("== list3 ==");
		List<Data2> list3 = new ArrayList<>();
		list3.add(new Data2(1));list3.add(new Data2(3));
		list3.add(new Data2(5));list3.add(new Data2(2));
		list3.add(new Data2(4));
		System.out.println(list3);
		System.out.println("==Comarator(비교자)를 이용한 정렬==");
//		Collections.sort(list3,new Comparator<Data2>() {
//
//			@Override
//			public int compare(Data2 o1, Data2 o2) {
//				return o1.value-o2.value;
//				//앞 - 뒤 = 음수 ( 앞이 더 작다)
//			}
//			
//		});
		//람다방식
		Collections.sort(list3,(d1,d2)->d1.value-d2.value);
		System.out.println(list3);
		
		
		//직관적인 람다방식
		Comparator<Data2> f = (d1,d2)->d1.value - d2.value;
		Collections.sort(list3,f);
		
		System.out.println(list3);
	}
}

 

---

예제

정렬 예제

package ex1_List;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

class Name implements Comparable<Name>{

	String kor;
	String eng; 
	public Name(String kor, String eng) {
		this.kor = kor;
		this.eng = eng;
	}
	public String toString() {
		return kor+" : "+eng;
	}
	@Override
	public int compareTo(Name o) {
//		return kor.hashCode() - o.kor.hashCode();
		//한글의해쉬코드로 정렬을 시도해봤다
		return kor.compareTo(o.kor);
        //comparTo는 int형같은 기본형으로는 사용할수없다
        //기본형이라면 왼쪽-오른쪽 : 음수 ( 왼쪽이작음) 양수(오른쪽이작음) 으로하자
	}
}
//==================================================================
public class Exam2 {

	public static void main(String[] args) {
		ArrayList<Name> list = new ArrayList<>();
		list.add(new Name("김","kim"));
		list.add(new Name("이","lee"));
		list.add(new Name("박","park"));
		list.add(new Name("안","an"));
		list.add(new Name("최","choi"));
		System.out.println(list);
		Collections.sort(list);//이름순
		System.out.println(list);
		System.out.println("영문이름으로 정렬해보기");
		//람다식을 이용했음
		Comparator<Name> f = (e1,e2)->{
			return e1.eng.compareTo(e2.eng);
			};
			
		Collections.sort(list, f);
		System.out.println(list);
		System.out.println("한글이름으로 내림차순 정렬");
		Collections.sort(list.reversed());
//		Collections.sort(list,Comparator.reverseOrder()); 위에랑 같은 의미	

		System.out.println(list);
		Comparator<Name> f1 = (e1,e2)->{
			return e1.kor.compareTo(e2.kor)*-1;
			};
		Collections.sort(list,f1);
		System.out.println(list);
		
		System.out.println("영문이름으로 내림차순 정렬하기");
		Collections.sort(list,(e1,e2)->e1.eng.compareTo(e2.eng)*-1);
		System.out.println(list);
		
		}
}

 

[김 : kim, 이 : lee, 박 : park, 안 : an, 최 : choi]

[김 : kim, 박 : park, 안 : an, 이 : lee, 최 : choi]

영문이름으로 정렬해보기

[안 : an, 최 : choi, 김 : kim, 이 : lee, 박 : park]

한글이름으로 내림차순 정렬

[최 : choi, 이 : lee, 안 : an, 박 : park, 김 : kim]

[최 : choi, 이 : lee, 안 : an, 박 : park, 김 : kim]

영문이름으로 내림차순 정렬하기

[박 : park, 이 : lee, 김 : kim, 최 : choi, 안 : an]

---

1-2)  set 

 

* Set : Collection 인터페이스의 하위

* 객체 중복저장 불가능

* 구현클래스 : HashSet , TreeSet , LinkedHashSet

 

package ex2_set;

import java.util.HashSet;
import java.util.LinkedHashSet;

public class SetEx1 {
	public static void main(String[] args) {
		Object [] arr = {"홍길동",1,"1","김삿갓","이몽룡","유재석","에러내ㅓ","홍길동","유재석","아이"};
		HashSet<Object> set1 = new LinkedHashSet<>();
		HashSet<Object> set2 = new HashSet<>();
		HashSet<Object> set3 = new HashSet<>();
		
		for (int i = 0; i < arr.length; i++) {
			if(!set1.add(arr[i])) {//set1객체에서 arr[i]객체 추가 실패인 경우
				if(!set2.add(arr[i])) {
					set3.add(arr[i]);
				}
			}
		}
		System.out.println(set1);
		System.out.println(set2);
		System.out.println(set3);
		
		//forEach구문으로 조회가능
		for (Object o : set1) {
			System.out.print(o+"__");
		}System.out.println();
		for (Object o : set2) {
			System.out.print(o+"__");
		}System.out.println();
		for (Object o : set3) {
			System.out.print(o+"__");
		}System.out.println();
		
	}
}

[홍길동, 1, 1, 김삿갓, 이몽룡, 유재석, 에러내ㅓ, 아이]

[홍길동, 유재석]

[]

홍길동__1__1__김삿갓__이몽룡__유재석__에러내ㅓ__아이__

홍길동__유재석__

 

''

---

예제 풀이

1.  Student 클래스 구현하기
    멤버변수 : 이름,국어점수, 영어점수, 수학점수
    멤버메서드 
         String toString() : 각멤버변수값,총점,평균 출력
         int getTotal() : 점수의 합 리턴
         int compareTo() : 이름의 오름차순으로 정렬되도록 구현
2. 구동 클래스 완성하기
    다음 결과가 나오도록 구동 클래스 구현하기    
        
[결과]
기본정렬방식
김삿갓:국어(95),영어(85),수학(75),총점(255),평균(85.00)
이몽룡:국어(80),영어(95),수학(95),총점(270),평균(90.00)
임꺽정:국어(60),영어(75),수학(100),총점(235),평균(78.33)
홍길동:국어(90),영어(80),수학(70),총점(240),평균(80.00)

총점기준 내림차순 정렬
이몽룡:국어(80),영어(95),수학(95),총점(270),평균(90.00)
김삿갓:국어(95),영어(85),수학(75),총점(255),평균(85.00)
홍길동:국어(90),영어(80),수학(70),총점(240),평균(80.00)
임꺽정:국어(60),영어(75),수학(100),총점(235),평균(78.33)
국어 점수내림차순 정렬
김삿갓:국어(95),영어(85),수학(75),총점(255),평균(85.00)
홍길동:국어(90),영어(80),수학(70),총점(240),평균(80.00)
이몽룡:국어(80),영어(95),수학(95),총점(270),평균(90.00)
임꺽정:국어(60),영어(75),수학(100),총점(235),평균(78.33)
영어 점수내림차순 정렬
이몽룡:국어(80),영어(95),수학(95),총점(270),평균(90.00)
김삿갓:국어(95),영어(85),수학(75),총점(255),평균(85.00)
홍길동:국어(90),영어(80),수학(70),총점(240),평균(80.00)
임꺽정:국어(60),영어(75),수학(100),총점(235),평균(78.33)
수학 점수내림차순 정렬
임꺽정:국어(60),영어(75),수학(100),총점(235),평균(78.33)
이몽룡:국어(80),영어(95),수학(95),총점(270),평균(90.00)
김삿갓:국어(95),영어(85),수학(75),총점(255),평균(85.00)
홍길동:국어(90),영어(80),수학(70),총점(240),평균(80.00)

 

완성시킨 클래스

package test_ListSet;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

class Student implements Comparable<Student>{
	String name;
	int kor;
	int eng;
	int math;

	public Student(String name, int kor, int eng, int math) {
		this.name = name;
		this.kor = kor;
		this.eng = eng;
		this.math = math;
	}
	
	int total(){
		return kor+eng+math;
	}
	
	double avg() {
		return (double)total()/3;
	}


	@Override
	public int compareTo(Student o) {
		return name.compareTo(o.name);
	}

	@Override
	public String toString() {
		return name + " 국어=" + kor + " 영어=" + eng +
				" 수학=" + math + " 총점 : "+total()+
				"  평균 :  "+String.format("%.2f",avg());
	}
	
}

total 메서드로 모든과목을 더하고

avg 메서드는 total에 과목수 만큼 나눠줘서 평균을 구한다

또한 Comparable<Student> 구현해

comapreTo 메서드를 오버라이딩한다

기본정렬을 우선시 해야하니 이름을 기준으로 정렬문을 작성해줌

public class test1 {
	public static void main(String[] args) {
		List<Student> list = new ArrayList<Student>();
		list.add(new Student("홍길동", 90, 80, 70));
		list.add(new Student("김삿갓", 95, 85, 75));
		list.add(new Student("이몽룡", 80, 95, 95));
		list.add(new Student("임꺽정", 60, 75, 100));

		System.out.println("기본정렬방식");
		Collections.sort(list);
		for(Student s : list) System.out.println(s);

		System.out.println("총점기준 내림차순 정렬");
		Collections.sort(list,(s1,s2)->s2.total()-s1.total());
		for(Student s : list) System.out.println(s);

		System.out.println("국어 점수내림차순 정렬");
		Comparator<Student> f = (s1,s2)->{
			return (s1.kor - s2.kor)*-1;};
		Collections.sort(list,f);
		for(Student s : list) System.out.println(s);

		System.out.println("영어 점수내림차순 정렬");
		Comparator<Student> f2 = (s1,s2)->{
			return (s1.eng - s2.eng)*-1;};
		Collections.sort(list,f2);
		for (Student s : list) {
			System.out.println(s);
		}

		System.out.println("수학 점수내림차순 정렬");
		Collections.sort(list,(m1,m2)->(m1.math-m2.math)*-1);
		for (Student s : list) {
			System.out.println(s);
		}
	}
}

compareTo 메서드구현으로 인해 Collection.sort를 사용할 수 있게 됨

 

또한 총점기준으로 내림차순을 진행할 시

람다를 이용해 Collections.sort(list  뒤에

(s1,s2)->s1.total - s2.total 을 하면 앞에가 더 작다면 음수를 반환하므로

오름차순이 된다 하지만 이결과에 -1을 곱해준다면 반대가될것이다

그러므로 내림차순이 된다.

다른것들도 이런식으로 진행을 했지만

 

영어점수 부분을 보면

Comaparator<Student> f2 = (s1,s2)->{return (s1.eng - s2.eng)*-1};

과 같이  다른방식의 람다를 이용했음..

 

---

예제 2)

이거는 예외처리까지 사용해야

예제와 맞는 문제가된다 난이도가 좀 있는편!!!

 

 

화면에서 여러개의 자연수를 입력받아(0을 입력시 입력종료) 이들 중 
홀수 인 자연수들만 이루어진 List 객체에 저장 
List  객체의 요소의 합을 구하고,
홀수 중 최대값, 최소값, 중간값 을 찾는 프로그램을 작성하기
단 자연수가 아닌 경우가 입력되면 무시한다.
홀수 들로만 이루어진 List 객체를 생성하여 출력하기

최대값과 최소값 :
Collections.max(list)와 Collections.min(list) 함수를 이용한다
중간값 :
 요소의 갯수가 홀수인 경우 : 가운데 값
 요소의 갯수가 짝수인 경우 : 가운데 값 2개의 평균

 [결과]
자연수를 입력하세요 종료(0)
12 77 38 41 53 92 85 aaa 0
[77, 41, 53, 85]의 합:256
홀수의 최대값:85
홀수의 최소값:41
홀수의 최대값 위치:3
홀수의 최소값 위치:1
입력된 홀수 목록:[77, 41, 53, 85]
중간값 :65.0

package test_ListSet;

import java.util.ArrayList;
import java.util.Collections;
import java.util.InputMismatchException;
import java.util.Scanner;

public class Test2 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("여러개의 자연수를 입력하세요 : (0입력시종료)");
		ArrayList<Integer> list = new ArrayList<>();
		int sum=0;

		while(true) {
			try {
				int n = scan.nextInt();//이래야 문자를입력해도 오류가안나지
				if(n==0) {break;}
				else {
					if(n%2 !=0) {
						list.add(n);
						sum+=n;
					}
				}
			} catch (InputMismatchException e) {
				scan.next();
				//만약 nextInt인데 문자값을 넣었다면
				//예외를 잡은 후 그 문자만 없애주고 다시 while문 시작
				//즉 문자를 입력하면 아무일도일어나지않은듯 루프가 돌아감
			}
		}
		
		
		System.out.println(list+"의 합 : "+sum);
		Integer max = Collections.max(list);
		Integer min = Collections.min(list);
		System.out.println("홀수의 최대값 : "+max);
		System.out.println("홀수의 최소값 : "+min);
		System.out.println("홀수의 최대값 위치 : "+list.indexOf(max));
		System.out.println("홀수의 최소값 위치 : "+list.indexOf(min));
		//Integer(객체)를 get에 넣으면 값의 위치를 반환해줌 
		//int를 넣을시 해당인덱스를 얘기함
		System.out.println("입력된 홀수 목록 : "+list);
		Collections.sort(list);
		double mid = 0;
		if(list.size()%2==0) {
			mid = (double)(list.get(list.size()/2)+list.get(list.size()/2-1))/2;
			System.out.println("중간값 : "+mid);
		}
		else {
			System.out.println(list.get(list.size()/2));
		}
	}
}

여기서의 포인트는 while문 안에

try catch문을 작성했다는점이다

만약 nextInt() 인데 문자를 입력했다면

InputMismatchException이 터질것이다

그러면 무시하려고해도 반복문이 종료되며 꺼질것이다.!!!

이걸 catch문으로 잡아서 scan.next()로 입력된문자열만 삭제해주고

다시 정상으로 루프를 돌리는 것임

 

루프안에서는 짝수인경우에는 신경쓰지않고 홀수인경우에만

list에 넣은 후 sum변수에 그값을 누적시켜 합을 구한다.

 

Collections.max 등은 말그대로 리스트의최대최소값을 구해주는거고

indexof(max) 를 통해 최대값의 인덱스값을 반환시킨다.

 

 

---

예제3)

 

난이도 있는편 

남들 풀이랑 다를 가능성있음

 

다음 결과가 나오도록 프로그램을 작성하시오
 1 ~ 1000번까지의 번호를 가지는 복권이 있다.
 1등 1장, 2등 2장, 3등 3장 을 추첨하는 프로그램 작성하기
  단 추첨은 3등부터 추첨하고, 당첨번호는 중복되면 안된다.
  추첨된 번호는 임의의 수이므로 숫자 값은 실행 할때 마다 다르다.

  LinkedHashSet : 순서유지, 중복불가
  Random ( 굳이사용안해도 다 가능함)
  new ArrayList(Set) : Set 객체를 List객체로 생성

  [결과]
3등 복권 추첨합니다.
369,355,699,
2등 복권 추첨합니다.
280,920,
1등 복권 추첨합니다.
839,
 *** 복권 추첨 결과 ***
1등:839
2등:920,280,
3등:699,355,369,
===========

1등:[839]
2등:[280, 920]
3등:[355, 369, 699]
 */

package test_ListSet;

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.Random;
public class Test3 {
	public static void main(String[] args) {
		//		int ran = new Random().nextInt(1000)+1;//1~1000
		LinkedHashSet<Integer> set = new LinkedHashSet<>();
		for (int i = 1; i < 1000; i++) {
			set.add(i);
		}
		ArrayList<Integer> list = new ArrayList<>(set);
		ArrayList<Integer> a3 = new ArrayList<>();
		ArrayList<Integer> a2 = new ArrayList<>();
		ArrayList<Integer> a1 = new ArrayList<>();
		Collections.shuffle(list);

		System.out.println("  [결과]  ");
		System.out.println("3등복권 추첨!");
		for (int i = 0; i < 3; i++) {
			a3.add(list.get(i));
			System.out.print(list.get(i)+",");
		} System.out.println();

		System.out.println("2등복권 추첨!");
		for (int i = 3; i < 5; i++) {
			a2.add(list.get(i));
			System.out.print(list.get(i)+",");	
		} System.out.println();

		System.out.println("1등복권 추첨!");
		System.out.println(list.get(5));
		a1.add(list.get(5));

		System.out.println("********");
		
		for (Integer i : a1) {
			System.out.println("1등 : "+i);
		}
		
		System.out.print("2등 : ");
		for (Integer i : a2) {
			System.out.print(i+" ");
		}System.out.println();
		
		System.out.printf("3등 : ");
		for (Integer i : a3) {
			System.out.print(i+" ");
		}System.out.println();
		
		System.out.println("===========");

		System.out.println("1등 : "+a1);
		System.out.println("2등 : "+a2);
		System.out.println("3등 : "+a3);

	}
}

여기서보면 set으로 1~1000까지를 받았는데

어차피 i값을 넣을거라서 list로해도됨.

 

일단 뭐 그냥 할게요

 

set에 1~1000값을 다 누적시켰다면

list에 set을 넣어준다

ArrayList<Integer> list = new ArrayList<>(set);

그리고

1등 2등 3 등을 담을 list도 생성해준다

 

	Collections.shuffle(list);

 

변수생성 대신에 Collections의 기능인 Shuffle로 섞어준다.

 

그 후 3등은 앞에서부터 3개

2등은 2개

1등은 1개를 뽑아 

각 리스트에 넣어준 후 출력해주면 됨