[28-D16] Collections Framework - Hashtable, Iterator, Generics

[01] Collections Framework - Hashtable 클래스

    - Key, 값으로 되어 있는 구조 입니다.

    - 중복된 키 값을 허용하지 않습니다. 만약 사용하게되면 기존의 값이 삭제됩니다.

    - 검색 결과가 없으면 null을 리턴합니다.

    - 다수의 스레드가 접속하더라도 동기화 처리가 되어 있어서 값을 안정적으로
      변경 할 수 있습니다.


java.lang.Object
  |
  +--java.util.Dictionary
        |
        +--java.util.Hashtable

모든 구현 인터페이스:
Cloneable , Map , Serializable

직계의 기존의 서브 클래스:
Properties , UIDefaults


>>>>> TestHashTable.java

import java.util.Hashtable;
import java.util.Map;


public class TestHashTable {

    public static void main(String[] args) {
        // Hashtable ht = new Hashtable();
        Map ht = new Hashtable();
        
        // 키, 값의 구조
        ht.put("AREA01", "대한민국");
        ht.put("AREA02", "러시아");
        ht.put("AREA03", new Integer(1000));
        ht.put("AREA04", "일본");
        
        String area = (String)ht.get("AREA01");
        // String area = (String)ht.get("AREA05");
        
        if ( area != null){
            System.out.println(area);
        }else{
            System.out.println("검색 지역이 없습니다.");
        }
        
        Integer integer = (Integer)ht.get("AREA03");
        System.out.println(integer);
    }
}







[02] Iterator
     - Collection Framework안에 저장된 객체를 하나씩 추출하는 기능을 합니다.

1. List - Vector에서의 사용

>>>>> IteratorVector.java

import java.util.Vector;
import java.util.Iterator;

public class IteratorVector {
    public static void main(String args[]){
        //Vector에 요소 저장
        Vector v = new Vector();
        
        v.addElement("관악산");
        v.addElement("북한산");
        v.addElement("도봉산");        
        v.addElement("수락산");
        v.addElement("불암산");
        v.addElement("사패산");

        //vector에 저장된 sungjuk객체 추출하여 출력
        Iterator iter = v.iterator();
        
        while(iter.hasNext() == true){
            // 처음부터 마지막까지 요소 추출
            String s = (String)iter.next();
            System.out.println(s);
        }
        
    }
}





2. Map - HashTable에서의 사용

>>>>> IteratorHashTable.java

import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;


public class IteratorHashTable {

    public static void main(String[] args) {
        // Hashtable ht = new Hashtable();
        Map ht = new Hashtable();
        
        // 코드, 값의 구조
        ht.put("AREA01", "대한민국");
        ht.put("AREA02", "러시아");
        ht.put("AREA03", "중국");
        ht.put("AREA04", "일본");
        
        //Iterator iter = ht.keySet().iterator();
        
        // 키들로만 구성된 집합을 추출
        Set keySet = ht.keySet();
        Iterator iter = keySet.iterator();
        
        // 다음키가 있는지 검사합니다.
        while(iter.hasNext() == true){
            
            // 키를 순차적으로 읽어 옵니다.
            String key = (String)iter.next();
            
            // 키에 해당하는 값을 추출합니다.
            String str = (String)ht.get(key);
            System.out.println(key + " - " + str);
        }
    }
}







[03] Generics

   - 객체를 저장하는 기술인 Collection Framework의 단점을 개선한
     기능입니다. 기존의 1.4이하에서는 Vector등에 들어오는 객체의
     타입을 Design Time에 확인이 안되 에러를 잡기 힘들었으나 1.5부터는
     개발자가 개발시에 이클립스로부터 에러 상황을 바로 확인할 수 있습니다.

   - Class ArrayList<E>에서 'E'가 있는 곳에는 ArrayList를 선언하고
     생성할 때 사용할 실제타입이 들어갑니다.

   - E는 Element(원소)를 말하며, new ArrayList<String>() 이면 'E'는
     'String' 클래스를 가르키며, < > 안의 String은 유형 매개 변수
     (type parameter)이다.
     따라서 boolean add(Object o) 메소드는 boolean add(String o) 가 된다.

   - 'E'는 ArrayList의 인스턴스를 만들때 < > 안에 넣는 타입을 말합니다.

   - 'E'는 컬렉션에 저장하고 컬렉션에서 리턴할 원소의 타입을 가르킵니다.



※ Generics 관련 예제

1. 1.4이하의 패턴

>>>>> Old14.java

import java.util.Vector;


public class Old14 {

    public static void main(String[] args) {
        // 객체 10개를 저장할 수 있는 list 객체 변수 선언
        Vector list = new Vector(1000);
        
        list.add(new Integer(10)); //Integer 추가
        list.add(new Integer(50)); //Integer 추가
        list.add("List Test");     //String 추가, ERROR
        
        for(int i=0; i<list.size(); i++){
            //Integer 객체를 추출합니다.
            Integer iobj = (Integer)list.get(i);
            
            //객체가 가지고 있는 값에 1000을 더합니다.
            int tot = iobj.intValue() + 1000;
            System.out.println("tot= " + tot);
        }

    }

}





2. generics가 적용된 코드 (compile 시점에 에러가 체크됨 )

>>>>> Generics.java

import java.util.Vector;
import java.util.Iterator;
import java.util.List;

public class Generics {

    public static void main(String[] args) {
        //선언되는 list는 Integer 클래스 타입만 저장할 수 있습니다.
        Vector<Integer> list = new Vector<Integer>(10);
        list.add(new Integer(10));
        
        //ERROR 강제 발생 부분, Integer 타입만 가능,
        //Design Time에서 발견됩니다.
        list.add("List Test");

        Iterator i = list.iterator();
        Integer su = (Integer)i.next();
        System.out.println("su=" + su);
        
        su = (Integer)i.next();
        System.out.println("su=" + su);
    }
}





3. 메소드에서의 Generics 사용

>>>>> Generics2.java

import java.util.Vector;
import java.util.Iterator;

public class Generics2 {
    //list인수는 Integer 객체만 저장된 List 객체를
    //받을 수 있습니다.
    public void prn(Vector<Integer> list){
        Iterator i = list.iterator();
        
        for (int k=0; k < list.size(); k++){
            Integer su = (Integer)i.next();
            System.out.println("su=" + su);
            
        }
    }

    public static void main(String[] args) {
        Vector<Integer> list = new Vector<Integer>(10);
        
        list.add(new Integer(10));
        list.add(new Integer(20));
        // list.add(30); //권장 아님
        
        Generics2 g = new Generics2();
        g.prn(list);
        
        Vector<String> list2 = new Vector<String>(10);
        list2.add("월요일");
        list2.add("화요일");
        g.prn(list2); // Vector안에 Integer 객체가 저장된 것만 받음
        
    }
}

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

[27-D15] Collections Framework - Vector, ArrayList

[01] Collections Framework - Vector

   - 배열의 단점을 개선한 클래스로 객체만 저장할 수 있습니다.

   - int등 각종 기본 데이터 타입을 저장하려면 Integer Wrapper Class 등으로
     변환해서 사용해야 합니다.

   - Thread에 안정적인 컬렉션 Class입니다. synchronized가 선언되어 있어 다중접속에
     안전합니다.

   - 동적인 크기 변경이 가능합니다.


java.lang.Object
  |
  +--java.util.AbstractCollection
        |
        +--java.util.AbstractList
              |
              +--java.util.Vector

모든 구현 인터페이스:
Cloneable , Collection , List , RandomAccess , Serializable

직계의 기존의 서브 클래스:
Stack



1. Object Type

   Object는 모든 클래스의 부모클래스임으로 모든 자식클래스를 할당 할 수 있습니다.
   모든 클래스는 Object를 자동으로 상속 받습니다.

   AClass k = new AClass();

   Object obj = k;


   Object 타입으로 저장된 클래스는 내부적으로 Object 타입을 가지고 있음으로
   
   실제 객체의 타입으로 변형해야 사용 할 수 있습니다.

   AClass k = new AClass();

   Object obj = k;

   강제 형변환을 해야 사용 할 수 있습니다.
   AClass m = (AClass)obj;

   이런 복잡한 절차를 실행하는 이유는 모든 타입의 객체를 Vector에 저장하고 가져오기
   위한 것입니다.

   Object 타입은 자바에서 어떤 객체의 기능을 구현하는 것이 목적이 아니라 모든 객체 타입을
   할당 가능하게하여 메소드간 데이터 전달을 쉽게 하기위한 매개체로 사용됩니다.



>>>>> CallByReference.java

// Call BY Reference를 이용해서 합계를 구하는 프로그램을 작성하세요.
class Data{
    String name;
    int kuk;
    int eng;
    int tot;

    // 기본 생성자
    public Data() {
        super(); // 부모 클래스의 기본 생성자
    }

    // method loading
    // this: 이 메소드를 호출한 객체의 주소 값
    public Data(String name, int kuk, int eng) {
        super();
        // heap = stack
        this.name = name;
        this.kuk = kuk;
        this.eng = eng;
    }

}

// 총점을 계산합니다.
class Calc{
      // ⓐ    
//    public void calcTot(Data data){
//        data.tot = data.kuk + data.eng;
//    }

      // ⓑ
//    public void calcTot(Data2 data){
//        data.tot = data.kuk + data.eng;
//    }    
    
    // ⓒ 총점을 구합니다.
    public void calcTot(Object object){
        Data data = (Data)object;
        // Data2 data = (Data2)object;
        // Data3 data = (Data3)object;
        data.tot = data.kuk + data.eng;
        
    }
    
}

public class CallByReference {
    public static void main(String[] args) {
        Data data = new Data("개발자", 100, 100);
        
        Calc calc = new Calc();
        calc.calcTot(data);  // Call By Reference
        
        System.out.println(data.tot);

    }
}





2. Vector에 요소 추가

>>>>> VectorAddTest.java

import java.util.Vector;

public class VectorAddTest{
    public static void main(String args[]){
        Vector list = new Vector();
        
        // java.lang.String
        list.addElement("기획자");
        // java.lang.Integer
        list.addElement(new Integer(100));
        // java.lang.Float
        list.addElement(new Float(10.5f));
        // java.lang.Double, 객체로 자동 형변환, 권장 아님
        list.addElement(100.5);
        // 권장
        list.addElement(new Double(100.5));
        
        System.out.println(list.elementAt(0));
        System.out.println((Integer)list.elementAt(1));
        System.out.println((Float)list.elementAt(2));
        System.out.println((Double)list.elementAt(3));
        System.out.println((Double)list.elementAt(4));        
    }
}





3. Vector의 이용 예

>>>>> VectorTest2.java

import java.util.Vector;

class Sungjuk{
    //멤버 변수
    String name="";
    int kuk = 0;
    int eng = 0;
    int tot = 0;
    int avg = 0;
    
    //생성자
    public Sungjuk(){}
    public Sungjuk(String name,int kuk,int eng){
        this.name = name;
        this.kuk = kuk;
        this.eng = eng;
        this.tot = kuk+eng;
        this.avg = (kuk+eng) / 2;
    }
}

public class VectorTest2 {
    public static void main(String args[]){
        int i=0;
        
        //sungjuk 객체 생성
        Sungjuk s = null;
        Sungjuk s1 = new Sungjuk("기획자", 100, 80);
        Sungjuk s2 = new Sungjuk("설계자", 80, 90);
        Sungjuk s3 = new Sungjuk("개발자", 90, 80);
        Sungjuk s4 = new Sungjuk("디자이너", 80, 65);
        Sungjuk s5 = new Sungjuk("테스터", 90, 70);
        
        //Vector에 요소 저장
        Vector v = new Vector();
        
        v.addElement(s1);
        v.addElement(s2);
        v.addElement(s3);        
        v.addElement(s4);
        v.addElement(s5);

        //vector에 저장된 sungjuk객체 추출하여 출력
        int vsize = v.size();
        for(i=0; i<vsize; i++){
            s = (Sungjuk)v.get(i);
            System.out.print(s.name + "\t");
            System.out.print(s.kuk + "\t");
            System.out.print(s.eng + "\t");
            System.out.print(s.tot + "\t");
            System.out.print(s.avg + "\t\n");           
        }
    }
}







[02] Collections Framework - java.util.ArrayList

   - Vector와 같은 목적을 가지고 있으며 기능이 비슷하나 차이점은 네트워크를 통한
     객체 공유시 동기화 처리가 되어 있지 않습니다.

   - 속도는 Vector보다 빠른 속도를 가지고 있습니다. 굳이 객체를 스레드를
     이용해 공유할 경우가 아니면 ArrayList 사용을 권장합니다.


java.lang.Object
  |
  +--java.util.AbstractCollection
        |
        +--java.util.AbstractList
              |
              +--java.util.ArrayList

모든 구현 인터페이스:
Cloneable , Collection , List , RandomAccess , Serializable



>>>>> ArrayListTest.java
       
import java.util.ArrayList;

class Jumsu{
    //멤버 변수
    String name="";
    int kuk = 0;
    int eng = 0;
    int tot = 0;
    int avg = 0;
    
    //생성자
    public Jumsu(){}
    public Jumsu(String name,int kuk,int eng){
        this.name = name;
        this.kuk = kuk;
        this.eng = eng;
        this.tot = kuk+eng;
        this.avg = (kuk+eng) / 2;
    }

}

public class ArrayListTest {
    public static void main(String args[]){
        int i=0;
        
        //sungjuk 객체 생성
        Jumsu s = null;
        Jumsu s1 = new Jumsu("기획자",100, 80);
        Jumsu s2 = new Jumsu("설계자",80, 90);
        Jumsu s3 = new Jumsu("개발자",90, 80);
        
        //Vector에 요소 저장
        ArrayList v = new ArrayList();
        
        v.add(s1);
        v.add(s2);
        v.add(s3);        

        //ArrayList에 저장된 sungjuk객체 추출하여 출력
        int size = v.size();
        for(i=0; i<size; i++){
            s = (Jumsu)v.get(i);
            System.out.print(s.name + "\t");
            System.out.print(s.kuk + "\t");
            System.out.print(s.eng + "\t");
            System.out.print(s.tot + "\t");
            System.out.print(s.avg + "\t\n");           
        }
    }
}

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

[26-D15] Thread, Thread Call Back 메소드, 우선순위

[01] Thread

   - Process: thread의 집합으로 하나의 exe, com, dll 프로그램을 말합니다.
     . Process간 자원(memory)을 공유할 수 없습니다. 따라서 Process를 많이 발생 시키면
       자원이 바닥나게 됩니다.

   - Thread:
     . 반복적으로 동기화하여 실행되는 프로그램 루틴 입니다.
     . 메소드(함수)단위의 처리 모듈, process의 구성 요소입니다.
     . Thread는 많이 발생해도 자원을 공유함으로 Process에 비해 시스템에 적은 부담이 됩니다.

   - Handle: 생성된 객체, 메모리 포인터, 함수포인터등의 핸들러, thread의 구성요소입니다.

   - run()메소드안에 처리로직을 구현하거나 처리로직을 호출하는 로직이 구현되어 있어야 합니다.

   - 네크워크, 게임 관련 프로그램에서 많이 사용

   - 자바의 스레드는 많은 Reference 참조로 인해 C언어의 스레드보다 속도 및 안정성이 떨어져
     접속자가 많은 네트워크 관련 프로그램에는 사용을 하지 않습니다.
     . Hash Code 관리 부분에 많은 리소스가 소모됩니다.



1. 스레드 콜백 메소드
   - start():
     . 스레드를 스레드 스케쥴러에 등록하고 실행상태로 변경합니다.
     . 이 메소드를 실행했다고해서 바로 스레드가 실행이 되는 것은 아닙니다.
     . JVM은 스레드를 실행할 수 있는 여유가 생겼을 때 자신이 작성한 스레드 스케쥴러에
       의해서 스레드의 run()메소드를 호출합니다.

   - run(): JVM이 호출하는 콜백메소드로 여기서 콜백 메소드는 개발자가 호출을 코드상에
     지시하는 것이 아니라 JVM이 호출하는 메소드를 말하는 것으로 이 run()메소드 안에는
     스레드 상태에서 처리하려고 하는 모든 비즈니스 로직이 구현되어 있어야 합니다.
     가장 중요한 메소드입니다.

   - sleep(long milli second): 지정된 시간동안 스레드를 쉬게하고, 그 시간이 지나면 다시
     스레드가 작동됩니다.
     . 1000이 1초입니다.

   - wait(): 현재를 스레드 무한정 대기 시킵니다. notify(), notifyall()메소드를
     통해서 재 실행 가능합니다.

   - suspend():스레드의 실행을 일시적으로 중단 시킵니다.
     다시 실행은 resume()를 통해서만 가능합니다.

   - yield(): 스레드의 실행 권한을 무조건 다른 스레드에게 넘겨 줍니다.(양보)

   - stop(): 스레드 실행을 완전히 종료 합니다.




2. 단일 스레드: 일반적으로 하나의 자바 프로그램을 만들어 실행하면 단일 스레드 상태가 됩니다.
   - main()메소드가 대표적인 단일 스레드입니다.




3. 멀티 스레드는 하나의 메소드가 처리가 끝나는 것이 아니라 여러 메소드가 계속적으로
   실행상태에 있으면서 자원을 공유하고 이용하는 처리 형태를 말합니다.
   - 어느 한 메소드가 실행이 종료 되지 않고 다른 메소드와 함께 계속 실행상태에 있게 되는 것




4. 스레드의 생성 방법
   - Thread 클래스를 상속받는 방법
   - Runnable 인터페이스를 구현하는 방법
     . 자바는 다중 상속이 안됨으로 클래스가 특정 클래스를 상속할 필요가 있는 경우는
       반드시 Runnable인터페이스를 구현해야 합니다.







[02] 스레드 실습

1. 스레드를 이용하지 않은 경우

>>>>> NonThread.java

class GenClass{
    //멤버 변수, 인스턴스 변수, 필드
    private int num;
    private String name;
    
    //기본 생성자
    public GenClass(String a, int b){
        name = a;
        num = b;
    }
    
    //멤버 메소드
    public void start(){
        for(int i=0; i<num; i++){
            System.out.println(name + " : " + i);
        }
    }
}

public class NonThread{
    public static void main(String args[]) {
        //객체가 가지고 있는 값은 참조 코드
        //new: 메모리 할당, 객체 생성
        GenClass t1 = new GenClass("first", 5);
        GenClass t2 = new GenClass("second", 5);
        GenClass t3 = new GenClass("third", 5);

        t1.start();
        t2.start();
        t3.start();         
    }
}





2. Thread 클래스를 상속받은 경우
   - start() ---> JVM ---> run()
     
     . start(): 개발자: 스레드 스케쥴러에 등록                
     . run(): JVM이 스레드스케쥴러를 확인후 그 실행 순서에 따라 run()메소드를 호출함, CallBack Method에 해당됨
     
            
   - CallBack Method: JVM이 자신의 실행 스케쥴러를 만들고 거기에 등록된 순서에 따라 자동으로 호출하는 메소드

     java.lang.Object
     |
     +--java.lang.Thread
        |
        +--MyThread.java


>>>>> ThreadTest1.java

class MyThread extends Thread{
    private int num;
    private String name;
    
    public MyThread(String a, int b) {
        name = a;
        num = b;
    }
    
    //JVM이 호출하는 Callback 메소드, 의무적으로 구현해야 함
    //스레드 관리자가 run()메소드를 집중적으로 실행하지 않고
    //객체를 순환하면서 객체안에 있는 run()메소드를 호출합니다.
    //t1, t2, t3안에 있는 run()메소드가 돌아가면서 실행됩니다.
    public void run() {  
        for(int i=0; i<num; i++){
            System.out.println(name + " : " + i);
        }
    }
}

public class ThreadTest1{
    public static void main(String args[]) {
        MyThread t1 = new MyThread("first", 1000);
        MyThread t2 = new MyThread("second", 1000);
        MyThread t3 = new MyThread("third", 1000);

        t1.start();  // run() 메소드 호출
        t2.start();
        t3.start();         
    }
}





3. Runnable 인터페이스를 사용한 경우
   - 스레드 내용을 가지고 있는 클래스가 추가적인 기능이 필요해 다른 클래스를 상속받는 경우는
     Thread 클래스를 Extend 할 수 없음으로 반드시 Runnable인터페이스를 상속받아야 합니다.

   - 상속을 받으면서 스레드를 구현하고 싶은 경우 사용됩니다.


>>>>> ThreadTest2.java

class ThreadOne implements Runnable {
    private int num;
    private String name;
    
    public ThreadOne(String a, int b) {
        name = a;
        num = b;
    }
    
    public void run(){
        for(int i=0; i<num; i++){
            System.out.println(name + " : " + i);
        }
    }
}

public class ThreadTest2{
    public static void main(String args[]) {
        //Runnable Interface를 구현한 클래스 객체를
        //Thread 클래스의 생성자로 할당합니다.
        Thread t1 = new Thread(new ThreadOne("first", 1000));
        Thread t2 = new Thread(new ThreadOne("second", 1000));
        Thread t3 = new Thread(new ThreadOne("third", 1000));

        t1.start();         
        t2.start();
        t3.start();
    }
}







[03] 우선순위, 동기화
   - java.lang.MIN_PRIORITY, java.lang.NORM_PRIORITY, java.lang.MAX_PRIORITY
   - setPriority(int p): 현재 스레드의 우선순위를 인자 p로 설정하기 위한 메소드
   - getPriority(): 현재 스레드의 우선순위를 반환하는 메소드


1. sleep()를 적용한 경우
   - 특정 스레드에 CPU의 자원이 집중하는 것을 막을 수 있습니다.
   - 불규칙적인 동기화는 지원합니다.
 
>>>>> SchedulingTest2.java

class RunThread2 extends Thread {  
    public RunThread2(String name) {
        super(name);
    }

    public void run() {
        for ( int i = 1; i <= 30000000 ; i++ ) {
            if ( i % 50 == 0 ){
                System.out.println("Thread [" + getName() + "] : " + i);
                try{
                   sleep(200); //0.02초
                   System.out.print("");
                }catch(Exception e){ }
            }
        }
    }    
}


public class SchedulingTest2 {
    public static void main(String args[]) {
        Thread[] t = new RunThread2[1000];
        String[] str = {"☆" ,"★","◆","◇","○"};
            for(int i=0; i<t.length; i++){
                
                int j=i % str.length;
                // 수를 5로 나눈 경우 나머지의 범위는 0 ~ 4까지입니다.

                t[i] = new RunThread2(str[j]);
                t[i].start();
            }
    }
}





2. 우선순위를 적용한 예
   - Thread.MAX_PRIORITY   10
   - Thread.NORM_PRIORITY  5
   - Thread.MIN_PRIORITY   1
   - sleep(): 우선순위가 적용은 되나 다른 스레드에게 제어권이 자주 넘어감, 따라서
     sleep() 메소드를 주석 처리하고 실행하면 우선순위가 정확하게 적용됨.

>>>>> SchedulingTest4.java

class RunThread4 extends Thread {  
    public RunThread4(String name) {
        super(name);
}

    public void run() {
        for ( int i = 1; i <= 10000 ; i++ ) {
            if ( i % 50 == 0 ){
                System.out.println("Thread [" + getName() + "] : " + i);
            }

            //try{
            //     sleep(1); //0.001초
            //}catch(InterruptedException e){ }

        }
    }    
}


public class SchedulingTest4 {

    public static void main(String args[]) {
        Thread[] t = new RunThread4[3];
    
        t[0] = new RunThread4("☆");
        t[0].start();
        t[0].setPriority(1);  // ☆ 가장 느린 우선 순위
        
        t[1] = new RunThread4("◑");        
        t[1].start();
        t[1].setPriority(5);

        t[2] = new RunThread4("○");        
        t[2].start();        
        t[2].setPriority(10); // ○ 가장 빠른 우선 순위
        /*
        System.out.println("t[0]" + t[0].getPriority());
        System.out.println("t[1]" + t[1].getPriority());
        System.out.println("t[2]" + t[2].getPriority());
        */        
    }
}





3. 동기화 코드

    String name = "";

    public synchronized String getName(){
        return this.name;
    }

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

[25-D14] FileWriter, FileReader, Unicode

[01] FileWriter, FileReader

1. 파일에 문장 기록하고 읽어 오기
   - readLine()메소드는 반드시 Exception 처리해야합니다.

>>>>> FileWriterDemo.java

import java.io.*;

class FileWriterDemo {
  public static void main(String args[]) {
    String source = "JAVA\n"
                    + "JSP\n"
                    + "EJB\n"
                    + "OJT\n"    
                    + "가나다\n";

    String fname= "";
    
    //저장할 파일명 입력
    //--------------------------------------------------
    try {
        System.out.print("저장할 파일명을 입력하세요: ");
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        fname = in.readLine();//한 라인을 읽어 들임      
    }
    catch (Exception e) {
        System.out.println("Error: " + e.toString());
    }
    //--------------------------------------------------
    
    try{
        //파일 쓰기 객체 생성
        FileWriter fw = new FileWriter(fname);
        fw.write(source);//파일에 기록
        fw.close();      //메모리 해제
        System.out.println("파일을 저장했습니다.");
        
        //파일을 읽어오는 객체 생성
        FileReader fr = new FileReader(fname);
        int i; // 하나의 문자 코드를 저장합니다.
        System.out.println("파일을 읽어 옵니다.");
        //한 문자를 읽어 들임, 파일의 끝이라면 -1을 읽음
        while((i = fr.read()) != -1 ) {
          System.out.print(" (" + i + ")");          
          System.out.print((char)i);
        }
        fr.close();        
    }catch(Exception e){
        System.out.println(e.toString());
    }
  }
}




>>>>> 실행 결과
저장할 파일명을 입력하세요: Test.txt
파일을 저장했습니다.
파일을 읽어 옵니다.
 (74)J (65)A (86)V (65)A (10)
 (74)J (83)S (80)P (10)
 (69)E (74)J (66)B (10)
 (79)O (74)J (84)T (10)
 (44032)가 (45208)나 (45796)다 (10)





2. 유니코드(Unicode)
   - 유니코드는 16비트 문자셋이며 완성형을 지원합니다.
   - 문자 코드의 범위는 0 ~ 65535 입니다.
   - 전 세계문자 40000자가 기록이 되어 있으며 자바는 유니코드를 사용합니다.
   - 문자 한문자를 사용해도 2바이트를 사용합니다.
   - 윈도우는 KSC5601 완성형을 사용합니다.


>>>>> CodeTest.java

public class CodeTest {

    public static void main(String[] args) {
        // 문자의 코드 값 출력
        System.out.println("A: " + (int)("A".charAt(0)));
        System.out.println("a: " + (int)("a".charAt(0)));
        System.out.println("0: " + (int)("0".charAt(0)));
        
        System.out.println((int)("대".charAt(0)));
        System.out.println((int)"한".charAt(0));
        System.out.println((int)"민".charAt(0));
        System.out.println((int)"국".charAt(0));        
        System.out.println((int)"大".charAt(0));
        System.out.println((int)"韓".charAt(0));
        System.out.println((int)"民".charAt(0));
        System.out.println((int)"國".charAt(0));
        
        // 코드 값을 이용해서 문자 출력
        System.out.println((char)45824);
        System.out.println((char)54620);
        System.out.println((char)48124);
        System.out.println((char)44397);
    }
}





3. 필수 입력의 처리

>>>>> Test.java

import java.io.BufferedReader;
import java.io.InputStreamReader;

class DataInput{
    // 키보드 입력 객체를 가져옵니다.
    public BufferedReader openReader(){
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        return in;
    }
    
    // 키보드 입력 객체를 닫습니다.
    public void closeReader(BufferedReader in){
        try {
            in.close();      
        }
        catch (Exception e) {
            System.out.println("Error: " + e.toString());
        }
    }
    
    // 키보드 입력 처리
    public String inStr(BufferedReader in, String message){
        String str = "";
        
        while(true){  // 무한 루틴
            System.out.print(message + ": ");
            
            try {
                str = in.readLine();//한 라인을 읽어 들임      
            }
            catch (Exception e) {
                System.out.println("Error: " + e.toString());
            }

            if (str.equals("")){
                System.out.println("입력받은 값이 없습니다.\n");
            }else{
                break; // while 문 종료
            }
        }
        return str;
    }
}

// 성명, 전화번호, 주소, 취미
public class Test {
    public static void main (String args[]) {
        DataInput di = new DataInput();
        BufferedReader in = di.openReader();
        
        System.out.println("이름: " + di.inStr(in, "이름을 입력해주세요."));
        System.out.println("전화번호: " + di.inStr(in, "전화번호를 입력해주세요."));
        System.out.println("주소: " + di.inStr(in, "주소를 입력해주세요."));
        System.out.println("취미: " + di.inStr(in, "취미를 입력해주세요."));
     
        di.closeReader(in);
    }
}




[출처 : http://nulunggi.pe.kr/]

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.