JavaIO加强（1）

最新推荐文章于 2024-09-23 10:18:26 发布
最新推荐文章于 2024-09-23 10:18:26 发布
阅读量317 收藏
点赞数
分类专栏： Java之IO流 Java从入门到高级编程 文章标签： java IO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zuosixiaonengshou/article/details/52171501
版权

首先对java中的IO作一个复习：

Java中IO流根据流的方向，流可分为两类：输入流和输出流。

   输入流和输出流又可分为：

       字节流：InputStream（输入）OutputStream（输出）

       字符流：Reader （输入） Writer（输出）

一个简单的对文件实行读写：

<span style="font-family:Times New Roman;font-size:14px;color:#000000;">package cn.huncu.io.hello;

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

public class Demo1 {

	public static void main(String[] args) {
		//writeDemo();
		readDemo();
	}

	private static void readDemo() {
		File file =new File("files\\a.txt");
		if(!file.exists()){
			System.out.println("文件不存在");
			return ;
		}
		FileInputStream in=null;
		byte[] b=new byte[512];
		try {
			in=new FileInputStream(file);
			in.read(b);
//				for(byte bb:b){这种方式，遇到中文会乱码
//					System.out.print((char)b);
//				}System.out.println();
			String str=new String(b, "utf-8");//解码--指定编码表
			System.out.println(str);
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(in!=null){
				try {
					in.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

	public static void writeDemo() {
		FileOutputStream out=null;
		String str="你好啊，你叫什么名字？ ";
		try {
			out=new FileOutputStream("files/a.txt");
			out.write(str.getBytes("utf-8"));
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(out!=null){
				try {
					out.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

}
</span>


 

                                      RandomAccessFile
    ★随机访问文件，自身具备读写的方法。
        new RandomAccessFile()之后，若文件不存在会自动创建，存在则不创建。——该类其实内部既封装了字节输入流，又封装了字节输出流。
该类若用write()方法写整数，每次只写它的最后一个字节。而采用writeInt()方法，则可把一个整数完整地写入。
   ★通过skipBytes(int x),seek(int x)来达到随机访问。
       通过seek方法设置数据的指针就可以实现对文件数据的随机读写。InputStream中的skip()方法只能从头往后跳，不能反向；而seek()方法可双向随便定位。
   ★数据修改方面的特点
      用RandomAccessFile类可以实现数据的修改，当然文件中的数据一般要有规律，以方 便在编程时能够进行定位，让数据写对地方。
而用“流”实现数据修改时，则通常需要把数据从流读到数组当中，在数组中进行数据修改，然后再把修改后的数组再重新写到流中。

 


    ★ 序列化
        将一个对象存放到某种类型的永久存储器上称为保持。如果一个对象可以被存放到磁盘或磁带上，或者可以发送到另外一台机器并存放到存储器或磁盘上，那么这个对象就被称为可保持的。（在Java中，序列化、持久化、串行化是一个概念。）
        java.io.Serializable接口没有任何方法，它只作为一个“标记者”，用来表明实现了这个接口的类可以考虑串行化。类中没有实现Serializable的对象不能保存或恢复它们的状态。
   ★ 对象图
       当一个对象被串行化时，只有对象的数据被保存；方法和构造函数不属于串行化流。如果一个数据变量是一个对象，那么这个对象的数据成员也会被串行化。树或者对象数据的结构，包括这些子对象，构成了对象图。
   ★ 瞬时 transient
        防止对象的属性被序列化。
序列化和transient演示：

<span style="font-family:Times New Roman;font-size:14px;color:#000000;">package cn.hncu.io.serial;

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

public class SerializableDemo {

	public static void main(String[] args) throws Exception{
		//writeDemo();
		writeDemo2();
		readDemo();
	}
	private static void readDemo() throws Exception{
		ObjectInputStream in = new ObjectInputStream( new FileInputStream("files/persons.txt"));
		//while(in.available()>0){//对象流不能以这种方式来判断是否有数据
		while(true){//对象流的读取，应该用处理异常的方式来判断文件结束
			try {
				Person p = (Person) in.readObject();//到达文件结束，会抛异常
				System.out.println(p);
			} catch (Exception e) {
				System.out.println("文件读取完毕!");
				break;
			}
		}
		
	}

	private static void writeDemo() throws IOException, FileNotFoundException {
		//序列化
		ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("files/persons.txt"));
		out.writeObject( new Person("Jack",24) );
		out.writeObject( new Person("张三",23) );
		out.writeObject( new Person("Rose",25) );
	}
	
	private static void writeDemo2() throws IOException, FileNotFoundException {
		//序列化
		ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("files/persons.txt"));
		out.writeObject( new Person("Jack",24,new MyDate(1995, 1, 1)) );
		out.writeObject( new Person("张三",23,new MyDate(1993, 10, 1)) );
		out.writeObject( new Person("Rose",25,new MyDate(1992, 1, 21)) );
	}

}</span>
<span style="font-family:Times New Roman;font-size:14px;color:#000000;">
</span>

Person类：

<span style="font-family:Times New Roman;font-size:14px;color:#000000;">package cn.hncu.io.serial;

import java.io.Serializable;

public class Person implements Serializable{
	private static final long serialVersionUID = -8696927766135529411L;
	private String name;
	private int age;
	private transient int num; //瞬时变量，不会序列化---如果不想让一个非静态变量序列化，那么就把它定义成瞬时变量
	private static int count=0; //※静态变量是无法序列化
	private MyDate birth;
	
	public Person() {
		num = ++count;
	}

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

	public Person(String name, int age, MyDate birth) {
		super();
		this.name = name;
		this.age = age;
		this.birth = birth;
	}

	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 MyDate getBirth() {
		return birth;
	}

	public void setBirth(MyDate birth) {
		this.birth = birth;
	}

	@Override
	public String toString() {
		//return count+":"+name + ", " + age ;
		return num+":"+name + ", " + age +", "+birth;
	}

}
</span>


MyDate类：

<span style="font-family:Times New Roman;font-size:14px;color:#000000;">package cn.hncu.io.serial;

import java.io.Serializable;

public class MyDate implements Serializable{
	private int year, month, day;

	public MyDate() {
		super();
	}

	public MyDate(int year, int month, int day) {
		super();
		this.year = year;
		this.month = month;
		this.day = day;
	}

	public int getYear() {
		return year;
	}

	public void setYear(int year) {
		this.year = year;
	}

	public int getMonth() {
		return month;
	}

	public void setMonth(int month) {
		this.month = month;
	}

	public int getDay() {
		return day;
	}

	public void setDay(int day) {
		this.day = day;
	}

	@Override
	public String toString() {
		return year + "年" + month + "月" + day + "日";
	}

}
</span>

 

注意：ObjectOutputStream类的write(Object obj)不会写静态成员（数据），即非静态数据都会写入对象流中，而如果非静态数据中有部分不想被写入对象流，这时需把定义成瞬时成员变量，如：private transient int age;（该瞬时数据将不被写入对象流中）

       用ObjectOutputStream类的write(Object obj)进行写对象时，其中的参数对象的类必须实现Serializable接口。（把光标定位在类名上，利用“Ctlr+1”，可自动为需序列化的类显式定义SerialVersionID，若自己未显式定义序列化ID，则会默认自动生成一个。 ）

缓冲输入输出流

（BufferedInputStream和BufferedOutputStream）

方式一：  DataInputStream in = new DataInputStream(

                                            newBufferedInputStream(

                                                        new FileInputStream("Test.txt")   );

方式二：DataInputStream in = new DataInputStream(

                                                                 new FileInputStream("Test.txt")   );

方式三：BufferedInputStream in = new BufferedInputStream(

                                                       new DataInputStream(

                                                           new FileInputStream("Test.java")  );

在这里我们将对这三种方式读取速度做一个比较，看看哪种方法效率。

代码实现如下：

<span style="font-family:Times New Roman;font-size:14px;color:#000000;">package cn.huncu.io.buffer;

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

public class BufferedStreamDemo {
	private static String FILE_NAME="files/buf.txt";
	public static void main(String[] args) {
		try {
			//demo1();
			//demo2();
			demo3();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	private static void demo3() throws IOException {
		long t1=System.currentTimeMillis();
		BufferedInputStream in=new BufferedInputStream(new DataInputStream(new FileInputStream(FILE_NAME)));
		String str=null;
		//in.readl
		byte[] b=new byte[50];
		int len=0;
		while((len=in.read(b))!=-1){
			System.out.print(new String(b,0,len));
		};
		System.out.println();
		long t2=System.currentTimeMillis();
		System.out.println("程序运行时间为（毫秒）："+(t2-t1));
	}

	
	private static void demo2() throws IOException {
		long t1=System.currentTimeMillis();
		DataInputStream in=new DataInputStream(new FileInputStream(FILE_NAME));
		String str=null;
		//in.readl
		
		while((str=in.readLine())!=null){
			System.out.println(str);
		}
		System.out.println();
		long t2=System.currentTimeMillis();
		System.out.println("程序运行时间为（毫秒）："+(t2-t1));
	}

	
	private static void demo1() throws IOException {
		long t1=System.currentTimeMillis();
		DataInputStream in=new DataInputStream(new BufferedInputStream(new FileInputStream(FILE_NAME)));
		String str=null;
		//in.readl
		while((str=in.readLine())!=null){
			System.out.println(str);
		}
		System.out.println();
		long t2=System.currentTimeMillis();
		System.out.println("程序运行时间为（毫秒）："+(t2-t1));
	}

}
</span>

 

为了保证数据的有效性，我做了多次测试。

第一种方式结果如图：

第二种方式：

第三种方式：

小结：

方式一是最优的。

1）有buffer比没有更快；

2）buffer放在中间层包装比放在外层更快；

3）按行或按块操作比 按字节或字符操作更快（用Object流操作的速度比 字节字符方式 更快）

4）缓冲区要结合流才可以使用，在流的基础上对流的功能进行了增强。


 

D灿
关注
专栏目录
javaIO流javaIO流javaIO流
07-02
Java IO流是Java平台中用于处理输入输出操作的核心机制，它允许程序与各种数据源（如文件、设备、网络）进行交互。Java IO流体系结构是基于“流”的概念，流是一组有序的数据序列，可以是字节流或字符流。Java IO库...
java IO应用
07-30
Java IO（Input/Output）是Java编程语言中用于处理输入输出操作的重要部分。它提供了丰富的类库，使得开发者能够高效地读写数据，无论是从键盘、文件、网络还是其他I/O设备。在Java中，IO操作是通过流（Stream）进行...
JAVA io流笔记05 增强流
wuyunhao 博客
12-22 195
package FileText; //字节流使用byte 数组！！！ //字符流使用char 数组！！！ import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.BufferedReader; import java.io.BufferedWriter; import ...
Java IO模型详解
m0_53067943的博客
02-09 1298
主要对于Java IO模型的详细介绍
JavaIO文件输出输出详解
qq_26496077的博客
07-11 2456
java.io.FIle类 文件或目录路径名的抽象表示形式.可以使用File类对文件或文件夹进行操作,比如: 创建一个新的文件/文件夹 删除文件/文件夹 获取文件/文件夹 判断文件/文件夹是否存在 对文件夹进行遍历 获取文件的大小 注: File类是一个与操作系统无关的类,任何操作系统都可以使用这个类中的方法. ...
java io流上传图片_Java IO流
weixin_28724003的博客
02-24 915
一、基本概念IO是Java对数据的操作是通过流的方式，数据传输是需要通道的，而IO流就是数据传输的通道。IO流可以形象的比喻为运送货物的传输带。IO流用来处理设备之间的数据传输，上传文件和下载文件，Java用于操作流的对象都在IO包中。总结一下，Java IO输入机制就是为了允许程序读取外部数据(包括来自于磁盘、光盘等存储设备的数据)和用户输入的数据。Java的IO流通过java.io包下的类和接...
Java IO流
can_chen的博客
09-26 781
文章目录一、文件1. 创建文件2. 文件相关操作3. 目录相关操作二、IO流1. IO流的分类2. IO流体系图三、字节文件流1. 字节文件输入流 FileInputStream2. 字节文件输出流 FileOutputStream四、字符文件流1. 字符文件输入流 FileReader2. 字符文件输出流 FileWriter五、节点流和处理流六、字符缓冲流1. 字符输入缓冲流 BufferedReader2. 字符输出缓冲流 BufferedWriter3. 通过BufferedReader和Buf
JavaIO的常用方法
微风吹过李子树的博客
12-02 1281
使用io的目的是想要 读写文件内部的内容，读写的方案就是流，既创建管道，让数据以流动的形式，先入先出的方式进行传输； 数据从数据源流向目的地； java提供了IO包供用户使用； 流的分类 流向分: (以程序为中心) 输入流 输出流 操作单元分: 字节流:任何数据都可以传输 字符流: 文本 功能分: 节点流: 操作基本功能的,实现读入写出的,数据从数据源头到目的地的 功能流: 增强功能,提高性能,操...
JavaIO流详细介绍
featureA的博客
06-22 601
在Java编程中，IO流（输入输出流）是用于处理数据读写的基础类。IO流分为多种类型，主要包括字节流、字符流、缓冲流、压缩流和转换流等。本文包括java IO基础知识，设计模式，io模型，nio模型等内容，将详细介绍这些流的概念及常见方法，并提供相应的代码示例。
Java中异步复用io
最新发布
u012108607的博客
09-23 1061
NIO：通过Selector和Channel实现非阻塞I/O。NIO.2：使用和支持回调的异步I/O。异步任务调度：结合编排异步任务。高性能I/O框架：使用Netty提供的高层次异步I/O处理。响应式编程：采用 Reactor、RxJava 等响应式编程框架处理异步I/O。
详解JAVA IO
Joker_ZJN的博客
02-20 445
JAVA IO中的各种类、各种流，一口气讲明白。
java io持久化_Java IO流
weixin_33657398的博客
02-27 313
IO(Input/Output)流IO流用来处理设备之间的数据传输Java对数据的操作是通过流的方式Java用于操作流的对象都在IO包中流按操作数据分为两种：字节流于字符流流按流向分为：输入流和输出流字符流由来就是：早期的字节流 + 编码表，为了更便于操作文字数据IO操作流程.pngIO流常用基类所属包：java.io字节流的抽象基类(二进制)InputStreamOutputStream字符流的...
java-IO.rar_io_java IO
09-21
Java 7进一步增强了NIO功能，引入了Path、Paths、Files等类，简化了文件操作，并引入了文件系统观察者（WatchService）。 通过深入学习和实践这些Java IO类和机制，开发者能够灵活地处理各种输入输出任务，无论是...
Java IO合集
09-24
Java IO和NIO是Java平台中用于输入/输出操作的核心组件。这两个库为开发者提供了处理数据传输的强大工具，无论是在磁盘、网络还是内存中。本合集包含了两本关于这些主题的专业书籍——"Java IO"和"Java NIO"，它们...
Java IO 与 装饰模式
05-27
1. Java IO体系结构： Java IO库基于流的概念，流是数据传输的抽象表示，分为字节流（处理单个字节的数据）和字符流（处理Unicode字符的数据）。流可以分为输入流和输出流，分别用于读取和写入数据。Java IO体系包含...
SpringMVC几个核心类(控制器核心类,加载配置文件核心类,处理url影射核心类,处理视图资源核心类,方法动态调用核心类)
~~~~~~~~~~~~
01-08 9068
核心类 制器核心类： •org.springframework.web.servlet.DispatcherServlet  － 配置web.xml   加载配置文件核心类： •org.springframework.web.context.ContextLoaderListener – spring的配置文件   处理url影射核心类： •org.springframework.
Hibernate常见操作(增、删、改)
~~~~~~~~~~~~
02-27 7631
Hibernate常见操作        如果利用Hibernate修改数据库时，需要使用事务处理，一个事务提交时才真正将修改过的记录更新到数据库中。 1、增加记录 Session session=HibernateSessionFactory.getSession(); /*定义事务开始*/ Transaction tran=session.beginTransaction
Ajax发送Json数据及解析
~~~~~~~~~~~~
03-15 6743
上一篇文章写了前端和后台用xml进行通信，这次写试用json来进行通信。 这两个都是前后端进行交互的较好的方式，具体区别，不懂得可自行百度。这里推荐一篇文章(里面总结的也是比较全的)： http://www.cnblogs.com/SanMaoSpace/p/3139186.html Json串格式：json数据格式：[{id:"U001",name:"Tom",age:19},
Ajax发送XML数据及解析
~~~~~~~~~~~~
03-15 6158
Ajax-XML技术： 将前台数据封装成XML数据，可以实现发送更复杂的数据。 流程：前台将数据拿到以后，封装成XML数据，向后台发送，后台接收到数据以后，用dom4j技术解析。     后台也可向前台发送XML数据，也是利用dom树来解析 前台： ajaxXml.jsp <%@ page language="java" contentType="text/html; char
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值