文档章节

java --I/O

求是科技
 求是科技
发布于 2016/09/27 00:01
字数 2372
阅读 25
收藏 0

总结:
1.java的io包括:
1.1文件流(操作字节)
1.2.字符流(操作字符(纯文本文件))
1.3.缓冲流(效率最高)
//1.创建输入/输出文件
//2.创建文件输入/输出流
//3.创建缓冲输入/输出流
//4.每个读取多少个字节数
//5.实际读取的字节数
//6.循环读写
1.4.对象流(操作对象(对象需要序列化))

2.从硬盘读取文件到内存中,步骤
2.1.创建读取文件
2.2.创建文件输入流
2.3.每次读取多少个字节
2.4.实际读取的字节数
2.5.循环读取

File file = new File("hello.txt");
FileInputStream fis = new FileInputStream(file);
byte[] b = new byte[20];
int len;
len=fis.read(b);
while(len != -1)
{
len=fis.read(b);
}

3.从内存中写字符流到文件中
3.1创建写入文件
3.2创建文件输出流
3.3写入字符流到文件中

File file = new File("hello.txt");
FileOutputStream fos = new FileOutputStream(file);
fos.write("zhangsan".getBytes());

4.实现文件复制,复制文件hello1.txt到hello2.txt,步骤
1.创建输入/输出文件
2.创建文件输入/输出流
3.每次读取多少个字节
4.实际读取到的个数
5.循环读写

File file1 = new File("hello1.txt");
File file2 = new File("hello.txt");
FileInputStream fis = new FileInputStream(file1);
FileOutputStream fos = new FileOutputStream(file2);
byte[] b = new byte[20];
int len = fis.read(b);
while(len != -1){
fos.write(b,0,len);
fos.flush();
len = fis.read(b);
}

I/O流用来处理设备之间的数据传输。
输入:读取外部数据(硬盘、磁盘等)到程序(内存)中。
输出:将程序(内存)数据输出到硬盘、光盘等设备中。
#1.FileInputStream

	/**
	 * 从硬盘存在的一个文件中,读取其内容到内存中
	 * 使用FileInputStream
	 * @throws IOException 
	 */
	@Test
	public void testFile() {
		
		FileInputStream fis = null;
		try {
			
			//1.创建一个文件对象
			File file = new File("hello.txt");
			//2.创建一个FileInputStream类的对象
			fis = new FileInputStream(file);
			//3.调用read()方法,实现文件的读取
			int b = fis.read();
			while (b != -1) {
				//将int转成char显示出来
				System.out.print((char)b);
				b = fis.read();
			}	
		} catch (Exception e) {
			//抛出异常
		}finally {
			//4.关闭相应的流
			try {
				fis.close();
			} catch (IOException e) {
				// 关闭异常
				e.printStackTrace();
			}
		}
	}

#2.改善读取的效率

	public void testFile() {
		
		FileInputStream fis = null;
		try {
			
			//1.创建一个文件对象
			File file = new File("hello.txt");
			//2.创建一个FileInputStream类的对象
			fis = new FileInputStream(file);
			//3.定义一个数组,用于表示每次读取多少个数据
			byte[] b = new byte[5];
			//4.每次读入到byte[]中数据的是实际个数
			int len;
			//5.调用read()方法,实现文件的读取
			len = fis.read(b);
			while (len != -1) {
				String str = new String(b, 0, len);
				System.out.println(str);
				len = fis.read(b);
			}	
		} catch (Exception e) {
			//抛出异常
		}finally {
			//4.关闭相应的流
			try {
				if (fis != null) {
					fis.close();
				}
			} catch (IOException e) {
				// 关闭异常
				e.printStackTrace();
			}
		}
	}

#3.FileOutputStream

	/**
	 * 从内存中取出字节流到文件中
	 * 使用FileOutputStream
	 * @throws IOException 
	 */
	@Test
	public void testFileOutputStream() throws IOException{
		
		//1.创建文件对象
		//输出的物理文件可以不存在,执行过程中,
		//若不存在,则会自动创建;若存在,则会将现有文件覆盖
		File file = new File("hello.txt");
		//2.创建一个文件输出流,用于写入数据到文件中
		FileOutputStream fos = null;
		try {
			fos = new FileOutputStream(file);
			//3.写入数据到文件中
			fos.write("zhangsanfeng".getBytes());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}finally {
			if (fos != null) {
				//4.关闭输出流
				fos.close();
			}
		}
	}

#4.文件复制

	/**
	 * 从硬盘读取一个文件,并写入到另一个位置(相当于文件复制)
	 * @throws IOException 
	 */
	@Test
	public void testFileInputOutputStream() throws IOException{
		
		//1.定义读出类文件
		File file1 = new File("hello.txt");
		//2.定义写入类文件
		//注意:写入类文件在硬盘中不一定存在,会自动创建
		File file2 = new File("hello2.txt");
		//3.定义输入文件流:流入内存
		FileInputStream fis = null;
		//4.定义输出文件流:从内存输出
		FileOutputStream fos = null;
		try {
			fis = new FileInputStream(file1);
			fos = new FileOutputStream(file2);
			//3.实现文件复制
			byte[] b = new byte[20];
			int len;
			//循环读入到数组中
			while ((len = fis.read(b)) != -1) {
				//输出到文件中
				fos.write(b, 0, len);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}finally {
			if (fis != null) {
				fis.close();
			}
			if (fos != null) {
				fos.close();
			}
		}
	}

#5.字符流
使用FileReader、FileWriter可以实现文本文件(字符流)的复制。
对于非文本文件(音频、视频、图片等)只能使用字节流。

	@Test
	public void testFileReaderWriter() throws IOException{
		
		FileReader fr = null;
		FileWriter fw = null;
		
		File src = new File("hello.txt");
		File desc = new File("hello2.txt");
		
		try {
			fr = new FileReader(src);
			fw = new FileWriter(desc);

			char[] c = new char[24];
			int len;
			while ((len = fr.read(c)) != -1) {
				fw.write(c, 0, len);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}finally {
			if (fr != null) {
				fr.close();
			}
			if (fw != null) {
				fw.close();
			}
		}
	}

#6.缓冲流
缓冲流可以提升效率,平时一般用这个居多。

	public void testBufferInputOutputStream() throws IOException{
		
		BufferedInputStream bis = null;
		BufferedOutputStream bos = null;
		try {
			//1.创建文件
			File file1 = new File("hello.txt");
			File file2 = new File("hello2.txt");
			//2.创建节点流
			FileInputStream fis = new FileInputStream(file1);
			FileOutputStream fos = new FileOutputStream(file2);
			//3.创建缓冲流
			bis = new BufferedInputStream(fis);
			bos = new BufferedOutputStream(fos);
			//4.实现文件复制
			byte[] b = new byte[2014];
			int len;
			while((len = bis.read(b)) != -1)
			{
				bos.write(b, 0, len);
				//刷新
				bos.flush();
			}
		} catch (Exception e) {
			// TODO: handle exception
		}finally {
			if (bos != null) {
				bos.close();
			}
			if (bis != null) {
				bis.close();
			}
		}
	}

#7.标准输入/输出流
标准的输入流:System.in
标准的输出流:System.out

	/**
	 * 标准输入流:System.out
	 * 标准输出流:System.in
	 * 
	 * 测试:从键盘输入字符串,要求将读取到的字符串输出,
	 * 接着继续输入,直到输入"exit"时退出程序
	 */
	@Test
	public void testOtherStream() {
		
		//缓冲流
		BufferedReader br = null;
		try {
			InputStream is =  System.in;
			InputStreamReader isr = new InputStreamReader(is);
			br = new BufferedReader(isr);
			String str;
			while (true) {
				System.out.println("请输入字符串:");
				str = br.readLine();
				if (str.equals("exit")) {
					break;
				}
				System.out.println(str);
			}
		} catch (Exception e) {
			// TODO: handle exception
		}finally {
		}
	}

#8.打印流

	/**
	 * 打印流
	 */
	@Test
	public void testPrintStream() {		
		FileOutputStream fos = null;
		try {
			fos = new FileOutputStream(new File("print.txt"));
		} catch (Exception e) {
			// TODO: handle exception
		}
		//创建打印输出流,设置为自动刷新
		PrintStream ps = new PrintStream(fos, true);
		if (ps != null) {
			//将标准的输出流(控制台)改成输出到文件
			System.setOut(ps);
		}
		//输出字符
		for (int i = 0; i < 255; i++) {
			System.out.print(i);
			if (i%50 == 0 ) {
				System.out.println();
			}
		}
		ps.close();
	}

#9.对象流
ObjectInputStream:对象输入流
ObjectOutputStream:对象输出流
序列化:用ObjectOutputStream类将一个java对象写入文件
反序列化:用ObjectInputStream读取文件恢复java对象
对象流不能序列化static和transient修饰的成员变量。

/**
 * 序列化对象
 *1.该对象要实现Serializable接口
 *2.对象里面的属性都需要实现Serializable接口
 */
class Car implements Serializable{
	
	private static final long serialVersionUID = 1L;
	Integer id;
	String brand;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getBrand() {
		return brand;
	}
	public void setBrand(String brand) {
		this.brand = brand;
	}
	public Car(Integer id, String brand) {
		super();
		this.id = id;
		this.brand = brand;
	}
	@Override
	public String toString() {
		return "Car [id=" + id + ", brand=" + brand + "]";
	}
}
	/**
	 * 对象的序列化过程
	 * 将内存中的对象通过ObjectOutputStream转换成二进制流,存储在硬盘中
	 * @throws ClassNotFoundException 
	 */
	public static void main(String[] args) throws ClassNotFoundException {
		Car car1 = new Car(1001, "ford");
		Car car2 = new Car(1002, "audi");
		
		ObjectOutputStream oos = null;
		ObjectInputStream ois = null;
		try {
			//序列化对象存入硬盘
			oos = new ObjectOutputStream(new FileOutputStream("hello.txt"));
			oos.writeObject(car1);
			oos.flush();
			oos.writeObject(car2);
			oos.flush();
			
			//从硬盘中读取对象到内存
			ois = new ObjectInputStream(new FileInputStream("hello.txt"));
			//这里有多个对象,采取循环读取
			Car car3 = (Car) ois.readObject();
			System.out.println(car3);
			Car car4 = (Car) ois.readObject();
			System.out.println(car4);
		}catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				if (oos != null) {
					oos.close();
				}
				if (ois != null) {
					ois.close();
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

#10.随机访问流
RandomAccessFile,该类支持随机访问的方式,程序可以直接跳到文件的任意位置来实现读/写文件。

	/**
	 * RandomAccessFile:支持随机访问
	 * 1.既可以充当一个输入流,也可以充当一个输出流
	 * 2.支持从文件的任意位置读取、写入
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		
		RandomAccessFile rafRead = null;
		RandomAccessFile rafWrite = null;
		//文件的读写
		try {
			//读文件
			rafRead = new RandomAccessFile(new File("hello.txt"), "r");
			//写文件
			rafWrite = new RandomAccessFile(new File("hello2.txt"), "rw");
			
			byte[] b = new byte[20];
			int len;
			while ((len = rafRead.read(b)) != -1) {
				rafWrite.write(b, 0, len);
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			rafRead.close();
			rafWrite.close();
		}
	}

实现文件内容覆盖的效果

		//实现文件内容覆盖的效果
		/**
		 * 如内容为:zhangwuji
		 * 现在实现用xy覆盖wu的效果
		 */
		RandomAccessFile raf = null;
		try {
			raf = new RandomAccessFile("hello.txt", "rw");
			//指定覆盖的起始位置
			raf.seek(5);
			//覆盖
			raf.write("xy".getBytes());
		} catch (Exception e) {
			// TODO: handle exception
		}finally{
			raf.close();
		}

实现在文件指定位置插入指定元素

		//实现在文件指定位置插入指定元素
		/**
		 * 例如:在zhangwuji字符串的g后面添加上xy字符串,结果是zhangxywuji
		 */
		RandomAccessFile raf = null;
		raf = new RandomAccessFile(new File("hello.txt"), "rw");
		//1.现将指针移到第5个位置,即g的后面
		raf.seek(5);
		//2.读取g后面一行字符串
		String str = raf.readLine();
		//输出内容为wuji
		System.out.println(str);
		//3.查看目前指针在哪个位置
		long pointPos = raf.getFilePointer();
		//指针的位置在该行字符串结尾
		System.out.println(pointPos);
		//4.重新将指针调回第5个位置
		raf.seek(5);
		//5.插入字符串,此时字符串应该是zhangxyji
		raf.write("xy".getBytes());
		//6.查看目前指针的位置
		long pointPos2 = raf.getFilePointer();
		//此时指针的位置在y的后面
		System.out.println(pointPos2);
		//7.再插入字符串,字符串str肯定比zhangxy后面的字符串长,所以可以完全覆盖
		raf.write(str.getBytes());

如上可以实现单行的插入,假设字符串存在多行呢

	public static void main(String[] args) throws IOException {
		//实现在文件指定位置插入指定元素(通用方法)
		/**
		 * 多行字符串的插入
		 * 例如:在zhangwuji
		 * 		abcd
		 * 		123456
		 * 需求:在字符串zhangwuji的g后面添加上xy字符串,结果是zhangxywuji,同时不改变字符串abcd和123456的位置
		 */
		RandomAccessFile raf = null;
		raf = new RandomAccessFile(new File("hello.txt"), "rw");
		raf.seek(5);
		byte[] b = new byte[20];
		int len;
		StringBuffer sb = new StringBuffer();
		while ((len = raf.read(b)) != -1) {
			sb.append(new String(b,0,len));
		}
		//此处输出内容
		/**
		 * gwuji
		 * abcd
		 * 123456
		 */
		System.out.println(sb.toString());
		//查看指针,很明显在最后一个字符串的最有一个位置
		long pointFile = raf.getFilePointer();
		System.out.println(pointFile);
		//调回指针
		raf.seek(5);
		//写入字符串,此时指针在y的后面
		raf.write("xy".getBytes());
		//拼接后面的字符串,得出的结果就是
		/**
		 * zhangxywuji
		 * abcd
		 * 123456
		 */
		raf.write(sb.toString().getBytes());
		//关闭流
		raf.close();
	}

© 著作权归作者所有

上一篇: java --序列化
下一篇: java --file
求是科技

求是科技

粉丝 97
博文 448
码字总数 231373
作品 0
成都
后端工程师
私信 提问
java电子书

Complete Java Ebook Collection Complete Java Ebook Collection 97 books | CHM PDF | 551.64 MB Absolute Java 1st Edition Advanced Java 2 Platform How to Program (JDK 1.3, J2EE 1.2......

runeveryday
2011/07/07
836
1
Java FileInputStream

一、序言 IO操作,才程序中比较普遍,JAVA 中提出了IO/NIO 的概念,也一直在说NIO 比IO快,一直不知道原因,就想memcache 和ehcache 比较优劣一样,这些东西得自己看看如何实现的,才 知道区...

pczhangtl
2014/08/03
0
0
Java中ThreadLocal的设计与使用

ThreadLocal是什么 ThreadLocal是什么呢?其实ThreadLocal并非是一个线程的本地实现版本,它并不是一个Thread,而是thread local variable(线程局部变量)。也许把它命名为ThreadLocalVar更...

DragonRace
2013/11/25
0
0
深入ThreadLocal的内部机制

早在JDK 1.2的版本中就提供java.lang.ThreadLocal,ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。使用这个工具类可以很简洁地编写出优美的多线程程序。ThreadLocal并不是一个T...

yqbboy
2012/10/27
0
0
Java 7 技术的新纪元

预计于今年秋天将最终发布的 Java 平台最新更新意义重大且倍受期待。虽然尚未通过 Java Community Process (JCP) 正式创建 Java 7 平台 Java Specification Request (JSR),并且最终特性集仍...

红薯
2010/06/07
565
2

没有更多内容

加载失败,请刷新页面

加载更多

程序员随想-关于分享

最早的时候,文字是贵族这些上层人士才会学习的,底层人士没有资格和渠道去学习,同样用文字、图像等其他载体承载的知识大部分也只有贵族阶层才能享受的。后来有了造纸术、印刷术,成本降低,...

Lubby
33分钟前
1
0
聊聊hibernate的session-level repeatable reads

序 本文主要研究一下hibernate的session-level repeatable reads 实例 doInTransaction(session -> { Product product = new Product(); product.setId(1L); product.setQuanti......

go4it
45分钟前
0
0
ubuntu或ubuntu kylin优麒麟中安装QQ、wechat微信、百度网盘

从中国国内的地址下载deepin wine,码云上的。这样网速比较快。然后,按照说明向下安装。 https://gitee.com/wszqkzqk/deepin-wine-for-ubuntu...

gugudu
56分钟前
2
0
基于redis分布式锁实现“秒杀”

最近在项目中遇到了类似“秒杀”的业务场景,在本篇博客中,我将用一个非常简单的demo,阐述实现所谓“秒杀”的基本思路。 业务场景 所谓秒杀,从业务角度看,是短时间内多个用户“争抢”资源...

别打我会飞
今天
14
0
Zookeeper的实践指南

本章重点 1.数据存储2.基于Java API初探Zookeeper的使用3.深入分析Watcher机制的实现原理4.Curator客户端的使用,简单高效 数据存储 事务日志快照日志运行时日志 bin/zookeepe...

须臾之余
今天
2
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部