`
Donald_Draper
  • 浏览: 981092 次
社区版块
存档分类
最新评论

文件读写方式简单综述

    博客分类:
  • NIO
nio 
阅读更多
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,今天主要来看面向字节流和面向字符流的读取文件方法。
测试实例:
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 {






  • 大小: 54.2 KB
  • 大小: 44 KB
  • 大小: 17.6 KB
  • 大小: 16 KB
  • 大小: 45 KB
  • 大小: 22.7 KB
  • 大小: 13.2 KB
  • 大小: 21.9 KB
  • 大小: 46.4 KB
  • 大小: 32.2 KB
  • 大小: 48.6 KB
  • 大小: 34.1 KB
  • 大小: 58.4 KB
  • 大小: 14.4 KB
  • 大小: 57.2 KB
  • 大小: 14.8 KB
  • 大小: 11.3 KB
  • 大小: 29.3 KB
  • 大小: 7.8 KB
  • 大小: 23.6 KB
  • 大小: 30 KB
  • 大小: 47.5 KB
  • 大小: 32.8 KB
  • 大小: 27.9 KB
  • 大小: 56.4 KB
  • 大小: 62.4 KB
0
0
分享到:
评论

相关推荐

    图文件读写综述

    本文将深入探讨图文件读写的各个方面,以帮助你更好地理解和应用这些知识。 首先,我们需要理解什么是图文件。图文件是指用于存储图像数据的文件,它们可以是位图(如BMP、JPEG、PNG)或矢量图(如SVG、EPS)。位图...

    二级文件操作系统

    【二级文件操作系统】是一种设计用于Linux系统的简单多用户文件系统,其主要目标是让学生通过实践设计,深入理解文件系统的内部工作原理和实现机制。在设计过程中,学生需要结合数据结构、程序设计和计算机原理等多...

    关于C++输入输出的综述

    - **读写操作**: 可以使用`&gt;&gt;`和`操作符来进行简单的文本数据读写;对于更复杂的操作,如读写特定类型的数据,可以使用`read()`和`write()`成员函数。 - **关闭文件**: 完成文件操作后,应该使用`close()`成员函数...

    主流的分布式存储技术综述

    GFS的设计目标是处理大规模数据流,支持大文件的快速读写,适合大规模数据分析和处理任务。 HDFS(Hadoop Distributed File System)是Apache Hadoop项目的一部分,是对GFS的一种开源实现。HDFS同样采用主从架构,...

    nosql 非关系数据库综述

    ### NoSQL非关系型数据库综述 #### 一、NoSQL产生背景 随着Web 2.0时代的到来,互联网的应用和服务迅速发展,这对数据管理和存储技术提出了新的挑战。传统的关系型数据库虽然在过去几十年中占据主导地位,但在面对...

    操作系统文件管理实验

    通过设计一个简单的多用户文件系统,学生将结合数据结构、程序设计、计算机原理等多门课程的知识,具体实践二级文件系统的构建,从而加深对操作系统核心概念的掌握。此外,实验还注重培养学生的实际应用能力和编程...

    wav文件 格式详解

    在 C 语言中读写 WAV 文件主要涉及对上述结构体的操作。编写程序时,首先需要解析 WAV 文件的头部信息,确定音频的基本参数,然后根据这些信息读取或写入音频数据。 读取 WAV 文件的步骤大致如下: 1. 打开 WAV ...

    JavaScript在线API文档生成文献综述.doc

    此外,JavaScript 语言还具有简单、易学、易用的特性,目的就是希望能让程序员快速完成程序的编写工作。 API 文档 API(Application Programming Interface,应用程序编程接口)是一些预先定义的函数,目的是提供...

    论文研究-NoSQL数据库综述 .pdf

    3. 键值存储数据库:键值存储数据库是NoSQL数据库中的一种简单形式,通过键值对来存储数据。它具有非常高的读写性能,并且扩展性好。Redis是键值存储数据库中最为知名的代表之一。 4. 图存储数据库:图存储数据库专...

    综述Linux平台上的数据库.pdf

    1. **xBASE兼容**:如dBase,以文件形式存储数据,适用于简单的单用户或小型多用户环境,但并发访问时可能会遇到性能问题。 2. **SQL兼容**:这类系统包括Ingres的先驱QUEL和SQL,通常有一个中心数据库引擎来处理...

    嵌入式开发系列课程(9):Windows CE驱动开发综述.pdf

    ### 嵌入式开发系列课程(9):Windows CE驱动开发综述 #### Windows CE驱动开发概述 在本节中,我们将深入了解Windows CE环境下的驱动开发,这是一门非常重要的课程,对于那些希望深入理解并掌握Windows CE操作系统...

    基于Hadoop生态系统的大数据解决方案综述.docx

    ### 基于Hadoop生态系统的大数据解决方案综述 #### 一、绪论 随着互联网技术的迅猛发展,数据量呈爆炸式增长,这不仅带来了前所未有的机遇,也对数据处理能力提出了更高要求。大数据技术应运而生,旨在解决大规模...

    云计算中Hadoop技术研究与应用综述.pdf

    本篇综述主要探讨了Hadoop技术的起源、优势以及技术原理,并回顾了其学术研究成果,并重点分析了Hadoop在各方面的应用进展,最后对未来的发展方向和需解决的问题进行了展望。 1. Hadoop的起源和发展 Hadoop是一个由...

    基于Linux的数据库的综述.pdf

    此外,Linux 配备了强大的防火墙组件,配置简单,管理成本低,安全性高,因此在关键业务系统中被广泛采用。 【基于 Linux 的数据库】 Linux 平台上的数据库系统以其稳定性和资源效率而受到青睐。数据库主要分为两...

    indy in depth(高清中文版)

    阻塞模式下的文件写入虽然简单,但在高并发环境下可能导致性能下降;而非阻塞模式虽然复杂,但效率更高。 **5.18 Just Like Files 文件一样** 在某些方面,Socket可以被视为一种特殊的“文件”,因为它们都提供了一...

    嵌入式Linux应用程序开发详解

    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各种解析方法

    这种方式更适合处理大型XML文件,因为它不需要一次性将整个文档加载到内存中。 3. **StAX (Streaming API for XML)**:这是一种流式解析API,结合了DOM和SAX的优点,既可以高效地处理大型XML文件,又提供了随机...

    ICE分布式程序设计中文版

    第 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 ...

Global site tag (gtag.js) - Google Analytics