InputStream 보다 좀 더 빨리 데이터를 처리 할 수 있는 BufferedReader/Writer

안녕하세요

이번 시간에는 BufferedReader/Writer를 활용하여 좀 더 빨리 데이터를 처리 할 수 있는

예제를 올려봅니다.


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

public class BufferedRedaerTest {

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

InputStream is = System.in;
PrintStream ps = System.out;
//BufferedReader br = new BufferedReader(is); // 1바이트 노드 스트림을 바로 못받음, 그래서 중간 다리스트림을넣어야함
BufferedReader br = new BufferedReader(new InputStreamReader(is));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(ps));


/*int input=0;
// 2byte는 char[]타입 배열에 넣어야 함
char[] buf = new char[100];

while((input=br.read(buf))!=-1){
bw.write(buf, 0, input);
bw.flush();
}*/

// 줄 단위로 입력
String line="";
bw.write("입력하세요=>");
while((line=br.readLine())!=null){
bw.write(line+"\r\n"); // 줄 바꿈을 강제로 넣어줘야 엔터가 됨
bw.newLine(); // 줄 바꿈 (리눅스 운영체제에서 Enter 키가 \n임 / 윈도우 운영체제는 \r\n)
bw.flush();
}

bw.close();
br.close();
is.close();
ps.close();
}

}

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

실행 결과는 이전에 했던 거와 같습니다

InputStreamReader를 활용하여 키보드 입력을 받아 콘솔에 출력 및 파일로 저장

안녕하세요

이번 시간에는 InputStreamReader / OutputStreamWriter를 활용한 예제를 보여드리겠습니다

일단 InputStreamReader / OutputStreamWriter를 설명하자면..

 [1] 2byte 기반 스트림
 [2] Bridge Stream
 - 1byte로 입력받은 데이터를 2byte로 조합하여 읽거나 내보낸다.
 - 1byte 기반 스트림을 2byte 기반 필터 스트림과 중간에 연결해주는 기능을 수행함


아래 예제는 키보드 입력을 받아서 콘솔에 출력하는 예제입니다.

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

public class InputStreamReadertest {

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

InputStreamReader ir = new InputStreamReader(System.in);
OutputStreamWriter ow = new OutputStreamWriter(System.out);

ow.write("입력하세요=>");
ow.flush();

// 배열을 쓰려면 char[] 배열을 활용해야 한다.

int input=0;
while((input=ir.read())!=-1){

ow.write(input);
ow.flush();
}

ir.close(); ow.close();

}

}

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

저 소스 코드를 실행할 때 자바 콘솔 창에서 하는 것보다 도스 창에서 실행하는 것이

더 낫습니다.

소스코드를 실행하려면 해당 프로젝트에 src 폴더가 아닌 bin 디렉토리에 가서

java io,day4.InputStreamReaderTest 명령어를 쳐야 실행이 됩니다

중간에 io.day4는 패키지 명이고 그 안에 InputStreamReaderTest 라는 자바 파일이 있습니다.



InputStreamReader / OutputStreamWriter 를 활용한 두 번째 예제도 올려봅니다.

두 번째 예제는 c:myjava 밑에 utf-8 방식으로 파일을 저장하는 예제입니다.

이것 또한 매우 간단합니다.

하지만 저 같은 경우는 io 입출력 예제를 처음 접하기 때문에 잘 몰라 어렵더군요 ㅜ



public class InputStreamReadertest2 {

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

//2바이트로 읽어서 2바이트로 내보내자
//FileReader fr = new FileReader("C:/MyJava/스트림테스트.txt"); // 글자가 깨짐

FileInputStream fis = new FileInputStream("C:/MyJava/스트림테스트.txt");
InputStreamReader ir = new InputStreamReader(fis, "UTF-8");
OutputStreamWriter ow = new OutputStreamWriter(System.out);

int input=0;
while((input=ir.read())!=-1){
ow.write(input);
ow.flush();
}

fis.close();
ir.close();
ow.close();
}

}

자바에서 디렉토리를 생성하는 방법과 전체공간과 가용공간을 알아보는 메소드 활용

안녕하세요

이번 시간에는 제목이 곧 내용입니다.

자바에서 디렉토리를 생성하고, 삭제하는 방법과

생성된 디렉토리의 전체공간과 가용공간이 얼마인지 알아보는 시간을 가지겠습니다.


이번 내용도 예제에 주석을 달면서 설명하겠습니다~


public class test {

public static void main(String[] args) {

//디렉토리를 만들어보자.
File dir = new File("sample"); //디렉토리명 'sample' 지정
boolean bool=dir.exists();
System.out.println(dir.getName()+"의 존재 여부 : " + bool);
if(!bool){ // 디렉토리가 존재하지 않는다면 생성
boolean b = dir.mkdir(); // 단일 디렉토리 생성
System.out.println("디렉토리 생성 여부 : " + b);
}

//디렉토리와 그 안에 세부 디렉토리를 생성하고 싶을 때
File dir2 = new File("example", "day01"); // example 폴더 안에 day01 폴더 생김
if(!dir2.exists()){
boolean c = dir2.mkdirs(); // 여러 디렉토리 생성 (mkdirs)
System.out.println("디렉토리2 생성 여부 : " + c);
}

//디렉토리 이름 변경 : renameTo(File f) : sample=> sample2로 변경
dir.renameTo(new File("sample2"));

//디렉토리 삭제 : delete()
//해당 디렉토리에 파일이 없을 경우만 삭제한다.

boolean d = dir2.delete();
System.out.println("삭제 여부 : " + d); // example은 삭제 안되고 day01 디렉토리 삭제됨
long tspace = dir.getTotalSpace(); // 디렉토리 전체공간
long uspace = dir.getUsableSpace(); // 가용공간
System.out.println("tspace="+tspace+", uspace="+uspace);

//C:/ 디렉토리 아래 파일 목록을 가져오자.
File dir3 = new File("C:/");
// 두 가지 방법이 있다
//1. String[] list()

String[] files = dir3.list();
if(files!=null){
System.out.println("----------"+dir3.getName());
for(String file : files){
System.out.println(file);
}
}

System.out.println("********************************");

//2. File[] listFiles()
File[] files2 = dir3.listFiles();
if(files2!=null){
System.out.println("---------"+dir3.getName());
for(File file : files2){
System.out.println(file);
}
}
}
}


위의 결과는 아래와 같습니다. 직접 소스를 쳐보고 이해하면서 결과를 이해하면 도움이 될 것 같습니다.

이전에 썼던 예제와 오늘을 썼던 예제를 응용하면 아래와 같은 결과도 나옵니다

결과는 길게 나왔지만 소스는 짧습니다.

public class test {

public static void main(String[] args) {

// C 디렉토리의 파일/DIR 목록을 가져오되 아래와 같이 출력되도록 하세요
// File[] listFiles() 메소드 활용
/* -------------------------------------------
* 파일명 DIR/FILE 여부 파일크기 마지막 수정날짜
* */

File dir = new File("C:/");

File[] files2 = dir.listFiles();
if(files2!=null){

System.out.println("--------------------------------------------------------------------------");
System.out.println("파일명\t\tDIR/FILE\t파일크기\t마지막 수정일");
System.out.println("--------------------------------------------------------------------------");

for(File file : files2){
String fname = file.getName();
String type = (file.isDirectory())?"DIR":"File";
long fsize = file.length();
long time = file.lastModified();
Date date = new Date(time);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
String lastDate = sdf.format(date);

System.out.println(fname + "\t\t\t\t  " + type + "\t\t  " + fsize + "\t  " + lastDate);
}

System.out.println("--------------------------------------------------------------------------");

}


}

}

자바에서 파일의 정보들을 알 수 있는 메소드 예제

안녕하세요

2일만에 블로그를 하게 되네요.

어제는 컴퓨터를 또 포맷할 일이 있어서 재설치 하느라 블로그를 못하게 됬네요


이번 시간에는 자바에서 File 메소드를 활용하여 파일의 정보를 알 수 있는 간단한 예제를

올려봅니다.

잘 봐주세요~!



<1> 첫번째 예제 - 파일의 파일명, 절대경로, 상대경로, 상위 부모 디렉토리, 파일 크기, 파일 여부, 디렉토리 여부, 파일을 마지막으로 수정한 날짜 등의 정보를 알려주자

public class test {

public static void main(String[] args) {

// 상대경로 <-> 절대경로(C:\..)
String fileStr="src/io/day3/FileReaderWriter.java";
File file = new File(fileStr);
// File 클래스의 메소드 활용
print("파일명 : " + file.getName());
print("파일의 절대경로: " + file.getAbsolutePath());
print("파일의 상대경로 : " + file.getPath());
print("상위 부모 디렉토리 : " + file.getParent());
long fsize=file.length();
print("파일 크기 : " + fsize + " bytes");

print("파일 여부 : "+file.isFile());
print("디렉토리 여부 : "+file.isDirectory());
File dir = file.getParentFile();
print(dir+"의 디렉토리 여부 : "+dir.isDirectory());

//파일을 마지막으로 수정한 날짜
//1970년 1월 1일부터 마지막 수정한 날짜까지의 시간을 밀리세컨드 초 (1/1000) 단위로 반환한다.
long time = file.lastModified();
print(String.valueOf(time));

//long형을 Date 형으로 바꾸면 날짜를 읽기 쉽게 바꿀수 있다

Date date = new Date(time);
print(date.toString());

//날짜 포맷
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
//yyyy: 연도 2자리, MM: 월, dd: 일, hh: 시간, mm: 분, ss: 초
String strDate = sdf.format(date);
print(strDate);
}

public static void print(String str){
System.out.println(str);
}

}

위의 예제를 실행하면 아래와 같은 결과 화면이 자바 콘솔창에 출력됩니다.

인터넷 url 이미지를 복사해서 자바 스윙의 화면으로 뿌려주기

안녕하세요

이번 시간에는 좀 재밌는 예제를 올려봅니다.

이번 예제는 먼저 결과 사진을 보면서 설명해드리겠씁니다.

먼저 화면은 위와 같습니다.

원본 이미지 파일 아래에 'pin.png' 라는 원본 파일이 있어야

아래의 목적 이미지 파일이 생성됩니다

사전에 이미지 파일을 하나 챙기세요~

목적 이미지 파일은 텍스트로 수정 가능하니

반드시 target.png 형태로 저장 될 필요는 없습니다.

중간에 Copy 버튼을 누르면 나비 모양의 pic.png 이미지가 하단에 출력이 됨과 동시에

target.png 라는 파일이 생길겁니다. 

패키지 익스플로러 창에서 F5 키 누르면 됩니다

두번째 기능은 인터넷 URL 이미지 복사 기능인데

원격 이미지 파일의 url에 제가 사전에 정의해놓은 경로가 있습니다.

바로 밑에 원격에서 Copy라는 버튼을 누르면..

아래와 같이 인터넷 이미지를 출력하게 됩니다.

자 그럼 이것을 어떻게 구현하냐 하면..

아래와 같이 하시면 됩니다.

소스 코드를 이해하시면서 봐야지 도움이 됩니다~!

public class ImageCopyGui extends JFrame {

JTextField tf1, tf2, tfUrl;

JButton btCopy, btUrlCopy; JProgressBar pb; JLabel lbImage;

FileInputStream fis; FileOutputStream fos;

File file1, file2;

public ImageCopyGui() {

super("::ImageCopyGui::");

Container cp = getContentPane();

cp.setLayout(new GridLayout(2,1));

JPanel p = new JPanel(new GridLayout(0,1));

cp.add(p);

lbImage=new JLabel("*^.^*", JLabel.CENTER);

cp.add(new JScrollPane(lbImage));

lbImage.setBorder(new LineBorder(Color.magenta));

tf1=new JTextField("pic.png"); tf2=new JTextField("target.jpg");

tfUrl=new JTextField("http://imgmovie.naver.com/design/preview01/1610/evnet_african/image//img_02.jpg");

btCopy=new JButton("Copy"); btUrlCopy=new JButton("원격에서 Copy");

pb=new JProgressBar();

p.add(tf1); p.add(tf2); p.add(tfUrl); 

JPanel p2 = new JPanel(); p.add(p2);

p2.add(btCopy); p2.add(btUrlCopy);

p.add(pb);

pb.setStringPainted(true); // 프로그레스바 몇%인지 보여줌

tf1.setBorder(new TitledBorder("원본 이미지 파일"));

tf2.setBorder(new TitledBorder("목적 이미지 파일"));

tfUrl.setBorder(new TitledBorder("원격 이미지 파일의 URL"));

btCopy.setMnemonic('C'); 

p.setBorder(new BevelBorder(BevelBorder.RAISED)); // 패널을 입체적으로 보여줌 

// 이미지를 복사하는 버튼 이벤트 리스너

btCopy.addActionListener(new ActionListener(){

public void actionPerformed(ActionEvent e){

String srcStr = tf1.getText(); // tf1의 이미지 pic.png(원본 이미지)

String targetStr=tf2.getText(); // // tf2의 이미지 target.png(복사 될 이미지)

file1=new File(srcStr); file2= new File(targetStr);

Thread tr = new Thread(){

@Override

public void run(){

fileCopy(file1, file2); // 사용자 정의 메소드

}

};

tr.start();

}

});

// 인터넷 이미지 url 주소의 이미지를 복사하는 버튼 이벤트 리스너

btUrlCopy.addActionListener(new ActionListener(){

public void actionPerformed(ActionEvent e){

String urlStr = tfUrl.getText();

new Thread(){

public void run(){

urlFileCopy(urlStr); // 사용자 정의 메소드

}

}.start();

}

});

setSize(500, 500);

setVisible(true);

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}

public synchronized void fileCopy(File srcFile, File tarFile){

// 스트림 연결 => 노드 스트림 => 필터 스트림

String msg="";

long fsize=srcFile.length(); // 원본 파일의 크기를 반환

setTitle("원본 파일 크기 : "+fsize+"bytes");

//pb의 최대값을 원본 파일 크기로 잡는다.

pb.setMaximum(0); pb.setMaximum((int)fsize);

try{

fis = new FileInputStream(srcFile);

fos = new FileOutputStream(tarFile);

//BuffredInputStream으로 처리하면 더 빠르다

// 반복문 돌면서 읽어들이고 내보낸다.

int input=0, count=0;

byte[] data = new byte[1024];

// 원본 이미지 복사

while((input=fis.read(data))!=-1){

fos.write(data, 0, input);

fos.flush();

count+=input;

pb.setValue(count);

Thread.sleep(10);

}

msg=count+"bytes 카피 완료";

// 스트림 닫기

fis.close(); fos.close();

lbImage.setIcon(new ImageIcon(tarFile.getAbsolutePath()));

}catch(FileNotFoundException e){

msg="없는 파일이에요: "+e.getMessage();

}catch(InterruptedException e){

msg="Interrupted 오류"+e.getMessage();

}catch(IOException e){

msg="오류 : "+e.getMessage();

}

JOptionPane.showMessageDialog(this, msg);

}

public void urlFileCopy(String urlStr){

// throws로 하면 다른 쪽에서 예외 처리를 해줘야함

try{

java.net.URL url = new java.net.URL(urlStr);

InputStream is = url.openStream();

java.net.URLConnection con = url.openConnection();

// url에 있는 파일의 크기를 반환한다.

int fsize = con.getContentLength();

setTitle(fsize+"bytes");

// 해당 url과 노드 연결된 입력 스트림을 반환한다.

BufferedInputStream bis = new BufferedInputStream(is);

file2 = new File(tf2.getText());

fos = new FileOutputStream(file2);

BufferedOutputStream bos = new BufferedOutputStream(fos);

int input=0, count=0;

byte[] data = new byte[3000];

while((input=bis.read(data))!=-1){

bos.write(data, 0, input);

bos.flush();

count+=input;

pb.setValue(count);

Thread.sleep(10);

}

bis.close(); bos.close();

is.close(); fos.close();

lbImage.setIcon(new ImageIcon(file2.getAbsolutePath()));

}catch(MalformedURLException e){

e.printStackTrace();

}catch(Exception e){

e.printStackTrace();

}

}

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

new ImageCopyGui();

}

}

BufferedInputStream을 활용하여 키보드로 입력받은 내용을 콘솔에도 입력하고 파일에도 내보내자

안녕하세요

이번 시간에는 자바에서 BufferedInputStream과 BufferedOutputStream을 활용하여

키보드로 입력받은 내용을 콘솔에도 내보내고, 파일에도 내보내는 예제를 올려봅니다.


이 내용도 소스가 길지 않고 크게 어려운건 없으니

보다보면 이해하실겁니다.


public class BIStream {

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

//노드 연결
InputStream is = System.in; PrintStream ps = System.out;

//필터링
BufferedInputStream bis = new BufferedInputStream(is);
BufferedOutputStream bos = new BufferedOutputStream(ps);

//[실습2] 키보드로 입력받은 내용을 콘솔에도 내보내고, 파일에도 내보내세요
//파일("../result.txt")에도 내보내세요
//단, BufferedOutputStream을 이용해서 내보내세요

//파일과 노드 연결
//bufferd 연결

BufferedOutputStream fbos = new BufferedOutputStream(new FileOutputStream("../result.txt", true));

int input=0, count=0;
while((input=bis.read())!=-1){
bos.write(input);
fbos.write(input);
bos.flush(); fbos.flush();
count++;
}

ps.println(count+"바이트 씀");
bis.close(); is.close();
bos.close(); ps.close();
fbos.close();

}

}

위 소스 코드를 실행할때는 도스 콘솔창에서 실행하는 게 좋습니다.

일단 제가 입력한 내용은

가

나

다

라

입니다.

그리고 패키지 익스플로러에서 F5 키를 눌러 갱신하면 result.txt 파일이 있습니다.

클릭하면 맨 마지막에 제가 입력한 '가나다라' 내용이 있습니다.

그 위의 있는 내용은 제가 이전에 썼던 내용입니다.

ObjectOutputStream을 활용하여 데이터를 저장하고 ObjectInputStream을 활용하여 데이터를 읽어들이기

안녕하세요

이번 시간에는 자바에서 ObjectOutputStream을 활용하여 생성된 텍스트 파일을

ObjectInputStream을 이용하여 불러들이는 예제를 올려봅니다.

이전에 했던 예제와 흡사하나

이번 예제는 직렬화 개념과 캡슐화 개념이 있는 클래스 파일을 하나 더 만들어서 활용한 예제입니다.

아마 이전 예제보다 이번 예제가 활용도가 좀 더 높을거라고 생각합니다.


먼저 첫번째 클래스 파일 올려봅니다.

첫번째 클래스 파일 이름 Employee 이고, 이름, 부서, 봉급 정보를 가지고 있는 클래스입니다.

여기서는 직렬화(Serializable) 개념을 활용했습니다.

직렬화(Serializable)를 해야  네트워크로 해당 객체를 전송하거나 파일에 저장할 수 있습니다.

java.io.Serializable 인터페이스를 상속 받으면 직렬화가 가능한데, 직렬화란 데이터들을 한 줄로 나열될 수 있다는 것을 의미하고 이것은 스트림을 통해 해당 객체가 전송될 수 있음을 의미하는 것을 뜻합니다.


자 그럼 소스 코드 올려봅니다.


public class Employee implements Serizlizable {

private String name;
private String dept;
// transient를 붙이면 해당 변수는 스트림에 내보낼 때 노출되지 않는다, 즉 직렬화 대상에서 제외시킨다.
transient private int salary;

public Employee(){

}

public Employee(String name, String dept, int salary){
super();
this.name=name;
this.dept=dept;
this.salary=salary;
}

public void showInfo(){

System.out.println("---Record for "+name+"=----");
System.out.println("Name: "+name);
System.out.println("Dept: "+dept);
System.out.println("Salary: "+salary);

}


}

자 이번에는 ObjectOutputStreamTest라는 클래스를 만들어 위의 Employee 객체를 몇 개

생성하여 파일에 해당 객체를 저장해보겠습니다.


public class ObjectOutputStreamTest {

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

Employee e1 = new Employee("King", "기획부", 5000);
Employee e2 = new Employee("Scott", "운영부", 3000);

//파일(obj.txt) => FileOutputStream====>ObjectOutputStream
//DataOutput 인터페이스와 ObjectOutput 인터페이스를 구현
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));

//java.io.NotSerializableException -> 직렬화 오류 발생 -> Employee 클래스에 implements 해야한다.
oos.writeObject(e1); oos.writeObject(e2);

//Date, JFrame 등 왠만한 것은 직렬화가 되어 있음

java.util.Date d = new java.util.Date();
oos.writeObject(d);

javax.swing.JFrame f = new javax.swing.JFrame("오브젝 스트림");
oos.writeObject(f);

oos.flush();
oos.close();
System.out.println("obj.txt 파일에 객체 쓰기 완료");
// 객체들을 바이트화 시켜서 obj.txt에 저장

}

}


두번째 소스 코드를 실행하면 아래와 같은 결과가 나옵니다.

obj.txt라는 파일이 폴더에 뜨고 콘솔창에는 ob.txt 파일에 객체 쓰기 완료라는 문구가 나오게 됩니다.

자 그럼 마지막으로 obj.txt 파일에 저장된 글들을 읽어들이는 예제를 올리면서

이상 포스팅을 마치겠습니다.

public class ObjectInputStreamTest {

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

//obj.txt 파일 읽어서 객체를 복원하자

//obj.txt==>FileInputStream=>>ObjectInputStream

ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));

//readObject()은 반환형이 Object

Object o1 = ois.readObject();

//형변환

Employee e1 = (Employee)o1;

Employee e2 = (Employee)ois.readObject();

e1.showInfo(); e2.showInfo();

Date day = (Date)ois.readObject();

System.out.println("객체가 저장된 시간: "+day.toString());

JFrame ff = (JFrame)ois.readObject();

ff.setSize(300, 300); ff.setVisible(true);

ois.close();

}

}

소스 코드를 실행하면 obj.txt 파일에 있는 데이터들을 정상적으로 읽어들입니다 ㅎ

DataOutputStream을 활용하여 데이터를 파일로 저장하고 DataInputStream을 통해 읽어들이기

안녕하세요

이번 시간에는 자바의 다양한 자료형의 데이터를 파일(data.txt)에 쓰고 읽어 들이는 예제를 올려봅니다.


소스 코드 파일은 두 개 입니다.

먼저 DataOutputStream을 활용하여 데이터를 파일(data.txt)에 저장하겠습니다.


public class DataOutputStreamTest {

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

String filename="data.txt";
//노드 연결(노드 스트림 연결)
FileOutputStream fos = new FileOutputStream(filename);
//필터 스트림과 노드 스트림을 연결
DataOutputStream dos = new DataOutputStream(fos);

//data.txt 파일에 데이터를 입력하자
byte b=65; byte[] buf={66,67,68};
short s=100; char ch='가'; boolean bool=true;
double d=123.45; String str="홍길동";

dos.write(b); // 1byte
dos.write(buf,0,buf.length); // 3byte
dos.writeShort(s); // 2byte
dos.writeChar(ch); // 2byte
dos.writeBoolean(bool); // 1byte
dos.writeDouble(d); //8byte
dos.writeUTF(str); // (3*3+2)byte

/* 문자열을 쓰고자 할 때 writeUTF()를 많이 이용
* 유니코드 utf-8 형식으로 문자열을 출력하는 메소드
* utf형식은 각 문자의 표현을 위해 한 바이트 사용했는지, 두 바이트 또는 세 바이트 차지하는지 알아내어
* 아스키 문자는 1byte로, 그리스어, 히브리어, 아랍어 등은 2byte로, 그 외 문자는 3byte로 표현
* */

System.out.println(dos.size()+"bytes 씀"); // 28byte

dos.flush(); // 스트림에 남아있는 데이터가 있으면 밀어내기를 해준다.

dos.close();
}

}


위의 소스 코드를 실행하면 아래와 같습니다

보시다시피 28bytes를 썼다는 문구와 함께 디렉토리에 data.txt 라는 파일이 생성하게 됩니다. 

data.txt 파일을 열어보면 영문자는 정상적으로 출력되지만 다른 문자는 인간이 이해하기 힘든 문자로 저장되었다는 것을 알 수 있습니다.

글자가 깨진건 아니니 염려마십시요~

위에서 DataOutputStream을 통해 내보낸 데이터는 반드시 DataInputStream을 통해  읽어야 합니다.

이번에는 DataInputStream 예제입니다.

public class DataInputStreamTest {

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

DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));

System.out.println(dis.available()+"바이트 읽을 예정");

// 파일에 쓴 순서대로 읽어야 함

byte a=dis.readByte(); System.out.println(a);

byte[]ba=new byte[3];

int n=dis.read(ba);

for(byte b:ba){

System.out.println(b);

}

short s=dis.readShort(); System.out.println(s);

System.out.println(dis.readChar());

System.out.println(dis.readBoolean());

System.out.println(dis.readDouble());

System.out.println(dis.readUTF());

dis.close();

}

}

보시다시피 위의 결과를 실행하면 DataOutputStream 예제에서 저장했던 결과를 불러올 수 있습니다.

FileInputStream을 활용하여 원본 파일(png)을 읽어서 복사 파일을 생성해보자

안녕하세요

이번 시간에는 자바에서 FileInputStream / FileOutputStream 을 활용하여

원본 파일 이미지를 복사해서 복사 이미지 파일을 생성하는 예제를 올려봅니다.


복잡 할 것 같지만 생각 외로 간단해서 저도 깜짝 놀랐습니다.

먼저 소스 코드 부터 보세요~!


public class Test {

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

File file1 = new File("pic.png");
File file2 = new File("copy2.png");

long fsize1 = file1.length(); // 원본 파일 크기 변환
System.out.println("원본 파일 크기 : " + fsize1);

FileInputStream fis = new FileInputStream(file1);
FileOutputStream fos = new FileOutputStream(file2);

int input=0, count=0;

byte[] data = new byte[1024];

while((input=fis.read(data))!=-1){
// 배열을 할 때는 0부터 끝까지 넣어야함
fos.write(data, 0, input);
count+=input;

// (읽은 바이트 수 / 전체 파일 크기) * 100
float per = ((float)count/fsize1) * 100;
System.out.println((int)per + "% 카피됨");

}

}

}


위의 소스 코드를 실행하면 아래와 같은 결과 화면이 나옵니다.




5194 바이트 크기의 원본 이미지 파일을 카피 했다는 문구가 뜹니다.




이와 동시에 폴더에 copy2.png 라는 이름을 가진 복사 파일본이 생기게 됩니다.

 

그림 이미지 파일은 똑같지만 잘 보면 파일명이 다릅니다.

원본 파일은 pic.png, 복사 된 파일은 copy2.png 입니다.

위의 예제를 응용하면 다양한 용도로 활용할 수 있을 것 같습니다.

IO 입출력 예제 part5 - 키보드로 입력 받은 내용을 파일로 내보내기

안녕하세요

이번 시간에는 자바 IO를 활용하여

키보드로 입력 받은 텍스트 내용을 파일로 저장하는 예제를 올려봅니다.


바로 소스 코드랑 주석을 올려봅니다.



public class Test {

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

System.out.println("입력하세요=> [입력한 내용은 " + " result.txt 파일에 저장됩니다.");
int input=0, count=0;

// true을 붙이면 기존 파일에 붙여쓰기 가능
FileOutputStream fos = new FileOutputStream("result.txt",true);

byte[] data = new byte[100];

while((input=System.in.read(data))!=-1){
fos.write(data, 0, input);
count+=input;

//배열을 안 썼을 때
//fos.write(input);
//count++;

}

System.out.println(count+"bytes를 result.txt파일에 씀");
fos.close(); System.in.close(); System.out.close();

}

}

위의 소스 코드를 실행하면 아래와 같은 결과가 나오게 됩니다.

(도스창에서 실행해야 합니다)

프로그램을 실행하면 자신이 원하는 텍스트를 쓰게 됩니다

그리고 다 쓴 후에 CTRL+C를 누르면 while 루프문을 빠져나오면서 result.txt 파일에 저장이 됩니다.

실제로도 bin 디렉토리에 위와 같이 result.txt 파일에 입력해 놓은 텍스트 값이 

저장되어 있습니다.

IO 입출력 예제 part4 - 파일을 읽어서 콘솔에 출력해보자

안녕하세요

이번 시간에는 자바 IO에서 파일을 읽어 들어 콘솔에 출력하는 예제를 올려봅니다.

일단 예제를 실행하면 아래와 같은 결과 화면이 나옵니다.

보시다시피 파일을 읽어 들어 콘솔 창에 띄워주고

맨 마지막 하단에 몇 바이트를 읽었는지 확인하는 프로그램입니다.

자 그럼 소스 코드를 볼까요~!

public class Test {

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

String filename = "C:/MyJava/workspace/Advance/src/io/day1/InputStreamTest.java";

//파일과 노드 연결

FileInputStream fis = new FileInputStream(filename);

int input=0, count=0;

while((input=fis.read())!=-1){

System.out.write(input);

count++;

}

System.out.println(count+"바이트 읽음");

fis.close(); System.out.close();

}

}

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

위의 소스 코드를 조금 변형해서 배열을 이용한 예제입니다.

아래 참고해주세요~!


public class Test {

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

String filename="C:/MyJava/workspace/Advance/src/io/day1/InputStreamTest.java";
//파일과 노드 연결
FileInputStream fis = new FileInputStream(filename);

byte[] data = new byte[1024]; // 1KB=>1024bytes
int input=0, count=0, total=0;
while((input=fis.read())!=-1){
System.out.write(data,0,input);
count++; // 반복문 횟수
total+=input;
}

System.out.println("총"+total+"바이트 읽음");
// 노드 연결 닫기
fis.close(); System.out.close();

}

}