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();
}

}


}