230823_컬렉션 프레임워크 2

[ArrayListTest02.java]

package kr.or.ddit.basic;

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

/*
 * 문제 ) 5명의 사람 이름을 입력받아 ArrayList에 추가한 후에
 * 	    ArrayList에 저장된 이름들 중에 '김'씨 성의 이름을 모두 출력하시오.
 * 		(단, 입력은 Scanner 객체를 이용한다.)
 */

public class ArrayListTest02 {
	
	static Scanner sc = new Scanner(System.in);

	public static void main(String[] args) {
		
		ArrayList<String> nameList = new ArrayList<String>();
		
		System.out.println("5명의 이름을 입력하세요...");
		for(int i=0; i<5; i++) {
			System.out.print((i+1) + "번째 사람 이름 >> ");
			String name = sc.nextLine();
			nameList.add(name);
		}
		
		System.out.println();
		
		System.out.println("김씨 성을 가진 사람들...");
		for(int i=0; i<nameList.size(); i++) {
			// 첫번째 방법
//			if(nameList.get(i).substring(0, 1).equals("김")) {
//				System.out.println(nameList.get(i));
//			}
			
			// 두번째 방법
//			if(nameList.get(i).charAt(0) == '김') {
//				System.out.println(nameList.get(i));
//			}
			
			// 세번째 방법
//			if(nameList.get(i).startsWith("김")) {
//				System.out.println(nameList.get(i));
//			}
			
			// 네번째 방법
//			if(nameList.get(i).indexOf("김") == 0) {
//				System.out.println(nameList.get(i));
//			}
			
			// 다섯번째 방법
			if(nameList.get(i).subSequence(0, 1).equals("김")) {
				System.out.println(nameList.get(i));
			}
		}
		
	}

}

---

[ArrayListTest03.java]

package kr.or.ddit.basic;

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

/*
 * 문제1) 5명의 별명을 입력받아 ArrayList에 추가한 후 이들 중
 *      별명의 길이가 제일 긴 별명을 출력하시오.
 *      (단, 각 별명의 길이는 모두 다르게 입력한다.)
 */

public class ArrayListTest03 {

	static Scanner sc = new Scanner(System.in);
	
	public static void main(String[] args) {
		
//		ArrayList<String> nameList = new ArrayList<String>();
//		
//		System.out.println("5명의 별명을 입력하세요...");
//		for(int i=0; i<5; i++) {
//			System.out.print((i+1) + "번째 별명 이름 >> ");
//			String name = sc.nextLine();
//			nameList.add(name);
//		}
//		
//		System.out.println();
//		
//		System.out.println("별명의 길이가 제일 긴 별명은?");
//		
//		String temp = aliasList.get(0);
//		int cnt = aliasList.get(0).length();
//		for(int i=0; i<nameList.size(); i++) {
////			System.out.println(nameList.get(i).length());
//			if(nameList.get(i).length() > cnt) {
//				cnt = nameList.get(i).length();
//				temp = nameList.get(i).toString();
//			}
//		}
//		
//		System.out.println(temp);
//		
//		System.out.println("--------------------------");
		
		ArrayList<String> aliasList = new ArrayList<String>();
		
		System.out.println("서로 다른 길이의 별명을 5번 입력하세요...");
		for(int i=0; i<5; i++) {
			System.out.print((i+1) + "번째 별명 >> ");
			String alias = sc.nextLine();
			aliasList.add(alias);
		}
		
		System.out.println();
		
		// 제일 긴 별명이 저장될 변수 선언 ==> 이 변수에는 List의 첫 번째 데이터
		String maxAlias = aliasList.get(0);
		
		for(int i=1; i<aliasList.size(); i++) {
			if(maxAlias.length() < aliasList.get(i).length()) {
				maxAlias = aliasList.get(i);
			}
		}
		
		System.out.println("제일 긴 별명 : " + maxAlias);
		
	}

}

---

[ArrayListTest04.java]

package kr.or.ddit.basic;

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

/*
 * 문제2) 문제 1에서 입력할 때 각 별명의 길이가 같은 것이 있을 경우에 대하여 처리하시오.
 */
public class ArrayListTest04 {
	
	static Scanner sc = new Scanner(System.in);

	public static void main(String[] args) {
		
		ArrayList<String> aliasList = new ArrayList<String>();
		
		System.out.println("별명을 5번 입력하세요...");
		for(int i=0; i<5; i++) {
			System.out.print((i+1) + "번째 별명 >> ");
			String alias = sc.nextLine();
			aliasList.add(alias);
		}
		
		System.out.println();
		
		// 제일 긴 별명의 길이가 저장될 변수 선언 ==> 이 변수는 첫 번째 데이터의 길이로 초기화한다.
		int maxLength = aliasList.get(0).length();
		
		for(int i=1; i<aliasList.size(); i++) {
			if(maxLength < aliasList.get(i).length()) {
				maxLength = aliasList.get(i).length();
			}
		}
		
		System.out.println("제일 긴 별명들...");
		for(int i=0; i<aliasList.size(); i++) {
			if(maxLength == aliasList.get(i).length()) {
				System.out.println(aliasList.get(i));
			}
		}
		
	}

}

---

[StackQueueTest.java]

package kr.or.ddit.basic;

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

/*
 * 		Stack ==> Last In First Out(LIFO), 후입선출
 * 		Queue ==> First In First Out(FIFO), 선입선출
 * 
 * 		Stack과 Queue는 LinkedList를 이용하여 사용할 수 있다.
 * 		(Stack은 'Stack'이라는 클래스를 제공해 준다.)
 */
public class StackQueueTest {

	public static void main(String[] args) {
		
		/*
		 * - Stack의 명령
		 * 1. 자료 입력 : push(입력값)
		 * 2. 자료 출력 : pop() ==> 자료를 꺼내온 후 꺼내온 자료를 Stack에서 삭제한다.
		 * 			   peek() ==> 삭제 없이 자료를 꺼내온다.
		 */
		
		Stack<String> stack = new Stack<String>();
		
		stack.push("홍길동");
		stack.push("일지매");
		stack.push("변학도");
		stack.push("강감찬");
		
		System.out.println("현재 stack값 : " + stack); // 현재 stack값 : [홍길동, 일지매, 변학도, 강감찬]
		System.out.println();
		
		String data = stack.pop();
		System.out.println("1번째 pop()으로 꺼내온 값 : " + data); // 1번째 pop()으로 꺼내온 값 : 강감찬
		System.out.println("2번째 pop()으로 꺼내온 값 : " + stack.pop()); // 2번째 pop()으로 꺼내온 값 : 변학도
		System.out.println("현재 stack값 : " + stack); // 현재 stack값 : [홍길동, 일지매]
		System.out.println();
		
		stack.push("성춘향");
		System.out.println("push()로 추가한 후 stack값 : " + stack); // push()로 추가한 후 stack값 : [홍길동, 일지매, 성춘향]
		System.out.println("pop()으로 꺼내온 값 : " + stack.pop()); // pop()으로 꺼내온 값 : 성춘향
		System.out.println("현재 stack값 : " + stack); // 현재 stack값 : [홍길동, 일지매]
		System.out.println();
		
		System.out.println("삭제없이 꺼내온 값 : " + stack.peek()); // 삭제없이 꺼내온 값 : 일지매
		System.out.println("현재 stack값 : " + stack); // 현재 stack값 : [홍길동, 일지매]
		System.out.println();
		System.out.println("-------------------------------------");
		System.out.println();
		
		/*
		 * - Queue의 명령
		 * 1. 자료 입력 : offer(입력값)
		 * 2. 자료 출력 : poll() ==> 자료를 꺼내오고 꺼내온 자료를 Queue에서 삭제한다.
		 * 			   peek() ==> 삭제없이 자료를 꺼내온다.
		 */
		
		Queue<String> queue = new LinkedList<String>();
		
		queue.offer("홍길동");
		queue.offer("일지매");
		queue.offer("변학도");
		queue.offer("강감찬");
		
		System.out.println("현재 queue의 값 : " + queue); // 현재 queue의 값 : [홍길동, 일지매, 변학도, 강감찬]
		System.out.println();
		
		String temp = queue.poll();
		System.out.println("꺼내온 값 : " + temp); // 꺼내온 값 : 홍길동
		System.out.println("꺼내온 값 : " + queue.poll()); // 꺼내온 값 : 일지매
		System.out.println("현재 queue의 값 : " + queue); // 현재 queue의 값 : [변학도, 강감찬]
		System.out.println();
		
		queue.offer("성춘향");
		System.out.println("offer()로 추가한 후 queue의 값 : " + queue); // offer()로 추가한 후 queue의 값 : [변학도, 강감찬, 성춘향]
		System.out.println("꺼내온 값 : " + queue.poll()); // 꺼내온 값 : 변학도
		System.out.println("현재 queue의 값 : " + queue); // 현재 queue의 값 : [강감찬, 성춘향]
		System.out.println();
		
		System.out.println("삭제없이 꺼내온 값 : " + queue.peek()); // 삭제없이 꺼내온 값 : 강감찬
		System.out.println("현재 queue의 값 : " + queue); // 현재 queue의 값 : [강감찬, 성춘향]
		System.out.println();
		
	}

}

---

[StackTest.java]

package kr.or.ddit.basic;

import java.util.Stack;

public class StackTest {

	public static void main(String[] args) {
		
		Browser b= new Browser();
		
		b.goURL("1. 네이버");
		b.history();
		
//		1. 네이버 사이트에 접속합니다...
//
//		--------------------------
//		         방 문 기 록
//		--------------------------
//		back    ==> []
//		현재페이지 ==> 1. 네이버
//		forward ==> []
//		--------------------------
		
		b.goURL("2. 야후");
		b.history();
		
//		2. 야후 사이트에 접속합니다...
//
//		--------------------------
//		         방 문 기 록
//		--------------------------
//		back    ==> [1. 네이버]
//		현재페이지 ==> 2. 야후
//		forward ==> []
//		--------------------------
		
		b.goURL("3. 구글");
		b.history();
		
//		3. 구글 사이트에 접속합니다...
//
//		--------------------------
//		         방 문 기 록
//		--------------------------
//		back    ==> [1. 네이버, 2. 야후]
//		현재페이지 ==> 3. 구글
//		forward ==> []
//		--------------------------
		
		b.goURL("4. 다음");
		b.history();
		
//		4. 다음 사이트에 접속합니다...
//
//		--------------------------
//		         방 문 기 록
//		--------------------------
//		back    ==> [1. 네이버, 2. 야후, 3. 구글]
//		현재페이지 ==> 4. 다음
//		forward ==> []
//		--------------------------
		
		System.out.println("뒤로 가기 후...");
		b.goBack();
		b.history();
		
//		뒤로 가기 후...
//
//		--------------------------
//		         방 문 기 록
//		--------------------------
//		back    ==> [1. 네이버, 2. 야후]
//		현재페이지 ==> 3. 구글
//		forward ==> [4. 다음]
//		--------------------------
		
		System.out.println("뒤로 가기 후...");
		b.goBack();
		b.history();
		
//		뒤로 가기 후...
//
//		--------------------------
//		        방 문 기 록
//		--------------------------
//		back    ==> [1. 네이버]
//		현재페이지 ==> 2. 야후
//		forward ==> [4. 다음, 3. 구글]
//		--------------------------
		
		System.out.println("앞으로 가기 후...");
		b.goForward();
		b.history();
		
//		앞으로 가기 후...
//
//		--------------------------
//		         방 문 기 록
//		--------------------------
//		back    ==> [1. 네이버, 2. 야후]
//		현재페이지 ==> 3. 구글
//		forward ==> [4. 다음]
//		--------------------------
		
		System.out.println("새로운 사이트 접속 후..."); // forward를 비워야 한다.
		b.goURL("5. 네이트");
		b.history();
		
//		새로운 사이트 접속 후...
//		5. 네이트 사이트에 접속합니다...
//
//		--------------------------
//		         방 문 기 록
//		--------------------------
//		back    ==> [1. 네이버, 2. 야후, 3. 구글]
//		현재페이지 ==> 5. 네이트
//		forward ==> []
//		--------------------------
		
	}

}

// 웹브라우저의 앞으로 가기, 뒤로 가기 기능 구현하기(Stack 이용)
class Browser {
	
	private Stack<String> back; // 이전 방문 내역이 저장될 스택, url 주소가 문자열.
	private Stack<String> forward; // 다음 방문 내역이 저장될 스택, url 주소가 문자열.
	private String currentURL; // 현재 페이지 주소가  저장될 변수.
	
	// 생성자
	public Browser() {
		back = new Stack<String>();
		forward = new Stack<String>();
		currentURL = "";
	}
	
	// 사이트를 방문하는 메서드 ==> 매개변수에 방문할 URL주소가 저장된다.
	public void goURL(String url) {
		System.out.println(url + " 사이트에 접속합니다...");
		
		if(currentURL != null && !"".equals(currentURL)) { // 현재 페이지가 있으면...
			back.push(currentURL); // 현재 페이지를 back 스택에 추가한다.
		}
		currentURL = url; // 현재 페이지를 변경한다.
		forward.clear(); // forward스택의 데이터를 전부 삭제한다.
	}
	
	// 뒤로 가기 기능 구현
	public void goBack() {
		// isEmpty() ==> Collection에 데이터가 없으면 true, 그렇지 않으면 false를 반환한다.
		if(!back.isEmpty()) { // back스택에 값이 있으면...
			forward.push(currentURL); // 현재 페이지를 forward 스택에 추가한다.
			currentURL = back.pop(); // back 스택에서 1개의 요소를 꺼내와 현재 페이지로 한다.
		}
	}
	
	// 앞으로 가기 기능 구현
	public void goForward() {
		if(!forward.isEmpty()) { // forward스택에 값이 있으면...
			back.push(currentURL); // 현재 페이지를 back스택에 추가한다.
			currentURL = forward.pop(); // forward 스택에서 1개의 요소를 꺼내와 현재 페이지로 한다.
		}
	}
	
	// 방문 기록 확인하기
	public void history() {
		System.out.println();
		System.out.println("--------------------------");
		System.out.println("         방 문 기 록");
		System.out.println("--------------------------");
		System.out.println("back    ==> " + back);
		System.out.println("현재페이지 ==> " + currentURL);
		System.out.println("forward ==> " + forward);
		System.out.println("--------------------------");
		System.out.println();
	}
	
}

---

[ListSortTest01.java]

package kr.or.ddit.basic;

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

public class ListSortTest01 {

	public static void main(String[] args) {
		
		ArrayList<String> list = new ArrayList<String>();
		
		list.add("일지매");
		list.add("홍길동");
		list.add("성춘향");
		list.add("변학도");
		list.add("이순신");
		
		System.out.println("정렬 전 : " + list); // 정렬 전 : [일지매, 홍길동, 성춘향, 변학도, 이순신]
		
		// 정렬은 Collections.sort() 메서드를 이용하여 정렬한다.
		// Collections.sort() 메서드는 기본적으로 내부 정렬 기준으로 정렬한다.
		Collections.sort(list);
		
		System.out.println("오름차순 정렬 후 : " + list); // 오름차순 정렬 후 : [변학도, 성춘향, 이순신, 일지매, 홍길동]
		
		// 내부 정렬 기준? 리스트 안에 들어간 데이터 종류에 따라 정렬. 
		// String 클래스 안에는 이미 정렬 기준이 있다는 말.
		// ㄱ~ㅎ 순으로 오름차순 정렬.
		// a~z, A~z 순으로 오름차순 정렬.
		
		// 내림차순 정렬은 어떻게 할까? 이럴 때를 대비해서 내가 정렬 기준을 만들 수 있다. 즉, 오름차순일지 내림차순일지에 대한 기준을 설정할 수 있다.
		
		Collections.shuffle(list); // 자료 섞기
		System.out.println("자료 섞은 후 : " + list); // 다시 실행 될 때마다 난수를 이용해 순서가 바뀜.
		
		// 외부 정렬 기준 클래스를 지정해서 정렬하기
		Collections.sort(list, new Desc());
		System.out.println("내림차순 정렬후 : " + list); // 내림차순 정렬후 : [홍길동, 일지매, 이순신, 성춘향, 변학도]
		
	}

}

/*

	정렬(sort)와 관련된 interface는 Comparable, Comparator 이렇게 두 가지가 있다.
	
	- Comparable은 Collection에 추가되는 데이터 자체에 정렬 기준을 넣고 싶을 때(내부 정렬 기준)
	    구현하는 인터페이스이다.
	- Comparator는 외부에 별도로 정렬 기준을 구현하고 싶을 때(외부 정렬 기준) 구현하는 인터페이스이다.
	
	- Comparable에서는 compareTo() 메서드를 재정의하고
	  Comparator에서는 compare() 메서드를 재정의해야 한다.
	  
	- String클래스, Wrapper클래스, Date클래스, File클래스 등에는 이미 내부 정렬 기준이 구현되어 있다.
	  (내부 정렬 기준은 오름차순으로 처리되도록 구현되어 있다.)

*/

// 1, 4, 6, 2, 5

// 정렬 방식을 정해주는 class를 작성한다. (외부 정렬 기준 클래스라고 한다.)
// Comparator 인터페이스를 구현해서 작성한다.
class Desc implements Comparator<String> {
	
	// compare() 메서드의 매개변수는 서로 인접한 2개의 데이터가 저장된다고 가정하여 처리한다.
	
	// compare() 메서드의 반환값의 의미
	// 반환값이 '0'이라면 두 값이 같다. (순서는 바뀌지 않는다.)
	// 반환값이 양수일 경우에는 앞, 뒤의 순서를 바꾼다.
	// 반환값이 음수일 경우에는 순서를 바꾸지 않는다.
	
	// 예) 오름차순 정렬일 경우 ==> 앞의 값이 크면 양수, 같으면 0, 앞의 값이 작으면 음수를 반환하도록 구현한다.
	@Override
	public int compare(String str1, String str2) {
		// 내림차순으로 구현하려 한다.
//		if(str1.compareTo(str2) > 0) {
//			return -1; // 앞의 수가 크고 뒤의 수가 작으므로 내림차순일 경우 순서를 바꾸면 안 된다.
//		}else if(str1.compareTo(str2) < 0) {
//			return 1; // 앞의 수가 작고 뒤의 수가 크므로 내림차순일 경우 순서를 바꿔야 한다.
//		}else {
//			return 0; // 두 값이 같으므로 순서를 바꾸지 않는다.
//		}
		
		return str1.compareTo(str2) * -1;
	}
	
}

---

[ListSortTest02.java]

package kr.or.ddit.basic;

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

public class ListSortTest02 {

	public static void main(String[] args) {
		
		ArrayList<Member> memList = new ArrayList<Member>();
		
		memList.add(new Member(1, "홍길동", "010-1111-1111"));
		memList.add(new Member(5, "이순신", "010-2222-1111"));
		memList.add(new Member(9, "성춘향", "010-3333-1111"));
		memList.add(new Member(3, "강감찬", "010-4444-1111"));
		memList.add(new Member(6, "일지매", "010-5555-1111"));
		memList.add(new Member(2, "변학도", "010-6666-1111"));
		
		System.out.println("정렬전...");
		for(Member mem : memList) {
			System.out.println(mem);
		}
		System.out.println("--------------------------------------------");
		
		// Member의 num값의 내림차순으로 정렬하는 외부 정렬 기준 클래스를 이용하여 정렬하시오.
		// (클래스명 : SortNumDesc)
		
		// 외부 정렬 기준 클래스를 지정해서 정렬하기
		Collections.sort(memList, new SortNumDesc());
		
		System.out.println("정렬후...");
		for(Member mem : memList) {
			System.out.println(mem);
		}
		
	}

}

class Member {
	
	private int num;
	private String name;
	private String tel;
	
	// 생성자, alt+shift+s로 자동 생성.
	public Member() {}
	public Member(int num, String name, String tel) {
		this.num = num;
		this.name = name;
		this.tel = tel;
	}
	
	// getter, setter, alt+shift+s로 자동 생성.
	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 String getTel() {
		return tel;
	}
	
	public void setTel(String tel) {
		this.tel = tel;
	}
	
	@Override
	public String toString() {
		return "Member [num=" + num + ", name=" + name + ", tel=" + tel + "]";
	}
	
}

// SortNumDesc
class SortNumDesc implements Comparator<Member> {
	
	// compare() 메서드의 매개변수는 서로 인접한 2개의 데이터가 저장된다고 가정하여 처리한다.
	
	// compare() 메서드의 반환값의 의미
	// 반환값이 '0'이라면 두 값이 같다. (순서는 바뀌지 않는다.)
	// 반환값이 양수일 경우에는 앞, 뒤의 순서를 바꾼다.
	// 반환값이 음수일 경우에는 순서를 바꾸지 않는다.
	
	// 예) 오름차순 정렬일 경우 ==> 앞의 값이 크면 양수, 같으면 0, 앞의 값이 작으면 음수를 반환하도록 구현한다.
	@Override
	public int compare(Member mem1, Member mem2) {
		
//		Integer num1 = mem1.getNum();
//		Integer num2 = mem2.getNum();
//		
//		// 내림차순으로 구현하려 한다.
//		if(num1.compareTo(num2) > 0) {
//			return -1; // 앞의 수가 크고 뒤의 수가 작으므로 내림차순일 경우 순서를 바꾸면 안 된다.
//		}else if(num1.compareTo(num2) < 0) {
//			return 1; // 앞의 수가 작고 뒤의 수가 크므로 내림차순일 경우 순서를 바꿔야 한다.
//		}else {
//			return 0; // 두 값이 같으므로 순서를 바꾸지 않는다.
//		}
		
		/////////////////////////////////////////////
		
		if(mem1.getNum() > mem2.getNum()) {
			return -1;
		}else if(mem1.getNum() < mem2.getNum()) {
			return 1;
		}else {
			return 0;
		}
		
	}
	
}