1. 현재 날짜와 시간 정보를 LocalDateTime 클래스를 사용해서
아래와 같은 형식으로 출력하세요 .
출력 형식 ) 2023/02/28 화요일 12:17:57.356
// 출력 형식 ) 2023/02/28 화요일 12:17:57.356
// 1. 객체 생성 : now(), of()
// 2. 출력 형식 : 형식화 클래스 DateTimeFormatter
LocalDateTime dt = LocalDateTime.now();
System.out.println( dt ); // 2023-02-28T09:48:35.144031700
String pattern = "yyyy/MM/dd E요일 hh:mm:ss.SSS";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
String s = formatter.format(dt);
System.out.println( s ); // 2023/02/28 화요일 09:51:52.823
String s2 = dt.format(formatter);
System.out.println( s2 );
2. String s = "2023.02.28 (화)" 문자열을 LocalDate 클래스로 변환시키세요.
String s = "2023.02.28 (화)";
// String s = "2023-02-28"; // ISO
String pattern = "yyyy.MM.dd (E)";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
LocalDate d = LocalDate.parse(s , formatter);
System.out.println( d );
3. 용어 정리
4. ArrayList 컬렉션 클래스를 사용하여
1) 팀원들 이름을 요소로 추가하기
2) 반복자(iteratror)를 사용해서 모든 요소 출력하기 ***
3) 팀원 한명을 검색해서 있다면 "홍길동"으로 수정하기
4) "홍길동"을 검색해서 있다면 삭제하기.
ArrayList list = new ArrayList();
list.add("이태규"); // 0
list.add("김지은"); // 1
list.add("김씨"); // 4
list.add("설경인"); // 2
list.add("윤재민"); // 3
list.add("홍김씨"); // 5
System.out.println( list );
/*
// 반복자 사용해서 출력.
Iterator ir = list.iterator();
// hasNext()
// next()
while (ir.hasNext()) {
String name = (String) ir.next();
System.out.println( name );
}
System.out.println( "-".repeat(40));
*/
/*
// boolean list.contains("김지은")
int idx = list.indexOf("김지은");
// list.lastIndexOf("김지은");
if( idx != -1 ) {
list.set(idx, "홍길동");
}
System.out.println( list );
System.out.println( "-".repeat(40));
*/
/*
idx = list.indexOf("홍길동");
if( idx != -1 ) {
list.remove(idx);
// list.remove("홍길동");
}
System.out.println( list );
System.out.println( "-".repeat(40));
*/
// [문제] 목록 안에 "김"씨 학생은 모두 삭제(제거)
// size()
// get()
// startsWith()
/*
for (int i = list.size()-1; i >=0 ; i--) {
String name = (String) list.get(i);
// if( name .contains("김") ) {
// if( name.charAt(0) == '김' ) {
// name.matches("김.+")
if( name.startsWith("김") ) {
// System.out.println( name );
list.remove(i);
}
}
*/
/*
list.removeIf( new Predicate<String>() {
@Override
public boolean test(String t) {
return t.startsWith("김");
}
} );
*/
list.removeIf( (t) -> ((String) t).startsWith("김") );
System.out.println( list );
5. 이름, 나이 필드를 가진 Person 클래스를 선언하고
ArrayList 컬렉션 클래스에 Person 객체를 요소로 추가하고
이름으로 오름차순 정렬해서 출력하는 코딩을 하세요 ..
1) Person 클래스 선언
2) Person 객체 요소 추가
11:03 수업 시작~~~
3) list 정렬
4) interator 반복자 사용 출력.
class Person implements Comparable<Person>{
// field
private String name;
private int age;
// constructor
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
// getter, setter
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() {
return "Person [name=" + name + ", age=" + age + "]";
}
@Override
public int compareTo(Person o) {
// return this.name.compareTo(o.name); // 0 , 양수, 음수
return this.age - o.age;
}
}
ArrayList list = new ArrayList();
list.add(new Person("이혜진", 20));
list.add(new Person("박진용", 25));
list.add(new Person("박현주", 24));
list.add(new Person("김수민", 23));
// 오름차순 정렬
// 나이순으로 오름차순 정렬. 코딩 수정..
list.sort(null);
// System.out.println( list );
Iterator ir = list.iterator();
while (ir.hasNext()) {
Person p = (Person) ir.next();
System.out.println( p );
}
6. java.time 패키지 클래스 사용. ( LocalDateTime )
1) 설문 시작일 23.2.15 09:00:00
2) 설문 종료일 23.2.28 09:00:00
오늘 현재 설문 가능한여부를 출력하세요.
LocalDateTime s = LocalDateTime.of(2023, 2, 15, 9,0, 0);
LocalDateTime e = LocalDateTime.of(2023, 2, 28, 9,0, 0);
LocalDateTime t = LocalDateTime.now();
if( t.isBefore(s) || t.isAfter(e) ) System.out.println("설문 X");
else System.out.println("설문 O");
package days24;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
/**
* @author ♈ k§nik
* @date 2023. 2. 28. - 오전 7:26:02
* @subject
* @content
*/
public class Ex01 {
public static void main(String[] args) {
// 9:40 제출~
// 10:04 수업 시작~
String [] names = {"박진용","박민종","이혜진", "김동현"};
// String [] -> ArrayList 변환
// [첫 번째]
/*
ArrayList list = new ArrayList();
for (int i = 0; i < names.length; i++) {
// System.out.println( names[i] );
list.add( names[i] );
}
*/
// Arrays 클래스의 asList() 메서드
// List a = Arrays.asList(T... a);
// List a = (List) Arrays.asList( names );
// ( 암기) String [] 을 ArrayList 변환하는 코딩.
ArrayList list = new ArrayList( Arrays.asList( names ) ); // 업캐스팅.
System.out.println( list );
// ArrayList -> String[] 다시 변환...
/*
String [] m = new String[ list.size() ];
Iterator ir = list.iterator();
int idx = 0;
while (ir.hasNext()) {
String name = (String) ir.next();
m[idx++] = name;
}
System.out.println( Arrays.toString( m ) );
*/
/*
Exception in thread "main" java.lang.ClassCastException:
class [Ljava.lang.Object;
cannot be cast to class [Ljava.lang.String;
[Ljava.lang.Object; and [Ljava.lang.String;
are in module java.base of loader 'bootstrap')
at days24.Ex01.main(Ex01.java:53)
*/
// Object[] toArray() -> String []
// (String[]) cast 연산자로 형변환..
// String[] m = (String[]) list.toArray(); XXXXX
String [] m = null ;
m = (String[]) list.toArray( new String[ list.size() ] );
System.out.println( Arrays.toString( m ) );
/*
Object [] m = list.toArray();
System.out.println( Arrays.toString(m) );
*/
} // main
} // class
package days24;
import java.util.Enumeration;
import java.util.List;
import java.util.Vector;
import java.util.function.Predicate;
/**
* @author ♈ k§nik
* @date 2023. 2. 28. - 오후 12:12:08
* @subject Vector 컬렉션 클래스
* @content ㄴ List 인터페이스 구현한 클래스
* ㄴ 순서 유지 O, 중복 허용 O
* ㄴ ArrayList 와 차이점 : 멀티 스레드 안전. ( 동기화 처리 )
*
* StringBuffer
* StringBuilder : 멀티 스레드 안전( 동기화 처리 되어져 있다)
*/
public class Ex02 {
public static void main(String[] args) {
// Vector v = new Vector(초기용량 10, 증가치 0);
Vector v = new Vector();
v.add("박현주");
v.addElement("박진용1");
v.addElement("박진용2");
v.addElement("박진용3");
v.addElement("박진용4");
v.addElement("박진용5");
v.addElement("박진용6");
// 요소 갯수
System.out.println( v.size() ); // 2
System.out.println( v.capacity() ); // 10
v.trimToSize();
System.out.println( v.capacity() ); // 2
System.out.println( "-".repeat(40 ));
v.setSize( 6 ); // 요소 6개 . null null null null
System.out.println( v.size() ); // 6
System.out.println( v.capacity() ); // 6
System.out.println( "-".repeat(40 ));
System.out.println( v ); // [박현주, 박진용, null, null, null, null]
System.out.println( v.get(0) );
// Returns the component at the specified index.
// This method is identical in functionality to the get(int)method (which is part of the List interface).
System.out.println( v.elementAt(0) );
System.out.println( "-".repeat(40 ));
// Iterator [반복자]
// 모든 요소를 반환하는 메서드
// Enumeration [열거자]
Enumeration en = v.elements();
// hasMoreElemetns() == hasMoreNext()
// en.nextElement() == next()
while (en.hasMoreElements()) {
String name = (String) en.nextElement();
System.out.println( name );
}
// v.setSize(6) null X 4
// [문제] v 안에 null 요소는 모두 제거하세요..
// v.remove(0); == v.removeElementAt(0);
// v.remove("홍길동"); == v.removeElement("홍길동)
// v.removeAllElements(); == v.clear();
/*
v.removeIf( new Predicate<String>() {
@Override
public boolean test(String t) {
return t == null;
}
} );
*/
v.removeIf( (t) -> t == null );
System.out.println( v );
Object [] names = v.toArray();
for (Object obj : names) {
System.out.println( (String)obj );
}
// v.firstElement() == v.get(0) == v.elementAt(0)
// v.lastElement() == v.get( v.size() -1 );== v.elementAt(v.size() -1)
// v.insertElementAt("박찬호", 1); == v.add(1, "박찬호");
// isXXXX() 이니 아니니? true/false
// v.clear();
// System.out.println( v.size() ); // 0
// System.out.println( v.isEmpty() ); // true
// 1
// [박현주, 박진용1, 박진용2, 박진용3, 박진용4, 박진용5]
List slist = v.subList( 1,4 ); // 1<= 요소 < 4
System.out.println( slist );
// v.sort(null);
// v.setElementAt("홍진용", 1); == v.set(1, "홍진용");
} // main
} // class
package days24;
/**
* @author ♈ k§nik
* @date 2023. 2. 28. - 오후 1:50:25
* @subject ArrayList 컬렉션 클래스
* @content Vector 컬렉션 클래스
* [ LinkedList 컬렉션 클래스 ]
*/
public class Ex03 {
public static void main(String[] args) {
/*
* 1. 배열
* (장점) 읽기 성능이 가장 빠르다.
* (단점) 배열크기 X,
* 삽입, 삭제 무지 속도 느리다.
*
* 메모리상에 동일한 자료형을 연속적으로 놓이게 한 것.
*
* 2. 링크드리스트
* (특징) 비연속적
*
* 단방향 환형 링크드리스트
* (더블)양방향 환형 링크드리스트
*
* 환형 링크드리스트
* */
Node node1 = new Node();
node1.value = 10;
Node node2 = new Node();
node2.value = 20;
Node node3 = new Node();
node3.value = 30;
Node node4 = new Node();
node4.value = 40;
node1.next = node2;
node2.next = node3;
node3.next = node4;
node4.next = null;
// [문제] 노드 2와 노드 3 사이에 노드 5를 삽입하는 코딩.
Node node5 = new Node();
node5.value = 50;
node2.next = node5;
node5.next = node3;
// node1 - node2 - node5 - node3 - node4
// [문제] 노드 3을 삭제..
node5.next = node4;
// node1 - node2 - node5 - node4
// [문제] 가장 마지막 노드( 노드 4) 를 삭제
node5.next = null;
// node1 - node2 - node5 - node5
Node node6 = new Node();
node6.value = 60;
node5.next = node6;
node6.next = null;
Node node7 = new Node();
node7.value = 70;
node7.next = node1;
Node node = node7;
while( node != null) {
System.out.println( node.value );
node = node.next;
}
} // main
} // class
class Node{
int value; // 값
Node next = null; // 다음 노드의 주소값
// Node prev = null; // 이전 노드의 주소값
}
package days24;
/**
* @author ♈ k§nik
* @date 2023. 2. 28. - 오후 1:50:25
* @subject ArrayList 컬렉션 클래스
* @content Vector 컬렉션 클래스
* [ LinkedList 컬렉션 클래스 ]
*/
public class Ex03 {
public static void main(String[] args) {
/*
* 1. 배열
* (장점) 읽기 성능이 가장 빠르다.
* (단점) 배열크기 X,
* 삽입, 삭제 무지 속도 느리다.
*
* 메모리상에 동일한 자료형을 연속적으로 놓이게 한 것.
*
* 2. 링크드리스트
* (특징) 비연속적
*
* 단방향 환형 링크드리스트
* (더블)양방향 환형 링크드리스트
*
* 환형 링크드리스트
* */
Node node1 = new Node();
node1.value = 10;
Node node2 = new Node();
node2.value = 20;
Node node3 = new Node();
node3.value = 30;
Node node4 = new Node();
node4.value = 40;
node1.next = node2;
node2.next = node3;
node3.next = node4;
node4.next = null;
// [문제] 노드 2와 노드 3 사이에 노드 5를 삽입하는 코딩.
Node node5 = new Node();
node5.value = 50;
node2.next = node5;
node5.next = node3;
// node1 - node2 - node5 - node3 - node4
// [문제] 노드 3을 삭제..
node5.next = node4;
// node1 - node2 - node5 - node4
// [문제] 가장 마지막 노드( 노드 4) 를 삭제
node5.next = null;
// node1 - node2 - node5 - node5
Node node6 = new Node();
node6.value = 60;
node5.next = node6;
node6.next = null;
Node node7 = new Node();
node7.value = 70;
node7.next = node1;
Node node = node7;
while( node != null) {
System.out.println( node.value );
node = node.next;
}
} // main
} // class
class Node{
int value; // 값
Node next = null; // 다음 노드의 주소값
// Node prev = null; // 이전 노드의 주소값
}
package days24;
import java.util.Deque;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
/**
* @author ♈ k§nik
* @date 2023. 2. 28. - 오후 2:32:29
* @subject
* @content
*/
public class Ex03_02 {
public static void main(String[] args) {
// LinkedList 컬렉션 클래스
// implements List 순서 유지 O, 중복 허용 O, Deque X, Cloneable 복제가능한, java.io.Serializable 직렬화
LinkedList list = new LinkedList();
list.add("김수민");
list.add("진예림");
list.add("김동현");
System.out.println( list );
list.addFirst("박민종");
System.out.println( list );
list.add(2, "박현주");
System.out.println( list );
// 요소(element) == 노드(node)
System.out.println( list.size() );
// 1. 김동현 검색 후 탁인혁으로 수정
list.contains("김동현");
list.indexOf("김동현");
list.lastIndexOf("김동현");
// list.offer( ); list.peek(); list.push();
int index = -1;
if( ( index = list.indexOf("김동현")) != -1 ) {
// list.add(index, list); // 삽입
list.set(index, "탁인혁");
}
System.out.println( list );
// 2. 탁인혁 삭제..
// list.remove(); // first element( node )
// list.removeLast();
// list.remove("탁인혁");
// System.out.println( list );
// 반복자를 사용해서 모든 요소(노드) 출력.
// 3:04 수업 시작
// Iterator ir = list.iterator();
Iterator ir = list.descendingIterator();
while (ir.hasNext()) {
String name = (String) ir.next();
System.out.println( name );
}
/*
* 1. 순차적으로 추가/삭제하는 경우 : ArrayList 가 LinkedList 보다 빠르다.
* 2. 중간에 추가/삭제하는 경우 : LinkedList가 ArrayList 보다 빠르다.
* ArrayList + 멀티 스레드 => Vector
* */
} // main
} // class
package days24;
import java.util.Stack;
/**
* @author ♈ k§nik
* @date 2023. 2. 28. - 오후 3:08:20
* @subject 스택(Stack)과 큐(Queue)
* @content
*/
public class dnEx04 {
public static void main(String[] args) {
/*
* 1. 스택(Stack) : LIFO 구조 ( 마지막 저장된 데이터를 가장 먼저 꺼내는 구조 )
* ---------------
* -> C B A |
* ---------------
* Last In First Out
*
* empty()
* peek()
* pop()
* push()
*
* search()
*
* 2. 큐(Queue) : FIFO 구조 ( 처음에 저장된 데이터를 가장 먼저 꺼내는 구조 )
* -------------------
* -> C B A ->
* -------------------
* First In First Out
*
* add()
* offer()
* remove()
* poll()
* element()
* peek()
* */
// 부모클래스 Vector <- List 인터페이스 <- Collection 인터페이스
Stack s = new Stack();
s.push("박진용");
s.push("진예림");
s.push("김예지");
System.out.println( s );
// X s.get(0)
/*
String name = (String) s.pop();
System.out.println( name );
name = (String) s.pop();
System.out.println( name );
name = (String) s.pop();
System.out.println( name );
*/
// s.empty() Stack
// s.isEmpty() Vector
/*
String name ;
while( !s.empty() ) {
name = (String) s.pop();
System.out.println( name );
}
*/
// peek() 와 pop() 메서드 차이점
// 읽어 제거
String name = (String) s.peek();
System.out.println( name );
name = (String) s.peek();
System.out.println( name );
name = (String) s.peek();
System.out.println( name );
System.out.println( s.size() );
// search() 메서드 1 부터 시작~
System.out.println( s.search("진예림") );
// 편의 점 = 우유
// 날짜..
} // main
} // class
7package days24;
import java.util.LinkedList;
import java.util.Queue;
/**
* @author ♈ k§nik
* @date 2023. 2. 28. - 오후 3:27:44
* @subject
* @content
*/
public class Ex04_02 {
public static void main(String[] args) {
// 큐( Queue ) - FIFO 구조
// 인터페이스
Queue q = new LinkedList() ;
// LinkedList q = new LinkedList() ;
// []-[]-[]-[]
// 큐
q.offer("박진용");
q.offer("진예림");
q.offer("김예지");
q.offer("김수민");
System.out.println( q );
// q.get(0) X
/*
// String name = (String) q.poll(); // 큐에서 삭제하고 가져오는 메서드
String name = (String) q.peek(); // 큐에서 삭제하지 않고 가져오는 메서드
System.out.println( name );
*/
while ( ! q.isEmpty() ) {
// String name = (String) q.poll();
String name = (String) q.remove();
System.out.println( name );
}
} // main
} // class
package days24;
//import java.util.Deque;
//import java.util.LinkedList;
//
///**
// * @author ♈ k§nik
// * @date 2023. 2. 28. - 오후 3:46:17
// * @subject Deque == [D]ouble [E]nded [Que]ue
// * @content 양쪽 끝에서 추가/추출이 가능한 큐 구조
// */
// /*
// * 큐(Queue)구조 == FIFO 구조
// * -------------------------
// * -> C B A ->
// * <- <-
// * -------------------------
// *
// * */
//
// Deque dq = new LinkedList();
//
// dq.offerFirst("홍길동");
// dq.offerLast("홍길동");
//
// dq.pollFirst();
// dq.pollLast();
//
// //메모리 스트림
// //swhile을 한바이트를 읽어와서 b라는곳에 저
// //bias close ()x
// ///buf ->ais 메모리 스팀 생성- shile 읽기 baos 메모리 스트림
//
// byte [] outBuf = toByteArray();
// //수료할때까지 안씀
//
//
// }
//
//}
//source 문자열에서 15번째 라인의 문자열을 출력
package days24;
import java.util.PriorityQueue;
import java.util.Queue;
/**
* @author ♈ k§nik
* @date 2023. 2. 28. - 오후 3:39:53
* @subject
* @content
*/
public class Ex05 {
public static void main(String[] args) {
// PriorityQueue 컬렉션 클래스
// Priority(우선권) + 큐 == 저장한 순서에 상관없이 우선 순위가 높은 것 부터 꺼내오는 구조
// 큐 구조 == FIFO 구조
Queue q = new PriorityQueue();
// int 는 우선 순위가 높은 값은 작은값.....
q.offer(3);
q.offer(5);
q.offer(2);
q.offer(4);
q.offer(1);
while ( !q.isEmpty()) {
int n = (int) q.poll();
System.out.println( n );
}
} // main
} //class
package days24;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.Vector;
/**
* @author ♈ k§nik
* @date 2023. 2. 28. - 오후 3:52:31
* @subject 열거자(Enumeration) 인터페이스
* @content 반복자(Iterator) 인터페이스
* (차이점)
* 컬렉션의 요소에 접근해서 가져오는 객체
* 4:05 수업 시작~
*
* ListIterator : Iterator에 양방향 조회기능 추가된 반복자.( List 구현한 클래스 에만 사용 가능 )
*/
public class Ex06 {
public static void main(String[] args) {
Vector v = new Vector();
v.add("박진용");
v.add("진예림");
v.add("김예지");
v.add("이혜진");
// [양방향 반복자]
ListIterator ir = v.listIterator();
while (ir.hasNext()) {
String name = (String) ir.next();
System.out.println(name );
}
System.out.println("> 순 방향으로 진행 완료!!!!");
while (ir.hasPrevious()) {
String name = (String) ir.previous();
System.out.println(name );
}
System.out.println("> 역 방향으로 진행 완료!!!!");
/*
// [차이점] 다른 곳에서 김예지- 수정. 삭제...
// 1) 열거자( 구 버전 )
Enumeration en = v.elements();
while (en.hasMoreElements()) {
String name = (String) en.nextElement();
System.out.println( name );
}
System.out.println( "-".repeat(40 ));
// 2) 반복자( 신 버전) 예외처리를 통해서 변경된 새로운 요소값을 읽어오도록 처리할 수 있다.
Iterator ir = v.iterator();
while (ir.hasNext()) {
String name = (String) ir.next();
System.out.println( name );
}
*/
} // main
} // class
package days24;
import java.util.Arrays;
import java.util.Comparator;
/**
* @author ♈ k§nik
* @date 2023. 2. 28. - 오후 4:22:21
* @subject Comparable 인터페이스 : 기본 정렬 기준을 구현하는 데 사용
* Comparator 인터페이스 : 기본 정렬 기준외에 다른 기준으로 정렬하고자 할 때 사용.
* @content
*/
public class Ex07 {
public static void main(String[] args) {
String [] m = { "tiger", "cat" , "Dog", "lion" };
System.out.println( Arrays.toString( m ) ); // [tiger, cat, Dog, lion]
// m 배열을 정렬을 해서 다시 출력.
// Arrays.sort( m );
// 내림차순 정렬 해서 다시 출력.
// Arrays.sort( m, new DesendingComparator() );
// 대소문자를 구분하지 않고 오름차순 정렬
Arrays.sort(m, String.CASE_INSENSITIVE_ORDER );
System.out.println( Arrays.toString( m ) ); // [Dog, cat, lion, tiger]
} // main
} // class
class DesendingComparator implements Comparator{
@Override
public int compare(Object o1, Object o2) {
String s1 = (String) o1;
String s2 = (String) o2;
return s2.toUpperCase().compareTo(s1.toUpperCase()); // 0, 양수, 음수
}
}
package days24;
import java.util.HashSet;
import java.util.Iterator;
import days15.Person;
/**
* @author ♈ k§nik
* @date 2023. 2. 28. - 오후 4:38:56
* @subject List -> [ ArrayList ], Vector, LinkedList, Stack, PriorityQueue, (Queue, Deque 인터페이스)
* @content Set -> 특징 중복허용X, 순서 유지 X
* 가장 대표적인 컬렉션 클래스 : HashSet
*/
public class Ex08 {
public static void main(String[] args) {
// HashSet<int> hs = new HashSet<int>();
HashSet<Integer> hs = new HashSet<Integer>();
hs.add(9);
hs.add(1);
hs.add(15);
hs.add(20);
System.out.println( hs.add(1) ); // false
hs.add(1);
hs.add(1);
System.out.println( hs.size() ); // 4
// hs.add("홍길동");
Iterator<Integer> ir = hs.iterator();
while (ir.hasNext()) {
int i = ir.next();
System.out.println( i );
}
hs.remove(20);
System.out.println( hs );
} // main
} // class
package days24;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Random;
/**
* @author ♈ k§nik
* @date 2023. 2. 28. - 오후 4:54:40
* @subject
* @content
*/
public class Ex08_02 {
public static void main(String[] args) {
// 로또게임
HashSet<Integer> lotto = new HashSet<>();
fillLotto( lotto );
dispLotto( lotto );
} // main
private static void dispLotto(HashSet<Integer> lotto) {
Iterator<Integer> ir = lotto.iterator();
while (ir.hasNext()) {
Integer n = (Integer) ir.next();
System.out.println( n );
}
}
private static void fillLotto(HashSet<Integer> lotto) {
Random rnd = new Random();
while( lotto.size() < 6) {
int n = rnd.nextInt(45)+1;
lotto.add(n);
}
}
} // class
