자바의 데이터 입출력

March 11, 2024

1. 입출력 스트림

자바는 입력 스트림과 출력 스트림을 통해 데이터를 입출력함
스트림(Stream): 단방향으로 데이터가 흐르는 것
- 바이트 스트림: 그림, 멀티미디어, 문자 등 모든 종류 데이터 입출력
- 문자 스트림: 문자만 입출력 할 때 사용(문자는 보통 문자 스트림으로 함)

분류

주인공(기반 클래스)	장식(주인공을 기준으로 파일 생성가능)
생성자의 매개변수 (~outputstream, ~input stream , ~reader , ~writer) 가 없으면 주인공 ➔ 혼자서 파일생성 가능	Constructor 의 매개변수를 보고 매개변수안에 (InputStream,OutputStream,Reader,Writer)가 보이면 장식
혼자서는 파일생성 불가능	1.) os.write =1byte 씩 출력 후 저장 2.) read() = 입력 스트림으로 부터 1byte읽고 int 타입으로 리턴 →더이상 읽을수 없다면 -1 리턴 3.) ex) os.write(array,1,3); 1번 인덱스부터 3개까지 출력

파일 설명
- 1. 바이트 스트림
  - 입력 스트림 -> ~~InputStream으로 끝남
  - 출력 스트림 -> ~~OutputStream으로 끝남
- 2. 문자 스트림
  - 입력 스트림 -> ~~Reader
  - 출력 스트림 -> ~~Writer

파일 생성(출력)
- OutputStream(바이트단위 파일생성)
- Writer(문자단위 파일생성)
주인공 장식

→ Constructor의 매개변수를 보고 매개변수 안에 InputStream, OutputStream, Reader,Writer가 보이면 장식, 없으면 주인공!
(주인공은 혼자서 파일 생성 가능, 장식은 혼자서 파일 생성 불가능)
파일에 값 저장
- write 메소드
파일 읽어들임
- InputStream(바이트단위로 읽어들임)
- Reader(문자단위로 읽어들임)
파일닫기
-close()

2. 바이트 입출력 스트림

1. 바이트 출력 스트림 (OutputStream)

OutputStream은 바이트 출력 스트림의 최상위 클래스로 추상 클래스
OutputStream은 1바이트 단위로 데이터를 출력하는 스트림
FileOutputStream을 제일 많이 씀

주요 메소드

리턴 타입	메소드	설명
void	write(int b)	1바이트 출력
void	write(byte[] b)	배열 b의 모든 바이트 출력
void	write(byte[] b, int off, int len)	배열 b의 off부터 len개 만큼 출력
void	flush()	출력 버퍼에 잔류하는 모든 바이트 출력
void	close()	스트림을 닫고 사용한 자원 해제

순서
- (매개변수의 따른)주인공 장식
- 파일에 저장 -write 메소드
- 파일 읽어들임 - InputStream(”바이트” 단위로 읽어들임) / Reader (”문자” 단위로 읽어들임)
- 파일 닫기 (close())

예제

바이트 입출력 예시

public class Test {
	public static void main(String[] args) {
		try {
			OutputStream os = new FileOutputStream("C:/Users/bitcamp/Desktop/Test.db");

			byte a = 10;
			byte b = 20;
			byte c = 30;

			os.write(a);
			os.write(b);
			os.write(c);

			os.flush();
			os.close();
		}catch(IOException e) {
			e.printStackTrace();
		}
	}
}

배열 기본코드(바이트 코드 배열로 읽기)

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class Test {
	public static void main(String[] args) {
		try {
			OutputStream os = new FileOutputStream("C:/Users/bitcamp/Desktop/Test/Test1.db");

			byte [] array = {10, 20, 30, 40, 50};

			os.write(array,1,3); //1번 인덱스에서 3개까지만 출력

			os.flush();
			os.close();
		}catch(IOException e) {
			e.printStackTrace();
		}
	}
}

2. 바이트 입력 스트림 (InputStream)

<p align="center">
<img src="/assets/images/Java/13-5.png" width="400">
</p>

InputStream은 바이트 출력 스트림의 최상위 클래스로 추상 클래스
1바이트 단위로 데이터를 입력(읽어오는) 스트림

주요 메소드

리턴 타입	메소드	설명
int	read()	1바이트 읽고 int로 리턴 (끝: -1)
int	read(byte[] b)	배열 b의 크기만큼 읽어 저장, 읽은 바이트 수 리턴
int	read(byte[] b, int off, int len)	배열 b의 off부터 len만큼 읽기
void	close()	스트림을 닫고 사용한 자원 해제

public class Test {
	public static void main(String[] args) {
		try {
			InputStream is = new FileInputStream("C:/Users/bitcamp/Desktop/Test/Test1.db");

			while(true) {
				int data = is.read(); //1byte씩 읽기
				if(data == -1) break; //파일 끝에 도달(-1)
				System.out.println(data);
			}

			is.close();
		}catch(IOException e) {
			e.printStackTrace();
		}
	}
}
------------------------------------------
 20 30 40

예제

이클립스에서 프로젝트를 refresh하면 파일이 생성된다
ByteArrayInputStream , FileOutputStream

import java.io.ByteArrayInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class Test{

 public static void main(String[] args) throws IOException  {

 ByteArrayInputStream in=null; //읽어들임
 FileOutputStream out=null;    //파일을 생성 값 저장

		try {
			byte []b=new byte[] {1,2,3};
			in = new ByteArrayInputStream(b); //1,2,3바이트 배열 읽어들임
			out=new FileOutputStream("g.dat"); //g.dat라는 파일 생성

			int r=-1;
			while((r=in.read())!=-1) {
				out.write(r); //1,2,3을 g.dat파일에 저장
			}
		}catch(Exception e) {}
		out.close();
		in.close();
}
}
------------------------------------------------------------

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class Test{

 public static void main(String[] args) throws IOException  {

  FileInputStream in=null;
  ByteArrayOutputStream out=null;

  try {
   in=new FileInputStream("g.dat");
   //g.dat파일을 읽어와서
   out=new ByteArrayOutputStream();
   //바이트 배열에 저장하겠다.
   int r=-1;
   while((r=in.read())!=-1) {
    out.write(r); //배열에 저장함 1,2,3
   }
   byte [] b=out.toByteArray();
   for(int i=0;i<b.length;i++) {
    System.out.println(b[i]);
   }
  }catch(Exception e) {}
  out.close();
  in.close();
 }
}

ByteArrayInputStream ByteArrayOutputStream

import java.io.*;
import java.util.Arrays;
public class Test {
	public static void main(String[] args) throws IOException {

		//1,2,3,4,5를 읽어와서 outputstream에 저장하고 싶다.
		byte[]in= {1,2,3,4,5};
		byte[]out=null;

		ByteArrayInputStream input=null;
		ByteArrayOutputStream output=null;

		output=new ByteArrayOutputStream();
		input=new ByteArrayInputStream(in); //바이트배열읽어옴

		int r=-1;
		while((r=input.read())!=-1) {
			output.write(r); //스트림에 저장
		}
		out=output.toByteArray();  //byte[]out=output.toByateArray();
		//바이트 아웃풋 스트림을 바이트 배열로 바꿔서 out(바이트 배열)
		System.out.println(Arrays.toString(in)); //배열클래스
		System.out.println(Arrays.toString(out));
	}
}

3. 문자 입출력 스트림

1. 문자 입력 스트림

Writer는 문자 추력 스트림의 최상위 클래스로, 추상 클래스

바이트 입출력 스트림에 대응하는 문자 입출력 스트림

리턴 타입	메소드	설명
void	write(int c)	매개값으로 주어진 한 문자 출력
void	write(char [] cbuf)	매개값으로 주어진 배열의 모든 문자 출력
void	write(char [] cbuf, int off, int len)	매개값으로 주어진 배열에서 cbuf[off]부터 len개까지의 문자를 출력
void	write(Srting str)	매개값으로 주어진 문자열 출력
void	write(String str, int off, int len)	매개값으로 주어진 문자열에서 off 순번부터 len개까지의 문자 출력
void	flush()	버퍼에 잔류하는 모든 문자 출력
void	close()	출력 스트림을 닫고 사용 메모리 삭제

2. 문자 출력 스트림

Reader는 문자 입력 스트림의 최상위 클래스로, 추상 클래스임

메소드		설명
int	read()	1개의 문자를 읽고 리턴
int	read(char[] cbuf	읽은 문자들을 매개값으로 주어진 문자 배열에 저장하고 읽은 문자 수를 리턴
void	close()	입력 스트림을 닫고, 사용 메모리 삭제

예제

파일생성과 읽어들임(문자단위)

import java.io.*;
import java.util.Arrays;
public class Test {
	public static void main(String[] args) throws IOException {
		//a.txt에 저장된 문자를 읽어와서 출력
		char ary[]=new char[10];  //SW
		int r;

		FileReader in=new FileReader("a.txt");
		//파일에 저장한 문자를 읽어들여서
		r=in.read(ary,0,ary.length);
		//배열의 길이만큼 저장
		for(int i=0;i<r;i++) {
			System.out.println(ary[i]);
		}
		in.close();

		/*char a='S';
		char b='W';

		//파일생성해서 문자저장
		FileWriter out=new FileWriter("a.txt");

		out.write(a);
		out.write(b);

		out.close();*/
	}
}

    //문자 입출력 스트림
    //콘솔창에 입력해서 입력한 문자를
		//파일에 저장
		BufferedReader bu=null; // 입력하기 위한 문자형 입력 스트림
		PrintWriter pr=null; // 출력하기 위한 문자형 출력 스트림

		try {
			InputStreamReader in=new InputStreamReader(System.in);
			bu=new BufferedReader(in);
			//콘솔에 입력!
			//BufferedReader bu=new BuffereReader
			// (new InputStreamReader(System.in));
			FileWriter fw=new FileWriter("d.txt");
			//d.txt에 저장

			pr=new PrintWriter(fw);

			String str=null;
			while((str=bu.readLine())!=null) {
				pr.print(str);
			}
			bu.close();
		}catch(Exception e) { }
		finally { //예외와 상관없이 무조건 닫아지는 finally
			pr.close();
		}
					//ctrl + z 실행!!!!!!!!!!!!!!
	}
}

4. 보조 스트림

다른 스트림과 연결되어 여러가지 기능을 제공

보조스트림 변수 = new 보조스트림(입출력 스트림);
보조스트림 2 변수 = new 보조스트림2(보조 스트림1);

종류

보조 스트림	기능
InputStreamReader	바이트 스트림을 문자 스트림으로 변환
BufferedinputStream,BufferedOutputStream, BufferedReader,BufferedWriter	입출력 성능 향상
DatainputStream,DataOutputStream	기본타입 데이터 입출력
PrintStream,PrintWriter	줄바꿈 처리 및 형식화 된 문자열 출력
ObjectinputStream,ObjectOutputStream	객체 입출력

5. 문자 변환 스트림 (Character Conversion Stream)

바이트 기반 스트림(InputStream, OutputStream)을 문자 기반 스트림(Reader, Writer)으로 변환하는 스트림
바이트 → 문자, 문자 → 바이트 변환을 담당하는 중간 다리

클래스	설명
InputStreamReader	바이트 입력 스트림(InputStream)을 문자 입력 스트림(Reader)로 변환
OutputStreamWriter	문자 출력 스트림(Writer)을 바이트 출력 스트림(OutputStream)으로 변환

6. 성능 향상 스트림 (Buffered Stream)

기본 입출력 스트림은 바이트나 문자 단위로 하나하나 작업
→ 입출력이 너무 자주 일어나서 속도가 느릴 수 있다
성능 향상 스트림은 메모리 버퍼를 이용
→ 데이터를 한 번에 모아서 읽고/쓰는 방식으로 속도를 개선
구조

프로그램이 직접 파일이나 네트워크와 작업하지 않음
➡ 버퍼(buffer) 메모리 영역과 먼저 작업
➡ 일정량이 차거나 플러시(강제 출력)할 때 실제로 입출력 소스에 작업을 요청
```
[프로그램] ↔ [버퍼 스트림] ↔ [파일/네트워크]
```
➡ 프로그램이 입출력 소스와 직접 작업x, 중간에 메모리 버퍼와 작업함으로써 실행 성능 향상

종류

클래스	설명
BufferedInputStream	바이트 입력 성능 향상 스트림
BufferedOutputStream	바이트 출력 성능 향상 스트림
BufferedReader	문자 입력 성능 향상 스트림
BufferedWriter	문자 출력 성능 향상 스트림

     		FileWriter fw=new FileWriter("b.txt");
        BufferedWriter out= new BufferedWriter(fw);

        out.write("안녕~");
        out.newLine();
        out.write("오늘은 금요일~");
        out.newLine();
        out.write("aaa@naver.com");
        out.close();

import java.io.*;

public class Test {
	public static void main(String[] args) throws Exception{
		//입출력 스트림 생성
		String originalFilepath1 = Test.class.getResource("file1.png").getPath();
		String targetFilepath1 = "C:/Users/bitcamp/Desktop/targetFilepath1.db";
		FileInputStream fis = new FileInputStream(originalFilepath1);
		FileOutputStream fos = new FileOutputStream(targetFilepath1);

		//입출력 스트림+버터 스트림 생성
		String originalFilepath2 = Test.class.getResource("File2").getPath();
		String targetFilepath2 = "C:/Users/bitcamp/Desktop/targetFilepath2.db";
		FileInputStream fis2 = new FileInputStream(originalFilepath2);
		FileOutputStream fos2 = new FileOutputStream(targetFilepath2);
		BufferedInputStream bis = new BufferedInputStream(fis2);
		BufferedOutputStream bos = new BufferedOutputStream(fos2);

		//버퍼를 사용하지 않고 복사
		long nonBufferTime = copy(fis, fos);
		System.out.println("버퍼 미사용:\t"+nonBufferTime+" ns");

		//버퍼를 사용하고 복사
		long bufferTime = copy(bis, bos);
		System.out.println("버퍼 사용:\t"+bufferTime+" ns");

		fis.close();
		fos.close();
		bis.close();
		bos.close();
	}

	public static long copy(InputStream is, OutputStream os) throws Exception{
		//시작 시간 저장
		long start = System.nanoTime();
		//1 바이트를 읽고 1 바이트를 출력
		while(true) {
			int data = is.read();
			if(data == -1) break;
			os.write(data);
		}
		os.flush();
		//끝 시간 저장
		long end = System.nanoTime();
		//복사 시간 리턴
		return (end-start);
	}
}

예제

BuffredReader,Writer

import java.io.*;
public class Test {
	public static void main(String[] args) {

		//FileReader f=new FileReader("b.txt");
		//BufferedReader in=new BufferedReader(f);
		//BufferedReader in = new BufferedReader(new FileReader("b.txt"));
    //b.txt파일 생성
		try {
			BufferedReader in=new BufferedReader(new FileReader("b.txt"));
			String str;
			while(true) {
				try {
					str=in.readLine();
					if(str==null) {
						break;
					}
					System.out.println(str);
				}
				catch(Exception e) {}
			}
			try {
				in.close();
			}catch(IOException e) {}
		}catch(FileNotFoundException e) {}
	}
}

/*FileWriter fw=new FileWriter("b.txt"); //b.txt파일이 생성됨
BufferedWriter out=new BufferedWriter(fw);

out.write("안녕~");
out.newLine();
out.write("오늘은 금요일~");
out.newLine();
out.write("aaa@naver.com");
out.close();*/

7. 기본 타입 스트림

DataInputStream과 DataOutputStream 보조스트림을 연결하는코드
DataInputStream과 DataOutputStream은 기본 데이터 타입 (int, double, boolean, 등)을
➡ 바이트 단위로 입출력할 수 있게 도와줌

개발자가 일일이 byte[]로 변환하거나 조립할 필요X
➡ int, double, boolean 이런 값을 바로 쓰기/읽기

DataInputStream dis = new DAtaInputStream(바이트 입력 스트림);
DataOutputStream dos = new  DataOutputStream(바이트 입력 스트림);

예제

DataOutputStream , DataInputStream

import java.io.*;
public class Test {
	public static void main(String[] args) throws IOException {

		DataInputStream in=null;
		try {
			FileInputStream fi=new FileInputStream("h.txt");
			in=new DataInputStream(fi);

			int a=in.readInt();
			double b=in.readDouble();
			boolean c=in.readBoolean();

			//파일에 저장한 기본자료형 값 읽어와서 출력
			System.out.println(a);
			System.out.println(b);
			System.out.println(c);
		}catch(Exception e) {}
			in.close();


		/*DataOutputStream out=null;
		//기본자료형 값을 저장할 수 있다
		try {
			int a=5;
			double b=1.5;
			boolean c=true;

			FileOutputStream fi=new FileOutputStream("h.txt");
			out=new DataOutputStream(fi);

			out.writeInt(a);
			out.writeDouble(b);
			out.writeBoolean(c);
		}catch(Exception e) {}
		out.close();*/
	}
}

8. 프린트 스트림

print(), println(), printf() 메소드를 가지고 있는 보조 스트림

우리가 콘솔에 출력하기 위해 System.our.println()을 사용한 이유는 out이 PrintStrem타입이여서
PrintStream은 바이트 출력 스트림과 연결 / PrintWriter는 문자 출력 스트림과 연결

//예시
PrintStream ps = new PrintStream(바이트 출력 스트림);
PrintWriter pw = new PrintWriter(문자 출력 스트림);

PrintStream(print)	PrintWrtiter(println)
void print(int i)	void println(int i)
void print (String)	void println(String s)

9. 객체 스트림 (Object Streams)

자바는 메모리에 생성된 객체를 파일 또는 네트워크로 출력할 수 있음
이를 위해 객체를 직렬화(serialization)하고, 다시 역직렬화(deserialization)하여 객체를 파일로 저장하거나 네트워크를 통해 전송
- 직렬화(serialization): 객체를 출력하려면 필드값을 일렬로 늘어선 바이트로 변경
- 역질렬화(deserialization): 직렬화된 바이트를 객체의 필드값으로 복원

ObjectInputStream과 ObjectOutputStream 보조 스트림을 연결하는 코드

ObjectInputStream ois = new ObjectInputStream(바이트 입력 스트림: 주인공);
ObjectOutputStream ois = new ObjectOutputStream(바이트 입력 스트림);

객체 직렬화: writeObject(객체)
- 객체를 바이트 스트림으로 변환하는 과정
- 이를 통해 객체를 파일이나 네트워크를 통해 전송할 수 있음
- 직렬화하고 싶은 클래스는 반드시 Serializable 인터페이스를 구현해야한다
역직렬화: readObject(객체)
- ObjectOutputStream의 readObject() 메소드는 읽은 바이트를 역질렬화해서 원래의 객체로 복원
- 파일이나 네트워크를 통해 전송된 바이트 데이터를 다시 객체 형태로 바꿔주는 역할
```
readObject() 메소드의 리턴타입 = Object
→ 구체적인 타입으로 강제 타입 변환 필요
```
```
객체타입 변수 = (리턴타입) ois.readObject();
```

1. Serializable 인터페이스

자바는 Serializable 인터페이스를 구현한 클래스만 직렬화 할 수 있도록 제한
Serializable 인터페이스는 멤버가 없는 빈 인터페이스
객체를 직렬화 할 수 있다고 표시하는 역할
객체가 직렬화될 때 인스턴스 필드값은 직렬화 대상이지만 정적 필드값과 transient로 선언된 필드값은 직렬화에서 제외되므로 출력되지 않음

public class XXX implements Serializable{
	public int field1;
	protected int field2;
	int field3;
	private int field4;  //여기까진 직렬화 됨
	public **static** int field5;  //직렬화X 정적 필드는 직렬화 제외
	**transient** int field6;      //직렬화X transien로 선언된 필드는 직렬화 제외
}

2. SerialVersionUID 필드

직렬화한 클래스를 역직렬화할 땐 동일한 클래스여야 함
(이름이 같아도 클래스 내용이 다르면 역직렬화 실패)
클래스 내용이 다르다 할지라도 직렬화된 필드를 공통으로 포함하고 있다면 역직렬화할 수 있음
(이클립스는 serialVersionUID 필드를 자동 생성하는 기능 제공)

public class Member implements Serializable{
	static final long serialVersionUID = 1;
	int field1;
	int field2;
}
-------------------------------------------
public class Member implements Serializable{
	static final long serialVersionUID = 1;
	int field1;
	int field2;
	int field3; //field3이 하나 더 추가되어있지만 serialVersionUID이 같아서 역직렬화 가능
}

예제

ObjectOutputStream, ObjectInputStream

import java.io.*;
class Stu implements Serializable{ //빈인터페이스라 선언만 하면 됨.
	private String name;
	private String id;
	private int age;

	//이클립스에 Source > Generate Getter Setter로 생성가능
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}
public class Test {
	public static void main(String[] args) throws IOException {

		ObjectOutputStream os=null;

		try {
			os=new ObjectOutputStream(new FileOutputStream("ob.dat"));
										//↑안에 텍스트 입력 불가능. 주인공 입력해야 함(혼자 파일 생성 불가)
			Stu s=new Stu();
			s.setName("길동");
			s.setId("123");
			s.setAge(22);

			os.writeObject(s); /객체 직렬화: writeObject(객체)

		}catch(Exception e) {}
		os.close();

		ObjectInputStream in=null;

		try {
			in=new ObjectInputStream(new FileInputStream("ob.dat"));
			Stu s=(Stu)in.readObject();  //형변환 역직렬화

			System.out.println(s.getName());
			System.out.println(s.getId());
			System.out.println(s.getAge());
		}catch(Exception e) {}
		in.close();

	}
}

직렬화

import java.io.*;

class Rec implements Serializable{
	int a,b;
	Rec(int a, int b){
		this.a = a;
		this.b = b;
	}
	void show() {
		System.out.println(a+" "+b);
	}
}

public class Test {
	public static void main(String[] args) throws IOException {
		 //객체 생성 및 직렬화 코드 ObjectOutputStream os = null; os = new
		 ObjectOutputStream(new FileOutputStream("obj.dat"));

		 //Rec r = new Rec(4,7);
		 os.writeObject(new Rec(4,7));
		 os.writeObject(new Rec(8,5));
		os.writeObject(new String("glgl"));

		 os.close();
	}
}

역직렬화

import java.io.*;

class Rec implements Serializable{
	int a,b;
	Rec(int a, int b){
		this.a = a;
		this.b = b;
	}
	void show() {
		System.out.println(a+" "+b);
	}
}

public class Test {
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		//역직렬화
		ObjectInputStream in = new ObjectInputStream(new FileInputStream("obj.dat"));
		Rec r1 = (Rec)in.readObject();
		Rec r2 = (Rec)in.readObject();
		String r3 = (String)in.readObject();

		r1.show();
		r2.show();
		System.out.println(r3);
	}
}
------------------------------------------------
4 7
8 5
glgl

10. File과 Files 클래스

1. File 클래스

file에 대한 정보가 담겨 있음
File 객체를 생성했다고 파일이나 디렉토리 생성X (파일이나 디렉터리가 실존하는 지확인하는데 사용)
파일이나 디렉토리가 실제 있는지 확인하고 싶다면 Dile 객체를 생성하고 exists() 메소드를 호출하면 됨

종류

메소드	설명
exists()	파일이나 디렉토리가 실제로 존재하는지 확인
createNewFile()	파일이 없으면 새 파일을 생성하고, 이미 존재하는 파일이면 false를 리턴
mkdir() / mkdirs()	단일 디렉토리를 생성 / 중간 디렉토리까지 포함하여 디렉토리를 생성
delete()	파일이나 디렉토리를 삭제(빈 디렉토리여야함)

2. Files 클래스

java.nio.file 패키지에 포함된 클래스
파일과 디렉토리 작업을 더 효율적으로 처리
File 클래스와 달리 더 다양한 기능을 제공하며 성능이 향상된 메소드들이 포함

종류

메소드	설명
exists(Path path)	주어진 경로가 존재하는지 확인
createFile(Path path)	파일을 새로 생성
createDirectories(Path path)	디렉토리를 생성 (간에 디렉토리가 없으면 함께 생성)
delete(Path path)	파일을 삭제

기출 문제

게임 어레이 리스트

import java.util.*;
class Person{
	private String name;
	private int id;

	Person(String n, int i){
		name=n;
		id=i;
	}
	public String getName() {
		return name;
	}
	public int getId() {
		return id;
	}
	@Override
	public boolean equals(Object obj) {
		Person p=(Person)obj;
		if(p.getId()==this.id && p.getName().equals(this.name)) {
			return true;
		}
		return false;
	}
}
class Game{

	Scanner s=new Scanner(System.in);
	//사용자 정의 객체
	ArrayList<Person> a= new ArrayList<Person>(5);

	Game(){  //초기화 과정
		a.add(new Person("상우",123));  //[0]
		a.add(new Person("유탁",456));  //[1]
		a.add(new Person("민택",789));  //[2]
		a.add(new Person("성민",112));  //[3]
		                         //가영 123[4]
	}
	void in() {
		while(true) {
			System.out.println("이름,id입력");
			String name=s.next();

			if(name.equals("stop")) {
				break;
			}
			int id=s.nextInt();
			Person pp=new Person(name, id);  //Person클래스 객체 생성 //가영 123

			if(a.contains(pp)) {  //리스트에 있는 객체인지 아닌지의 여부
				System.out.println(pp.getName()+"은 이미 있다");
			}
			else {
				a.add(pp);
			}
		}
	} //어레이리스트에 값을 저장함

	void out() {
		while(true) {
			Random r=new Random();
			int n=r.nextInt(a.size());
			//0~4 사이의 난수 발생시켜서 n에 저장
			Person p=a.get(n);
			String str=p.getName();

			System.out.println(str+"의 id는?");  //성민의 id는?
			int id=p.getId();  //112

			Scanner s=new Scanner(System.in);
			int id2=s.nextInt();

			if(id2==-1) {
				break;
			}
			if(id2==id) {
				System.out.println("정답");
			}
			else
				System.out.println("정답아님");
		}
	}
	void end() {
		System.out.println("종료");
		System.exit(0);  //프로그램 종료(현재 실행하고 있는 프로세스를 강제 종료시킴)
	}
}
public class Test {
	public static void main(String[] args)  {

		Game g=new Game();
		Scanner s=new Scanner(System.in);

		while(true) {
			System.out.println("1,2,3");
			int select=s.nextInt();
			switch(select) {
			case 1:
				g.in();
				break;
			case 2:
				g.out();
				break;
			case 3:
				g.end();
				break;
			}
		}
	}
}

콘솔창에 입력한 문자열 파일에 저장

import java.io.*;
public class Test {
	public static void main(String[] args) {

		//콘솔창에 문자를 입력해서 입력한 문자를
		//파일에 저장
		BufferedReader bu=null;  //입력하기 위한 문자형 입력 스트림
		PrintWriter pr=null;     //출력하기 위한 문자형 출력 스트림

		try {
			InputStreamReader in= new InputStreamReader(System.in);
			bu=new BufferedReader(in);
			//콘솔에 입력!
			//BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
			FileWriter fw= new FileWriter("d.txt");
			//d.txt에 저장

			pr=new PrintWriter(fw);

			String str=null;
			while((str=bu.readLine())!=null) {
				pr.println(str);
			}
			bu.close();
		}catch(Exception e) {}
		finally {
			pr.close();
		}
	}
}

이 문자열을 test01.txt 파일에 저장해라. Hi 저는 자바를 좋아하고 잘합니다. 앞으로 더 열심히 공부할 것입니다.

public class Test {
	public static void main(String[] args) throws Exception {

		FileWriter fw = new FileWriter("text01.txt");
		BufferedWriter out = new BufferedWriter(fw);

		out.write("Hi\n");
		out.write("저는 자바를 좋아하고 잘합니다.\n");
		out.write("앞으로 더 열심히 공부할 것입니다\n");
		out.close();
	}
}

Scanner로 입력 받은 이름(문자열), id(문자열)를 한 줄마다 파일(test02.txt)에 저장해라. “그만” 입력하면 종료. “그만” 입력하기 전까지의 문자열을 파일에 저장해라.(break, FileWriter 사용)

실행 결과) 홍길동 hong

Scanner s = new Scanner(System.in);
BufferedWriter filewriter = new BufferedWriter(new FileWriter("test02.txt"));

try {
	while (true) {
		System.out.println("이름, id 입력. 입력을 끝내려면 '그만'을 입력하세요");
		String name = s.nextLine();
		if (name.equals("그만")) { //name.compareTo("그만")!=0도 가능
			break;
		}
		String id = s.nextLine();
		filewriter.write(name + ", " + id);
		filewriter.newLine();

	}
} catch(Exception e) {
	e.printStackTrace();
}
s.close();
filewriter.close();

test01.txt 파일에 저장한 데이터들을 화면에 출력해라.(FileReader사용, int값으로 초기화해라)

BufferedReader br = new BufferedReader(new FileReader("test01.txt"));

while (true) {
	try {
		int a = br.read();
		System.out.print((char)a); //char로 문자변환을 안하는 경우 숫자로 출력됨
		if (a == -1) {
			break;
		}
	} catch (Exception e) {}
}
br.close();
---------------------------------------
문자단위로 읽기
FileReader f = new FileReader("test01.txt");
int n;

while((n=f.read())!=-1) {
	System.out.println((char)n);
}

Twitter Facebook LinkedIn

Kimsu