I/O基础

最新推荐文章于 2024-05-21 15:12:42 发布
最新推荐文章于 2024-05-21 15:12:42 发布
阅读量725 收藏
点赞数
文章标签： io 流

1、java.io包中定义了多个流类型（类或抽象类）来实现输入、输出功能；可以从不同角度对其进行分类：
  （1）按数据流的方向不同可以分为输入流和输出流。
  （2）按处理数据单位不同可以分为字节流和字符流。
  （3）按照功能不同可以分为节点流和处理流。
2、J2SDK所提供的所有流类型位于包java.io内，都分别继承自以下四种抽象流类型：
    
                          字节流                            字符流
                    
输入流              InputStream                        Reader

输出流              OutputStream                       Writer


java中 字符是两字节，16位；中文就是占两个字节。

 

InputStream的基本方法

 

//读取一个字节并以整数的形式返回（0~255）
//如果返回-1已到输入流的末尾
int read()throws IOException

//读取一系列字节并存储到一个数组buffer
//返回实际读取的字节数，如果读取前已到输入流的末尾，返回-1
int read (byte[] buffer) throws IOException


//读取length个字节,并存储到一个字节数组buffer，从offset位置开始
//返回实际读取的字节数，如果读取前已到输入流的末尾，返回-1
int read(byte[] buffer,int offset,int length)throws Ecception


//关闭流释放内存资源
void close() throws IOException

//跳过n个字节不读，返回实际跳过的字节数
long skip(long n)throws IOException

 

 

OutputStream的基本方法
//向输出流中写入一个字节数据，该字节数据为参数b的低8位
void write (int b) throws IOException

//将一个字节类型的数组中的数据写入输出流
void write (byte [] b)throws IOException

//将一个字节类型的数组中的从指定位置（off）开始的len个字节写入到输出流
void write(byte[] b,int off,int len)throws IOException

//关闭流释放内存资源
void close() throws IOException

//将输出流中缓冲的数据全部写出到目的地
void flush()throws IOException

 

 

Read的基本方法

//读取一个字符并以整数的形式返回(0~255)，如果返回-1已到输入流的末尾
int read()throws IOException

//读取一系列字符并存储到一个数组buffer，返回实际读取的字符数，如果读取前已到输入流的末尾返回-1
int read (char[] cbuf)throws IOException

int read(char[] cbuf,int offset,int length)throws IOException

void close()throws IOException

long skip(long n)throws IOException

 


Writer的基本方法
//向输出流中写入一个字符数据，该数据为参数b的低16位
void write(int c) throws IOException

//将一个字符类型的数组中的数据写入输出流
void write(char[] cbuf)throws IOException

//将一个字符类型的数组中的从指定位置（offset）开始的length个字符写入到输出流
void write(char[]cbuf,int offset,int length)throws IOException

//将一个字符串中的字符写入到输出流
void write(String str)throws IOException

//将一个字符串从offset开始的length个字符写入到输出流
void write(String str,int offset,int length)throws IOException

void close()

void flush();

 

 

 

3、节点流和处理流
  节点流可以从一个特定的数据源（节点）读写数据（如：文件，内存）。
  处理流是“连接”在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更强大的读写功能。
 
  只能建文件不能建目录
 
4、  节点流分类：
 
     类型                              字符流                                字节流
 
  File（文件）                 FileReader                        FileInputStream
                                       FileWriter                           FileOutputStream
 
  Memory Array              CharArrayReader               ByteArrayInputStream
                                       CharArrayWriter                  ByteArrayOutputStream
                             
  Memory String               String Reader                           -
                                        String Writer                             -
                             
  Pipe(管道)                  PipedReader                        PipedInputStream
                                     PipedWriter                           PipedOutputStream
     
  字节流example：

package Test;

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

public class TestFileInputStream {
	
	public static void main(String[] args) {
		
	
	FileInputStream in=null;
	try {
		in = new FileInputStream("D:\\Myeclipse\\workspace\\MyTest\\src\\Test\\TestFileInputStream.java");
	} catch (FileNotFoundException e) {
		// TODO Auto-generated catch block
		System.out.println("找不到指定的文件！");
		System.exit(-1);
		e.printStackTrace();
	}
	int b=0;
	int num=0;
	try {
		while((b=in.read())!=-1){
			System.out.print((char)b);
			num++;
			
		}
		in.close();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		
		System.out.println("读取文件出错！");
		System.exit(-1);
		e.printStackTrace();
	}
	
	
	}
	

}

package Test;

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

public class TestFileOutputStream {
	public static void main(String[] args) {
		FileOutputStream out=null;
		FileInputStream in=null;
		
		try {
			in=new FileInputStream("D:\\Myeclipse\\workspace\\MyTest\\src\\Test\\TestFileOutputStream.java");
			out=new FileOutputStream("D:\\Myeclipse\\workspace\\MyTest\\src\\Test\\TFO.java");
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			
			System.out.println("找不到指定的文件！");
			System.exit(-1);
			e.printStackTrace();
		}
		
		int b=0;
		try {
			while((b=in.read())!=-1){
				out.write(b);
			}
			
			in.close();
			out.close();
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			System.out.println("读取文件出错！");
			System.exit(-1);
			e.printStackTrace();
		}
		
		
	}

}


字符流example：

package Test;

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

public class TestReader {
	public static void main(String[] args) {
		FileReader fr=null;
		try {
			fr=new FileReader("D:\\Myeclipse\\workspace\\MyTest\\src\\Test\\TestReader.java");
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			System.out.println("找不到指定的文件！");
			System.exit(-1);
		}
		int b=0;
		try {
			while((b=fr.read())!=-1){
				System.out.print((char)b);
			}
			fr.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			System.out.println("读取文件出错！");
			System.exit(-1);
		}
		
	}

}

package Test;

import java.io.FileWriter;
import java.io.IOException;

public class TestWriter {
	public static void main(String[] args) {
		FileWriter fw=null;
		try {
			fw=new FileWriter("D:\\Myeclipse\\workspace\\MyTest\\src\\Test\\TW.java");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		try {
		for(int c=0;c<50000;c++){
			
				fw.write(c);
			}
		fw.close();
		}
		
		 catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		
	}
	

}





 

5、处理流分类：
6、缓冲流
  （1）输入缓冲流支持其父类的mark和reset方法
  （2）BufferedReader提供了readLine方法用于读取一行字符串（以\r或\n分割） 

public String readLine()
                throws IOException


  （3）BufferedWriter提供了newLine用于写入一个行分割符
  （4）对于输出的缓冲流，写出的数据会现在内存中缓存，使用flush方法将会使内存中的数据立刻写出。

 

 

   BufferedReader(Reader in)
  BufferedReader(Reader in,int sz)  //sz为自定义缓存区的大小
  BufferedWriter(Writer out)
  BufferedReader(Reader in,int sz)
  BufferedInputStream(InputStream in )
  BufferedInputStream(InputStream in ,int sz)
  BUfferedOutputStream(OutputStream out)
  BUfferedOutputStream(OutputStream out,int sz)

 

缓冲流example

import java.io.*;
public class TestBufferStream{
 public static void main(String[] args){
  try{
  
  FileInputStream in=new FileInputStream("F:\\JavaTest\\IO\\TestBufferStream.java");
  BufferedInputStream bis=new BufferedInputStream(in);
  int b=0;
  System.out.println((char)bis.read());
  System.out.println((char)bis.read());
  bis.mark(100);
  for(int i=0;i<10;i++){
   System.out.print((char)bis.read());
   }
   System.out.println();
   
   bis.reset();
   for(int i=0;i<10;i++){
   System.out.print((char)bis.read());
   }
  
  bis.close();
 }catch(IOException e){
  System.out.println("出错啦！");
  System.exit(-1);
  }
  
 }
}
 
 
 
注意：
mark就像书签一样，在这个BufferedReader对应的buffer里作个标记，以后再调用reset时就可以再回到这个mark过的地方。mark方法有个参数，通过这个整型参数，你告诉系统，希望在读出这么多个字符之前，这个mark保持有效。读过这么多字符之后，系统可以使mark不再有效，而你不能觉得奇怪或怪罪它。这跟buffer有关，如果你需要很长的距离，那么系统就必须分配很大的buffer来保持你的mark。     
     //eg.     
     //reader       is       a       BufferedReader     
       
     reader.mark(50);//要求在50个字符之内，这个mark应该保持有效，系统会保证buffer至少可以存储50个字符     
     int       a       =       reader.read();//读了一个字符     
     int       b       =       reader.read();//又读了一个字符     
       
     //做了某些处理，发现需要再读一次     
     reader.reset();     
     reader.read();//读到的字符和a相同     
     reader.read();//读到的字符和b相同
 
 
 

 
 
 
 
package Test;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class TestBufferStream2 {
	public static void main(String[] args) {
		
		BufferedWriter bw=null;
		BufferedReader br=null;
		FileWriter fw=null;
		try {
			fw=new FileWriter("D:\\Myeclipse\\workspace\\MyTest\\src\\Test\\TBF.java");
			br=new BufferedReader(new FileReader("D:\\Myeclipse\\workspace\\MyTest\\src\\Test\\TBF.java"));
		
		
		bw=new BufferedWriter(fw);
		String s=null;
		for(int i=0;i<100;i++){
			s=String.valueOf(Math.random());
			
				bw.write(s);
				bw.newLine();  //
			
			
			
		}
		bw.flush();   //
		
		while((s=br.readLine())!=null){                    //
			System.out.println(s);
		}
		bw.close();
		br.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

 

  转换流
  （1）InputStreamReader和OutputStreamWriter用于字节数据到字符数据的转换
  （2）InputStreamReader需要和InInputStream“套接”。
  （3）OutputStreamWriter需要和OutputStream“套接”。
  （4）转换流在构造时可以指定其编码集合，例如：InputStream isr=new InputStreamReader(System.in,"ISO8859_1")
  使用转换流后，对于写入，原本是一个字节一个字节地写入，现在可以直接写入一个字符串
  ISO8859_1是西欧语言编码，也称latin-1

 

转换流example

package Test;

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

public class TestTransFormal1 {

	public static void main(String[] args) {
		OutputStreamWriter osw;
		try {
			osw = new OutputStreamWriter(new FileOutputStream(
					"D:\\Myeclipse\\workspace\\MyTest\\src\\Test\\TTF1.java"));

			osw.write("asdfghjkl");
			System.out.println(osw.getEncoding());
			osw.close();
			osw = new OutputStreamWriter(new FileOutputStream(
					"D:\\Myeclipse\\workspace\\MyTest\\src\\Test\\TTF1.java",
					true), "ISO8859-1");
//   这里的true，使第二次写入接在原有的信息后面接着写，不加true，则擦除原有的内容重新写入新内容！
			osw.write("asdfghjkl");
			System.out.println(osw.getEncoding());
			osw.close();

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


 

package Test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class TestTransForml2 {
	public static void main(String[] args) {
		try {
			InputStreamReader isr = new InputStreamReader(System.in);                      //
			BufferedReader br = new BufferedReader(isr);
			String s = null;

			s = br.readLine();

			while (s != null) {
				if (s.equalsIgnoreCase("exit"))
					break;
				System.out.println(s.toUpperCase());
				s = br.readLine();
			}
			br.close();

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

	}
}


  数据流  DataOutputStream和ByteArrayOutputStream
  int占4个字节，long占8个字节
  float占4个字节，double占8个字节
  bool类型占1个字节

 

 

public class ByteArrayOutputStream
extends OutputStream
This class implements an output stream in which the data is written into a byte array. The buffer automatically grows as data is written to it. The data can be retrieved using toByteArray() and toString().

Closing a ByteArrayOutputStream has no effect. The methods in this class can be called after the stream has been closed without generating an IOException.

 

 

 

Constructor and Description
ByteArrayOutputStream()
Creates a new byte array output stream.
ByteArrayOutputStream(int size)
Creates a new byte array output stream, with a buffer capacity of the specified size, in bytes.

 

 

 

toByteArray
public byte[] toByteArray()
Creates a newly allocated byte array. Its size is the current size of this output stream and the valid contents of the buffer have been copied into it.
Returns:
the current contents of this output stream, as a byte array.
See Also:
size()

 

 

数据流example
 

package Test;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;

public class TestDataStream {

	public static void main(String[] args) {
		try {
			ByteArrayOutputStream bos = new ByteArrayOutputStream();               //
			DataOutputStream dos = new DataOutputStream(bos);

			dos.writeDouble(Math.random());

			dos.writeBoolean(true);

			ByteArrayInputStream bais = new ByteArrayInputStream(
					bos.toByteArray());                                //
			System.out.println(bais.available());                              //

			DataInputStream dis = new DataInputStream(bais);
			System.out.println(dis.readDouble());
			System.out.println(dis.readBoolean());
			dos.close();
			dis.close();

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

	}
}


 

  
  PrintWriter和PrintStream都属于输出流，分别针对字符和字节
  PrintWriter和PrintStream提供了重载的print
  PrintWriter和PrintStream的输出操作不会 抛出异常，用户通过检测错误状态获取错误信息
  PrintWriter和PrintStream有自动flush功能
 

 

import java.io.*;

public class TestPrintStream1{
	public static void main(String[] args){
		try{
		FileOutputStream fis=new FileOutputStream("F:\\JavaTest\\IO\\TestPrintStream1Log.txt");
		PrintStream ps=new PrintStream(fis);
		
		System.setOut(ps);
		int ln=0;
		for(char i=0;i<50000;i++){
			System.out.print(i);
			if(ln++==100){System.out.println();ln=0;}
			}
		}catch(IOException e){System.out.println("出错啦！");System.exit(-1);}
		
		}
	}


 

 

import java.io.*;

public class TestPrintStream2{
	public static void main(String[] args ){
		try{
		
		InputStreamReader  isr=new InputStreamReader(System.in);
		BufferedReader br=new BufferedReader(isr);
		
		FileWriter fos=new FileWriter("F:\\JavaTest\\IO\\TestPrintStream2Log.txt",true);
		PrintWriter ps=new PrintWriter(fos);
		String s=null;
		while((s=br.readLine())!=null){
			if(s.equals("exit"))break;
			System.out.println(s.toUpperCase());
			ps.println(s.toUpperCase());
			ps.flush();
			}
			
			br.close();
			ps.close();
		}catch(IOException e){System.out.println("出错啦！");System.exit(-1);}
		
		
		}
	}


 

 

import java.io.*;

public class TestPrintStream3{
	public static void main(String []args){
		String fileName=args[0];
		if(fileName!=null)list(fileName,System.out);
		}
		
		public static void list(String f,PrintStream fs){
			try{
			
			BufferedReader br=new BufferedReader(new FileReader(f));
			String s=null;
			while((s=br.readLine())!=null){
				fs.println(s);
				}
			br.close();
		}catch(IOException e){System.out.println("出错啦！");System.exit(-1);}
			}
	}
 
 
javac TestPrintStream3.java
java TestPrintStream3  TestPrintStream3.java
 
 
 


 

 

gchichafengyun
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于cos（腾讯云）上传文本内容丢失或者文本内容不全
m0_46649280的博客
04-28 798
byte[] contentBytes = content.getBytes(); InputStream input = new ByteArrayInputStream(contentBytes); ObjectMetadata objectMetadata = new ObjectMetadata(); objectMetadata.setCo...
探索Java I/O 模型的演进
08-25
在理解Java I/O模型之前，我们需要先了解一些基础概念，包括同步与异步、阻塞与非阻塞。 同步和异步是描述用户线程与内核交互方式的概念。同步I/O是指用户线程发起I/O请求后，需要等待内核完成I/O操作后才能继续...
腾讯云COS上传文件出现数据损坏问题
wan9x1nzZZ的博客
10-25 2874
给metadata的ContentLength属性赋值所要传输文件字节流的字节数.桶中能正常接收到文件，但是文件出现数据损坏，控制台报错为。另外COS上传文件的工具类分享给大家.
亚马逊云COS组件使用实践总结
小小默：进无止境
11-14 2万+
(1)创建目录对象 ```java AmazonS3 singleAmazonS3 = this.getSingleAmazonS3(); // 创建文件--带有文件目录 如 test1/test3/hello.txt Bucket bucket = cosFileSystem.getBucket(singleAmazonS3); singleAmazonS3.putObject(bucket.getName(),"test1/test3/hello.txt",new File("./hello.txt
腾讯云COS上传文件出现的问题
最新发布
Caoshilong1的博客
05-21 445
添加fileInputStream.close()解决。ObjectMetadata 的文件长度。使用 FileInputStream。使用完没有及时关闭导致报错。
遇到一个content-length的大坑（未解决）
weixin_48494122的博客
03-26 494
2，请求头带content-length，且与form-data字节数不一致，会报错org.springframework.web.multipart.MultipartException: Could not parse multipart servlet request;1，请求头带content-length，且与form-data字节数一致(请求头先不加content-length，代码中断点获取content-length)，会获取不到文件（接口加与不加requestparam都一样）
java基础之I/O流
10-12
Java中的I/O流是程序与外部数据交互的重要机制，它允许数据在程序、文件、网络等之间流动。I/O流分为两大类：字符流（Character Stream）和字节流（Byte Stream），每类又分为输入流（Input Stream）和输出流...
Java 新I/O
03-19
Java 新I/O，也称为NIO（New Input/Output），是Java平台中对传统I/O模型的一种改进。在Java 1.4版本中引入的NIO库为开发人员提供了更高效、非阻塞的数据处理方式，特别适用于高并发、低延迟的系统。NIO的核心在于...
I/O交互支持库
07-24
在IT领域，I/O交互支持库扮演着至关...总之，I/O交互支持库是软件开发中的基础工具，它简化了与系统进行数据交换的复杂性，使开发者能够专注于业务逻辑。理解并熟练运用这些库，对于任何IT专业人员来说都是必要的技能。
文件I/O基础-I.MX6U嵌入式Linux C应用编程学习笔记基于正点原子阿尔法开发板
05-08
文件I/O基础-I.MX6U嵌入式Linux C应用编程学习笔记基于正点原子阿尔法开发板
AMAZON S3(1)Introduction and File Upload API
快马扬鞭须努力！
03-08 1815
AMAZON S3(1)Introduction and File Upload API S3 Amazon Simple Storage Service(Amazon S3) - Simple Storage Service Price 5GB of Amazon S3, 20,000 Get requests, 2,000 Put Requests and 15GB of dat...
必须先将 ContentLength 字节写入请求流，然后再调用 [Begin]GetResponse。解决方法
qdz2597的专栏
05-21 7493
因为由于我们使用的是代理服务器，那个还有一种原因不能忽略，就是如果目标网页的HTTP的版本号为1.0或之前的版本，而代理服务器的本版为1.1或以上。这么这是，代理服务器将不会转发我们的Post请求，并报错‍（417） Unkown。 再看wireshark的包信息，其中明确可以看出，协议的版本号为HTTP1.1。这样，我们基本上可以确定‍（417） Unkown的原因： 握手失败，请求
Bytes to be written to the stream exceed the Content-Length bytes size specified 解决方法
weixin_34348111的博客
10-14 554
context.Response.ContentType = encode;               using (StreamWriter writer = new StreamWriter(context.Response.OutputStream, UTF8))    {          writer.Write(str);    }上面代码常会报错: Bytes to be writ...
System Error Codes
热门推荐
snail8384的专栏
08-13 8万+
From: http://msdn.microsoft.com/en-us/library/windows/desktop/ms681382%28v=vs.85%29.aspx Applies to: desktop apps only Note   The information on this page is intended to be used by programm
request.getContentLength()的值为-1的问题解决方案【HttpPost发起】
jellyjiao2008的专栏
09-28 1万+
1、问题的发现，服务端使用DataInputStream的方式获取流，直接上代码说明 try { DataInputStream in = new DataInputStream(request.getInputStream()); // 将请求消息的实体送到b变量中 int totalBytes = request.getContentLength(); byte[] b = ne...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值