Java IO流详解-优快云博客

package com.yh.io;

import java.io.File;

/**
* File 类的高级方法
* String[] list() 返回一个字符串数组，这些字符串指定此路径名表示的目录中的文件和目录
* File[] listFiles() 返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件
*
*/
public class Test03File {

public static void main(String[] args) {
// TODO Auto-generated method stub
//当前项目文件
File file=new File("D:\\software\\TestString");

//System.out.println("文件路径:"+file.getAbsoluteFile());

String[] str=file.list();

for(int i=0;i<str.length;i++){
System.out.println("list():"+str[i]);
}

File[] files=file.listFiles();

for(File f :files){
System.out.println("listFiles"+f);
}
System.out.println("--------遍历文件----------");
//遍历file下所有的文件
listFiles(file);
}
//列出file 下的所有文件

public static void listFiles(File file){

File[] files=file.listFiles();

for(int i=0;i<files.length;i++){
//判断文件是否是目录
if(files[i].isDirectory()){
//递归
listFiles(files[i]);
}else{
System.out.println("文件:"+files[i].getName());
}
}

}

}

package hu.io;

import java.io.File;

import java.io.FileInputStream;
/*
* 输入流： inputStream 抽象类
* 实例化：new FileInputStream()
* int read() 从此输入流中读取一个数据字节。
int read(byte[] b) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。

*/
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/*
* 读文件：new FileInputStream(File file)
* read()
* read(byte[] byte)
* close() 关闭此文件输入流并释放与此流有关的所有系统资源。
*
*
* 写文件：
* new FileOutputStream(File file) 源文件如果由内容，写入的内容直接覆盖
* new FileOutputStream(File file,boolean append) 往文件的末尾拼接写入的内容
* write(byte[] byte)
*FileNotFoundException :
*1.如果该文件存在，但它是一个目录，而不是一个常规文件；
*2.或者该文件不存在，但无法创建它；抑或因为其他某些原因而无法打开，则抛出 FileNotFoundException
* void write(byte[] b) 将 b.length 个字节从指定 byte 数组写入此文件输出流中。
void write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。

close();关闭此文件输出流并释放与此流有关的所有系统资源。
*/

public class MyInputStream {

public static void main(String[] args) {
// TODO Auto-generated method stub

//创建文件 //相对于项目的路径
//File file=new File("test1/2_rename.dc");

//writeFile(file);
readFile(new File("log4j.properties"));
//readWriteFile();
}

//读文件

public static void readFile(File file){
try {
//创建输入流对象
FileInputStream ins=new FileInputStream(file);

/* //一次读取一个字符
int a=0;
while((a=ins.read())!=-1){
System.out.println((char)a);
}*/

//读取指定长度的字节

byte[] buf=new byte[1024];

int len=-1;
//ins.read(buf) 将字节读到字节数组中，返回字符-1说明文件读取到结尾了
while((len=ins.read(buf))!=-1){
System.out.println(new String(buf,0,len));
}
//关闭输入流
ins.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

//写文件
public static void writeFile(File file){

//输出流对象
try {
// FileOutputStream(file,true) true，则将字节写入文件末尾处
FileOutputStream ops=new FileOutputStream(file,true);
String s="2016java班";
//String 转byte[]
byte[] buf=s.getBytes();
//write(byte[] )
ops.write(buf);

// ops.write(buf,0,buf.length);

//关闭输出流、
ops.close();

} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

//文件的复制
public static void readWriteFile(){

File read=new File("log4j.properties");

File write=new File("copy.nm");

try {
//输入流
FileInputStream ins=new FileInputStream(read);
//输出流
FileOutputStream ous=new FileOutputStream(write);

byte[] buf=new byte[1024];
int len=-1;
try {
while((len=ins.read(buf))!=-1){
//new String(buf,0,len);
ous.write(buf,0,len);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

//关闭输出流
ous.close();
//关闭输入流
ins.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

}

package com.yh.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

/**
* 高效流：BufferedInputStream BufferedOutputStream
* BufferedInputStream:
*
*
*
*/

public class Test06BufferedInputStream {

public static void main(String[] args) {
// TODO Auto-generated method stub

try {
//创建输入流对象
InputStream ins = new FileInputStream(new File("04-List.wmv"));

//输入流高效流对象
BufferedInputStream bis=new BufferedInputStream(ins);

//创建输出流对象
OutputStream ops=new FileOutputStream(new File("test1/test2/04-List.wmv"));

//输出流高效流对象
BufferedOutputStream bos=new BufferedOutputStream(ops);

byte[] buf=new byte[1024];

int len=-1;
while((len=bis.read(buf))!=-1){
//read()读取数据 buf覆盖，指定数组的索引
bos.write(buf,0,len);
}

///强制输出缓冲区中的数据
bos.flush();

//关闭输入流
bis.close();
//关闭输出流
bos.close();

} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

package com.yh.io;

import java.io.Serializable;

public class Student implements Serializable{

private String sno;
private String name;
private int age;
private String sex;

public Student(String sno,String name,int age,String sex){
this.sno=sno;
this.name=name;
this.age=age;
this.sex=sex;
}

public String getSno() {
return sno;
}
public void setSno(String sno) {
this.sno = sno;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public void setAge(int age) {
this.age = age;
}

//重写：继承关系，子类重写父类的方法
@Override
public boolean equals(Object obj){
//obj 和当前对象指向同一块内存
if(obj==this){
return true;
}

if(obj==null){
return false;
}

/* if(this.getClass()==obj.getClass()){

}*/

//两个对象是同一个实例，实例的所有属性值相等
if(obj instanceof Student){
Student stu=(Student)obj;
if(stu.getSno()!=null && this.sno.equals(stu.getSno()) && stu.getName()!=null && this.name.equals(stu.getName()) && this.age==stu.getAge()){
return true;
}
}

return false;

}

//重写hashcode
@Override
public int hashCode(){
return sno.hashCode()+name.hashCode()+String.valueOf(age).hashCode();
}

//重写toString()
@Override
public String toString() {

return "sno:"+this.sno+" name:"+this.name+" age:"+age+" sex:"+this.sex;
}

}

package com.yh.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;

/**
*
* ObjectInputStream 读取对象和ObjectOutputStream 写入对象
*
* 实例化: new ObjectOutputStream(OutputStream out)
void writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。

new ObjectInputStream(InputStream ins)
void readObject(Object) 从文件读取对象
*/

public class Test07ObjectInputStream {

public static void main(String[] args) {
// TODO Auto-generated method stub
//writeObject();
readObject();
}

//写入对象
public static void writeObject(){

//创建输出流对象
OutputStream out;
try {
out = new FileOutputStream(new File("test1/2.txt"));

//创建对象输出流对象
ObjectOutputStream oos=new ObjectOutputStream(out);

Student zhangsan=new Student("10001","张三",20,"男");
Student zhangsan2=new Student("10002","张三2",21,"男");

//写入对象
oos.writeObject(zhangsan);
oos.writeObject(zhangsan2);

} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

//读取对象

public static void readObject(){

try {
//创建对象输入流
ObjectInputStream ois=new ObjectInputStream(new FileInputStream(new File("test1/2.txt")));

Student zhangsan=(Student) ois.readObject();

Student zhangsan2=(Student) ois.readObject();

Student zhangsan3=(Student)ois.readObject();

System.out.println(zhangsan.toString());
System.out.println(zhangsan2.toString());

} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}

字符流

package com.yh.io;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

import org.apache.log4j.Logger;

/*
* 字符流的读写
*
* Reader 用于读取字符流的抽象类子类 FileReader 与字节流InputStream相对应
* public abstract void close() 关闭输入流
public int read() 读取单个字符
public int read(char[] c) 将内容读取到字符数组中，并返回读取的长度
*
* Writer 写入字符流的抽象类子类FileWriter 与字节流outputStream相对应
* public abstract void close() 关闭输出流
public void write(String str) 输出字符串
public void write(char[] c) 输出字符数组
public abstract void flush() 强制清空缓存
*
*/

public class Test08ReaderWriter {

static Logger logger=Logger.getLogger("Test08ReaderWriter");

public static void main(String[] args) {
// TODO Auto-generated method stub

//写入字符串
// writeFile();
readCharFile();
}

//字符流写入文件
public static void writeFile(){

File file=new File("2_rename.nm");

String s="hello10001第一个Java应用输入输出!";

char[] strChar=s.toCharArray();

try {
//创建字符流输出流对象
Writer writer=new FileWriter(file);

//以字符串的形式写入
//writer.write(s);
//以字符数组写入
writer.write(strChar);

logger.debug("文件写入成功!");

writer.flush();
writer.close();
} catch (IOException e) {
// TODO Auto-generated catch block
//e.printStackTrace();
logger.debug("文件写入失败");
}

}

//以字符流读取文件

public static void readCharFile(){

try {
//创建字符流输入流对象
Reader reader=new FileReader(new File("2_rename.nm"));

int ch;
while((ch=reader.read())!=-1){
System.out.println((char)ch);
}

logger.debug("文件读取结束!");

} catch (Exception e) {
// TODO Auto-generated catch block
// e.printStackTrace();
logger.debug("读取错误!");
}

}

}

package com.yh.io;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

import org.apache.log4j.Logger;

/**带缓冲区的字符流的读写
* BufferedReader BufferedWriter public BufferedReader(Reader in) 构造方法接收Reader类实例
* int read() 读取单个字符。
* int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分。
* public String readLine() 方法从缓冲区中读取一行文本如果已到达流末尾，则返回 null
*
BufferedWriter public BufferedWriter(Writer out) 构造方法接收Writer类实例
public void newLine() 方法写入一个行分隔符
public void write(int c) 方法写入单个字符
public void write(char[] c,int off,int len) 方法写入字符数组的一部分
public void write(String s,int off,int len) 方法写入字符串的一部分
*
*
*/
public class Test09BufferedReaderWriter {

static Logger logger=Logger.getLogger("Test09BufferedReaderWriter");

public static void main(String[] args) {
// TODO Auto-generated method stub

//writeFile();

readFile();
}

public static void writeFile(){

try {
Writer writer = new FileWriter(new File("buffer.nm"));
String s="2016-11-25 public void write(String s,int off,int len)方法写入字符串的一部分";

char[] strArray=s.toCharArray();
//创建一个缓冲区的字符流输出流对象
BufferedWriter bw=new BufferedWriter(writer);

//整个字符串写入文件
//bw.write(s, 0, s.length());

//部分写入文件
//bw.write(s,s.indexOf("p"),s.indexOf(")")-s.indexOf("p")+1);

//写入一个行分隔符
bw.newLine();
//写入字符数组
bw.write(strArray);

logger.debug("文件写入成功!");

bw.flush();

bw.close();
} catch (Exception e) {
// TODO Auto-generated catch block
// e.printStackTrace();
logger.debug("文件写入失败!");
}

}

//读文件
public static void readFile(){

try {
//创建带缓冲区的字符流输入流对象
BufferedReader br=new BufferedReader(new FileReader(new File("buffer.nm")));

//read() 一次读取一个字符
/* int len;
while((len=br.read())!=-1){
System.out.print((char)len);
}*/

/* System.out.println("read(char[])");
int flag;
char[] ch=new char[1024];

while((flag=br.read(ch))!=-1){
System.out.print(String.valueOf(ch, 0, flag));
}*/

//readLine()读取一行文本
String s=null;
while((s=br.readLine())!=null){
System.out.println(s);
}

} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

}

io流读写程序