Java 持久化操作之 --io流与序列化
1)File类操作文件的属性
1.File类的常用方法
1.
文件的绝对完整路径:getAbsolutePath()
文件名:getName()
文件相对路径:getPath()
文件的上一级目录:getParent()
文件的大小为:length()
删除文件:delete()
具体操作请参考如下代码:
2)IO流(堵塞型io)
如何读写文件?
分析:流是指一连串流动的字符,是以先进先出方式发送信息的通道
输入/输出流于数据源:
java流的分类:
我们可以对它进行如下分类:
· 按处理的数据类型可分为字节流与字符流
· 按流的流向可分为输入流(in)与输出流(out)
· 按流的功能可分为节点流(Node)和过滤流(Filter)
在Java中,字节流一般适用于处理字节数据(诸如图片、视频),字符流适用于处理字符数据(诸如文本文件),但二者并没有严格的功能划分,因为有转换流的存在,使得对于数据的处理变得更加灵活。
1)字节流读写文件
一般用于处理字节数据,但字节流采用ASCII编码的,所以处理字符数据时容易出现中文乱码
1. 输入流
InputStream:此抽象类是表示字节输入流的所有类的超类(基类)
序号 |
方法描述 |
1 |
public final int read(byte[] r, int off, int len)throws IOException |
2 |
Public final int read(byte [] b)throws IOException |
3 |
1. public final Boolean readBooolean()throws IOException, 2. public final byte readByte()throws IOException, 3. public final short readShort()throws IOException 4. public final Int readInt()throws IOException 从输入流中读取字节,返回输入流中两个字节作为对应的基本数据类型返回值。 |
4 |
public String readLine() throws IOException |
所有字节输入流都是以此类发散出来的,但此类是一个抽象类,不可被实例化,所以实际编程过程中,都是使用它发散出来的一些子类,下面是输入流的关系图:
输入流最常用的就是FileInputStream类:
1-1 文本文件的读取:用FileInputStream
该流用于从文件读取数据,它的对象可以用关键字 new 来创建。
·有多种构造方法可用来创建对象。
·可以使用字符串类型的文件名来创建一个输入流对象来读取文件:
·····InputStream f = new FileInputStream("C:/java/hello");
·也可以使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象:
·····File f = new File("C:/java/hello");
·····InputStream out = new FileInputStream(f);
·创建了InputStream对象,就可以使用下面的方法来读取流或者进行其他的流操作。
字节流:
基类:InputStream 子类:FileInputStream
构造:
FileInputStream(File file) || FileInputStream(String name)
方法:
read() 按字节读
read(byte[] b) 读到字节数组缓冲区,数组存满统一批次循环读取
read(byte[] b, int off, int len) 向数组存放时进行了限制,起始位置off和终止位置len
int available() 表示当前还剩多少个字节未读取
注意:read方法返回 int 类型 返回读入字节数组的长度,如果读取到文件末尾的时候,则返回-1
代码演示按字节读取到控制台:
四步走:1.导入相关类 2.创建字节流对象 3.实现读取文本文件的数据 4.关闭文件流对象
测试文档:
使用Read()读取
废话不多说 举个栗子:
package text;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.FileInputStream;
public class FileInputStream01 {
public static void main(String[] args) {
//创建字节流对象
InputStream fls=null;
try {
fls=new FileInputStream("D://TextFile//A.txt");
//实现读取操作
int data;//存储读取的字节
while((data=fls.read())!=-1)
{
//System.out.print(data);//读取的是数字
System.out.print((char)data);//读取的是和文件一致
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally
{
try {
if(fls!=null)
fls.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
修改代码使用Read(byte[] b)读取
int len;//存储读入数组的长度
byte[] wrods=new byte[1024];
while((len=fls.read(wrods))!=-1)
{
System.out.print(new String(wrods,0,len));//String构造方法 把字节byte[] 转换成字符串形式,0代表截取起始位置,len表示截取终止位置
}
结果与上述一致:
1. 输出流
OutputStream:此抽象类是表示字节输出流的所有类的超类(基类)
序号 |
方法描述 |
1 |
public final void write(byte[] w, int off, int len)throws IOException |
2 |
Public final int write(byte [] b)throws IOException |
3 |
1. public final void writeBooolean()throws IOException, 2. public final void writeByte()throws IOException, 3. public final void writeShort()throws IOException, 4. public final void writeInt()throws IOException 这些方法将指定的基本数据类型以字节的方式写入到输出流。 |
4 |
Public void flush()throws IOException |
5 |
public final void writeBytes(String s) throws IOException |
所有字节输出流都是以此类发散出来的,但此类是一个抽象类,不可被实例化,所以实际编程过程中,都是使用它发散出来的一些子类,下面是输出流的关系图:
输出流最常用的就是FileOutputStream 类:
1-2文本文件的写入:用FileOutputStream
该类用来创建一个文件并向文件中写数据。
如果该流在打开文件进行输出前,目标文件不存在,那么该流会创建该文件。
有两个构造方法可以用来创建 FileOutputStream 对象。
使用字符串类型的文件名来创建一个输出流对象:
OutputStream f = new FileOutputStream("C:/java/hello")
也可以使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象:
File f = new File("C:/java/hello");
OutputStream f = new FileOutputStream(f);
输出流:
基类:OutputStream
子类:FileOutputStream ..............
构造:
方法:
废话不多说 举个栗子:
1-3文件读取和写入同步
废话不多说 举个栗子:
2)字符流读和缓冲流读文件
用BufferedReader 和 BufferedWriter读写文本文件//字符流
或 FileReader
字符编码:ASCII码 0~127 8位二进制数1个字节。 16位二进制数表示一个字符 两个字节
字符流:输入流
基类:Reader----FileReader
构造:
常用方法:
1)如果 使用字节流读取带有汉字的文件会怎么样那
package text;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.FileInputStream;
public class FileInputStream01 {
public static void main(String[] args) {
//创建字节流对象
InputStream fls=null;
try {
fls=new FileInputStream("D://TextFile//A.txt");
//实现读取操作
int data;//存储读取的字节
while((data=fls.read())!=-1)
{
//System.out.print(data);//读取的是数字
//System.out.println("还剩:"+fls.available()+"字节未读取");
System.out.print((char)data);
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally
{
try {
if(fls!=null)
fls.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
运行结果如下:
很明显出现了乱码
2)下面使用FileReader字符流 Read()读取文件,示例如下
package text;
/**
* 使用字符流读取文本文件
*<p>Title:FileReaderDemo</p>
*<p>Description:</p>
*<p>Company:</p>
* @author MLQ
* @date 2018年3月7日 下午12:38:35
*/
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader; public class FileReaderDemo {
public static void main(String[] args) {
//创建一个字符流对象
Reader rd=null;
try {
rd=new FileReader("D://TextFile//A.txt");
int word;//就收读取的字符
while((word=rd.read())!=-1)
{
System.out.print((char)word);
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally
{
if(rd!=null)
{
try {
rd.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
运行结果你会发现,乱码消失了
3)下面使用FileReader字符流 Read(char[] b)读取文件,示例如下
修改代码如下:
package text;
/**
* 使用字符流读取文本文件
*<p>Title:FileReaderDemo</p>
*<p>Description:</p>
*<p>Company:</p>
* @author MLQ
* @date 2018年3月7日 下午12:38:35
*/
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader; public class FileReaderDemo {
public static void main(String[] args) {
//创建一个字符流对象
Reader rd=null;
StringBuffer sb=new StringBuffer();
try {
rd=new FileReader("D://TextFile//A.txt");
int word;//就收读取的字符
char[] ch=new char[1024];
while((word=rd.read(ch))!=-1)
{
sb.append(ch,0,word);
}
System.out.println(sb.toString());
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally
{
if(rd!=null)
{
try {
rd.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
运行结果如下:
温馨提示:如果上述的代码 sb.append(ch,0,word) 只写数组的话,会把空格也会追加到 StringBuffer。读取文
件的时候最后可能没有写满数组
4)使用BufferedReader读取文本文件
(增强)
BufferedReader类是Reader类的子类
bufferedReader类带有缓冲区
按行读取内容的ReadLine()方法
实现步骤:
构造:
方法:
演示代码如下:
运行结果如下:
3)字符流读和缓冲流写文件
基类:Write 子类:FileWrite
构造:
方法:
演示代码如下:
3-1)使用FileWrite字符流写入文档
3-2)使用BufferedWrite字符流写入文件
如何提高字符流写文本文件的效率?
解:使用FileWrite类与BufferReader类
BufferedWrite类是Write类的子类
BufferedWrite类带有缓冲区
步骤:
构造:
方法:
代码演示如下:
package text;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer; public class BufferedWrite01 {
public static void main(String[] args) {
//创建FileWrite 和 BufferedWrite 对象
Writer wd=null;
BufferedWriter bw=null;
//创建FileReader 和 BufferedReader 对象
Reader ed=null;
BufferedReader br=null;
try {
wd=new FileWriter("D:\\TextFile\\A.txt");
bw=new BufferedWriter(wd);
bw.write("我是测试员");
bw.newLine();//换行符方法
bw.write("负责测试程序运行问题");
bw.flush();
System.out.println("成功写入");
//读取文本文件信息
ed=new FileReader("D:\\TextFile\\A.txt");
br=new BufferedReader(ed);
String word=null;
while((word=br.readLine())!=null)
{
System.out.println(word);
} } catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
if(wd!=null){
try {
wd.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(bw!=null){
try {
bw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(ed!=null){
try {
ed.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(bw!=null){
try {
bw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
4)使用数据流读写文件
二进制文件读写:
使用DataInputStream 和 DataOutputStream 读写二进制文件 //属于字节流
DataInputStream 类:
FileInputStream的子类
与FileInputStream类结合使用读取二进制文件
DataOutputStream 类:
FileOutputStream的子类
与FileOutputStream类结合使用写二进制文件
DataOutputStream:
演示代码如下:
实现步骤:
package text;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
@SuppressWarnings("unused")
public class DataInOutStream {
@SuppressWarnings("resource")
public static void main(String[] args)throws Exception {
DataInputStream di=null;
DataOutputStream ds=null;
di=new DataInputStream(new FileInputStream("D://TextFile//dd.class"));
ds=new DataOutputStream(new FileOutputStream("D://TextFile//coty.class"));
int len;//接收读取的字节
while((len=di.read())!=-1)
{
ds.write(len);
}
System.out.println("执行完毕");
if(di!=null)
di.close();
ds.close();
}
}
3)序列化和反序列化
序列化和反序列化的过程
序列化的步骤:
1.实现 Serializable 接口
2.创建对象输出流
3.调用 writeObject()方法将对象写入文件
4.关闭对象输出流
使用集合保存对象,可以将集合中的所有对象序列化
序列化构造和常用方法
反序列化构造和常用方法
实现序列化 和 反序列化 演示代码:
package text;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class TextStudent {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
//创建序列化对象
ObjectOutputStream xl=null;
//创建反序列化对象
ObjectInputStream xl1=null;
//初始化要序列化的对象
Map<String,Student> map=new HashMap<String,Student>();
Map<String,Student> map1=new HashMap<String,Student>();
Student stu=new Student("小明",18,"男");
Student stu1=new Student("小红",18,"女");
map.put(stu.getName(), stu);
map.put(stu1.getName(), stu1);
try {
xl=new ObjectOutputStream(new FileOutputStream("D://TextFile//xuliehua.bin"));
xl1=new ObjectInputStream(new FileInputStream("D://TextFile//xuliehua.bin"));
xl.writeObject(map);
System.out.println("写入成功");
//反序列化文件输出到控制台
map1=(Map<String,Student>)xl1.readObject();
Set<String> key=map1.keySet();
Iterator<String> l=key.iterator();
while(l.hasNext())
{
String keys=l.next();
map1.get(keys).show();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
if(xl!=null){
try {
xl.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(xl1!=null)
{
try {
xl1.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
} }
}
测试类
提示:如果不希望Student类某一属性被序列化可使用 transient 修饰
biu ~biu ~ biu ~
注:最后在提一句:使用序列化操作时,一定要将准备序列化的类或数据声明为可序列化操作!!!!
Java 持久化操作之 --io流与序列化的更多相关文章
- Java文件操作(IO流)
File 在java中用来表示文件和文件夹的具体类. File的构建 File的常见方法 字节流: 对象序列化: 字符流: 转接流: InputStreamReader. ...
- Java 持久化操作
持久化就是将内存中的数据保存起来,使之可以长期存在. 在Java中 可以做到持久化有很多种方法. 其中有: 1. 堵塞型IO,也就是我们经常说的io流: 2. 非堵塞型IO,通常称为New IO.也就 ...
- Java socket中关闭IO流后,发生什么事?(以关闭输出流为例)
声明:该博文以socket中,关闭输出流为例进行说明. 为了方便讲解,我们把DataOutputstream dout = new DataOutputStream(new BufferedOutpu ...
- IO流的序列化和反序列化
序列化和反序列化的概念: 序列化:把对象转换为字节序列的过程称为对象的序列化.(常见的就是存文件) 反序列化:把字节序列恢复为对象的过程称为对象阿德反序列化. 序列化和反序列化的使用: java.io ...
- Java 持久化之 --io流与序列化操作
1)File类操作文件的属性 1.File类的常用方法 1. 文件的绝对完整路径:getAbsolutePath() 文件名:getName() 文件相对路径:getPath() 文件的上一级目录:g ...
- Java 基础 IO流之序列化
一,前言 在前面的IO中,我们都是讲数据以字符串的形式保存.能不能将一个数组保存到文件呢,当取出数据时也是一个数组,如果能够实现那就完美了.我们都知道比较通用的有JSON格式的序列化,那java中也有 ...
- java写文件读写操作(IO流,字节流)
package copyfile; import java.io.*; public class copy { public static void main(String[] args) throw ...
- 乐字节Java之file、IO流基础知识和操作步骤
嗨喽,小乐又来了,今天要给大家送上的技术文章是Java重点知识-IO流. 先来看看IO流的思维导图吧. 一. File 在Java中,Everything is Object!所以在文件中,也不例外! ...
- java学习(九) —— java中的File文件操作及IO流概述
前言 流是干什么的:为了永久性的保存数据. IO流用来处理设备之间的数据传输(上传和下载文件) java对数据的操作是通过流的方式. java用于操作流的对象都在IO包中. java IO系统的学习, ...
随机推荐
- ambari下 hive metastore 启动失败
由字符集引起的hive 元数据进程启动失败 解决方法新增 这2句话 reload(sys)sys.setdefaultencoding('utf8')
- Android Screen Monito
1.下载 Android Screen Monitor http://code.google.com/p/android-screen-monitor/ (1) 下載 ASM_2_40.zip 并解压 ...
- Hybrid App混合模式开发的了解
Hybrid App(混合模式移动应用)是指介于web-app.native-app这两者之间的app,兼具"Native App良好用户交互体验的优势"和"Web Ap ...
- WordPress怎么给分类目录排序
WordPress默认的分类目录是按照字母的顺序排序的, 我们可以安装一款插件Category Order就可以自定义分类目录的顺序了,这款插件很小,安装后即可在后台的左侧菜单中看见Category ...
- Unity程序们经常用到的网址(方便自己用,一直更新)
浏览器收藏夹不好用,那就整理到这里吧 官方 API查询: https://docs.unity3d.com/ScriptReference/index.html 文档查询:https://docs.u ...
- 记录解决python在spark运行加载第三方库的问题
一般写python的我们经常会import一些常用的库,然后有时集群环境上的python没有这些库,怎么办呢? 通过一段时间的摸索发现有二种方式可以解决这个问题: 第一种方法: 下载对应python的 ...
- find命令总结
find命令 2018-2-27日整理完成 1,结合-exec的用法 查当前目录下的所有普通文件,并在 -exec 选项中使用ls -l命令将它们列出# find . -type f -exec ls ...
- 云主机和vps的区别
云主机和vps的区别 近年来,IT行业开始热衷于各种云概念,而云主机就是其中之一,并且有越来越热之势.对普通用户而言,可能不太清楚云主机和VPS的区别,下面我们就来说说云主机和VPS到底有什么不同 ...
- 【原创】快应用QuickApp--HelloWorld体验
快应用: 快应用是九大手机厂商基于硬件平台共同推出的新型应用生态.用户无需下载安装,即点即用,享受原生应用的性能体验. 3月20日在北京联合召开快应用标准启动发布会.过去1天了,官网(快应用官方网站) ...
- delete操作字符串会报错吗?
其实是不会的."delete只能对对象属性进行操作"的说法是错误的,严谨来说,delete可以对任意变量类型进行操作,只不过只有对对象的属性才能操作成功,对其他变量类型操作失败罢了 ...