刚开始学java IO的时候，有好多不明白的地方，入行后工作中真正用到的地方也不是太多，有一天忽然想回过头来，在看看自己对基础java的认识，才发现自己竟然有好多东西已经忘却了，所以写下这个例子，再从新学一遍java IO
package com.leadron.test1;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.CharArrayReader;
import java.io.CharArrayWriter;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
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.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Serializable;
import java.io.StringBufferInputStream;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.StringTokenizer;
public class ByteIOTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ByteIOTest t = new ByteIOTest();
t.fileTest();
}
// ===========================================================================
/**
*
* 字节流的操作
*
*/
// ===========================================================================
// 字节类型的读取
/**
* input stream 1)ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用
* 2)StringBufferInputStream：把一个String对象作为InputStream
* 3)FileInputStream：把一个文件作为InputStream，实现对文件的读取操作
* 4)PipedInputStream：实现了pipe的概念，主要在线程中使用
*
* out stream 1)ByteArrayOutputStream：把信息存入内存中的一个缓冲区中
* 2)FileOutputStream：把信息存入文件中 3)PipedOutputStream：实现了pipe的概念，主要在线程中使用
* 4)SequenceOutputStream：把多个OutStream合并为一个OutStream
*/
/**
* ByteArrayOutputStream类是在创建它的实例时，程序内部创建一个byte型别数组的缓冲区，然后利用
* ByteArrayOutputStream和ByteArrayInputStream的实例向数组中写入或读出byte型数据。
* 在网络传输中我们往往要传输很多变量，我们可以利用ByteArrayOutputStream把所有的变量收集到一起，
* 然后一次性把数据发送出去。具体用法如下:
*
* ByteArrayOutputStream: 可以捕获内存缓冲区的数据，转换成字节数组。
*
* ByteArrayInputStream: 可以将字节数组转化为输入流
*
* 如下所示：ByteArrayOutputStream把内存中的数据读到字节数组中,
* 而ByteArrayInputStream又把字节数组中的字节以流的形式读出,实现了对同一个字节数组的操作.
*/
public void byteRead() {
int a = 0;// 把数据放在内存中的缓冲区
int b = 1;
int c = 2;
ByteArrayOutputStream bout = new ByteArrayOutputStream();
bout.write(a);// 捕获内存缓冲区的数据
bout.write(b);
bout.write(c);
byte[] buff = bout.toByteArray();// 转换成字节数组
for (int i = 0; i < buff.length; i++) {
System.out.println(buff[i]);
}
System.out.println("***********************");
ByteArrayInputStream bin = new ByteArrayInputStream(buff);
while ((b = bin.read()) != -1) {
System.out.println(b);
}
try {
bout.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
bin.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void stringBufferInputStreamTest() {
String str = "11111111111111\n333333333333333333\nadbcd";
int s;
StringBufferInputStream bin = new StringBufferInputStream(str);
while ((s = bin.read()) != -1) {
System.out.println(s);
}
}
public void fileInputStreamTest() {
FileInputStream bin = null;
FileOutputStream fw=null;
File fl=null;
try {
fl=new File("src/com/leadron/test1/a.txt");
if(!fl.exists()){
fl.createNewFile();
}
byte b=1;
fw=new FileOutputStream(fl);
OutputStreamWriter ow=new OutputStreamWriter(fw);
ow.write("我们的");
ow.write(2);
ow.flush();
ow.close();
bin = new FileInputStream(fl);
try {
System.out.println(bin.read());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
bin.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
// ===========================================================================
/**
*
* Unicode字符为导向的stream的操作
*
*
* 1 Input Stream
* 1) CharArrayReader：与ByteArrayInputStream对应
* 2) StringReader：与StringBufferInputStream对应
* 3) FileReader：与FileInputStream对应
* 4) PipedReader：与PipedInputStream对应
*
*
* 2 Out Stream
* 1) CharArrayWriter：与ByteArrayOutputStream对应
* 2) StringWriter：无与之对应的以字节为导向的stream
* 3) FileWriter：与FileOutputStream对应
* 4) PipedWriter：与PipedOutputStream对应
*
*
*
*/
// ===========================================================================
public void charArrayReader() {
int a = 1;
int b = 2;
int c = 3;
CharArrayWriter br = null;
br = new CharArrayWriter();
br.write(a);
br.write(b);
br.write(c);
char[] but = br.toCharArray();
CharArrayReader bin = null;
bin = new CharArrayReader(but);
try {
while ((c = bin.read()) != -1) {
System.out.println((char)c);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
br.close();
bin.close();
}
}
public void stringReader() {
StringReader bin = null;
StringWriter bw = null;
int a;
bw = new StringWriter(10);
bw.write("1");
bw.write("2");
StringBuffer buf = bw.getBuffer();
bin = new StringReader(buf.toString());
try {
while ((a = bin.read()) != -1) {
System.out.println((char)a);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
bw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
bin.close();
}
}
public void fileReader() {
FileReader fr = null;
try {
File fl = new File("src/com/leadron/test1/file1.txt");
if (!fl.exists()) {
fl.createNewFile();
}
fr = new FileReader(fl);
int a;
while ((a = fr.read()) != -1) {
System.out.println((char)a);
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// ==========================================================================
/**
* 以字符为导向的stream基本上对有与之相对应的以字节为导向的stream。两个对应类实现
* 的功能相同，字是在操作时的导向不同。如CharArrayReader：和ByteArrayInputStream的
* 作用都是把内存中的一个缓冲区作为InputStream使用，所不同的是前者每次从内存中读取 一个字节的信息，
* 而后者每次从内存中读取一个字符。
*/
// ==========================================================================
// ===========================================================================
/**
*
* InputStreamReader和OutputStreamWriter：把一个以字节为导向的stream转换成
* 一个以字符为导向的stream。
*
*/
// ===========================================================================
public void inputStreamReader(){
try
{
int b;
InputStreamReader isr = new InputStreamReader (new FileInputStream (new File ("src/com/leadron/test1/file2.txt")));
System.out.println ("The content of text is:");
while ((b = isr.read()) != -1)//顺序读取文件text里的内容并赋值给整型变量b,直到文件结束为止。
{
System.out.print((char)b);
}
isr.close();
}
catch(FileNotFoundException e)
{
System.out.println(e);
}
catch(IOException e)
{
System.out.println(e);
}
catch(Exception e)
{
System.out.println(e);
}
}
public void outputStreamWriter(){
File fl=new File("src/com/leadron/test1/file2.txt");
if(!fl.exists()){
try {
fl.createNewFile();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(fl.exists()){
FileOutputStream op=null;
try {
op = new FileOutputStream(fl);
//如果直接用字节写中文的话，会产生乱码
OutputStreamWriter ow= new OutputStreamWriter(op);
ow.write("大家好,我正在学习Java \n");
ow.write("请多多指教");
ow.write(1);
System.out.println("file2.txt写入成功!***************开始读..\n");
ow.flush();
ow.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
// ===========================================================================
// 简单文件读写
public void fileTest() {
try {
File f = new File("src/com/leadron/test1/file1.txt");
if (!f.exists()) {
f.createNewFile();
}
FileWriter fw = new FileWriter(f);
BufferedWriter bw = new BufferedWriter(fw);
bw.write("大家好,我正在学习Java");
bw.newLine();
bw.write("请多多指教");
System.out.println("file1.txt写入成功!***************开始读..\n");
bw.flush();
bw.close();
FileReader fr = new FileReader("file1.txt");
BufferedReader br = new BufferedReader(fr);
String temp = null;
do {
temp = br.readLine();
System.out.println(temp == null ? "" : temp);
} while (temp != null);
fr.close();
br.close();
System.out.println("file1.txt已经读完!*************");
}
catch (IOException ex) {
ex.printStackTrace();
}
}
//创建一个类
public void creatJava(){
FileWriter fw=null;
BufferedWriter bw = null;
try {
File fjava=new File("src/com/leadron/test1/TestCreate.java");
if(!fjava.exists()){
fjava.createNewFile();
}
fw=new FileWriter(fjava);
bw = new BufferedWriter(fw);
bw.write("package com.leadron.test1;");
bw.newLine();
bw.write("public class TestCreate implements Serializable{");
bw.newLine();
bw.write(" public static void main(String[] args){");
bw.newLine();
bw.write(" System.out.println(\"Hello World !\");");
bw.newLine();
bw.write(" }");
bw.newLine();
bw.write("}");
} catch (Exception e) {
// TODO: handle exception
}finally{
try {
bw.flush();
bw.close();
fw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
// File的操作
public void fileTest2() {
try {
File f = new File("file1.txt");
System.out.println("文件是否存在: " + f.exists());
if (!f.exists()) {
System.out.println("文件不否存在，开始创建！");
f.createNewFile();
}
System.out.println("文件是否存在: " + f.exists());
System.out.println("是文件吗: " + f.isFile());
System.out.println("是文件夹吗: " + f.isDirectory());
System.out.println("可否读取文件: " + f.canRead());
System.out.println("可否修改文件: " + f.canWrite());
System.out.println("是否隐藏: " + f.isHidden());
System.out.println("文件名称: " + f.getName());
System.out.println("标准文件名: " + f.getCanonicalFile());
System.out.println("相对路径: " + f.getPath());
System.out.println("绝对路径: " + f.getAbsolutePath());
System.out.println("标准路径: " + f.getCanonicalPath());
System.out.println("最后修改时间: " + f.lastModified());
System.out.println("文件大小: " + f.length() + " 字节");
} catch (IOException ex) {
ex.printStackTrace();
}
}
// 分隔符读取
public void fileTest3() {
try {
File f = new File("file1.txt");
if (!f.exists()) {
f.createNewFile();
}
FileWriter fw = new FileWriter(f);
BufferedWriter bw = new BufferedWriter(fw);
bw.write("小明,男,1980-1-1,13624577654");
bw.newLine();
bw.write("小强,男,1984-2-1,13634375634");
bw.newLine();
bw.write("小红,女,1986-1-5,13724777774");
System.out.println("数据写入成功！");
bw.flush();
bw.close();
FileReader fr = new FileReader(f);
BufferedReader br = new BufferedReader(fr);
String s = null;
while ((s = br.readLine()) != null) {
StringTokenizer st = new StringTokenizer(s, ",");
System.out.println(s == null ? " " : s);
while (st.hasMoreTokens()) {
String name = st.nextToken();
String sex = st.nextToken();
String birthday = st.nextToken();
String tel = st.nextToken();
System.out.println("姓名: " + name);
System.out.println("性别: " + sex);
System.out.println("生日: " + birthday);
System.out.println("电话: " + tel);
System.out.println("_______________________________ ");
}
}
while (s != null)
;
fr.close();
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public void fileTest4() {
ByteArrayOutputStream bout = new ByteArrayOutputStream();
DataOutputStream dout = new DataOutputStream(bout);
String name = "xxy";
int age = 84;
try {
dout.writeUTF(name);
dout.writeInt(age);
byte[] buff = bout.toByteArray();
ByteArrayInputStream bin = new ByteArrayInputStream(buff);
DataInputStream dis = new DataInputStream(bin);
String newName = dis.readUTF();
int newAge = dis.readInt();
System.out.println(newName + ":" + newAge);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
bout.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
dout.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
