Comparable, Collections 정렬 / Map, Properties, Stack, Queue, PriorityQueue, Shuffle, TreeSet

package ex0802;

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


public class Ex01_Sort {
	public static void main(String[] args) {
		List<UserVO> list = new ArrayList<UserVO>();
		list.add(new UserVO("너자바", "010-1111-1111", 23));
		list.add(new UserVO("홍길동", "010-2222-1111", 20));
		list.add(new UserVO("스프링", "010-1111-3333", 25));
		list.add(new UserVO("김자바", "010-1313-1111", 23));
		list.add(new UserVO("나나나", "010-1111-1515", 20));
		
		print("정렬 전...", list);
		
		// 정렬 : Comparable를 구현한 클래스만 가능
		Collections.sort(list);
		
		print("정렬 후...", list);
	}
	
	public static void print(String title, List<UserVO> list ) {
		System.out.println(title);
		for(UserVO vo : list) {
			System.out.print(vo.getName()+"\t");
			System.out.print(vo.getTel()+"\t");
			System.out.print(vo.getAge()+"\n");
		}
		System.out.println();
	}
	
}


class UserVO implements Comparable<UserVO>{
	private String name;
	private String tel;
	private int age;
	
	public UserVO() {
	}
	public UserVO(String name, String tel, int age) {
		this.name = name;
		this.tel = tel;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getTel() {
		return tel;
	}
	public void setTel(String tel) {
		this.tel = tel;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	// compareTo : Comparable 인터페이스 메소드로 정렬할 때 정렬할 기준(방법)을 설정
	@Override
	public int compareTo(UserVO o) {
		// 이름 오름차순 :  String compareTo() 메소드로 문자열을 비교
		// return name.compareTo(o.getName());
		
		// return - name.compareTo(o.getName()); // 이름 내림차순
		
		return age - o.getAge(); // 나이 오름차순
	}
}

Collections 정렬 (sort)를 쓰기 위해서 UserVO에서 Comparable 상속 받은 모습

 

package ex0802;

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

public class Ex02_Sort {
	public static void main(String[] args) {
		List<UserDTO> list = new ArrayList<UserDTO>();
		list.add(new UserDTO("나너노", "010-1111-2222", 25));
		list.add(new UserDTO("가나다", "010-3333-2222", 20));
		list.add(new UserDTO("호호호", "010-1111-4545", 23));
		list.add(new UserDTO("가도도", "010-1212-2222", 27));
		list.add(new UserDTO("마마마", "010-1111-5241", 23));
		
		print("정렬전...", list);
		
		// Comparator 인터페이스 구현 : 정렬 기준 설정(이름 오름차순)
		Comparator<UserDTO> comp = new Comparator<UserDTO>() {
			@Override
			public int compare(UserDTO o1, UserDTO o2) {
				return o1.getName().compareTo(o2.getName());
			}
		};
		Collections.sort(list, comp);
		
		print("이름 오름차순...", list);
		
		// Comparator 인터페이스 구현 : 정렬 기준 설정(나이 오름차순)
		Comparator<UserDTO> comp2 = new Comparator<UserDTO>() {
			@Override
			public int compare(UserDTO o1, UserDTO o2) {
				return o1.getAge() - o2.getAge();
			}
		};
		Collections.sort(list, comp2);
		
		print("나이 오름차순...", list);
		
	}
	
	public static void print(String title, List<UserDTO> list) {
		System.out.println(title);
		for(UserDTO dto : list) {
			System.out.print(dto.getName()+"\t");
			System.out.print(dto.getTel()+"\t");
			System.out.print(dto.getAge()+"\n");
		}
		System.out.println();
	}
}

class UserDTO {
	private String name;
	private String tel;
	private int age;
	
	public UserDTO() {
	}
	
	public UserDTO(String name, String tel, int age) {
		this.name = name;
		this.tel = tel;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getTel() {
		return tel;
	}
	public void setTel(String tel) {
		this.tel = tel;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

인터페이스를 구현 해버리면 상속은 안해도 된다.

 

 

Map

package ex0802;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
 - Map
   : 키와 값 구조
   : 키는 중복을 허용하지 않음
   : 키는 순서가 없음
   : 반복자가 없음(키는 반복자가 존재)
- Map 구현 클래스
   : HashMap - 동기화 지원하지 않음
   : Hashtable - 동기화 지원
   : TreeMap - 키 순서로 정렬. 키는 Comparable 인터페이스가 구현되어 있어야 함
 */
public class Ex03_Map {
	public static void main(String[] args) {
		//  키, 값
		Map<String, Integer> map = new HashMap<String, Integer>();
		
		// map에 값 저장
		map.put("서울", 1000);
		map.put("부산", 350);
		map.put("대구", 250);
		map.put("인천", 350);
		map.put("광주", 150);
		map.put("대전", 150);
		map.put("울산", 110);
		map.put("세종", 20);
		map.put("서울", 980); // 동일한 키는 기존 값을 덮어씀
		System.out.println(map);
		
		// map에서 값 가져오기
		int n = map.get("서울");
		System.out.println(n);
		
		boolean b = map.containsKey("서울");
		System.out.println("키로 서울이 존재 ? " + b);
		b = map.containsValue(350);
		System.out.println("값으로 350이 존재 ? " + b);
		
		System.out.println("map의 전체 데이터 개수 : " + map.size());
		
		map.remove("세종"); // 키가 세종이 데이터 삭제
		System.out.println(map);
		
		// Map은 Iterator이 존재하지 않음. 향상된 for 문도 사용 불가
		// 키는 처음부터 끝까지 순회 가능(Iterator이 존재)
		System.out.println("\n전체 리스트...");
		Set<String> keySet = map.keySet(); // 키에서 Set 객체를 반환
		Iterator<String> it = keySet.iterator();
		while(it.hasNext()) {
			String key = it.next();
			Integer value = map.get(key);
			System.out.println(key + " -> " + value);
		}
		
	}
}

Map의 구현 클래스는 HashMap이다

 

전체 리스트를 출력하기 위한 소스

 

Set<String> keySet = map.keySet(); // 키에서 Set 객체를 반환
		Iterator<String> it = keySet.iterator();
		while(it.hasNext()) {
			String key = it.next();
			Integer value = map.get(key);
			System.out.println(key + " -> " + value);
		}

Iterator를 사용해서 출력

 

package ex0802;

import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Ex04_Map {

	public static void main(String[] args) {
		Map<String, Integer> map = new HashMap<String, Integer>();
		map.put("자바", 80);
		map.put("오라클", 90);
		map.put("빅데이터", 100);
		map.put("서블릿", 60);
		map.put("스프링", 80);
		
		// map의 키를 Set으로 가져오기
		System.out.println("map의 키를 Set으로 가져오기");
		Set<String> set = map.keySet();
		System.out.println(set);
		
		System.out.println("\nmap의 값을 List로 가져오기");
		List<Integer> list = new LinkedList<Integer>(map.values());
		System.out.println(list);
		
		System.out.println("\nmap 전체 리스트 - 1");
		Iterator<String> it = map.keySet().iterator();
		while(it.hasNext()) {
			String key = it.next();
			int value = map.get(key);
			System.out.println(key + " -> " + value);
		}
		
		System.out.println("\nmap 전체 리스트 - 2");
		for(String key : map.keySet()) {
			int value = map.get(key);
			System.out.println(key + " -> " + value);
		}

	}
}

 

Map에서 일부분만 출력

package ex0802;

import java.util.Map;
import java.util.TreeMap;

public class Ex05_Map {

	public static void main(String[] args) {
		// TreeMap : 키로 정렬하여 저장. 키는 Comparable 인터페이스가 구현 되어 있어야 함
		// Map<String, Integer> map = new TreeMap<>();
		
		TreeMap<String, Integer> map = new TreeMap<>();
		map.put("서울", 1000);
		map.put("부산", 350);
		map.put("대구", 250);
		map.put("인천", 350);
		map.put("광주", 150);
		map.put("대전", 150);
		map.put("울산", 110);
		map.put("세종", 20);
		
		System.out.println(map);
		
		Map<String, Integer> subMap = map.subMap("대전", "세종");
		System.out.println(subMap); // 대전에서 세종 전까지
	}
}

 

 

Entry

package ex0802;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
 - entry
   : 키와 값을 Set 형태로 저장
   : 키와 값을 묶어주기 위해 entry를 사용
 - Map.Entry
   : 맵의 엔트리(키와 값의 페어)
   : Map.entrySet 메소드는 캡의 컬렉션 뷰를 반환 함
 */
public class Ex06_Entry {

	public static void main(String[] args) {
		Map<String, Integer> map = new HashMap<String, Integer>();
		map.put("서울", 1000);
		map.put("부산", 350);
		map.put("대구", 250);
		map.put("인천", 350);
		map.put("광주", 150);
		map.put("대전", 150);
		map.put("울산", 110);
		map.put("세종", 20);
		
		System.out.println("전체 리스트...");
		Set<Map.Entry<String, Integer>> set = map.entrySet();
		Iterator<Map.Entry<String, Integer>> it = set.iterator();
		while(it.hasNext()) {
			Map.Entry<String, Integer> e = it.next();
			String key = e.getKey();
			Integer value = e.getValue();
			System.out.println(key + " -> " + value);
		}
		

	}

}

entry는 키와 값을 Set의 형태로 저장( 키와 값을 묶어주기 위함)

 

 

Properties

package ex0802;

import java.util.Iterator;
import java.util.Properties;

/*
 - Properties
   : Hashtable를 상속 받음
   : 키와 값 모두 문자열(String)만 가능
   : 파일 저장 및 불러오기가 간단해서 환경 설정 등에서 많이 사용
 */
public class Ex07_Properties {

	public static void main(String[] args) {
		Properties p = new Properties();
		
		// Properties에 값 저장
		// p.setProperty("자바", 80); // 컴파일 오류. 키와 값 모두 문자열만가능
		p.setProperty("자바", "80"); // 키, 값
		// p.put("키", "값"); 도 가능하지만 권장하지 않음
		p.setProperty("오라클", "100");
		p.setProperty("스프링", "95");
		p.setProperty("서블릿", "90");
		
		// Properties 내용을 표준 출력 장치로 출력
		p.list(System.out);
		
		// Properties 값 불러오기
		String k, s;
		k = "자바";
		s = p.getProperty(k);
		System.out.println(s);
		
		System.out.println("\n전체 리스트...");
		// Iterator<String> it = p.keySet().iterator(); // 컴파일 오류
		Iterator<Object> it = p.keySet().iterator();
		while(it.hasNext()) {
			String key = (String) it.next();
			String value = p.getProperty(key);
			System.out.println(key + " -> " + value);
		}
		
	}

}

문자열만 가능 !

 

package ex0802;

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

public class Ex08_Properties {

	public static void main(String[] args) {
		Properties p = new Properties();
		p.setProperty("자바", "80");
		p.setProperty("스프링", "90");
		p.setProperty("서블릿", "85");
		p.setProperty("오라클", "90");
		p.setProperty("HTML", "100");
		
		p.list(System.out);
		
		// Properties에 저장된 내용을 파일로 저장
		String pathname = "subject.properties";
		// FileOutputStream : 파일 출력 바이트 스트림
		try( FileOutputStream fos = new FileOutputStream(pathname) ) {
			p.store(fos, "과목별 성적"); // Properties 내용을 파일에 저장
									// 영어나 숫자 이외는 유니코드로 저장
			
			System.out.println("파일 저장 완료...");
		} catch (IOException e) {
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}

}

 

package ex0802;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

public class Ex09_Properties {

	public static void main(String[] args) {
		String pathname = "subject.properties";
		Properties p = new Properties();
		
		// 파일에 저장된 프로퍼티 값 불러오기
		// FileInputStream
		//  : 파일의 내용을 읽어 내는 바이트 스트림
		//  : 파일이 없으면 FileNotFoundException 발생
		try( FileInputStream fis = new FileInputStream(pathname) ) {
			p.load(fis); // 파일 내용을 읽어 Properties에 저장
			
			p.list(System.out);
			
			String s = p.getProperty("자바");
			System.out.println("자바 : " + s);
			
		} catch (IOException e) {
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

}

 

Stack

package ex0802;

import java.util.Stack;

/*
  - Stack
    : LIFO 구조
    : Vector의 하위 클래스(Vector 클래스의 메소드 사용은 권장 하지 않음)
    : 주요 메소드
      push(E e) : 스택에 데이터 추가
      pop() : top 요소를 반환 후 삭제
      peek() :  top 요소를 반환 후 삭제 하지 않음
 */
public class Ex10_Stack {
	public static void main(String[] args) {
		Stack<String> s = new Stack<String>();
		
		// 스택에 데이터 추가
		s.push("검정");
		s.push("노랑");
		s.push("녹색");
		s.push("청색");
		s.push("빨강");
		
		/*
		String st2r = s.pop();
		System.out.println(st2r);
		*/
		
		while( ! s.empty()) {
			String str = s.pop(); // 스택 top 위치 요소 반환 후 삭제
			System.out.println(str);
		}
		
		
	}
}

LIFO의 구조..

 

 

Queue

package ex0802;

import java.util.LinkedList;
import java.util.Queue;

/*
 - Queue 인터페이스
   : FIFO 구조
   : 주요 구현 클래스 - LinkedList
   : 주요 메소드
     peek() : head 값을 반환. 반환 후 삭제하지 않음. 없으면 null
     poll() : head 값을 반환. 반환 후 삭제. 없으면 null
     offer() : 큐의 마지막에 삽입
 */
public class Ex11_Queue {

	public static void main(String[] args) {
		Queue<String> q = new LinkedList<String>();
		
		q.offer("자바");
		q.offer("오라클");
		q.offer("서블릿");
		q.offer("스프링");
		q.offer("자바스크립트");
		
		while(q.peek() != null) {
			String s = q.poll();
			System.out.println(s);
		}
	}
}

 

 

PriorityQueue

package ex0802;

import java.util.PriorityQueue;

/*
 - PriorityQueue
   : 우선 순위 큐
   : Comparable 인터페이스 구현 클래스 만 가능. 그렇지 않으면 런타임 오류
 */
public class Ex12_PriorityQueue {

	public static void main(String[] args) {
		PriorityQueue<String> q = new PriorityQueue<String>();
		
		q.offer("자바");
		q.offer("오라클");
		q.offer("서블릿");
		q.offer("스프링");
		q.offer("자바스크립트");
		System.out.println(q);
		
		while(q.peek() != null) {
			String s = q.poll();
			System.out.println(s);
		}
	}

}

package ex0802;

import java.util.PriorityQueue;

public class Ex13_PriorityQueue {

	public static void main(String[] args) {
		PriorityQueue<TestVO> q = new PriorityQueue<TestVO>();
		q.offer(new TestVO("홍길동", 25));
		q.offer(new TestVO("김자바", 20));
		q.offer(new TestVO("스프링", 23));
		q.offer(new TestVO("오라클", 24));
		
		while( q.peek() != null ) {
			TestVO vo = q.poll();
			System.out.println(vo.getName() +" : " + vo.getAge());
		}

	}
}

class TestVO implements Comparable<TestVO>{
	private String name;
	private int age;
	
	public TestVO() {
	}
	public TestVO(String name, int age) {
		this.name = name;
		this.age = age;
	}

	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 int compareTo(TestVO o) {
		return age - o.getAge();
	}
}

 

 

Shuffle

package ex0802;

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

public class Ex14_Shuffle {

	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		
		list.add("java");
		list.add("spring");
		list.add("html");
		list.add("css");
		list.add("javascript");
		
		System.out.println(list);
		
		// Shuffle(무작위로 섞기)
		Collections.shuffle(list);
		System.out.println("Shuffle 후 : "+list);
		
		// 배열 Shuffle => List로 변환해서 Shuffle
		String[] ss = new String[] {"java","spring","html","css","javascript"};
		System.out.println("\n문자열 배열:" + Arrays.toString(ss));
		
		Collections.shuffle(Arrays.asList(ss));
		System.out.println("문자열 배열 Shuffle 후:" + Arrays.toString(ss));
		
		// int[]는 Shuffle 불가
		Integer[] ii = {10, 13, 20, 17, 30, 50, 34};
		System.out.println("\n정수 배열:" + Arrays.toString(ii));
		
		Collections.shuffle(Arrays.asList(ii));
		System.out.println("정수 배열 Shuffle 후:" + Arrays.toString(ii));
	}
}

package ex0802;

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

public class Ex15_Shuffle {

	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		
		list.add("java");
		list.add("spring");
		list.add("html");
		list.add("css");
		list.add("javascript");
		
		System.out.println(list);
		
		// Shuffle 구현
		String s;
		int n;
		for(int i=0; i<list.size(); i++) {
			n = (int) (Math.random() * list.size());
			if(n != i) {
				s = list.get(i);
				list.set(i, list.get(n));
				list.set(n, s);
			} else {
				i--;
			}
		}
		
		System.out.println("Shuffle 후 : "+list);
		
	
	}
}

 

 

TreeSet

package ex0802;

import java.util.Set;
import java.util.TreeSet;

public class Ex16_TreeSet {
	public static void main(String[] args) {
		// Set<DemoVO> set = new HashSet<DemoVO>();
		Set<DemoVO> set = new TreeSet<DemoVO>();
		
		set.add(new DemoVO("가가가", 80));
		set.add(new DemoVO("도도도", 75));
		set.add(new DemoVO("나나나", 90));
		set.add(new DemoVO("가거거", 70));
		set.add(new DemoVO("하하하", 100));
		
		
		System.out.println("점수 내림차순...");
		for(DemoVO vo : set) {
			System.out.println(vo.getName() + " : " + vo.getScore());
		}
		
	}
}

class DemoVO implements Comparable<DemoVO> {
	private String name;
	private int score;
	
	public DemoVO() {
	}
	public DemoVO(String name, int score) {
		this.name = name;
		this.score = score;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getScore() {
		return score;
	}
	public void setScore(int score) {
		this.score = score;
	}
	
	@Override
	public int compareTo(DemoVO o) {
		return - (score - o.getScore());
	}
}

마지막 오버라이드로 재정의 해준 모습

점수로 내림차순을 하게 된다.