'전체 글'에 해당되는 글 396건
- 2019.07.25 23일차
- 2019.07.25 2일차
- 2019.07.24 주차관리 시스템 ver.2
- 2019.07.24 1일차
- 2019.07.23 비교와 조건문
- 2019.07.23 변수, 주석, 줄바꿈과 여백
- 2019.07.23 Java - Stream, Network
- 2019.07.23 객체 정렬하기
- 2019.07.22 숫자와 문자
- 2019.07.22 실행방법과 실습환경
package Week03.day0725;
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.Iterator;
import java.util.Objects;
public class practice0725 {
public static void main(String[] args) throws ParseException {
SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd");
Product p1 = new Product(3424, "갤럭시S10");
Product p2 = new Product(3331, "아이폰XR");
Product p3 = new Product(5552, "아이폰X");
Product p4 = new Product(1111, "아이폰S7");
HashMap products = new HashMap();
// products.put(004, "갤럭시S10");
// products.put(001, "아이폰XR");
// products.put(002, "아이폰X");
// products.put(003, "아이폰S7");
Order or = new Order(123, f.parse("2019-07-01"), products);
or.addProduct(1, p1);
or.addProduct(2, p2);
or.addProduct(3, p3);
or.addProduct(4, p4);
or.delProduct(123);
Product pr = new Product(9997, "아이패드");
or.chgProduct(1, pr);
or.printKeyBySort(products);
Compare1 c = new Compare1();
or.printValueBySort(c);
//comparable로 구현
// System.out.println("====printValueBySort(by comparable)====");
// ArrayList<Product> list = new ArrayList<Product>();
// list.addAll(products.values());
// Collections.sort(list);
// for(Product p : list) {
// System.out.println(p.toString());
// }
}
}
class Order{
private int orderNo;
private Date orderDt;
private HashMap products = new HashMap(); // 주문상품
public int getOrderNo() {
return orderNo;
}
public void setOrderNo(int orderNo) {
this.orderNo = orderNo;
}
public Order(int orderNo, Date orderDt, HashMap products) {
this.orderNo = orderNo;
this.orderDt = orderDt;
this.products = products;
}
public void addProduct(int ordProdNo, Product p) { // 주문상품을 추가한다
this.orderNo = orderNo;
this.products.put(ordProdNo, p);
}
public void delProduct(int ordProdNo) { // 주문상품을 삭제한다
products.remove(ordProdNo);
}
public void chgProduct(int orProdNo, Product p) { // 주문상품을 변경한다
products.replace(orProdNo, p);
}
public void printKeyBySort(HashMap products) { // 주문상품을 키를 기준으로 정렬하여 출력한다
System.out.println("====printKeyBySort====");
HashMap<Integer, Product> hs = new HashMap<Integer, Product>(products);
Iterator<Integer> it = products.keySet().iterator(); //키값 오름차순 정렬(기본)
while(it.hasNext()) {
Integer key = it.next();
System.out.println("key 값 : " + (key) +", 제품명 : " + hs.get(key).getProductNm() + ", 제품번호 : " + hs.get(key).getProductNo());
}
}
public void printValueBySort(Comparator <Product> c) {
//주문상품을 Value를 기준으로 정렬하여 출력한다
//Value는 제품번호를 기준으로 정렬한다
System.out.println("====printValueBySort====");
ArrayList<Product> list = new ArrayList<Product>();
list.addAll(this.products.values()); // 값을 리턴. comparable로 (내부)
Collections.sort(list, c);
for(Product p : list) {
System.out.println(p.toString());
}
}
}
class Compare1 implements Comparator<Product> {
@Override
public int compare(Product o1, Product o2) {
if(o1.getProductNo() > o2.getProductNo()){
return 1;
} else if (o1.getProductNo() < o2.getProductNo()) {
return -1;
} else {
return 0;
}
}
}
// Comparator - 편법 키값을 정렬해서 다시 value를 정렬하는 방법.
// list.addAll(products.keySet()); // 키값을 리턴. comparator로 (외부)
// Collections.sort(list, new Comparator() {
// @Override
// public int compare(Object o1,Object o2) {
// Object v1 = products.get(o1);
// Object v2 = products.get(o2);
// return ((Comparable<Object>) v2).compareTo(v1);
// }
// });
//
// Collections.reverse(list); // 주석시 오름차순
// return;
class Product{
private int productNo; // 제품번호
private String productNm; // 제품이름
public Product(int productNo, String productNm) {
this.productNo = productNo;
this.productNm = productNm;
}
public int getProductNo() {
return productNo;
}
public void setProductNo(int productNo) {
this.productNo = productNo;
}
public String getProductNm() {
return productNm;
}
public void setProductNm(String productNm) {
this.productNm = productNm;
}
public int hashCode() {
return Objects.hash(this.productNm, this.productNo);
}
public boolean equals(Object obj) {
if(obj instanceof Product) {
Product tmp = (Product)obj;
return this.productNo== tmp.productNo && this.productNm.equals(tmp.productNm);
}
return false;
}
public String toString() {
return "제품번호 : " + this.getProductNo() + "/" + "제품이름 : " + this.getProductNm();
}
//comparable로 구현 (Product클래스에 implements Comparable 붙어야함)
// public int compareTo(Object s) {
// if(this.productNo < ((Product)s).getProductNo()) {
// return -1;
// } else if (this.productNo > ((Product)s).getProductNo()) {
// return 1;
// }
// return 0;
// }
}
주요내용 : 텍스트 제어함수, 문자자르기, 숫자 제어함수, 데이터 조작함수
/*-- (빈공백은 나오지 않게 처리한다) */
/*1. 고객정보에서 고객이름이 ‘The’로 시작되고 고객국가가 ‘USA’인 고객의 주소정보를 다음의 Format으로 추출하시오
(빈공백은 나오지 않게 처리한다)
Format = 고객주소’ ‘고객시/도’ ‘고객주’ ‘고객우편번호’(‘고객국가’)’
*/
SELECT TRIM(CUST_ADDRESS) || '''' || '''' ||TRIM(cust_city) || '''' || '''' || TRIM(cust_state)|| '''' || '''' || TRIM(cust_zip) || '''' || '(' || '''' || TRIM(cust_country) || '''' || ')' || ''''
FROM CUSTOMERS
WHERE CUST_NAME LIKE 'The%'
AND CUST_country = 'USA';
/*2. 주문제품항목에서 주문번호가 ‘20005’, ‘20007’ 인 주문에 대해 주문번호, 제품번호와 주문총금액(항목수량*항목가격) 을 추출하시오*/
SELECT order_num, prod_id, (quantity*item_price)
FROM orderitems
WHERE order_num IN ('20005', '20007');
/*3. 제품정보에서 공급업체번호가 ‘BRS01’, ‘DLL01’이 아닌 제품이름과 제품가격을 다음의 Format으로 추출하시오
Format = 제품이름’[’제품가격’]’
*/
SELECT TRIM(prod_name) ||'['||prod_price||']'
FROM Products
WHERE vend_id NOT IN ('BRS01', 'DLL01');
/*텍스트 제어함수*/
/*공급업체이름의 길이*/
SELECT vend_id, LENGTH(TRIM(vend_name))
FROM vendors;
/*공급업체 주소를 소문자 or 대문자로 */
SELECT vend_id, LOWER(vend_address), UPPER(vend_address)
FROM vendors;
/*문자 자르기*/
SELECT vend_id, SUBSTR(vend_address, 1, 3), SUBSTR(vend_address, 4)
FROM vendors;
--문자 대체하기--
SELECT vend_id, REPLACE(vend_address, 'Street', 'Road')
FROM vendors;
--NULL이 아닌 첫번째 값--
SELECT vend_id, vend_state, vend_city, COALESCE(vend_state, vend_city)
FROM vendors
WHERE vend_id = 'FNG01';
-- 공급업체주가 CA이면 1, NY이면 2 모두 아니면 3--
SELECT vend_id, vend_state, DECODE(TRIM(vend_state), 'CA', 'NY', 2, 3)
FROM vendors;
--NULL이면 다른 값으로
--nvl : 널값이면 디폴트값 리턴
SELECT nvl(cust_email, 'test@naver.com')
FROM customers;
--1. 고객의 주소 중에 소문자로 ‘south’가 들어간 고객정보를 다음의 Format으로 추출하시오(공백제거) - Format: 고객이름’/’고객주소, 소문자로
SELECT RTRIM(cust_name)||'/'||LTRIM(cust_address)
FROM Customers
WHERE LOWER(cust_address) LIKE '%south%';
--2. 주문상품의 주문번호가 ‘20005’, ‘20007’가 아닌 제품유형코드를 추출하시오 - 제품유형코드: 제품번호의 앞의 2자리
SELECT SUBSTR(prod_id, 0, 2)
FROM Orderitems
WHERE order_num NOT IN ('20005', '20007');
--3. 고객의 고객이름과 고객주소정보를 추출하시오 - 고객주소정보: 고객주소중에 Drive는 Car로 변경
SELECT cust_name, REPLACE(cust_address, 'Drive', 'Car')
FROM Customers;
--4. 공급업체의 공급업체번호가 ‘BR’로 시작되는 공급업체이름과 공급업체지역번호를 공급업체이름으로 내림차순으로 추출한다 - 공급업체지역번호: 우편번호의 앞에 2자리
SELECT vend_name, SUBSTR(vend_zip, 0, 2)
FROM Vendors
WHERE vend_id LIKE 'BR%' ORDER by vend_name DESC;
--5. 공급업체의 공급업체번호가 ‘BRE02’이 아닌 공급업체이름과 공급업체사업구역번호를 추출한다 - 공급업체사업구역번호: 공급업체지역번호가 44이면 A, 99이면 B, 11이면 C 나머지는 D
SELECT vend_name, DECODE(SUBSTR(vend_zip,1,2), '44', 'A', '99', 'B', '11', 'C', 'D')
FROM Vendors
WHERE vend_id <> 'BRE02';
--6. 고객의 고객명과 고객주소정보를 추출한다 - 고객주소정보: 고객메일주소 or 고객주소, 고객메일주소가 있으면 고객메일주소가 우선
SELECT cust_name, COALESCE(cust_email, cust_address)
FROM Customers;
--7. 제품의 제품명에 ‘bear’이 들어있는 모든 제품에 대해 제품이름을 추출하는데 bear를 toy로 변경하여 추출한다
SELECT REPLACE(prod_name, 'bear', 'toy')
FROM Products
WHERE prod_name LIKE '%bear%';
/*숫자제어함수*/
-- 올림, 내림
SELECT prod_id, prod_price, CEIL(prod_price), FLOOR(prod_price)
FROM products;
-- 반올림, 버림
SELECT prod_id, prod_price, ROUND(prod_price,1), TRUNC(prod_price,1)
FROM products;
-- 제곱, 제곱근
SELECT prod_id, prod_price, POWER(prod_price,2), SQRT(prod_price)
FROM products;
-- 나머지
SELECT prod_id, prod_price, MOD(prod_price,2)
FROM products;
--1. 제품의 제품번호가 ‘BR’로 시작되는 상품의 가격을 소수점 첫째자리에서 반올림 하여 제품이름과 함께 추출하시오
SELECT RTRIM(prod_name), ROUND(prod_price, 0)
FROM Products
WHERE prod_id LIKE 'BR%';
--2. 주문상품중에 가격이 10$이상인 주문번호와 상품번호, 항목가격을 추출하시오 - 항목가격: 항목가격은 소수점 버림으로 처리하여 추출
SELECT order_num, prod_id, TRUNC(item_price,0)
FROM Orderitems
WHERE item_price >=10;
/*데이터 조작함수 사용하기*/
-- 현재날짜와 주문날짜 간의 월차이
SELECT order_num, TO_CHAR(order_date, 'YYYY-MM-DD'), MONTHS_BETWEEN(sysdate, order_date)
FROM orders;
-- 주문날짜에서 10개월을 추가
SELECT order_num, TO_CHAR(order_date, 'YYYY-MM-DD'), TO_CHAR(ADD_MONTHS(order_date,10), 'YYYY-MM-DD')
FROM orders;
-- 주문한 달의 마지막 날짜
SELECT order_num, TO_CHAR(order_date, 'YYYY-MM-DD'), TO_CHAR(LAST_DAY(order_date), 'YYYY-MM-DD')
FROM orders;
-- 특정날짜와 주문날짜간의 월차이
SELECT order_num, TO_CHAR(order_date, 'YYYY-MM-DD'), MONTHS_BETWEEN(TO_DATE('2018-12-05', 'YYYY-MM-DD'), order_date)
FROM orders;
-- 숫자를 문자로
SELECT order_num, quantity, 'A'||TO_CHAR(quantity)
FROM orderitems;
-- 날짜를 문자로
SELECT order_num, TO_CHAR(order_date, 'YYYY-MM-DD'), TO_CHAR(sysdate, 'YYYY/MM/DD HH24:MI:SS')
FROM orders;
-- 2004년에 주문된 항목의 주문번호
SELECT order_num
FROM Orders
WHERE TO_NUMBER(TO_CHAR(order_date, 'YYYY'))=2004;
-- BETWEEN으로 구현
SELECT order_num
FROM Orders
WHERE order_date BETWEEN TO_DATE('20040101') AND TO_DATE('20041231');
-- 1. 고객주문에서 주문월일 2월인 모든 주문번호를 주문번호를 내림차순으로 하여 추출한다
SELECT order_num, order_date
FROM Orders
WHERE TO_NUMBER(TO_CHAR(order_date, 'MM'))=2 Order by order_num DESC;
-- 2. 고객주문에서 주문일에 +1일을 한 날자가 해당 주문월의 마지막 날자와 같은 주문번호를 오름차순으로 추출한다
SELECT order_num
FROM Orders
WHERE LAST_DAY(order_date) = (order_date + 1)
Order by order_num ASC;
-- 3. 고객주문에서 현재일과 주문일간의 차이가 185개월을 넘는 주문번호를 추출한다
SELECT order_num, order_date
FROM Orders
WHERE MONTHS_BETWEEN(sysdate, order_date) > 185;
-- 4. 고객주문에서 고객번호가 1로 끝나는 주문의 주문날짜의 월일을 추출하시오 (Format예 : 07-01)
SELECT cust_id, TO_CHAR(order_date, 'MM')||'-'||TO_CHAR(order_date, 'DD') /* TO_CHAR(order_date, 'MM-DD')*/
FROM Orders
WHERE cust_id LIKE '%1'; /* WHERE SUBSTR(cust_id, LENGTH(cust_id),1) = '1'*/
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);
// }
// }
'Java' 카테고리의 다른 글
| 좌석 예약 시스템 (0) | 2019.08.01 |
|---|---|
| 디버깅하는 법 (0) | 2019.07.31 |
| Java - Stream, Network (0) | 2019.07.23 |
| 객체 정렬하기 (0) | 2019.07.23 |
| Java - Stream(byte, 문자) (0) | 2019.07.22 |
주요내용 : 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)
조건문안에 괄호()가 있으면, 괄호안을 먼저 실행한다.
'JavaScript' 카테고리의 다른 글
| 함수 (0) | 2019.08.13 |
|---|---|
| 반복문 (0) | 2019.07.25 |
| 변수, 주석, 줄바꿈과 여백 (0) | 2019.07.23 |
| 숫자와 문자 (0) | 2019.07.22 |
| 실행방법과 실습환경 (0) | 2019.07.22 |
############### 변수 ##################
변수 : 값을 담는 그릇(값을 유지할 필요가 있을 때)
var로 시작해서 변수 선언.
다른 값을 담을 수도 있다. 그럴 때는 다시 var 쓸 필요 없다.
변수에는 숫자, 문자 등등 어떤 것도 담길 수 있다.
그것들을 사용해서 연산, 결합 등 할 수 있다
변수 2개를 동시에 선언할 때는 var a = 1, b = 2의 형태로 var는 한 번만 쓰고 ,로 연결하면 된다.
변수는 코드의 재활용성을 높이기 위해서 쓴다.
이것은 코딩을 할 때 대단히 중요한 특성이다.
############### 주석 ##################
주석(comment) // ~~ or /* ~~ */
- 코드의 이해를 돕기위해 설명하거나, 코드를 비활성화 시킬때 사용.
- 나중에 잊어버렸을 때나, 타인과 협업할 때 유용.
-- 궁극적으로는, 쉽게 이해하고 가독성이 좋은 코드가 BEST.
############### 줄바꿈과 여백 ##################
; 세미콜론(semicolon)
- 명령이 끝났다는 표현
- 한줄에 여러 명령이 있을때, 구분하는 역할
- 자바스크립트는 줄바꿈을 해도 알아듣지만, 쓰는 것이 좋은 습관
여백(blank)은 가독성을 위해 쓴다.
'JavaScript' 카테고리의 다른 글
| 반복문 (0) | 2019.07.25 |
|---|---|
| 비교와 조건문 (0) | 2019.07.23 |
| 숫자와 문자 (0) | 2019.07.22 |
| 실행방법과 실습환경 (0) | 2019.07.22 |
| 언어소개 (0) | 2019.07.12 |
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();
}
}
}
'Java' 카테고리의 다른 글
| 디버깅하는 법 (0) | 2019.07.31 |
|---|---|
| 주차관리 시스템 ver.2 (0) | 2019.07.24 |
| 객체 정렬하기 (0) | 2019.07.23 |
| Java - Stream(byte, 문자) (0) | 2019.07.22 |
| Java - Thread(싱글, 다중(멀티), 스위칭), 동기화 (0) | 2019.07.19 |
정렬 대상 클래스
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)]'Java' 카테고리의 다른 글
| 주차관리 시스템 ver.2 (0) | 2019.07.24 |
|---|---|
| Java - Stream, Network (0) | 2019.07.23 |
| Java - Stream(byte, 문자) (0) | 2019.07.22 |
| Java - Thread(싱글, 다중(멀티), 스위칭), 동기화 (0) | 2019.07.19 |
| Java - 제네릭스, Wildcard, 열거형, Thread (0) | 2019.07.18 |
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
'JavaScript' 카테고리의 다른 글
| 반복문 (0) | 2019.07.25 |
|---|---|
| 비교와 조건문 (0) | 2019.07.23 |
| 변수, 주석, 줄바꿈과 여백 (0) | 2019.07.23 |
| 실행방법과 실습환경 (0) | 2019.07.22 |
| 언어소개 (0) | 2019.07.12 |
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8"/>
</head>
<body>
<script>
alert('Hello world'); // 이 부분만 javaScript 이고 나머지는 html코드임.
</script>
</body>
</html>IDE = 통합 개발 도구
선택은 본인의 몫.
개발자라면 좋은 도구를 찾는 노력을 게을리해서는 안됨.
'JavaScript' 카테고리의 다른 글
| 반복문 (0) | 2019.07.25 |
|---|---|
| 비교와 조건문 (0) | 2019.07.23 |
| 변수, 주석, 줄바꿈과 여백 (0) | 2019.07.23 |
| 숫자와 문자 (0) | 2019.07.22 |
| 언어소개 (0) | 2019.07.12 |
