- 浏览: 981092 次
文章分类
- 全部博客 (428)
- Hadoop (2)
- HBase (1)
- ELK (1)
- ActiveMQ (13)
- Kafka (5)
- Redis (14)
- Dubbo (1)
- Memcached (5)
- Netty (56)
- Mina (34)
- NIO (51)
- JUC (53)
- Spring (13)
- Mybatis (17)
- MySQL (21)
- JDBC (12)
- C3P0 (5)
- Tomcat (13)
- SLF4J-log4j (9)
- P6Spy (4)
- Quartz (12)
- Zabbix (7)
- JAVA (9)
- Linux (15)
- HTML (9)
- Lucene (0)
- JS (2)
- WebService (1)
- Maven (4)
- Oracle&MSSQL (14)
- iText (11)
- Development Tools (8)
- UTILS (4)
- LIFE (8)
最新评论
-
Donald_Draper:
Donald_Draper 写道刘落落cici 写道能给我发一 ...
DatagramChannelImpl 解析三(多播) -
Donald_Draper:
刘落落cici 写道能给我发一份这个类的源码吗Datagram ...
DatagramChannelImpl 解析三(多播) -
lyfyouyun:
请问楼主,执行消息发送的时候,报错:Transport sch ...
ActiveMQ连接工厂、连接详解 -
ezlhq:
关于 PollArrayWrapper 状态含义猜测:参考 S ...
WindowsSelectorImpl解析一(FdMap,PollArrayWrapper) -
flyfeifei66:
打算使用xmemcache作为memcache的客户端,由于x ...
Memcached分布式客户端(Xmemcached)
Java Socket通信实例:http://donald-draper.iteye.com/blog/2356695
Java Socket读写缓存区Writer和Reader:http://donald-draper.iteye.com/blog/2356885
Java序列化与反序列化实例分析:http://donald-draper.iteye.com/blog/2357515
FileChannel示例:http://donald-draper.iteye.com/blog/2373661
FileChanne定义:http://donald-draper.iteye.com/blog/2374149
引言:
在Java序列化与反序列化实例分析文章我们用ObjectInput/OutputStream将对象序列化到文件,FileChannel示例这篇文章中我们通过文件通道读写文件,ObjectInput/OutputStream读写文件是面向字节流的读写文件方式,fileChannel是面向通道的读写文件方法(ByteBuffer),还有一种是面向字符流的读取文件方式,及Reader和Writer,今天主要来看面向字节流和面向字符流的读取文件方法。
测试实例:
执行程序,控制台输出:
文件路径:E:\file\dir\test.txt
文件绝对路径:E:\file\dir\test.txt
文件规范路径:E:\file\dir\test.txt
文件父路径:E:\file\dir
完整文件名:test.txt
文件名:test
文件类型:txt
文件分隔符:\
是否绝对路径:true
是否为目录:false
是否为文件:true
是否为隐藏文件:false
文件是否可读:true
文件是否可写:true
文件是否可执行:true
========创建文件:true
创建文件过后,是否为文件:true
========是否为隐藏文件:false
========文件是否可读:true
========文件是否可写:true
========文件是否可执行:true
文件系统根目录size:5
C:\,D:\,E:\,F:\,G:\,
当前文件目录下的文件size:1
E:\file\dir\test.txt,
Path文件类型:class sun.nio.fs.WindowsPath
===写字节序列到文件输出流完成======
==文件输入流可用字节数:30
从文件输入流读取字节数:30
从文件输入流内容:test FileOutputStream write...
===写字节序列到缓冲区输出流======
===刷新缓冲区字节序列到输出流完毕======
==缓存区输入流可用字节数:64
从缓存区输入流读取字节数:64
从缓存区输入流内容:test FileOutputStream write...test BufferedOutputStream write...
=======测试Writer,Reader=====
========创建文件:true
创建文件过后,是否为文件:true
========是否为隐藏文件:false
========文件是否可读:true
========文件是否可写:true
========文件是否可执行:true
==fileWriter写字符串完毕
==fileReader读取字符数:24
==fileReader读取结果:test FileWriter write...
==bufferedWriter写字符串完毕
==bufferedReader读取一行字符串:test FileWriter write...
==bufferedReader读取一行字符串:test BufferedWriter write...
==创建临时文件成功:testFile5597549589275073288.tmp
总结:
File表示的系统文件,可以是目录,可以是实际文件。创建文件时首先要确保实际文件的父目录要存在。通过文件获取的文件名,返回的是完整文件名,即文件名+后缀(文件类型)。
FileOutput/InputStream,主要用于面向字节流读写文件方式;读文件文件我们还可以借助其他字节流比如:
BufferedOutput/InputStream在写字节序列,先放入缓冲区中,调用flush方法,
可以缓冲区字节序列更新到底层输出流;
DataOutput/InputStream,除了处理字节序列之外,也可以处理原始类型Int,Char,
Long,Double,Float,Boolean等;
ObjectOutput/InputStream除了可以处理字节序列之外,也可以原始类型,主要用于对象的序列化和反序列化;
上述三种字节流的构造中,都有一个构造参数,即Output/InputStream,可以为socket(BIO)输出流/输入流,或FileOutput/InputStream。
FileWriter/Reader,为面向字符流的读写文件方式;也可以通过BufferedWriter/Reader,读写文件,可以将文件先包装成FileOutput/InputStream,再根据FileOutput/InputStream,构造OutputStreamWriter/InputStreamReader,最后OutputStreamWriter/InputStreamReader构造BufferedWriter/Reader,就可以通过BufferedWriter/Reader读写文件;而OutputStreamWriter/InputStreamReader的构造关键参数为Output/InputStream,
我们可以从Socket(BIO),获取socket输入流和输出流,包装成OutputStreamWriter/InputStreamReader,那么我们就可以通过BufferedWriter/Reader读socket输入流和写socket输出流。OutputStreamWriter/InputStreamReader,是字节流与字符流的桥接,写操作,字符流使用Charset编码成字节流,以字节流的形式发送底层字节流。Charset编码可设置,如果没有设定,则用默认的编码,读操作类似。
上述中的面向字节流和字符流中带Buffered*,是可以缓存字节序列和字符串,写操作过后,要调用flush,更缓存数据到底层的输出流。
当然读写文件的方式也可以通过RandomAccessFile,和FileChannel。读取文件,建议
用FileChannel方法,因为FileChannel直接将文件映射到物理内存中,读写更高效,如果对
性能没有要求,可以用面向字节流(Output/InputStream)和字符流(Writer/Reader)的方式。
无论面向字节的,还是面向字符的流,都是读写分离的,而RandomAccessFile,是可读可写的;可写字节序列,原始类型,可读字节序列,原始类型,按行读取。字节流,字符流,RandomAccessFile为java io(JDK1.0,1.1)包中的工具类,文件通道FileChannel为java nio(JDK1.4)包中的工具类。
文件读写方式简单综述后续(文件,流构造):http://donald-draper.iteye.com/blog/2374294
附:
//FileOutputStream
//FileInputStream
//BufferedOutputStream
//FilterOutputStream
//BufferedInputStream
//FilterInputStream
//DataOutputStream
//DataInputStream
//FileWriter
//OutputStreamWriter
//FileReader
//InputStreamReader
//BufferedWriter
//BufferedReader
//RandomAccessFile
Java Socket读写缓存区Writer和Reader:http://donald-draper.iteye.com/blog/2356885
Java序列化与反序列化实例分析:http://donald-draper.iteye.com/blog/2357515
FileChannel示例:http://donald-draper.iteye.com/blog/2373661
FileChanne定义:http://donald-draper.iteye.com/blog/2374149
引言:
在Java序列化与反序列化实例分析文章我们用ObjectInput/OutputStream将对象序列化到文件,FileChannel示例这篇文章中我们通过文件通道读写文件,ObjectInput/OutputStream读写文件是面向字节流的读写文件方式,fileChannel是面向通道的读写文件方法(ByteBuffer),还有一种是面向字符流的读取文件方式,及Reader和Writer,今天主要来看面向字节流和面向字符流的读取文件方法。
测试实例:
package nio.file; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.OutputStream; import java.io.OutputStreamWriter; import java.io.RandomAccessFile; import java.nio.channels.FileChannel; import java.nio.file.OpenOption; import java.nio.file.Path; import java.nio.file.attribute.FileAttribute; import java.util.Set; /** * 测试读写文件 * @author donald * 2017年5月12日 * 下午11:33:14 * @see java.io.FileInputStream#getChannel()//读模式 * @see java.io.FileOutputStream#getChannel()//写模式 * @see java.io.RandomAccessFile#getChannel()//以创建RandomAccessFile的模式为准,r,rw。 */ public class testFile { private static File file = null; public static void main(String[] args) throws IOException { file = new File("E:/file/dir/test.txt"); String pathStr = file.getPath();//路径中包括文件名和文件后缀 System.out.println("文件路径:"+pathStr); System.out.println("文件绝对路径:"+file.getAbsolutePath()); System.out.println("文件规范路径:"+file.getCanonicalPath());//返回路径的规范格式,与系统有关 System.out.println("文件父路径:"+file.getParent()); System.out.println("完整文件名:"+file.getName());//默认返回的文件名是包括后缀的 System.out.println("文件名:"+file.getName().split("\\.")[0]); System.out.println("文件类型:"+file.getName().split("\\.")[1]); System.out.println("文件分隔符:"+file.separator); System.out.println("是否绝对路径:"+file.isAbsolute()); System.out.println("是否为目录:"+file.isDirectory()); System.out.println("是否为文件:"+file.isFile()); System.out.println("是否为隐藏文件:"+file.isHidden()); System.out.println("文件是否可读:"+file.canRead()); System.out.println("文件是否可写:"+file.canWrite()); System.out.println("文件是否可执行:"+file.canExecute()); // testMkdirs(); if(file.exists()){ file.delete(); } if(!file.exists()){ createFile(file); } testListRoots(); testListFiles(file); /* * 这里的Path,就是我们在FileChannle定义文章中,要打开一个文件通道,要传入一个Path参数 * FileChannel open(Path path,Set<? extends OpenOption> options,FileAttribute<?>... attrs) * */ Path path = file.toPath(); System.out.println("Path文件类型:"+path.getClass()); //FileOutputStream //第二个参数为true,表示从文件末尾开始写,只写模式 FileOutputStream fileOutputStream = new FileOutputStream(file,true); String writeString = "test FileOutputStream write..."; fileOutputStream.write(writeString.getBytes("UTF-8")); System.out.println("===写字节序列到文件输出流完成======"); // fileOutputStream.getChannel();//获取写模式文件通道 fileOutputStream.close(); //FileInputStreams FileInputStream fileInputStream = new FileInputStream(file); int fisAvailable = fileInputStream.available(); System.out.println("==文件输入流可用字节数:"+fisAvailable); byte[] readBytes = new byte[fisAvailable]; System.out.println("从文件输入流读取字节数:"+fileInputStream.read(readBytes)); System.out.println("从文件输入流内容:"+new String(readBytes,"UTF-8")); // fileInputStream.getChannel();//获取读模式文件通道 fileInputStream.close(); /* FileOutput/InputStream,主要用于读写文件,面向字节流的*/ //BufferedOutputStream BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(file,true)); bufferedOutputStream.write(new String("test BufferedOutputStream write...").getBytes("UTF-8")); System.out.println("===写字节序列到缓冲区输出流======"); bufferedOutputStream.flush(); System.out.println("===刷新缓冲区字节序列到输出流完毕======"); bufferedOutputStream.close(); //BufferedInputStream BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(file)); int bisAvailable = bufferedInputStream.available(); System.out.println("==缓存区输入流可用字节数:"+bisAvailable); byte[] readBytesfromBuffer = new byte[bisAvailable]; System.out.println("从缓存区输入流读取字节数:"+bufferedInputStream.read(readBytesfromBuffer)); System.out.println("从缓存区输入流内容:"+new String(readBytesfromBuffer,"UTF-8")); bufferedInputStream.close(); /* * BufferedInputStream,BufferedOutputStream,也可以用于读写socket(Bio)输入/出流 * 针对字节流,在写字节序列,先放入缓冲区中,调用flush方法,可以缓冲区字节序列更新到底层输出流 */ /* * public DataOutputStream(OutputStream out) { * super(out); * } */ //DataOutputStream构造中的OutputStream,可以为socket(Bio)输出流,或FileInputStream DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream(file,true));; dataOutputStream.close(); /* * public DataInputStream(InputStream in) { * super(in); * } */ //DataInputStream构造中的InputStream,可以为socket(Bio)输入流,或FileInputStream DataInputStream dataInputStream = new DataInputStream(new FileInputStream(file)); dataInputStream.close(); /* * DataInputStream,DataOutputStream,除了处理字节序列之外,也可以原始类型Int,Char,Long,Double, * Float,Boolean等 */ // ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(file,true)); // objectOutputStream.writeObject(obj); // objectOutputStream.close(); // ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file)); // objectInputStream.readObject(); // objectInputStream.close(); /* * ObjectOutput/InputStream构造中的Output/InputStream,可以为socket(Bio)输出流/输入流, * 或FileOutput/InputStream,ObjectOutput/InputStream除了可以处理字节序列之外,也可以原始类型Int, * Char,Long,Double,Float,Boolean等,主要用于对象的序列化和反序列化; * 这部分测试的话,最好先写一个对象到文件,然后在读取,因为写对象的时候,要将魔数等信息写进去 */ System.out.println("=======测试Writer,Reader====="); if(file.exists()){ file.delete(); } if(!file.exists()){ createFile(file); } FileWriter fileWriter = new FileWriter(file, true); fileWriter.write("test FileWriter write..."); fileWriter.flush(); fileWriter.close(); System.out.println("==fileWriter写字符串完毕"); FileReader fileReader = new FileReader(file); char[] readChars = new char[24]; if(fileReader.ready()){ System.out.println("==fileReader读取字符数:"+fileReader.read(readChars)); System.out.println("==fileReader读取结果:"+new String(readChars)); } fileReader.close(); /* FileWriter/Reader,主要用于读写文件,面向字符流的*/ /* * public OutputStreamWriter(OutputStream out, String charsetName) */ OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(file,true),"UTF-8"); BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter); bufferedWriter.newLine(); bufferedWriter.write("test BufferedWriter write..."); bufferedWriter.newLine(); bufferedWriter.flush(); bufferedWriter.close(); System.out.println("==bufferedWriter写字符串完毕"); /* * public InputStreamReader(InputStream in, String charsetName) */ InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(file),"UTF-8"); BufferedReader bufferedReader = new BufferedReader(inputStreamReader); if(bufferedReader.ready()){ System.out.println("==bufferedReader读取一行字符串:"+bufferedReader.readLine()); System.out.println("==bufferedReader读取一行字符串:"+bufferedReader.readLine()); } bufferedReader.close(); /* * BufferedWriter/Reader,读写文件,可以将文件先包装成FileOutput/InputStream, * 再根据FileOutput/InputStream,构造OutputStreamWriter/InputStreamReader, * 最后OutputStreamWriter/InputStreamReader构造BufferedWriter/Reader,就可以 * 通过BufferedWriter/Reader读写文件;从上面可以看出OutputStreamWriter/InputStreamReader * 的构造关键参数为Output/InputStream,我们从Socket(BIO),获取socket输入流和输出流, * 包装成OutputStreamWriter/InputStreamReader,那么我们就可以通过BufferedWriter/Reader * 读socket输入流和写socket输出流。 */ RandomAccessFile randomAccessFile = new RandomAccessFile(file,"rw"); //这里就不具体介绍了,F3,看看具体非方法声明,就知道怎么回事了 // randomAccessFile.getChannel();//获取读写模式文件通道 randomAccessFile.close(); /** * 前面无论是面向字节的,还是面向字符的流,都是读写分离的,而RandomAccessFile,是 * 可读可写的;可写字节序列,原始类型,可读字节序列,原始类型,按行读取; * */ // FileChannel fileChannel = randomAccessFile.getChannel(); /** * 这种方式为通过通道读写文件,在前面的文章以说,这里不再说 */ File tfile = File.createTempFile("testFile", ".tmp", new File("E:/file/dir/")); if(tfile.exists()){ System.out.println("==创建临时文件成功:"+tfile.getName()); } tfile.deleteOnExit();//针对临时文件 } /** * 测试创建文件目录方法 */ public static void testMkdirs(){ if(!file.exists()){ System.out.println("========文件不存在========"); System.out.println("========创建文件路径:"+file.mkdir()); } if(!file.exists()){ System.out.println("========文件不存在========"); //当父路径不存在时,循环创建父类路径,包括文件名和后缀 System.out.println("========循环创建父类路径:"+file.mkdirs()); } } /** * 创建文件 * @param f * @return * @throws IOException */ public static File createFile(File f) throws IOException{ if(!f.exists()){ //创建文件时,如果文件父路径不存在,则应先创建创建路径,然后再创建文件 f.getParentFile().mkdirs(); if(f.getParentFile().exists()){ System.out.println("========创建文件:"+f.createNewFile()); System.out.println("创建文件过后,是否为文件:"+file.isFile()); System.out.println("========是否为隐藏文件:"+file.isHidden()); System.out.println("========文件是否可读:"+file.canRead()); System.out.println("========文件是否可写:"+file.canWrite()); System.out.println("========文件是否可执行:"+file.canExecute()); } } return f; } /** * 获取文件系统的更目录,unix下,根目录为/ * windows为C:,D:,E:... */ public static void testListRoots(){ System.out.println("文件系统根目录size:"+File.listRoots().length); for(File tfile : File.listRoots()){ System.out.print(tfile.getPath()+","); } System.out.println(); } /** * 获取文件当前目录下的文件 * @param lf */ public static void testListFiles(File lf){ File parentFile = lf.getParentFile(); System.out.println("当前文件目录下的文件size:"+parentFile.listFiles().length); for(File tfile : parentFile.listFiles()){ System.out.print(tfile.getPath()+","); } System.out.println(); } }
执行程序,控制台输出:
文件路径:E:\file\dir\test.txt
文件绝对路径:E:\file\dir\test.txt
文件规范路径:E:\file\dir\test.txt
文件父路径:E:\file\dir
完整文件名:test.txt
文件名:test
文件类型:txt
文件分隔符:\
是否绝对路径:true
是否为目录:false
是否为文件:true
是否为隐藏文件:false
文件是否可读:true
文件是否可写:true
文件是否可执行:true
========创建文件:true
创建文件过后,是否为文件:true
========是否为隐藏文件:false
========文件是否可读:true
========文件是否可写:true
========文件是否可执行:true
文件系统根目录size:5
C:\,D:\,E:\,F:\,G:\,
当前文件目录下的文件size:1
E:\file\dir\test.txt,
Path文件类型:class sun.nio.fs.WindowsPath
===写字节序列到文件输出流完成======
==文件输入流可用字节数:30
从文件输入流读取字节数:30
从文件输入流内容:test FileOutputStream write...
===写字节序列到缓冲区输出流======
===刷新缓冲区字节序列到输出流完毕======
==缓存区输入流可用字节数:64
从缓存区输入流读取字节数:64
从缓存区输入流内容:test FileOutputStream write...test BufferedOutputStream write...
=======测试Writer,Reader=====
========创建文件:true
创建文件过后,是否为文件:true
========是否为隐藏文件:false
========文件是否可读:true
========文件是否可写:true
========文件是否可执行:true
==fileWriter写字符串完毕
==fileReader读取字符数:24
==fileReader读取结果:test FileWriter write...
==bufferedWriter写字符串完毕
==bufferedReader读取一行字符串:test FileWriter write...
==bufferedReader读取一行字符串:test BufferedWriter write...
==创建临时文件成功:testFile5597549589275073288.tmp
总结:
File表示的系统文件,可以是目录,可以是实际文件。创建文件时首先要确保实际文件的父目录要存在。通过文件获取的文件名,返回的是完整文件名,即文件名+后缀(文件类型)。
FileOutput/InputStream,主要用于面向字节流读写文件方式;读文件文件我们还可以借助其他字节流比如:
BufferedOutput/InputStream在写字节序列,先放入缓冲区中,调用flush方法,
可以缓冲区字节序列更新到底层输出流;
DataOutput/InputStream,除了处理字节序列之外,也可以处理原始类型Int,Char,
Long,Double,Float,Boolean等;
ObjectOutput/InputStream除了可以处理字节序列之外,也可以原始类型,主要用于对象的序列化和反序列化;
上述三种字节流的构造中,都有一个构造参数,即Output/InputStream,可以为socket(BIO)输出流/输入流,或FileOutput/InputStream。
FileWriter/Reader,为面向字符流的读写文件方式;也可以通过BufferedWriter/Reader,读写文件,可以将文件先包装成FileOutput/InputStream,再根据FileOutput/InputStream,构造OutputStreamWriter/InputStreamReader,最后OutputStreamWriter/InputStreamReader构造BufferedWriter/Reader,就可以通过BufferedWriter/Reader读写文件;而OutputStreamWriter/InputStreamReader的构造关键参数为Output/InputStream,
我们可以从Socket(BIO),获取socket输入流和输出流,包装成OutputStreamWriter/InputStreamReader,那么我们就可以通过BufferedWriter/Reader读socket输入流和写socket输出流。OutputStreamWriter/InputStreamReader,是字节流与字符流的桥接,写操作,字符流使用Charset编码成字节流,以字节流的形式发送底层字节流。Charset编码可设置,如果没有设定,则用默认的编码,读操作类似。
上述中的面向字节流和字符流中带Buffered*,是可以缓存字节序列和字符串,写操作过后,要调用flush,更缓存数据到底层的输出流。
当然读写文件的方式也可以通过RandomAccessFile,和FileChannel。读取文件,建议
用FileChannel方法,因为FileChannel直接将文件映射到物理内存中,读写更高效,如果对
性能没有要求,可以用面向字节流(Output/InputStream)和字符流(Writer/Reader)的方式。
无论面向字节的,还是面向字符的流,都是读写分离的,而RandomAccessFile,是可读可写的;可写字节序列,原始类型,可读字节序列,原始类型,按行读取。字节流,字符流,RandomAccessFile为java io(JDK1.0,1.1)包中的工具类,文件通道FileChannel为java nio(JDK1.4)包中的工具类。
文件读写方式简单综述后续(文件,流构造):http://donald-draper.iteye.com/blog/2374294
附:
//FileOutputStream
public class FileOutputStream extends OutputStream
//FileInputStream
public class FileInputStream extends InputStream
//BufferedOutputStream
public class BufferedOutputStream extends FilterOutputStream
//FilterOutputStream
public class FilterOutputStream extends OutputStream
//BufferedInputStream
public class BufferedInputStream extends FilterInputStream
//FilterInputStream
public class FilterInputStream extends InputStream
/* @author Arthur van Hoff * @see java.io.BufferedOutputStream * @see java.io.ByteArrayOutputStream * @see java.io.DataOutputStream * @see java.io.FilterOutputStream * @see java.io.InputStream * @see java.io.OutputStream#write(int) * @since JDK1.0 */ //OutputStream public abstract class OutputStream implements Closeable, Flushable
/* @author Arthur van Hoff * @see java.io.BufferedInputStream * @see java.io.ByteArrayInputStream * @see java.io.DataInputStream * @see java.io.FilterInputStream * @see java.io.InputStream#read() * @see java.io.OutputStream * @see java.io.PushbackInputStream * @since JDK1.0 */ //InputStream public abstract class InputStream implements Closeable
//DataOutputStream
public class DataOutputStream extends FilterOutputStream implements DataOutput
/* @author Frank Yellin * @see java.io.DataInput * @see java.io.DataOutputStream * @since JDK1.0 */ //DataOutput public interface DataOutput {
//DataInputStream
public class DataInputStream extends FilterInputStream implements DataInput
/* @author Frank Yellin * @see java.io.DataInputStream * @see java.io.DataOutput * @since JDK1.0 */ public interface DataInput { //DataInput
/* @author Mike Warres * @author Roger Riggs * @see java.io.DataOutput * @see java.io.ObjectInputStream * @see java.io.Serializable * @see java.io.Externalizable * @see [url=../../../platform/serialization/spec/output.html]Object Serialization Specification, Section 2, Object Output Classes[/url] * @since JDK1.1 */ //ObjectOutputStream public class ObjectOutputStream extends OutputStream implements ObjectOutput, ObjectStreamConstants
/* @author unascribed * @see java.io.InputStream * @see java.io.ObjectOutputStream * @see java.io.ObjectInputStream * @since JDK1.1 */ //ObjectOutput public interface ObjectOutput extends DataOutput, AutoCloseable
/* @author Mike Warres * @author Roger Riggs * @see java.io.DataInput * @see java.io.ObjectOutputStream * @see java.io.Serializable * @see [url=../../../platform/serialization/spec/input.html] Object Serialization Specification, Section 3, Object Input Classes[/url] * @since JDK1.1 */ //ObjectInputStream public class ObjectInputStream extends InputStream implements ObjectInput, ObjectStreamConstants
/* @author unascribed * @see java.io.InputStream * @see java.io.ObjectOutputStream * @see java.io.ObjectInputStream * @since JDK1.1 */ //ObjectInput public interface ObjectInput extends DataInput, AutoCloseable
//FileWriter
/* @see OutputStreamWriter * @see FileOutputStream * * @author Mark Reinhold * @since JDK1.1 */ public class FileWriter extends OutputStreamWriter {
//OutputStreamWriter
/* @see BufferedWriter * @see OutputStream * @see java.nio.charset.Charset * * @author Mark Reinhold * @since JDK1.1 */ public class OutputStreamWriter extends Writer {
//FileReader
/* @see InputStreamReader * @see FileInputStream * * @author Mark Reinhold * @since JDK1.1 */ public class FileReader extends InputStreamReader {
//InputStreamReader
/* @see BufferedReader * @see InputStream * @see java.nio.charset.Charset * * @author Mark Reinhold * @since JDK1.1 */ public class InputStreamReader extends Reader {
//BufferedWriter
/* @see PrintWriter * @see FileWriter * @see OutputStreamWriter * @see java.nio.file.Files#newBufferedWriter * * @author Mark Reinhold * @since JDK1.1 */ public class BufferedWriter extends Writer {
//BufferedReader
/* @see FileReader * @see InputStreamReader * @see java.nio.file.Files#newBufferedReader * * @author Mark Reinhold * @since JDK1.1 */ public class BufferedReader extends Reader {
//Writer /* @see Writer * @see BufferedWriter * @see CharArrayWriter * @see FilterWriter * @see OutputStreamWriter * @see FileWriter * @see PipedWriter * @see PrintWriter * @see StringWriter * @see Reader * * @author Mark Reinhold * @since JDK1.1 */ //Writer public abstract class Writer implements Appendable, Closeable, Flushable {
/* @see BufferedReader * @see LineNumberReader * @see CharArrayReader * @see InputStreamReader * @see FileReader * @see FilterReader * @see PushbackReader * @see PipedReader * @see StringReader * @see Writer * * @author Mark Reinhold * @since JDK1.1 */ public abstract class Reader implements Readable, Closeable {
//RandomAccessFile
/* @author unascribed * @since JDK1.0 */ public class RandomAccessFile implements DataOutput, DataInput, Closeable {
发表评论
-
文件通道解析二(文件锁,关闭通道)
2017-05-16 23:17 1067文件通道解析一(读写操作,通道数据传输等):http://do ... -
文件通道解析一(读写操作,通道数据传输等)
2017-05-16 10:04 1164Reference定义(PhantomRefere ... -
文件通道创建方式综述
2017-05-15 17:39 1066Reference定义(PhantomReference,Cl ... -
文件读写方式简单综述后续(文件,流构造)
2017-05-14 23:04 1480Java Socket通信实例:http://donald-d ... -
FileChanne定义
2017-05-12 23:28 938文件读写方式简单综述:http://donald-draper ... -
SeekableByteChannel接口定义
2017-05-11 08:43 1235ByteChannel,分散聚集通道接口的定义(SocketC ... -
FileChannel示例
2017-05-11 08:37 992前面我们看过socket通道,datagram通道,以管道Pi ... -
PipeImpl解析
2017-05-11 08:41 933ServerSocketChannel定义:http://do ... -
Pipe定义
2017-05-10 09:07 906Channel接口定义:http://donald-drape ... -
NIO-Pipe示例
2017-05-10 08:47 905PipeImpl解析:http://donald-draper ... -
DatagramChannelImpl 解析四(地址绑定,关闭通道等)
2017-05-10 08:27 779DatagramChannelImpl 解析一(初始化):ht ... -
DatagramChannelImpl 解析三(多播)
2017-05-10 08:20 1900DatagramChannelImpl 解析一(初始化):ht ... -
NIO-UDP实例
2017-05-09 12:32 1585DatagramChannelImpl 解析一(初始化):ht ... -
DatagramChannelImpl 解析二(报文发送与接收)
2017-05-09 09:03 1406DatagramChannelImpl 解析一(初始化):ht ... -
DatagramChannelImpl 解析一(初始化)
2017-05-08 21:52 1410Channel接口定义:http://donald-drape ... -
MembershipKeyImpl 简介
2017-05-08 09:11 924MembershipKey定义:http://donald-d ... -
DatagramChannel定义
2017-05-07 23:13 1228Channel接口定义:http://donald-drape ... -
MulticastChanne接口定义
2017-05-07 13:45 1136NetworkChannel接口定义:ht ... -
MembershipKey定义
2017-05-06 16:20 917package java.nio.channels; i ... -
SocketChannelImpl 解析四(关闭通道等)
2017-05-05 08:38 2533SocketChannelImpl 解析一(通道连接,发送数据 ...
相关推荐
本文将深入探讨图文件读写的各个方面,以帮助你更好地理解和应用这些知识。 首先,我们需要理解什么是图文件。图文件是指用于存储图像数据的文件,它们可以是位图(如BMP、JPEG、PNG)或矢量图(如SVG、EPS)。位图...
【二级文件操作系统】是一种设计用于Linux系统的简单多用户文件系统,其主要目标是让学生通过实践设计,深入理解文件系统的内部工作原理和实现机制。在设计过程中,学生需要结合数据结构、程序设计和计算机原理等多...
- **读写操作**: 可以使用`>>`和`操作符来进行简单的文本数据读写;对于更复杂的操作,如读写特定类型的数据,可以使用`read()`和`write()`成员函数。 - **关闭文件**: 完成文件操作后,应该使用`close()`成员函数...
GFS的设计目标是处理大规模数据流,支持大文件的快速读写,适合大规模数据分析和处理任务。 HDFS(Hadoop Distributed File System)是Apache Hadoop项目的一部分,是对GFS的一种开源实现。HDFS同样采用主从架构,...
### NoSQL非关系型数据库综述 #### 一、NoSQL产生背景 随着Web 2.0时代的到来,互联网的应用和服务迅速发展,这对数据管理和存储技术提出了新的挑战。传统的关系型数据库虽然在过去几十年中占据主导地位,但在面对...
通过设计一个简单的多用户文件系统,学生将结合数据结构、程序设计、计算机原理等多门课程的知识,具体实践二级文件系统的构建,从而加深对操作系统核心概念的掌握。此外,实验还注重培养学生的实际应用能力和编程...
在 C 语言中读写 WAV 文件主要涉及对上述结构体的操作。编写程序时,首先需要解析 WAV 文件的头部信息,确定音频的基本参数,然后根据这些信息读取或写入音频数据。 读取 WAV 文件的步骤大致如下: 1. 打开 WAV ...
此外,JavaScript 语言还具有简单、易学、易用的特性,目的就是希望能让程序员快速完成程序的编写工作。 API 文档 API(Application Programming Interface,应用程序编程接口)是一些预先定义的函数,目的是提供...
3. 键值存储数据库:键值存储数据库是NoSQL数据库中的一种简单形式,通过键值对来存储数据。它具有非常高的读写性能,并且扩展性好。Redis是键值存储数据库中最为知名的代表之一。 4. 图存储数据库:图存储数据库专...
1. **xBASE兼容**:如dBase,以文件形式存储数据,适用于简单的单用户或小型多用户环境,但并发访问时可能会遇到性能问题。 2. **SQL兼容**:这类系统包括Ingres的先驱QUEL和SQL,通常有一个中心数据库引擎来处理...
### 嵌入式开发系列课程(9):Windows CE驱动开发综述 #### Windows CE驱动开发概述 在本节中,我们将深入了解Windows CE环境下的驱动开发,这是一门非常重要的课程,对于那些希望深入理解并掌握Windows CE操作系统...
### 基于Hadoop生态系统的大数据解决方案综述 #### 一、绪论 随着互联网技术的迅猛发展,数据量呈爆炸式增长,这不仅带来了前所未有的机遇,也对数据处理能力提出了更高要求。大数据技术应运而生,旨在解决大规模...
本篇综述主要探讨了Hadoop技术的起源、优势以及技术原理,并回顾了其学术研究成果,并重点分析了Hadoop在各方面的应用进展,最后对未来的发展方向和需解决的问题进行了展望。 1. Hadoop的起源和发展 Hadoop是一个由...
此外,Linux 配备了强大的防火墙组件,配置简单,管理成本低,安全性高,因此在关键业务系统中被广泛采用。 【基于 Linux 的数据库】 Linux 平台上的数据库系统以其稳定性和资源效率而受到青睐。数据库主要分为两...
阻塞模式下的文件写入虽然简单,但在高并发环境下可能导致性能下降;而非阻塞模式虽然复杂,但效率更高。 **5.18 Just Like Files 文件一样** 在某些方面,Socket可以被视为一种特殊的“文件”,因为它们都提供了一...
6.6.1 文件读写及上锁 201 6.6.2 多路复用式串口读写 204 本章小结 207 思考与练习 207 第7章 进程控制开发 208 7.1 Linux下进程概述 208 7.1.1 进程相关基本概念 208 7.1.2 Linux下的进程...
这种方式更适合处理大型XML文件,因为它不需要一次性将整个文档加载到内存中。 3. **StAX (Streaming API for XML)**:这是一种流式解析API,结合了DOM和SAX的优点,既可以高效地处理大型XML文件,又提供了随机...
第 5 章 一个简单文件系统的 Slice 定义 137 5.1 本章综 137 5.2 文件系统应用 137 5.3 文件系统的 Slice 定义 138 5.4 完整的定义 140 第 6 章 客户端的 Slice-to-C++ 映射 143 6.1 本章综 143 6.2 引言 143 6.3 ...