Java IO操作

学习Java的同学注意了！！！

学习过程中遇到什么问题或者想获取学习资源的话，欢迎加入Java学习交流群，群号码：286945438 我们一起学Java！

File类的使用

public static void main(String[] args) { //File.separator 表示分隔符
File file1 = new File("D:"+File.separator+"yyd"+File.separator+"cdut.txt"); //路径分隔符 // String s = File.pathSeparator; //文件是否存在
if(!file1.exists()){ try { //创建一个新文件
boolean b = file1.createNewFile(); System.out.println("创建文件："+b); } catch (IOException e) { e.printStackTrace(); } } //删除文件 //System.out.println(file1.delete()); //得到文件的上一级路径
System.out.println(file1.getParent()); //判断一个路径是否是文件夹
System.out.println("是否是目录："+file1.isDirectory()); ////判断一个路径是否是文件
System.out.println("是否是文件："+file1.isFile()); File file2 = new File("d:\\yydt"); //列出文件夹中的所有文件名
String[] fileName = file2.list(); for (String s : fileName) { System.out.println(s); } //列出文件夹中的所有文件，以File数组返回
File[] files = file2.listFiles(); for (File file : files) { System.out.println(file.getPath()+"---"+file.length()); } //创建文件夹
File file3 = new File("d:\\zhangsan\\lisi"); file3.mkdirs(); //重命名
File file4 = new File("d:\\zhangsan\\wangwu"); file3.renameTo(file4); }

IO



InputStream

/** * 字节输入流的读取方式三：每次读取指定大小的字节 */
public static void read3(){ try { File f = new File("d:\\1.txt"); //构造一个字节输入流对象
InputStream in = new FileInputStream(f); //指定每次要读取的字节数组
byte[] bytes = new byte[10]; int len = -1;//每次读取的实际长度
StringBuilder sb = new StringBuilder(); while((len = in.read(bytes))!=-1){ sb.append(new String(bytes,0,len)); } //关闭
in.close(); //输出
System.out.println(sb); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } /** * 字节输入流的读取方式二：一次性读取所有字节 */
public static void read2(){ try { File f = new File("d:\\1.txt"); //构造一个字节输入流对象
InputStream in = new FileInputStream(f); //根据文件的大小构造字节数组
byte[] bytes = new byte[(int)f.length()]; int len = in.read(bytes); System.out.println(new String(bytes)); System.out.println("len="+len); //关闭
in.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } /** * 字节输入流的读取方式一：每次读取一个字节 */
public static void read1(){ try { //构造一个字节输入流对象
InputStream in = new FileInputStream("d:\\1.txt"); int b = -1;//定义一个字节，－1表示没有数据
while((b=in.read())!=-1){ System.out.print((char)b); } //关闭
in.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } public static void main(String[] args) { // read1(); // read2();
read3(); }

OutputStream

/** * 字节输出流的方式二：每次输出指定大小的字节 */
public static void write2() { try { // 创建一个文件字节输出流对象(参数true表示追加输出)
OutputStream out = new FileOutputStream("d:\\1.txt", true); // String info = "hello,xiaobai";
String info = "one car come,one car go,two car pengpeng,one car die!"; byte[] bytes = info.getBytes(); out.write(bytes);// 输出一个字节数组 // out.write(bytes,0,5);//输出一个字节数组中的指定范围的字节 // 关闭流
out.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } /** * 字节输出流的方式一：每次输出一个字节 */
public static void write1() { try { // 创建一个文件字节输出流对象
OutputStream out = new FileOutputStream("d:\\1.txt"); String info = "hello,IO"; byte[] bytes = info.getBytes(); for (int i = 0; i < bytes.length; i++) { // 向文件中输出
out.write(bytes[i]); } // 关闭流
out.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } public static void main(String[] args) { // write1();
write2(); System.out.println("success"); }

Writer

/** * 字符输出流方式一：以字符数组方式输出 */
public static void writer1(){ File f = new File("d:\\2.txt"); try { //构造一个字符输出流对象(true表示追加输出)
Writer out = new FileWriter(f,true); String info = "good good study,day day up!"; //向文件中输出 // out.write(info.toCharArray());
out.write(info); //关闭流
out.close(); } catch (IOException e) { e.printStackTrace(); } } public static void main(String[] args) { writer1(); }

Reader

/** * 字符输入流方式一：使用指定大小的字符数组输入 */
public static void reader1(){ File f = new File("d:\\1.txt"); try { //构造一个字符输入流对象
Reader in = new FileReader(f); char[] cs = new char[20]; int len = -1; StringBuffer sb = new StringBuffer(); while((len = in.read(cs))!=-1){ sb.append(new String(cs,0,len)); } //关闭流
in.close(); System.out.println(sb); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } /** * 使用字节流读取文本文件 */
public static void byteReader(){ File f = new File("d:\\1.txt"); try { InputStream in = new FileInputStream(f); byte[] bytes = new byte[20]; int len = -1; StringBuffer sb = new StringBuffer(); while((len = in.read(bytes))!=-1){ sb.append(new String(bytes,0,len)); } in.close(); System.out.println(sb); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } public static void main(String[] args) { // byteReader();
reader1(); }

流转换

/** * 使用转换流，把字节流转换成字符流 */
public static void reader(){ try { //构造字节输入流
InputStream in = new FileInputStream("d:\\1.txt"); //通过字节输入流构造一个字符输入流
Reader reader = new InputStreamReader(in); char[] cs = new char[50]; int len = -1; StringBuilder sb = new StringBuilder(); while((len=reader.read(cs))!=-1){ sb.append(new String(cs,0,len)); } //关闭流
reader.close(); in.close(); System.out.println(sb); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } /** * 使用转换流，把字符流转换成字节流输出 * OutputStreamWriter */
public static void writer(){ try { //构造一个字节输出流
OutputStream out = new FileOutputStream("d:\\3.txt"); String info = "山不在高，有仙则名；学JAVA，没威哥不行"; //通过字节输出流构造一个字符输出流
Writer writer = new OutputStreamWriter(out); writer.write(info);//输出 //关闭流
writer.close(); out.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } public static void main(String[] args) { // writer();
reader(); }

BufferedReader & BufferedWriter

/** * 使用缓冲流实现读取操作 */
public static void reader(){ try { Reader r = new FileReader("d:\\5.txt"); //根据字符输入流构造一个字符缓中流
BufferedReader br = new BufferedReader(r); char[] cs = new char[512]; int len = -1; StringBuilder sb = new StringBuilder(); while((len=br.read(cs))!=-1){ sb.append(new String(cs,0,len)); } br.close(); r.close(); System.out.println(sb); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block
e.printStackTrace(); } } /** * 使用缓冲流实现写入操作 */
public static void write(){ try { Writer w = new FileWriter("d:\\5.txt"); //根据字符输出流构造一个字符缓冲流
BufferedWriter bw = new BufferedWriter(w); bw.write("小白，怎么了，这是，被驴踢了吧"); bw.flush();//刷新
bw.close(); w.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } public static void main(String[] args) { // write();
reader(); }

BufferedInputStream　＆　BufferedOutputStream　　　　　

public static void write(){ try { OutputStream out = new FileOutputStream("d:\\4.txt"); //根据字节输出流构造一个字节缓冲流
BufferedOutputStream bos = new BufferedOutputStream(out); String info = "good good study , day day up"; bos.write(info.getBytes()); bos.flush();//刷新缓冲区
bos.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } /** * 使用字节缓冲流进行读取操作 */
public static void input(){ try { InputStream in = new FileInputStream("d:\\4.txt"); //根据字节输入流构造一个字节缓冲流
BufferedInputStream bis = new BufferedInputStream(in); Reader r = new InputStreamReader(bis); char[] cs = new char[512]; int len = -1; StringBuilder sb = new StringBuilder(); while((len=r.read(cs))!=-1){ sb.append(new String(cs,0,len)); } r.close(); bis.close(); in.close(); System.out.println(sb); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block
e.printStackTrace(); } } public static void main(String[] args) { // input();
write(); }

PrintStream

/** * 使用PrintWriter打印流 */
public static void print2(){ try { BufferedWriter bw = new BufferedWriter(new FileWriter("d:\\2.txt")); PrintWriter pw = new PrintWriter(bw); pw.print("\r\n");//输出回车加换行符
pw.println(105); pw.println("张三李四王五"); pw.flush(); pw.close(); bw.close(); } catch (IOException e) { e.printStackTrace(); } } /** * 使用PrintStream打印流 */
public static void print(){ try { OutputStream out = new FileOutputStream("d:\\1.txt"); BufferedOutputStream bos = new BufferedOutputStream(out); //构造字节打印流对象
PrintStream ps = new PrintStream(bos);//             ps.println(3.14f); ps.println(188); ps.println(true); ps.println("好好学习，天天向上"); //关闭流 ps.flush(); out.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block
e.printStackTrace(); } } public static void main(String[] args) { // print();
print2(); }

ObjectStream

/** * 类通过实现 java.io.Serializable 接口以启用其序列化功能,标记接口，没有任何方法 */
public class Dog implements Serializable{ private String name; private transient int age; //使用transient关键字声明的属性将不会被序列化

public Dog() { super(); } public Dog(String name, int age) { super(); this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "Dog [name=" + name + ", age=" + age + "]"; } }

/** * 从文件中读取对象数组 */
public static void readerObject2(){ try { InputStream in = new FileInputStream("d:\\obj.tmp"); //根据字节输入流构造一个对象流
ObjectInputStream ois = new ObjectInputStream(in); //读取一个对象
Dog[] dogs = (Dog[])ois.readObject(); //关闭
ois.close(); in.close(); for (Dog dog : dogs) { System.out.println(dog); } } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } } /** * 把一组对象序列化到文件中 */
public static void writerObject2(){ try { OutputStream out = new FileOutputStream("d:\\obj.tmp"); //根据字节输出流构造一个对象流
ObjectOutputStream oos = new ObjectOutputStream(out); Dog[] dogs = {new Dog("小白",8),new Dog("小黑",2),new Dog("小红",4)}; // Dog dog1 = new Dog("小白",8); // Dog dog2 = new Dog("小黑",2); // Dog dog3 = new Dog("小红",4);
oos.writeObject(dogs);//向文件写入对象 //关闭流
oos.close(); out.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } /** * 使用ObjectInputStream读取文件中的对象 */
public static void readerObject(){ try { InputStream in = new FileInputStream("d:\\obj.tmp"); //根据字节输入流构造一个对象流
ObjectInputStream ois = new ObjectInputStream(in); //读取一个整数
int num = ois.readInt(); //读取一个对象
Dog dog = (Dog)ois.readObject(); //关闭
ois.close(); in.close(); System.out.println("num="+num); System.out.println(dog); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } } /** * 使用ObjectOutputStream把对象写入文件中 */
public static void writerObject(){ try { OutputStream out = new FileOutputStream("d:\\obj.tmp"); //根据字节输出流构造一个对象流
ObjectOutputStream oos = new ObjectOutputStream(out); //输出数据
oos.writeInt(106); Dog dog = new Dog("小白",8); oos.writeObject(dog);//向文件写入对象 //关闭流
oos.close(); out.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } public static void main(String[] args) { // writerObject(); // readerObject(); // writerObject2();
readerObject2(); }

ByteArrayStream

/** * 使用ByteArrayOutputStream写操作 */
public static void write(){ //创建一个字节数组输出流对象
ByteArrayOutputStream baos = new ByteArrayOutputStream(); String info = "好好学习，天天向上！"; try { //往缓冲区中输出数据
baos.write(info.getBytes()); baos.write(10); // baos.toByteArray();
baos.close();//关闭无效
} catch (IOException e) { e.printStackTrace(); } //根据一个字节数组构造一个字节数组输入流
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); byte[] bytes = new byte[512]; int len = -1; StringBuilder sb = new StringBuilder(); try { while((len=bais.read(bytes))!=-1){ sb.append(new String(bytes,0,len)); } } catch (IOException e) { } System.out.println(sb); } public static void main(String[] args) { write(); }

DataStream

public static void reader(){ try { InputStream in = new FileInputStream("d:\\3.txt"); //根据字节输入流构造一个数据输入流
DataInputStream dis = new DataInputStream(in); int flag = dis.readInt();//读取一个整数
String info = dis.readUTF();//读取一个UTF编码的字符串 //关闭流
dis.close(); in.close(); System.out.println("flag="+flag); System.out.println("info="+info); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } public static void write(){ try { OutputStream out = new FileOutputStream("d:\\3.txt"); //根据字节输出流构造一个数据输出流
DataOutputStream dos = new DataOutputStream(out); dos.writeInt(1);//输出一个整数
dos.writeUTF("好好学习天天向上..."); dos.close(); out.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } public static void main(String[] args) { // write();
reader(); }

StringStream

public static void writer(){ //写入操作
StringWriter sw = new StringWriter(); sw.write("好好学习。。天天向上 。。。"); //----------------------------------------- //读取操作,根据一个字符串去构造一个字符串输入流
StringReader sr = new StringReader(sw.toString()); char[] cs = new char[10]; int len = -1; try { while((len=sr.read(cs))!=-1){ System.out.print(new String(cs,0,len)); } } catch (IOException e) { e.printStackTrace(); } } public static void main(String[] args) { writer(); }

学习Java的同学注意了！！！
学习过程中遇到什么问题或者想获取学习资源的话，欢迎加入Java学习交流群，群号码：286945438 我们一起学Java！