IO流详细-阿里云开发者社区

开发者社区> 开发与运维> 正文

IO流详细

简介:


API中IO流的结构图

IO(intput output)流

特点:读写之间没有直接联系,读入数组,从数组写入硬盘

IO流用来处理设备之间的数据传输

Java对数据的操作是通过流的方式

Java用于操作流的对象都在IO包中

流按操作数据分两种:字节流(处理图片等)和字符流(早期只有字节流,字节流能处理所有文件,但是文本文件是很常见的,为了方便所以弄了字符流,内部融合了编码表)

流按流向分为:输入流,输出流(针对内存)

IO流常用的基类(大量运用了装饰者模式)

字节流的抽象类

    InputStream,OutputStream

字符流的抽象类

    Reader,Writer

有这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。

Writer类(字符流的输出类)

FileWriter

FileWriter fw = new FileWriter("demo.txt");//如果demo.txt里面有东西,里面的东西会被清空

fw.write("sdgdfh");//这里是将字符串写入流中,也就是内存中,由于它里面有缓冲,想要把数据写入目标文件的话,要调用fluesh()方法

FileWriter fw = new FileWriter("C:\\Users\\JSON\\Desktop\\a.txt");
//		fw.flush();//在写入前调用达不到效果,要在写入字符串后调用
		fw.write("aaaaa");
		fw.flush();//刷新缓冲区,将缓冲区的内容刷到目的地中
		fw.close();//它的效果和flush差不多,关前会刷新缓冲区,关了流再写东西,已经关闭了怎么东西呢?所以报错

在一个已有内容的文件末尾续写其它内容。

   FileWriter(String fileName, boolean append) 
          根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。更详细的看帮助文档。

package com.itheima.shipin1;

import java.io.FileWriter;

/**
 * 在一个有内容的txt文件中,继续写入其他东西
 *
 * @author Terry
 * @date 2014-6-10
 *
 */
public class FileWriterTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		FileWriter fw = new FileWriter("C:\\Users\\JSON\\Desktop\\a.txt",true);
		fw.write("bbbbb");//windows的当中,它的回车符是\r\n,其他的可以用\n
		fw.flush();
		fw.close();
	}

}

FileReader类

package com.itheima.shipin1;

import java.io.FileReader;
import java.io.FileWriter;

/**
 *
 *
 * @author Terry
 * @date 2014-6-10
 *
 */
public class FileWriterTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		FileReader fr = new FileReader("C:\\Users\\JSON\\Desktop\\a.txt");
		int ch = 0;
		while((ch = fr.read())!=-1){//回来看的时候,如果忘了看帮助文档
			System.out.println((char)ch);
		}
	}

}

package com.itheima.shipin1;

import java.io.FileReader;
import java.io.FileWriter;

/**
 * 
 * //这方法可以打印文件
 * @author Terry
 * @date 2014-6-10
 *
 */
public class FileWriterTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		FileReader fr = new FileReader("C:\\Users\\JSON\\Desktop\\a.txt");
//		char[] char1 = new char[3];
//		int num = fr.read(char1);//将内容读到char1里面,如果开始读了3个,后面再读2个,最后读的这2个覆盖数组里的前2两个,数组中的第三个元素还是原来第一次读的时候的那个
//		System.out.println(num + "::"+new String(char1));
//		int num1 = fr.read(char1);
//		System.out.println(num1 + "::"+new String(char1));
		int numb = -1;
//		char[] buf = new char[2];//通常情况下这里定的是1024的整数倍,1024是一字节
		char[] buf = new char[1024];
		while ((numb = fr.read(buf))!=-1) {//此时fr.read(buf)返回的是读的个数
			
			System.out.println(new String(buf,0,numb));
			
		}
	}

}


File类(操作文件的类)(重要)

常用方法

 创建:

boolean createNewFile()
          当且仅当不存在具有此抽象路径名指定名称的文件时,不可分地创建一个新的空文件。(文件如果存在则不创建,返回false)输出流创建的文件会覆盖原文件
boolean mkdir()
          创建此抽象路径名指定的目录。(创建文件夹,只能创建一级目录,aaa\\bbb\\ccc是不能创建的)
boolean mkdirs()
          创建此抽象路径名指定的目录,包括所有必需但不存在的父目录。(创建多级文件夹)

 

删除:

boolean delete()
          删除此抽象路径名表示的文件或目录。

void

deleteOnExit()
          在虚拟机终止时,请求删除此抽象路径名表示的文件或目录。(对文件做一系列动作时,最后要删除,但是突然出现异常,用上面的方法就删不掉,代码走不到他那就异常退出了,在程序退出时删除指定文件)

删除文件夹中的所有东西,包括自身

<pre class="java" name="code">package com.itheima.shipin1;

import java.io.File;

public class DeleteFile {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		File file = new File("F:\\新建文件夹");
		remove(file);
	}
	
	public static void remove(File file){	
		if(file.exists()){//不加if语句会报空指针异常
			for (File file1 : file.listFiles()) {
				if(file1.isDirectory())   // if(!file1.isHidden()&&file1.isDirectory())//这里以后最好都这样写,养成好//习惯
					remove(file1);
//					file1.delete();原本我是想在这用这方法删除的,但是看了视频后,还是在下面删除的好,可以少删除几次文件
				else
					System.out.println("delete:"+file1.delete());
			}
			System.out.println("delete:"+file.delete());
		}
	}
}


判断:

boolean exists()          测试此抽象路径名表示的文件或目录是否存在。
boolean isDirectory()          测试此抽象路径名表示的文件是否是一个目录。(先判断文件是否存在)
boolean isFile()          测试此抽象路径名表示的文件是否是一个标准文件。(先判断文件是否存在)
boolean isHidden()          测试此抽象路径名指定的文件是否是一个隐藏文件。
boolean isAbsolute()          测试此抽象路径名是否为绝对路径名。(文件不存在也行)

获取信息:

 String getName()          返回由此抽象路径名表示的文件或目录的名称。
 String getPath()          将此抽象路径名转换为一个路径名字符串。
String getParent()          返回此抽象路径名父目录的路径名字符串;如果此路径名没有指定父目录,则返回null
String getAbsolutePath()          返回此抽象路径名的绝对路径名字符串。
 long lastModified()          返回此抽象路径名表示的文件最后一次被修改的时间。
 long length()          返回由此抽象路径名表示的文件的长度。
boolean renameTo(File dest)          重新命名此抽象路径名表示的文件。

File file1 = new File("C:\\haha.java"):

File file2 = new File("D:\\hehe.java");

file1.renameTo(file2);

执行,原理是,把file的文件copy,然后删除,在把里面的内容写给file2,创建file2

重要的方法

static File[] listRoots()          列出可用的文件系统根。
String[] list()          返回一个字符串数组,这些字符串指定此抽象路径名表示的目录中的文件和目录。(隐藏文件也打印)
String[] list(FilenameFilter filter)          返回一个字符串数组,这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。

 

package com.itheima.shipin1;

import java.io.File;
import java.io.FilenameFilter;

/**
 * 实现文件筛选功能
 *
 * @author Terry
 * @date 2014-6-10
 *
 */
public class FileWriterTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		File file = new File("C:\\Users\\JSON\\Desktop\\学习");//目录文件
		String [] a = file.list(new FilenameFilter() {
			
			@Override
			public boolean accept(File dir, String name) {
				// TODO Auto-generated method stub
//				/**
//				 * 筛选条件自定义
//				 */
//				String [] a = name.split("\\.");
//				if(a[a.length-1].equals("java")){
//					return true;
//				}
//				return false;
				return name.endsWith(".java");
			}
		});
		
		
		
		/**
		 * 打印结果
		 */
		for (String string : a) {
			System.out.println(string);
		}
		
	}

}

File[] listFiles(FileFilter filter)
          返回抽象路径名数组,这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。
<pre class="java" name="code">package com.itheima.shipin1;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.io.IOException;

public class DeleteFile {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			go1();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public static void go1() throws Exception{
		File from = new File("F:\\海伦音标");
		File to = new File("F:\\test.txt");
		FileWriter fileWriter = new FileWriter(to);
		BufferedWriter bw = new BufferedWriter(fileWriter);
		fileList(from,to,bw);
	}
	
	/**
	 * 获取指定目录下的java文件的绝对路径,并存储到一个文本文件中。
	 * @param from:指定的文件
	 * @param to:将目录写到哪
	 * @throws Exception 
	 */
	public static void fileList(File from,File to,BufferedWriter bw) throws Exception{
		File[] files1 =  from.listFiles();
		for (File file : files1) {
			if(!file.isHidden()&&file.isDirectory())
				fileList(file, to, bw);
			else
				if(file.getName().endsWith(".java")){
					bw.write(file.getAbsolutePath()+"\r\n");
//					bw.write(file.getAbsolutePath());
//					bw.newLine();
//					bw.flush();
				}		
		}
		bw.close();//不关闭流,to文件中没有内容,因为写入的是内存,也可以调用bw.flush();,但要在close前面
		
	}
}

Properties类(还能操作硬盘上的键值对信息)

Properties是hashtable的子类,也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。是集合中和IO技术相结合的集合容器。

该对象的特点:可以用于键值对形式的配置文件。

XML:存储软件的一些基本配置信息

<pre class="java" name="code">package com.itheima.shipin1;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.util.Properties;
import java.util.Set;

public class DeleteFile {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		go2();
	}
	
	
	public static void go2(){
		Properties prop = new Properties();		
		prop.setProperty("zhangsan", "30");
		prop.setProperty("lisi", "39");		
//		System.out.println(prop);
		String value = prop.getProperty("lisi");
		System.out.println(value);
		Set<String> set = prop.stringPropertyNames();
		for (String s : set) {
			System.out.println(prop.getProperty(s));
		}
	}
}		


 void load(InputStream inStream)          从输入流中读取属性列表(键和元素对)。

操作一个已存在的.txt中的键值对内容

     

package com.itheima.shipin1;

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.FilenameFilter;
import java.io.Writer;
import java.util.Properties;
import java.util.Set;

public class DeleteFile {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			go2();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	
	public static void go2() throws Exception{
		Properties pt = new Properties();
		BufferedReader br = new BufferedReader(new FileReader("F:\\java\\BianChengRuanJian\\myeclipseworkspace\\LearningIOStream\\src\\com\\itheima\\shipin1\\ini.txt"));
		pt.load(br);//加载
		System.out.println(pt.get("zhangsan4"));
		pt.setProperty("zhangsan4", "11111");//修改
		System.out.println(pt.get("zhangsan4"));
		pt.load(br);//加载,为的是看看ini.txt的内容会被改不
		System.out.println(pt.get("zhangsan4"));//看到的结果是被更改了,但是ini.txt文件内的内容却没更改,要用save()方法但过时了
		Writer writer = new BufferedWriter(new FileWriter("F:\\java\\BianChengRuanJian\\myeclipseworkspace\\LearningIOStream\\src\\com\\itheima\\shipin1\\ini.txt"));
		//把properties类中的"zhangsan4"写入
		pt.store(writer, "zhangsan4");//这时候,ini.txt文件的内容被改了
		pt.setProperty("zhangsan3", "2222222");
		//指定的文件中,后面的string是注释信息,可加可不加
		pt.store(writer, "");
		pt.load(br);
		for (String string : pt.stringPropertyNames()) {
			System.out.println(string+"----"+pt.getProperty(string));
		}
	}
}	


小练习

1、用于记录应用程序运行次数。如果使用次数已到,那么给出注册提示

<pre class="java" name="code">Properties pp = new Properties();
		FileInputStream fis = new FileInputStream("F:\\java\\BianChengRuanJian\\myeclipseworkspace\\LearningIOStream\\src\\com\\itheima\\shipin1\\ini.txt");
		pp.load(fis);
		String frequencyOfUse1 = pp.getProperty("FrequencyOfUse");//作用是一样的,得到的字符以;结尾
//		String frequencyOfUse2 = (String) pp.get("FrequencyOfUse");//作用是一样的
		Integer temp = Integer.parseInt(frequencyOfUse1);
		if(temp>=3){//用3次
			System.out.println("试用期已过,请注册,(请给钱,亲)");
		}else{
			System.out.println(frequencyOfUse1);
			temp ++;
			pp.setProperty("FrequencyOfUse", temp.toString());
			FileWriter fw = new FileWriter("F:\\java\\BianChengRuanJian\\myeclipseworkspace\\LearningIOStream\\src\\com\\itheima\\shipin1\\ini.txt");
			pp.store(fw, "");
			fw.close();
		}


递归方法要注意的地方

1、循环条件

2、要注意递归的次数,尽量避免内存溢出

什么时候用递归:

递归与循环是两种不同的解决问题的典型思路。 递归算法: 优点:代码简洁、清晰,并且容易验证正确性。(如果你真的理解了算法的话,否则你更晕) 缺点:它的运行需要较多次数的函数调用,如果调用层数比较深,需要增加额外的堆栈处理,比如参数传递需要压栈等操作,会对执行效率有一定影响。但是,对于某些问题,如果不使用递归,那将是极端难看的代码。循环算法:  优点:速度快,结构简单。缺点:并不能解决所有的问题。有的问题适合使用递归而不是循环。如果使用循环并不困难的话,最好使用循环。递归算法 和循环算法总结  1.   一般递归调用可以处理的算法,也通过循环去解决常需要额外的低效处理 。2.   现在的编译器在优化后,对于多次调用的函数处理会有非常好的效率优化,效率未必低于循环。

IO包中的其他类

PrintWrite(字符打印流,作用很大)(Web开发的时候,最常用)

 该流提供了打印方法,可以原样的打印各种数据类型。print()方法。

 构造方法接收参数:比PrintStream多了4的构造参数方法

1、file对象。File

2、字符串路径。String

3、字节输出流。OutputStream

4、字符输出流。Writer

PrintStream(字节打印流)

SequenceInputStream(序列流)读取多个流对象成一个流对象

合并文件

/**
	 * 合并文件
	 * @throws Exception
	 */
	public static void go5() throws Exception{
		FileReader os1 = new FileReader("C:\\Users\\JSON\\Desktop\\1.txt");
		FileReader os2 = new FileReader("C:\\Users\\JSON\\Desktop\\2.txt");
		FileReader os3 = new FileReader("C:\\Users\\JSON\\Desktop\\3.txt");
		FileReader os4 = new FileReader("C:\\Users\\JSON\\Desktop\\4.txt");	
		List<FileReader> list = new ArrayList<FileReader>();
		list.add(os1);
		list.add(os2);
		list.add(os3);
		list.add(os4);
		byte[] temp = new byte[1024];
		String next = null;
		FileWriter fos = new FileWriter("C:\\Users\\JSON\\Desktop\\5.txt");
		BufferedWriter bw = new BufferedWriter(fos);
		for (FileReader b : list) {
			BufferedReader br = new BufferedReader(b);
			while ((next = br.readLine())!=null) {
				bw.write(next);
				bw.newLine();
			}
			br.close();
		}
		bw.close();
		fos.close();
	}
	
	/**
	 * 合并文件
	 * @throws Exception
	 */
	public static void go4() throws Exception{
		Vector<InputStream> vt = new Vector<InputStream>();
		vt.add(new FileInputStream("C:\\Users\\JSON\\Desktop\\1.txt"));
		vt.add(new FileInputStream("C:\\Users\\JSON\\Desktop\\2.txt"));
		vt.add(new FileInputStream("C:\\Users\\JSON\\Desktop\\3.txt"));
		vt.add(new FileInputStream("C:\\Users\\JSON\\Desktop\\4.txt"));	
		SequenceInputStream ss = new SequenceInputStream(vt.elements());
		byte[] temp = new byte[1024];
		int next = -1;
		FileOutputStream fos = new FileOutputStream("C:\\Users\\JSON\\Desktop\\5.txt");
		BufferedOutputStream bw = new BufferedOutputStream(fos);
		while ((next = ss.read(temp))!=-1) {
			bw.write(temp,0,temp.length);
		}
		bw.close();
		fos.close();
		ss.close();
	}

把一个大的文件切割成几个小的文件,然后在把这几个小的文件给合并成原文件。

package com.itheima.shipin1;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;

public class MergersAndCutting {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List list = new ArrayList();
		list.add("C:\\Users\\JSON\\Desktop\\cutting1.txt");
		list.add("C:\\Users\\JSON\\Desktop\\cutting2.txt");
		list.add("C:\\Users\\JSON\\Desktop\\cutting3.txt");
		try {
			cutting();
			merger(list);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 合并文件
	 */
	public static void merger(List<String> paths) throws Exception{
		InputStream is = null;
		OutputStream os = new FileOutputStream("C:\\Users\\JSON\\Desktop\\merger.flv");
		int len = -1;
		byte[] b = new byte[1024];
		for (String path : paths) {
			is = new FileInputStream(path);
			while ((len = is.read(b))!=-1) {
				os.write(b);			
			}
			is.close();
		}
		os.close();
	}
	
	public static void cutting() throws Exception{
		InputStream is = new FileInputStream("F:\\海伦音标\\1.flv");	
		OutputStream os = null;
		int len = 0;
		byte[] temp = new byte[1024*1024*2];
		int count = 1;
		while ((len = is.read(temp))!=-1) {
			os = new FileOutputStream("C:\\Users\\JSON\\Desktop\\cutting"+count+++".txt");
			os.write(temp);
			os.close();
		}
		is.close();
	}
}


ObjectInputStream和ObjectOutputStream(序列化和反序列化)使用频率不高,但有用到

对象存在堆内存,变量存在栈内存

要持久化存储的对象必须实现Serializable(序列化)接口

静态属性不能被序列化

transient  修饰的非静态成员变量,也不会被序列化。

ObjectOutputStream写的文件,只有ObjectInputStream才能读出来,我用自定义类加载器加载过,序列化多个文件,read一次返回第一个对象,再read一次返回第二个对象

package com.itheima.shipin1;

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

public class ObjectStream implements Serializable{
	People p = new People("zf",27);
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			serialization();//当把这里注释,然后改动People对象,运行unSerialization()时会报类有问题的异常。序列号不一样,序列号的//值来源于成员的变量
			unSerialization();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/**
	 * 把对象持久化存储
	 */
	public static void serialization() throws Exception{
		FileOutputStream fos = new FileOutputStream("C:\\Users\\Public\\Desktop\\test.obj");//要存储的目标文件
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		ObjectStream os = new ObjectStream();
		oos.writeObject(os.p);
	}
	
	/**
	 * 把对象反持久化
	 */
	public static void unSerialization() throws Exception{
		FileInputStream fos = new FileInputStream("C:\\Users\\Public\\Desktop\\test.obj");//要存储的目标文件
		ObjectInputStream oos = new ObjectInputStream(fos);
		
		People os = (People)oos.readObject();
		System.out.println(os.getClass());
		System.out.println(os.name+"---"+os.age);
	}
	
	class People implements Serializable{//内部类很麻烦,连改个外部类就会发生类有问题的异常
		String name;
		int 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;
		}


		public People(String name,int age){
			this.name = name;
			this.age = age;
		}
		
	}
}

管道流PipedInputStream和PipedOutputStream与多线程相关

管道输入流类

package com.itheima.pipedInputstream;

import java.io.PipedInputStream;

/**
 * 管道流IO
 *
 * @author Terry
 * @date 2014-6-14
 *
 */
public class PipedInputStreamThread implements Runnable{
	private PipedInputStream pipedInputStream ;
	
	public PipedInputStreamThread(PipedInputStream pipedInputStream){
		this.pipedInputStream = pipedInputStream;
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			byte[] a = new byte[1024];
			int len = 0;
//			while ((len = pipedInputStream.read(a))!= -1) {//这些程序会报错,返回的是读的字符个数
//				System.out.println(len);
//				String temp = new String(a);
//				System.out.println(temp);
//			}
			System.out.println("准备读数据");
			len = pipedInputStream.read(a);
			String temp = new String(a);
			System.out.println(temp);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		
	}
	
}

管道输出流类

package com.itheima.pipedInputstream;

import java.io.PipedOutputStream;

/**
 * 管道流IO
 *
 * @author Terry
 * @date 2014-6-14
 *
 */
public class PipedOutputStreamThread implements Runnable{
	private PipedOutputStream pipedOutputStream ;
	
	public PipedOutputStreamThread(PipedOutputStream pipedOutputStream){
		this.pipedOutputStream = pipedOutputStream;
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			Thread.sleep(5000);
			System.out.println("5秒后开始写!");
			Thread.sleep(5000);
			pipedOutputStream.write("hahahahahaha".getBytes());
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}
	
}

Main类

package com.itheima.pipedInputstream;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class Main {
	public static void main(String[] a){
		PipedInputStream pipedInputStream = new PipedInputStream();
		PipedOutputStream pipedOutputStream = new PipedOutputStream();
		try {
			
			pipedInputStream.connect(pipedOutputStream);
			
			new Thread(new PipedInputStreamThread(pipedInputStream)).start();
			
			new Thread(new PipedOutputStreamThread(pipedOutputStream)).start();
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	
	}
}

RandomAccessFile(随机访问文件类,结尾没有父类后缀,自成一派)

特点:1、它不算是IO体系中的子类,直接继承Object.

           2、它又在IO包中,因为它具备读和写功能。

           3、内部封装数组,通过指针操作数组,可以用getFilePointer获取指针位置,可以用seek改变指针位置。

           4、它完成读写的原理是内部封装了字节输入流和输出流。

           5、看构造函数得知他只能操作文件,并且带模式访问。


DataInputStream与DataOutputStream(用的频率很高,操作基本数据类型)

package com.itheima.datainputstream;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

public class DataInputStreamDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
//			dataOutputStreamWrite();
//			dataInputStreamWrite();
//			dataOutputStreamWriteUTF();
			outputStreamWriter();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 有编码器
	 */
	public static void outputStreamWriter()throws Exception{
		OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("gbk.txt"),"gbk");
		outputStreamWriter.write("你好");
		OutputStreamWriter outputStreamWriter1 = new OutputStreamWriter(new FileOutputStream("utf.txt"),"utf-8");
		outputStreamWriter1.write("你好");
		outputStreamWriter.close();
		outputStreamWriter1.close();
	}
	
	public static void dataOutputStreamWriteUTF()throws Exception{
		DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream("WriteUTF.txt"));
		dataOutputStream.writeUTF("张帆张帆");
		dataOutputStream.close();
	}
	/**
	 * 用DataOutputStream写文件
	 */
	public static void dataOutputStreamWrite() throws Exception{
		DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream("dataOutputStream.txt"));
		dataOutputStream.writeInt(2354);
		dataOutputStream.writeDouble(23.4);
		dataOutputStream.writeUTF("张帆");//特殊方法,用这方法写的,也得用这方法读
		dataOutputStream.writeBytes("a");
		dataOutputStream.close();
	}
	
	/**
	 * 用DataOutputStream写文件
	 */
	public static void dataInputStreamWrite() throws Exception{
		DataInputStream dataInputStream = new DataInputStream(new FileInputStream("dataOutputStream.txt"));
		//读的顺序必须和写的顺序一样,要不数据错误
		int a = dataInputStream.readInt();
		double b = dataInputStream.readDouble();
		String c = dataInputStream.readUTF();
		byte d = dataInputStream.readByte();
		System.out.println(a+"---"+b+"---"+c+"---"+d);
		dataInputStream.close();
	}
}


ByteArrayInputStream和ByteArrayOutputStream(也很有用,类加载器用到过,操作字节数组)

这两个类没有用到系统资源,所以不用关闭,就算关闭了,它们还能使用

源设备:

        键盘:System.in,硬盘:FileStream,内存:ArrayStream。

目的设备:

        控制台:System.out,硬盘:FileStream,内存:ArrayStream。

ByteArrayOutputStream的好处是可以将字节读进去,然后是动态的,配合类加载器用

package com.itheima.bytearrayinputstream;

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

public class ByteArrayInputStreamTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//数据源
		ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream("hahasdhug".getBytes());
		//数据目的
		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
		System.out.println(byteArrayOutputStream.size());
		int len = 0;
		while((len = byteArrayInputStream.read())!=-1){//read()方法,返回的是读到的字节,用int显示的
			byteArrayOutputStream.write(len);
		}
		
		System.out.println(byteArrayOutputStream.toString());
		
		
		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream("test.obj");
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		int temp = 0;
		try {
			while((temp = fileInputStream.read())!=-1){
				byteArrayOutputStream.write(temp);
			}
			fileInputStream.close();
			System.out.println(byteArrayOutputStream.toString());
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	
}

CharArrayReader和CharArrayWriter(和ByteArrayInputStream用法一样)

StringReader和StringWriter(和ByteArrayInputStream用法一样)

InputStreamReader和OutputStreamWriter(字节和字符之间的转换用)

字符编码

编码:字符变字节

解码:字节变字符










版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

分享:
开发与运维
使用钉钉扫一扫加入圈子
+ 订阅

集结各类场景实战经验,助你开发运维畅行无忧

其他文章