`

Java IO流 续

JAVAIO流 
阅读更多

1.基于字节文件读写

  • FileInputStream和FileOutputStream分别继承自InputStream和OutputStream用于向文件中输入和输出字节。
  • FileInputStream和FileOutputStream的常用构造方法：
    FileInputStream(String name) throws FileNotFoundException
    FileInputStream(File file)   throws FileNotFoundException
    FileOutputStream(String name)throws FileNotFoundException
    FileOutputStream(File file)  throws FileNotFoundException
    FileOutputStream(File file, boolean append)throws FileNotFoundException
  • 注意：
    在实例化FileInputStream和FileOutputSteam流时要用try－catch语句以处理其可能抛出的FileNotFoundException。
    在读写数据时也要用try－catch语句以处理可能抛出的 IOException。
    FileNotFoundException是IOException的子类
  • 读
package javaio.inputstream;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
 * 将TestFileInputStream.java中的内容读出来
 * @author Administrator
 *
 */
public class TestFileInputStream {
	public static void main(String[] args) {
		FileInputStream in = null;
		try {
			in = new FileInputStream("D:\\TestFileInputStream.java");
		} catch (FileNotFoundException e) {
			System.out.println("没有找到TestFileInputStream.java文件");
			e.printStackTrace();
			return;
		}
		//如果流不为空循环流
		if(in!=null){
			StringBuffer buffer = new StringBuffer();
			byte b[] = new byte[1024];
			try {
				while (in.read(b)!=-1) {
					buffer.append(new String(b));
					b = new byte[1024];
				}
				System.out.println(buffer.toString());
			} catch (IOException e) {
				System.out.println("读取错误");
				e.printStackTrace();
				return;
				//关闭流
			}finally{
				if(in!=null){
					try {
						in.close();
						in = null;
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
			}
		}
	}
}
  •  写
package javaio.outputstream;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 将TestFileInputStream.java中的内容读出来然后写入到TestFileInputStream2.java
 * 
 * @author Administrator
 * 
 */
public class TestFileOutputStream {
	public static void main(String[] args) {
		FileInputStream in = null;
		FileOutputStream out = null;
		try {
			in = new FileInputStream("D:\\TestFileInputStream.java");
			out = new FileOutputStream("D:\\TestFileInputStream2.java");
			if(in!=null){
				StringBuffer buffer = new StringBuffer();
				byte b[] = new byte[1];
				while (in.read(b)!=-1) {
					buffer.append(new String(b));
					out.write(b);
					b = new byte[1];
				}
			}
		} catch (FileNotFoundException e) {
			System.out.println("没有找到TestFileInputStream.java文件");
			e.printStackTrace();
			return;
		} catch (IOException e) {
			System.out.println("读取或写入发生错误");
			e.printStackTrace();
		}finally {
		  	try {
		  		if(in != null) {
		  			in.close(); 
		  			in = null;
		  		}
		    } catch(IOException e) {
		    	e.printStackTrace();
		    }
		  	try {
		  		if(out != null) {
		  			out.flush();
		    		out.close();
		    		out = null;
		    	} 
		    } catch(IOException e) {
		    	e.printStackTrace();
		    }
		  }
	}
}

 2.基于字符文件读写

  • FileReader 和 FileWriter 分别继承自Reader和Writer，FileInputSteam与FileOutputStream类似，所不同的是FileReader和FileWriter向文件输入和输出的数据单位为字符。
  • FileReader和FileWriter的常用构造方法：
    public FileWriter(File file) throws IOException
    public FileWriter(File file, boolean append)throws IOException
    public FileWriter(String fileName)throws IOException
    public FileWriter(String fileName,boolean append)throws IOException
    public FileReader(String fileName)throws FileNotFoundException
    public FileReader(File file) throws FileNotFoundException
  • 读
package javaio.reader;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/**
 * 读取指定文件内容
 * 
 * @author Administrator
 * 
 */
public class TestFileReader {
	public static void main(String[] args) {
		FileReader reader = null;
		try {
			reader = new FileReader("D:\\TestFileReader.java");
			if(reader!=null){
				StringBuffer buffer = new StringBuffer();
				char b[] = new char[1024];
				while (reader.read(b)!=-1) {
					buffer.append(new String(b));
					b = new char[1024];
				}
				System.out.println(buffer.toString());
			}
		} catch (FileNotFoundException e) {
			System.out.println("没有找到TestFileReader.java文件");
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if(reader != null) {
				try{
					reader.close();
				}
				catch (IOException e){
					e.printStackTrace();
				}
				reader = null;
			}
		}
	}
}

 

  • 写
package javaio.writer;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/**
 * 将TestFileReader.java内容写入到TestFileReader2.java中
 * @author Administrator
 *
 */
public class TestFileWriter {
	public static void main(String[] args) {
		FileReader reader = null;
		FileWriter writer = null;
		try {
			reader = new FileReader("D:\\TestFileReader.java");
			writer = new FileWriter("D:\\TestFileReader2.java");
			if(reader!=null){
				char b[] = new char[1];
				while (reader.read(b)!=-1) {
					writer.write(b);
				}
			}
		} catch (FileNotFoundException e) {
			System.out.println("没有找到TestFileReader.java文件");
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if(reader != null) {
				try{
					reader.close();
				}
				catch (IOException e){
					e.printStackTrace();
				}
				reader = null;
			}
			if(writer != null) {
				try{
					writer.flush();
					writer.close();
				}
				catch (IOException e){
					e.printStackTrace();
				}
				writer = null;
			}
		}
	}
}

 

3.什么时候使用字节流？什么时候使用字符流？

  • 任何数据存在硬盘上时，都是以二进制的形式存储的。
  • 通过使用字节流，可以读取任意文件。字节流一次读取一个字节，而字符流使用了字节流读到一个或者多个字节时，去查找指定的编码表，返回对应的编码。所以字符流只能处理纯文本字符数据，而字节流可以处理更多类型的数据，比如图片，视频，音频文件等。
  • 只要是纯文本数据处理，优先考虑使用字符流。其他情况就使用字节流。

4.缓冲流

  • 缓冲流-Buffered:缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率
  • 读写
    BufferedReader提供了readLine方法用于读取一行字符串（以\r或\n分隔）。
    BufferedWriter提供了newLine用于写入一个行分隔符。
    对于输出的缓冲流，写出的数据会先在内存中缓存，使用flush方法将会使内存中的数据立刻写出。
  • 常用的构造方法
    BufferedReader(Reader in)
    BufferedReader(Reader in,int size) //size 为自定义缓存区的大小
    BufferedWriter(Writer out)
    BufferedWriter(Writer out,int sz)
    BufferedInputStream(InputStream in)
    BufferedInputStream(InputStream in,int size)
    BufferedOutputStream(OutputStream out)
    BufferedOutputStream(OutputStream out,int size)
  • 基于字节读
package javaio.buffered;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
/**
 * 使用缓冲流读取指定文件内容
 * @author Administrator
 *
 */
public class TestBufferedInputStream {
	  public static void main(String[] args) {
		  	BufferedInputStream bis = null;
		    try {
		      InputStream fis =  new FileInputStream("D:\\TestFileInputStream.java");
		      bis = new BufferedInputStream(fis);
		      if(bis!=null){
					StringBuffer buffer = new StringBuffer();
					byte b[] = new byte[1024];
					while (bis.read(b)!=-1) {
						buffer.append(new String(b));
						b = new byte[1024];
					}
					System.out.println(buffer.toString());
		      }
		      System.out.println(); 
		     
		    } catch (IOException e) {
		    	e.printStackTrace();
		    } finally {
		    	 try {
		    	 	if(bis != null) {
		    	 		bis.close();
		    	 		bis = null;
		    	 	}
		    	} catch (IOException e) {
		    		e.printStackTrace();
		    	}
		    }
		  }
}
  •  基于字节写
package javaio.buffered;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
 * 使用缓冲流读取指定文件内容复制到另一个文件
 * @author Administrator
 *
 */
public class TestBufferedOutputStream {
	public static void main(String[] args) {
		BufferedInputStream bis = null;
		BufferedOutputStream bos = null;
		try {
			InputStream fis = new FileInputStream("D:\\TestFileInputStream.java");
			OutputStream out = new FileOutputStream("D:\\TestFileInputStream3.java");
			bis = new BufferedInputStream(fis);
			bos = new BufferedOutputStream(out);
			if (bis != null) {
				StringBuffer buffer = new StringBuffer();
				byte b[] = new byte[1];
				while (bis.read(b) != -1) {
					buffer.append(new String(b));
					bos.write(b);
					b = new byte[1];
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (bis != null) {
					bis.close();
					bis = null;
				}
				if (bos != null) {
					bos.flush();
					bos.close();
					bos = null;
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}
  •  基于字符读写
package javaio.buffered;

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

/**
 * 从指定文件中用BufferedReader读取数据然后用BufferedWriter写入另一个文件中
 * 
 * @author Administrator
 * 
 */
public class TestBufferedReaderAndWriter {
	public static void main(String[] args) {
		BufferedReader breader = null;
		BufferedWriter bwriter = null;
		try {
			Reader reader = new FileReader("D:\\TestFileReader.java");
			Writer writer = new FileWriter("D:\\TestFileReader3.java");
			breader = new BufferedReader(reader);
			bwriter = new BufferedWriter(writer);
			if(breader!=null){
				while(breader.ready()){
					bwriter.write(breader.readLine());
					bwriter.newLine();
				}
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(bwriter!=null){
				try {
					bwriter.flush();
					bwriter.close();
					bwriter = null;
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(breader!=null){
				try {
					breader.close();
					breader = null;
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

 5.转换流

  • InputStreamReader和OutputStreamWriter用与字节数据到字符数据之间的转换。
  • InputStreamReader需要和InputStream “套接”。
  • OutpStreamWriter需要和OutputStream “套接”。
  • 转换流在构造时可以指定其编码集合，例如：
     InputStream isr = new InputStreamReader(InputStream in, CharsetDecoder dec)
  • TestOutputStreamWriter

 

package javaio.transfer;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

/**
 * 将字节流转换为字符流输出
 * 
 * @author Administrator
 * 
 */
public class TestOutputStreamWriter {
	public static void main(String[] args) {
		OutputStreamWriter osw = null;
		try {
			osw = new OutputStreamWriter(new FileOutputStream("D:\\test.txt"),"gbk");
			osw.write("测试OutputStreamWriter");
			osw.write("\r\n");
			osw.write("测试OutputStreamWriter");
			osw.flush();
			osw.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}
  •  TestInputStreamReader
package javaio.transfer;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
/**
 * 在控制台写入内容保存到文件中
 * @author Administrator
 *
 */
public class TestInputStreamReader {
	public static void main(String args[]) {
		InputStreamReader isr = new InputStreamReader(System.in);
		BufferedReader br = new BufferedReader(isr);
		BufferedWriter writer = null;
		try {
			String str = br.readLine();
			writer = new BufferedWriter(new FileWriter("D:\\write.txt"));
			while (str != null) {
				if ("".equals(str)){
					break;
				}
				writer.write(str);
				writer.newLine();
				str = br.readLine();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(br!=null){
				try {
					br.close();
					br=null;
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(writer!=null){
				try {
					writer.flush();
					writer.close();
					writer=null;
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

6.数据流

  • DataInputStream和DataOutputStream分别继承自InputSteam和OutputStream，它属于过滤流，需要分别“套接”在InputStream 和OutputStream类型的节点流上。
  • DataInputStream和DataOutputStream提供了可以存取与机器无关的Java原始类型数据（如：int，double等）的方法。
  • DataInputStream和DataOutputStream的构造方法为:
    DataInputStream(InputStream in)
    DataOutputStream(OutputStream out)
  • TestDataStream
package javaio.datastream;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestDataStream {
	public static void main(String[] args) {
		DataOutputStream dos = null;
		DataInputStream dis = null;
		try {
			dos = new DataOutputStream(new FileOutputStream("d:\\data.txt"));
			dos.writeInt(5);
			dos.writeDouble(2.12);
			dos.flush();
			dos.close();
			
			dis = new DataInputStream(new FileInputStream("d:\\data.txt"));
			System.out.println(dis.readInt());
			System.out.println(dis.readDouble());
			dis.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

7.Print流

  • PrintWriter和PrintStream都属于输出流，分别针对与字符和字节。
  • PrintWriter和PrintStream提供了重载的print
  • println方法用于多种数据类型的输出。
  • PrintWriter和PrintStream有自动flush功能。
package javaio.print;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;

public class TestPrint {
	public static void main(String[] args) {
		PrintStream ps = null;
		try {
			FileOutputStream fos = new FileOutputStream("D:\\TestFileReader3.java");
			ps = new PrintStream(fos);
		} catch (IOException e) {
			e.printStackTrace();
		}

		if (ps != null) {
			System.setOut(ps);
		}
		System.out.println("我们是中国人");
		System.out.println("我们是中国人");
		if(ps!=null){
			ps.flush();
			ps.close();
		}
	}
}

 

8.Object流

  • 直接将Object写入或读出
  • transient声明的部分不会被序列化
  • Serializable接口:序列化
  • Externalizable 接口
    void writeExternal(ObjectOutput out) throws IOException
    void readExternal(ObjectInput in) throws IOException,ClassNotFoundException
package javaio.object;

import java.io.Serializable;

public class Person implements Serializable{
	private static final long serialVersionUID = 1L;
	private String name;
	private String sex;
	private transient int age = 20;
	public String getName() {
		return name;
	}
	public String getSex() {
		return sex;
	}
	public int getAge() {
		return age;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}

 

 

package javaio.object;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class TestObjectIO {
	public static void main(String args[]) throws Exception {
		
		Person person = new Person();
		person.setAge(23);
		person.setName("张三");
		person.setSex("男");
		FileOutputStream fos = new FileOutputStream("D://object.data");
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeObject(person);
		oos.flush();
		oos.close();
		
		FileInputStream fis = new FileInputStream("D://object.data");
		ObjectInputStream ois = new ObjectInputStream(fis);
		Person tReaded = (Person)ois.readObject();
		System.out.println(tReaded.getName() + " " + tReaded.getSex() + " " + tReaded.getAge());
	}
}

 

0
顶
0
踩
分享到：
| Java IO流
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    图片下载IO流代码参考

    标题中的“图片下载IO流代码参考”提示我们，这篇内容主要涉及的是如何使用Java的输入输出流（IO流）来实现图片的下载功能。在Java编程中，IO流是处理数据传输的核心工具，广泛应用于文件读写、网络通信等场景。在...

    Java IO流相关知识代码解析

    以上是对Java IO流相关知识的解析，涵盖了IO流的基本分类和使用方法，包括了流的转换、对象的序列化以及实现文件断点续传。在实际开发中，合理运用Java IO流可以有效地处理各种数据输入输出任务。

    java断点续传，刚刚整理出来多线程处理

    Java的`java.io`包提供了丰富的类，如`FileInputStream`、`FileOutputStream`、`RandomAccessFile`等，可以帮助我们进行复杂的文件操作。`RandomAccessFile`类尤其适合断点续传，因为它支持在文件的任意位置进行读写...

    java 段点续传 例子

    1. **文件IO操作**：Java的`java.io`包提供了丰富的文件输入/输出流类，如`FileInputStream`、`FileOutputStream`、`RandomAccessFile`等，这些类在断点续传中起到关键作用。特别是`RandomAccessFile`，它能让我们在...

    用Java实现断点续传

    4. **写入文件**：使用`java.nio`的FileChannel和ByteBuffer，从HTTP响应的输入流中读取数据，并将其写入本地文件，同时更新已下载的字节数。 5. **持续监控**：在下载过程中，不断检查网络连接状态，如果发现中断...

    java端点续传

    1. 文件IO流：Java的`java.io`包提供了丰富的文件输入/输出流类，如`FileInputStream`和`FileOutputStream`，它们是实现断点续传的基础。通过这些类，我们可以读取和写入文件，控制文件的特定位置进行操作。 2. ...

    java实现ftp断点续传Java实用源码整理learns

    使用`FTPClient`的`retrieveFileStream()`方法，然后使用`java.io`类如`BufferedInputStream`和`FileOutputStream`来处理流并写入本地文件。确保在下载过程中检查异常，如果发生中断，可以记录当前的位置以便下次续...

    Java Socket IO Thread 整合大文件与上传下载

    Java IO流处理是数据传输的核心，它负责读取和写入数据。在文件上传下载场景中，通常使用InputStream和OutputStream来读取和写入数据，BufferedInputStream和BufferedOutputStream可以提供缓冲，提高效率。对于大...

    JAVA实现HTTP断点续传[借鉴].pdf

    5. 使用`java.io.RandomAccessFile`或`java.nio.channels.FileChannel`等类将输入流的数据写入本地文件，从上次下载结束的位置开始追加。 需要注意的是，在实际应用中，我们还需要处理一些细节问题，如检查服务器...

    JAVA 上传音乐

    在Java编程语言中，上传音乐涉及的主要知识点是IO流（Input/Output Stream）的使用，特别是对于大文件如音乐的高效处理。IO流是Java中处理数据传输的核心机制，允许程序读取或写入数据到各种来源，如硬盘、网络、...

    输入输出流2

    IO流用来处理设备之间的数据传输。 java对数据的操作是通过流的方式。 java用于操作流的对象都在IO包中。 续51IO流，下载此文件，可先下载之前上传的51IO流

    从网络上获取资源

    在Java等编程语言中，IO流分为字节流和字符流两大类，涵盖了输入流、输出流、缓冲流、转换流等多个子类，用于处理各种类型的文件和网络通信。 在网络资源下载过程中，通常会用到HTTP协议，这是一种应用层协议，主要...

    java断点续传.doc

    为了保存接收到的字节流到本地文件，可以使用`java.io.RandomAccessFile`类。创建一个RandomAccessFile对象，并指定读写模式（"rw"）。使用`seek()`方法将文件指针定位到上次断点的位置，然后通过循环读取输入流的...

    Java文件断点续传实现原理解析

    Java 文件断点续传实现原理解析 Java 文件断点续传实现原理解析是指在文件传输过程中，实现断点续传的功能，即在文件传输过程中突然中断，重新连接后可以从上一次断点继续传输。这种技术在实际应用中非常广泛，例如...

    java文件传输源代码

    Java的IO流模型是文件传输的基础。流分为字节流（Byte Stream）和字符流（Character Stream），并有输入流（Input Stream）和输出流（Output Stream）之分。例如，`InputStream`和`OutputStream`用于处理字节流，`...

    java源码包---java 源码 大量 实例

    　Java数据压缩与传输实例，可以学习一下实例化套按字、得到文件输入流、压缩输入流、文件输出流、实例化缓冲区、写入数据到文件、关闭输入流、关闭套接字关闭输出流、输出错误信息等Java编程小技巧。 Java数组倒置...

    java实现的上传大文件以及压缩包，并且支持断点续传-上传大文件.zip

    在Java编程环境中，实现...总结起来，实现Java中的大文件上传、断点续传以及压缩包处理，需要理解Servlet多部分请求、文件流操作以及HTTP头部信息的使用。通过结合这些技术，可以构建出高效且用户友好的文件上传服务。

Magicbox
Global site tag (gtag.js) - Google Analytics