JavaIO技术

最新推荐文章于 2023-02-19 20:57:51 发布
最新推荐文章于 2023-02-19 20:57:51 发布
阅读量1.8k 收藏 3
点赞数
分类专栏： Java 文章标签： fontfontfontfontfont
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woblog/article/details/9445545
版权
IO

一、字节流

1、InputStream
2、OutputStream

二、字符流

Writer
Reader

BufferedWriter
BufferedReader

三、实例一：

import java.io.*;
	
	/*	字符流
		Writer
			|-FileWriter
	*/
	
	class FileTest 
	{
		public static void main(String[] args) throws IOException
		{	
			//创建一个FileWriter对象，同时会在制定目录创建一个文件
			FileWriter fw = new FileWriter("test.txt");
			
			//将字符写到流中
			fw.write("Test");
	
			//刷新缓冲中的数据，存到目的地
			//fw.flush();
			
			/*
			关闭流之前会刷新流
			flush和close区别：
			flush刷新后流还可以继续使用，close关闭流
			后不能使用
			*/
			fw.close();
		}
	}
实例二：
	import java.io.*;
	
	/*
		文件异常处理
	*/
	
	class IOExceptionTest 
	{
		public static void main(String[] args) 
		{
			FileWriter fw = null;
			try
			{
				fw = new FileWriter("Test.txt");
				fw.write("Test");
			}
			catch (IOException ie)
			{
				System.out.println(ie.toString());
			}
			finally {
				try
				{
					if(fw != null)
						fw.close();
				}
				catch (IOException ie)
				{
					System.out.println(ie.toString());
				}
			}
		}
	}

四、字符读取

实例一： 

import java.io.*;

/*
	文件读取
*/
class  FileReaderTest  
{
	public static void main(String[] args) throws IOException
	{
		read_2();
	}

	//读取一个字符
	public static void read_1() throws IOException {
		FileReader fr = new FileReader("FileReaderTest.java");
		
		int ch = 0;
		while((ch = fr.read()) != -1) {
			System.out.print((char)ch);
		}

		fr.close();
	}

	//读取到字符数组
	public static void read_2() throws IOException {

		FileReader fr = new FileReader("FileReaderTest.java");
		//定义一个字符数组
		char[] chs = new char[1024];

		int num = 0;
		while((num = fr.read(chs)) != -1) {
			System.out.print(new String(chs, 0 ,num));
		}

		fr.close();
	}
}

实例二： 

import java.io.*;

/*
	文件拷贝实例
	步骤：
		1、创建一个字符数组
		2、读取字符并写入
	
	注意：通过缓冲区中的readLine方法读取，不包括换行符
*/

class FileCopyTest
{
	public static void main(String[] args) throws IOException {
		copy_3();
	} 

	//通过缓冲区复制文件
	public static void copy_3() {
		BufferedReader bufr = null;
		BufferedWriter bufw = null;

		try
		{
			bufr = new BufferedReader(new FileReader("FileCopyTest.java"));
			bufw = new BufferedWriter(new FileWriter("copy_test.txt"));

			String str = null;

			while((str = bufr.readLine()) != null) {
				bufw.write(str);
				bufw.newLine();
				bufw.flush();
			}
		}
		catch (IOException ie)
		{
			throw new RuntimeException("文件读取失败！");
//			ie.printStackTrace();
		}
		finally
		{
			if (bufr != null)
			{
				try
				{
					bufr.close();
				}
				catch (IOException ie)
				{
					throw new RuntimeException("写文件关闭失败！");
				}
			}

			if (bufw != null)
			{
				try
				{
					bufw.close();
				}
				catch (IOException ie)
				{
					throw new RuntimeException("读文件关闭失败！");
				}
			}
		}
	}
	
	//读取一个字符数组
	public static void copy_2() {
		FileWriter fw = null;
		FileReader fr = null;
		
		try
		{
			
			fw = new FileWriter("Copy_2_test.txt");
			fr = new FileReader("FileCopyTest.java");

			char[] buf = new char[1024];

			int len = 0 ;

			while((len = fr.read(buf)) != -1) {
				fw.write(buf, 0, len);
			}
		}
		catch (IOException ie)
		{
			throw new RuntimeException("文件读取失败");
		}
		finally
		{
			if (fw != null)
			{
				try
				{
					fw.close();
				}
				catch (IOException ie)
				{
				}
			}

			if (fr != null)
			{
				try
				{
					fr.close();
				}
				catch (IOException ie)
				{
				}
			}
		}
	}

	//读取一个字符就写入
	public static void copy_1() throws IOException {
		FileWriter fw = new FileWriter("Copy_1_Test.txt");

		FileReader fr = new FileReader("FileCopyTest.java");

		int temp = 0;
		while((temp = fr.read()) != -1) {
			fw.write(temp);
		}

		fw.close();
		fr.close();
	}
}


五、自己实现readLine()


import java.io.*;

/*
	实现readLine

	原理：就是一个一个的读取字符，在判断改字符如果不是换行符，
	就存入缓冲区，如果是则返回缓冲区中的字符
*/
//MyBufferedReader
class MyBufferedReader
{
	private FileReader fr;

	public MyBufferedReader(FileReader fr) {
		this.fr = fr;
	}

	//读取一行方法
	public String myReadLine() throws IOException {
		//定义缓冲区
		StringBuilder sb = new StringBuilder();

		//读取字符
		int ch = 0;
		while ((ch = fr.read()) != -1)
		{
			if(ch == '\r')
				continue;
			if(ch == '\n')
				return sb.toString();
			else 
				sb.append((char)ch);
		}
		if(sb.length() != 0)
			return sb.toString();
		return null;
	}

	//关闭流
	public void myColse() throws IOException {
		fr.close();
	}
}
class MyReadLine 
{
	public static void main(String[] args) throws IOException
	{
		MyBufferedReader mybuf = new MyBufferedReader(new FileReader("test.txt"));

		String str = null;
		while((str = mybuf.myReadLine()) != null) {
			System.out.println(str);
		}
	}
}

六、自定义实现getLineNumber()

import java.io.*;

/*
	类 LineNumberReader
	int getLineNumber() 
          获得当前行号。 
	void setLineNumber(int lineNumber) 
          设置当前行号。 
	1、测试这两个方法
	2、自定义类实现上述方法
*/

class  BufferedLineNumber
{
	public static void main(String[] args) throws IOException
	{
		test_2();
	}
	
	//2
	public static void test_2() throws IOException {
		FileReader fr = new FileReader("BufferedLineNumber.java");
		MyBufferedLineNumber mybufr = new MyBufferedLineNumber(fr);

		String str = null;
		mybufr.setLineNum(100);
		while((str = mybufr.readLine()) != null) {
			System.out.println(mybufr.getLineNum() + ":" + str);
		}
	} 

	//1
	public static void test_1() throws IOException {
		LineNumberReader lnbr = new LineNumberReader(new FileReader("BufferedLineNumber.java"));
		
		lnbr.setLineNumber(100); //101开始
		String str = null;
		while((str = lnbr.readLine()) != null) {
			System.out.println(lnbr.getLineNumber() + ":" + str);
		}
	}
}

//自定义类，用来增强BufferedReader类
class MyBufferedLineNumber 
{
	public MyBufferedLineNumber(Reader r) {
		this.r = r;
	}
	
	public String readLine() throws IOException {
		i++;
		StringBuilder sb = new StringBuilder();

		int str = 0;
		while((str = r.read()) != -1) {
			if(str == '\r')
				continue;
			if(str == '\n')
				return sb.toString();
			sb.append((char)str);
		}
		if(sb.length() != 0)
			return sb.toString();
		return null;
	}
	
	public void close() throws IOException {
		r.close();
	}

	public int getLineNum() {
		return i;
	}

	public void setLineNum(int i) {
		this.i = i;
	}

	
	private Reader r;
	private int i;
}

字符流常用对象：
	FileReader
	FileWriter
	
	BufferedReader
	BufferedWriter

Java流操作规律

1，明确源和目的。

源：输入流。InputStream  Reader
目的：输出流。OutputStream  Writer。

2，操作的数据是否是纯文本。

是：字符流。
不是：字节流。

3，当体系明确后，在明确要使用哪个具体的对象。

通过设备来进行区分：
源设备：内存，硬盘。键盘
目的设备：内存，硬盘，控制台。

----------------------------------

字节流

一、字节流

InputStream
OutputStream

字节流缓冲区：
BufferedInputStream
BufferedOutputStream 

实例一；
import java.io.*;

/*
	字节流测试
	InputStream
	OutputStream

	注意：字节流写时，不需要刷新
*/

class StreamTest
{
	public static void main(String[] args) throws IOException
	{
		outputTest();
	}
	
	//一次性读取完
	public static void test_3() throws IOException {
		FileInputStream fis = new FileInputStream("Test.txt");
		int len = fis.available();
		byte[] temp = new byte[len];
		fis.read(temp);
		System.out.print(new String(temp));

		fis.close();
	}
	
	//读取一个字节数组
	public static void test_2() throws IOException {
		FileInputStream fis = new FileInputStream("Test.txt");
		
		byte[] temp = new byte[1024];
		int len = 0;
		while((len = fis.read(temp)) != -1) {
			System.out.print(new String(temp));
		}

		fis.close();
	}

	//读取一个打印一个
	public static void test_1() throws IOException {
		FileInputStream fis = new FileInputStream("Test.txt");

		int len = 0;
		while((len = fis.read()) != -1) {
			System.out.print((char)len + " ");
		}

		fis.close();
	}

	//输出
	public static void outputTest() throws IOException {
		FileOutputStream fos = new FileOutputStream("Test.txt");
		fos.write("这是字符串".getBytes());
		fos.close();
	}
}

拷贝图片文件

1，明确源和目的。

源：输入流。InputStream  Reader
目的：输出流。OutputStream  Writer。

2，操作的数据是否是纯文本。

是：字符流。
不是：字节流。

3，当体系明确后，在明确要使用哪个具体的对象。

通过设备来进行区分：
源设备：内存，硬盘。键盘
目的设备：内存，硬盘，控制台。

----------------------------------

字节流

一、字节流

InputStream
OutputStream

字节流缓冲区：
BufferedInputStream
BufferedOutputStream 

实例一；
import java.io.*;

/*
	字节流测试
	InputStream
	OutputStream

	注意：字节流写时，不需要刷新
*/

class StreamTest
{
	public static void main(String[] args) throws IOException
	{
		outputTest();
	}
	
	//一次性读取完
	public static void test_3() throws IOException {
		FileInputStream fis = new FileInputStream("Test.txt");
		int len = fis.available();
		byte[] temp = new byte[len];
		fis.read(temp);
		System.out.print(new String(temp));

		fis.close();
	}
	
	//读取一个字节数组
	public static void test_2() throws IOException {
		FileInputStream fis = new FileInputStream("Test.txt");
		
		byte[] temp = new byte[1024];
		int len = 0;
		while((len = fis.read(temp)) != -1) {
			System.out.print(new String(temp));
		}

		fis.close();
	}

	//读取一个打印一个
	public static void test_1() throws IOException {
		FileInputStream fis = new FileInputStream("Test.txt");

		int len = 0;
		while((len = fis.read()) != -1) {
			System.out.print((char)len + " ");
		}

		fis.close();
	}

	//输出
	public static void outputTest() throws IOException {
		FileOutputStream fos = new FileOutputStream("Test.txt");
		fos.write("这是字符串".getBytes());
		fos.close();
	}
}

拷贝图片文件

import java.io.*;

/*
	字节流拷贝文件
	1、将源文件与字节输入流相关联
	2、将目标文件与字节输出流相关联
	3、拷贝
*/

class CopyPic 
{
	public static void main(String[] args) 
	{
		FileInputStream fis = null;
		FileOutputStream fos = null;

		try
		{
			fis = new FileInputStream("c:\\1.bmp"); //源
			fos = new FileOutputStream("c:\\2.bmp"); //目标

			int len = 0;
			byte[] sub = new byte[1024];

			while((len = fis.read(sub)) != -1) {
				fos.write(sub, 0, len);
			}

		}
		catch (IOException ie)
		{
			throw new RuntimeException("文件拷贝失败！");
		}
		finally
		{
			if (fis != null)
			{
				try
				{
					fis.close();
				}
				catch (IOException ie)
				{
					throw new RuntimeException("源文件关闭失败！");
				}
			}

			if (fos != null)
			{
				try
				{
					fos.close();
				}
				catch (IOException ie)
				{
					throw new RuntimeException("源文件关闭失败！");
				}
			}
		}
	}
}


拷贝MP3

import java.io.*;

/*
	拷贝mp3
*/

class CopyMp3 
{
	public static void main(String[] args) throws IOException
	{
		long start = System.currentTimeMillis();
		copyTest();
		long end = System.currentTimeMillis();
		System.out.println((end - start) + "毫秒");
	}

	public static void copyTest() throws IOException {
		BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("c:\\1.mp3")); //源文件
		BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\\2.mp3")); //目标文件

		int len = 0;
		while((len = bufis.read()) != -1) {
			bufos.write(len);
		}

		bufis.close();
		bufos.close();
	}
}

四、自定义InputStream缓冲区
import java.io.*;

/*
	实现BufferedInputStreame功能
	步骤：
		1、首先定义InputStremae变量用来接受传进来的对象
		2、定义一字节数组和两个变量
*/

class MyBufferedInputStream
{
	private InputStream r;
	private int pos;
	private int count;
	private byte[] sub = new byte[1024];


	MyBufferedInputStream(InputStream r) {
		this.r = r;
	}

	public int read() throws IOException {
		if (count == 0) //如果count等于0说明字节数组中的数据取完了
		{
			count = r.read(sub); //取数据到缓冲区
			if (count < 0) //说明文件已经读取完了
				return -1;
			
			pos = 0; 
			byte b = sub[pos];
			count--; //计数器减一
			pos++; //位置自增
			return b & 0xff;
		} else if (count > 0)
		{
			byte b = sub[pos];
			count--;
			pos++;
			return b & 0xff;
		}
		return -1;
	}
	
	//close
	public void close() throws IOException {
		r.close();
	}
}

从键盘上读取数据

import java.io.*;

/*
	从键盘读取数据

	需求：
		1、从键盘读取一串数据 敲回车后全部打印
		2、如果输入over则停止输入
*/

class ReadIn 
{
	public static void main(String[] args) throws IOException
	{
		test_2();
	}
	
	//方式二 将InputStream流转成Reader流
	public static void test_2() throws IOException{
//		//获取键盘输入流
//		InputStream in = System.in;
//
//		//将字节流转换成字符流
//		InputStreamReader is = new InputStreamReader(in);
//
//		//为了提高读取效率使用缓冲技术
//		BufferedReader bufi = new BufferedReader(is);
		
		//1、键盘录入
//		BufferedReader bufi = new BufferedReader(new InputStreamReader(System.in));

		//2、读取文件
		BufferedReader bufi = new BufferedReader(new InputStreamReader(new FileInputStream("ReadIn.java")));

//		//将输出字节流转缓存字节流
//		OutputStream out = System.out;
//		OutputStreamWriter outw = new OutputStreamWriter(out);
//		BufferedWriter bufw = new BufferedWriter(outw);
		
		//1、输出到控制台
//		BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

		//2、输出到文件
		BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("test.txt")));

		String line = null;
		while((line = bufi.readLine()) != null) {
			if("over".equals(line))
				break;
			bufw.write(line);
			bufw.newLine();
			bufw.flush();
//			System.out.println(line);
		}
	}

	//方式一
	public static void test_1() throws IOException {
		InputStream in = System.in;
		StringBuilder sb = new StringBuilder();
		int ch = 0;
		while(true) {
			ch = in.read();
			
			if(ch == 13)
				continue;
			if(ch == 10) {
				if("over".equals(sb.toString()))
					break;
				System.out.println(sb.toString());
				sb.delete(0, sb.length());
			} else {
				sb.append((char)ch);
			}
		}
	}
}

自定义InputStream缓冲区

import java.io.*;

/*
	实现BufferedInputStreame功能
	步骤：
		1、首先定义InputStremae变量用来接受传进来的对象
		2、定义一字节数组和两个变量
*/

class MyBufferedInputStream
{
	private InputStream r;
	private int pos;
	private int count;
	private byte[] sub = new byte[1024];


	MyBufferedInputStream(InputStream r) {
		this.r = r;
	}

	public int read() throws IOException {
		if (count == 0) //如果count等于0说明字节数组中的数据取完了
		{
			count = r.read(sub); //取数据到缓冲区
			if (count < 0) //说明文件已经读取完了
				return -1;
			
			pos = 0; 
			byte b = sub[pos];
			count--; //计数器减一
			pos++; //位置自增
			return b & 0xff;
		} else if (count > 0)
		{
			byte b = sub[pos];
			count--;
			pos++;
			return b & 0xff;
		}
		return -1;
	}
	
	//close
	public void close() throws IOException {
		r.close();
	}
}

File类常用方法及实例

一、File类常见方法：

1、创建
boolean createNewFile()
 创建新文件，如果已存在，则不创建，与输出流不同
输出流会覆盖， 

创建文件夹
boolean mkdir() 
          创建此抽象路径名指定的目录。 
  boolean mkdirs() 
          创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。 


2、删除
boolean delete() 
          删除此抽象路径名表示的文件或目录。
        void deleteOnExit() 
          在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。  
3、判断
boolean canExecute() 
          该文件是否可执行
        boolean exists() 
          测试此抽象路径名表示的文件或目录是否存在。
        boolean isDirectory()
          该文件对象是否是目录
        boolean isFile();
         该文件对象是否是文件
        boolean isHidden()
        该文件是否是隐藏对象
        boolean isAbsolute() 
          测试此抽象路径名是否为绝对路径名。    
4、获取
String getName() 
          返回由此抽象路径名表示的文件或目录的名称。 
        String getPath() 
          将此抽象路径名转换为一个路径名字符串。 
        String getParent() 
          返回此抽象路径名父目录的路径名字符串；如
          果此路径名没有指定父目录，则返回 null。 
        String getAbsolutePath() 
          返回此抽象路径名的绝对路径名字符串。 
        long lastModified() 
          返回此抽象路径名表示的文件最后一次被修改的时间。
        long length() 
          返回由此抽象路径名表示的文件的长度。
          
static File[] listRoots() 
          列出可用的盘符。   
          
        String[] list()  
          列出File对象目录和文件
    5、更改
    boolean renameTo(File dest) 
          重新命名此抽象路径名表示的文件

二、目录列表

import java.io.*;

/*
	File类

	列出目录中的目录
*/

class  FileTest
{
	public static void main(String[] args) 
	{
		File f = new File("c:/testdir");
		removeDir(f);
	}

	
	//输出目录前面的空格
	public static String getLevel(int n) {
		StringBuilder sb = new StringBuilder();
		sb.append("|--");
		for(int i=0;i<n;i++) {
			sb.insert(0, "  ");
		}
		return sb.toString();
	}

	//递归删除一个目录
	public static void removeDir(File dir) {
		File[] files = dir.listFiles();

		for(File f : files) {
			if(f.isDirectory()) {
				removeDir(f);
			} else {
				out(f + "--file--" + f.delete());
			}
		}
		out(dir + "--dir--" + dir.delete());
	}

	//列出目录和文件1
	public static void showDir(File dir, int level) {
//		out(getLevel(level) + dir.getPath());
		level++;
		File[] files = dir.listFiles();
		for(File f : files) {
			if(f.isDirectory()) {
				showDir(f, level);
			} else {
				out(getLevel(level) + f.getName());
			}
		}
	}

	//输出
	public static void out(Object obj) {
		System.out.println(obj);
	}
}

三、打印流

该流可以打印各种类型的数据
1、PrintStream 字节打印流
构造方法参数：
(1)、File
(2)、字符串路径
(3)、字节输出流 OutputStream
2、PrintWriter 字符打印流
构造方法参数：
(1)、File
(2)、字符串路径
(3)、字节输出流 OutputStream
(4)、字符输出流 Writer
实例： 

import java.io.*;

class  PrintStreamDemo
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader bufr = 
			new BufferedReader(new InputStreamReader(System.in));

		PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);

		String line = null;

		while((line=bufr.readLine())!=null)
		{
			if("over".equals(line))
				break;
			out.println(line.toUpperCase());
			//out.flush();
		}

		out.close();
		bufr.close();

	}	
}

分割图片

import java.io.*;
import java.util.*;

class SplitFile 
{
	public static void main(String[] args) throws IOException
	{
		//splitFile();
		merge();
	}


	public static void merge()throws IOException
	{
		ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();

		for(int x=1; x<=3; x++)
		{
			al.add(new FileInputStream("c:\\splitfiles\\"+x+".part"));
		}

		final Iterator<FileInputStream> it = al.iterator();

		Enumeration<FileInputStream> en = new Enumeration<FileInputStream>()
		{
			public boolean hasMoreElements()
			{
				return it.hasNext();
			}
			public FileInputStream nextElement()
			{
				return it.next();
			}
		};

		SequenceInputStream sis = new SequenceInputStream(en);


		FileOutputStream fos = new FileOutputStream("c:\\splitfiles\\0.bmp");

		byte[] buf = new byte[1024];

		int len = 0;

		while((len=sis.read(buf))!=-1)
		{
			fos.write(buf,0,len);
		}

		fos.close();
		sis.close();
	}

	public static void splitFile()throws IOException
	{
		FileInputStream fis =  new FileInputStream("c:\\1.bmp");

		FileOutputStream fos = null;


		byte[] buf = new byte[1024*1024];

		int len = 0;
		int count = 1;
		while((len=fis.read(buf))!=-1)
		{
			fos = new FileOutputStream("c:\\splitfiles\\"+(count++)+".part");
			fos.write(buf,0,len);
			fos.close();
		}
		
		fis.close();
		
	}
}

SequenceInputStream合并文件

import java.io.*;
import java.util.*;
class SequenceDemo 
{
	public static void main(String[] args) throws IOException
	{

		Vector<FileInputStream> v = new Vector<FileInputStream>();

		
		v.add(new FileInputStream("c:\\1.txt"));
		v.add(new FileInputStream("c:\\2.txt"));
		v.add(new FileInputStream("c:\\3.txt"));

		Enumeration<FileInputStream> en = v.elements();

		SequenceInputStream sis = new SequenceInputStream(en);

		FileOutputStream fos = new FileOutputStream("c:\\4.txt");

		byte[] buf = new byte[1024];

		int len =0;
		while((len=sis.read(buf))!=-1)
		{
			fos.write(buf,0,len);
		}

		fos.close();
		sis.close();
	}
}

IO包中其他流

一、对象持久化

1、将Person对象写到文件

Person:

import java.io.*;
class Person implements Serializable
{
	
	public static final long serialVersionUID = 42L;

	private String name;
	transient int age;
	static String country = "cn";
	Person(String name,int age,String country)
	{
		this.name = name;
		this.age = age;
		this.country = country;
	}
	public String toString()
	{
		return name+":"+age+":"+country;
	}
}

ObjectStreamDemo：

import java.io.*;

class ObjectStreamDemo 
{
	public static void main(String[] args) throws Exception
	{
		//writeObj();
		readObj();
	}
	public static void readObj()throws Exception
	{
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));

		Person p = (Person)ois.readObject();

		System.out.println(p);
		ois.close();
	}

	public static void writeObj()throws IOException
	{
		ObjectOutputStream oos = 
			new ObjectOutputStream(new FileOutputStream("obj.txt"));

		oos.writeObject(new Person("lisi0",399,"kr"));

		oos.close();
	}
}

二、管道流

import java.io.*;

class Read implements Runnable
{
	private PipedInputStream in;
	Read(PipedInputStream in)
	{
		this.in = in;
	}
	public void run()
	{
		try
		{
			byte[] buf = new byte[1024];

			System.out.println("读取前。。没有数据阻塞");
			int len = in.read(buf);
			System.out.println("读到数据。。阻塞结束");



			String s= new String(buf,0,len);

			System.out.println(s);

			in.close();

		}
		catch (IOException e)
		{
			throw new RuntimeException("管道读取流失败");
		}
	}
}

class Write implements Runnable
{
	private PipedOutputStream out;
	Write(PipedOutputStream out)
	{
		this.out = out;
	}
	public void run()
	{
		try
		{
			System.out.println("开始写入数据，等待6秒后。");
			Thread.sleep(6000);
			out.write("piped lai la".getBytes());
			out.close();
		}
		catch (Exception e)
		{
			throw new RuntimeException("管道输出流失败");
		}
	}
}

class  PipedStreamDemo
{
	public static void main(String[] args) throws IOException
	{

		PipedInputStream in = new PipedInputStream();
		PipedOutputStream out = new PipedOutputStream();
		in.connect(out);

		Read r = new Read(in);
		Write w = new Write(out);
		new Thread(r).start();
		new Thread(w).start();


	}
}

三、RandomAccessFile对数据的随机访问

import java.io.*;


/*
RandomAccessFile

该类不是算是IO体系中子类。
而是直接继承自Object。

但是它是IO包中成员。因为它具备读和写功能。
内部封装了一个数组，而且通过指针对数组的元素进行操作。
可以通过getFilePointer获取指针位置，
同时可以通过seek改变指针的位置。


其实完成读写的原理就是内部封装了字节输入流和输出流。

通过构造函数可以看出，该类只能操作文件。
而且操作文件还有模式：只读r，，读写rw等。

如果模式为只读 r。不会创建文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常。
如果模式rw。操作的文件不存在，会自动创建。如果存则不会覆盖。

*/
class RandomAccessFileDemo 
{
	public static void main(String[] args) throws IOException
	{
		//writeFile_2();
		//readFile();

		//System.out.println(Integer.toBinaryString(258));

	}

	public static void readFile()throws IOException
	{
		RandomAccessFile raf = new RandomAccessFile("ran.txt","r");
		
		//调整对象中指针。
		//raf.seek(8*1);

		//跳过指定的字节数
		raf.skipBytes(8);

		byte[] buf = new byte[4];

		raf.read(buf);

		String name = new String(buf);

		int age = raf.readInt();


		System.out.println("name="+name);
		System.out.println("age="+age);

		raf.close();


	}

	public static void writeFile_2()throws IOException
	{
		RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
		raf.seek(8*0);
		raf.write("周期".getBytes());
		raf.writeInt(103);

		raf.close();
	}

	public static void writeFile()throws IOException
	{
		RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");

		raf.write("李四".getBytes());
		raf.writeInt(97);
		raf.write("王五".getBytes());
		raf.writeInt(99);

		raf.close();
	}
}

四、操作基本数据类型流

DataInputStream和DataOutputStream

/*
DataInputStream与DataOutputStream

可以用于操作基本数据类型的数据的流对象。

*/
import java.io.*;
class DataStreamDemo 
{
	public static void main(String[] args) throws IOException
	{
		//writeData();
		//readData();

		//writeUTFDemo();

//		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"),"gbk");
//
//		osw.write("你好");
//		osw.close();

//		readUTFDemo();

	}
	public static void readUTFDemo()throws IOException
	{
		DataInputStream dis = new DataInputStream(new FileInputStream("utf.txt"));

		String s = dis.readUTF();

		System.out.println(s);
		dis.close();
	}



	public static void writeUTFDemo()throws IOException
	{
		DataOutputStream dos = new DataOutputStream(new FileOutputStream("utfdate.txt"));

		dos.writeUTF("你好");

		dos.close();
	}

	public static void readData()throws IOException
	{
		DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));

		int num = dis.readInt();
		boolean b = dis.readBoolean();
		double d = dis.readDouble();

		System.out.println("num="+num);
		System.out.println("b="+b);
		System.out.println("d="+d);

		dis.close();
	}
	public static void writeData()throws IOException
	{
		DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));

		dos.writeInt(234);
		dos.writeBoolean(true);
		dos.writeDouble(9887.543);

		dos.close();

		ObjectOutputStream oos = null;
		oos.writeObject(new O());

		
	}
}

五、操作数组流

ByteArrayInputStream和ByteArrayOutputStream

/*
用于操作字节数组的流对象。

ByteArrayInputStream ：在构造的时候，需要接收数据源，。而且数据源是一个字节数组。

ByteArrayOutputStream： 在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。
这就是数据目的地。

因为这两个流对象都操作的数组，并没有使用系统资源。
所以，不用进行close关闭。


在流操作规律讲解时：

源设备，
	键盘 System.in，硬盘 FileStream，内存 ArrayStream。
目的设备：
	控制台 System.out，硬盘FileStream，内存 ArrayStream。


用流的读写思想来操作数据。


*/
import java.io.*;
class ByteArrayStream 
{
	public static void main(String[] args) 
	{
		//数据源。
		ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEFD".getBytes());

		//数据目的
		ByteArrayOutputStream bos = new ByteArrayOutputStream();

		int by = 0;

		while((by=bis.read())!=-1)
		{
			bos.write(by);
		}



		System.out.println(bos.size());
		System.out.println(bos.toString());

	//	bos.writeTo(new FileOutputStream("a.txt"));

	}
}

六、字符转换流

InputStreamReader和OutputStreamWriter

注意：中文GBK两个八位，最高位为1，也就是两个负数

编码实例1：

/*
编码：字符串变成字节数组。


解码：字节数组变成字符串。

String-->byte[];  str.getBytes(charsetName);


byte[] -->String: new String(byte[],charsetName);

*/
import java.util.*;
class  EncodeDemo
{
	public static void main(String[] args)throws Exception 
	{
		String s = "哈哈";

		byte[] b1 = s.getBytes("GBK");

		System.out.println(Arrays.toString(b1));
		String s1 = new String(b1,"utf-8");
		System.out.println("s1="+s1);

		//对s1进行iso8859-1编码。
		byte[] b2 = s1.getBytes("utf-8");
		System.out.println(Arrays.toString(b2));

		String s2 = new String(b2,"gbk");

		System.out.println("s2="+s2);

		

	}
}

编码实例2：记事本里面直接输入联通，打开乱码

这是因为将联通两个字编码后正好符合UTF-8读取规则，所以记事本将该文件识别成UTF-8格式，但是其实这个文件是GBK的，所以最后导致乱码

补充：UTF-8读取规则（在API,DataInputStream接口中，readUTF方法中）

开头为0，一个八位

开头为110,两个八位

开头为1110，三个八位


class EncodeDemo2 
{
	public static void main(String[] args) throws Exception
	{
		String s = "联通ͨ";

		byte[] by = s.getBytes("gbk");

		for(byte b : by)
		{
			System.out.println(Integer.toBinaryString(b&255));
		}


		System.out.println("Hello World!");
	}
}

字符编码3：编码转换

import java.io.*;

class EncodeStream 
{
	public static void main(String[] args) throws IOException 
	{
			//writeText();
			readText();
	}

	public static void readText()throws IOException 
	{
		InputStreamReader isr = new InputStreamReader(new FileInputStream("utf.txt"),"gbk");

		char[] buf = new char[10];
		int len = isr.read(buf);

		String str = new String(buf,0,len);

		System.out.println(str);

		isr.close();
	}
	public static void writeText()throws IOException 
	{
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("utf.txt"),"UTF-8");

		osw.write("你好");

		osw.close();
	}

}

爱上学习啊
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础知识——JavaIO
weixin_45680007的博客
02-01 1万+
Java io IO的基本分类 同步和异步的区别：同步是线程去查看是否完成，异步是完成的数据去提醒线程已经完成 参考资料 data = socket.read();socket本意为套接字，为ip+端口，我理解为一个数据载体 (BIO)阻塞io：未请求到数据即让出cpu (NIO not block io)非阻塞io：在 while 循环中不断地去询问内核数据是否就绪，这样会导致 CPU 占用率非...
java io技术精髓
04-17
【Java IO技术精髓】是Java开发中不可或缺的一部分，它涵盖了数据输入和输出的各种方式。Java IO的核心在于流（Stream），流分为两类：以字节为导向的流和以Unicode字符为导向的流。 1. **以字节为导向的流**主要...
Java IO技术
正在逐渐长大
02-24 577
最近又看了看IO技术的具体内容，记一下。 IO的由来：不管是对象的什么信息都是在内存中操作的（以前学操作系统、汇编等课程时总是纠结于RAM与ROM，后来才知道我根本就不必纠结那东西的），计算机一旦断电或者操作系统关闭，那么内存中的数据都会消失，因此要想个办法把这些数据保存起来以备下次使用，于是人类发明了各种介质来保存数据。我记得最初的计算机是用纸带打孔来记录数据的，这也是刁刁的( ⊙ o
Java IO 技术
jayvee's Blog
02-22 298
文章目录流的概念IO 流类体系InputStream / OutputStreamReader / Writer文件字节流文件字符流缓冲字节流缓冲字符流字节数组流 流的概念 按流的方向分类： 1. 输入流：数据流向是数据源到程序(以InputStream、Reader结尾的流)。 2. 输出流：数据流向是程序到目的地(以OutPutStream、Writer结尾的流)。 按处理的数据单元分类： 字节流：以字节为单位获取数据，命名上以 Stream 结尾的流一般是字节流，如FileInput
java IO技术
weixin_44722237的博客
10-24 155
package Demo; import javax.sql.rowset.FilteredRowSet; import java.io.*; public class Demo10 { public static void main(String[] args) throws Exception { //字符输出 (字节打印流) 与PrintWriter效果基本相同，但是进行字符输出时还是使用后者 PrintStream ps = new PrintStr.
Java中的IO技术使用总结
evan_man的专栏
07-21 3294
请尊重他人劳动成果，请勿随意剽窃，转载请注明，谢谢！转载请注明出处：http://blog.csdn.net/evan_man/article/details/51812678          Java中对于IO操作拥有的类有很多，很容易记混淆，需要读者认真梳理，这样才能使用的顺手，不至于出太大的错误。本篇博客将对Java中涉及到的所有IO操作，做一次总结，帮助各位去梳理一下看似混乱
JavaIO技术分析.rar_javaIO
09-21
Java I/O API之性能分析 IO API的可伸缩性对Web应用有着极其重要的意义。Java 1.4版以前的API中，阻塞I/O令许多人失望。从J2SE 1.4版本开始，Java终于有了可伸缩的I/O API。本文分析并计算了新旧I/O API在可伸缩性...
Java IO合集
09-24
Java IO和NIO是Java平台中用于输入/输出操作的核心组件。这两个库为开发者提供了处理数据传输的强大工具，无论是在磁盘、网络还是内存中。本合集包含了两本关于这些主题的专业书籍——"Java IO"和"Java NIO"，它们...
Java IO复用_动力节点Java学院整理
08-30
Java IO复用是一种提高服务器并发处理能力的技术，其目的是在处理大量并发连接时，既能保持高效，又能有效地利用系统资源。传统的并发编程模型通常将一个线程与一个连接绑定，但这种方法在面对高并发场景时，由于...
Java IO流文档
03-31
在Java中，输入输出流（简称IO流）是用来处理文件读写的核心技术之一。它主要包括两类：以字节为导向的流和以字符为导向的流。 ##### 1.1 以字节为导向的流 以字节为导向的流是指按照字节来进行数据读写的流，适用...
java基础之IO技术_1
wygsqsj的博客
12-14 647
IO技术我们也成为IO流，是Input（输入）和Output（输出）的简写，  IO技术是java中十分、特别、非常重要的一门技术，也是java的开发中使用频率相当高的技术，所以必须要掌握。
Java之IO流技术详解
Jan's的博客
04-11 1006
何为IO？ 首先，我们看看百度给出的解释。 I/O输入/输出(Input/Output)，分为IO设备和IO接口两个部分。 i是写入，Input的首字母。o是输出，Output的首字母。 IO 也称为IO流，IO = 流，它的核心就是对文件的操作，对于 字节 、字符类型的输入和输出流。 IO分类 IO流主要分为两大类，字节流和字符流。而按照作用分类，可以分为输入流和输出流。 流？ 在电脑上的数据有三种存储方式，一种是外存，一种是内存，一种是缓存。比如电脑上的硬盘，磁盘，U盘等都是外存，
Java IO篇 Java IO编程
最新发布
凤文Sharing的博客
02-19 1288
Java IO即Java 输入输出系统。不管我们编写何种应用，都难免和各种输入输出相关的媒介打交道，其实和媒介进行IO的过程是十分复杂的，这要考虑的因素特别多，比如我们要考虑和哪种媒介进行IO（文件、控制台、网络），我们还要考虑具体和它们的通信方式（顺序、随机、二进制、按字符、按字、按行等等）。Java类库的设计者通过设计大量的类来攻克这些难题，这些类就位于java.io包中。
Java IO 技术之基本流类
flex技术-gidlsl
01-20 106
Java IO 技术之基本流类 2011年03月08日 　　转自http://www.blogjava.net/coderdream/articles/65609. html 很好的一篇文章，谢谢作者 　　流式IO 　　流(Stream)是字节的源或目的。 　　 　　两种基本的流是：输入流(Input Stream)和输出流(Output Stream)。可从中读出一系列字...
java的IO技术中什么是I什么是O？
mark_to_win的专栏
05-01 2403
马克-to-win：很多老司机还搞不清什么是I什么是O。很简单，我有个土办法。以内存为单位，数据进内存叫In，出内存叫Out。读文件，是数据从硬盘进到内存，所以用in类型流来处理。 更多请见：https://blog.csdn.net/qq_44639795/article/details/102484792 ...
高性能IO模型浅析
weixin_34331102的博客
11-14 1291
高性能IO模型浅析 服务器端编程经常需要构造高性能的IO模型，常见的IO模型有四种：（1）同步阻塞IO（Blocking IO）：即传统的IO模型。（2）同步非阻塞IO（Non-blocking IO）：默认创建的socket都是阻塞的，非阻塞IO要求socket被设置为NONBLOCK。注意这里所说的NIO并非Java的NIO（New IO）库。（3）IO多路复用（IO Multiplexing...
Java中的IO技术简介
路漫漫 始于足下
06-30 1116
Linux网络IO模型简介1.阻塞IO模型2.非阻塞IO模型3.IO复用模型4.信号驱动IO模型5.异步IOIO多路复用技术Java的IO发展简史BIO伪异步IONIOAIO四种IO的对比[最好列出表格]...
Java I/O底层是如何工作的？
XHMLLH的专栏
12-22 1487
转自：http://www.codeceo.com/article/java-io-work.html 重点：操作系统的重要性！！！！！！！！！！ 本博文主要讨论I/O在底层是如何工作的。本文服务的读者，迫切希望了解Java I/O操作是在机器层面如何进行映射，以及应用运行时硬件都做了什么。假定你熟悉基本的I/O操作，比如通过Java I/O API读写文件。这些内容不在本文的讨论
Java IO流学习
weixin_34054866的博客
12-04 360
Java IO流学习   Java流操作有关的类或接口： Java流类图结构： 流的概念和作用 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。   在IO中涉及的设备文件包括文件、控制台、网络链接等，这其中又根据流的方向可以将两端的设备文件分为数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值