java之IO 一

1.IO的引入

2.IO流的分类

流向：

输入流读取数据

输出流写出数据

数据类型：

字节流

字节输入流读取数据 InputStream

字节输出流写出数据 OutputStream

字符流

字符输入流读取数据 Reader

字符输出流写出数据 Writer

我们一般在探讨IO流的时候，如果没有明确说明按照那种分类来说，默认情况下是按照数据类型来分的。

3.写入数据

package com;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
/**
 * 字节输出流操作步骤：
 * 1.创建字节输出流对象
 * 2.写数据
 * 3.释放资源
 */
public class FileOutputStreamDemo {
	@SuppressWarnings("resource")
	public static void main(String[] args) throws Exception {
		File file = new File("hello.txt");
		OutputStream os = new FileOutputStream(file,true);
		/**
		 * 创建字节流输出对象做了以下几件事
		 * 调用系统功能去创建文件
		 * 创建os对象
		 * 把os对象指向这个文件
		 */
		os.write("你好，世界".getBytes());
		os.close();//释放资源
		/**
		 * 为什么一定要close()呢？
		 * 1.让流对象变成垃圾，这样就可以被垃圾回收器回收了
		 * 2.通知系统去释放和该文件相关的资源
		 */
	}

}

package com;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/**
 * 字节输出流操作步骤：
 * 1.创建字节输出流对象
 * 2.调用write()方法
 * 3.释放资源
 * 
 *  public void write(int b)写一个字节
 *  public void write(byte[] b)写一个字节数组
 *  public void write(byte[] b,int offset,int len)写一个字节数组的一部分
 *
 */
public class FileOutputStreamDemo2 {
	public static void main(String[] args) throws IOException {
		OutputStream os = new FileOutputStream("fos.txt");
		os.write(97);
		os.write("helloworld".getBytes());
		os.write(new byte[]{97,98, 99,100},1,3);
		os.close();
	}

}

4.实现数据的追加写入

package cn;

import java.io.FileOutputStream;
import java.io.OutputStream;
/**
 * 如何实现数据的换行？
 * 		写入换行符号即可。
 * 		不同的系统针对不同的换行符号识别是不一样的。
 * 		windows:\r\n
 * 		Linux:\n
 * 		Mac:\r
 * 		一些常见的高级记事本软件，是可以识别任意换行符号。
 * 
 * 如何实现数据的追加写入？
 *   	public FileOutputStream(String name,boolean append)
 *
 */
public class FileOutputStreamDemo {
	public static void main(String[] args)  throws Exception{
		//创建字节输出流对象
		OutputStream os = new FileOutputStream("fos.txt",true);

		//写数据
		for (int i = 0; i < 10; i++) {
			os.write(("hello"+i).getBytes());
			os.write("\n".getBytes());
		}

		//释放资源
		os.close();

	}

}

5.加入异常处理的字节输出流操作

package cn;

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

/**
 * 加入异常处理的字节输出流操作
 */
public class FileOutputStreamDemo1 {
	public static void main(String[] args) {
		OutputStream os = null;
		try {
			/**
			 * 为什么os要赋值为null?
			 * 因为try{到os = new FileOutputStream("fos.txt")之间一旦出现异常，
			 * 那么os就没有默认值,但是os是局部变量啊，怎么可能没有默认值呢？
			 */
			os = new FileOutputStream("fos.txt");
			os.write("java".getBytes());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			//如果os不为null，就为close
			//为什么要加入此判断呢,倘若os = new FileOutputStream("z://fos.txt")，文件不存在，那么此时会抛出异常
			//当然cath()会捕获到，但是一般程序运行到finally的时候，如果没有if判断，就是os.close()，而os此时是null啊，
			//null.close()当然报NullPointerException了
			if(os != null){
				//为了保障close()一定会执行，就放到finally里面了
				try {
					os.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

6.读取数据

package cn;

import java.io.FileInputStream;
import java.io.InputStream;

/**
 * 字节输入流的操作步骤：
 * 	1.创建字节输入流对象
 * 	2.调用read()方法读取数据，并把数据显示在控制台
 * 	3.释放资源
 * 
 * read()方法
 * public int read() throws IOExcepiton：从输入流中读取一个字节数据，如果到达文件末尾，则返回-1
 */
public class FileInputStreamDemo {
	public static void main(String[] args) throws Exception {
		//创建字节输入流对象
		InputStream is = new FileInputStream("fos.txt");

		//调用read()方法读取数据，并把数据显示在控制台
		int a = is.read();
		while(-1 != a){
			System.out.print((char)a);
			a = is.read();
		}

		//释放资源
		is.close();
	}
}

改进版

package cn;

import java.io.FileInputStream;
import java.io.InputStream;

/**
 * 字节输入流的操作步骤：
 * 	1.创建字节输入流对象
 * 	2.调用read()方法读取数据，并把数据显示在控制台
 * 	3.释放资源
 * 
 * read()方法
 * public int read() throws IOExcepiton：从输入流中读取一个字节数据，如果到达文件末尾，则返回-1
 */
public class FileInputStreamDemo {
	public static void main(String[] args) throws Exception {
		//创建字节输入流对象
		InputStream is = new FileInputStream("fos.txt");

		//调用read()方法读取数据，并把数据显示在控制台
		int a = 0;
		while((a = is.read()) != -1){
			System.out.print((char)a);
		}

		//释放资源
		is.close();
	}
}

7.复制文件

package cn;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 *  复制文本文件
 *  
 *  数据源：从哪里来  a.txt 读取数据 --FileInputStream
 *  目的地: 到哪里去  b.txt 写入数据 --FileOutputStream
 */
public class FileCopyDemo {
	public static void main(String[] args) throws IOException{
		//数据源
		InputStream is = new FileInputStream("a.txt");

		//目的地
		OutputStream os = new FileOutputStream("b.txt");

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

		//释放资源
		is.close();
		os.close();

	}

}

不过这种方式每次都是读取一个字节，效率太慢了，如果读取大的文件，这种方式就不适合。

package cn;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * 复制文件
 * 一次读取一个字符数组：public int read(byte[] b)
 * 返回值其实是实际读取的字节个数 如果因为已经到达文件末尾而没有更多的数据，则返回-1
 */
public class FileCopy2 {
	public static void main(String[] args) throws Exception{
		//创建字节输入流对象
		InputStream is = new FileInputStream("a.txt");

		//创建字符流输出对象
		OutputStream os = new FileOutputStream("b.txt");

		//定义一个字节数组
		byte[] b = new byte[1024];
		int temp = 0;
		while((temp = is.read(b)) != -1){
			os.write(b,0,temp);
		}
		//释放资源
		is.close();
		os.close();

	}

}

看到这里很多人都崩溃了，为什么这么写呢？哈哈，且听老夫来分解代码？

如果我a.txt文件中的内容是

hello

world

java

那么我们按照下面的代码来执行

	        byte[] c = new byte[5];
		//第一次
		int len = is.read(c);
		System.out.print(new String(c));
		System.out.println(len);
		System.out.println("--------------");
		//第二次
		len = is.read(c);
		System.out.print(new String(c));
		System.out.println(len);
		System.out.println("--------------");
		//第三次
		len = is.read(c);
		System.out.print(new String(c));
		System.out.println(len);
		System.out.println("--------------");
		//第四次
		len = is.read(c);
		System.out.print(new String(c));
		System.out.println(len);

结果是这样的

hello5

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

wor5

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

ava

why?

其实a.txt的内容是下面这样的啊

hello\r\n

world\r\n

java\r

我们是不是定义byte[] b = new byte[5];

第一次

hello 长度是5

第二次

\r\nwor 长度也是5

其实第二次相当于

b[0]=\r

b[1]=\n

b[2]=w

b[3]=o

b[4]=r

当然这些字符的底层会转换为byte的，不用担心啊，我这样写只是为了让各位理解

第三次

ld\r\nj 长度也是5

b[0]=l

b[1]=d

b[2]=\r

b[3]=\n

b[4]=j

当然这些字符的底层会转换为byte的，不用担心啊，我这样写只是为了让各位理解

第四次

ava\rj 长度也是5 是不是不理解啦

第三次的是不是这样的

b[0]=l

b[1]=d

b[2]=\r

b[3]=\n

b[4]=j

但是这次其实只有ava，那么数组中是不是这样排列？

b[0]=a

b[1]=v

b[2]=a

那么第4，第5个元素呢，当然是第三次的，因为这一次是没有字符去赋值的。

b[3]=\n

b[4]=j

懂了没？

但是我们如何避免这种情况呢？

看上面的len,就是每次读取的字节长度。5,5,5,3

那么，我们的代码改成下面的样子，是不是可以避免上面的问题呢？

		byte[] c = new byte[5];
		//第一次
		int len = is.read(c);
		System.out.print(new String(c,0,len));
		System.out.println(len);
		System.out.println("--------------");
		//第二次
		len = is.read(c);
		System.out.print(new String(c,0,len));
		System.out.println(len);
		System.out.println("--------------");
		//第三次
		len = is.read(c);
		System.out.print(new String(c,0,len));
		System.out.println(len);
		System.out.println("--------------");
		//第四次
		len = is.read(c);
		System.out.print(new String(c,0,len));
		System.out.println(len);

hello5

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

wor5

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

ava3

此时，输出的就是我们想要的啦。

那么现在看懂下面的代码吗？

package cn;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * 复制文件
 * 一次读取一个字符数组：public int read(byte[] b)
 * 返回值其实是实际读取的字节个数 如果因为已经到达文件末尾而没有更多的数据，则返回-1
 */
public class FileCopy2 {
	public static void main(String[] args) throws Exception{
		//创建字节输入流对象
		InputStream is = new FileInputStream("a.txt");

		//创建字符流输出对象
		OutputStream os = new FileOutputStream("b.txt");

		//定义一个字节数组
		byte[] b = new byte[1024];
		int temp = 0;
		while((temp = is.read(b)) != -1){
			os.write(b,0,temp);
		}
		//释放资源
		is.close();
		os.close();

	}

}

8.字节缓冲流

字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多哦，这是加入数组这样的缓冲效果，java本身在设计的时候，也考虑到了这样的设计思想（装饰模式），所以提供了字节缓冲区流

字节缓冲输出流

BufferedOutputStream

字节缓冲输入流

BufferedInputStream

package cn;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class BufferedOutputStreamDemo {
	public static void main(String[] args) throws IOException {
		OutputStream os = new BufferedOutputStream(new FileOutputStream("bos.txt"));

		os.write("helloworld".getBytes());

		os.close();

	}

}

package cn;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class BufferedInputStreamDemo {
	public static void main(String[] args) throws IOException {
		InputStream is = new BufferedInputStream(new FileInputStream("bos.txt"));

		byte[] b = new byte[1024];
		int temp = 0;
		while((temp=is.read(b)) != -1){
			System.out.println(new String(b,0,temp));
		}

		is.close();
	}

}

时间： 2024-04-13 20:21:24

java之IO 一的相关文章

Java之IO(八)PipedIutputStream和PipedOutputStream

转载请注明源出处:http://www.cnblogs.com/lighten/p/7056278.html 1.前言本章介绍Java的IO体系中最后一对字节流--管道流.之前在字节数组流的时候就说过,其可以充当输入输出流的转换作用,Java中还有一个管道流可以完成相似的功能,但是其主要作用是用于不同线程间的通讯,下面就具体讲一下管道流是如何实现的,以及相关例子. 值得注意的是,在JDK源码注释中提到了,通常使用一个管道输出流关联一个管道输入流形成管道会话.通常输入流和输出流是不在一个线程中的

黑马程序员——Java基础---IO(下)

黑马程序员——Java基础---IO(下) ------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------ 一.概述 Java除了基本的字节流.字符流之外,还提供了File类.properties类.打印流.序列流等和输入输出相关的类,它们能够帮助我们更好的处理信息.下面将对它们进行简单的介绍. 一.正

java的IO总结（一）

Java的IO流是实现输入输出的基础,这里所说的流就是数据流,大部分的与流相关的类放在Java.io包下. 一,Java的流分类按照不同的分类方式可以把流分成不同的类型,下面我们从不同的角度对流进行分类. 1,按照流的方向可以分为输入流与输出流输入流:只能从中读取数据,而不能向其写出数据输出流:只能向其写出数据,而不能从中读数据. 2,字节流与字符流字节流主要是以InputStream和OutputStream为基类,其对应子类有FileInputStre

java中IO写文件工具类

下面是一些根据常用java类进行组装的对文件进行操作的类,平时,我更喜欢使用Jodd.io中提供的一些对文件的操作类,里面的方法写的简单易懂. 其中jodd中提供的JavaUtil类中提供的方法足够我们使用,里面的方法写的非常简练,例如append,read等方法,封装更好,更符合面向对象, 这里面我写的一些方法可多都是模仿jodd,从里面进行抽取出来的. /** * 获取路径文件夹下的所有文件 * @param path * @return */ public static File[] ge

Java操作IO各主要类介绍

DataInputStream和DataOutputStream 往二进制文件中读和写入java基本数据类型 public class BinaryReadWrite { private DataInputStream dis = null; private DataOutputStream dos = null; private String s_FilePath = "config\\bin.dat"; private byte[] buff = "{\"nam

JAVA之IO技术File类的使用

package ioTest.io3; /* * File类是对文件和文件夹的抽象. * File类的常见方法: * 1.创建 * createNewFile():在指定的位置创建文件,如果该文件已经存在,则不创建,返回false. * 和输出流对象不一样,输出流对象,只要已建立就创建,如果文件存在,则覆盖. * mkdir():创建此抽象路径名指定的目录 * mkdir():创建此抽象路径名指定的目录,包括所有必需但不存在的父目录. * 2.删除 * delete() * deleteOnEx

JAVA之IO技术-获取指定目录下的文件夹和文件的File对象或是字符串名称。

package ioTest.io3; /* * 获取指定目录下的文件夹和文件的File对象或是字符串名称. * 也可以通过filter获取指定的文件夹或者指定类型的文件 * 这里面需要做一个总结,如何利用jdk的源码去理解不熟悉的方法的应用. */ import java.io.File; import java.io.FileFilter; import java.io.FilenameFilter; public class FileDemo2 { public static void m

Java之IO(十)Reader和Writer

转载请注明源出处:http://www.cnblogs.com/lighten/p/7071733.html 1.前言之前的章节已经将Java8的io包中的字节流介绍完毕了.本章开始介绍Java的IO中另一个重要的体系,字符流.字节是给计算机看的,字符才是人能够认识的,可想而知字符流的重要性.字符流体系的根源在于抽象父类Reader和Writer.一切都起源于这两个类. 2.Reader Reader实现了Readable和Closeable接口,这两个接口从JDK1.5开始出现.Reader

Java之IO(九)其它字节流

转载请注明源出处:http://www.cnblogs.com/lighten/p/7063161.html 1.前言之前的章节已经介绍了java的io包中所有成对(输入.输出对应)的字节流,本章介绍剩余的一些字节流,包括:LineNumberInputStream.SequenceInputStream.StringBufferInputStream.在JDK8的版本中,只有中间的SequenceInputStream没有被废弃,其它两个都被指出已废弃了. 2.LineNumberInput

java之io之File类的list()方法过滤目录的使用

java的io的知识中,File类必须掌握.File类是对文件或者文件夹的封装.它本身并不能对所封装的文件进行读写,它封装的只是文件或文件夹的周边知识,比如大小啦,创建日期啦,路径啦等等. 如果File封装的文件夹,File类的list()方法可以将此文件夹下的所有文件夹和文件已字符串数组的形式返回. list(FilenameFilter)可以对返回的字符串数组进行过滤,取自己想要的字符串. ?打印文件夹下的.java文件实现1 package com.westward.io; impor