Java Framework 공부용

class Ex01 {
	public static void main(String[] args) {
		System.out.println("별찍기");
		for(int i=1; i<=5; i++){
			for(int j=1; j<=i; j++){
				System.out.print("*");
			}
		System.out.println(" ");
		}
	}
}


결과

*
**
***
****
*****

========================================================================================

[ 거꾸로 찍기 ] 

class Ex01 {
	public static void main(String[] args) {
		System.out.println("별찍기");
		for(int i=5; i>=1; i--){
			for(int j=1; j<=i; j++){
				System.out.print("*");
			}
		System.out.println();
		}
	}
}


결과

*****
****
***
**
*


========================================================================================

class Ex01 {
	public static void main(String[] args) {
		System.out.println("별찍기");
		for(int i=0; i<=10; i++){
			for(int j=i; j<=10; j++){
				System.out.print(" ");
			}
			for(int k=0; k<i; k++){
				System.out.print(" "+"*");
			}
			System.out.println();
		}
	}
}


결과

           *
          * *
         * * *
        * * * *
       * * * * *
      * * * * * *
     * * * * * * *
    * * * * * * * *
   * * * * * * * * *
  * * * * * * * * * *

========================================================================================

class Ex01 {
	public static void main(String[] args) {
		System.out.println("별찍기");
		for(int i=0; i<=10; i++){
			for(int j=i; j<=10; j++){
				System.out.print(" ");
			}
			for(int k=0; k<i; k++){
				System.out.print(" "+"*");
			}
			System.out.println();
		}
		for(int i=10; i>=0; i--){
			for(int j=i; j<=10; j++){
				System.out.print(" ");
			}
			for(int k=0; k<i; k++){
				System.out.print(" "+"*");
			}
			System.out.println();
		}
	}
}



결과

           *
          * *
         * * *
        * * * *
       * * * * *
      * * * * * *
     * * * * * * *
    * * * * * * * *
   * * * * * * * * *
  * * * * * * * * * *
  * * * * * * * * * *
   * * * * * * * * *
    * * * * * * * *
     * * * * * * *
      * * * * * *
       * * * * *
        * * * *
         * * *
          * *
           *

---------------------------------------      package test01.thread;      ----------------------------------------------------------

임시 저장소에 데이터를 저장하는 스레드

package test01.thread;
// 임시 저장소에 데이터를 저장하는 스레드
class TempThread extends Thread{
	//Message msg=new Message();==>두 개의 자원을 사용하겠다고 여기에 이렇게주면 안된다.
	private Message msg;
	//main 메소드에서 생성된 객체를 참조해 온다.
	public TempThread(Message msg){
		this.msg=msg;
	}
	public void run(){	
		char[] data={'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'};	//다운로드 할 데이터. 이것을 msg.set~로 옮겨야 함. 
		for(int i=0; i<data.length; i++){
			//다운로드 할 데이터를 임시 저장소에 저장하기
			msg.setMsg(String.valueOf(data[i]));	//setMsg는 파라미터 값을 돌면서 계속 연결해주는 역할
			//for(int j=0; j<=1000; j++);	//시간 지연하기
		}
		System.out.println("임시저장공간에 다운로드 완료");
	}
}
// 임시 저장소의 데이터를 파일로 저장하는 스레드
class WriteThread extends Thread{
	private Message msg;
	//main 메소드에서 생성된 객체를 참조해 온다.
	public WriteThread(Message msg){
		this.msg=msg;
	}
	public void run(){	
		System.out.println("파일로 저장 시작!");
		System.out.println(msg.getMsg());
		System.out.println("파일에 저장 완료!");
	}
}
public class MainTest {
	public static void main(String[] args) {
		Message msg=new Message();//스레드간에 공유자원이 될 객체
		TempThread thread1=new TempThread(msg);
		WriteThread thread2=new WriteThread(msg);//msg 객체를 파일로 저장
		thread1.start();
		thread2.start();		
	}
}

입금 기능을 갖는 스레드

package test01.thread;
//동기화
class InputThread extends Thread{//입금 기능을 갖는 스레드
	private Bank bank;
	public InputThread(Bank bank){
		this.bank=bank;
	}
	public void run(){
		synchronized (bank) {	//싱크로나이즈드. (bank) =공유자원	동기화 처리하기(lock 이 걸림)
		System.out.println("입금 처리중");
		bank.input(1000);	//공유자원
		for(int i=1; i<=100000000; i++);//;을 안찍어주면 계속 루프를 돌기 때문에 찍어준다. 시간지연(입금 처리중이라고 가정하자.)
		System.out.println("입금 완료!");
		System.out.println("입금 후 잔액: " + bank.getMoney());
		}
	}
}
class OutputThread extends Thread{
	private Bank bank;
	public OutputThread(Bank bank){
		this.bank=bank;
	}
	public void run(){
		synchronized (bank){//동기화 처리하기(lock 이 걸림)
		System.out.println("출금 처리중");
		bank.output(2000);
		for(int i=1; i<=100000000; i++);//시간지연(입금 처리중이라고 가정하자.)
		System.out.println("출금 완료!");
		System.out.println("출금 후 잔액: "+bank.getMoney());
		}
	}
}
public class MainTest01 {
	public static void main(String[] args) {
			Bank bank=new Bank(5000);
			new OutputThread(bank).start();
			new OutputThread(bank).start();
			new OutputThread(bank).start();
			new InputThread(bank).start();
			new OutputThread(bank).start();
			new OutputThread(bank).start();
	}
}

공유 자원이 될 객체

package test01.thread;
//공유 자원의 될 객체
public class Bank {
	private double money;//잔액
	public Bank(double money){
		this.money=money;
	}
	public void input(double m){//입금기능
		money+=m;
	}
	public void output(double m){//출금기능
		if(money<m){	//입금 된 돈이 적으면
			System.out.println("잔액부족");
			return;//메소드 끝내기
		}
		money-=m;
	}
	public double getMoney(){
		return money;
	}
}
 



스레드간의 객체 공유하기
package test01.thread;
// 스레드 간의 객체 공유하기
//공유 될 클래스
public class Message {
	private String msg="";
	public void setMsg(String msg){
		this.msg+=msg;
	}
	public String getMsg(){return msg;}
}

---------------------------------------      package test02.thread;      ----------------------------------------------------------

Test02 InputThread

package test02.thread;

class InputThread extends Thread{
	private Bank bank;
	public InputThread(Bank bank){
		this.bank=bank;
	}
	public void run(){
		//bank 객체 자체에서 동기화 처리가 되어있으므로 사용하는 곳에서는 동기화 처리를 하지 않는다.
		bank.input(1000);
	}
}
class OutputThread extends Thread{
	private Bank bank;
	public OutputThread(Bank bank){
		this.bank=bank;
	}
	public void run(){
		bank.output(2000);
	}
}
public class MainTest {
	public static void main(String[] args) {
		Bank bank=new Bank(5000);
		new OutputThread(bank).start();
		new OutputThread(bank).start();
		new InputThread(bank).start();
		new OutputThread(bank).start();
	}
}

Test02 공유자원이 될 객체

package test02.thread;
//공유 자원의 될 객체
public class Bank {
	private double money;//잔액
	public Bank(double money){
		this.money=money;
	}
	public synchronized void input(double m){	//동기화 메소드
		System.out.println("입금 처리중");
		for(int i=1; i<=100000000; i++);
		money+=m;
		System.out.println("입금 처리 완료");
		System.out.println("입금 후 잔액: " +money);
	}
	public synchronized void output(double m){	//동기화 메소드
		System.out.println("출금 처리중");
		for(int i=1; i<=100000000; i++);
		if(money<m){	//입금 된 돈이 적으면
			System.out.println("잔액부족");
			return;//메소드 끝내기
		}
		money-=m;
		System.out.println("입금 처리 완료");
		System.out.println("입금 후 잔액: " +money);
	}
	public double getMoney(){
		return money;
	}
}

---------------------------------------      package test03.thread;      ----------------------------------------------------------

Test03 임시 저장 공간에 다운로드 및 파일저장

package test03.thread;

class TempThread extends Thread{//템프스레드는 Message msg 객체를 가지고 있지
	private Message msg;
	public TempThread(Message msg){
		this.msg=msg;
	}
	public void run(){
		synchronized (msg) {	//동기화
			System.out.println("임시 저장 공간에 다운로드 시작");
			char[] data={'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'};//다운로드 할 데이터. 이것을 msg.set~로 옮겨야 함. 
			for(int i=0; i<data.length; i++){
				//다운로드 할 데이터를 임시 저장소에 저장하기
				msg.setMsg(String.valueOf(data[i]));//setMsg는 파라미터 값을 돌면서 계속 연결해주는 역할
				for(int j=0; j<=1000; j++);//시간 지연하기
			}
			System.out.println("임시저장공간에 다운로드 완료");
			msg.notify();//wait 하고 있는 객체를 깨운다.
			msg.setStatus(true);	//참이면 32행이 false 로 실행하지 않고 파일 저장 시작~ 뜸
		}
	}
}
// 임시 저장소의 데이터를 파일로 저장하는 스레드
class WriteThread extends Thread{
	private Message msg;
	//main 메소드에서 생성된 객체를 참조해 온다.
	public WriteThread(Message msg){
		this.msg=msg;
	}
	public void run(){
		synchronized(msg) {
			if(msg.isStatus()==false){//생산자 스레드가 아직 notify 하지 않는 경우 ==> wait 가 수행되어야 함
				try{
					msg.wait();//다른 스레드에서 notify 메소드로 깨울 때까지 wait 상태가 됨. synchronized 블록 안에서만 사용 가능!
				}catch(InterruptedException ie){
					System.out.println(ie.getMessage());
				}
			}
			System.out.println("파일로 저장 시작!");
			System.out.println(msg.getMsg());
			System.out.println("파일에 저장 완료!");
		}
	}
}
public class MainTest {
	public static void main(String[] args) {
		Message msg=new Message();	//스레드간에 공유자원이 될 객체
		TempThread thread1=new TempThread(msg);
		WriteThread thread2=new WriteThread(msg);//msg 객체를 파일로 저장
		thread1.start();
		thread2.start();		
	}
}

Test03 스레드 간의 객체 공유하기

package test03.thread;
// 스레드 간의 객체 공유하기
// 공유될 클래스
public class Message {
	private String msg="";
	private boolean status=false;
	public void setStatus(boolean status){
		this.status = status;
	}
	public boolean isStatus(){
		return status;
	}
	public void setMsg(String msg){	//setMsg : setter 메소드 라고 부름
		this.msg+=msg;
	}
	public String getMsg(){	//getMsg : getter 메소드라고 부름
		return msg;
	}
}

---------------------------------------      package test04.thread;      ----------------------------------------------------------

Test04 ThreadJoin

package test04.thread;

import java.util.Random;

class MyThread1 extends Thread{
	public void run(){
		Random rnd=new Random();
		for(int i=1;i<=100;i++){
			int n=rnd.nextInt(100);
			System.out.print("발생된난수:"+n);
			if(i%10==0) System.out.println();
		}
		System.out.println("자식스레드 종료");
	}
}
public class ThreadJoin {
	public static void main(String[] args) {
		MyThread1 thread=new MyThread1();
		thread.start();
		try{
			thread.join();	//부모 스레드가 자식 스레드가 종료 될 때까지 기다림
		}catch(InterruptedException ie){
			System.out.println(ie.getMessage());
		}
		System.out.println("메인스레드종료");
	}
}

Test04 hreadStop

package test04.thread;

import java.util.Random;

class MyThread extends Thread{
	private boolean status=false;
	public void run(){
		Random rnd=new Random();
		status=true;
		while(status){
			int n=rnd.nextInt(100);
			System.out.println("발생된난수:"+n);
		}
	}
	public void stopMyThread(){
		status=false;
	}
}
public class ThreadStop {
	public static void main(String[] args) {
		MyThread th=new MyThread();
		th.start();//스레드 실행하기
		try{
			Thread.sleep(3000);
		}catch(InterruptedException ie){}
		th.stopMyThread();//스레드 종료하기
	}
}
// 메인 스레드에서 th.stopMyThread(); 호출

package test03.thread;
/*
 * << 스레드(Thread) >>
 * - 경량의 프로세스 (프로그램의 흐름) : 하나의 프로그램에서 어떠한 작업을 작은 프로세스로 따로 실행시키는것
 * - 사용이유
 *   1) 어떠한 작업이 동시에 이루어져야 할때 
 *      예:게임에서 이미지가 이동될때,여러 파일을 동시에 다운로드받을때...등
 *   2) 어떠한 작업이 시간이 지연되는 작업일때
 *      예:파일복사,프린터로 출력하기,...
 * - 만드는 방법
 *   방법1)
 *   Thread클래스를 상속받고 run메소드를 오버라이딩해서 스레드로 구현되어야 할 작업을 구현한다.
 *   실행할때는 start메소드를 사용한다.  
 *   방법2)
 *   Runnable인터페이스를 상속받아 구현하기
 *   
 */

//스레드만드는 방법1
////////// 1. 스레드클래스 상속받기 ////////////
class FileCopy extends Thread{
	////////// 2. run메소드 오버라이딩  /////////
	public void run(){
		for(int i=1;i<=10000;i++){
			System.out.print("파일복사중..");
			if(i%100==0) System.out.println();
		}
	}
}
class FilePrint extends Thread{
	public void run(){
		for(int i=1;i<=1000000;i++){
			System.out.print("프린터로 인쇄중");
			if(i%100==0) System.out.println();
		}
	}
}
public class ThreadTest01 {
	public static void main(String[] args) {
		/////////// 3.스레드생성하고 start메소드로 스레드 실행하기 ///////////
		FileCopy fc=new FileCopy();//스레드객체 생성
		fc.start();//스레드 실행(반드시 start메소드로 스레드를 실행시켜야 함==>스레드로 구동되기위한 환경을 만들고
		//내부적으로 run메소드를 호출해준다.)	
		FilePrint fp=new FilePrint();
		fp.start();
	}
}	

스레드(Thread)만드는 방법 02

package test03.thread;
//스레드만드는 방법2
//1.Runnable인터페이스 상속받아 run메소드 오버라이딩하기
class MyThread01 implements Runnable{
	public void run(){
		for(int i=1;i<=100;i++){
			System.out.println("...파일복사중");
			if(i%10==0) System.out.println();
			try{
				Thread.sleep(1000);//스레드를 1초간 지연
			}catch(InterruptedException ie){
				System.out.println(ie.getMessage());
			}
		}
	}
}
public class ThreadTest02 {
	public static void main(String[] args) {
		//2.Runnable자식객체생성
		MyThread01 tt=new MyThread01();
		//3.Thread객체생성하고 Runnable객체 인자로 보내기
		Thread th=new Thread(tt);
		//4.스레드를 start메소드로 실행하기
		th.start(); 
		//new Thread(tt).start();
		
		for(int i=1;i<=100;i++){
			System.out.println("...프린터인쇄중");
			if(i%10==0) System.out.println();
			try{
				Thread.sleep(1000);//스레드 1초간 지연하기
			}catch(InterruptedException ie){
				System.out.println(ie.getMessage());
			}
		}
	}
}

스레드(Thread) - 파일을 복사하고 디렉토리 크기 구하기

package test03.thread;

import java.io.*;
import java.util.Scanner;

public class ThreadTest03 {
	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		while(true){
			System.out.println("어떤 작업을 할까요? 1. 파일복사   2. 디렉토리 크기 구하기   3. 종료");
			int n=scan.nextInt();
			switch(n){
			case 1:filecopy(); break;
			case 2:dirSize(); break;
			case 3:System.exit(0);
			default:System.out.println("잘못입력");
			}
		}
	}
	private static void filecopy() {
		File f1=new File("c:\\java\\navi.jpg");	//원본파일
		File f2=new File("c:\\java\\navi_copy.jpg");	//복사본 파일
		
		try{
			FileInputStream fin=new FileInputStream(f1);	//파일을 읽어오기 위한 스트림
			FileOutputStream fos=new FileOutputStream(f2);	//파일을 출력하기 위한 스트림
			//파일 복사하기
			int n=0;
			byte[] b=new byte[1000];
			while((n=fin.read(b))!=-1){	//원본 파일에서 데이터 읽어와 b 배열에 저장
				fos.write(b,0,n);	//b 배열을 복사본 파일에 저장(출력)
			}
			//스트림 닫기
			fos.close();
			fin.close();
			System.out.println("[[[[[[[[[[[[[[[[[[[[[[[[		복사 완료		]]]]]]]]]]]]]]]]]]]]]]]]");
		}catch(FileNotFoundException fe){
			System.out.println(fe.getMessage());
		}catch(IOException ie){
			System.out.println(ie.getMessage());
		}
	}
	public static void dirSize(){
		File f1=new File("c:\\java\\");
		long size=getSize(f1);
		System.out.println("디렉토리 크기:" + size + "bytes");
	}
	

public static long getSize(File f1){
  long len=0;
  File[] list=f1.listFiles();
  for(int i=0; i<list.length; i++){
   if(list[i].isFile()){
    len+=list[i].length();
   }else{
    len+=getSize(list[i]);
   }
  }
  return len;
 }
}

*코드가 너무 길어서 짤렸음...위와 같이 이어줄 것!*

package test03.thread;
class MyThread extends Thread{
	public MyThread(String name){
		super(name);
	}
	public void run(){
		for(int i=0; i<=50; i++){
			System.out.println("실행중인 스레드: "+getName());
		}
	}
}
public class ThreadTest05 {
	public static void main(String[] args) {
		MyThread th1=new MyThread("1번 스레드");
		MyThread th2=new MyThread("2번 스레드");
		MyThread th3=new MyThread("3번 스레드");
		
		th3.setPriority(Thread.MAX_PRIORITY);	//우선순위를 가장 높게 설정
		th2.setPriority(Thread.NORM_PRIORITY);		//우선 순위를 중간으로 설정
		th1.setPriority(Thread.MIN_PRIORITY);	//우선 순위를 가장 낮게 설정
		
		th1.start();
		th2.start();
		th3.start();
	}
}

package test03.thread;

import java.util.Calendar;
import java.util.Random;
/*
 * 1초에 한 번씩 현재시각을 출력하는 스레드(Thread 상속)와
 * 1초에 한 번씩 난수를 얻어와 출력하는 스레드(Runnable 상속)를 만들고 실행시켜 보세요.
 */
class TimeThread extends Thread{
	public void run() {
		while(true){
			Calendar cal=Calendar.getInstance();
			String str=cal.get(Calendar.HOUR_OF_DAY)+"시" +cal.get(Calendar.MINUTE) +"분" + cal.get(Calendar.SECOND) +"초";
			System.out.println(str);
			try{
				Thread.sleep(1000);
			}catch(InterruptedException ie){
				System.out.println(ie.getMessage());
			}
		}
	}
}
class RndThread implements Runnable{
	public void run(){
		Random rnd=new Random();
		while(true){
			int n=rnd.nextInt(100)+1;	//1~100까지 수 중 임의의 난수 얻어오기
			System.out.println("발생한 난수: "+n);
			try{
				Thread.sleep(1000);
			}catch(InterruptedException ie){
				System.out.println(ie.getMessage());
			}
		}
	}
}
public class Quiz01 {
	public static void main(String[] args) {
		//TimeThread thread1=new TimeThread();
		//thread1.start();
		new TimeThread().start();
		new Thread(new RndThread()).start();
	}
}

[ 과  제 ]

package test03.thread;
/*<< 덧셈 프로그램 작성하기 >>
임의의 난수를 두개 더하는 프로그램. 맞히면 점수는 10점 증가된다.
시간은 60초가 주어진다.(스레드로 시간 체크하기)

3+1=
4
jumsu:10
5+10=
				<<50초 남음>>
15
jumsu:20
1+4=
				<<40초 남음>>
5
jumsu:30
5+1=
				<<30초 남음>>
				<<20초 남음>>
				<<10초 남음>>
				<<0초 남음>>
게임이 종료됩니다.
*/
import java.util.Random;
import java.util.Scanner;

class Game extends Thread{
	public void run(){
		for(int i=60; i>=1; i--){		//60초부터
			try{
				Thread.sleep(1000);
				if(i%10==0)		//10초
					System.out.println("                                  <<"+i+"초 남았습니다. >>");
				}catch(InterruptedException ie){
					System.out.println(ie.getMessage());
					}
			}
		System.out.println("게임을 종료합니다.");
		System.exit(0);		//종료
		}
	}
class Plus extends Thread{
	public void run(){
		Scanner scan=new Scanner(System.in);
		int sum=0;
		Random rnd=new Random();
		while(true){
			int n=rnd.nextInt(10)+1;
			int e=rnd.nextInt(10)+1;
			System.out.println(n+"+"+e+"=");		//난수 더하기 난수=
			int dap=scan.nextInt();
			if(dap==(n+e)){
				sum+=20;
			}
		System.out.println("점수"+sum);
		}
	}
}
public class Quiz02 {
	public static void main(String[] args) {
		
		System.out.println("덧셈 게임을 시작합니다.");
		new Game().start();		
		new Plus().start();
	}
}

File클래스 - 디렉토리 확인 및 디렉토리 삭제, 생성

/*
	<< File클래스★ >>
	- 파일 또는 디렉토리에 관련된 정보를 갖는 클래스
 */
import java.io.*;
class  File01{
	public static void main(String[] args) {
		File f=new File("c:\\JAVA\\12일차\\navi.jpg");
		//public boolean exists()
		if(f.exists()){
			System.out.println("디렉토리가 존재합니다.");
			System.out.println("파일의 크기: "+f.length() + "bytes");	//해당 파일의 크기
		}else{
			System.out.println("해당 디렉토리가 존재하지 않습니다.");
		}
		File f1=new File("c:\\JAVA\\test");
		if(f1.exists()){
			f1.delete();//디렉토리 또는 파일 삭제하기(디렉토리 안에 파일이 있으면 디렉토리를 지울 수 없으며 그 안의 내용을 지워줘야 삭제가능)
			System.out.println("해당 디렉토리를 삭제했습니다.");
		}else{
			System.out.println("해당 디렉토리가 존재하지 않습니다.");
			f1.mkdir();//디렉토리 생성하기
			System.out.println("해당 디렉토리를 생성했습니다.");
		}
	}
}
 
 
 
 
File클래스 - 디렉토리 안의 목록(디렉토리명 또는 파일명)이름을 배열로 얻어오기

import java.io.*;
class File02 {
	public static void main(String[] args) {
		File f=new File("c:\\JAVA");
		//public string[] list()
		//디렉토리 안의 목록(디렉토리명 또는 파일명)이름을 배열로 얻어오기
		String[] list=f.list();
		for(int i=0; i<list.length; i++){
			System.out.println(list[i]);
		}
		System.out.println("=======================================");
		//public File[] listFiles()
		//디렉토리 안의 정보를 File객체 배열로 얻어옴
		File[] flist=f.listFiles();
		for(int i=0; i<flist.length; i++){
			if(flist[i].isDirectory()){
				System.out.println("디렉토리: "+flist[i]);
			}else if(flist[i].isFile()){
				System.out.println("파일: "+flist[i] + "파일 크기: "+flist[i].length() + "bytes");
			}
		}
	}
}

File클래스 - 파일 절대 경로 및 이름 불러오기

import java.io.*;
class File03 {
	public static void main(String[] args) {
		File f=new File("c:\\aa\\bb");
		if(f.exists()){
			System.out.println("디렉토리가 존재해요.");
		}else{
			f.mkdirs();	//자식 디렉토리까지 생성
			System.out.println("디렉토리 생성");
		}
		File f1=new File("File01.java");
		//public string getAbsolutePath() ==> 파일의 절대 경로 얻어오기
		String path=f1.getAbsolutePath();
		System.out.println("파일의 절대 경로: "+path);
		String name=f1.getName();		//getName : 파일 이름 불러오기
		System.out.println("파일명: "+name);
	}
}

내부클래스 - 인스턴스 내부 클래스

class Rect{
	private int x, y;
	private String color;
	public Rect(int x, int y, String color){
		this.x=x;
		this.y=y;
		this.color=color;
	}
	public void print(){
		Printer prn=new Printer();
		prn.printRect();
	}
	//인스턴스 내부 클래스
	class Printer{
		public void printRect(){
			//Outer클래스(Rect)의 비공개 멤버 변수에 접근 가능하다.
			System.out.println(x+"," +y+"의 위치에 "+color+"색상으로 사각형 출력하기");
		}
	}
}
class  InnerClass01{
	public static void main(String[] args) {
		Rect rr=new Rect(100, 200, "red");
		rr.print();
	}
}

내부 클래스 - 익명의 내부 클래스

//익명의 내부 클래스
interface Shape{
	void draw();
}
class  InnerClass02{
	public static void main(String[] args) {
		/*class MyRect implements Shape{//MyRect가 딱 한번만 호출하기 위한 목적으로 만들어진다. 1회용!
			public void draw(){
				System.out.println("사각형 그리기");
			}
		}
		MyRect rr=new MyRect();
		rr.draw();
		*/
		//위의 작업을 익명의 내부클래스로 만들면(일회성 클래스인 경우에)
		/*Shape rect=new Shape(){	//new할 수 없지만 다시 블럭을 지정, 추상메소드 작성
			public void draw(){
				System.out.println("사각형 그리기");
			}
		};
		rect.draw();
	}
}*/
		new Shape(){
		public void draw(){
			System.out.println("사각형 그리기");
			}
		}.draw();
	}
}

객체의 직렬화

//MyPerson.java
import java.io.Serializable;
/*
		<< 객체의 직렬화 >>
		- 객체를 바이트 단위로 일렬로 나열하는 것
		- 직렬화가 가능하도록 하려면 Sserializable인터페이스를 상속받는다.
		- 멤버가 transient인 경우, static인 경우는 직렬화가 되지 않는다.

		#역직렬화
		- 바이트 단위로 나열된 데이터를 다시 조합해 객체로 만드는 것
*/
//직렬화가 가능한 클래스 만들기
public class MyPerson implements Serializable{
	private String name;	//이름
	private transient String jumin;	//주민번호--> 직렬화가 되지 않는 멤버	transient: 멤버 앞에 주면 직렬화 되지 않도록 하는 것
	private String phone;	//전화번호

	public MyPerson(String name, String jumin, String phone){
		this.name=name;
		this.jumin=jumin;
		this.phone=phone;
	}
	public String getName(){return name;}
	public String getJumin(){return jumin;}
	public String getPhone(){return phone;}
}

ObjectOutputStream01 - 객체를 파일로 저장하기 위한 스트림 객체 생성

import java.io.*;
import java.util.Date;
/*
	ObjectOutputStream
	==> 객체를 출력하기 위한 스트림
	ObjectInputStream
	==> 객체를 읽어오기 위한 스트림
*/
class ObjectOutputStream01 {
	public static void main(String[] args) {
		//public ObjectOutputStream(OutputStream out) throws IOException
		//객체를 파일로 저장하기 위한 스트림 객체 생성
		try{
			//객체를 파일로 저장하기 위한 스트림 객체 생성
			ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("test.ser"));
			//public final void writeObject(Object obj) throws IOException
			//객체를 파일로 저장하기
			oos.writeObject(new String("안녕"));
			oos.writeObject(new Date());
			oos.writeObject(new Integer(100));
			oos.close();
			System.out.println("파일로 저장 성공!");
		}catch(IOException ie){
			System.out.println(ie.getMessage());
		}
	}
}
 
 
 
 
ObjectInputStream02 - 파일에 저장된 순서로 객체 읽어오기

import java.util.Date;
import java.io.*;
class ObjectInputStream02 {
	public static void main(String[] args) {
		try{
			//객체를 파일에서 읽어오기 위한 스트림 객체
			ObjectInputStream ois=new ObjectInputStream(new FileInputStream("test.ser"));
			//public final Object readObject() throws IOException, ClassNotFoundException
			//파일에 저장된 순서로 객체 읽어오기
			String str=(String)ois.readObject();
			Date d=(Date)ois.readObject();
			Integer i=(Integer)ois.readObject();
			System.out.println("파일에 저장된 객체");
			//파일에서 읽어오노 객체를 화면에 출력
			System.out.println(str);
			System.out.println(d);
			System.out.println(i);
			ois.close();	//스트림 닫기
		}catch(IOException ie){
			System.out.println(ie.getMessage());
		}catch(ClassNotFoundException ce){
			System.out.println(ce.getMessage());
		}
	}
}
/*
파일에 저장된 객체
안녕
Wed Aug 01 10:17:07 KST 2012
100
*/

ObjectOutputStream03 - 객체를 파일로 저장하고 예외발생처리

import java.io.*;
class ObjectOutputStream03 {
	public static void main(String[] args) {
		try{
			ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("person.ser"));
			out.writeObject(new MyPerson("홍길동", "8012122223456", "010-111-1234"));
			out.close();
			System.out.println("객체를 파일로 저장 성공!");
		}catch(IOException ie){
			System.out.println("예외발생:"+ie.getMessage());
		}
	}
}

ObjectInputStream04 - person.per에 저장된 객체를 읽어와 화면에 출력

import java.io.*;
class ObjectInputStream04 {
	public static void main(String[] args) {
		//person.per에 저장된 객체를 읽어와 화면에 출력해 보세요.
		try{
			ObjectInputStream ois=new ObjectInputStream(new FileInputStream("Person.ser"));
			//파일에서 객체 읽어오기
			MyPerson per=(MyPerson)ois.readObject();	//리턴타입이 오브젝트니까 형변환 꼭 해서 메소드 통해 얻어옴.
			System.out.println("Person에 있는 내용 출력하기");
			System.out.println("이름: "+per.getName());
			System.out.println("주민번호: "+per.getJumin());
			System.out.println("전화번호: "+per.getPhone());
			ois.close();	//스트림 닫기
		}catch(IOException ie){
			System.out.println(ie.getMessage());
		}catch(ClassNotFoundException ce){
			System.out.println(ce.getMessage());
		}
	}
}
/*
[결과]
Person에 있는 내용 출력하기
이름: 홍길동
주민번호: null
전화번호: 010-111-1234
*/

재귀 메소드 - 팩토리얼 구하기

//재귀메소드 - 자기 자신을 호출하는 메소드
class  Test07_재귀메소드{
	public static void main(String[] args) {
		int n=4;
		int num=factorial(n);
		System.out.println(n+"!="+num);	//4!=4x3x2x1
	}
	public static int factorial (int n){
		return (n>1)?n*factorial(n-1):n;
	}
}   
 
 
 
 
 
 
Quiz01

/*
	c:\\JAVA\\test 폴더를 삭제해 보세요!
*/
import java.io.*;
class Quiz01 {
	public static void main(String[] args) {
		File f=new File("c:\\JAVA\\test");
		if(f.exists()){
		//디렉토리 안의 목록(디렉토리또는파일) 얻어오기
		File[]flist=f.listFiles();
		//디렉토리 안의 파일 지우기
		for(int i=0; i<flist.length; i++){
			System.out.println("디렉토리: "+flist[i]);
			flist[i].delete();
			}
			f.delete();		//디렉토리 삭제하기
			System.out.println("해당 디렉토리를 삭제했습니다.");
			}else{
				System.out.println("해당 디렉토리가 존재하지 않습니다.");
				f.mkdir();	//디렉토리 생성하기
				System.out.println("해당 디렉토리를 생성했습니다.");
			}
	}
}


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            

Quiz02

/*
		디렉토리 삭제하기 - 폴더 안에 또 폴더가 존재하는 경우
*/
import java.io.*;
class Quiz02 {
	public static void main(String[] args) {
		File f=new File("c:\\java\\test");
		if(delDir(f)){
			System.out.println("디렉토리 삭제 성공");
		}else{
			System.out.println("디렉토리 삭제 실패");
		}
	}
	//재귀메소드 호출
	public static boolean delDir(File f){
		File[] list=f.listFiles();	//디렉토리 안의 목록 얻어오기
		for(int i=0; i<list.length; i++){
			if(list[i].isFile()){//파일인 경우
				list[i].delete();//파일 삭제하기
			}else{	//디렉토리인 경우
				delDir(list[i]);//디렉토리 안의 목록 삭제하는 자기 자신의 메소드 호출
			}
		}
		if(f.delete()){//자기 자신의 폴더 삭제하기
			return true;//정상적으로  삭제됐으면  true, 아니면 false
		}else{
			return false;
		}
	}
}
 
 
 
 
 
Quiz03

/*
	디렉토리의 크기를 구하는 프로그램 작성
	1.쉬운경우:디렉토리안에 파일만 존재하는 경우
	2.어려운경우:디렉토리안에 디렉토리가 존재하는 경우
*/
//1번
import java.io.*;
class Quiz03{
	public static void main(String[] args) 	{
		File f=new File("c:\\java\\test");
		long fileSize=0;
		File[] list=f.listFiles();
		for(int i=0;i<list.length;i++){
			fileSize+=list[i].length();
		}
		System.out.println("디렉토리 크기:"+fileSize +"bytes");
	}
}


 
 
 
 
Quiz04

//2번
import java.io.*;
class Quiz04 {
	public static void main(String[] args) {
		File f=new File("c:\\java\\test");
		long dirSize=getDirSize(f);
		System.out.println("디렉토리크기: "+dirSize + "bytes");
	}
	public static long getDirSize(File f){
		long size=0;	//디렉토리 크기
		File[] list=f.listFiles();
		for(int i=0; i<list.length; i++){
			if(list[i].isFile()){	//파일인 경우
				size+=list[i].length();	//파일크기를 구해서 디렉토리 크기에 누적
			}else{	//디렉토리인 경우
				size+=getDirSize(list[i]);	//자식 디렉토리크기 구해서 디렉토리 크기에 누적
			}
		}
		return size;
	}
}


 
 
 
Quiz05

interface Animal{
	void move();
	void say();
}
class Quiz05 {
	public static void main(String[] args) {
		//위의 인터페이스를 이용해서 익명의 내부클래스를 만들어 아래처럼
		//결과가 나오도록 출력해 보세요.
		//고양이는 살금살금
		//고양이는 야옹야옹
		Animal rr=new Animal(){
			public void move(){
				System.out.println("고양이는 살금살금");
			}
			public void say(){
				System.out.println("고양이는 야옹야옹");
			}
		};
		rr.move();
		rr.say();
	}
}

[ 과  제 ]

/*
1. c:\ 일기장이라는 폴더에는 일기가 텍스트 파일로 저장되어 있다.
아래와 같은 작업이 수행되도록 프로그램을 작성해 보세요.
[실행결과]	String도 괜찮음 편한걸로~
c:\일기장 폴더의 파일목록
20120701.txt
20120702.txt
20120703.txt

보여줄 파일명 입력: 20120701.txt	(버퍼리더로 읽어오기)
[내용]
날짜 : 2012년 07월 01일
오늘은 날씨가 맑음
오늘은 드디어 HTA에 첫 수강을 했다.
완전 재밌다~~~
 */
import java.io.*;
import java.util.Scanner;
class Project01 {
	public static void main(String[] args) {
		Scanner scan=new Scanner (System.in);
		File f=new File("c:\\java\\일기장\\");
		if(f.exists());{
			String[]list=f.list();
			for(int i=0; i<list.length; i++){
				System.out.println(list[i]);
			}
			System.out.println("==================");
			System.out.println("보고 싶은 일기장을 쓰세요.");
			String name=scan.next();
			System.out.println("[내용]");
			try{
				BufferedReader br=new BufferedReader(new FileReader("c:\\java\\일기장\\"+name+".txt"));
				String line;
				while((line=br.readLine())!=null){
					System.out.println(line);
				}
				br.close();
			}catch(FileNotFoundException fe){
				System.out.println(fe.getMessage());
			}catch(IOException ie){
				System.out.println(ie.getMessage());
			}
		}
	}
}

BufferedOutputStream

import java.io.*;
class BufferedOutputStream01 {
	public static void main(String[] args) {
		//public BufferedOutputStream(OutputStream out)
		//화면에 출력하기 위한 버퍼(바이트 배열)기능이 강화된 객체 생성
		//OutputStream out=System.out;
		BufferedOutputStream bos=new BufferedOutputStream(System.out);//System.out : 모니터로 연결
		//아래처럼 버퍼의 크기(1024바이트)를 지정할 수 있다.
		//BufferedOutputStream bos=new BufferedOutputStream(System.out,1024);
		byte[] b={65,66,67,68,69,70};
		try{
			bos.write(b,0,5);//5byte
			bos.flush();
			bos.close();
		}catch(IOException ie){
			System.out.println(ie.getMessage());
		}
	}
}
/*
[결과]
ABCDE
*/
 
 
 
 
BufferedOutputStream - 데이터 파일로 저장

import java.io.*;
class  BufferedOutputStream02{
	public static void main(String[] args) {
		//public BufferedOutputStream (OutputStream out) - 파일과 연결해주고 싶으면 FileOutputStream
		byte[] b={65,66,67,68,69,70};
		try{
			OutputStream out=new FileOutputStream("buf.dat");
			//파일로 출력하기 위한 스트림 객체 생성
			BufferedOutputStream bos=new BufferedOutputStream(out);//System.out : 모니터로 연결, out : 파일과 연결
			bos.write(b,0,5);	//b배열의 데이터가 파일로 저장됨
			bos.flush();
			bos.close();
			System.out.println("데이터를 파일로 저장 성공!");
		}catch(IOException ie){
			System.out.println(ie.getMessage());
		}
	}
}

BufferedReader - 한 줄 Line 입력

import java.io.*;
class BufferedReader03 {
	public static void main(String[] args) {
		//public BufferedReader (Reader in)
		//InputStreamReader (InputStream in)
		//키보드로부터 읽어오기 위한 1바이트 처리 스트림 얻어오기
		InputStream in=System.in;
		//1바이트 처리 스트림을 2바이트 처리 스트림으로 변환하기
		Reader rd=new InputStreamReader(in);
		//2바이트 처리 스트림을 버퍼기능을 향상시킨 스트림 객체로 포장하기
		BufferedReader br=new BufferedReader(rd);
		//BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); => 이렇게 한 줄로 나열하여 쓸 수 있다
		//public String readLine() throws IOException
		System.out.println("한 줄 입력");
		try{
			String line=br.readLine();
			System.out.println("Line: "+line);
			br.close();	//스트림닫기
		}catch(IOException ie){
			System.out.println(ie.getMessage());
		}
	}
}

DataOutputStream - 기본자료형을 파일로 출력

import java.io.*;
class DataOutputStream01 {
	public static void main(String[] args) {
		try{
		//기본 자료형을 파일로 출력하기 위한 스트림 객체 생성
			DataOutputStream dos=new DataOutputStream(new FileOutputStream("data.dat"));
			int a=10;
			byte b=100;
			boolean c=false;
			float d=4.5f;
			double e=3.4;
			String f="hello";
			dos.writeInt(a);	//int형을 파일로 저장(실제로 자료형의 크기(4바이트)만큼 저장된다.)
			dos.writeByte(b);	//byte형을 파일로 저장(파일에 1바이트로 저장)
			dos.writeBoolean(c);
			dos.writeFloat(d);	
			dos.writeDouble(e);
			dos.writeUTF(f);
			System.out.println("파일로 저장 성공!");
			dos.close();
		}catch(FileNotFoundException fe){
			System.out.println(fe.getMessage());
		}catch(IOException ie){
			System.out.println(ie.getMessage());
		}
	}
}
 
 
 
 
DataInputStream - 데이터의 자료형 크기 만큼  읽어오기

import java.io.*;
class DataInputStream02 {
	public static void main(String[] args) {
		//data.dat파일에서 데이터를 자료형의 크기만큼 읽어오기 위한 스트림 객체 생성
		try{
			DataInputStream dis=new DataInputStream(new FileInputStream("data.dat"));
			//파일에서 읽어올 때는 저장된 자료형의 순서와 반드시 일치해야 한다.
			//파일에서 int형의 크기(4바이트)만큼 읽어와 a에 저장
			int a=dis.readInt();
			byte b=dis.readByte();
			boolean c=dis.readBoolean();
			float d=dis.readFloat();
			double e=dis.readDouble();
			String f=dis.readUTF();
			System.out.println("파일에 저장된 데이터");
			System.out.println("a: "+a);
			System.out.println("b: "+b);
			System.out.println("c: "+c);
			System.out.println("d: "+d);
			System.out.println("e: "+e);
			System.out.println("f: "+f);
			dis.close();
		}catch(FileNotFoundException fe){
			System.out.println(fe.getMessage());
		}catch(IOException ie){
			System.out.println(ie.getMessage());
		}
	}
}

 FileOutputStream - b배열의 0번째 위치에서 b배열의 크기(5)만큼 파일로 저장하기

import java.io.*;
class  FileOutputStream01{
	public static void main(String[] args) {
		//public FileOutputStream(String name)  throws FileNotFoundException
		FileOutputStream fout=null;	//FileOutputSream객체를 선언(반드시 객체 선언)
		try{
			//파일에 데이터를 출력할 수 있는 1바이트 처리 스트림객체 생성
			fout=new FileOutputStream("test.dat");
			//public void write(byte[] b,int off, int len)	throws IOExecption
			byte[] b={65,66,67,68,69};
			//b배열의 0번째 위치에서 b배열의 크기(5)만큼 파일로 저장하기
			fout.write(b, 0, b.length);
			fout.flush();//버퍼가 다 차지 않아도 데이터 출력하기
			System.out.println("파일로 저장 성공!");
		}catch(FileNotFoundException fe){
			System.out.println(fe.getMessage());
			}catch(IOException ie){
			System.out.println(ie.getMessage());
		}finally{
			try{
				if(fout!=null) fout.close();//파일 스트림 닫기
			}catch(IOException ie){
				System.out.println(ie.getMessage());
			}
		}
	}
}

 
 
 
 
FileInputStream - 파일에서 1바이트단위로 데이터를 읽어오기

import java.io.*;
class FileInputStream02{
	public static void main(String[] args) 	{
		//public FileInputStream(String name) throws FileNotFoundException
		FileInputStream fin=null;
		try{
			//파일에서 1바이트단위로 데이터를 읽어오기위한 스트림객체 생성
			fin=new FileInputStream("test.dat");

			//////// 방법1 /////////////////////////////
			/*
			//public int read() throws IOException
			while(true){
				//파일에서 1바이트 읽어와 n에 저장
				int n=fin.read();
				if(n==-1) //파일의 끝에 도달한 경우
					break;//루프끝내기
				System.out.print((char)n);//n을 화면에 출력
			}*/

			///////// 방법2 //////////////////////////////
			/*int n=0;
			while((n=fin.read())!=-1){
				System.out.print((char)n);
			}*/

			//public int read(byte[] b,int off, int len)	throws IOException
			byte[]d =new byte[100];
			int n=0;	//n에 저장되어있는 것은 5byte
			while(true){
				//파일에서 읽어와 b배열에 저장. n에는 읽어온 바이트 수 크기가 저장
				n=fin.read(d,0,d.length);
				if(n==-1){	//파일 끝에 도달해서 더이상 데이터가 없으면 루프 끝내기
					break;
				}
				//d배열의 0번 째에서 n만큼 (읽어온 바이트 수 크기 만큼)화면에 출력하기
				System.out.write(d, 0, n);
				System.out.flush();
			}
		}catch(FileNotFoundException fe){
			System.out.println(fe.getMessage());
		}catch(IOException ie){
			System.out.println(ie.getMessage());
		}finally{
			try{
				if(fin!=null) fin.close();//파일스트림 닫기
			}catch(IOException ie){
				System.out.println(ie.getMessage());
			}
		}

	}
}



 

PrintWriter - 화면에 출력하기

import java.io.*;
//아래의 결과를 화면으로 출력되도록 수정해 보세요~~
class PrintWriter01 {
	public static void main(String[] args) {
		//화면에 출력하기 위한 스트림 객체 생성	
		PrintWriter pw=new PrintWriter (System. out);
			pw.println("안녕하세요!");
			pw.println("만나서 반가워요~");
			pw.close();
			System.out.println("파일로 저장 성공!");
	}
}
		/* 파일로 생성
		try{
			//파일에 출력하기 위한 스트림 객체 생성
			PrintWriter pw=new PrintWriter("print.txt");
			pw.println("안녕하세요!");
			pw.println("만나서 반가워요~");
			pw.close();
			System.out.println("파일로 저장 성공!");
		}catch(FileNotFoundException fe){
			System.out.println(fe.getMessage());
		}
	}
}
*/
 
 
 
 
Quiz01

/*
	파일복사하는 프로그램을 작성해 보세요.
	FileInputStream,FileOutputStream 사용
	
	원본          복사본
	test.dat ===> copy.dat
*/
import java.util.Scanner;
import java.io.*;
class Quiz01_1{
	public static void main(String[] args)	{
		Scanner scan=new Scanner(System.in);
		System.out.println("원본파일명");
		String orgFileName=scan.next();
		System.out.println("복사될파일명");
		String copyFileName=scan.next();

		FileInputStream fin=null;
		FileOutputStream fout=null;
		try{
			//원본파일을 읽어오기위한 파일스트림객체
			fin=new FileInputStream(orgFileName);
			//복사본파일에 저장하기 위한 파일스트림객체
			fout=new FileOutputStream(copyFileName);
			byte[] b=new byte[100];
			int n=0;
			int fileSize=0;//전체 파일크기
			while(true){
				//원본파일읽어와 b배열에 저장하기
				n=fin.read(b,0,b.length);
				if(n==-1) break;
				//읽어온 데이터를 복사본파일에 저장하기
				fout.write(b,0,n);
				fileSize+=n;
			}
			fin.close();
			fout.close();
			System.out.println("복사된 파일크기:"+ fileSize +"bytes");
			System.out.println(copyFileName+"으로 복사성공!");

		}catch(FileNotFoundException fe){
			System.out.println(fe.getMessage());
		}catch(IOException ie){
			System.out.println(ie.getMessage());
		}
	}
}

Quiz02

/*
	BufferedReader 를 사용해서 test.txt파일을 한 줄씩 읽어와 화면에 출력해 보세요.

*/
import java.io.*;
class  Quiz02{
	public static void main(String[] args) {
		try{
			//test.txt파일에서 데이터를 읽어오기 위한 2바이트 처리 스트림 객체 생성
			 BufferedReader in = new BufferedReader(new FileReader("c:\\JAVA\\11일차_예외처리_IO\\test.txt"));
			 String line=null;
			 while((line=in.readLine())!=null){//파일에서 한 줄 읽어오기(null이면 파일 끝)
					System.out.println(line);//화면에 출력하기
			}
			in.close();
		}catch(FileNotFoundException fe){
			System.out.println(fe.getMessage());
		}catch(IOException ie){
			System.out.println(ie.getMessage());
		}
	}
}
 
 
 
 
Quiz03

/*
	다섯 명의 학생 이름, 전화번호를 키보드로 입력력받아 파일(phone.txt)에 저장해 보세요.
		
	##파일에 저장된 형태
	홍길동, 010-111-1234
	김아무, 010-222-3333
*/
import java.io.*;
import java.util.Scanner;
class Quiz03 {
	public static void main(String[] args) {
		//Scanner scan=new Scanner (System.in);
		try{
			//키보드로 데이터를 읽어오기 위한 입력스트림객체
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		//파일에 저장하기 위한 출력 스트림 객체
		PrintWriter in=new PrintWriter("phone.txt");
		//다섯명 데이터 입력받아 파일로 저장하기
		for(int i=1; i<=5; i++){
			System.out.println("학생의 이름을 입력하세요.");
			String name=br.readLine();
			System.out.println("전화번호를 입력하세요.");
			String phone=br.readLine();
			//파일로 저장
			in.println(name+","+phone+"\r\n");
		}
		br.close();
		in.close();
		System.out.println("파일로 저장 성공!");
		}catch(FileNotFoundException fe){
			System.out.println(fe.getMessage());
		}catch(IOException ie){
			System.out.println(ie.getMessage());
		}
	}
}

Quiz04

/*
	1. 학생의 이름,국어,영어점수를 키보드로 입력받아 총점,평균을 계산후 파일에 저장하기
	   Scanner,DataOutputStream 사용
	2. 파일에 저장된 이름,국어,영어,총점,평균을 읽어와 화면에 출력하기
*/
import java.io.*;
import java.util.Scanner;
class  Quiz04_1{
	static Scanner scan=new Scanner(System.in);
	public static void main(String[] args) 	{	
		while(true){
			System.out.println("1.점수입력    2.성적보기   3.종료");
			int n=scan.nextInt();
			switch(n){
				case 1:saveData();break;
				case 2:readData();break;
				case 3:System.exit(0);break;
				default:System.out.println("잘못입력");
			}
		}
	}
	public static void saveData(){
		try{
			//파일에 데이터를 추가할 수 있는 모드로 스트림객체 생성
			DataOutputStream dos=new DataOutputStream(new FileOutputStream("stu.dat",true));
			System.out.print("이름:");
			String name=scan.next();
			System.out.print("국어:");
			int kor=scan.nextInt();
			System.out.print("영어:");
			int eng=scan.nextInt();
			int tot=kor+eng;
			double ave=tot/2.0;
			//입력받은 데이터를 파일에 저장하기
			dos.writeUTF(name);
			dos.writeInt(kor);
			dos.writeInt(eng);
			dos.writeInt(tot);
			dos.writeDouble(ave);
			dos.close();
			System.out.println("저장성공!");
		}catch(Exception e){
			System.out.println(e.getMessage());
		}
	}
	public static void readData(){
		DataInputStream dis=null;
		try{
			dis=new DataInputStream(new FileInputStream("stu.dat"));
			System.out.println("이름\t국어\t영어\t총점\t평균");
			while(true){
				//파일에 저장된 순서대로 데이터 읽어오기
				String name=dis.readUTF();
				int kor=dis.readInt();
				int eng=dis.readInt();
				int tot=dis.readInt();
				double ave=dis.readDouble();
				System.out.println(name+"\t"+kor+"\t"+eng+"\t"+tot+"\t"+ave);
			}
		}catch(FileNotFoundException fe){
			System.out.println(fe.getMessage());
		}catch(EOFException e){
			System.out.println("모든 정보 출력됨");
		}catch(IOException ie){
			System.out.println(ie.getMessage());
		}finally{
			try{
				if(dis!=null) dis.close();
			}catch(IOException ie){}
		}
	}
}
 
 
 
 
 
[ 과  제 ]
 
과제 보기
과제 접기
  
 
과제 1


 
/*
		1. BufferedInputStream, BufferedOutStrream을 사용해서 파일을 복사하는 프로그램을 작성해보세요.

		예)
		원본 파일명 : 내사진.jpg
		복사본 파일명 : 내사진copy.jpg
		==>  파일이 복사됨
*/
import java.io.*;
class Project01 {
	public static void main(String[] args) {
		try{
		BufferedInputStream bis=new BufferedInputStream(new FileInputStream("navi.jpg"));
		BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("navi_copy.jpg"));
		byte b[]=new byte[500];		//파일 크기
		int n=0;
		while((n=bis.read(b))!=-1){		//원본데이터를 읽어와
			bos.write(b,0,n);	//복사본 파일에 저장
		}
		System.out.println("파일 복사가 완료되었습니다.");
		bis.close();
		bos.close();
		}catch(FileNotFoundException fe){
			System.out.println(fe.getMessage());
		}catch(IOException ie){
			System.out.println(ie.getMessage());
		}
	}
}


 
 
 
 
과제 2

/*
		2. 아래와 같은 eng.txt파일이 있을 때 파일을 읽어와 아래와 같은 작업이 이루어지도록 프로그램을 작성해 보세요.
		##파일 eng.txt
		love, 사랑하다
		apple, 사과
		yellow, 노랑
		....
		##프로그램
		영어단어 : apple
		apple의 뜻 -> 사과
*/
import java.io.*;
import java.util.Scanner;
class Project02 {
	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		try{
		//파일에 저장하기 위한 출력 스트림 객체
		PrintWriter in=new PrintWriter("eng.txt");
		//다섯명 데이터 입력받아 파일로 저장하기
		for(int i=1; i<=3; i++){
			System.out.println("영어 단어를 입력하세요.");
			String eng=scan.next();
			System.out.println("뜻을 입력하세요.");
			String dd=scan.next();
			//파일로 저장
			in.println(eng+","+dd+"\r\n");
		}
		//br.close();
		in.close();
		System.out.println("파일로 저장 성공!");
		}catch(FileNotFoundException fe){
			System.out.println(fe.getMessage());
			}
		System.out.println();
		//영어단어 찾기
		System.out.println("=======이제 영어단어를 찾습니다.==========");
		while(true){
		System.out.println("찾을 단어를 입력하세요.(종료: exit입력)");
		String title=scan.next();
		boolean find=false;
		try{
		BufferedReader ar=new BufferedReader(new FileReader("eng.txt"));  //eng 텍스트 파일 불러오기
			String line=null;
			while((line=ar.readLine())!=null){ // eng파일 읽어오기
				String ss[]=line.split(",");  // , 를 기준으로 문자열 쪼개서 배열 저장
				for (int i=0;i<ss.length ;i++ ){
					if (title.equals(ss[i])){  // 찾을 단어와 일치하는지 검색
						System.out.println(title+"의 뜻은 : "+ss[i+1]); //ss[i]번째와 일치하니 다음에 있는 ss[i+1]번째 단어 출력
						find=true;
					}
				}
			}
			if(!find){
				System.out.println("찾는 단어가 없습니다");
			}
			ar.close();
			}catch(FileNotFoundException ne){
				System.out.println(ne.getMessage());
			}catch(IOException xe){
				System.out.println(xe.getMessage());
			}
			if(title.equals("exit")){
				System.out.println("종료합니다.");
				break;
			}
		}
	}
}




과제 접기