디렉터리 생성/ 삭제
mkdirs()
//디렉터리 생성/ 삭제
//경로 구분자
String sep=File.separator;
//File 객체 선언/생성
File dir= new File("C:"+sep+"storage");//C드라이브아래 stroage디렉터리
//C:\storage 디렉터리가 없으면 만들고 있으면 지우기
if(dir.exists()==false)
{
dir.mkdirs();
System.out.println(dir.getPath()+"디렉터리 생성 성공");
}
else {
dir.delete();//지금 바로 지운다
//dir.deleteOnExit(); 자바의 실행이 끝나면 지운다.
System.out.println(dir.getPath()+"디렉터리 삭제 성공");
}
}
파일 생성/삭제
createNewFile()
//파일 생성/삭제
try {
//디렉터리를 File 객체로 생성
File dir=new File("C:/storage");//Windows 플랫폼에서도 슬래시가 인식됨
if(!dir.exists())
{
dir.mkdirs();
System.out.println(dir.getPath()+"디렉터리 생성 성공");
}
//파일을 객체로 생성
File file =new File(dir,"myfile.txt");
//파일이 있으면 지우고 없으면 생성
if(file.exists())
{
file.delete();
System.out.println(file.getPath()+"파일 삭제 성공");
}
else {
file.createNewFile(); //반드시 예외처리를 해야하는 코드(Checked Exception인 IOException 발생)
System.out.println("myfile.txt 파일 생성 완료");
}
}catch (IOException e) {
e.printStackTrace();
}
파일,디렉터리 정보확인
listFiles() : 모든 File 객체를 저장한 File[] 반환
getName() : 이름 반환
getParent() : 저장된 디렉터리 반환
getPath() : getParent() + getName()
lastModified() : 최종수정일을 long 타입으로 반환
length() : 크기를 long 타입의 바이트 단위로 반환
isDirectory() : 디렉터리이면 true 반환
isFile() : 파일이면 true 반환
//디렉터리를 File 객체로 생성
File dir=new File("C:/Program Files/Java/jdk-11");
//디렉터리에 있는 모든 File 객체(파일, 디렉터리) 가져오기
File[] files=dir.listFiles();
//디렉터리에 있는 모든 파일 객체 정보 확인하기
for(int i=0;i<files.length;i++)
{
//개별 File 객체
File file=files[i];
//출력 결과를 저장할 StringBuilder 생성
StringBuilder sb= new StringBuilder();
//File 객체 이름
sb.append(String.format("%-15s",file.getName() ));
//File 객체 최종 수정일
long lastModified=file.lastModified();
String strlastModified=new SimpleDateFormat("yyyy-MM-dd a h:mm").format(lastModified);
sb.append(String.format("%-20s", strlastModified));
long size= file.isFile()?file.length():0;//파일은 바이트 단위로 저장, 디렉터리면 크기를 표시할 필요없어서0
long kbsize=(size/1024)+(size%1024!=0?1:0);
if(size!=0)
{
sb.append(String.format("%10s",kbsize+"KB"));
}
// StringBuilder 객체를 String 으로 변환
String str=sb.toString();
//출력
System.out.println(str);
}
바이트 기반의 출력 클래스이다.
출력단위
1) int
2) byte[]
FileOutputStream
//디렉터리를 File 객체로 만들기
File dir=new File("C:storage");
if(!dir.exists())
{
dir.mkdirs();
System.out.println(dir.getPath()+"디렉터리가 생성되었습니다.");
}
//파일 객체로 만들기
File file=new File(dir,"ex01.dat");
//파일 출력 스트림 선언
FileOutputStream fout=null;
try {
//파일 출력 스트림 생성
//1.생성모드: 언제나 새로 만든다(덮어쓰기) new FileOutputStream(file)
//2. 추가모드: 새로만들거나. 기존 파일에 추가한다. new FileOutputStream(file,true)
fout= new FileOutputStream(file);
int c='A';
String s="pple";
byte[] b= s.getBytes();// byte[] : String 을 byte[]로 변환
//출력
fout.write(c);
fout.write(b);
}catch (IOException e) {
e.printStackTrace();
}finally {
try {
if(fout !=null)
{
fout.close();//출력스트림은 반드시 닫아줘야함.(반드시 예외처리가 필요한 코드)
}
}catch (IOException e) {
e.printStackTrace();
}
}
//디렉토리 파일객체로 만들기
File dir= new File("C:/storage");
if(!dir.exists())
{
dir.mkdirs();
System.out.println(dir.getPath()+"디렉토리가 생성됐습니다");
}
//파일을 파일객체로 만들기
File file =new File(dir,"ex02.dat");
//파일 스트림 선언
FileOutputStream fout=null;
try {
//파일 스트림 생성(반드시 예외처리가 필요)
fout=new FileOutputStream(file);
String s="파일스트림생성";
byte[]b=s.getBytes("UTF-8"); //String 을 byte[]로 변환
//출력
fout.write(b);
}
catch (IOException e) {
e.printStackTrace();
}finally {
try {
if(fout!=null)
{
fout.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
1.int,double,Strng 등의 변수를 그대로 출력하는 출력스트림이다.
2.보조 스트림이므로 메인스트림과 함께 사용한다.
//디렉토리 File 객체로 만들기
File dir =new File("C:/storage");
if(!dir.exists()) {
dir.mkdirs();
}
//파일을 File 객체로 만들기
File file =new File(dir,"ex04.dat");
//데이터출력스트림 선언
DataOutputStream dout=null;
try {
//데이터출력스트림 생성(반드시 예외처리 필요)
dout=new DataOutputStream(new FileOutputStream(file));
//출력할 데이터 (파일로 보낼 데이터)
String name="tom";
int age=50;
double height=180.5;
String school="가산대학교";
//출력(파일로 데이터 보내기)
dout.writeChars(name);// dout.writeChar('t'), dout.writeChar('o'), dout.writeChar('m')
dout.writeInt(age);
dout.writeDouble(height);
dout.writeUTF(school);
System.out.println(file.getPath()+"파일크기:"+file.length()+"바이트"
);
}catch (IOException e) {
}finally {
try {
if(dout!=null)
{
dout.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
1.객체를 그대로 출력하는 출력스트림이다.
2. 직렬화(Serializable)된 객체를 보낼 수 있다.
3. 보조스트림이므로 메인스트림과 함께 사용한다.
직렬화(Serializable) 처리하기
1. java.io.Serializable 인터페이스를 구현 (implements) 한다.
2. long serialVersionUID 필드 값을 생성(generate)한다.
// 디렉터리를 File 객체로 만들기
File dir = new File("C:/storage");
if(!dir.exists()) {
dir.mkdirs();
}
// 파일을 File 객체로 만들기
File file = new File(dir, "ex05.dat");
// 객체출력스트림 선언
ObjectOutputStream oout = null;
try {
// 객체출력스트림 생성 (반드시 예외 처리가 필요한 코드)
oout = new ObjectOutputStream(new FileOutputStream(file));
// 출력할 데이터(파일로 보낼 데이터)
String name = "tom";
int age = 50;
double height = 180.5;
String school = "가산대학교";
Student student = new Student(name, age, height, school);
// 출력(파일로 데이터 보내기)
oout.writeObject(student);
System.out.println(file.getPath() + " 파일 크기 : " + file.length() + "바이트");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(oout != null) {
oout.close(); // 출력스트림은 반드시 닫아줘야 함 (반드시 예외 처리가 필요한 코드)
}
} catch (IOException e) {
e.printStackTrace();
}
}
int read() 메소드
1. 1개 데이터를 읽어서 반환한다.
2. 읽은 내용이 없으면 -1을 반환한다.
1)int
// 디렉터리를 File 객체로 만들기
File dir = new File("C:/storage");
// 파일을 File 객체로 만들기
File file = new File(dir, "ex01.dat");
// 파일입력스트림 선언
FileInputStream fin = null;
try {
// 파일입력스트림 생성 (반드시 예외 처리 필요, 파일이 없으면 예외 발생)
fin = new FileInputStream(file);
// 입력된 데이터 저장 변수
int c = 0;
// 입력된 데이터를 누적할 StringBuilder 생성
StringBuilder sb = new StringBuilder();
// int read() 메소드
// 1. 1개 데이터를 읽어서 반환한다.
// 2. 읽은 내용이 없으면 -1을 반환한다.
// 반복문 : 읽은 내용이 -1이 아니면 계속 읽는다.
while( (c = fin.read()) != -1 ) {
sb.append((char)c);
}
// 결과 확인
System.out.println(sb.toString());
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(fin != null) {
fin.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
2)byte[]
// 바이트 기반 스트림은 원래 한글 처리가 안 된다.
// 디렉터리를 File 객체로 만들기
File dir = new File("C:/storage");
// 파일을 File 객체로 만들기
File file = new File(dir, "ex02.dat");
// 파일입력스트림 선언
FileInputStream fin = null;
try {
// 파일입력스트림 생성 (반드시 예외 처리 필요, 파일이 없으면 예외 발생)
fin = new FileInputStream(file);
// 입력된 데이터 저장 변수
byte[] b = new byte[4]; // 임의로 크기 설정(최대 4바이트 입력 가능)
// 실제로 읽은 바이트 수 저장 변수
int readByte = 0;
// 입력된 데이터를 누적할 StringBuilder 생성
StringBuilder sb = new StringBuilder();
// int read(byte[] b) 메소드
// 1. 파라미터로 전달된 byte[] b에 읽은 내용을 저장한다.
// 2. 실제로 읽은 바이트 수를 반환한다.
// 3. 읽은 내용이 없으면 -1을 반환한다.
// 반복문 : read()의 반환값이 -1이 아니면 계속 읽는다.
while( (readByte = fin.read(b)) != -1 ) {
sb.append(new String(b, 0, readByte)); // 배열 b의 인덱스 0부터 readByte개 데이터를 String으로 변환한다.
}
/*
* 15바이트 "abcdefghijklmno"를 4바이트씩 읽는 방식
*
* byte[] b readByte new String(b, 0, readByte)
*
* 1차 Loop
* ┌---------------┐
* │ a | b | c | d │ 4 배열 b의 인덱스 0부터 4개 데이터를 String으로 변환한다.
* └---------------┘
* 2차 Loop
* ┌---------------┐
* │ e | f | g | h │ 4 배열 b의 인덱스 0부터 4개 데이터를 String으로 변환한다.
* └---------------┘
* 3차 Loop
* ┌---------------┐
* │ i | j | k | l │ 4 배열 b의 인덱스 0부터 4개 데이터를 String으로 변환한다.
* └---------------┘
* 4차 Loop
* ┌---------------┐
* │ m | n | o | l │ 3 배열 b의 인덱스 0부터 3개 데이터를 String으로 변환한다.
* └---------------┘
* ↑
* └---- 이전 Loop에서 읽은 데이터이므로 사용하면 안 된다.
*/
// 결과 확인
System.out.println(sb.toString());
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(fin != null) {
fin.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
내부 버퍼를 가지고 있는 입력스트림이다.
많은 데이터를 한 번에 입력받기 때문에 속도 향상을 위해서 사용한다.
보조스트림이므로 메인스트림과 함께 사용한다.
// 디렉터리를 File 객체로 만들기
File dir = new File("C:/storage");
// 파일을 File 객체로 만들기
File file = new File(dir, "ex03.dat");
// 버퍼입력스트림 선언
BufferedInputStream bin = null;
try {
// 버퍼입력스트림 생성 (반드시 예외 처리 필요, 파일이 없으면 예외 발생)
bin = new BufferedInputStream(new FileInputStream(file));
// 입력된 데이터 저장 변수
byte[] b = new byte[4]; // 임의로 크기 설정(최대 4바이트 입력 가능)
// 실제로 읽은 바이트 수 저장 변수
int readByte = 0;
// 입력된 데이터를 누적할 StringBuilder 생성
StringBuilder sb = new StringBuilder();
// int read(byte[] b) 메소드
// 1. 파라미터로 전달된 byte[] b에 읽은 내용을 저장한다.
// 2. 실제로 읽은 바이트 수를 반환한다.
// 3. 읽은 내용이 없으면 -1을 반환한다.
// 반복문 : read()의 반환값이 -1이 아니면 계속 읽는다.
while( (readByte = bin.read(b)) != -1 ) {
sb.append(new String(b, 0, readByte)); // 배열 b의 인덱스 0부터 readByte개 데이터를 String으로 변환한다.
}
// 결과 확인
System.out.println(sb.toString());
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(bin != null) {
bin.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
DataOutputStream과 DataInputStream을 사용하면
바이트 기반 입출력에서도 한글 처리가 가능하다.(writeUTF, readUTF 메소드 이용)
// 디렉터리를 File 객체로 만들기
File dir = new File("C:/storage");
// 파일을 File 객체로 만들기
File file = new File(dir, "ex04.dat");
// 데이터입력스트림 선언
DataInputStream din = null;
try {
// 데이터입력스트림 생성 (반드시 예외 처리 필요, 파일이 없으면 예외 발생)
din = new DataInputStream(new FileInputStream(file));
// 순서대로 입력 받기
char ch1 = din.readChar(); // 't'
char ch2 = din.readChar(); // 'o'
char ch3 = din.readChar(); // 'm'
int age = din.readInt(); // 50
double height = din.readDouble(); // 180.5
String school = din.readUTF(); // 가산대학교
// 결과 확인
System.out.println("" + ch1 + ch2 + ch3);
System.out.println(age);
System.out.println(height);
System.out.println(school);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(din != null) {
din.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
// 디렉터리를 File 객체로 만들기
File dir = new File("C:/storage");
// 파일을 File 객체로 만들기
File file = new File(dir, "ex05.dat");
// 객체입력스트림 선언
ObjectInputStream oin = null;
try {
// 객체입력스트림 생성 (반드시 예외 처리 필요, 파일이 없으면 예외 발생)
oin = new ObjectInputStream(new FileInputStream(file));
// 객체 순서대로 입력 받기
Student s = (Student)oin.readObject();
// 결과 확인
System.out.println(s);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
} finally {
try {
if(oin != null) {
oin.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
// 디렉터리를 File 객체로 만들기
File dir = new File("C:/storage");
if(dir.exists() == false) {
dir.mkdirs();
}
// 파일을 File 객체로 만들기
File file = new File(dir, "ex01.txt");
// 파일출력스트림 선언
FileWriter fw = null;
try {
// 파일출력스트림 생성(반드시 예외 처리가 필요한 코드)
// 1. 생성모드 : 언제나 새로 만든다.(덮어쓰기) new FileWriter(file)
// 2. 추가모드 : 새로 만들거나, 기존 파일에 추가한다. new FileWriter(file, true)
fw = new FileWriter(file);
// 출력할 데이터(파일로 보낼 데이터)
int c = 'H';
char[] cbuf = {'e', 'l', 'l', 'o'};
String str = " world";
// 출력(파일로 데이터 보내기)
fw.write(c);
fw.write(cbuf);
fw.write(str);
// 메시지
System.out.println(file.getPath() + " 파일 생성 완료");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(fw != null) {
fw.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
내부 버퍼를 가지고 있는 출력스트림이다.
많은 데이터를 한 번에 출력하기 때문에 속도 향상을 위해서 사용한다.
보조스트림이므로 메인스트림과 함께 사용한다.
2)char[]
// 디렉터리를 File 객체로 만들기
File dir = new File("C:/storage");
if(dir.exists() == false) {
dir.mkdirs();
}
// 파일을 File 객체로 만들기
File file = new File(dir, "ex02.txt");
// 버퍼출력스트림 선언
BufferedWriter bw = null;
try {
// 버퍼출력스트림 생성(반드시 예외 처리가 필요한 코드)
bw = new BufferedWriter(new FileWriter(file));
// 출력할 데이터(파일로 보낼 데이터)
String str1 = "Hello";
String str2 = "world";
// 출력(파일로 데이터 보내기)
bw.write(str1, 0, 4); // 문자열 str1의 인덱스 0부터 4글자만 출력
bw.newLine(); // 줄 바꿈(bw.write("\n")과 동일하다.) BufferedWriter 클래스의 전용 메소드이다.
bw.write(str2);
// 메시지
System.out.println(file.getPath() + " 파일 생성 완료");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(bw != null) {
bw.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
print() 메소드와 println() 메소드를 지원하는 출력스트림이다.
println() 메소드를 사용하면 자동으로 줄 바꿈이 처리된다.
서버가 클라이언트에게 데이터를 전송할 때 사용하는 기본 Writer이다.
3)String
// 디렉터리를 File 객체로 만들기
File dir = new File("C:/storage");
if(dir.exists() == false) {
dir.mkdirs();
}
// 파일을 File 객체로 만들기
File file = new File(dir, "ex03.txt");
// PrintWriter 선언
PrintWriter out = null;
try {
// PrintWriter 생성(반드시 예외 처리가 필요한 코드)
out = new PrintWriter(file);
// 출력할 데이터(파일로 보낼 데이터)
String str1 = "Hello";
String str2 = "world";
// 출력(파일로 데이터 보내기)
out.println(str1);
out.println(str2);
// 메시지
System.out.println(file.getPath() + " 파일 생성 완료");
} catch (IOException e) {
e.printStackTrace();
} finally {
if(out != null) {
out.close(); // try 체크를 하지 않는 PrintWriter 클래스의 close() 메소드
}
}
문자 기반의 입력스트림이다.
입력 단위
1) int
2) char[]
3) String
1)int
// 디렉터리를 File 객체로 만들기
File dir = new File("C:/storage");
// 파일을 File 객체로 만들기
File file = new File(dir, "ex01.txt");
// 파일입력스트림 선언
FileReader fr = null;
try {
// 파일입력스트림 생성(반드시 예외 처리 필요, 파일이 없으면 FileNotFoundException 발생)
fr = new FileReader(file);
// 입력된 문자 저장 변수
int ch = 0;
// 입력된 문자를 누적할 StringBuffer 생성
StringBuffer sb = new StringBuffer();
// read() 메소드
// 1. 1개 문자를 읽어서 반환한다.
// 2. 읽은 문자가 없으면 -1을 반환한다.
// 반복문 : 읽은 문자가 -1이 아니면 계속 읽는다.
while((ch = fr.read()) != -1) {
sb.append((char)ch);
}
// 결과 확인
System.out.println(sb.toString());
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(fr != null) {
fr.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
2)char[]
// 디렉터리를 File 객체로 만들기
File dir = new File("C:/storage");
// 파일을 File 객체로 만들기
File file = new File(dir, "ex02.txt");
// 파일입력스트림 선언
FileReader fr = null;
try {
// 파일입력스트림 생성(반드시 예외 처리 필요, 파일이 없으면 FileNotFoundException 발생)
fr = new FileReader(file);
// 입력된 문자 저장 배열
char[] cbuf = new char[2];
// 실제로 읽은 글자 수 저장 변수
int readChar = 0;
// 입력된 문자를 누적할 StringBuffer 생성
StringBuffer sb = new StringBuffer();
// int read(char[] cbuf) 메소드
// 1. 파라미터로 전달된 char[] cbuf에 읽은 문자를 저장한다.
// 2. 실제로 읽은 글자 수를 반환한다.
// 3. 읽은 문자가 없으면 -1을 반환한다.
// 반복문 : read()의 반환값이 -1이 아니면 계속 읽는다.
while((readChar = fr.read(cbuf)) != -1) {
sb.append(cbuf, 0, readChar); // 배열 cbuf의 인덱스 0부터 readChar개 문자를 sb에 추가한다.
}
// 결과 확인
System.out.println(sb.toString());
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(fr != null) {
fr.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
3)String
내부 버퍼를 가지고 있는 입력스트림이다.
많은 데이터를 한 번에 입력받기 때문에 속도 향상을 위해서 사용한다.
보조스트림이므로 메인스트림과 함께 사용한다.
// 디렉터리를 File 객체로 만들기
File dir = new File("C:/storage");
// 파일을 File 객체로 만들기
File file = new File(dir, "ex03.txt");
// 버퍼입력스트림 선언
BufferedReader br = null;
try {
// 버퍼입력스트림 생성(반드시 예외 처리 필요, 파일이 없으면 FileNotFoundException 발생)
br = new BufferedReader(new FileReader(file));
// 입력된 문자열 저장 변수
String line = null;
// 입력된 문자를 누적할 StringBuffer 생성
StringBuffer sb = new StringBuffer();
// String readLine() 메소드
// 1. 한 줄 전체를 반환한다.
// 2. 읽은 문자가 없으면 null을 반환한다.
// 반복문 : readLine()의 반환값이 null이 아니면 계속 읽는다.
while((line = br.readLine()) != null) {
sb.append(line + "\n"); // 읽은 라인에 줄 바꿈(\n)은 포함되어 있지 않다.
}
// 결과 확인
System.out.println(sb.toString());
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(br != null) {
br.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
바이트 출력스트림으로 보낸 문자를 바이트 입력스트림으로 읽기(한글 실패)
바이트 출력스트림으로 보낸 문자를 문자 입력스트림으로 읽기(한글 성공)
// 1단계. 바이트 출력스트림으로 문자 보내기
File dir = new File("C:/storage");
if(dir.exists() == false) {
dir.mkdirs();
}
File file = new File(dir, "server.dat");
BufferedOutputStream bout = null;
try {
bout = new BufferedOutputStream(new FileOutputStream(file));
String s1 = "안녕하세요";
String s2 = "Hello";
bout.write(s1.getBytes("UTF-8"));
bout.write(s2.getBytes("UTF-8"));
bout.close();
} catch (IOException e) {
e.printStackTrace();
}
// 2단계. 문자 입력스트림으로 읽기
/*
* java.io.InputStreamReader 클래스
* 1. Reader 클래스를 상속 받는 클래스이다. (문자 입력스트림이다.)
* 2. InputStream(바이트 입력스트림)을 받아서 Reader(문자 입력스트림)으로 변환한다.
*/
BufferedReader br = null;
try {
br = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
String line = null;
StringBuffer sb = new StringBuffer();
while((line = br.readLine()) != null) {
sb.append(line + "\n");
}
System.out.println(sb.toString());
br.close();
} catch (IOException e) {
e.printStackTrace();
}
사용한 자원(대표적으로 입출력 스트림)을 자동으로 close 해 주는 try문이다.
형식
try (입출력 스트림 생성) {
코드
} catch(Exception e) {
e.printStackTrace();
}
예시)
// 디렉터리를 File 객체로 생성
File dir = new File("C:/storage");
if(dir.exists() == false) {
dir.mkdirs();
}
// 파일을 File 객체로 생성
File file = new File(dir, "ex01.txt");
// try 블록에서 출력스트림 생성하기
try (BufferedWriter bw = new BufferedWriter(new FileWriter(file, true))) { // 추가모드
// 출력할 데이터
String str1 = "안녕하세요";
String str2 = "반갑습니다";
// 출력 (추가모드이므로 기존 파일 뒤에 추가된다.)
bw.newLine();
bw.write(str1);
bw.newLine();
bw.write(str2);
System.out.println(file.getPath() + " 파일에 데이터 추가 완료");
} catch (IOException e) {
e.printStackTrace();
}
}
관련 예제