[Day25] Java 25 - PriorityQueue, ListIterator, Arrays메서드, HashSet, LinkedHashSet, TreeSet

[Day25] Java 25 [9/14]

PriorityQueue

PriorityQueue 컬렉션 클래스

ㄴ FIFO X , 저장순서에 상관없이 Priority(우선권) 높은 요소가 먼저 나온다.

// <기본형 X, 참조형 O> 제네릭
// Queue<int>   q = new PriorityQueue<int>();
Queue<Integer>   q = new PriorityQueue<Integer>();
// 정수인 경우에는 낮은 정수가 우선순위가 높구나..(확인)
q.offer(3);  // int -> Integer  오토 박싱
q.offer(5);
q.offer(2);
q.offer(4);
q.offer(1);
		
// 큐  FIFO
while ( ! q.isEmpty() ) {
	  int n = q.poll();
	  System.out.println( n ); // 1,2,3,4,5
} //

Deque( [D]ouble-[E]nded [Que]ue ) FIFO 디큐, 덱

양쪽 끝에서 모두 추가/추출이 가능한 컬렉션 클래스

LinkedList , ArrayDeque 컬렉션 클래스

↑ ↓ offer() offerFirst() pollFirst()

| |

↑ ↓ poll() pollLast() offerLast()

public static void main(String[] args) {
	Deque<String> dq = new LinkedList<String>();
} // main

Iterator, ListIterator, Enumeration 인터페이스

모두 컬렉션에서 저장된 요소를 접근하는데 사용되는 인터페이스

Enumeration(구버젼) Iterator(신버젼) < ListIterator 기능확장

fail-fast 기능

Vector<String> v = new Vector<>();
v.add("A"); v.add("B"); v.add("C"); v.add("D"); v.add("E");
		
// 열거자
// Iterator               -> 단방향 요소 접근
// ListIterator        ->  <- 양방향 요소 접근

ListIterator<String> ir = v.listIterator();

while (ir.hasNext()) {
	String str =  ir.next();
	System.out.println( str );
}
	   
while (ir.hasPrevious() ) { // 이전 요소 있냐? 
	String str = ir.previous();
	System.out.println( str );
}

Arrays 메서드

1) copyOf(), copyOfRange() - 배열 복사

2) fill(), setAll() - 배열 채우기

3) sort(), binarySearch() - 정렬 과 검색

4) equals(), toString() 배열 비교, 출력

5) asList() - 배열 -> List 컬렉션클래스 변환

6) parallelXXX() , Spliterator() , stream()

- 처리 속도(성능)을 위해서

- 여러 스레드가 동시에 처리하는 메서드

Comparator 인터페이스와 Comparable

- 배열 채우기

Arrays.setAll(m,   (x) -> (int)(Math.random()*101)  );
System.out.println( Arrays.toString(m) );
Arrays.sort(m);  // 내림차순 정렬
System.out.println( Arrays.toString(m) );

- 정렬

// 오름차순(asc) 정렬
Arrays.sort( m );
		
// 내림차순( desc ) 정렬 + Comparator 직접구현 , 무명클래스, 람다식
Arrays.sort(m, new DesendingComparator());

// 대소문자 구분하지 않고 정렬( 기억 )
Arrays.sort(m,  String.CASE_INSENSITIVE_ORDER );
System.out.println( Arrays.toString(m) );

Comparator 인터페이스

클래스 자체에서 implements Comparable 해서 @Override

public class Ex06_02 {
	public static void main(String[] args) {
		// 12:05 수업 시작~ 
		Person [] m = {
				new Person("문혜빈", 23),				
				new Person("김경연", 27),
				new Person("조민경", 25)
		}; 
		
		System.out.println(  Arrays.toString( m ) );
		
		// 정렬
		// java.lang.ClassCastException: [days25.Person] cannot be cast to java.lang.[Comparable]
		// Person 클래스는 Comparable인터페이스를 구현 하지 않았기 때문에 형변환 X -> 정렬( 비교  X )
		//  Person 클래스   무엇을 기준으로 정렬 정해져 있지 않다. 
		/*
		Arrays.sort( m , new Comparator<Person>() {

			@Override
			public int compare(Person o1, Person o2) {
				 
				return o1.age      -       o2.age;
				// return o1.name.compareTo(     o2.name  );
			}
		});
		*/
		
		// Arrays.sort( m ,   ( o1,  o2) -> o1.name.compareTo(     o2.name  ) );		
		Arrays.sort( m );  // 이름, 나이 정렬		
		
		System.out.println(  Arrays.toString( m ) );	
	} // main
} // class

class Person implements Comparable<Person>{
	
	// 필드
	String rrn; // 주민등록번호
	String name;
	int age;	
	
	// 생성자
	public Person() {
		super(); 
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}  
	public Person(String rrn, String name, int age) {
		super();
		this.rrn = rrn;
		this.name = name;
		this.age = age;
	}
	
	// 
	@Override
	public String toString() {
		return "Person [rrn=" + rrn + ", name=" + name + ", age=" + age + "]";
	}
	
	@Override
	public int compareTo(Person o) { 
		return this.name.compareTo(o.name);
	}
	
	// Student                   hashCode() , equals() 오버라이딩~
	// HashSet 추가할때   학번 같으면 추가되지 않도록 구현하세요. 
	//                                 
	@Override
	public int hashCode() { 
		return  this.rrn.hashCode();
	}
	@Override
	public boolean equals(Object obj) {		
		
		if( obj instanceof Person) { 
			Person p = (Person)obj;
			return this.rrn.equals(p.rrn);  // true, false 
		}	
		return false;
	}	
} // class

HashSet 컬렉션 클래스

ㄴ Set 구현한 대표적인 컬렉션 클래스

ㄴ 순서 유지 X, 중복 허용 X

HashSet<Integer>  hs = new HashSet<>();
// Collecion <? extends Integer> c 매개변수   
hs.add( 3 );
hs.add( 5 );
hs.add( 2 );
hs.add( 4 );
hs.add( 1 );
		
// 메서드 3가지 - 1)기능 2) 매개변수 3)리턴값(리턴자료형)
System.out.println(   hs.add( 1 )   );  // 중복 허용 X    false
hs.remove(5);  // Object o,   int index X

활용 (중요 : HashSet -> LinkedList 변환, 정렬하기 위해)

public static void main(String[] args) {
	HashSet<Integer>  lotto = new HashSet<Integer>();
		
	fillLotto( lotto ); 
	dispLotto( lotto ); 

} // main

public static void fillLotto( HashSet<Integer> lotto) { 
	Random rnd =  new Random();  
	while( lotto.size() < 6) {
		    int temp = rnd.nextInt(45) + 1;   
			lotto.add( temp );  
	} // while  
}

public  static void dispLotto(HashSet<Integer> lotto) {
	// 컬렉션객체 -> [] 배열로 변환  : toArray()
	// Object [] =  lotto.toArray(); 
	
	/*
	List<Integer> list = new LinkedList<>(lotto);  // 암기( 시험 ) 
	Collections.sort(list);
	*/
	
	Iterator<Integer> ir = lotto.iterator();
	// Iterator<Integer> ir =  list.iterator();
	while (ir.hasNext()) {
		int n =  ir.next();  // 오토 언박싱  ( Integer -> int 형변환)
		System.out.printf("[%d]", n);
	}
	System.out.println();
} // dispLotto

LinkedHashSet

LinkedHashSet<Integer> lotto = new LinkedHashSet<>();
		
lotto.add(19);
lotto.add(7);
lotto.add(27);

System.out.println(  lotto );  //순서유지

//  로또게임 : 3번         
int gameNumber = 1;
		
Scanner scanner = new Scanner(System.in);
System.out.print("> 로또 게임 횟수 입력 ? ");
gameNumber = scanner.nextInt();
		
// int [][] lottos = new int[gameNumber][6];
// LinkedHashSet<Integer> [] lottos = new LinkedHashSet[gameNumber]; 		
ArrayList< LinkedHashSet<Integer> > lottos = new ArrayList<LinkedHashSet<Integer>>();
		
// [ 배열의 배열 = 다차원 ]
// 로또 채워넣고.
for (int i = 0; i <  gameNumber  ; i++) {  // == gameNumber
	LinkedHashSet<Integer>   lotto = new LinkedHashSet<Integer>();			
	Ex07_02.fillLotto(lotto);				
	lottos.add(lotto);
}

// 로또 출력
Iterator<LinkedHashSet<Integer>> ir = lottos.iterator();
while (ir.hasNext()) {
	LinkedHashSet<Integer> lotto = ir.next();
	Ex07_02.dispLotto(lotto);
}

* ArrayList안에 LinkedHashSet 넣을 수 있음!!

HashSet<Person>  hs = new HashSet<Person>();
		
// 주민등록번호가 같다면 동일한 사람( Person) 이다.
Person p1 = new Person(  "1111", "홍길동", 20  );
Person p2 = new Person(  "1111", "홍길동", 20  );
		 
System.out.println( p1.hashCode() );  // 366712642
System.out.println( p2.hashCode() ); // 1829164700		
System.out.println(  p1.equals(p2) );  // false
	 
		
// 주민등록번호가 같은 Person은 hs 에 중복체크에 걸려서 추가되지 않도록 하고 싶다. 
// 방법 ?  Object.hashCode(), equals() 메서드 를 오버라이딩.
hs.add(  p1 );
hs.add(  p2 );
		
System.out.println(  hs ); // [Person [rrn=1111, name=홍길동, age=20]]

예제) 빙고판 안에 25개의 숫자 중복이 되지 않게 넣고 다시 2차원 배열로 채워넣기 위해 LinkedHashSet 사용

int [][] board = new int[5][5]; //
//  1~25 숫자를  중보되지 않게 임의로 다 채워 넣어야 되네요.
Random rnd = new Random();		
		
// 	왜 ? LinkedHashSet 컬렉션 클래스 사용
LinkedHashSet<Integer>  hs = new LinkedHashSet<Integer>();		
// 3:06 수업시작
while(  hs.size() < 25  ) {
	 hs.add(       rnd.nextInt(25) +1        );  // 1~25 
} // while
		
// 출력.
// [25, 23, 2, 16, 22, 21, 6, 20, 7, 12, 15, 10, 1, 3, 13, 18, 14, 9, 24, 5, 11, 8, 4, 19, 17]
System.out.println(  hs );
		
// hs -> [][] board
Iterator<Integer>  ir = hs.iterator();
// []  -> [][]
int i = 0;
while (ir.hasNext()) {
	 int n =  ir.next();
	 board[i/5][i%5] = n;
	  i++;
}

중복체크 ( HashSet에 new 연산자로 서로 다른 인스턴스 저장하면 다른 객체로 인식, 만약 객체의 내용이 동일한 것으로 취급하기 위해선 Person 객체 내에서 equals 메서드를 오버라이딩 해줘야함

// 중복 체크 방법 ? 
HashSet<Person>  hs = new HashSet<Person>();
		
// 주민등록번호가 같다면 동일한 사람( Person) 이다.
Person p1 = new Person(  "1111", "홍길동", 20  );
Person p2 = new Person(  "1111", "홍길동", 20  );
		
System.out.println( p1.hashCode() );  // 366712642
System.out.println( p2.hashCode() ); // 1829164700		
 
System.out.println(  p1.equals(p2) );  // false
	 		
// 주민등록번호가 같은 Person은 hs 에 중복체크에 걸려서 추가되지 않도록 하고 싶다. 
// 방법 ?  Object.hashCode(), equals() 메서드 를 오버라이딩.
hs.add(  p1 );
hs.add(  p2 );
		
System.out.println(  hs ); // [Person [rrn=1111, name=홍길동, age=20]]

Person객체

@Override
public int hashCode() {
  return this.rrn.hashCode();
}

@Override
public boolean equals(Object obj) {
  if(obj instanceof Person) {
    Person p = (Person)obj;
    return this.rrn.equals(p.rrn);
  }
  return false;
}

합집합 / 교집합 / 차집합

HashSet<Integer> a = new HashSet<Integer>();
a.add(1);a.add(2);a.add(3);a.add(4);a.add(5);
		
HashSet<Integer> b = new HashSet<Integer>();
b.add(4);b.add(5);b.add(6);b.add(7);b.add(8);

// 1.  합집합      a  U   b     [1, 2, 3, 4, 5, 6, 7, 8]
HashSet<Integer> hab = new HashSet<Integer>();
		
/*
Iterator<Integer>  ir = a.iterator();
while (ir.hasNext()) {
	Integer n = (Integer) ir.next();
	hab.add(n);
}
		
ir = b.iterator();
while (ir.hasNext()) {
	Integer n = (Integer) ir.next();
	hab.add(n);
}
*/
		
hab.addAll(a);
hab.addAll(b);

// 2. 교집합  a  ∩  b   [4, 5]
HashSet<Integer> kyo = new HashSet<Integer>();
				
Iterator<Integer>  ir = a.iterator();
while (ir.hasNext()) {
	Integer n = (Integer) ir.next();
	if(  b.contains( n )) {  // 교집합
		kyo.add(n);
	} else{                        // 차집합
		//cha.add(n);
	}
} //  while
				
// 3. 차집합  a - b  [1,2,3]
HashSet<Integer> cha = new HashSet<Integer>( a  );  // [1, 2, 3, 4, 5]
// cha.addAll(a);
cha.removeAll(kyo);

TreeSet

[TreeSet 특징]

1) 이진 검색 트리 (binarySearch Tree) -> 데이터 저장

검색 성능 뛰어나다.

2) Set = 중복 허용 X, 순서 유지 X

3) 검색 + 정렬 + 범위 검색 성능 뛰어나다.

4) 링크드리스트 처럼 노드(Node)가 연결된 구조.

next 다음 요소 주소

Prev 이전 요소 주소

5) 최상위 노드를 "root" 노드

부모-자식 노드 관계,

형제 노드 관계

6) class TreeNode{

TreeNode 왼쪽 자식노드;

TreeNode 오른쪽 자식노드;

Object value;

}

TreeSet<Integer>  ts = new TreeSet<Integer>();
ts.add( 7 );
ts.add( 4 );
ts.add( 9 );
ts.add( 1 );
ts.add( 5 );
ts.add( 6 ); 
        
System.out.println( ts ); //[1, 4, 5, 6, 7, 9]
        
System.out.println(  ts.first() );  // 정렬된 순서에서 첫 번째 객체를 반환한다.   1
System.out.println(  ts.last() );  // 정렬된 순서에서 마지막 번째 객체를 반환한다.  9
        
SortedSet<Integer>  ss =  ts.subSet(1, 7);
System.out.println( ss ); //[1, 4, 5, 6]
        
// 지정된 객체(1) 보다 큰 값을 가진 객체 중에 제일 가까운 값의 객체를 반환, 없으면 null
System.out.println(  ts.higher(1) );  // 4
// ts.lower(1)        // null
        
// 지정된 객체(3)와 같은 객체를 반환, 없으면 작은 값을 가진 객체 중에 제일 가까운 값을 객체를 반환
//  없으면 null 반환
System.out.println(  ts.floor(3) );  //  1
        
// 지정된 객체(3)와 같은 객체를 반환, 없으면 큰값을 가진 객체 중에 제일 가까운 값을 객체를 반환
//  없으면 null 반환
System.out.println(  ts.ceiling(3) );  //  4
        
// TreeSet은 정렬된 구조 ( 따로 정렬 X )

예제

TreeSet<Integer> set = new TreeSet<Integer>();
int [] score = { 80, 95, 50, 35, 45, 65, 10, 100};
for (int i = 0; i < score.length; i++) {
	 set.add(  score[i] );
}
System.out.println( set );  // 자동 오름차순 정렬
			
// headSet() : 지정된 객체(50)보다 작은 값의 객체들을 반환.
SortedSet<Integer>  r1 = set.headSet(50, true);   // 50 포함되지 않는다. 
		
// tailSet() : 지정된 객체(50)보다 큰 값의 객체들을 반환.
SortedSet<Integer>  r1 = set.tailSet(50);   // 50 포함되지 않는다. 
set.headSet(50, true);   // 50 포함한다.

저작자표시

'👨‍💻 Web Development > Java' 카테고리의 다른 글

[Day27] Java 27 - Enum, 어노테이션, 입출력(I/O), 문자/바이트 스트림 (0)	2022.09.20
[Day26] Java 26 - HashMap, Hashtable, Properties, Collections, 제네릭 (클래스,인스턴스,와일드카드) (0)	2022.09.18
[Day24] Java 24 - 컬렉션 프레임워크(JCF), ArrayList, Vector, Iterator/enumerator, LinkedList, Stack, Queue (0)	2022.09.17
[Day23] Java 23 - java.time활용 (0)	2022.09.17
[Day22] Java 22 - java.time, 형식화 클래스 (0)	2022.09.17

[Day25] Java 25 - PriorityQueue, ListIterator, Arrays메서드, HashSet, LinkedHashSet, TreeSet

[Day25] Java 25 [9/14]

'👨‍💻 Web Development > Java' 카테고리의 다른 글

전체 카테고리

블로그 인기글

티스토리툴바

[Day25] Java 25 [9/14]

'👨‍💻 Web Development > Java' 카테고리의 다른 글

전체 카테고리

최근 글

최근댓글

블로그 인기글

티스토리툴바