매료매료의 개발 이야기

package Week03.day0724;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;


public class practice0724 {

	public static void main(String[] args) throws ParseException {
		
//		java.util.Date 쓰는 법 
//		SimpleDateFormat f = new SimpleDateFormat("MM-dd HH:mm")
//		f.parse("07-01 15:30")
		
		SimpleDateFormat f = new SimpleDateFormat("MM-dd HH:mm");
		
		ParkingLotAdm pla = new ParkingLotAdm(f.parse("07-01 06:00"), f.parse("07-31 24:00"), 5); 
		// "HH:mm:ss"
		
		Car cr1 = new Car("22나7077", f.parse("07-01 06:00"), f.parse("07-01 06:30"), 500, f.parse("07-01 06:00"));
		Car cr2 = new Car("22나7078", f.parse("07-01 06:10"), f.parse("07-01 06:50"), 500, f.parse("07-01 06:00"));
		Car cr3 = new Car("22나7079", f.parse("07-01 06:20"), f.parse("07-01 07:30"), 500, f.parse("07-01 06:00"));
		Car cr4 = new Car("22나7070", f.parse("07-01 06:30"), f.parse("07-01 08:30"), 500, f.parse("07-01 06:00"));
		Car cr5 = new Car("22나7071", f.parse("07-01 06:40"), f.parse("07-01 10:30"), 500, f.parse("07-01 06:00"));
		
		pla.addCar(cr1);
		pla.addCar(cr2);
		pla.addCar(cr3);
		pla.addCar(cr4);
		pla.addCar(cr5);
		
		ArrayList al = new ArrayList();
		
//		pla.carSort(Car car);
		
		pla.outCar(cr1);
		pla.outCar(cr2);
		pla.outCar(cr3);
		
	}
}

class ParkingLotAdm{
	private Date startDt; // 주차장이 언제 열고 닫는지
	private Date endDt;
	private final int maxCarsu = 3; // 최대 수용자동차수
	private HashSet cars = new HashSet(); // 주차된 차들s
	private HashMap outCars = new HashMap(); // 나간 차들
	private ArrayList waitCars = new ArrayList(); // 대기중인 차들
	
	public ParkingLotAdm(Date startDt, Date endDt, int maxCarsu) {
		this.startDt = startDt;
		this.endDt = endDt;
	}
	
	public void addCar(Car car) { // 주차하는 차를 추가한다
		if(this.cars.size()< maxCarsu) {
//			Iterator it = this.cars.iterator(); // ★★★★★★★★★★★★★★★★★★★★★  this. !!!!!
//			while(it.hasNext()) {
//				Car e = (Car) it.next();
				this.cars.add(car);
				System.out.println("입고된 차량 번호 :" + car.getCarNo() + ", 입차시간 : " + car.getInDt());
		}else { 	
				waitCars.add(car);
				System.out.println("대기중인 차량 번호 :" + car.getCarNo() + ", 대기시간 : " + car.getWaitStrDt());
		}
	}
	
	public void outCar(Car car) throws ParseException {
		// 나가는 차를 제거하면 outCars에 추가하고 주차비용을 리턴한다 
		// + 출차시간 업데이트
		// 주차비용은 30분당 500원 이다
		// 주차대기중인 차가 있으면 주차시킨다(주차대기중인 차는 대기순서에 따라 주차됨.)
		// add된 순서대로 들어감.
		
		//나가는차 제거
		this.cars.remove(car);
		
		//outCars에 추가 + 출차시간 업데이트
		this.outCars.put(car.getCarNo(), car.getOutDt());
		System.out.println("출차차량번호 : " + car.getCarNo() + ", 출차시간 : " + car.getOutDt());
		Car.calTimeGap(car);
		
		//주차비용 계산(Date)
//		SimpleDateFormat transFormat = new SimpleDateFormat("HH:mm:ss");
//		String st_inDt = transFormat.format(car.getInDt());
//		String st_outDt = transFormat.format(car.getOutDt());
//		int new_inDt = Integer.parseInt(st_inDt);
//		int new_outDt = Integer.parseInt(st_outDt);
		
		//주차비용 계산(String으로)
//		int new_inDt = Integer.parseInt(car.getInDt());
//		int new_outDt = Integer.parseInt(car.getOutDt());
//		int hourDiff = new_outDt / 100 - new_inDt / 100; //시간의 차이
//		int minDiff = new_outDt % 100 - new_inDt % 100; // 분의 차이를 계산한다.
//		// 총 분의 시간을 계산하고 30분당 500원으로 계산한 후  출력한다.
//		int totDiff = hourDiff * 60 + minDiff;
//		int rateStd = 500;
//		int rate = totDiff / 30 * rateStd;
		
	}
	
	public void carSort(Car car, Comparator c) {
		//  파라미터로 전달한 정렬기준에 따라 주차차량을 Sort한다
		Collections.sort((List)car, c);
		System.out.println(car);
	}
	
//	public int compare(Car c1, Car c2) {
//		if (c1.getInDt() < c2.getInDt()) {
//			return -1;
//		} else if (Integer.parseInt(c1.getInDt()) > Integer.parseInt(c2.getInDt())) {
//            return 1;
//        }
//        return 0;
//	}
		
			//Comparator 방법 적용
			// 첫 번째 파라미터로 넘어온 객체 < 두 번째 파라미터로 넘어온 객체: 음수 리턴
		    // 첫 번째 파라미터로 넘어온 객체 == 두 번째 파라미터로 넘어온 객체: 0 리턴
			// 첫 번째 파라미터로 넘어온 객체 > 두 번째 파라미터로 넘어온 객체: 양수 리턴
			// 음수 또는 0이면 객체의 자리가 그대로 유지되며, 양수인 경우에는 두 객체의 자리가 변경된다.
	
}


class Car {
	private String carNo; //차량번호
	private Date inDt; // 입차시간
	private Date outDt; // 출차시간
	private int fee; // 수수료
	private Date waitStrDt; // 대기시작시간
	
	public Car(String carNo, Date inDt, Date outDt, int fee, Date waitStrDt) {
		this.carNo = carNo;
		this.inDt = inDt;
		this.outDt = outDt;
		this.fee = fee;
		this.waitStrDt = waitStrDt;
	}

	public String getCarNo() {
		return carNo;
	}

	public void setCarNo(String carNo) {
		this.carNo = carNo;
	}

	public Date getInDt() {
		return inDt;
	}

	public void setInDt(Date inDt) {
		this.inDt = inDt;
	}

	public Date getOutDt() {
		return outDt;
	}

	public void setOutDt(Date outDt) {
		this.outDt = outDt;
	}

	public int getFee() {
		return fee;
	}

	public void setFee(int fee) {
		this.fee = fee;
	}

	public Date getWaitStrDt() {
		return waitStrDt;
	}

	public void setWaitStrDt(Date waitStrDt) {
		this.waitStrDt = waitStrDt;
	}
	
	public int hashCode() {
		return Objects.hash(carNo);
	}
	
	public boolean equals(Object obj) {
		if (obj != null && obj instanceof Car) { // obj가 Car의 Instance
			return carNo.equals(((Car) obj).carNo); // 값이 같은지 비교
		} else {
			return false;
		}
	}
	
	 public static void calTimeGap(Car car) throws ParseException {
		  long diff = car.getOutDt().getTime() - car.getInDt().getTime();
		  long hour = diff / (1000*60*30); // 1000: 초로 만듬 , 60:시간으로 만듬, 30: 분으로 만듬.
		  long rate = 500 * (int)hour;
		  System.out.println("총 주차요금은 " + rate + "원입니다.");
	 }
}

//시간계산 유틸.

//class Utils{
//	 public static int calTimeGap(Date carIndt) throws ParseException {
//	  Date now = new Date(); // 현재시간
//	  long diff = now.getTime() - carIndt.getTime();
//	  long hour = diff / (1000*60*60);
//	  
//	  return (int)hour;
//	 }
//	 
//	 public static Date getDate(int year, int month, int date, int hour, int minute, int second) {
//	  Calendar cal = Calendar.getInstance();
//	  cal.set(year, month-1, date, hour, minute, second);
//	  cal.set(Calendar.MILLISECOND, 0);
//	  return cal.getTime();
//	 } 
//	 
//	 public static String getDate(Date date) {
//	  SimpleDateFormat format1 = new SimpleDateFormat ( "yyyy-MM-dd HH:mm:ss");
//	  return format1.format(date);
//	 }
//	}

주요내용 : DB Column Data Type

/* 주문된 상품 중에 가격이 5$이상이고 10%미만인 주문번호를 오름차순으로 추출 */
SELECT order_num
FROM Orderitems
Where item_price >= 5
AND item_price < 10;

/* 제품 중에 제조사가 ‘DLL01’이 아닌 제품명을 내림차순으로 추출*/
SELECT prod_name
FROM products
WHERE vend_id != 'DLL01' ORDER by prod_name DESC;

/*  IN 연산자 사용 // 제조업체가 DLL01과 BRS01인 모든 제품을 가져온다
NOT IN 이라고도 표현 가능.*/
SELECT prod_name, prod_price
FROM Products
WHERE vend_id IN('DLL01', 'BRS01')
ORDER By prod_name;

/* IN와 OR 연산자는 동일한 기능을 수행
OR보다 IN이 좋음.*/
SELECT prod_name, prod_price
FROM Products
WHERE vend_id = 'DLL01' OR vend_id = 'BSR01'
ORDER By prod_name;

/*NOT연산자 사용
DLL01 제조업체 이외에서 만든 모든 제품을 가져온다.*/
SELECT prod_name, prod_price
FROM Products
WHERE vend_id <> 'DLL01'
ORDER by Prod_name;

/*고객명이 ‘Kids Place’거나 ‘Village Toys’인 고객중에 사는 도시가 ‘Detroit’가 아닌 고객명 추출*/
SELECT cust_name
FROM CUSTOMERS
WHERE cust_name IN('Kids Place', 'Village Toys')
AND cust_city <> 'Detroit';

/* 제조업체명이 ‘Bear Emporium’ 거나 ‘Jouets et ours’인 제조업체 중에 주정보가 없는 제조업체명을 내림차순으로 추출 */
SELECT vend_name
FROM VENDORS
WHERE vend_name In('Bear Empourium', 'Jouets et ours')
AND vend_state is null;

/* 주문상품 중에 제품번호가 ‘BR03’ 거나 ‘BNBG01’이고 주문수량이 100개 이상인 주문번호를 오름차순으로 추출 */
SELECT prod_id, order_num, quantity
FROM Orderitems
WHERE prod_id in('BR03', 'BNBG01')
AND quantity >100 Order by order_num ASC;

/* 와일드카드를 사용한 필터링: 값의 일부가 일치하는 경우를 검색하는데 사용되는 특별한 문자 
 Fish라는 단어로 시작하는 모든 제품을 검색*/
SELECT prod_name, prod_price
FROM Products
WHERE prod_name LIKE 'Fish%';

/* bean bag라는 문구가 들어간 모든 제품을 검색 */
SELECT prod_name, prod_price
FROM Products
WHERE prod_name LIKE '%bean bag%';

/*F로 시작하고 y로 끝나는 모든 제품을 검색*/
SELECT prod_name, prod_price
FROM Products
WHERE prod_name LIKE '**'||RTRIM('F%y')||'**';

/* _ 는 단하나의 문자에 대해 아무문자나 허용하는 검색
언더바가 두개임.
앞에 어떤 두문장이 있음.
세문장은 틀린거임.*/
SELECT prod_id, prod_name
FROM Products
WHERE prod_name LIKE '__inch teddy bear';

/*고급필터링
1번
고객의 이름이 ‘Fun’로 시작되고 ‘M’로 시작되는 도시에 사는 고객명과 주소를 고객명을 내림차순으로 추출 
*/
SELECT cust_name, cust_address
From CUSTOMERS
WHERE cust_name LIKE 'Fun%'
AND cust_city LIKE 'M%'
ORDER by cust_name DESC;

/*2번
제품번호가 ‘B’로 시작되고 ‘1’로 끝나는 제품명과 제조사ID 그리고 제품가격을 제품가격 오름차순으로 추출 
*/
SELECT prod_id, vend_id, prod_price
FROM Products
WHERE prod_id LIKE 'B%1'
ORDER by prod_price ASC;

/*3번
 공급업체ID가 ‘D’로 시작되고 공급업체 시도 ‘D’로 시작하는 공급업체명과 공급업체주소를 공급업체명 오름차순으로 추출 
*/
SELECT vend_name, vend_address
FROM VENDORS
WHERE vend_id LIKE 'D%'
AND VEND_city LIKE 'D%'
ORDER by vend_name ASC;

/*4번
주문상품중에 제품번호ID에 ‘BG’가 포함되고 주문수량이 100개인 주문번호와 주문단가를 주문단가 오름차순으로 추출
*/
SELECT order_num, item_price
FROM orderitems
WHERE prod_id LIKE '%BG%'
AND quantity = 100 ORDER by item_price ASC;

/*필드의 결합*/
SELECT vend_name || '('||vend_country ||')'
FROM vendors
ORDER by vend_name;

/*공백의 제거*/
SELECT vend_name ||'('|| RTRIM(vend_country)||')'
FROM Vendors
ORDER by vend_name;

/*별칭 사용*/
SELECT vend_name ||'('|| RTRIM(vend_country)||')' vend_title
FROM vendors
ORDER by vend_name;

/*수학적계산*/
SELECT prod_id, quantity, item_price, quantity*item_price expanded_price
FROM OrderItems
WHERE order_num = 20008;

############### 비교 ##################

비교(Comparison) - 둘 이상의 사물을 견주어 서로 간의 유사점, 차이점, 일반 법칙 따위를 고찰하는 일.
연산자(Operator) - 어떤 작업을 컴퓨터에게 지시하기 위한 기호.

-> 비교연산자(Comparison operator) 사물을 비교하도록 컴퓨터에게 지시하는 기호.

기본으로 기준은 좌항

= 대입연산자 (Assignment Operator)  ## 비교연산자아닌 연산자의 한종류 ##

<비교연산자>
== 동등연산자 (equal operator)
=== 일치연산자 (strict equal operator) ; 같은 데이터 타입인경우만 true가 됨.
!= 부등연산자 (inequality) 
!== 불일치연산자 (strict inequality)
> Greater than operator
>= Greater than or equal operator 
< Less than operator 
<= Less than or equal operator 

==,===의 차이
만약 ==을 써 정밀하고 거대한 프로그램을 만들경우, 
데이터타입의 차이로 인해 Boolean 오류가 날수 있다.
즉, ===을 쓰면 그런 위험을 피할 수 있다. 그냥 === 쓰자.

<참고사이트>

http://dorey.github.io/JavaScript-Equality-Table/ (==과 ===의 차이점)

############### 조건문 ##################

조건문(Conditional statement)
if( * ){ ~ }에서 
괄호 안에는 조건으로 반드시 boolean 이 들어와야 하며,
그 boolean이 반드시 true가 될때만 중괄호 안의 ~가 실행된다.

//로그인 사용 로직

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8"/>
</head>
<body>
    <script>
        var id = prompt('아이디를 입력해주세요.');
        if(id=='egoing'){
            var password = prompt('비밀번호를 입력해주세요.');
            if(password==='111111'){
                alert('인증 했습니다.');
            } else {
                alert('인증에 실패 했습니다.');
            }
        } else {
            alert('인증에 실패 했습니다.');
        }
    </script>
</body>
</html>

논리연산자(Logical operators)
&& (Logical AND) - && 양쪽이 모두 true가 되어야, true.
|| (Logical OR) - || 양쪽의 하나라도 ture면, true.
! (Logical NOT ) - ! 뒤의 Boolean은 반대로 바뀐다. (!true -> false, !false -> true)

조건문안에 괄호()가 있으면, 괄호안을 먼저 실행한다.

############### 변수 ##################

변수 : 값을 담는 그릇(값을 유지할 필요가 있을 때)

var로 시작해서 변수 선언.
다른 값을 담을 수도 있다. 그럴 때는 다시 var 쓸 필요 없다.

변수에는 숫자, 문자 등등 어떤 것도 담길 수 있다.
그것들을 사용해서 연산, 결합 등 할 수 있다

변수 2개를 동시에 선언할 때는 var a = 1, b = 2의 형태로 var는 한 번만 쓰고 ,로 연결하면 된다.
변수는 코드의 재활용성을 높이기 위해서 쓴다.
이것은 코딩을 할 때 대단히 중요한 특성이다.

############### 주석 ##################

주석(comment) // ~~ or /* ~~ */
- 코드의 이해를 돕기위해 설명하거나, 코드를 비활성화 시킬때 사용.
- 나중에 잊어버렸을 때나, 타인과 협업할 때 유용.
-- 궁극적으로는, 쉽게 이해하고 가독성이 좋은 코드가 BEST.

############### 줄바꿈과 여백 ##################

; 세미콜론(semicolon)
- 명령이 끝났다는 표현
- 한줄에 여러 명령이 있을때, 구분하는 역할
- 자바스크립트는 줄바꿈을 해도 알아듣지만, 쓰는 것이 좋은 습관

여백(blank)은 가독성을 위해 쓴다.

package Week03.day0723;

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

class Customer<T extends Order> implements Comparable<Customer>{ //order를 포함한 하위에 대해서만 선언가능.(special도 가능)
	private String name;
	private int age;
	private int point;
	private ArrayList<T> orders = new ArrayList<>();
	
	Customer(String name, int age, int point) {
		this.name = name;
		this.age = age;
		this.point = point;
	}

	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;
	}

	public int getPoint() {
		return point;
	}

	public void setPoint(int point) {
		this.point = point;
	}

	public ArrayList<T> getOrders() {
		return orders;
	}

	public void addOrders(T order) {
		this.orders.add(order);
	}
	
	@Override
	public int compareTo(Customer o) { // Point로 Customer 정렬, SpecialCustomer는 bonus를 더해준다 //customer로 해야인식가능(아니면 object로 인식)
		System.out.println("비교 - Customer: " + this.name);
		int thisToPoint = point;
		int paramToPoint = 0;
		
		if(o instanceof SpecialCustomer) {
			paramToPoint = o.getPoint() + ((SpecialCustomer)o).getBonusPoint();
		} else {
			paramToPoint = o.getPoint();
		}
		
			//Comparator 방법 적용
			// 첫 번째 파라미터로 넘어온 객체 < 두 번째 파라미터로 넘어온 객체: 음수 리턴
		    // 첫 번째 파라미터로 넘어온 객체 == 두 번째 파라미터로 넘어온 객체: 0 리턴
			// 첫 번째 파라미터로 넘어온 객체 > 두 번째 파라미터로 넘어온 객체: 양수 리턴
			//음수 또는 0이면 객체의 자리가 그대로 유지되며, 양수인 경우에는 두 객체의 자리가 변경된다.
			if(thisToPoint < paramToPoint) {
				return -1;
			} else if (thisToPoint > paramToPoint) {
				return 1;
			}
			return 0;
	}
	
	public String toString() { // point만 출력
		return name + "/" + point;
	}
	
}

class SpecialCustomer<T extends SpecialOrder> extends Customer<T>{
	private int bonusPoint;
	
	public SpecialCustomer(String name, int age, int point, int bonuspoint) {
		super(name, age, point);
		this.bonusPoint = bonuspoint;
	}

	public int getBonusPoint() {
		return bonusPoint;
	}

	public void setBonusPoint(int bonusPoint) {
		this.bonusPoint = bonusPoint;
	}
	
	public int compareTo(Customer o) {
		System.out.println("비교 - SpecialCustomer: " + super.getName());
		int thisToPoint = super.getPoint() + bonusPoint;
		int paramToPoint = 0;
		
		if(o instanceof SpecialCustomer) {
			paramToPoint = o.getPoint() + ((SpecialCustomer)o).getBonusPoint();
		} else {
			paramToPoint = o.getPoint();
		}
		
			if(thisToPoint < paramToPoint) {
				return -1;
			} else if (thisToPoint > paramToPoint) {
				return 1;
			}
			return 0;
	}
	
	public String toString() { // bonuspoint 합쳐진거 출력.
		return super.getName() + "/" + (super.getPoint() + bonusPoint);
	}
	

}

class Order{
	private int orderNo;
	private String product;
	private String orderDt;
	
	public Order(int orderNo, String product, String orderDt) {
		this.orderNo = orderNo;
		this.product = product;
		this.orderDt = orderDt;
	}
	
	public int getOrderNo() {
		return orderNo;
	}

	public void setOrderNo(int orderNo) {
		this.orderNo = orderNo;
	}

	public String getProduct() {
		return product;
	}

	public void setProduct(String product) {
		this.product = product;
	}

	public String getOrderDt() {
		return orderDt;
	}

	public void setOrderDt(String orderDt) {
		this.orderDt = orderDt;
	}
	
}

class SpecialOrder extends Order{
	private String gift; // 사은품
	
	public SpecialOrder(int orderNo, String product, String orderDt, String gift) {
		super(orderNo, product, orderDt);
		this.gift = gift;
	}

	public String getGift() {
		return gift;
	}

	public void setGift(String gift) {
		this.gift = gift;
	}
	
	
}

public class practice0723 {

	public static void main(String[] args) {
		
		Customer<Order> c1 = new Customer<>("홍길동", 30, 100);
		// Customer는 order를 포함한 자식만 선언가능.
		
		Order o = new Order(1234, "정보보호론", "2019-07-01");
		
		c1.addOrders(o);
		
		SpecialCustomer<SpecialOrder> c2 = new SpecialCustomer<>("김길동", 31, 150, 50);
		// SpecialCustomer는  SpecialOrder만 선택가능 (order는 선택불가능)
		
		SpecialOrder so = new SpecialOrder(1234, "정보보호론", "2019-07-01", "각티슈");

		c2.addOrders(so);
		
		ArrayList al = new ArrayList();
		Customer<Order> c3 = new Customer<>("최길동", 30, 100);

		al.add(c1);
		al.add(c2);
		al.add(c3);
		
		Collections.sort(al);   // 점수순서대로 정렬. 
		
		System.out.println(al.toString());

	}

}
--------------------------------------------------------------------------

package Week03.day0723;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;

public class FilterStreamTest {

	public static void main(String[] args) {
		
		//보조Stream - Filter 입출력
		//소문자로 변경
		int c = 0;
		try {
			InputStream in = new LowerCaseInputStream(new BufferedInputStream(new FileInputStream("C:\\Temp\\practice0722.java")));
			
			while((c=in.read())>=0) {
				System.out.println((char)c);
			}
			in.close();
		} catch(IOException e) {
			e.printStackTrace();
		}
	}
}

class LowerCaseInputStream extends FilterInputStream{ //Filter대상 메소드 재정의

	protected LowerCaseInputStream(InputStream in) {
		super(in);
	} 
	
	public int read() throws IOException{ // read는 읽어들이는 값을 불러옴.
		int c = super.read();
		return (c==-1 ? c : Character.toLowerCase((char)c));
	}
	
	public int read(byte[] b, int offset, int len) throws IOException{
		int result = super.read(b, offset, len);
		for(int i = offset; i<offset+result; i++) {
			b[i] = (byte)Character.toLowerCase((char)b[i]);
		}
		return result;
	}
	
}
--------------------------------------------------------------------------

package Week03.day0723;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FilterReader;
import java.io.IOException;
import java.io.Reader;

public class FilterReaderTest extends FilterReader{
	
	public FilterReaderTest(Reader in) {
		super(in);
	}
	//read 메소드를 override한다.
	//주석부분은 읽지 않도록 filter 처리
	public int read(char[] buf, int offset, int len) throws IOException{
		int numChars = 0;
		boolean inComment = false;
		while(numChars ==0) {
			numChars = in.read(buf, offset, len);
			if(numChars ==-1)
				return -1;
			int last = offset;
			for(int i=offset; i<offset+numChars; i++) {
				// 주석부분은 filter로서 걸러낸다.
				if(inComment) {
					if((buf[i]=='*') && (buf[i+1]=='/')){
						// System.out.println("주석1");
						inComment = false; //주석종료알림
						i++;
					}
				} else {
					if((buf[i]=='/') && (buf[i+1]=='*')){
						// System.out.println("주석2");
						inComment = true; // 주석시작
						i++;
				} else {
					buf[last++] = buf[i]; //Data 담기
				}
			}
		}
		numChars = last - offset;
	}
	return (numChars);
	}
	
	public int read() throws IOException{
		char[] buf = new char[1];
		//유니코드로서 2byte씩 읽어 들인다.
		int result = read(buf, 0, 1);
		if(result==-1) {
			return -1;
		} else {
			return ((int)buf[0]);
		}
	}

	public static void main(String[] args) {
		
		//보조Stream - Filter 입출력
		
		FileReader f = null;
		BufferedReader in = null;
		String buf;
		try {
			//File Input Stream을 생성한다.
			f = new FileReader("practice0722.java");
			//File Stream 인자로 하는 Filter Stream을 생성하여 이를 Buffer Stream에 연결한다.
			in = new BufferedReader(new FilterReaderTest(f));
			//한줄씩 읽어들인다.  readLine() 은 내부에서 read() 메소드를 이용하여 작동한다.
			while((buf = in.readLine()) != null) {
				System.out.println(buf);
			}
			in.close();
		} catch(Exception e) {
			System.out.println(e);
		}
	}
}

--------------------------------------------------------------------------

package Week03.day0723;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Date;

public class BufferedReaderWriter {

	public static void main(String[] args) {
		
		// 보조Stream- Buffer 입출력
		
		FileReader fr = null;
		FileWriter fw = null;
		BufferedReader br = null;
		BufferedWriter bw = null;
		
		Date d = null;
		try {
			// "ReadFile.txt" 파일을 읽는 FileReader 객체 생성
			// BufferedReader 객체 생성
			fr = new FileReader("C:\\Temp\\practice0722.java");
			br = new BufferedReader(fr);
			
			//FileWriter로 파일 "Copy.File.txt"에 출력한다. 기존파일은 덮어쓴다.
			//BufferedWriter 객체 생성
			fw = new FileWriter("C:\\Temp\\practice0722.java", false);
			bw = new BufferedWriter(fw);
			
			String s = null;
			d = new Date();
			
			//파일 복사 시작 시간
			long start = d.getTime();
			
			//ReadFile.txt에서 한줄씩 읽어서 BufferedReader에 저장한다.
			while((s=br.readLine())!=null) {
				//읽은 데이터(한줄)를 BufferedWriter에 쓴다.
				//한줄씩 읽으므로, newLine() 메소드로 줄바꿈을 해준다.
				bw.write(s);
				bw.newLine(); 
			}
			
			// 복사 완료된 시간을 얻는다.
			d = new Date();
			long end = d.getTime();
					
			System.out.println("복사 시간 : " + (end-start)); // 복사 시간 : 0
			
		} catch(Exception e) {
			e.printStackTrace();
		} finally {
			//BufferedReader FileReader를 달아준다.
			if(br !=null)try {br.close();}catch(IOException e) {}
			if(fr !=null)try {fr.close();}catch(IOException e) {}
			
			//BufferedWriter FileWriter를 달아준다.
			if(bw !=null)try {bw.close();}catch(IOException e) {}
			if(fw !=null)try {fw.close();}catch(IOException e) {}
		}


	}

}
--------------------------------------------------------------------------

package Week03.day0723;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Date;

public class ObjectInputOutputTest {

	public static void main(String[] args) throws IOException, ClassNotFoundException {
		FileOutputStream ostream = new FileOutputStream("practice0722.java");
		ObjectOutputStream p = new ObjectOutputStream(ostream);
		p.writeInt(12345);
		p.writeObject("Today");
		p.writeObject(new Date());
		p.flush();
		ostream.close();
		
		FileInputStream istream = new FileInputStream("practice0722.java");
		ObjectInputStream p2 = new ObjectInputStream(istream);
		int i = p2.readInt();
		String today = (String)p2.readObject();
		Date date = (Date)p2.readObject();
		
		System.out.println(i);
		System.out.println(today);
		System.out.println(date);
		istream.close();

	}

}

//출력값
//12345
//Today
//Tue Jul 23 14:26:59 KST 2019

--------------------------------------------------------------------------

package Week03.day0723;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.Serializable;

class ObjectData implements Serializable{
	String name;
	int age;
	float height;
	public ObjectData() {
		this("Noname", 0, 0.0f);
	}
	
	public ObjectData(String name, int age, float height) {
		this.name = name;
		this.age = age;
		this.height = height;
	}
	
	private void writeObject(ObjectOutputStream stream) throws IOException {
		stream.defaultWriteObject();
		System.out.println("writeObject:");
	}
	
	private void readObject(ObjectInputStream stream) throws ClassNotFoundException, IOException {
		stream.defaultReadObject();
		System.out.println(" readObject : ");
	}
	
	public String toString() {
		return("name : " + name+ ", age: " + age + ", height : " + height);
	}
}

public class ObjectInputOutputTest2 {

	public static void main(String[] args) {
		ObjectData[] data = new ObjectData[3];
		data[0] = new ObjectData("YongWoo", 26, 168f);
		data[1] = new ObjectData("Kildong", 19, 174.8f);
		data[2] = new ObjectData("Dongsoo", 30, 169.4f);
		
		try {
			FileOutputStream outf = new FileOutputStream("practice0722.java");
			ObjectOutput out = new ObjectOutputStream(outf);
			out.writeInt(data.length);
			System.out.println("Number : " + data.length);
			//Object 개수만큼 Object를 출력한다.
			for(int i = 0; i<data.length; i++) {
				out.writeObject(data[i]);
				System.out.println(data[i]);
			}
			out.close();
			FileInputStream inf = new FileInputStream("practice0722.java");
			ObjectInput in = new ObjectInputStream(inf);
			int numberOfData;
			ObjectData objData;
			numberOfData = in.readInt();
			System.out.println("Number : " + numberOfData);
			//Object개수만큼 읽어들인다.
			for(int i = 0; i<numberOfData; i++) {
				objData = (ObjectData)in.readObject();
				System.out.println(objData);
			}
			in.close();
		} catch(Exception e) {
			e.printStackTrace();
		}
	}
}

//출력값
//Number : 3
//writeObject:
//name : YongWoo, age: 26, height : 168.0
//writeObject:
//name : Kildong, age: 19, height : 174.8
//writeObject:
//name : Dongsoo, age: 30, height : 169.4
//Number : 3
// readObject : 
//name : YongWoo, age: 26, height : 168.0
// readObject : 
//name : Kildong, age: 19, height : 174.8
// readObject : 
//name : Dongsoo, age: 30, height : 169.4
--------------------------------------------------------------------------
package Week03.day0723;

import java.net.InetAddress;
import java.rmi.UnknownHostException;
import java.util.Arrays;

public class NetworkEx1 {

	public static void main(String[] args) {
		
		InetAddress ip = null;
		InetAddress[] ipArr = null;
		
		try {
			ip = InetAddress.getByName("www.naver.com");
			System.out.println("getHostName() : " + ip.getHostName());
			System.out.println("getHostAddress() : " + ip.getHostAddress());
			System.out.println("toString(): " + ip.toString());
			
			byte[] ipAddr = ip.getAddress();
			System.out.println("getAddress() : " + Arrays.toString(ipAddr));
			
			String result = "";
			for(int i=0; i<ipAddr.length; i++) {
				result+=(ipAddr[i]<0) ? ipAddr[i] + 256 : ipAddr[i];
				result+=".";
			}
			System.out.println("getAddress() + 256 : " + result);
			System.out.println();
		} catch(java.net.UnknownHostException e) {
			e.printStackTrace();
		}
		
		try {
			ip = InetAddress.getLocalHost();
			System.out.println("getHostName() : " + ip.getHostName());
			System.out.println("getHostAddress() : " + ip.getHostAddress());
			System.out.println();
		} catch(java.net.UnknownHostException e) {
			e.printStackTrace();
		}
		
		try {
			ipArr = InetAddress.getAllByName("www.naver.com");
			
			for(int i=0; i<ipArr.length; i++) {
				System.out.println("ipArr[" + i + "] : " + ipArr[i]);
			}
		} catch(java.net.UnknownHostException e) {
			e.printStackTrace();
		}
	}
}

//출력값
//getHostName() : www.naver.com
//getHostAddress() : 210.89.164.90
//toString(): www.naver.com/210.89.164.90
//getAddress() : [-46, 89, -92, 90]
//getAddress() + 256 : 210.89.164.90.
//
//getHostName() : DESKTOP-CCP86DI
//getHostAddress() : 192.168.0.27
//
//ipArr[0] : www.naver.com/210.89.164.90
//ipArr[1] : www.naver.com/125.209.222.141

--------------------------------------------------------------------------
package Week03.day0723;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;

public class NetworkEx4 {

	public static void main(String[] args) {
		
		//URL객체 예제2
		//Stream으로 바로 접근하여 Data를 주고 받는다.
		
		URL url = null;
		BufferedReader input = null;
		String address = "http://192.168.0.16:8090/pro07/memberForm.html";
		String line = "";
		
		try {
			url = new URL(address);
			
			//Stream을 reader로 바꿔준다.
			input = new BufferedReader(new InputStreamReader(url.openStream(), "UTF-8"));
			
			while((line=input.readLine())!=null) {
				System.out.println(line);
			}
			input.close();
		} catch(Exception e) {
			e.printStackTrace();
		}
	}
}

//출력값
//<!DOCTYPE html>
//<html>
//<head>
//<meta charset="UTF-8">
//<title>회원 가입창</title>
//<script type="text/javascript">
//function fn_sendMember(){
//   var frmMember=document.frmMember;
//   var id=frmMember.id.value;
//   var pwd=frmMember.pwd.value;
//   var name=frmMember.name.value;
//   var email=frmMember.email.value;
//   if(id.length==0 ||id==""){
//      alert("아이디는 필수입니다.");
//   }else if(pwd.length==0 ||pwd==""){
//      alert("비밀번호는 필수입니다.");
//   }
//   else if(name.length==0 ||name==""){
//      alert("이름은 필수입니다.");
//   }else if(email.length==0 ||email==""){
//      alert("이메일은 필수입니다.");
//   }else{
//      frmMember.method="post";
//      frmMember.action="member3";
//      frmMember.submit();
//   } 
//}
//</script>
//</head>
//<body>
//  <form name="frmMember">
//  <table>
//	   <th>회원 가입창</th>
//	  <tr>
//		<td>아이디</td>
//		<td><input type="text" name="id"></td>
//	  </tr>
//	  <tr>
//		<td>비밀번호</td>
//		<td><input type="password" name="pwd"></td>
//	  </tr>
//	  <tr>
//		<td>이름</td>
//		<td><input type="text" name="name"></td>
//	  </tr>
//	    <tr>
//		<td>이메일</td>
//		<td><input type="text" name="email"></td>
//	  </tr>
//  </table>
//   <input type="button" value="가입하기" onclick="fn_sendMember()">
//   <input type="reset" value="다시입력">
//   <input  type="hidden" name="command" value="addMember" />	
//  </form>
// </body>
//</html>
//
--------------------------------------------------------------------------

package Week03.day0723;

import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.URL;

public class NetworkEx5 {

	public static void main(String[] args) {
		
		//URL객체 예제3 - download
		
		URL url = null;
		InputStream in = null; // 리소스에서 읽어들인다.
		FileOutputStream out = null;
		String address = "http://192.168.0.16:8090/pro07/memberForm.html";
		
		int ch=0;
		
		try {
			url = new URL(address);
			in = url.openStream();
			out = new FileOutputStream("memberForm.html");
			
			while((ch=in.read())!=-1) {
				System.out.println("downloading..."); // 출력값 : downloading... 주구장창 나옴
				out.write(ch);
			}
			in.close();
			out.close();
		} catch(Exception e) {
			e.printStackTrace();
		}
	}
}

--------------------------------------------------------------------------

package Week03.day0723;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.URL;

public class URLConnectionTest {

	public static void main(String[] args) {
		
		//URLConnection 예제2 - HttpURLConnection
		//서버에서 검색조건을 넣고 검색버튼을 누르는 기능과 유사
		
		String input = "query=un";
		try {
			/* Set up*/
			URL naver = new URL("http://kin.naver.com/search/list.nhn");
			HttpURLConnection urlConn = (HttpURLConnection)naver.openConnection();
			urlConn.setDoOutput(true); // Output을 사용가능하게 설정
			// urlConn.setRequestMethod("POST");
			
			/*write - 서버에 Write*/
			BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(urlConn.getOutputStream()));
			bw.write(input);
			bw.flush();
			bw.close();
			
			/*read - 서버에서 결과 read*/
			BufferedReader br = new BufferedReader(new InputStreamReader(urlConn.getInputStream(), "UTF-8"));
			String inputLine;
			while((inputLine = br.readLine())!=null) {
				System.out.println(inputLine);
			}
			br.close();
		} catch (Exception e) {
			System.out.println("Exception : " + e.toString());
		}
	}
}
--------------------------------------------------------------------------

package Week03.day0723;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;

public class TcpIpMultichatServer {
	
	HashMap clients; // 모든 Client를 HashMap에 담고 있다.
	
	TcpIpMultichatServer(){
		clients = new HashMap();
		Collections.synchronizedMap(clients);
	}
	
	public void start() {
		ServerSocket serverSocket = null;
		Socket socket = null;
	
	try {
		serverSocket = new ServerSocket(7777);
		System.out.println("서버가 시작되었습니다.");
		
		while(true) {
			//Server가 Client의 접속을 계속 기다린다.
			socket = serverSocket.accept();
			System.out.println("[" + socket.getInetAddress() + ":" + socket.getPort() + "]" + "에서 접속하였습니다." );
			//접속할  Client와 통신할 Thread를 Client와 통신할 Socket을 가지고 만들어 띄워준다.
			ServerReceiver thread = new ServerReceiver(socket); // 내부 class
			thread.start();
		}
	}catch(Exception e) {
		e.printStackTrace();
	}
	
	}// start()
	
	void sendToAll(String msg) {
		Iterator it = clients.keySet().iterator();
		
		while(it.hasNext()) {
			try {
				DataOutputStream out = (DataOutputStream)clients.get(it.next());
				out.writeUTF(msg);
			} catch(IOException e) {}
		} // while
	} // sendToAll

	public static void main(String[] args) {
		new TcpIpMultichatServer().start();
	}
	
	class ServerReceiver extends Thread{
		Socket socket;
		DataInputStream in;
		DataOutputStream out;
		
		ServerReceiver(Socket socket){
			this.socket = socket;
			try {
				in = new DataInputStream(socket.getInputStream());
				out = new DataOutputStream(socket.getOutputStream());
			} catch (IOException e) {}
		}
		
		public void run() {
			String name = "";
			try {
				name = in.readUTF(); // 문자열 Read
				sendToAll("#" + name + "님이 들어오셨습니다.");
				
				clients.put(name, out); // clients는 외부 class 의 멤버변수로 client별 outputStream을 담고 있다.
				System.out.println("현재 서버접속자 수는 " + clients.size() + "입니다.");
				
				while(in!=null) {
					sendToAll(in.readUTF()); // Read한 내용을 모든 Client에서 전달한다
				}
			} catch(IOException e) {
				//ignore
			} finally {
				sendToAll("#" + name + "님이 나가셨습니다.");
				clients.remove(name);
				System.out.println("[" + socket.getInetAddress() + ":" + socket.getPort() + "]" + "에서 접속을 종료하였습니다.");
				System.out.println("현재 서버접속자 수는 " + clients.size() + "입니다.");
			} //try
		} //run
	} //ReceiverThread
} // class
--------------------------------------------------------------------------
package Week03.day0723;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ConnectException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class TcpIpMultichatClient {

	public static void main(String[] args) throws UnknownHostException, IOException {
		String chatName = "bit_chat2";
		
		try {
			String serverIp = "192.168.0.32";
//			String serverIp = "127.0.0.1";
			//소켓을 생성하여 연결을 요청한다.
			Socket socket = new Socket(serverIp, 7777);
			System.out.println("서버에 연결되었습니다.");
			Thread sender = new Thread(new ClientSender(socket, chatName)); //서버로 chat문장 write
			Thread receiver = new Thread(new ClientReceiver(socket)); // 서버에서 chat문장 read
			
			sender.start();
			receiver.start();
		} catch(ConnectException ce) {
			ce.printStackTrace();
		}
	} // main

	//서버에 chat문장을 전달하는 thread
	static class ClientSender extends Thread{
		Socket socket;
		DataOutputStream out;
		String name;
		
		ClientSender(Socket socket, String name){
			this.socket = socket;
			try {
				out = new DataOutputStream(socket.getOutputStream());
				this.name = name;
			} catch(Exception e) {
			}
		}
	public void run() {
		//대화를 입력
		Scanner scanner = new Scanner(System.in);
		try {
			if(out!=null) {
				out.writeUTF(name); //chat 이름을 서버에 전달
			}
			
			while(out!=null) {
				out.writeUTF("[" + name + "]" + scanner.nextLine()); // 채팅문장 서버에 전달
			}
		} catch(IOException e) {
		}
		}// run()
	}// clientSender
	
	//Server에서 전달하는 chat문장을 Read 하는 thread
	static class ClientReceiver extends Thread{
		Socket socket;
		DataInputStream in;
		
		ClientReceiver(Socket socket){
			this.socket = socket;
			try {
				in = new DataInputStream(socket.getInputStream());
			} catch (IOException e) {
			}
		}
		
		public void run() {
			while(in!=null) {
				try {
					System.out.println(in.readUTF());
				} catch(IOException e) {
				}
			}
		} // run()
	} //ClientReceiver
} // class


--------------------------------------------------------------------------

package Week03.day0723;

import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {

	public static void main(String[] args) {
		
		ServerSocket serverSocket = null;
		try {
			//서버소켓을 생성하여 7777번 포트와 결합(bind)시킨다.
			serverSocket = new ServerSocket(7777);
			System.out.println("[Server]" + getTime() + "서버가 준비되었습니다.");
		} catch(IOException e) {
			e.printStackTrace();
		}
		while(true) {
			try {
				System.out.println("[Server]" + getTime() + "연결요청을 기다립니다.");
				//서버소켓은 클라이언트의 연결요청이 올 때까지 실행을 멈추고 계속 기다린다.
				//클라이언트의 연결요청이 오면 클라이언트 소켓과 통신할 새로운 소켓을 생성한다.
				Socket socket = serverSocket.accept();
				System.out.println("[Server]" + getTime() + socket.getInetAddress() + "로부터 연결요청이 들어왔습니다.");
				
				//소켓의 출력스트림을 얻는다.
				OutputStream out = socket.getOutputStream();
				DataOutputStream dos = new DataOutputStream(out);
				
				//원격 소켓(remote socket)에 데이터를 보낸다.
				dos.writeUTF("[Notice] Test Message1 from Server.");
				System.out.println("[Server]" + getTime() + "데이터를 전송했습니다.");
				
				//스트림과 소켓을 닫아준다.
				dos.close();
				socket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		} // while
	}
}
--------------------------------------------------------------------------
package Week03.day0723;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ConnectException;
import java.net.Socket;

public class Client {

	public static void main(String[] args) {
		
		//커넥션의 기본
		
		try {
			String serverIp = "127.0.0.1";
			
			System.out.println("[Client]" + "서버에 연결중입니다. 서버IP : " + serverIp);
			//소켓을 생성하여 연결을 요청한다.
			Socket socket = new Socket(serverIp, 7777);
			
			//소켓의 입력스트림을 얻는다.
			InputStream in = socket.getInputStream();
			DataInputStream dis = new DataInputStream(in);
			
			//소켓으로부터 받은 데이터를 출력한다.
			System.out.println("[Client]" + "서버로부터 받은 메세지 : " + dis.readUTF());
			System.out.println("[Clinet]" + "연결을 종료합니다.");
			
			//스트림과 소켓을 닫는다.
			dis.close();
			socket.close();
			System.out.println("[Client]" + "연결이 종료되었습니다.");
		} catch(ConnectException ce) {
			ce.printStackTrace();
		} catch(IOException ie) {
			ie.printStackTrace();
		} catch(Exception e) {
			e.printStackTrace();
		}

	}

}

정렬 대상 클래스

public class Player {
    private String name;
    private int score;

    public Player(String name, int score) {
        this.name = name;
        this.score = score;
    }

    // Getters, Setters 생략
}

List<Player> players = new ArrayList<>();
players.add(new Player("Alice", 899));
players.add(new Player("Bob", 982));
players.add(new Player("Chloe", 1090));
players.add(new Player("Dale", 982));
players.add(new Player("Eric", 1018));

객체 정렬 기준의 필요성

단순한 숫자나 문자와 같은 기본형(primitive) 데이터는 사람들이 하는 일반적으로 받아드리는 대소 비교라는 개념이 있습니다. (Natural Order)
따라서 우리는 1보다는 2가 크며, 'A' 보단 'B'가 크다는 것을 알기 때문에 자바는 이런 통념에 따라 정렬을 해줍니다.

예를 들어, 게이머들의 점수만으로 별도의 배열을 만들면 다음과 같이 Arrays.sort() 메서드를 사용하여 정렬을 할 수 있습니다.

int[] scores = {899, 982, 1090, 982, 1018};
Arrays.sort(scores);
System.out.println(Arrays.toString(scores)); // [899, 982, 982, 1018, 1090]

Comparable 인터페이스

객체의 정렬 기준을 정의하는 첫번째 방법은 정렬 대상 클래스를 자바에서 기본적으로 제공하고 있는 Comparable 인터페이스를 구현하도록 변경하는 것입니다.
이를 적용하면 Player 클래스는 다음과 같이 수정됩니다.

public class Player implements Comparable<Player> {
    // Fields, Getters, Setters 생략

    @Override
    public int compareTo(Player o) {
        return o.getScore() - getScore();
    }
}

Comparable 인터페이스의 compareTo() 메서드를 통해 인자로 넘어온 같은 타입의 다른 객체와 대소 비교가 가능합니다. 메서드를 호출하는 객체가 인자로 넘어온 객체보다 작을 경우에는 음수를 리턴하고, 크기가 동일하다면 0, 클 경우에는 양수를 리턴해야합니다.

게이머 랭키 페이지의 경우 높은 점수 순으로 내림 차순 정렬을 원하기 때문에, 인자로 넘어온 게이머의 점수에서 메서드를 호출하는 게이머의 점수를 빼면 됩니다. 예를 들어 인자로 넘어온 게이머의 점수가 982이고 compareTo() 메서드를 호출하는 객체의 점수가 1018이라면, compareTo() 메서드는 음수(982-1018)를 리턴하게 되며, 이는 곧 메서드를 호출하는 게미머가 인자로 넘어온 게이머보다 작다는 것을 의미합니다. 다시 말해, 메서드를 호출를 호출하는 메서드가 점수가 더 크지만, 객체 자체 비교에서는 인자로 넘어온 게이머보다 작은 객체가 됩니다.

Comparator 객체 사용

만약 정렬 대상 클래스의 코드를 직접 수정할 수 없는 경우에는 어떻게 객체의 정렬 기준을 정의할 수 있을까요? 또는 정렬 하고자 하는 객체에 이미 존재하고 있는 정렬 기준과 다른 정렬 기준으로 정렬을 하고 싶을 때는 어떻게 해야할까요?

이 때 필요한 것이 바로 Comparable 인터페이스와 이름이 유사한 Comparator 인터페이스입니다. Comparator 인터페이스의 구현체를 Arrays.sort()나 Collections.sort()와 같은 정렬 메서드의 추가 인자로 넘기면 정렬 기준을 누락된 클래스의 객체나 기존 정렬 기준을 무시하고 새로운 정렬 기준으로 객체를 정렬할 수 있습니다.

Comparator<Player> comparator = new Comparator<Player>() {
    @Override
    public int compare(Player a, Player b) {
        return b.getScore() - a.getScore();
    }
};

Collections.sort(players, comparator);
System.out.println(players); // [Player(name=Chloe, score=1090), Player(name=Eric, score=1018), Player(name=Bob, score=982), Player(name=Dale, score=982), Player(name=Alice, score=899)]

위 코드는 Comparator 객체를 Collections.sort() 메서드의 두번째 인자로 넘겨서 이전 섹션과 동일한 정렬 결과를 만들어 내고 있습니다. 이렇게 Comparator 객체를를 인자로 넘기면, 정렬 대상 객체가 Comparable 인터페이스를 구현 여부와 상관없이, 넘어온 Comparator 구현체의 compare() 메서드 기준으로 정렬을 수행합니다.
compare() 메서드는 비교 대상 2 개의 객체를 인자를 차례로 인자로 받습니다. 첫번째 인자가 두번째 인자보다 작다면 음수, 같다면 0, 크다면 양수를 리턴하면 됩니다.

Stream 으로 정렬

Stream 클래스의 sorted() 메서드도 Comparator 객체를 인자로 받아 정렬을 해줍니다.
스트림을 사용하면 위에서 살펴본 배열과 리스트의 정렬과 달리 기존 객체의 순서를 변경하지 않고, 새롭게 정렬된 객체를 생성하고자 할 때 사용됩니다.

List<Player> sortedPlayers = players.stream()
        .sorted((a, b) -> b.getScore() - a.getScore())
        .collect(Collectors.toList());
System.out.println(sortedPlayers); // [Player(name=Chloe, score=1090), Player(name=Eric, score=1018), Player(name=Bob, score=982), Player(name=Dale, score=982), Player(name=Alice, score=899)]

javascript의 데이터형식에는 크게 숫자와 문자가 있다.

################## 숫자(number)  ##################

- 자바스크립트에서는 정수와 실수를 입력할때 구분하지 않는다
- 곱하기기호 *(asterisk) 나누기기호 /(slash)
- 숫자는 따옴표로 둘러 싸지 않는다

- 사칙연산 뿐 아니라 Math같은 함수를 쓰면 제곱, 제곱근, 난수 등 복잡한 계산도 가능하다.

Math.pow(3,2);       // 9,   3의 2승 
Math.round(10.6);    // 11,  10.6을 반올림
Math.ceil(10.2);     // 11,  10.2를 올림
Math.floor(10.6);    // 10,  10.6을 내림
Math.sqrt(9);        // 3,   3의 제곱근
Math.random();       // 0부터 1.0 사이의 랜덤한 숫자

################## 문자열(string)  ##################
- 따옴표로 무엇이든 둘러 싸게 하면 문자열로 인식(같은 따옴표 사용해야함)

- 역슬래쉬(\)n : 줄바꿈 (Enter와 같은 역할)

- 간혹 ' '사이에 '를 써야 하는 경우 \' 이와 같은 모습으로 기록을 해주어야 컴퓨터가 문자로서 '를 인지한다.
\를 이스케이프라 한다.
- typeof __ : __에 어떠한 데이터를 넣으면 데이터타입이 무엇인지 출력한다
- 문자열뒤에 명령어를 쓸 수 있다. ex) "code".length // "code".indexof

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8"/>
    </head>
    <body>
        <script>
            alert('Hello world'); // 이 부분만 javaScript 이고 나머지는 html코드임.
        </script>
    </body>
</html>

IDE = 통합 개발 도구

선택은 본인의 몫.

개발자라면 좋은 도구를 찾는 노력을 게을리해서는 안됨.

package Week03.day0722;

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


class Driver{
	private String name;
	private int licenceNo;
	private HashMap cars = new HashMap();
	private int hisMaxIndex = 3;
	private int hisIndex;
	private Accident[] history = new Accident[hisMaxIndex]; // 사고이력
	private int cnt = 0;
	
	Driver() {
		
	}
	
	Driver(String name, int licenseNo) {
		this.name = name;
		this.licenceNo = licenseNo;
	}
	
	public void addCar(String carNo, String type, int volume) throws Exception { // HashMap
//		소유자동차를 추가한다
//        - carNo(차량번호), type(차종), volume(배기량)
//        - carNo를 key로 HashMap에 추가한다
//        - 동일한 자동차를 추가할 수 없다
//        - HashMap에는 Key는 String, Value에는 Car class만 추가가능하다 // 제네릭스 추가.
		
		int New_carNo = (Integer.parseInt(carNo.substring(4, 7)));
		
		cars = new HashMap(New_carNo);
		
		String carInfo = carNo + "/" + type + "/" + volume;
		
		if(cars.containsKey(New_carNo)) {
			throw new Exception("동일한 자동차는 추가 될 수 없습니다.");
		}
		else{
			cars.put(New_carNo, carInfo);
		}
		
	}
	
	public void printCars() { // 소유하고 있는 Car를 출력한다- carNo/type/volume를 출력한다 // HashMap
		Set set = cars.entrySet();
		Iterator it = set.iterator();
		
		while(it.hasNext()) {
			Entry e = (Entry) it.next();
			System.out.println(e.getValue());
		}
	}
	
	public void addAccident(Accident ac) { // arraylist
//		사고이력을 추가한다
//        - 사고이력 추가 시 Array size를 넘어설 경우 Array size를 2배로 늘려서 추가한다
//        - 사고이력 추가 시 Car는 Driver가 소유하고 있는 Car만 추가가능 하다
		
		if(hisIndex ==  hisMaxIndex-1) {
			Accident[] old = history; //old배열에 기존배열 데이터를 담아둔다.
			hisMaxIndex = 2 * hisMaxIndex;
			history = new Accident[hisMaxIndex];
			
			for(int i = 0; i < hisIndex; i++) {
				history[i] = old[i];
			}
		}
		history[this.hisIndex++] = ac;
	}
	
	public void printAccident() { // 사고이력을 출력한다 . arraylist
		System.out.println("======사고이력======");
		for(int i=0; i<this.hisIndex; i++) {
			Car info = history[i].getCar();
			System.out.println("사고장소 = " + history[i].getLocation() +", 사고일자 = " + history[i].getDate()+", 사고차량 = " + info.getCarNo() + "/" + info.getType() + "/" + info.getVolume());
		}
		
	}
}

class Accident extends Driver{
	private String location; // 위치
	private String date; // 사고일자
	private Car car; // 사고차량
	
	Accident(){
		
	}
	
	Accident(String location, String date, Car car){
		this.location = location;
		this.date = date;
		this.car = car;
	}

	public String getLocation() {
		return location;
	}

	public void setLocation(String location) {
		this.location = location;
	}

	public String getDate() {
		return date;
	}

	public void setDate(String date) {
		this.date = date;
	}

	public Car getCar() {
		return car;
	}

	public void setCar(Car car) {
		this.car = car;
	}
	
}

class Car extends Accident{
	private String carNo;
	private String type;
	private int volume;
	
	Car(String carNo, String type, int volume){
		this.carNo = carNo;
		this.type = type;
		this.volume = volume;
	}

	public String getCarNo() {
		return carNo;
	}

	public void setCarNo(String carNo) {
		this.carNo = carNo;
	}

	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}

	public int getVolume() {
		return volume;
	}

	public void setVolume(int volume) {
		this.volume = volume;
	}
	
	public boolean equals(Object obj) {
		if (obj != null && obj instanceof Accident) { // obj가 Accident의 Instance
			String tmp = carNo + type + volume;
			String tmp2 = ((Car)obj).getCarNo() + ((Car)obj).getType() + ((Car)obj).getVolume();
			
			return tmp.equals(tmp2);
		} else {
			return false;
		}
	}
}

public class practice0722 {

	public static void main(String[] args) throws Exception {
		
		Car cr = new Car("32다4931", "소형차", 3000);

		cr.addCar("32다4931", "소형차", 3000);
//		try {
//			cr.addCar("32다4931", "소형차", 3000); // 오류메세지 출력용	
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
		cr.printCars();
		
		Accident ac = new Accident("로타리사거리", "20190228", cr);
		
		cr.addAccident(ac);
		cr.printAccident();
	}

}
--------------------------------------------------------------------------
/* Stream */
1. 데이터의 흐름, 통로(파일/키보드/메모리/Network)
2. 데이터를 읽고 쓰기 위한 공통된 방법을 제공
3. 장치마다 연결할 수 있는 각각의 Stream 이 존재

package Week03.day0722;

import java.io.File;

public class FileEx1 {

	public static void main(String[] args) {
		
		File f = new File("C:\\Temp\\practice0722.java");
		String fileName = f.getName();
		int pos = fileName.lastIndexOf("."); // 확장자 구분자 위치
		
		System.out.println("경로를 제외한 파일이름 - " + f.getName()); // 경로를 제외한 파일이름 - practice0722.java
		System.out.println("확장자를 제외한 파일이름 - " + fileName.substring(0,pos)); // 확장자를 제외한 파일이름 - practice0722
		System.out.println("확장자 - " + fileName.substring(pos+1)); // 확장자 - java
		
		System.out.println("경로를 포함한 파일이름 - " + f.getPath()); // 경로를 포함한 파일이름 - C:\Temp\practice0722.java
		System.out.println("파일의 절대경로 - " + f.getAbsolutePath()); // 파일의 절대경로 - C:\Temp\practice0722.java
		System.out.println("파일이 속해 있는 디렉토리 - " + f.getParent()); // 파일이 속해 있는 디렉토리 - C:\Temp
		System.out.println();
		System.out.println("File.PathSeparator - " + File.pathSeparator); // File.PathSeparator - ; // String용
		System.out.println("File.pathSeparator Char - " + File.pathSeparatorChar); // File.pathSeparator Char - ; // Char용
		System.out.println("File.separator - " + File.separator); // File.separator - \ // String용
		System.out.println("File.separatorChar - " + File.separatorChar); // File.separatorChar - \ // Char용

	}

}
--------------------------------------------------------------------------
package Week03.day0722;

import java.io.File;

public class FileEx2 {

	public static void main(String[] args) {
		
		File f = new File("C:\\Temp");
		
		if(!f.exists() || !f.isDirectory()) {
			System.out.println("유효하지 않은 디렉토리입니다.");
			System.exit(0);
		}
		
		File[] files = f.listFiles();
		
		for(int i=0; i<files.length; i++) {
			String fileName = files[i].getName();
			System.out.println(files[i].isDirectory() ? "[" + fileName+"]" : fileName);
		}
	} // main
}

//출력값
//[AUtempR]
//practice0722.java
--------------------------------------------------------------------------

package Week03.day0722;

import java.io.File;
import java.util.ArrayList;

public class FileEx3 {
	
	//디렉토리와 파일을 불러와서 출력 + 재귀호출
	
	static int totalFiles = 0;
	static int totalDirs = 0;

	public static void main(String[] args) {
		
		File dir = new File("C:\\Temp");
		
		if(!dir.exists() || !dir.isDirectory()) {
			System.out.println("유효하지 않은 디렉토리입니다.");
			System.exit(0);
		}
		
		printFileList(dir);
		
		System.out.println();
		System.out.println("총" + totalFiles + "개의 파일");
		System.out.println("총" + totalDirs + "개의 디렉토리");
	}
	
	public static void printFileList(File dir) {
		System.out.println(dir.getAbsolutePath() + " 디렉토리");
		File[] files = dir.listFiles(); // dir내부 파일목록(디렉토리 포함)
		
		ArrayList subDir = new ArrayList();
		
		
		//내부 파일목록 출력
		for(int i=0; i<files.length; i++) {
			String filename = files[i].getName();
			
			if(files[i].isDirectory()) {
				filename = "[" + filename + "]"; // 디렉토리이면 []로 표시
				subDir.add(i+"");
			}
			System.out.println(filename);
		}
		
		int dirNum = subDir.size();
		int fileNum = files.length - dirNum;
		
		totalFiles += fileNum;
		totalDirs += dirNum;
		
		System.out.println(fileNum + "개의 파일, " + dirNum + "개의 디렉토리");
		System.out.println();
		
		for(int i=0; i<subDir.size(); i++) {
			int index = Integer.parseInt((String)subDir.get(i));
			printFileList(files[index]); //디렉토리인 것에 대해 재귀호출
		}
	}
}

//출력값
//C:\Temp 디렉토리
//[AUtempR]
//practice0722.java
//1개의 파일, 1개의 디렉토리
//
//C:\Temp\AUtempR 디렉토리
//0개의 파일, 0개의 디렉토리
//
//
//총1개의 파일
//총1개의 디렉토리
--------------------------------------------------------------------------

package Week03.day0722;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileReaderWriterTest {

	public static void main(String[] args) {
		
		//Stream - 문자
		
		boolean append = false;
		int i, len = 0;
		String strFile01 = "C:\\Temp\\practice0722.java";
		String strFile02 = "C:\\Temp\\0722실습.txt";
		FileReader in = null;
		FileWriter out = null;
		
		try { // 파일을 Character input Stream 에 연결한다.
			in = new FileReader(new File(strFile01));
			//파일은 Character output Stream에 연결한다.
			out = new FileWriter(strFile02, append);
		} catch(FileNotFoundException e) {
			System.out.println(e);
		} catch(IOException e) {
			System.out.println(e);
		}
	
		try { // input Stream에 연결된 파일 내용을 읽는다.
			while((i=in.read())!=-1){ // 1 char 읽어서
				//Output Stream에 연결된 파일에 내용을 출력한다.
				out.write(i);
				//총 읽은 byte수를 count한다.
				len++;
			}
			in.close(); out.close(); System.out.println(len + " bytes are copied..."); // 4255 bytes are copied...
		} catch(IOException e) {
			System.out.println(e);
		}
	}
}
--------------------------------------------------------------------------
/* FileInputStream */
1. FileInputStream(File file) : 주어진 File객체가 가리키는 파일을 바이트 스트림으로 읽기위한 FileInputStream 객체를 생성
2. FileInputStream(String name) : 주어진 이름이 가리키는 파일을 바이트 스트림으로 읽기위한 FileInputStream 객체를 생성
3. 파일과 직접 연결하여 사용

/* FileOutputStream */
1. FileOutputStream(File file) : 주어진 File객체가 가리키는 파일을 바이트 스트림으로 읽기위한 FileOutputStream 객체를 생성
2. FileOutputStream(String name) : 주어진 이름이 가리키는 파일을 바이트 스트림으로 읽기위한 FileOutputStream 객체를 생성
- 기존 파일이 존재할때는 덮어씀.
3. FileOutputStream(String name, boolean append) : 주어진 이름이 가리키는 파일을 바이트 스트림으로 쓰기 위한 FileOutputStream 객체를 생성.
- append 값에 따라 새로운 파일을 생성하거나 또는 기존의 내용에 추가

package Week03.day0722;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class FileInputOutputStream {

	public static void main(String[] args) {
		
		//Stream - byte
		
		boolean append = false;
		int i, len = 0;
		String strFile01 = "C:\\Temp\\practice0722.java";
		String strFile02 = "C:\\Temp\\0722실습.txt";
		InputStream in = null;
		OutputStream out = null;
		
		try { // 파일을 Character input Stream 에 연결한다.
			in = new FileInputStream(new File(strFile01));
			//파일은 Character output Stream에 연결한다.
			out = new FileOutputStream(strFile02, append);
		} catch(FileNotFoundException e) {
			System.out.println(e);
		}
	
		try { 
			while((i=in.read())!=-1){ // 1byte를 읽어서
				System.out.println(i); // 1byte이므로 한글은 깨짐.
				out.write(i); // 1byte를 쓴다. 
				len++;
			}
			in.close(); out.close(); System.out.println(len + " bytes are copied..."); // 4703 bytes are copied...
		} catch(IOException e) {
			System.out.println(e);
		}

	}

}
--------------------------------------------------------------------------
package Week03.day0722;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteArrayInputOutputTest {

	public static void main(String[] args) throws IOException {
		
		//배열 입출력 Stream = Byte
		
		int ch;
		byte arr[] = { (byte) 'J', (byte)'a', (byte)'v', (byte)'a', (byte)'!'};
		//배열 arr을 입력버퍼로 사용하는 객체 생성
		ByteArrayInputStream in = new ByteArrayInputStream(arr);
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		
		FileOutputStream outFile = new FileOutputStream("0722실습.txt");
		//배열 arr의 내용을 읽는다.
		while((ch=in.read())!=-1) {
			//출력Stream의 버퍼에 출력합니다.
			out.write(ch);
			System.out.println(" read:[" + (char)ch + "]" + ", write:[" + out.toString() + "]" + out.size() + ", available:" + in.available());
		}
		
		System.out.println("String: " + out.toString());
		byte arrOut[] = out.toByteArray();
		for(int i=0; i<arrOut.length; i++) {
			System.out.println(arrOut[i]+",");
		}
		
		//출력버퍼의 내용을 인자로 주어진 OutputStrema(File)에 출력합니다.
		out.writeTo(outFile);
	}
}

//출력값
//read:[J], write:[J]1, available:4
//read:[a], write:[Ja]2, available:3
//read:[v], write:[Jav]3, available:2
//read:[a], write:[Java]4, available:1
//read:[!], write:[Java!]5, available:0
//String: Java!
//74,
//97,
//118,
//97,
//33,
--------------------------------------------------------------------------

package Week03.day0722;

import java.io.CharArrayReader;
import java.io.CharArrayWriter;
import java.io.IOException;

public class CharArrayReadeWriterTest {

	public static void main(String[] args) throws IOException {
		
		//배열 입출력 Stream - 문자
		
		int ch;
		//input Stream 으로 사용할 char 배열
		char arr[] = { 'H', 'e', 'l', 'l', 'o', ',', ' ', 'J', 'a', 'v', 'a', '!'};

		CharArrayReader in;
		CharArrayWriter out;
		
		//주어진 문자 배열의 주어진 부분을 입력 버퍼로 사용하는 input Stream을 생성
		in = new CharArrayReader(arr, 7, 5); //7번째 index부터 5개를 read.
		//디폴트 크기의 문자 배열을 출력 버퍼로 사용하는 output Stream을 생성
		out = new CharArrayWriter();
		
		while((ch=in.read())!=-1) {
			//출력버퍼에 쓰기
			out.write(ch);
			System.out.println(" read:[" + (char)ch + "]" + ", write:[" + out.toString() + "]" + out.size());
		}
		
		//출력버퍼에 쓰여진 내용을 문자열로 리턴한다.
		System.out.println("String: " + out.toString());
		//출력버퍼를 char 배열로 리턴
		char arrOut[] = out.toCharArray();
		for(int i=0; i<arrOut.length; i++) {
			System.out.println(arrOut[i]+",");
		}
	}
}

//출력값
//read:[J], write:[J]1
//read:[a], write:[Ja]2
//read:[v], write:[Jav]3
//read:[a], write:[Java]4
//read:[!], write:[Java!]5
//String: Java!
//J,
//a,
//v,
//a,
//!,


--------------------------------------------------------------------------
package Week03.day0722;

import java.io.CharArrayWriter;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;

public class StringReaderWriterTest {

	public static void main(String[] args) throws IOException {
		
		//문자열 입출력 Stream
		
		int ch;
		//입력 버퍼로 사용할 문자열
		String s = "Hello, Java!";
		//String s를 입력 Stream으로 하는 StringReader객체생성
		StringReader in = new StringReader(s);
		//주어진 크기의 문자열 Buffer를 포함하고 있다.
		StringWriter out = new StringWriter(s.length() /2 );
		//주어진 개수만큼 건너뛴다. index를 J로 이동
		in.skip(7);
		while((ch=in.read())!=-1){
			out.write(ch);
			//출력함에 따라 출력버퍼의 size는 늘어난다.
			System.out.println("read:[" + (char)ch + "]" + ", write: [" + out.toString() + "]" + out.getBuffer().length());
		}
		//Java!
		System.out.println(" out : " + out.toString());
		//StringWriter의 내부출력버퍼의 내용을 반전시킴. Java!
		out.getBuffer().reverse();
		System.out.println(" out : " + out.toString());
		in = new StringReader(out.toString());
		//Char 배열 출력 Stream 생성
		CharArrayWriter out2 = new CharArrayWriter();
		while((ch=in.read())!=-1) {
			out2.write(ch);
			System.out.println("read : [" + (char)ch + "]" + ", write : [" + out2.toString() + "]" + out2.size());
		}
		
		//CharArrayWriter Stream에 쓰여진 내용을 StringWriter Stream에 쓴다.
		//기존에 쓰여진 부분은 append 된다.
		out2.writeTo(out);
		//문자열 output Stream에 append된 결과 출력
		System.out.println(" out: " + out.toString());
		System.out.println(" out2: " + out2.toString());
	}
}

//출력값
//read:[J], write: [J]1
//read:[a], write: [Ja]2
//read:[v], write: [Jav]3
//read:[a], write: [Java]4
//read:[!], write: [Java!]5
// out : Java!
// out : !avaJ
//read : [!], write : [!]1
//read : [a], write : [!a]2
//read : [v], write : [!av]3
//read : [a], write : [!ava]4
//read : [J], write : [!avaJ]5
// out: !avaJ!avaJ
// out2: !avaJ

package Week02.day0719;

import java.sql.Date;
import java.text.MessageFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.Set;



class Car{
	private String model; // 모델명
	private int effciency; // 연비 (cc)
	private int distance; // 뛴거리 (km)
	private HashMap fixHis = new HashMap(); // 수리이력
	private String nowOwner;
	private HashSet accidentHis = new HashSet(); // 사고이력
	
	Car(String model, int effciency, int distance, String nowOwner){
		this.model = model;
		this.effciency = effciency;
		this.distance = distance;
		this.nowOwner = nowOwner;
	}
	
	public void addAccidentHis() throws Exception { //		사고이력을 추가한다. HashMap
//        - info: location(장소), date(20190102), time(12:50)이 / 를 구분자로 add
		//구분자 쓰는법 : String data[] = info.split("/");
//            ex. format : " 로타리사거리/20190501/14:00 "
//        - 조건1:  같은 사고이력을 추가할 수 없다
//        - 조건2:  잘못된 날짜와 시간이 추가되면 안된다(ex. 55시. 55월...)
		
		AccidentHis in = new AccidentHis("로타리사거리", "20190228", "12:00");
		
		//같은 사고이력 체크 , hashset은 중복체크 스스로 하므로 필요가 없다.
		if(accidentHis.contains(in)) {
			throw new Exception("같은 사고이력을 추가하실 수 없습니다.");
		}
		
		//잘못된 날짜와 시간 추가 방지 체크
		if(Util.validationDate(in.getDate() + " " + in.getTime()))
			accidentHis.add(in);
		else
			throw new Exception("잘못된 날짜이거나 잘못된 시간 형식입니다.");
	}
	
	public void printAccidnetHis() throws ParseException{ // 사고이력을 출력한다. HashMap
//		형식: ‘{0} - {1} ? {2}’, {0}: 장소, {1}: 날자, {2}: 시간
//                날자는 xxxx.xx.xx Format으로 출력한다
		
		SimpleDateFormat original_format = new SimpleDateFormat("yyyyMMdd");
		SimpleDateFormat new_format = new SimpleDateFormat("yyyy.MM.dd");
		Iterator it = accidentHis.iterator();
		while(it.hasNext()) { // hasnext를 쓰면 아래 에선 쓰지 못하므로 변수를 써서 한다.
			AccidentHis e = (AccidentHis) it.next();
			java.util.Date original_date = original_format.parse(e.getDate());
			String new_date = new_format.format(original_date);
			String msg = "{0} - {1} ? {2}";
			Object[] arguments = {((AccidentHis)e).getLocation(), new_date, ((AccidentHis)e).getTime()};
			String result = MessageFormat.format(msg, arguments);
			System.out.println(result);
		}
		
	}
	
	//SubString으로 활용하는 방법도 있다.
//	public boolean DateCheck(int month, int date, int hour, int min) {
//		if(month>0 && month<=12)
//			if(date>0 && date<=31)
//				if(hour>=0 && hour <24)
//					if(min>=0 && min<60)
//						return true;
//		return false;
//	}
//	public void addAccidentHis(String info) {
//		String[]ac = info.split("/");
//		int month = (Integer.parseInt(ac[1].substring(4, 6)));
//		int date = (Integer.parseInt(ac[1].substring(6, 8)));
//		int hour = (Integer.parseInt(ac[2].substring(0, 2)));
//		int min = (Integer.parseInt(ac[2].substring(3, 5)));
//		Accident acc = new Accident(ac[0],ac[1],ac[2]);
//		if(!DateCheck(month, date, hour, min)) {
//			System.out.println("��¥/�ð��� �߸� �Է��߽��ϴ�.");
//		}else {
//			accidentHis.add(acc);
//		}
//	}
	
	
	public void addFixHis(String date, String item, String fixcmt) throws Exception { // 수리이력을 추가한다. item : 수리부품 , HashMap
//		 - date별 item(수리부품)의 fixcmt(수리이력)을 추가한다
//       - 조건1 : date별 item(수리부품)은 중복될 수 없다(같은날 같은 엔진)
		
		FixHis fh = new FixHis(date, item, fixcmt);
		
		String strKey = date + "/" + item;
		//System.out.println(strKey); //20190717/범퍼
		String strFixinfo = date + "/" + item + "/" + fixcmt;
		if(fixHis.containsKey(strKey)) {
			throw new Exception("같은 수리부품은 중복 될 수 없습니다.");
		}
		else{
			fixHis.put(strKey, strFixinfo);
		}
		
	}
	
	public void printFixHis() { // 수리이력을 출력한다. HashMap
//		 - 날자 ? 부분 ? 수리Cmt를 출력한다
		Set set = fixHis.entrySet(); // HashMap에 넣은 Key와 Value를 Set에 넣고 iterator에 값으로 Set정보를 담에 준다.
		Iterator it = set.iterator();
		
		while(it.hasNext()) {
			Entry e = (Entry) it.next(); // Entry 객체를 이용하면 key 와 value를 동시에 구할 수 있다
			System.out.println(e.getValue()); // values() --> 저장된 모든 값 출력
		}
	}
	
}

class Util{
	public static boolean validationDate(String date) {
		//setLenient(boolean lenient) :날짜가 파싱될 때 허술하게 할지말지를 설정.
		//이렇게 체크할 경우, 유효한 날짜가 아니면 ParseException을 던질것이고, 유효한 날짜라면 true로 반환.
		try {
			SimpleDateFormat dateformat = new SimpleDateFormat("yyyyMMdd HH:mm");
			dateformat.setLenient(false);
			dateformat.parse(date);
			return true;
		}catch(ParseException e) {
			return false;
		}
		
	}
}


class AccidentHis{
	String location;
	String date;
	String time;
	
	AccidentHis(String location, String date, String time){
		this.location = location;
		this.date = date;
		this.time = time;
	}

	public String getLocation() {
		return location;
	}

	public void setLocation(String location) {
		this.location = location;
	}

	public String getDate() {
		return date;
	}

	public void setDate(String date) {
		this.date = date;
	}

	public String getTime() {
		return time;
	}

	public void setTime(String time) {
		this.time = time;
	}
	
	public int hashCode() {
		return Objects.hash(location, date, time);
	}
	
	public boolean equals(Object obj) {
		if (obj != null && obj instanceof AccidentHis) { // obj가 AccidentHis의 Instance
			return location.equals(((AccidentHis) obj).location) && date.equals(((AccidentHis) obj).date) && time.equals(((AccidentHis) obj).time); // 값이 같은지 비교
		} else {
			return false;
		}
	}

}

class FixHis{
	String date;
	String item;
	String fixcmt;
	
	FixHis(String date, String item, String fixcmt){
		this.date = date;
		this.item = item;
		this.fixcmt = fixcmt;
	}

	public String getDate() {
		return date;
	}

	public void setDate(String date) {
		this.date = date;
	}

	public String getItem() {
		return item;
	}

	public void setItem(String item) {
		this.item = item;
	}

	public String getFixcmt() {
		return fixcmt;
	}

	public void setFixcmt(String fixcmt) {
		this.fixcmt = fixcmt;
	}
	
	public boolean equals(Object obj) {
		if (obj != null && obj instanceof FixHis) {
			String thisTmp = date + "/" + item;
			String tmp = ((FixHis)obj).getDate() + "/" + ((FixHis)obj).getItem();
			
			return thisTmp.equals(tmp);
		} 
		else return false;		
	}
	
	public int hashCode() {
		return Objects.hash(date, item, fixcmt);
	}
	
}

public class 실습9일차 {

	public static void main(String[] args) throws Exception {
		
		Car car = new Car("말리부", 3000, 10000, "홍길동");
		
		car.addAccidentHis();
		try {
			car.addAccidentHis();  // 오류메세지 출력용	
		}catch (Exception e) {
		e.printStackTrace();
		}
		
		car.printAccidnetHis();
		
		car.addFixHis("20190719", "와이퍼", "교체");
		car.printFixHis();
		try {
			car.addFixHis("20190719", "와이퍼", "교체"); // 오류메세지 출력용	
		}catch (Exception e) {
		e.printStackTrace();
		}
		
		
	}

}
--------------------------------------------------------------------------

package Week02.day0719;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.Set;

class Plane{
	private String model;
	private String airline; //항공사이름
	private HashSet fixHis1 = new HashSet(); // 수리이력
	
	Plane(String model, String airline){
		this.model = model;
		this.airline = airline;
	}
	
	public void addFixHis(String info) throws Exception { // 수리이력을 추가한다 - 같은 수리이력을 추가할 수 없다(airport/date/cmt)
		String data[] = info.split("/");

		try {
			FixHis1 ac = new FixHis1(data[0], data[1], data[2]);
			if(fixHis1.contains(ac))
				throw new Exception("같은 수리이력은 추가 될 수 없습니다.");
			else
				fixHis1.add(ac);
		} catch(Exception e) {
			e.printStackTrace();
		}
	}
	
	public void printFixtHis() { // 수리이력을 출력한다. -  - 수리이력을 출력: 공항-날자-사고내용
		Iterator it = fixHis1.iterator();
		
		while(it.hasNext()) {
			FixHis1 e = (FixHis1) it.next();
			System.out.println(e.getAirport() +"-"+ e.getDate() +"-"+ e.getCmt());
		}
	}
}

class FixHis1{ //set은 hashcode와 equals를 재정의해야함.
	private String airport; // 공항
	private String date; // 수리일자
	private String cmt; // 수리내용
	
	FixHis1(String airport, String date, String cmt){
		this.airport = airport;
		this.date = date;
		this.cmt = cmt;
	}

	public String getAirport() {
		return airport;
	}

	public void setAirport(String airport) {
		this.airport = airport;
	}

	public String getDate() {
		return date;
	}

	public void setDate(String date) {
		this.date = date;
	}

	public String getCmt() {
		return cmt;
	}

	public void setCmt(String cmt) {
		this.cmt = cmt;
	}
	
	public boolean equals(Object obj) {
		if (obj != null && obj instanceof FixHis1) {
			String thisTmp = airport + date + cmt;
			String tmp = ((FixHis1) obj).getAirport() + ((FixHis1) obj).getDate() + ((FixHis1) obj).getCmt();
			return thisTmp.equals(tmp);
		} else
			return false;
	}
	
	public int hashCode() { // 추가할수록 값이 디테일하게 쪼개짐.
		return Objects.hash(airport, date, cmt);
	}
}

public class 실습9일차2번 {

	public static void main(String[] args) {
		
		Plane pl = new Plane("보잉707", "아시아나");
		
		try {
		pl.addFixHis("인천공항/20190701/타이어교체");
		pl.addFixHis("나하공항/20190601/날개교체");
		pl.addFixHis("인천공항/20190701/타이어교체");
		pl.printFixtHis();
		} catch(Exception e) {
			e.printStackTrace();
		}
		

	}

}
--------------------------------------------------------------------------

package Week02.day0719;

public class ThreadEx1 {

	public static void main(String[] args) {
		
		//싱글 스레드
		long startTime = System.currentTimeMillis();
		
		for(int i=0; i<500; i++)
			System.out.printf("%s", new String("-"));
		
		System.out.print("소요시간1:" + (System.currentTimeMillis()-startTime)); // 소요시간1:32
		
		for(int i=0; i<500; i++)
			System.out.printf("%s", new String("|"));
		
		System.out.print("소요시간2:" + (System.currentTimeMillis()-startTime)); // 소요시간2:43

	}

}
--------------------------------------------------------------------------
/* Multi Threading */
1. 여러 Thread가 하나의 자원을 공유
2. Monitors
- Monitor란 상태변수
- Monitors는 일종의 열쇠, 임계영역(critical section)을 들어가기 위해선 이 열쇠가 필요하다.
- 임계영역을 만들기 위해 synchronized 키워드를 사용한다.

package Week02.day0719;

public class ThreadEx2 {
	
	static long startTime = 0;

	public static void main(String[] args) {
		
		//멀티스레드
		ThreadEx2_1 th1 = new ThreadEx2_1();
		th1.run();
		startTime = System.currentTimeMillis();
		
		for(int i=0; i<300; i++) {
			System.out.print("-");
		}

		System.out.print("소요시간2:" + (System.currentTimeMillis()- ThreadEx2.startTime)); // 소요시간2:2
	}

}


class ThreadEx2_1 extends ThreadEx2{
	public void run() {
		for(int i=0; i<300; i++) {
			System.out.print("|");
		}
		
		System.out.print("소요시간2:" + (System.currentTimeMillis()- ThreadEx2.startTime)); // 소요시간2:1563517789948
	}
}

--------------------------------------------------------------------------
package Week02.day0719;

public class ThreadSwtiching {

	public static void main(String[] args) {
		//ThreadSwtiching 예제
		/*앞에서 만든 쓰레드 B를 만든 후 Start
		 * 해당 쓰레드가 실행되면, 해당 쓰레드는 run메소드안에서 자신의 모니터링 락을 획득
		 */
		
		ThreadB b = new ThreadB();
		b.start();
		//b에 대하여 동기화 블럭을 설정
		//만약 main 쓰레드가 wait을 하게 되면서 main쓰레드 대기
		synchronized(b) { // synchronized{} : 동기화 처리부분
			try {
				//b.wait()메소드를 호출.
				//메인쓰레드는 정지
				//ThreadB가 5번 값을 더한 후 norify를 호출하게 되면 wait에서 깨어남
				System.out.println("b가 완료될 때까지 기다립니다.");
				b.wait();
			} catch(InterruptedException e) {
				e.printStackTrace();
			}
			//깨어난 후 결과를 출력
			System.out.println("Total is : " + b.total);
		}
	}
}

class ThreadB extends Thread{
	/*해당 쓰레드가 실행되면 자기 자신의 모니터링 락을 획득
	 * 5번 반복하면서 0.5초씩 쉬면서 total에 값을 누적
	 * 그 후에 notify()메소드를 호출하여 wait하고 있는 쓰레드를 깨움
	 */
	
	int total;
	public void run() {
		synchronized(this) {
			for(int i=0; i<5; i++) {
				System.out.println(i + "를 더합니다.");
				total+=i;
				try {
					Thread.sleep(500);
				} catch(InterruptedException e) {
					e.printStackTrace();
				}
			}
			notify();
		}
	}
}

//출력값
//b가 완료될 때까지 기다립니다.
//0를 더합니다.
//1를 더합니다.
//2를 더합니다.
//3를 더합니다.
//4를 더합니다.
//Total is : 10

--------------------------------------------------------------------------

package Week02.day0719;

public class SyncThread {

	public static void main(String[] args) {
		
		//동기화 적용예제
		
		User user = new User();
		
		//3개의 스레드 객체 생성
		UserThread p1 = new UserThread(user, "A1");
		UserThread p2 = new UserThread(user, "B2");
		UserThread p3 = new UserThread(user, "C3");
		
		//스레드 스케줄링 : 우선순위 부여
		p1.setPriority(p1.MAX_PRIORITY);
		p2.setPriority(p3.NORM_PRIORITY);
		p3.setPriority(p3.MIN_PRIORITY);

		System.out.println("----------------------");
		System.out.println("sychronized 적용안한 경우");
		System.out.println("----------------------");
		
		//스레드 시작
		p1.start();
		p2.start();
		p3.start();
	}
}

//Heap영역의 멤버 변수는 공통으로 사용
class User{
	private int userNo = 0;
	
	//임계 영역을 지정하는 sychronized메소드
	public void add(String name) {
		System.out.println(name + ":" + userNo++ + "번째 사용"); //  sychronized 가 없으므로, 랜덤값이 출력됨.
	}
}

class UserThread extends Thread{
	User user;
	
	UserThread(User user, String name){
	super(name);
	this.user = user;
	}
	
	public void run() {
		try {
			for(int i=0; i<3; i++) {
				user.add(getName());
				sleep(500);
			}
		}catch(InterruptedException e) {
			System.err.println(e.getMessage());
		}
	}
}

//출력값
//----------------------
//sychronized 적용안한 경우
//----------------------
//A1:0번째 사용
//B2:1번째 사용
//C3:2번째 사용
//A1:3번째 사용
//C3:3번째 사용
//B2:3번째 사용
//A1:4번째 사용
//C3:5번째 사용
//B2:4번째 사용

--------------------------------------------------------------------------

package Week02.day0719;

public class SyncThread2 {

	public static void main(String[] args) {
		
		//동기화 적용예제
		
		User2 user = new User2();
		
		//3개의 스레드 객체 생성
		UserThread2 p1 = new UserThread2(user, "A1");
		UserThread2 p2 = new UserThread2(user, "B2");
		UserThread2 p3 = new UserThread2(user, "C3");
		
		//스레드 스케줄링 : 우선순위 부여
		p1.setPriority(p1.MAX_PRIORITY);
		p2.setPriority(p3.NORM_PRIORITY);
		p3.setPriority(p3.MIN_PRIORITY);

		System.out.println("----------------------");
		System.out.println("sychronized 적용한 경우");
		System.out.println("----------------------");
		
		//스레드 시작
		p1.start();
		p2.start();
		p3.start();
	}
}

//Heap영역의 멤버 변수는 공통으로 사용
class User2{
	private int userNo = 0;
	
	//임계 영역을 지정하는 sychronized메소드
	//메소드 내 작업이 완료될 때까지 다른 Thread가 들어올 수 없다.
	public synchronized void add(String name) {
		System.out.println(name + ":" + userNo++ + "번째 사용");
	}
}

class UserThread2 extends Thread{
	User2 user;
	
	UserThread2(User2 user, String name){
	super(name);
	this.user = user;
	}
	
	public void run() {
		try {
			for(int i=0; i<3; i++) {
				user.add(getName());
				sleep(500);
			}
		}catch(InterruptedException e) {
			System.err.println(e.getMessage());
		}
	}
}

//출력값
//----------------------
//sychronized 적용한 경우
//----------------------
//A1:0번째 사용
//B2:1번째 사용
//C3:2번째 사용
//B2:3번째 사용
//A1:4번째 사용
//C3:5번째 사용
//B2:6번째 사용
//C3:7번째 사용
//A1:8번째 사용