1) Iterator (반복자) Enumeration
2) stack 과 Queue
3) 입출력 스트림
텍스트가 아닌 파일은 반드시 FileInputStream , FileOutputStream 이용
1) Iterator (반복자) Enumeration
* Iterator 인터페이스 : 반복자
ITerator() : Collection 객체는 Iterator 객체로 변환이 가능함
주요메서드
boolean HasNext() : 조회할요소가있는가
Object next(); ㅣ 조회대상 객체리턴
void remove(); : 조회된 객체를 제거 . next() 실행 이후에가능
public class IterartorEx1 {
public static void main(String[] args) {
Iterator<Object> it = null;
ArrayList<Object> list = new ArrayList<Object>();
HashSet<Object> set = new HashSet<Object>();
for (int i = 1; i <= 5; i++) {
list.add(i+10);
set.add(i*10);
}
System.out.println("print 이전의 list : "+list);
System.out.println("print 이전의 set : "+set);
it = list.iterator(); //Collection의 하위만 사용가능
print(it);
it = set.iterator();
print(it);
System.out.println("print 이후의 list : "+list);
System.out.println("print 이후의 set : "+set);
}
private static void print(Iterator<Object> e ) {
while(e.hasNext()) {
//다음 조회 할 대상이 있니?
System.out.print(e.next()+",");
//조회대상 객체반환
e.remove();
//조회된 객체 삭제
}System.out.println();
}
}print 이전의 list : [11, 12, 13, 14, 15]
print 이전의 set : [50, 20, 40, 10, 30]
11,12,13,14,15,
50,20,40,10,30,
print 이후의 list : []
print 이후의 set : []
Enumeration 인터페이스 :
Iterator 이전의 반복자 Hashtable , Vector에서만 사용가능
메서드
boolean hasNextElement() : 조회요소가 있는가
Object nextElement : 조회 대상 객체 리턴
package ex4_Iterator;
import java.util.Enumeration;
import java.util.List;
import java.util.Vector;
public class EnumerationEx1 {
public static void main(String[] args) {
// List<Object> fruits = new Vector<>();
Vector<Object> fruits = new Vector<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Cherry");
fruits.add("Mango");
Enumeration<Object> e = fruits.elements();
//elements() : Vector클래스의 멤버 ( ArrayList등은 사용할수없음)
System.out.println("과일 목록 : ");
print(e);
}
private static void print(Enumeration<Object> e) {
while(e.hasMoreElements()) {
System.out.print(e.nextElement()+",");
}System.out.println();
}
}과일 목록 :
Apple,Banana,Cherry,Mango,
2) Stack 과 Queue
* stack : LIFO( last in first out)
stack 클래스 : Vector 클래스의 하위클래스 List객체
주요메서드 :
push(Object o ) : 객체를 Stack에추가
Object pop() : 객체를 stack에서 꺼내기
Object peek() : Stack에서 다음에 꺼낼 데이터를 조회
* queue : FIFO( firsti in First out)
인터페이스 LinkedList가 구현클래스임List객체
offer(Object o ) : 넣기
Object poll() : 꺼내기
Object peek() : 객체조회
* Deque : (ArrayDeque , LinkedList) 성능과 간편함을 잡음
양쪽으로 데이터를 입력하고 출력할 수 있으므로,
스택과 큐의 역할을 모두 수행할 수 있다.
Deque 를 Stack 과 Queue 로 사용하기 위한 메서드 이름까지 제공한다.
offerFirst() : 앞에 추가한다.
offerLast() : 뒤에 추가한다.
pollFirst() : 앞에서 꺼낸다.
pollLast() : 뒤에서 꺼낸다. == pop()
public class StackQueueEx1 {
public static void main(String[] args) {
String [] cars = {"Sonata","grandeur","K5","G80"};
Stack<Object> stack = new Stack<>();
Queue<Object> queue = new LinkedList<>();
ArrayDeque<Object> deque = new ArrayDeque<>();
for (String c : cars) {
stack.push(c);
queue.offer(c);
deque.offer(c);
}
System.out.println("스택에 저장된 객체의 갯수 "+stack.size());
System.out.println("큐에 저장된 객체의 갯수 "+queue.size());
System.out.println("데크에 저장된 객체의 갯수 "+deque.size());
System.out.println("stack:"+stack);
System.out.println("queue:"+queue);
System.out.println("deque:"+deque);
System.out.println("--다음에 꺼낼 데이터 조회--");
//queue와 deque는 앞에서 꺼냄
System.out.println(stack.peek());
System.out.println(queue.peek());
System.out.println(deque.peekLast());
System.out.println("--------------");
//꺼낼 데이터조회만 하는거임 객체의변동X
System.out.println(stack.pop());
System.out.println(queue.poll());
System.out.println(deque.pollLast());//마지막에넣은걸 뺴
System.out.println("스택에 저장된 객체의 갯수 : "+stack.size());
System.out.println("큐에 저장된 객체의 갯수 : "+queue.size());
System.out.println("데크에 저장된 객체의 갯수 : "+deque.size());
}
}스택에 저장된 객체의 갯수 4
큐에 저장된 객체의 갯수 4
데크에 저장된 객체의 갯수 4
stack:[Sonata, grandeur, K5, G80]
queue:[Sonata, grandeur, K5, G80]
deque:[Sonata, grandeur, K5, G80]
--다음에 꺼낼 데이터 조회--
G80
Sonata
G80
--------------
G80
Sonata
G80
스택에 저장된 객체의 갯수 : 3
큐에 저장된 객체의 갯수 : 3
데크에 저장된 객체의 갯수 : 3
3) 입출력스트림
출력스트림 : 외부로데이터전송
입력스트림 : 외부데이터 읽기
| 입출력스트림 (IO Stream) |
입력 | 바이트 | 바이트형입력 | InputStream , FileInputStream (System.in)은 InputStream타입 |
| ↑(X) | ↓ InputStramReader | ||||
| 문자 | 문자형입력 |
Reader FileReader |
||
| 출력 | 바이트 | 바이트 출력 | OutputStream FileOutPutStream System.out 은 바이트형출력 |
|
| ↑(X) | ↓ OutputStreamWriter | ||||
| 문자 | 문자형 출력 | Writer FileWrite |
||
상속여부는 맨뒤에글자를 확인하자
OutputStreamWriter 는 문자형출력Writer의 자식
* 입출력 스트림 : 데이터의 이동통로 . 단방향 추상클래스
* 입력스트림 : 바이트--> 바이트형 입력스트림 : InputStream
* 1byte 단위로읽기
* 동영상 , 이미지 ,텍스트등을 읽기
* 문자형 --> 문자형 입력스트림 : Reader
* 2byte (1char) 단위로읽기
* 텍스트데이터 읽기
* 출력스트림 : 바이트-->바이트형 출력스트림 : OutputSteam
* 1bye 단위로 쓰기
* 동영상 이미지 텍스트 등을 쓰기
* 문자형--> 문자형 출력스트림 : Writer
* 2byte(1char) 단위로 쓰기
* 텍스트데이터 쓰기
* InputStreamReader : 바이트형 입력 스트림 -> 문자형 입력스트림 변경 Reader 하위클래스
* OutPutStreamWriter : 바이트형 출력스트림 -> 문자형 출력스트림 변경 Writer 하위클래스
* 자바에서 제공되는 표준 입출력스트림
* 표준입력 스트림 : InputStream System.in --> 키보드에서 입력
* 표준출력 스트림 : printStream System.out : 콘솔(화면)으로출력
* 표준오류스트림 : PrintStream System.err ==> 콘솔(화면)으로 출력 , 빨간색 출력
1 ) 입력스트림(InputStream , Reader)
(IOException 을 던지든 잡든 해야함)
public class InputSteamEx1 {
public static void main(String[] args) throws IOException{
InputStream in = System.in;// 키보드입력
int data=0;
//in.read() : 1byte 씩 읽기
while((data=in.read()) != -1) {//ctrl+z (EOF) : 더이상안한다고판단
System.out.print((char)data+" ");
}
}
}
/*
1234
1 2 3 4
rk
r k
가나다라
ê ° ë ë ¤ ë ¼
*/
//--------------문자형입력---------------
public class ReaderEx1 {
public static void main(String[] args) throws IOException {
//InputStreamReader : InputStream객체를 Reader로 변경 스트림
Reader in = new InputStreamReader(System.in);
int data=0;
//in.read : 2byte단위로읽어 (한글같은 char형의 데이터도 문제없이 읽어냄)
while((data = in.read()) != -1) {
System.out.print((char)data);
}
}
}
/*
avc
avc
가나다라
가나다라
*/
2 ) 출력스트림(OutputStream , Writer)
public class OutputStreamEx1 {
public static void main(String[] args) throws IOException {
//OutputStream : 바이트형 출력
OutputStream out = System.out;
out.write('1');out.write('2');out.write('3');
out.write('a');out.write('b');out.write('c');
out.write('가');out.write('나');out.write('다');//내가보내는 부분
//1byte씩만 출력되기때문에 한글이 깨질거다
out.flush();//버퍼의 내용을 강제로 목적지(화면)로보내는 메서드
}
}
/*
* OutputStreamEx1 의 데이터를 한글도 꺠지지않도록 프로그램수정
* OutputStreamWriter 클래스이용
*/
public class Exam1_Writer {
public static void main(String[] args) throws IOException{
Writer out = new OutputStreamWriter(System.out);
out.write('1');out.write('2');out.write('3');
out.write('a');out.write('b');out.write('c');
out.write('가');out.write('나');out.write('다');//내가보내는 부분 2byte씩 보냄
out.flush();//한글이깨지지않음
}
}
3 ) FileInputStream (입력)
* FileInputStream : 파일내용 읽어 화면에출력 (바이트단위)
*
* 주요메서드
* int read() : 1바이트읽어서 내용을 리턴
* int read(byte[] buf) : buf의 크기만큼 읽어서 내용을 buf에 저장.읽은 바이트 수를 리턴해줌
* int read(byte[] buf,int start, int len) :
* len의크기만큼읽어서 buf의 start인덱스 부터 내용을 buf에 저장.읽은 바이트 수를 리턴해줌
*
* int available() : 읽기 가능 바이트 수 return
package ex3_file;
import java.io.FileInputStream;
import java.io.IOException;
public class FileInputStreamEx1 {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("src\\ex1\\InputStream\\GG.java");
int data = 0;
System.out.println("======= read() 메서드를 이용해 읽기");
while((data=fis.read()) != -1) {
System.out.print((char)data);
//읽을때 1byte씩 읽으므로 파일이 좀 많이깨지는 현상!!
}
System.out.println("=====read(byte[]) 메서드이용해 읽기 ====");
fis = new FileInputStream("src\\ex1\\InputStream\\GG.java");
//다른패키지 or 다른경로상에있는 파일을 불러오려면 전체경로를 입력하자
//ex) D:/java/Java_study/chap12/src/test_ListSet/Gd.java
byte[] buf = new byte[fis.available()];
System.out.println("fis.available()"+fis.available());
//fis.available() 읽기가능 바이트수
//100바이트짜리 파일을 읽지 않은 경우 100
//100바이트짜리 파일중 1바이트를 읽은경우 99
while((data=fis.read(buf)) != -1) {
//fis.read(buf) : fis에서 buf만큼 읽어서 읽은내용은 buf저장 , 실제읽은크기를 리턴
//data : 실제읽은 바이트 수
System.out.print(new String(buf,0,data));
System.out.println("@@ data @@ "+data);//1695
//new String(buf,0,data) : buf에 0번인덱스부터 data의크기만큼 문자열객체로생성
//buf로 읽어낸다면 한번에 읽어내기때문에 훨씬성능이좋음
}
System.out.println("=======read(byte[],int,int) 메서드 이용 ====");
fis = new FileInputStream("src\\ex1\\InputStream\\GG.java");
buf = new byte[fis.available()+1];
buf[0]='Z';
while((data=fis.read(buf,1,buf.length-1)) != -1) {
System.out.print(new String(buf,0,data));
}
}
}======= read() 메서드를 이용해 읽기
package ex1.InputStream;
public class GG {
//package ex1.InputStream;ì í´ëì¤ì
}
=====read(byte[]) 메서드이용해 읽기 ====
fis.available()97
package ex1.InputStream;
public class GG {
//package ex1.InputStream;의 클래스임
}
@@ data @@ 97
=======read(byte[],int,int) 메서드 이용 ====
Zpackage ex1.InputStream;
public class GG {
//package ex1.InputStream;의 클래스임
}
4 ) FileReader(입력)
텍스트가 아닌 파일은 반드시 FileInputStream , FileOutputStream 이용
* FileReader클래스 : 파일에서 데이터2byte단위로 읽기
*
* int read() : 파일에서 데이터 1char단위로읽기
* int read(char[] buf) : 파일에서 buf크기만큼을 읽어 buf에 내용저장 ,실제읽은 char수 리턴
* int read(char[] buf , int start , int len)"
* 파일에서 len크기만큼 읽어서 buf의 strat인덱스부터 저장 , 실제읽은 char수 리턴
*
* 생성자 : FileNotFoundException(IOException의 하위클래스)예외처리필수
* read() : IOException예외처리필수
|
void close()
|
사용중인 자원을 반납하고, 입력 스트림을 닫는다.
|
package ex3_file;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderEx1 {
public static void main(String[] args) throws IOException {
char[] buf = new char[8000];
int data = 0;
FileReader fr = new FileReader("src\\ex1\\InputStream\\GG.java");
System.out.println("-------read()메서드로 읽기-----");
while((data=fr.read())!= -1) {
System.out.print((char)data);
}
System.out.println("-------read(char[] buf)메서드로 읽기-----");
fr = new FileReader("src\\ex1\\InputStream\\GG.java");
while((data=fr.read(buf))!= -1) {
//buf에서읽은 데이터 수를 data에 넣어
System.out.print(new String(buf,0,data));
}
System.out.println("-------read(char[],int,int)메서드로 읽기-----");
fr = new FileReader("src\\ex1\\InputStream\\GG.java");
while((data=fr.read(buf,0,buf.length))!= -1) {
// fr을 buf의 0번부터 buf의크기만큼 넣어
//넣은 크기 : data
System.out.print(new String(buf,0,data));
System.out.println("data ::::"+data);
}
}
}
-------read()메서드로 읽기-----
package ex1.InputStream;
public class GG {
//package ex1.InputStream;의 클래스임
}
-------read(char[] buf)메서드로 읽기-----
package ex1.InputStream;
public class GG {
//package ex1.InputStream;의 클래스임
}
-------read(char[],int,int)메서드로 읽기-----
package ex1.InputStream;
public class GG {
//package ex1.InputStream;의 클래스임
}
data ::::87
5 ) FileOutputStream(출력)
* FileOutputStream 예제 : 파일에 데이터 저장.
* 주요메서드
* void write(int data): 1byte를 출력.
* void write(byte[] buf): buf의 내용을 출력
* void write(byte[] buf,int start, int len): buf의 start 인덱스 부터 len크기만큼 내용 출력
*
* 생성자 : FileNotFoundException 예외처리 필수. IOException 의 하위 클래스
* => 파일의 생성 권한이 없는 경우 예외 발생.
* write() : IOException 예외처리 필수
|
void close()
|
사용중인 자원을 반납하고, 출력 스트림을 닫는다.
|
package ex3_file;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamEx1 {
public static void main(String[] args) throws IOException {
System.out.println("out.txt 파일에 내용이 저장됩니다.");
// FileOutputStream fos = new FileOutputStream("out.txt");
FileOutputStream fos = new FileOutputStream("out.txt",true);
/*
* fos : out.txt 파일에 내용을 쓸수 있는 바이트형출력스트림
* out.txt 파일이 없으면 out.txt 파일을 생성하여 내용 출력
* out.txt 파일이 있으면 out.txt 파일에 내용 출력. 기존의 내용 사라짐. 최종결과만 출력
*
* new FileOutputStream("out.txt") : out.txt 파일에 내용 출력.최종내용만남음
* new FileOutputStream("out.txt",true) : out.txt 파일에 내용 출력.
* 기존내용에 새로운 내용을 추가함
*/
fos.write('1');fos.write('2');fos.write('3');
fos.write('a');fos.write('b');fos.write('c');
fos.write('가');fos.write('나');fos.write('다');
//String.getBytes() : 문자열을 byte[]로 리턴
byte[] buf = "\nFileOutputStream 예제입니다.\n".getBytes();
fos.write(buf); //buf의 내용을 out.txt파일에 출력
fos.write(buf,5,6); //buf의 내용 중 5번인덱스부터 6개의 바이트를 출력
fos.flush();
}
}
6 ) FileWriter ( 출력 )
텍스트가 아닌 파일은 반드시 FileInputStream , FileOutputStream 이용
* FileWriter 클래스를 이용하여 FileOutputStreamEx1.java의 내용을 out2.txt 파일에 저장하기
* 주요메서드
* void write(int data): 1char를 출력.
* void write(char[] buf): buf의 내용을 출력
* void write(char[] buf,int start, int len): buf의 start 인덱스 부터 len크기만큼 내용 출력
* void write(String str) : str문자열의 내용을 출력
|
void close()
|
사용중인 자원을 반납하고, 출력 스트림을 닫는다.
|
package ex3_file;
import java.io.FileWriter;
import java.io.IOException;
public class Exam1 {
public static void main(String[] args) throws IOException {
System.out.println("out.txt 파일에 내용이 저장됩니다.");
FileWriter fos = new FileWriter("out2.txt",true);
//fos: out2.txt 파일에 내용을 저장 할 수 있는 출력스트림
fos.write('1');fos.write('2');fos.write('3');
fos.write('a');fos.write('b');fos.write('c');
fos.write('가');fos.write('나');fos.write('다');
//char단위로 읽기때문에 한글이깨지지않음
//String.toCharArray : 문자열을 char형 배열로 바꿔줌
char[] buf = "\nFileOutputStream 예제입니다.\n".toCharArray();
fos.write(buf); //buf의 내용을 out.txt파일에 출력
fos.write(buf,5,6); //buf의 내용 중 5번인덱스부터 6개의 바이트를 출력
fos.write("\nFileWrite는 문자열 출력이가능해요!!\n");
fos.flush();
fos.close();
}
}123abc가나다
FileOutputStream 예제입니다.
Output
FileWrite는 문자열 출력이가능해요!!
FileWriter의 write는 1char(2byte)씩
출력하니 한글이 깨지지않음
OutPutSteam, FileWriter(예제)
package ex3_file;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.Scanner;
/*
* 화면에서 exit 값을 입력할때 까지 내용을 입력받아 data.txt 파일에 저장하기
* [결과]
* data.txt 파일에 저장할 내용을 입력하세요(종료:exit)
* aaaa
* bbbb
* exit
*/
public class Exam2 {
public static void main(String[] args) throws IOException {
Scanner scan = new Scanner(System.in);
FileOutputStream fw = new FileOutputStream("data.txt",true);
while(true) {
System.out.print("내용입력 : ");
String next = scan.nextLine();
if(next.equals("exit")) {
break;
}
fw.write((next+"\n").getBytes());
}
fw.close();
//-----------------------
// FileWriter fw = new FileWriter("data.txt");
// while(true) {
// System.out.print("내용입력 : ");
// String next = scan.next();
// if(next.equals("exit")) {
// break;
// }
// fw.write(next);
//Write는 문자열자체를 읽기때문에 byte로변환해줄필요없음
//
// }
// fw.close();
}
}
예제
/*
* InputStreamEx1.java 파일을 읽어서 InputStreamEx1.bak 파일로생성해보자
* FileInputStream클래스로 구현
FileReader로도 구현해보자
*/
package ex3_file;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class Exam3 {
public static void main(String[] args) throws IOException{
FileInputStream fi = new FileInputStream("src\\ex3_file\\FileInputStreamEx1.java");
FileOutputStream fw = new FileOutputStream("InputStreamEx1.bak");
int data=0;
byte [] buf = new byte[fi.available()];
//fi.available() :fi 의 읽기가능한 byte 수
while((data=fi.read(buf))!=-1) {
//fi의내용을 buf에 넣는다
//넣은 숫자를 data에 리턴
fw.write(buf);//fw에 byte단위로 출력
}
fi.close();
fw.flush();
fw.close();
System.out.println("프로그램종료1");
FileReader fr = new FileReader("src\\ex3_file\\GG.java");
Writer w = new FileWriter("GG.bak");
char [] c = new char[2000];
int data2 =0;
while((data2=fr.read(c,0,c.length))!=-1) {
System.out.println("data2 : "+data2);
w.write(c);
}
fr.close();
w.flush();
w.close();
System.out.println("프로그램종료");
}
}
내용이 너무길어 생략!!
예제)
* 화면에서 파일명을 입력받아서 해당 파일의 내용을 화면에 출력하기.
* 만약 파일이 없는 경우는 '해당 파일 없음' 을 출력하기
* 한글은 깨지지 않아야 함.
* FileInputStream 사용하기
잘못된 예)
package test;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) throws IOException {
Scanner scan = new Scanner(System.in);
System.out.println("파일명 입력 : ");
String file = scan.next();
try {
int data=0;
FileInputStream fi = new FileInputStream(file);
while((data=fi.read())!=-1) {
System.out.print((char)data);
}
}
catch(FileNotFoundException e) {
System.out.println("존재하지않는 파일");
}
}
}
FileInputStrema의 fi.read() 는 1byte씩밖에 읽어오지못함
방안 1 , 2)
read(byte[])의 방법을 사용해보고
FileReader를 사용
package test;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) throws IOException {
Scanner scan = new Scanner(System.in);
System.out.println("파일명 입력 : ");
String file = scan.next();
try {
int data=0;
int data2=0;
FileInputStream fi = new FileInputStream(file);
FileReader fr = new FileReader(file);
byte[] buf1 = new byte[fi.available()];//fi의 읽을 수 있는크기의 byte배열
char[] c = new char[3000];
System.out.println("= = = FileInputStream사용 = = =");
System.out.println("FileInputStream.read(byte[] buf)");
while((data=fi.read(buf1))!=-1) {
System.out.print(new String(buf1,0,data));
}
System.out.println("===Reader 사용 ===");
System.out.println("Reader는 char형을 사용함");
while((data2=fr.read(c))!= -1) {
System.out.printf(new String(c,0,data2));
}
}
catch(FileNotFoundException e) {
System.out.println("존재하지않는 파일");
}
}
}파일명 입력 :
D:\java\Java_study\chap13_\data.txt
= = = FileInputStream사용 = = =
FileInputStream.read(byte[] buf)
하이
루
===Reader 사용 ===
Reader는 char형을 사용함
하이
루
파일명 입력 :
g
존재하지않는 파일
FileNotFoundException을 catch해서 예외처리를해줌
예제 2)
2.
bin/ex1_inputstream/InputStreamEx1.class 파일은 이진 파일이다.
이파일을 읽어서 16진수로 출력하기
[결과]
CA FE BA BE 00 00 00 34 00 8E 07 00 02 01 00 17
63 68 61 70 31 35 2F 50 72 69 6E 74 53 74 72 65
61 6D 54 65 73 74 32 07 00 04 01 00 10 6A 61 76
61 2F 6C 61 6E 67 2F 4F 62 6A 65 63 74 01 00 06
3C 69 6E 69 74 3E 01 00 03 28 29 56 01 00 04 43
6F 64 65 0A 00 03 00 09 0C 00 05 00 06 01 00 0F
package test;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
public class Test2 {
public static void main(String[] args) throws IOException {
FileInputStream r = new FileInputStream("bin\\ex1\\InputStream\\InputStreamEx1.class");
int data =0;
int i=0;
while((data = r.read())!= -1) {
++i;
String hexString = Integer.toHexString(data).toUpperCase();
System.out.printf("%3s",hexString+" ");
if(i%16==0) {
System.out.println();
}
}
}
}FileInputStream.read() 를 사용한다면
1바이트씩의 데이터를 읽어 data에 저장할것이다.
그럴때마다 int타입의 data를 Integer.toHexString을 이용해
16진수로 계속 출력해줌
(16번째루프마다 \n )
예제3)
1. 반복문을 이용하여
파일명을 입력받아서 해당 파일이 존재하면 해당파일명.bak 파일 복사하기
파일명에 exit 가 입력되면, 프로그램 종료.
해당 파일이 없으면 해당 파일이 없습니다. 메세지 출력
[결과]
파일명을 입력하세요(종료:exit)
aaa.txt
aaa.txt=>aaa.bak 복사완료
파일명을 입력하세요(종료:exit)
bbb.txt
복사할 파일이 없습니다.
파일명을 입력하세요(종료:exit)
exit
package test;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.util.Scanner;
public class Test3_A {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
while(true) {
System.out.println("파일명을 입력하세요 (종료 exit)");
try {
String file = scan.next();
if(file.equalsIgnoreCase("exit")) {
System.out.println("종료");
break;
}
int lastIndexOf = file.lastIndexOf(".");
if(lastIndexOf==-1) {
System.out.println("확장자가 없어요");
continue;
}
String bak = file.substring(0, lastIndexOf)+".bak";
// String[] split = file.split("\\.");//정규식을 이용해 .을 문자로인식하게해야함
// String bak = split[0]+".bak";//.txt앞의 파일명을 따옴
Reader r =new FileReader(file);
// FileInputStream r = new FileInputStream(file);
int data=0;
char[] a = new char[2000];
// byte[] a = new byte[r.available()];
Writer w = new FileWriter(bak);
// FileOutputStream w = new FileOutputStream(file+".bak");
while((data=r.read(a))!= -1) {
w.write(a,0,data);
}
r.close();
w.flush();
w.close();
System.out.println(file+"--> "+bak+" 복사완료");
} catch (IOException e) {
System.out.println("파일이 없어요");
}
}
}
}try-catch문으로 파일이존재하지 않았을 때
터지는 예외를 잡아주자
1.파일명입력받기
2. 파일명에서 "."의 인덱스를 반환
@없다면
확장자가 잘못됐어요 출력 후
continue(반복문 현재단계종료후 첨부터시작)
@있다면 r = FileReader or FileiInputStream에 넣어주고
".bak"을 추가한 반환값을
w = FileWrite or FileOutputStream 에 집어넣자
4.그 후 read(char[] or byte[])메서드를 이용해 값을 전부 배열에넣어줌
while((data=r.read(a))
그 배열의 0번인덱스부터 data(실제 읽은 수)까지 write해줌
w.write(a,0,data)
r.close , w.flush , w.close 후 복사문을 출력한 후 끝내자
(스트림을사용했다면 항상 닫자)
파일명을 입력하세요 (종료 exit)
dd
파일명을 입력하세요 (종료 exit)
data.txt
data.txt--> data 복사완료
파일명을 입력하세요 (종료 exit)
예제4)
텍스트가 아닌 파일은 반드시 FileInputStream , FileOutputStream 이용
* apple.gif 파일을 읽어서, apple2.gif 파일로 복사하기
* gif같은 파일은 바이너리파일임 (byte로 읽고써야함)
* FileInput , FileOutput 사용하자
(1byte씩 읽고 쓰는 방식)
package test;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOError;
import java.io.IOException;
import java.io.Writer;
public class Test4 {
public static void main(String[] args) throws IOException{
FileInputStream fr = new FileInputStream("D:\\java\\apple.gif");
FileOutputStream w = new FileOutputStream("apple2.gif");
FileOutputStream w2 = new FileOutputStream("apple3.gif");
int data=0;
int data2=0;
byte[] a = new byte[fr.available()];
while((data=fr.read())!= -1) {
w.write(data);
}
fr = new FileInputStream("D:\\java\\apple.gif");
while((data2=fr.read(a,0,a.length))!= -1) {
w2.write(a,0,data2);
}
fr.close();
w.flush();
w2.flush();
w.close();
w2.close();
}
}난 2가지방법을 이용했다
그냥 읽어오는방법 :
read() 의 반환값(data)들을
모두 write(data);
fr 의 읽기 가능한 크기의 byte배열 a 생성
(byte [] a = new byte[fr.available();]
fr.read(a,0,a.length); 로
모든값을 읽어
a배열의 0번인덱스부터a의크기만큼 채워줌
그 후
write(a);
'부트캠프(Java)' 카테고리의 다른 글
| 자바/스프링 부트캠프 18일차( 멀티 스레드) (0) | 2025.02.25 |
|---|---|
| 자바/스프링 부트캠프 17일차( 보조스트림 ,객체직렬화 , 파일) (1) | 2025.02.25 |
| 자바/스프링 부트캠프 15일차( Collection {set , map} ) (0) | 2025.02.20 |
| 자바/스프링 부트캠프 14일차( collection ) (3) | 2025.02.19 |
| 자바/스프링 부트캠프 13일차( API {java.util}) (0) | 2025.02.18 |