JAVA_DAY4

Collection 추가

• Map 계열

// 3. Map 계열
Map<String, Integer> m = new Hashtable<>();
Map<String, String> m2 = new HashMap<>(); // 둘 다 사용 가능

m.put("kor", 100);
m.put("eng", 99);
m.put("eng", 33);
m.put("math", 98);
m.put("math", 22); // 실행은 되지만, 쌓이진 않는다.

System.out.println(m.size()); // 3

for (String key : m.keySet()) { // key로 설정한 타입으로 foreach 돌면 된다.
	System.out.println(m.get(key)); // 가져올땐 get 함수 사용
}

// m.clear(); // 전체 삭제

System.out.println("=========================================");

Map<String, BoardVO> mvos = new Hashtable<>();
mvos.put("vo1", new BoardVO(1, "kim", "aaa", "bbb"));
mvos.put("vo2", new BoardVO());

for (String key : mvos.keySet()) {
	System.out.println(m.get(key));
}

• java는 equals() 함수 이용하여 String을 비교한다.

Stack, Queue

// Stack
package test.com;

import java.util.Stack;

public class Test03main {
	public static void main(String[] args) {
		Stack<Coin> cs = new Stack<Coin>(); // FILO
	
		for (int i = 1; i <= 5; i++) {
			Coin c = new Coin();
			c.setValue(100 * i);
			cs.push(c);	
		}
		
		System.out.println(cs); // 배열처럼 출력됨. 맨왼쪽이 맨처음넣은것
		System.out.println(cs.size()); // 1
		System.out.println(cs.pop()); // Object가 통째로 나옴
		System.out.println(cs.peek()); // == top()
	}
}

// Queue
package test.com;

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

public class Test03main_2 {
	public static void main(String[] args) {
		Queue<Message> q = new LinkedList<>(); // FIFO
	
		Message msg1 = new Message("sendMail", "yang");
		Message msg2 = new Message("sendSms", "shin");
		Message msg3 = new Message("sendKakao", "kim");
		
		q.offer(msg1);
		q.offer(msg2);
		q.offer(msg3); // push
		
		System.out.println(q.size()); // 3
		System.out.println(q); // 가장 처음에 들어온 게 왼쪽
		
		System.out.println(q.peek()); // == front();
		
//		System.out.println(q.poll());
//		System.out.println(q.poll());
//		System.out.println(q.poll()); // == pop()
		
		while (!q.isEmpty()) {
			Message m = q.poll();
			System.out.println(m.getCommand() + " " + m.getTo());
		}
	}
}

Queue 사용 시, LinkedList를 사용해야 함에 주의한다.

enum

열거형 상수

// Enum
package test.com;

public enum TestEnum {
	// 기본적으로 전부 public static final
	MON, TUE, WED, THU, FRI, SAT, SUN
}

// main
package test.com;

public class Test04main {

	public static void main(String[] args) {
		System.out.println(TestEnum.SUN); // SUN
		
		System.out.println("SUN".equals("SUN")); // true
		System.out.println("SUN".equals(TestEnum.SUN)); // false
//		System.out.println("SUN" == TestEnum.SUN); // error
		System.out.println("SUN" == TestEnum.SUN.toString()); // true
		System.out.println(new String("SUN") == new String("SUN")); // false
		System.out.println(new String("SUN").equals(new String("SUN"))); // true
	}
}
// 

annotation

// annotation
package test.com;

import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

import java.lang.annotation.Retention;
import java.lang.annotation.Target;

@Retention(RUNTIME)
@Target(METHOD)
public @interface TestAnnotation {
	String value() default "TestAnnotation: default value";
}

// object
package test.com;

public class TestObject {
	
	@TestAnnotation
	public void test() {
		System.out.println("TestObject test()....");
	} // Annotation이 달린 method
	
	@TestAnnotation("TestObject: 변경된 값 양성호")
	public void test2() {
		System.out.println("TestObject test2()....");
	} // Annotation이 달린 method
}

// main
package test.com;

import java.lang.reflect.Method;

public class TestAnnotationMain {

	public static void main(String[] args) {
		// @TestAnnotation
		
		TestObject obj = new TestObject();
		obj.test();
		
		Method[] ms = TestObject.class.getMethods(); // Method[] 반환
	
		for (Method method : ms) {
			boolean isAnnotation = method.isAnnotationPresent(TestAnnotation.class);
			
			System.out.println(method.isAnnotationPresent(TestAnnotation.class)); // test만 true, 나머진 false
			
			if (isAnnotation) {
				System.out.println(method.getName()); // test
				TestAnnotation ta = method.getDeclaredAnnotation(TestAnnotation.class); // Class T에는 ~~~.class가 들어간다.
				System.out.println(ta.value()); // Annotation의 value()로 설정해둔 값 출력
			}
		}
	}
}

Inner Class

• 1. Member Inner
• 2. Static Inner
• 3. local Inner
• 4. Anonymous Inner

// Member outer class
package test.com;

public class MemberOuter {
	String url = "http://samsungsds.com";
	private Integer kor = 99;
	
	public class Inner { // 이름 상관  X
		// inner class는 new로 객체생성 안해도, 메서드 쓸 수 있다.
		String name = "kim";
		
		public Inner() {
			System.out.println("MemberOuter Inner()...");
			System.out.println(url); // 그냥 호출 된다.
			System.out.println(kor); // 그냥 호출 된다.			
		}
		
		public void sleep() {
			System.out.println("sleep()...");
		}
	}
}

// Static class
package test.com;

public class StaticOuter {
	public static class Inner {
		// 내부 클래스의 자원이 static을 포함할 때
		// static 안에는 일반 멤버는 앵간하면 넣지 말자
		String name = "lee";
		static String sname = "Samsung"; // class가 static이 아니라면 만들기 불가
		
		public void sleep() {
			System.out.println("Inner sleep()....");
		}
		
		public static void run() {
			// sleep(); // error
			System.out.println("Inner static run()....");
		}
	}
}

// abstract class
package test.com;

public abstract class TestAbsClass {
	public abstract void start();
}

// Interface
package test.com;

public abstract class TestAbsClass {
	public abstract void start();
}

// main
package test.com;

import test.com.MemberOuter.Inner;

public class TestMain {

	public static void main(String[] args) {
		// Member inner, static inner, local inner, anonymous inner 총 4개
		System.out.println("inner class");
		
		// 1. member inner
		MemberOuter outer = new MemberOuter();
		// new로 Inner class는 만들 수 없다.
		Inner inner = outer.new Inner(); // 이건 가능, import 필수	
		System.out.println(inner.name);
		inner.sleep(); 
		// .java 파일은 1개지만, 컴파일 되어있는 bin 폴더에 가면 Inner class도 .class 파일로 만들어져 있다. (MemberOuter$Inner.class)
		
		// 2. static inner
		StaticOuter sout = new StaticOuter();
		
		System.out.println(StaticOuter.Inner.sname); // Samsung
		StaticOuter.Inner.run();
		StaticOuter.Inner sinner = new StaticOuter.Inner(); // Static class의 객체 생성
		sinner.sleep(); // Inner sleep()...
		
		// 3. local inner -> 변경 불가능, 
		
		String model = "OOOO";
//		model = "BMW"; // error
		class LocalInner {
			String name = "yang";
			
			public LocalInner() { // 생성자 필요 X
				System.out.println(model); // 가능
			}
			public void stop() {
				System.out.println("LocalInner stop()...");
			}
		}
		
		LocalInner loc_inner = new LocalInner();
		loc_inner.stop();
		
		// 4. anonymous inner(어찌보면 local inner)
		TestMain tm = new TestMain() {
			public void aaa() {
				System.out.println("aaa()...");
			} 
		};
//		tm.aaa(); // error
		tm.play(); // ok
		
//		TestAbsClass tac = new TestAbsClass(); // error
		TestAbsClass tac = new TestAbsClass() {
			@Override
			public void start() {
				System.out.println("start()...");
			}
		}; // ok
		tac.start();
		
		TestInterface ti = new TestInterface() {
			@Override
			public int insert(String name) {
				System.out.println(name);
				System.out.println(model); // 가능
				return 0;
			}
		};
		ti.insert("kim"); // ok
	} 
	
	public void play() {
		System.out.println("play()...");
	}
}

Thread

• try-catch는 java의 예외 처리에 대한 예약어

// RunnableImpl.java
package test.com;

public class RunnableImpl implements Runnable {

	@Override
	public void run() {
		for (int i = 10000; i < 10010; i++) {
			System.out.println(i);
			
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

}

// Threadex.java
package test.com;

public class Threadex extends Thread {
	@Override
	public void run() {
		for (int i = 100; i < 110; i++) {
			System.out.println(i);
			
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

// ThreadMain.java
package test.com;

public class ThreadMain {

	public static void main(String[] args) throws InterruptedException {
		// thread: 프로세스의 병렬 처리
		System.out.println("start main...");
		
		for (int i = 0; i < 10; i++) {
			System.out.println(i);
			Thread.sleep(500);
		}
		
		// 1. Thread class를 상속받아서 병렬처리
		new Thread() {
			@Override
			public void run() {
				try {
					testFor(); // 여기서 에러나도, 비정상종료 아니고 정상적으로 빠져나갈 수 있도록 해준다.
				} catch (InterruptedException e) { 
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}.start(); // run이 병렬처리되듯이 실행시켜주는 내장함수가 start()이다.
		
		// 2. Thread 클래스를 상속받는 class를 만든다.
		Threadex tex = new Threadex();
		
//		tex.run(); // 그냥 순차 진행
		tex.start(); // 실제 병렬처리
		
		Thread t = new Thread(new Runnable() { // 사실 얘도 RunnableImpl이랑 같은 거다.
			@Override
			public void run() { // 원래 추상으로 들어있다.
				for (int i = 30; i < 40; i++) {
					System.out.println(i);
					
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		}); // interface가 runnable target으로 온다.
		t.start();
		
		// RunnableImpl
		RunnableImpl rimpl = new RunnableImpl();
		rimpl.run();
//		t = new Thread(new RunnableImpl()); // 이것도 가능
//		t.start();
		
		// DB 커넥팅 또는 요청과 응답 사이에 텀(1~3초 이상)이 존재할 때,
		// Thread로 구현하면 로딩창 같은거 구현 가능
		// 네트워크를 통한 원격지로부터 정보 요청, 응답할 때 병렬처리
		
		System.out.println("end main...");
	}
	
	public static void testFor() throws InterruptedException {
		for (int i = 10; i < 20; i++) {
			System.out.println(i);
			Thread.sleep(500);
		}
	}
}

Lambda

// Thread lambda
package test.com;

public class Test01Lambda_Thread {
	public static void main(String[] args) {
		// anonymous inner >> Lambda식 표현: () -> {}
		
		System.out.println("start main...");
		Thread t = new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("run()...");
				
				for (int i = 10; i < 20; i++) {
					System.out.println(i);
					try {
						Thread.sleep(300);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		});
		t.start();
		
		t = new Thread(() -> { // js의 함수표현식과 유사
			System.out.println("lambda run()...");
			
			for (int i = 20; i < 30; i++) {
				System.out.println(i);
				try {
					Thread.sleep(300);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		});
		t.start();
		
		Runnable runnable = () -> { // 재사용 가능
			System.out.println("lambda run()...");
			
			for (int i = 30; i < 40; i++) {
				System.out.println(i);
				try {
					Thread.sleep(300);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		};
		t = new Thread(runnable);
		t.start();
		
		System.out.println("end main...");
	}
}

// Collections lambda
package test.com;

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

public class Test02Lambda_Collections {
	public static void main(String[] args) {
		// Lambda식을 Collection에서 사용

		List<Integer> sus = new ArrayList<Integer>();
		sus.add(1000);
		sus.add(3000);
		sus.add(2000);
		System.out.println(sus); // [1000, 3000, 2000]
		
		List<Integer> sus2 = Arrays.asList(3000, 4000, 5000);
		System.out.println(sus2);
		
		System.out.println("=============== after sort");
		Collections.sort(sus);
		System.out.println(sus); // [1000, 2000, 3000]
		
		Collections.sort(sus, Collections.reverseOrder()); // 역정렬
		System.out.println(sus); // [3000, 2000, 1000]
		
		System.out.println("===============");
		
		sus2.sort(new Comparator<Integer>() {
			@Override
			public int compare(Integer o1, Integer o2) {
				// o1 - o2 : 순정렬
				// o2 - o1 : 역정렬
				return o1 - o2;
			}
		});
		System.out.println(sus2);
        
        System.out.println("===============");
	
		List<Integer> sus3 = Arrays.asList(30000, 50000, 40000);
		System.out.println(sus3);
		sus3.sort((o1, o2) -> {
			return o1 - o2;
		});
		System.out.println(sus3);
        
        System.out.println("===============");
		
		List<String> names = Arrays.asList("yang", "kim", "lee");
		// 해시코드를 비교해야 한다.
		
		String name = "yang";
		String name2 = "kim";
		System.out.println(name.equals(name2)); // Object 비교
		System.out.println(name.compareTo(name2)); // hashCode 비교. name - name2의 정수 반환, 14
		
		names.sort(new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				return o1.compareTo(o2);
			}
		});
		
		names.sort((s1, s2) -> {
			return s1.compareTo(s2); // 양수는 정방향, 음수는 역방향
		});
		
		System.out.println(names);
	}
}