Java流(文件读写操作)
字节流和字符流进行读写操作的一般步骤
字节流和字符流进行读写操作的一般步骤
字节流和字符流是 Java 中用于数据读写的两种基本流，它们有着不同的特点和应用场景。
在字节流中进行读写操作一般包括以下步骤:
1. 打开文件或输入输出流：使用相应的打开方法，如打开FileInputStream 或 FileOutputStream 对象，打开文件或输出流。
2. 读取数据：使用输入流的 read() 方法或 RandomAccessFile 类的 read() 方法读取数据，将其存储在字节数组或字符数组中。
3. 处理数据：对读取到的数据进行处理，如将其转换为字符串、打印到控制台等。
4. 关闭流：使用相应的关闭方法，如 FileInputStream.close() 或 FileOutputStream.close() 方法，关闭文件或输入输出流。
在字符流中进行读写操作一般也包括以下步骤:
1. 打开文件或输入输出流：与字节流相似，使用相应的打开方法打开文件或输入输出流。
2. 读取字符：使用输入流的 read() 方法或 RandomAccessFile 类的 read() 方法读取字符，将其存储在字符数组中。
3. 处理字符：对读取到的字符进行处理，如将其转换为字符串、打印到控制台等。
4. 关闭流：与字节流相似，使用相应的关闭方法，如FileInputStream.close() 或 FileOutputStream.close() 方法，关闭文件或输入输出流。
不过，在字符流中，读取的字符需要进行编码转换，以适应不同的字符编码方案。
例如，在读取文本文件时，需要将读取到的字符进行 UTF-8 编码转换，以确保读取的字符符合文本文件的格式。
fileinputstream中read方法返回值
fileinputstream中read方法返回值FileInputStream（文件输入流）是一种用于读取文件内容的Java类，它属于InputStream接口的一个实现。
在使用FileInputStream时，经常会用到它的read方法。
本文将详细介绍FileInputStream的read方法及其应用。
一、FileInputStream概述FileInputStream继承自InputStream，用于处理字节流。
它可以读取文件、磁盘、网络等资源的字节流。
在Java编程中，使用FileInputStream读取文件是一种常见操作。
二、read方法的作用与返回值FileInputStream的read方法是一个字节读取方法，它从输入流中读取一个字节。
read方法的返回值是读取到的字节，如果到达文件末尾或发生异常，则返回-1。
三、read方法的使用注意事项1.读取文件时，建议使用try-with-resources语句，以便在操作完成后自动关闭流。
2.读取文件时，可以根据需要调用read方法多次，也可以使用循环持续读取。
3.读取过程中，如果遇到异常，如文件未找到、文件读取完毕等，需要处理异常。
4.考虑到性能和资源消耗，尽量避免在一个方法中长时间使用read方法读取大量数据。
四、实战案例：使用read方法读取文件内容以下是一个使用FileInputStream的read方法读取文件内容的示例：```javaimport java.io.File;import java.io.FileInputStream;import java.io.IOException;public class ReadFileExample {public static void main(String[] args) {File file = new File("test.txt");try (FileInputStream fis = new FileInputStream(file)) {byte[] buffer = new byte[1024];int bytesRead;while ((bytesRead = fis.read(buffer)) != -1) {String content = new String(buffer, 0, bytesRead);System.out.print(content);}} catch (IOException e) {e.printStackTrace();}}}```在这个示例中，我们使用FileInputStream的read方法读取文件test.txt 的内容。
JAVA读取文件流,设置浏览器下载或直接预览操作
JAVA读取⽂件流,设置浏览器下载或直接预览操作最近项⽬需要在浏览器中通过URL预览图⽚。
但发现浏览器始终默认下载，⽽不是预览。
研究了⼀下，发现了问题：// 设置response的Header，注意这句，如果开启，默认浏览器会进⾏下载操作，如果注释掉，浏览器会默认预览。
response.addHeader("Content-Disposition", "attachment;filename=" + FileUtil.getOriginalFilename(path));然后需要注意：response.setContentType(contentType);//不同的⽂件类型，contentType不⼀样，⽐如图⽚⼀般是image/jpeg、image/png等@RequestMapping(value = "getFile/{folder}/{fileName:.+}*", method = RequestMethod.GET)public void getFile(HttpServletResponse response, @PathVariable String folder,@PathVariable String fileName){// 设置编码response.setCharacterEncoding("UTF-8");try{String path = folder + "/" + fileName;boolean flag = ossClient.doesObjectExist(ossProperties.getBucket(), path);// 判断⽂件是否存在if (flag){// 清空responseresponse.reset();// 设置response的Header，注意这句，如果开启，默认浏览器会进⾏下载操作，如果注释掉，浏览器会默认预览。
java中byte的用法
java中byte的用法Java是一种面向对象的编程语言，它具有简单、可移植、可靠、安全、高效等特点。
在Java中，byte是一种基本数据类型，用于表示8位的二进制数据。
本文将介绍Java中byte的用法及其相关知识。
一、byte的定义和范围byte是Java中的一种基本数据类型，用于表示8位的二进制数据。
它占据一个字节（8位），范围为-128到127。
可以用以下代码来定义一个byte类型的变量：byte b;二、byte的应用在Java中，byte类型变量的主要应用场景有以下几个方面：1. 文件读写在Java中，文件读写是常见的操作之一。
当读取一个文件时，文件中的数据将被读取到一个byte数组中。
使用byte数组的好处是，可以有效地节省内存空间，因为byte类型的数据占用的空间比较小。
同时，byte数组也可以用来写入数据到文件中。
2. 网络编程在网络编程中，数据通常是以字节流的方式进行传输的。
Java中提供了Socket类和ServerSocket类，可以用来建立网络连接和进行数据传输。
在网络编程中，byte类型的数据也是常见的。
3. 图像处理在图像处理中，byte类型的数据也是常见的。
例如，可以使用Java中的ImageIO类来读取和写入图像文件。
在读取图像文件时，文件中的数据将被读取到一个byte数组中。
同时，在对图像进行处理时，也可以使用byte类型的数据来进行相应的操作。
4. 数据加密在数据加密中，byte类型的数据也是常见的。
例如，可以使用Java中的MessageDigest类来对数据进行加密。
在对数据进行加密时，数据将被转换成byte类型的数组，并进行相应的加密操作。
5. 数据库操作在数据库操作中，byte类型的数据也是常见的。
例如，可以使用Java中的JDBC技术来进行数据库操作。
在将数据插入到数据库中时，经常需要将数据转换成byte类型的数据，然后再插入到数据库中。
三、byte的转换在Java中，byte类型的数据可以和其他类型的数据进行相互转换。
java 顺序读写文件的原理
java 顺序读写文件的原理Java顺序读写文件的原理顺序读写文件是一种常见的文件操作方式，特别是用于处理大型文件或者需要按照固定顺序访问文件内容的情况。
Java提供了多种API和技术来实现顺序读写文件，下面将介绍其原理。
1. 读取文件（顺序读取）：顺序读取文件主要通过FileInputStream类来实现。
以下是其原理：- 使用FileInputStream类的构造函数创建一个文件输入流对象，并指定要读取的文件路径。
- 创建一个字节数组或者字符数组作为缓冲区，用来存放从文件中读取的数据。
- 使用read方法从文件输入流中读取数据，并将数据存入缓冲区。
read方法会返回读取的字节数或者字符数，如果已经读取到文件末尾，则返回-1。
- 重复执行上述步骤，直到读取完整个文件内容。
2. 写入文件（顺序写入）：顺序写入文件主要通过FileOutputStream类来实现。
以下是其原理：- 使用FileOutputStream类的构造函数创建一个文件输出流对象，并指定要写入的文件路径。
- 创建一个字节数组或者字符数组作为缓冲区，用来存放待写入的数据。
- 使用write方法将缓冲区中的数据写入文件输出流。
write方法会将数据写入文件并返回写入的字节数或者字符数。
- 重复执行上述步骤，直到写入完所有数据。
- 使用close方法关闭文件输出流，确保所有数据都被写入文件。
需要注意的是，顺序读写文件时要合理设置缓冲区的大小。
缓冲区太小会导致频繁的IO操作，影响性能；缓冲区太大则会占用过多内存。
因此，根据实际情况调整缓冲区大小以达到最佳性能。
另外，为了保证顺序读写文件的稳定性和可靠性，建议在读写文件时使用try-catch-finally或者try-with-resources语句块，确保资源能够被正确释放。
总结：顺序读写文件是通过Java的FileInputStream和FileOutputStream类来实现的。
Java文件操作
Java文件操作java.io包提供了大量的流类，其中所有输入流都是InputStream抽象类(字节输入流)和Reader抽象类(字符输入流)的子类，而所有的输出流都是OutputStream抽象类(字节输出流)和Writer抽象类(字符输出流)的子类。
File类：(处理文件和目录)File对象主要获取文件本身的属性，如文件目录、文件长度、和文件读写权限等，不涉及对文件内容的读写操作。
创建File对象的构造方法有如下三个：File(String filename)File(String directoryPath,String filename)File(File f,String filename)//f是制定一个目录的文件文件的属性：经常使用File类下列方法获取文件本身一些信息：public String getName()//获取文件名public boolean canRead()//判断文件是否可读public boolean canWrite()//判断文件是否可写public boolean exists()//判断文件是否存在public long length()//获取文件长度(字节单位)public String getAbsolutePath()//获取文件绝对路径public String getParent()//获取文件父目录public boolean isFile()//判断文件是否是一个正常文件，而不是目录public boolean isDirectory()//判断文件是否是一个(已存在)目录public boolean isHidden()//判断文件是否是隐藏文件public long lastModified()//获取文件最后修改时间(时间是从1970年午夜至文件最后修改时刻的毫秒数)目录：1、创建目录：使用File对象调用方法public boolean mkdir()可创建一个目录，成功创建返回true，否则返回false(如果该目录已经存在则返回false)。
java读写word文档 完美解决方案
java读写word文档完美解决方案Java读写Word文档：完美解决方案Word文档是一种广泛使用的文件格式，用于创建和编辑文本文档。
在Java编程中，读写Word文档是一个常见的需求。
本文将介绍一种完美解决方案，帮助您在Java中实现对Word文档的读写操作。
一、引入依赖要在Java中读写Word文档，我们需要使用Apache POI库。
Apache POI是一个Java类库，可用于读取和编写Microsoft Office文件格式，包括Word文档。
在您的Java项目中，您需要将以下依赖项添加到您的构建文件中，以便使用Apache POI库：```java<dependency><groupId>org.apache.poi</groupId><artifactId>poi</artifactId><version>4.1.2</version></dependency><dependency><groupId>org.apache.poi</groupId><artifactId>poi-ooxml</artifactId><version>4.1.2</version></dependency>```二、读取Word文档要读取一个Word文档，您可以使用Apache POI提供的XWPFDocument类。
以下是一个简单的示例代码，演示如何使用XWPFDocument读取Word文档：```javaimport ermodel.XWPFDocument;import org.apache.poi.xwpf.extractor.XWPFWordExtractor;import java.io.FileInputStream;import java.io.IOException;public class ReadWordDocument {public static void main(String[] args) {try {FileInputStream fis = newFileInputStream("path/to/your/word/document.docx");XWPFDocument document = new XWPFDocument(fis);XWPFWordExtractor extractor = new XWPFWordExtractor(document);String content = extractor.getText();System.out.println(content);fis.close();} catch (IOException e) {e.printStackTrace();}}}```在上面的代码中，您需要将"path/to/your/word/document.docx"替换为您实际的Word文档路径。
JAVA中文件写入的6种方法
JAVA中文件写入的6种方法在Java中，我们可以使用不同的方法将数据写入文件。
下面介绍了6种常见的文件写入方法。
方法一：使用FileOutputStream类FileOutputStream类用于写入数据到文件中。
它是OutputStream类的一个派生类，并提供了用于写入字节的各种方法。
```javatryFileOutputStream fos = new FileOutputStream("file.txt");byte[] data = "Hello, World!".getBytes(;fos.write(data);fos.close(;} catch (IOException e)e.printStackTrace(;```方法二：使用BufferedWriter类BufferedWriter类提供了一个高效的方式将文本写入文件。
它继承自Writer类，可用于写入字符和字符串。
```javatryBufferedWriter bw = new BufferedWriter(newFileWriter("file.txt"));bw.write("Hello, World!");bw.close(;} catch (IOException e)e.printStackTrace(;```方法三：使用PrintWriter类PrintWriter类是Writer类的子类，可以用于写入字符和字符串到文件中。
```javatryPrintWriter pw = new PrintWriter("file.txt");pw.println("Hello, World!");pw.close(;} catch (IOException e)e.printStackTrace(;```方法四：使用FileWriter类FileWriter类用于写入字符或字符串到文件。
java io流详解
java io流详解Java IO流是Java中的一个重要概念，它被用于文件的输入和输出，网络数据传输等方面。
本文将详细介绍Java IO流的使用以及其相关的知识点，让大家能够更好地了解并使用该重要技术。
一、流概述流是Java中非常重要的一个概念。
流实际上是一种在程序和存储设备之间传输信息的方式。
Java中的流是基于输入/输出(I/O)操作的，使用Java IO流，程序就可以从文件或网络中读取信息，也可以将信息写入到文件或网络中。
二、Java IO流分类Java IO流分为两类：字节流和字符流：1. 字节流是以字节(Int流)为单位传输数据，它适合传输二进制文件(如图片、音乐)等数据。
2. 字符流是以字符为单位传输数据，它适合传输文本文件等数据。
字节流又分为输入字节流和输出字节流，字符流又分为输入字符流和输出字符流。
三、Java IO流的基本操作1. 数据的输入:使用Java IO流读取文件的数据，可以使用FileInputStream类。
使用Java io输入流的步骤具体如下：① 创建输入流对象，即FileInputStream类。
② 读取数据，即使用read()方法读取数据。
③ 关闭读取流，即使用close()方法。
2. 数据的输出：使用Java IO流将数据写入到文件中，可以使用FileOutputStream类。
使用Java io输出流的步骤具体如下：① 创建输出流对象，即FileOutputStream类。
② 写入数据，即使用write()方法将数据写入文件中。
③ 关闭输出流，即使用close()方法。
3. 文件的复制：使用Java IO流可以轻松实现文件的复制。
具体操作步骤如下：① 创建输入流对象，即FileInputStream类。
② 创建输出流对象，即FileOutputStream类。
③ 读取数据，即使用read()方法读取数据，并调用write()方法写入到输出流中。
④ 关闭输入流和输出流。
在MacOS上使用Java实现文件读写操作
在MacOS上使用Java实现文件读写操作在MacOS系统上，使用Java语言进行文件读写操作是一种常见的需求。
Java提供了丰富的API和库，使得文件处理变得简单而高效。
本文将介绍如何在MacOS上使用Java实现文件读写操作，包括文件的创建、写入、读取和删除等操作。
1. 文件的创建在Java中，可以使用File类来表示文件或目录，并通过该类的方法来创建文件。
下面是一个简单的示例代码，演示了如何在MacOS上创建一个新的文件：示例代码star：编程语言：javaimport java.io.File;import java.io.IOException;public class CreateFileExample {public static void main(String[] args) {File file = new File("example.txt");try {if (file.createNewFile()) {System.out.println("File created: " + file.getName());} else {System.out.println("File already exists.");}} catch (IOException e) {System.out.println("An error occurred.");e.printStackTrace();}}}示例代码end运行以上代码后，将在当前目录下创建一个名为example.txt的文件。
2. 文件的写入要向文件中写入数据，可以使用FileWriter类。
下面是一个简单的示例代码，演示了如何在MacOS上向文件中写入内容：示例代码star：编程语言：javaimport java.io.FileWriter;import java.io.IOException;public class WriteToFileExample {public static void main(String[] args) {try {FileWriter writer = newFileWriter("example.txt");writer.write("Hello, World!");writer.close();System.out.println("Successfully wrote to the file.");} catch (IOException e) {System.out.println("An error occurred.");e.printStackTrace();}}}示例代码end运行以上代码后，example.txt文件中将会写入”Hello, World!“这行内容。
Java输入输出流（一）——常用的输入输出流
Java输⼊输出流（⼀）——常⽤的输⼊输出流1.流的概念：在Java中，流是从源到⽬的地的字节的有序序列。
Java中有两种基本的流——输⼊流（InputStream）和输出流（OutputStream）。
根据流相对于程序的另⼀个端点的不同，分为节点流和过滤流。
（1）节点流：以特定源如磁盘⽂件、内存某区域或者线程之间的管道为端点的构造输⼊输出流，是⼀种基本的流。
（2）过滤流：以其他已经存在的流为端点构造的输⼊输出流。
根据流中的数据单位分为字节流和字符流。
（1）字节流：流中的数据是以8位字节为单位进⾏读写，以InputStream和OutputStream为基础类。
（2）字符流:流中的数据是以16为字符为单位进⾏读写，以Reader和Writer为基础类。
2.字节流InputStream和OutputStream是字节流的两个顶层⽗类，提供了输⼊流类和输出流类的通⽤API。
2.1 输⼊字节流InputStream基本⽅法：（1）基本读⽅法;: int read() int read（byte[] b） int read(byte[] b,int off,int len)(2) 关闭流：void close()(3) 返回输⼊流中还有多少可读字节 int available()(4) 跳过指定字节 long skip(long n)(5) 回读数据 boolean markSupported() void Mark(int readlimt) void reset()2.2 输出字符流OutputStream基本⽅法：（1）基本写⽅法：void write（int c） void write(byte[] b) void write(byte[] b,int off,int len)(2) 关闭流：void close()(3)q强制输出：void flush（）3.字符流：Reader和Writer是字符流的顶层⽗类，字符流能够处理Unicode字符集中的所有字符。
Java读写文件方法总结
Java读写⽂件⽅法总结Java读写⽂件⽅法总结Java的读写⽂件⽅法在⼯作中相信有很多的⽤处的，本⼈在之前包括现在都在使⽤ Java的读写⽂件⽅法来处理数据⽅⾯的输⼊输出，确实很⽅便。
奈何我的记性实在是叫⼈着急，很多时候既然都会想不起来怎么写了，不过我的Java 代码量也实在是少的可怜，所以应该多多练习。
这⾥做⼀个总结，集中在⼀起⽅⾯今后查看。
Java读⽂件1 package天才⽩痴梦;23 import java.io.BufferedReader;4 import java.io.File;5 import java.io.FileInputStream;6 import java.io.FileReader;7 import java.io.IOException;8 import java.io.InputStream;9 import java.io.InputStreamReader;10 import java.io.RandomAccessFile;11 import java.io.Reader;1213 public class JavaIO {1415 /**16 * 采⽤的是操作系统底层默认的编码⽅式，GBK等，⾮UTF817 * */1819 /**20 * 以字节为单位读取⽂件内容，常⽤于读取⼆进制⽂件，⽐如图⽚、影像、声⾳等⽂件21 * */22 public static void readFileByBytes(String filename) {23 File file=new File(filename);24 FileInputStream in=null;25 try {26 System.out.println("以字节为单位读取⽂件,⼀次读⼀个字节: ");27 in=new FileInputStream(file);28 int temp=0;29 while ((temp=in.read()) != -1) {30 System.out.println(temp);31 }32 in.close();33 } catch (IOException e) {34 e.printStackTrace();35 return ;36 }37 try {38 System.out.println("以字节为单位读取⽂件，⼀次读多个字节： ");39 byte[] temp=new byte[100];40 int byteread=0;41 in=new FileInputStream(file);42 JavaIO.showAvailableBytes(in);43 while ((byteread=in.read(temp)) != -1) {44 System.out.write(temp,0,byteread);45 }46 } catch (Exception e1) {47 e1.printStackTrace();48 } finally {49 if (in != null) {50 try {51 in.close();52 } catch (IOException e1) {5354 }55 }56 }57 }58 /**59 * 以字符为单位读取⽂件，常⽤于读⽂本，数字等类型的⽂件60 * */61 public static void readFileByChar(String filename) {62 File file=new File(filename);63 Reader reader=null;64 try {65 System.out.println("以字符为单位读取⽂件内容，⼀次⼀个字节：");66 //InputStreamReader类:是字节向字符转换的桥梁67 reader=new InputStreamReader(new FileInputStream(file));68 int temp;69 while ((temp=reader.read()) != -1) {70 if (((char)temp) != '\r') {71 System.out.println((char)temp);72 }73 }74 reader.close();75 } catch (Exception e) {76 e.printStackTrace();77 }78 try {79 System.out.println("以字符为单位读取⽂件内容，⼀次读多个字节： ");80 char[] temp=new char[30];81 int charread=0;82 reader=new InputStreamReader(new FileInputStream(filename));83 while ((charread=reader.read(temp)) != -1) {84 if ((charread == temp.length) && (temp[temp.length-1]!='\r')) {85 System.out.println(temp);86 } else {87 for (int i=0; i<charread; i++) {88 if (temp[i] == '\r') {89 break;90 } else {91 System.out.println(temp[i]);92 }93 }94 }95 }96 } catch (Exception e) {97 e.printStackTrace();98 } finally {99 if (reader != null) {100 try {101 reader.close();102 } catch (IOException e) {103104 }105 }106 }107 }108 /**109 * 以⾏为单位读取⽂件，常⽤于读⾯向⾏的格式化⽂件110 * */111 public static void readFileByLine(String filename) {112 File file=new File(filename);113 BufferedReader reader=null;114 try {115 System.out.println("以⾏为单位读取⽂件内容，⼀次读⼀整⾏： "); 116 reader=new BufferedReader(new FileReader(file));117 String temp=null;118 int line=1;119 while ((temp=reader.readLine()) != null) {120 System.out.println("line " + line + ": " + temp);121 line++;122 }123 reader.close();124 } catch (IOException e) {125 e.printStackTrace();126 } finally {127 if (reader != null) {128 try {129 reader.close();130 } catch (IOException e) {131132 }133 }134 }135 }136 /**137 * 随机读取⽂件内容138 * */139 public static void readFileByRandomAccess(String filename) {140 RandomAccessFile randomfile=null;141 try {142 System.out.println("随机读取⼀段⽂件内容");143 randomfile=new RandomAccessFile(filename,"r");144 long fileLength=randomfile.length();145 int beginIndex=(fileLength > 4 ? 4 : 0);146 randomfile.seek(beginIndex);147 byte[] bytes=new byte[10];148 int byteread=0;149 while ((byteread=randomfile.read(bytes)) != -1) {150 System.out.write(bytes,0,byteread);151 }152 } catch (IOException e) {153 e.printStackTrace();154 } finally {155 if (randomfile != null) {156 try {157 randomfile.close();158 } catch (IOException e) {159160 }161 }162 }163 }164 private static void showAvailableBytes(InputStream in) {165 try {166 System.out.println("当前字节输⼊流中的字节数为：" + in.available());167 } catch (IOException e) {168 e.printStackTrace();169 }170 }171 public static void main(String[] args) {172 String filename="E:\\BaiYiShaoNian.txt";173 JavaIO.readFileByBytes(filename);174 JavaIO.readFileByChar(filename);175 JavaIO.readFileByLine(filename);176 JavaIO.readFileByRandomAccess(filename);177 }178 }Java写⽂件1 package天才⽩痴梦;23 import java.io.BufferedWriter;4 import java.io.File;5 import java.io.FileNotFoundException;6 import java.io.FileOutputStream;7 import java.io.FileWriter;8 import java.io.IOException;9 import java.io.OutputStreamWriter;1011 public class JavaIO2 {1213 public static void main(String[] args) throws IOException {14 String Path="E:\\天才⽩痴梦\\JAVA";15 File file=new File("E:\\天才⽩痴梦\\JAVA","BaiYiShaoNian.txt");16 if (!file.exists()) {17 try {18 file.createNewFile();19 } catch (IOException e) {20 e.printStackTrace();21 }22 }23 /**24 * Java写⼊⽂件的三种⽅法25 * */26 FileOutputStream fos=null;27 BufferedWriter bw=null;28 FileWriter fw=null;29 int value=1000;3031 try {32 fos=new FileOutputStream(new File(Path+"fos.txt"));33 long begin=System.currentTimeMillis();34 for (int i=1; i<=value; i++) {35 fos.write(5);36 }37 long end=System.currentTimeMillis();38 System.out.println("TheCostTime of FileOutputStream is : " + (end-begin));39 fos.close();4041 bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File(Path+"br.txt")),"UTF8"));42 begin=System.currentTimeMillis();43 for (int i=1; i<=value; i++) {44 bw.write(5);45 bw.newLine();46 }47 bw.close();48 end=System.currentTimeMillis();49 System.out.println("TheCostTime of BufferedWriter is : " + (end-begin));5051 fw=new FileWriter(Path+"fw.txt");52 begin=System.currentTimeMillis();53 for (int i=1; i<=value; i++) {54 fw.write(5);55 }56 fw.close();57 end=System.currentTimeMillis();58 System.out.println("TheCostTime of FileWriter is : " + (end-begin));596061 } catch (Exception e) {62 // TODO Auto-generated catch block63 e.printStackTrace();64 } finally {65 try {66 fos.close(); //FileOutputStream67 bw.close(); //BufferedWriter68 fw.close(); //FileWriter69 } catch (Exception e) {70 e.printStackTrace();71 }72 }7374 }75 }。
用java逐行读取和写入大文件的最快方法
在软件开发过程中，经常会遇到需要处理大文件的情况，而对于Java语言来说，如何高效地逐行读取和写入大文件是一个常见的问题。
本文将介绍使用Java语言逐行读取和写入大文件的最快方法，帮助开发人员更加高效地处理大文件。
一、使用BufferedReader和BufferedWriter进行逐行读取和写入BufferedReader和BufferedWriter是Java标准库中提供的用于缓冲输入和输出的类，它们可以显著提高文件读写的效率。
下面是使用BufferedReader和BufferedWriter进行逐行读取和写入的代码示例：```javapublic class FileUtil {public static void copyFile(String sourceFileName, String targetFileName) {try (BufferedReader br = new BufferedReader(new FileReader(sourceFileName));BufferedWriter bw = new BufferedWriter(new FileWriter(targetFileName))) {String line;while ((line = br.readLine()) != null) {bw.write(line);bw.newLine();}} catch (IOException e) {e.printStackTrace();}}}```在上面的代码中，我们使用了BufferedReader逐行读取文件，并使用BufferedWriter逐行写入文件，通过缓冲输入和输出来提高读写效率。
这种方法适用于处理中等大小的文件，但对于大文件来说，还有更加高效的方法可供选择。
二、使用RandomAccessFile进行逐行读取和写入RandomAccessFile是Java标准库中提供的用于随机访问文件的类，它可以在文件中进行任意位置的读写操作。
javafileoutputstream使用方法
javafileoutputstream使用方法Java中的FileOutputStream是一种用于写入二进制数据的输出流。
它将数据写入文件，并且支持按字节、字节数组和字符数组的写入操作。
使用FileOutputStream可以创建并写入新文件，也可以追加写入已存在的文件。
使用FileOutputStream的基本步骤如下：1. 创建FileOutputStream对象：通常会使用文件名或文件对象作为参数来创建FileOutputStream对象。
例如，可以使用以下方式创建一个新文件输出流：```FileOutputStream fos = new FileOutputStream("filename");```2. 写入数据：可以使用write(方法将数据写入文件。
write(方法有多种重载形式，可以接受不同类型的参数，包括int、byte、byte数组和String。
以下是几种常用的写入方法示例：- 使用write(int b)方法写入一个字节数据：```fos.write(65); // 写入ASCII码为65的字节，即大写字母A```- 使用write(byte[] b)方法写入字节数组的数据：```byte[] data = {65, 66, 67, 68}; // A, B, C, Dfos.write(data); // 写入字节数组```- 使用write(byte[] b, int off, int len)方法写入字节数组的一部分数据：```byte[] data = {65, 66, 67, 68}; // A, B, C, Dfos.write(data, 1, 2); // 从字节数组的索引1开始写入2个字节，即B, C```- 使用write(String str)方法写入字符串数据：```String str = "Hello, World!";fos.write(str.getBytes(); // 写入字符串的字节数组```3. 刷新和关闭流：写入完成后，需要调用flush(方法刷新缓冲区并将数据写入文件。
Java InputStream和OutputStream,Reader和Writer的辨析
Java InputStream和OutputStream，Reader和Writer的辨析对Java 的文件操作中的一些概念做了个总结，资料收集+自己理解。
文本文件I/O：概念辨析：File 类：File 类中提供了文件的创建、目录的创建、删除、文件列表、获取文件有关信息等操作，不涉及文件内容的读和写，读与写的操作要靠write() 和read() 方法。
Writer 和Reader：Writer 和Reader 用于字符流的写入和读取，也就是说写入和读取的单位是字符，如果读与写的操作不涉及字符，那么是不需要Writer 和Reader 的。
Writer 类（抽象类），子类必须实现的方法仅有write()、flush()、close()。
继承了此类的类是用于写操作的“Writer”。
Reader 类（抽象类），子类必须实现的方法仅有read()、close()。
继承了此类的类是用于读操作的“Reader”write()方法和read()方法：write()方法是将数据写入到文件（广义概念，包括字节流什么的）中。
read()方法是将文件（广义概念，包括字节流什么的）中的数据读出到缓冲目标上。
InputStream和OutputStream：InputStream：此抽象类是表示字节输入流的所有类的超类。
字节输入流相当于是一个将要输入目标文件的“流”。
InputStream有read() 方法而没有write()方法，因为它本身代表将要输入目的文件的一个“流”OutputStream：此抽象类是表示输出字节流的所有类的超类。
输出流接受输出字节并将这些字节发送到某个接收器。
是从文件中将要输出到某个目标的“流”。
OutputStream有write()方法而没有read()方法。
InputStreamReader和OutputStreamWriter：InputStreamReader是字节流通向字符流的桥梁：它使用指定的charset 读取字节并将其解码为字符。
文件操作中的对象流和数据流使用方法
文件操作中的对象流和数据流使用方法一、对象流对象流 (Object InputStream) 是一种输入流，它允许我们读取二进制数据。
Java 中的文件输入流 (FileInputStream) 实际上是一个对象流，我们可以通过调用它的 read 方法来读取文件的数据。
下面是一个简单的使用对象流读取文件的示例代码:```FileInputStream fis = new FileInputStream("file.txt"); ObjectInputStream in = new ObjectInputStream(fis);try {// 读取文件数据String content = (String) in.readObject();System.out.println("文件内容:" + content);} catch (IOException e) {e.printStackTrace();} finally {// 关闭输入流in.close();fis.close();}```在上面的示例代码中，我们首先创建了一个文件输入流(FileInputStream),然后创建了一个对象输入流(ObjectInputStream),并将其连接到文件输入流上。
接下来，我们通过调用 readObject 方法来读取文件的数据，并将其转换为字符串对象。
最后，我们打印了文件的内容，并关闭了输入流。
使用对象流有一个好处是它可以读取二进制数据，而不仅仅是文本数据。
另外，对象流还可以处理各种类型的数据，例如对象、数组等。
但是，对象流也有一些缺点，例如它需要花费更多的时间来读取数据，并且不容易进行错误处理。
二、数据流数据流 (DataInputStream) 是一种输入流，它允许我们读取文本数据。
Java 中的文件输入流实际上是一个数据流，我们可以通过调用它的 read 方法来读取文件的数据。
Java使用FileInputStream流读取文件示例详解
Java使⽤FileInputStream流读取⽂件⽰例详解⼀、File流概念JAVA中针对⽂件的读写操作设置了⼀系列的流，其中主要有FileInputStream,FileOutputStream,FileReader,FileWriter四种最为常⽤的流⼆、FileInputStream1）FileInputStream概念FileInputStream流被称为⽂件字节输⼊流，意思指对⽂件数据以字节的形式进⾏读取操作如读取图⽚视频等2）构造⽅法2.1）通过打开与File类对象代表的实际⽂件的链接来创建FileInputStream流对象public FileInputStream(File file) throws FileNotFoundException{}若File类对象的所代表的⽂件不存在;不是⽂件是⽬录;或者其他原因不能打开的话，则会抛出FileNotFoundException/**** 运⾏会产⽣异常并被扑捉--因为不存在xxxxxxxx这样的⽂件*/public static void main(String[] args){File file=new File("xxxxxxxx"); //根据路径创建File类对象--这⾥路径即使错误也不会报错，因为只是产⽣File对象，还并未与计算机⽂件读写有关联try{FileInputStream fileInputStream=new FileInputStream(file);//与根据File类对象的所代表的实际⽂件建⽴链接创建fileInputStream对象}catch (FileNotFoundException e){System.out.println("⽂件不存在或者⽂件不可读或者⽂件是⽬录");}}2.2）通过指定的字符串参数来创建File类对象，⽽后再与File对象所代表的实际路径建⽴链接创建FileInputStream流对象public FileInputStream(String name) throws FileNotFoundException通过查看源码，发现该构造⽅法等于是在第⼀个构造⽅法的基础上进⾏延伸的，因此规则也和第⼀个构造⽅法⼀致public FileInputStream(String name) throws FileNotFoundException {this(name != null ? new File(name) : null);}2.3）该构造⽅法没有理解---查看api是指使⽤的fdObj⽂件描述符来作为参数，⽂件描述符是指与计算机系统中的⽂件的连接，前⾯两个⽅法的源码中最后都是利⽤⽂件描述符来建⽴连接的public FileInputStream(FileDescriptor fdObj)3）FileInputStream常⽤API3.1）从输⼊流中读取⼀个字节返回int型变量，若到达⽂件末尾，则返回-1public int read() throws IOException理解读取的字节为什么返回int型变量1、⽅法解释中的-1相当于是数据字典告诉调⽤者⽂件已到底，可以结束读取了，这⾥的-1是Int型2、那么当⽂件未到底时，我们读取的是字节，若返回byte类型，那么势必造成同⼀⽅法返回类型不同的情况这是不允许的3、我们读取的字节实际是由8位⼆进制组成，⼆进制⽂件不利于直观查看，可以转成常⽤的⼗进制进⾏展⽰，因此需要把读取的字节从⼆进制转成⼗进制整数，故返回int型4、因此结合以上3点，保证返回类型⼀致以及直观查看的情况，因此该⽅法虽然读取的是字节但返回int型read⽅法读取实例--最后输出内容和字符内容⼀致是123package com.test;import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.IOException;public class FileStream{/*****/public static void main(String[] args){//建⽴⽂件对象File file=new File("C:\\Users\\Administrator\\Desktop\\1.txt");try{//建⽴链接FileInputStream fileInputStream=new FileInputStream(file);int n=0;StringBuffer sBuffer=new StringBuffer();while (n!=-1) //当n不等于-1,则代表未到末尾{n=fileInputStream.read();//读取⽂件的⼀个字节(8个⼆进制位),并将其由⼆进制转成⼗进制的整数返回char by=(char) n; //转成字符sBuffer.append(by);}System.out.println(sBuffer.toString());}catch (FileNotFoundException e){System.out.println("⽂件不存在或者⽂件不可读或者⽂件是⽬录");}catch (IOException e){System.out.println("读取过程存在异常");}}}3.2）从输⼊流中读取b.length个字节到字节数组中，返回读⼊缓冲区的总字节数，若到达⽂件末尾，则返回-1public int read(byte[] b) throws IOException1. 我们先设定⼀个缓冲区即字节数组⽤于存储从流中读取的字节数据，该数组的长度为N2. 那么就是从流中读取N个字节到字节数组中。
filereader和filewriter用法
filereader和filewriter用法使用FileReader和FileWriter进行文件读写是Java中常用的操作之一。
FileReader用于读取文本文件的内容，而FileWriter用于向文本文件中写入内容。
下面将逐步介绍这两个类的使用方法。
一、FileReader的使用方法1. 导入FileReader类：首先，需要在Java程序中导入java.io.FileReader类，才能使用它的方法。
可以通过以下代码导入该类：javaimport java.io.FileReader;2. 创建FileReader对象：使用FileReader类的构造方法可以创建FileReader对象。
可以在构造方法中传递文件路径作为参数，示例如下：javaFileReader reader = new FileReader("文件路径");3. 读取文件内容：通过FileReader对象，可以使用read()方法逐字符读取文件内容，直到达到文件末尾。
读取的字符可以存储在一个字符数组或字符流中。
示例如下：javaint data;while((data = reader.read()) != -1) {char ch = (char) data;处理读取到的字符}4. 关闭FileReader对象：在文件读取完成后，需要关闭FileReader对象以释放系统资源。
关闭对象的方法是调用close()方法。
示例如下：javareader.close();二、FileWriter的使用方法1. 导入FileWriter类：同样，需要首先导入java.io.FileWriter类才能使用它的方法。
可以使用以下代码导入该类：javaimport java.io.FileWriter;2. 创建FileWriter对象：使用FileWriter类的构造方法可以创建FileWriter对象。
可以在构造方法中传递文件路径作为参数，示例如下：javaFileWriter writer = new FileWriter("文件路径");3. 写入文件内容：通过FileWriter对象，可以使用write()方法将字符、字符数组或字符串写入文件。
java File文件操作和文件流的详解(福哥出品)
一. 创建文件（1）最常用的（获得一个固定路径下的文件对象）File parentFile = new File(“D:\\My Documents\\.....”);//参数是一个路径的字符串。
（2）在父目录创建一个名为child的文件对象，child 为文件对象的名字File chileFile= new File(“D:\\My Documents\\.....”,String child);或File chileFile= new File(parentFile,String child);二,常见文件夹属性和方法（1）createNewFile（）；该方法的作用是创建指定的文件。
该方法只能用于创建文件，不能用于创建文件夹，且文件路径中包含的文件夹必须存在File file=new ("D:\\My Document\\text.txt");file.createNewFile();这样就会在D盘下的My Document 创建text.txt的记事本（注意：首先得保证D盘下有My Documen这个文件夹）（2）mkdir();根据File对象的名字(路径)创建一个目录(文件夹)，如果是相对目录，则新建的目录在当前目录下（3）mkdirs();如果File对象名字有多级目录，则可以调用该方法一次性创建多级目录。
（4）exists();判断File对象指向的文件是否存在，返回一个boolean类型（5）isDirectory（）；判断File对象指向的文件是否为目录，返回一个boolean类型的值，true或者false。
（6）getName();获得文件名称（不带路径）（7）length（）；得到File对象指向文件的长度，以字节计算，返回一个长整形的值(long);注意：在系统中，文件夹(目录)的大小为零，也就是不占用空间，使用length()时返回的是0（8）delete（）;删除File对象所指定的文件（9）isFile（）；判断File对象指向的文件是不是标准文件（就像图片，音乐文件等）三,文件的属性和方法1.File.separator 当前操作系统的名称分隔符，等于字符串“\”.2.File.pathSeparator当前操作系统的路径分隔符，等于字符串“;”.3. File file=new ("D:\\My Document\\text.txt");file.canExecute();测试应用程序是否可以执行该文件;4.File file=new ("D:\\My Document\\text.txt");file.canRead();测试用用程序是否可以读取该文件5.file.canWrite();测试用程序是否可以修改文件6.file.exists();测试此抽象路径名表示的文件或目录是否存在pareTo（file1）；按字母顺序比较两个抽象路径。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Java流一、流的分类•按数据流动方向–输入流：只能从中读取字节数据，而不能向其写出数据–输出流：只能向其写入字节数据，而不能从中读取数据•按照流所处理的数据类型–字节流：用于处理字节数据。
–字符流：用于处理Unicode字符数据。
•按照流所处理的源–节点流:从/向一个特定的IO设备读/写数据的流。
（低级流）–处理流:对已存在的流进行连接和封装的流。
（高级流）二、缓冲流•缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法。
•J2SDK提供了四种缓存流：–BufferedReader–BufferedWriter–BufferedInputStream s–BufferedOutputStream•缓冲输入流支持其父类的mark()和reset()方法：–mark()用于“标记”当前位置，就像加入了一个书签，可以使用reset()方法返回这个标记重新读取数据。
•BufferedReader提供了readLine()方法用于读取一行字符串（以\r 或\n分隔）。
•BufferedWriter提供了newLine()用于写入一个行分隔符。
•对于输出的缓冲流，写出的数据会先在内存中缓存，使用flush()方法将会使内存中的数据立刻写出。
三、类层次3.1、InputStream类层次3.2、OutputStream类层次3.3、Reader类层次3.4、Writer类层次四、常用的字符流与字节流的转化说明：1.字节流用于读写诸如图像数据之类的原始字节流。
2.字符流用于读写诸如文件数据之类的字符流。
3.低级流能和外设交流。
4.高级流能提高效率。
5.InputStreamReader 是字节流通向字符流的桥梁。
6.OutputStreamWriter 是字符流通向字节流的桥梁。
五、代码实例5.1、常用读文件：/***以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
*@param fileName:文件的名*/public static void readFileByBytes(String fileName) { File file = new File(fileName);InputStream in = null;try {logger.debug("以字节为单位读取文件内容，一次读多个字节：");/*一次读多个字节*/byte[] tempbytes = new byte[100];int byteread = 0;in = new FileInputStream(file);/*读入多个字节到字节数组中，byteread为一次读入的字节数*/while ((byteread = in.read(tempbytes)) != -1) {logger.debug(tempbytes);logger.debug(0);logger.debug(byteread);}} catch (Exception e1) {logger.error("读取文本文件异常",e1);} finally {if (in != null) {try {in.close();} catch (IOException e1) {logger.error("读取文本文件异常",e1);}}}}*以字符为单位读取文件，常用于读文本，数字等类型的文件*@param fileName:文件名*/public static void readFileByChars(String fileName) {Reader reader = null;try {logger.debug("以字符为单位读取文件内容，一次读多个字节：");/*一次读多个字符*/char[] tempchars = new char[100];int charread = 0;if(fileName!=null&&!"".equals(fileName)){reader = new InputStreamReader(newFileInputStream(fileName));/*读入多个字符到字符数组中，charread为一次读取字符数*/while ((charread = reader.read(tempchars)) != -1) {/*对于windows下，rn这两个字符在一起时，表示一个换行。
*//*但如果这两个字符分开显示时，会换两次行。
*//*因此，屏蔽掉r，或者屏蔽n。
否则，将会多出很多空行。
*/if ((charread == tempchars.length)&& (tempchars[tempchars.length- 1] != 'r')) {logger.debug(tempchars);} else {for (int i = 0; i < charread; i++) {if (tempchars[i] == 'r') {continue;} else {logger.debug(tempchars[i]);}}}}}} catch (Exception e1) {logger.error("读取文本文件异常",e1);} finally {if (reader != null) {try {reader.close();} catch (IOException e1) {logger.error("读取文本文件异常",e1);}}}/***以行为单位读取文件，常用于读面向行的格式化文件*@param fileName:文件名*/public static List<String> readFileByLines(String fileName) { List<String> list = new ArrayList<String>();if(fileName!=null&&!"".equals(fileName)){File file = new File(fileName);BufferedReader reader = null;try {logger.debug("以行为单位读取文件内容，一次读一整行：");reader = new BufferedReader(new FileReader(file));String tempString = null;/*一次读入一行，直到读入null为文件结束*/while ((tempString = reader.readLine()) != null) {logger.debug(tempString);list.add(tempString);}} catch (IOException e) {logger.error("读取文本文件异常",e);} finally {if (reader != null) {try {reader.close();} catch (IOException e1) {logger.error("读取文本文件异常",e1);}}}}return list;}5.2、常用写文件：/***把内容写到文件*@param filePathName文件名*@param List<String>文件内容*/public static boolean writerFile(String filePathName,String content){boolean flag=false;OutputStreamWriter osw=null;try {if(filePathName!=null&&!"".equals(filePathName)){osw = new OutputStreamWriter(newFileOutputStream(filePathName));}} catch (FileNotFoundException e1) {flag=false;e1.printStackTrace();}if(osw!=null){BufferedWriter bw=new BufferedWriter(osw);try {if(content!=null&&!"".equals(content)){bw.write(content);flag= true;}} catch (IOException e) {flag=false;e.printStackTrace();}finally{try {bw.close();osw.close();} catch (IOException e) {flag=false;e.printStackTrace();}}}return flag;}/***把内容写到文件或追加到文件中*@param filePathName文件名*@param List<String>文件内容*/public static boolean writerFileIsAppend(String filePathName,String content){boolean flag=false;OutputStreamWriter osw=null;try {if (filePathName!=null&&!"".equals(filePathName)) {osw = new OutputStreamWriter(newFileOutputStream(filePathName,true));}} catch (Exception e1) {flag=false;e1.printStackTrace();}if(osw!=null){BufferedWriter bw=new BufferedWriter(osw);try {if(content!=null&&!"".equals(content)){bw.write(content);flag= true;}} catch (IOException e) {flag=false;e.printStackTrace();}finally{try {bw.close();osw.close();} catch (IOException e) {flag=false;e.printStackTrace();}}}return flag;}六、RandomAccessFile6.1：说明•RandomAccessFile是一种特殊的文件流，可以用它在文件的任何地方查找或者插入数据•RandomAccessFile同时实现了DataInput和DataOutput接口，所以可以用它来读/写文件•构造器：---RandomAccessFile(java.io.File f,String mode)---RandomAccessFile(String file,String mode)6.2：代码示例/***Description:读取文件最后一行内容*@param fileName文件路径名+文件名*/public static String getfinalLineData(String pathName){R andomAccessFile raf = null;S tring lastLine = "";try {raf = new RandomAccessFile(pathName, "r");long len = raf.length();if (len != 0L) {long pos = len - 1;while (pos > 0) {pos--;raf.seek(pos);if (raf.readByte() == '\n') {lastLine = raf.readLine();break;}}}} catch (Exception e) {e.printStackTrace();}finally {if (raf != null) {try {raf.close();} catch (IOException e1) {e1.getStackTrace();}}}return lastLine;}七、注意事项1、将高级流“套接“在低级流上，这样起到缓冲的作用可以提高效率。