Bohemian life

package com.basic;//Thread Priority이용하여 우선순위 높이기

public class ThreadEx9 {
	public static void main(String[] args){

		ThreadEx9_1 th1 = new ThreadEx9_1();
		ThreadEx9_2 th2 = new ThreadEx9_2();

		//우선순위를 기본우선순위(5) - > 7
		th2.setPriority(7);

		System.out.println("Priority of th1(-) : "+th1.getPriority());
		System.out.println("Priority of th2(|) : "+th2.getPriority());

		th1.start();
		th2.start();
	}
}

class ThreadEx9_1 extends Thread{
	public void run(){
		for(int i=0;i<300;i++)
			System.out.print("-");
	}
}

class ThreadEx9_2 extends Thread{
	public void run(){
		for(int i=0;i<300;i++)
			System.out.print("|");
	}
}

package com.basic;//Thread 클래스 사용하여 멀티스레드 사용
//멀티 스레드를 지원하는 클래스를 만드려면 java.lang.Thread 클래스의 상속받아야함
class ThreadExam extends Thread{
	ThreadExam(String name){//생성자에 스레드 이름이 전달인자로 넘어옴
		//ThreadExam의 상위 클래스인 Thread의 생성자 (super)호출
		super(name);//전달인자로 준 값이 스레드의 이름이 됨
	}
	public void run(){
		for(int num=1;num<=5;num++){
			try{
				Thread.sleep(1000);
			}catch(InterruptedException e){
				e.printStackTrace();
			}
			//스레드의 이름을 얻어 출력함
			System.out.println(getName()+" : "+num);
		}
	}
}
public class ThreadTest01 {
	public static void main(String[] args) {
		
		ThreadExam t1 = new ThreadExam("첫 번째 스레드");
		ThreadExam t2 = new ThreadExam("두 번째 스레드");
		ThreadExam t3 = new ThreadExam("세 번째 스레드");
		
		t1.start();
		t2.start();
		t3.start();
	}

}

package com.basic;//thread Runnable

public class RunnableEx implements Runnable{
	public void run(){//구현
		for(int i=0;i<10;i++){
			try{
				Thread.sleep(1000);//1초동안 멎게 만듬 static 한 메소드 (밀리 세컨드)(Thread.sleep)
			}catch(InterruptedException e){
				e.printStackTrace();
			}
			System.out.printf("스레드 이름 : %s, ",Thread.currentThread().getName());

			System.out.printf("temp value : %d\n",i);
		}
	}
	public static void main(String[] args) {
		RunnableEx r = new RunnableEx();
		Thread td = new Thread(r,"두번째");//객체 등록
		td.start();
	}
}

package com.basic;//스레드



public class ThreadEx extends Thread{
	public ThreadEx(String threadName){
		super(threadName);
	}
	//run 메소드 재정의
	public void run(){
		for(int i=0;i<10;i++){
			try{
				sleep(1000);//1초동안 멎게 만듬 static 한 메소드 (밀리 세컨드)(Thread.sleep)
			}catch(InterruptedException e){
				e.printStackTrace();
			}
			System.out.printf("스레드 이름 : %s, ",currentThread().getName());
			
			System.out.printf("temp value : %d\n",i);
		}
	}
	public static void main(String[] args) {
		ThreadEx td = new ThreadEx("첫번째");
		td.start();//run()메소드 실행
	}
}

package com.map;//해쉬 테이블 다루기

import java.util.Hashtable;
import java.util.Enumeration;

public class HashTableTest {
	public static void main(String[] args) {
		//Hastable : 정렬이 보장되지 않음 key,value null을 인정하지 않음
		
		Hashtable<string,string> ht = new Hashtable<string,string>();
		//해쉬 테이블에 키 /데이터 입력한다
		ht.put("사과", "Apple");
		ht.put("딸기", "Strawberry");
		ht.put("포도", "Grapes");
		/*ht.put(null, "널");
		ht.put("배", null);*/
		ht.put("사과", "Banana");
		
		System.out.println(ht);
		
		
		//해쉬 테이블의 값을 키를 이용하여 얻는다
		String val = (String)ht.get("포도");
		if(val != null)
			System.out.println("포도 : "+val);
		
		Enumeration<string> en = ht.keys();
		while(en.hasMoreElements()){
			String k = en.nextElement();
			String v = ht.get(k);
			System.out.println(k+" : "+v);
		}
	}

}

package com.map;

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

public class MapEx1 {

	public static void main(String[] args) {
		String[] msg = {"Berlin","Paris","Seoul","New York","London"};

		HashMap<Integer, String> map = new HashMap<Integer, String>();

		for (int i=0;i<msg.length;i++)
			map.put(i, msg[i]);//맵에저장

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

		//Set<Integer> s = map.keySet();
		//Iterator<Integer> keys2 =s.iterator();
		//위의 두줄을  아래와같이 한줄로 바꿀수있다  
		Iterator<Integer> keys2 = map.keySet().iterator();

		while(keys2.hasNext()){
			Integer key = keys2.next();
			System.out.print(key+", ");
			System.out.println(map.get(key));
		}
	}
}

package com.map;//HashMap특성

import java.util.HashMap;

public class HashMapExample1 {
	public static void main(String[] args) {
		//HashMap : 정렬을 보장하지 않는다 , Key와 Value의 null 값 인정함
		//key와 value를 쌍으로 저장한다 , key의 중복이 허용되지 않는다
		HashMap<string, integer=""> map = new HashMap<string, integer="">();
		map.put("해리", new Integer(95));
		map.put("헤르미온느",new Integer(100));
		map.put("론", new Integer(85));
		map.put("드레이코",new Integer(93));
		map.put("네빌",new Integer(70));
		map.put(null, new Integer(40));
		map.put("신봉선", null);
		//중복이 허용이 되지 않아 덮어씌워짐(key값)
		map.put("헤르미온느", new Integer(0));
		
		
		
		System.out.println(map);
		
		Integer num = map.get("헤르미온느");
		System.out.println("헤르미온느의 성적은? : "+num);
		
	}

}

package com.list;//로또만들기 ArrayList , Contains메소드 이용해서 

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

public class ArrayListLotto {
	public ArrayListLotto(){
		make();
	}

	public void make(){
		ArrayList<integer> vc = new ArrayList<integer>();

		Random ra = new Random();
		Integer ir = null;
		while(vc.size()<6){
			//난수 발생
			ir = new Integer(ra.nextInt(45)+1);
			//중복값 체크
			if(!vc.contains(ir))
				vc.add(ir);
		}
		Collections.sort(vc);//오름차순
		for(int i : vc)
			System.out.print(i+"\t");
	}
	public static void main(String[] args) {
		new ArrayListLotto();
	}
}

package com.set;//로또 만들기(HashSet)

import java.util.Set;
import java.util.List;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Collections;

public class HashSetLotto {
	public static void main(String[] args) {
		Set<integer> set = new HashSet<integer>();

		while(set.size()<6){
			int num = (int)(Math.random()*45)+1;
			System.out.println(num);
			set.add(new Integer(num));
		}
		
		//데이터를 정렬하기 위해 Set -> List
		List<integer> list = new LinkedList<integer>(set);
		
		//데이터 정렬
		Collections.sort(list);
		
		System.out.println(list);
	}
}

package com.set; //Set인터페이스 (데이터 중복허용X) (정렬 안됨) (바구니 구조)
import java.util.Set;
import java.util.HashSet;

public class Collections01 {
	public static void main(String[] args) {
		
		Set set = new HashSet();
		System.out.println("요소의 개수  = "+set.size());
		set.add("하나");
		set.add(2);
		set.add(2);
		set.add(3.42);
		set.add("넷");
		set.add("five");
		set.add(6);
		
		System.out.println("요소의 개수  = "+set.size());
		System.out.println(set);

	}
}

package com.list;//LinkedList 사용(속도가 좀 느림)

import java.util.LinkedList;

public class LinkedListTest {
	public static void main(String[] args) {
		LinkedList<string> myQue = new LinkedList<string>();

		myQue.offer("1-자바");
		myQue.offer("2-C++");
		myQue.offer("3-API");
		myQue.offer("4-MFC");
		while(myQue.peek() != null)
			System.out.println(myQue.poll());
	}

}

package com.list;//Stack의 구조

import java.util.Stack;

public class StackTest01 {
	public static void main(String[] args) {

		//Stack은 자료구조가 후입선출(Last-In-First-Out)
		Stack<string> myStack = new Stack<string>();

		myStack.push("1-자바");
		myStack.push("2-C++");
		myStack.push("3-API");
		myStack.push("4-MFC");

		System.out.println(myStack);

		while(!myStack.isEmpty())//isEmpty() 비어있는지 확인
			System.out.println(myStack.pop());//빼고 나서 제거
		System.out.println(myStack);
	}
}

package com.list;//Enumeration 인터페이스 사용법

import java.util.Enumeration;
import java.util.Vector;

public class EnumerationTest01 {
	public static void main(String[] args){
		Vector<integer> vec = new Vector();
		for(int i=1;i<5;i++)
			vec.add(new Integer(i*10));
		Enumeration<integer> enu = vec.elements();
		while(enu.hasMoreElements())
			System.out.println(enu.nextElement());
	}
}

package com.list;//ArrayList클래스 사용하여 뒤에서부터 제거하기
//뒤에서 제거하여 객체 재저장??
//여러개의 데이터를 제거할경우에는 뒤에서 부터 제거해야됨
import java.util.ArrayList;

public class ArrayListEx1 {
	public static void main (String[] args){
		ArrayList<Integer> list1 = new ArrayList<Integer>(10);

		list1.add(new Integer(5));
		list1.add(new Integer(4));
		list1.add(new Integer(2));
		list1.add(new Integer(0));
		list1.add(new Integer(1));
		list1.add(new Integer(3));

		System.out.println(list1);
		System.out.println("=-=-=-=-=-=-=-=-=-=");
		
															//1~3까지 객체 반환(1,4)
		ArrayList<Integer> list2 = new ArrayList<Integer>(list1.subList(1,4));
		System.out.println(list2);
		
		System.out.println("=-=-=-=-=-=-=-=-=-=");
		
		//add(데이터) : 가장 뒤 인덱스에 추가
		//add(인덱스.데이터) : 해당 인덱스에 데이터 추가되며 원래 데이터가 있었다면 다음 인덱스로 밀어내기
		list2.add(2,9);
		System.out.println(list2);
		
		System.out.println("=-=-=-=-=-=-=-=-=-=");
		//add와 set의 차이점 set은 바꿔치기 add는 밀어내기
		list2.set(1,5); //해당 인덱스의 데이터 교체
		System.out.println(list2);

		//데이터 지우기
		for(int i= list2.size()-1;i>=0;i--)
			if(list1.contains(list2.get(i)))
				list2.remove(i);
		
		System.out.println("=-=-=-=-=-=-=-=-=-=");
		System.out.println(list2);
	}
}