Queue
import java.util.Queue;
import java.util.LinkedList;
public class QueueDemo {
public static void main(String[] args) {
String [] array = {"설운도", "이미자", "조성모", "나훈아"};
Queue<String> queue = new LinkedList<String>();
for(int i = 0 ; i < array.length ; i++)
queue.offer(array[i]);
System.out.println(queue.peek());
System.out.println(queue.poll());
System.out.println(queue.poll());
System.out.println(queue.poll());
System.out.println(queue.poll());
System.out.println(queue.poll());
}
}
출력:
설운도
설운도
이미자
조성모
나훈아
null
-------
bulk로 뽑으려면
System.out.println 부분을 빼고
Iterator<String> iters = queue.iterator();
while(iters.hasNext()){
System.out.println(iters.next());
}
을 추가 해주면 한번에 출력이 가능하다
설운도
이미자
조성모
나훈아
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
Generics
public class Demo<T> { //Generic Demo라고 선언
private T value;
public Demo(T value){
this.value = value;
}
public void setValue(T value){
this.value = value;
}
public T getValue(){
return this.value;
}
}
public class GenericDemo {
public static void main(String[] args) {
Demo<Integer> d = new Demo<Integer>(5); //Integer를 사용하는 Demo
d.setValue(10);
int num = d.getValue();
Demo<String> d1 = new Demo<String>("Hello"); //String을 사용하는 Demo
String value1 = d1.getValue();
Demo<Double> d2 = new Demo<Double>(89.5); //Double을 사용하는 Demo
double value2 = d2.getValue();
System.out.println(value1);
}
}
출력: Hello
generic은 인트형 더블형 스트링형등 모든 형을 처리할 수 있지만 label을 해줘야한다.
위에서 d1.setValue(89.5); 이렇게 써준다면 오류가 발생한다. String형에 89.5 를 써주어서.
----------------
import java.util.Stack;
public class GenericDemo1 {
public static void main(String[] args) {
Stack<String> mystack = new Stack<String>(); //mystack에는 스트링형만 넣을 수 있다.
mystack.push("Hello");
change(mystack);
}
static void change(Stack<String> s){
String msg = s.pop();
}
}
class Car{
String maker = "Kia";
}
//자바에서는 안전하게 하기위해서 형을 명확하게 써준다.
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
import java.util.Vector;
public class GenericDemo2 {
public static void main(String[] args) {
/*
Stack<String> stack = new Stack<String>();
stack.push("World");
Stack<Object> stack1 = stack; */ //에러발생. generic은 형번환이 되지 않는다.
//Queue<String> queue = new LinkedList<String>(); //<>사이에 있는 것이 형변환이 안되는 것이지 Queue와 LinkedList의 형변환은 된다.
Vector<Double> vecotr = new Stack<Double>(); //Generic 타입이 형변환이 안되는 것이지 객체가 형변환이 안되는 것은 아니다.
}
}
---------------------------------
import java.util.Stack;
import java.util.Vector;
public class GenericDemo3 {
public static void main(String[] args) {
Stack<String> stack = new Stack<String>();
stack.push("설운도"); stack.push("이미자");
print(stack);
}
static void print(Vector<String> v){ //String을 보냈는데 Vector가 받을 수 있다. 그러나 String이 바뀌면 안된다.
for(int i = 0 ; i < v.size(); i++) System.out.println(v.get(i));
}
}
출력:
설운도
이미자
----위 코드를 String형이 아닌 그냥 Stack으로 받으면
static void print(Stack s) { //raw type - 형지정을 하지 않음.
System.out.println(s.pop());
System.out.println(s.pop());
}
안전하지 않다는 warning이 뜨지만 실행은 가능하다.
출력:
이미자
설운도
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
import java.util.Stack;
import java.util.Vector;
public class GenericDemo3 {
public static void main(String[] args) {
Stack<Car> stack = new Stack<Car>();
stack.push(new Car());
print(stack);
}
static void print(Stack s) {
System.out.println(s.pop());
}
}
class Car{
String maker = "KIA";
}
출력:
Car@1c35ec
이렇게 나오는데
-----이를 원하는 값을 얻기 위해 print를 아래와 같이 바꾸면 KIA가 출력된다.
static void print(Stack s) {
Car car = (Car)s.pop();
System.out.println(car.maker);
}
그러나 이는 좋은 방법이 아니다.
------------ print를 아래와같이 ?를 사용하는 방법.
static void print(Stack<?> s){ //?는 warning 안 뜨게 하는 역할이지 큰 역할은 없다.
Car car = (Car)s.pop();
System.out.println(car.maker);
}
형변환을 해야하는 것은 똑같지만 warning이 뜨지않는다.
?자체는 의미가없지만 extends나 super를 써서 누구 이상이나 누구 이하로 제한 해야한다.
처음에썼던 Demo와 GenericDemo을 보면
public class Demo<T extends Number> ->Demo를 이렇게 쓰게되면 GenericDemo에서는 Stirng은 사용 불가하게 된다.
Number의 자식들만 사용할 수 있게되어서 int, double등 숫자형만 사용가능하게된다.
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
generic method는 리턴타입안에 또 무언가가 있는..
api에서 보면 sort를 찾아보면 public static <T> void sort(T[] a. Comparator< ? super T> c) 라고 쓰여진 것을 볼 수 잇다.
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
public class GenericMethodDemo {
public static void main(String[] args) {
//Car [] array = new Car[3]; //Comparable의 자식이 아니라서 못넘어감.에러발생.
//sort(array);
String [] array = new String[]{"Hello","World","Java","Oracle"}; //Comparable의 자식이라서 넘어감
sort(array);
for(String str : array) System.out.println(str + "\t");
System.out.println();
Product [] array1 = new Product[4];
array1[0] = new Product("Notebook", 10_000_000);
array1[1] = new Product("Ballpen", 1_000);
array1[2] = new Product("Computer", 12_000_000);
array1[3] = new Product("Mouse", 50_000);
sort(array1);
for(Product p : array1) System.out.print(p + "\t");
}
static <T extends Comparable<T>> void sort(T [] array){ //comparable 자식들은 맘대로 사용할수 있는 만능 sort
for(int i = 0 ; i < array.length - 1 ; i++){
for(int j = 0 ; j < array.length - 1 - i; j++){
if(array[j].compareTo(array[j+1]) > 0){
T temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
}
}
class Product implements Comparable<Product>{
private String name;
private int price;
public Product(String name, int price){
this.name = name; this.price = price;
}
@Override
public String toString(){
return String.format("<%s, %,d>", this.name, this.price);
}
@Override
public int compareTo(Product p){
return this.price - p.price;
}
}
출력:
Hello
Java
Oracle
World
<Ballpen, 1,000> <Mouse, 50,000> <Notebook, 10,000,000> <Computer, 12,000,000>
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
===============================================================
Collection
import java.util.HashSet;
public class CollectionDemo {
public static void main(String[] args) {
//Object [] array = {new Car(), new Product("mouse", 50_000), 'A', 89.5, false, "Hello", 10}; //다양한 타입들을 한 배열에 넣을 수 있게 Object형 배열을 만들어줌.
String [] array = {"설운도","나훈아", "조용필", "이미자", "설운도"};
HashSet<String> set = new HashSet<String>();
for(int i = 0 ; i < array.length ; i++) set.add(array[i]);
System.out.println(set.size());
}
}
출력 : 4
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class CollectionDemo {
public static void main(String[] args) {
String [] array = {"설운도","나훈아", "조용필", "이미자", "설운도"};
HashSet<String> hset = new HashSet<String>();
for(int i = 0 ; i < array.length ; i++) hset.add(array[i]);
System.out.println("<HashSet>"); print(hset);
TreeSet<String> tset = new TreeSet<String>();
for(int i = 0 ; i< array.length ; i++) tset.add(array[i]);
System.out.println("<TreeSet>"); print(tset);
}
static void print(Set<String> set){
Iterator<String> iters = set.iterator();
while(iters.hasNext()) System.out.print(iters.next() + "\t");
System.out.println();
}
}
출력:
<HashSet>
나훈아 이미자 조용필 설운도
<TreeSet>
나훈아 설운도 이미자 조용필
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
ArrayList
import java.util.ArrayList;
public class ArrayListDemo {
public static void main(String[] args) {
String [] array = {"설운도","나훈아", "조용필", "이미자", "설운도"};
ArrayList<String> list = new ArrayList<String>();
System.out.println("size = " + list.size());
for(int i = 0 ; i < array.length ; i++) list.add(array[i]);
for(int i = 0 ; i < array.length ; i++){
System.out.printf("%d --> %s\n", i, list.get(i));
}
//Iterator<String> iters = list.iterator();
//System.out.println("capacity = " + list.g);
}
}
출력:
size = 0
0 --> 설운도
1 --> 나훈아
2 --> 조용필
3 --> 이미자
4 --> 설운도
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
Vector
예전 성적관리프로그램을 Vector로 바꾸면 (Vector는 받는 개수가 몇개인지 모른다)
Student.java
public class Student implements Comparable<Student>{
private String hakbun, name;
private int kor, eng, mat, edp, tot, ranking;
private double avg;
private char grade;
public Student(String hakbun, String name, int kor, int eng, int mat, int edp) {
this.hakbun = hakbun;
this.name = name;
this.kor = kor;
this.eng = eng;
this.mat = mat;
this.edp = edp;
this.ranking = 1;
}
@Override
public int compareTo(Student s){
return this.getTot() - s.getTot();
}
@Override
public String toString(){
return String.format("%-10s%7s%5d%5d%5d%5d%5d%10.2f%5c%5d\n", this.hakbun, this.name, this.kor, this.eng, this.mat, this.edp, this. tot, this.avg, this.grade, this.ranking);
}
public int getTot() {
return tot;
}
public void setTot(int tot) {
this.tot = tot;
}
public int getRanking() {
return ranking;
}
public void setRanking(int ranking) {
this.ranking = ranking;
}
public double getAvg() {
return avg;
}
public void setAvg(double avg) {
this.avg = avg;
}
public char getGrade() {
return grade;
}
public void setGrade(char grade) {
this.grade = grade;
}
public int getKor() {
return kor;
}
public int getEng() {
return eng;
}
public int getMat() {
return mat;
}
public int getEdp() {
return edp;
}
}
Input.java
import java.io.File;
import java.io.FileNotFoundException;
import java.util.NoSuchElementException;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.Vector;
import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
public class Input {
private Scanner scan;
private Vector<Student> vector;
public Input(Vector<Student> vector){
this.vector = vector;
JFileChooser jc = new JFileChooser();
File file = null;
try{
if(jc.showOpenDialog(null) == JFileChooser.APPROVE_OPTION){ //확인버튼을 눌렀다면
file = jc.getSelectedFile();
this.scan = new Scanner(file);
}
}catch(FileNotFoundException ex){
JOptionPane.showMessageDialog(null, "File Not Found");
System.exit(-1);
}
}
public void input(){
StringTokenizer st = null;
String line = null;
try{
while((line = this.scan.nextLine()) !=null){
st = new StringTokenizer(line);
String [] array = new String[st.countTokens()];
int i = 0;
while(i < array.length){
array[i++] = st.nextToken();
}
Student student = new Student(array[0].trim(), array[1].trim(), Integer.parseInt(array[2].trim()),Integer.parseInt(array[3].trim()),Integer.parseInt(array[4].trim()), Integer.parseInt(array[5].trim()) );
this.vector.addElement(student); //학생 하나 만들어서 추가
}
}catch(NoSuchElementException ex){}
}
}
Calc.java
import java.util.Vector;
public class Calc {
private Vector<Student> vector;
public Calc(Vector<Student> vector) {
this.vector = vector;
}
public void calc(){
for(int i = 0 ; i < this.vector.size() ; i++){
Student s = this.vector.get(i);
s.setTot(s.getKor() + s.getEng() + s.getMat() + s.getEdp());
s.setAvg(s.getTot() /4 );
s.setGrade(this.getGrade(s.getAvg()));
}
}
private char getGrade(double avg){
if(avg<=100 && avg>=90 ) return 'A';
else if(avg<90 && avg>=80) return 'B';
else if(avg<80 && avg>=70) return 'C';
else if(avg<70 && avg>=60) return 'D';
else return 'F';
}
}
Sort.java
import java.util.Vector;
public class Sort {
private Vector<Student> vector;
public Sort(Vector<Student> vector) {
this.vector = vector;
}
public void sort(){
for(int i = 0 ; i < this.vector.size() - 1 ; i++){
for(int j = i+1; j < this.vector.size(); j++){
if(this.vector.get(i).compareTo(this.vector.get(j))>0){
this.vector.get(j).setRanking(this.vector.get(j).getRanking() +1);
}else if (this.vector.get(i).compareTo(this.vector.get(j))<0){
this.vector.get(i).setRanking(this.vector.get(i).getRanking() +1);
}
}
}
}
}
Output.java
import java.util.Vector;
public class Output {
private Vector<Student> vector;
public Output(Vector<Student> vector) {
this.vector = vector;
}
public void output(){
printLabel();
for(int i = 0 ; i < this.vector.size(); i++){
System.out.print(this.vector.elementAt(i));
}
}
private void printLabel(){
System.out.println(" <<성적관리프로그램>>");
}
}
Main.java
import java.util.Vector;
public class Main {
public static void main(String[] args) {
Vector<Student> vector = new Vector<Student>(1,1); //1명들어올떄마다 크기를 1개씩만 증가.
Input input = new Input(vector);
input.input();
Calc calc = new Calc(vector);
calc.calc();
Sort sort = new Sort(vector);
sort.sort();
Output output = new Output(vector);
output.output();
}
}
출력:
<<성적관리프로그램>>
1101 한송이 78 87 83 78 326 81.00 B 6
1102 정다워 88 83 57 98 326 81.00 B 6
1103 그리운 76 56 87 78 297 74.00 C 10
1104 고아라 83 57 88 73 301 75.00 C 9
1105 사랑해 87 87 53 55 282 70.00 C 11
1106 튼튼이 98 97 93 88 376 94.00 A 1
1107 한아름 68 67 83 89 307 76.00 C 8
1108 더크게 98 67 93 78 336 84.00 B 4
1109 더높이 88 99 53 88 328 82.00 B 5
1110 아리랑 68 79 63 66 276 69.00 D 12
1111 한산섬 98 89 73 78 338 84.00 B 3
1112 하나로 89 97 78 88 352 88.00 B 2
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
Hashtable
import java.util.Date;
import java.util.Hashtable;
import java.util.StringTokenizer;
public class HashtableDemo {
public static void main(String[] args) {
Date now = new Date();
//System.out.println(now);
StringTokenizer st = new StringTokenizer(now.toString());
//Mon Mar 24 16:34:53 KST 2014
String [] array = new String[st.countTokens()];
int i = 0 ;
while(i < array.length) array[i++] = st.nextToken();
System.out.print("오늘은 " + array[5] + "년 " + getMonth(array[1]) + "월 " + array[2] + "일입니다.");
}//오늘은 2014년 Mar월 24일입니다. 이렇게 나오는 것을 해결하기 위해 아래를 추가.
static int getMonth(String month){ //해쉬 테이블은 DB역할. 키로 값을 뽑아내는.
Hashtable<String, Integer> ht = new Hashtable<String, Integer>();
ht.put("Jan", new Integer(1)); ht.put("Feb", new Integer(2));
ht.put("Mar", new Integer(3)); ht.put("Apr", new Integer(4));
ht.put("May", new Integer(5)); ht.put("Jun", new Integer(6));
ht.put("July", new Integer(7)); ht.put("Aug", new Integer(8));
ht.put("Sep", new Integer(9)); ht.put("Oct", new Integer(10));
ht.put("Nov", new Integer(11)); ht.put("Dec", new Integer(12));
return ht.get(month);
}
}
출력:
오늘은 2014년 3월 24일입니다.
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
Porperties
//Properties는 hashtable의 자식이다. 키와 값을 모두 가지고 있다.
import java.util.Enumeration;
import java.util.Properties;
public class PropertiesDemo {
public static void main(String[] args) {
Properties props = System.getProperties();
//키
Enumeration<Object> keys = props.keys();
while(keys.hasMoreElements()){
String key = (String)keys.nextElement();
System.out.printf("%s --> %s\n", key, System.getProperty(key));
}
//값
/*Enumeration<Object> enums = props.elements();
while(enums.hasMoreElements()){
Object obj = enums.nextElement();
System.out.println(obj);
}*/
}
}
출력은 영어로 시스템에 대한 정보(키or값)이 나온다.
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
dbinfo.properties 텍스트파일
DBDRIVER=oracle.jdbc.driver.JdbcDriver
DBURL=jdbc:oracle:thin:@127.0.0.1:1521:orcl
DBUSER=scott
DBPWD=tiger
PropertiesDemo1.java
import java.io.FileReader;
import java.util.Properties;
public class PropertiesDemo1 {
public static void main(String[] args) throws Exception{
Properties props = new Properties();
FileReader fr = new FileReader("dbinfo.properties");
props.load(fr);
System.out.println("Driver Name : " + props.getProperty("DBDRIVER"));
System.out.println("Driver URL : " + props.getProperty("DBURL"));
System.out.println("User : " + props.getProperty("DBUSER"));
System.out.println("Password : " + props.getProperty("DBPWD"));
}
}
출력:
Driver Name : oracle.jdbc.driver.JdbcDriver
Driver URL : jdbc:oracle:thin:@127.0.0.1:1521:orcl
User : scott
Password : tiger
Chapter 7. Methods.pdf
eclipse.desktop