StudyTonight-Java-中文教程-七-

StudyTonight Java 中文教程（七）

原文：StudyTonight

协议：CC BY-NC-SA 4.0

Java 中的字符流类

原文：https://www.studytonight.com/java-file-io/characterstream-classes-in-java

在本教程中，我们将在 Java 中学习关于字符流的课程。引入这些类是为了克服ByteStream 类的缺点。ByteStream 类只能处理 8 位字节，与 Unicode 字符不兼容。另一方面，字符流类用于处理 16 位 Unicode 字符。

在本文中，我们将了解一下 Java 中 CharacterStream 类的概述。在接下来的教程中，我们将详细介绍每种方法。

有两个类Reader 和Writer 是所有字符流类的超类。这两个类都是抽象类，位于java.io包中。

Java `Reader`类

这些类支持从输入流中读取 16 位字符。Reader 类是一个抽象类，因此我们不能直接使用它，但是表中给出的以下类继承了 Reader 类，并覆盖了该类的所有方法。

Reader 类的所有子类如下:

班级	描述
`BufferedReader`	这个类提供了从缓冲区读取字符的方法。
`CharArrayReader`	这个类提供了从字符数组中读取字符的方法。
`FileReader`	这个类提供了从文件中读取字符的方法。
`FilterReader`	这个类提供了从基础字符输入流中读取字符的方法。
`InputStreamReader`	此类提供将字节转换为字符的方法。
`PipedReader`	此类提供从连接的管道输出流中读取字符的方法。
`StringReader`	此类提供从字符串中读取字符的方法。

读者课的方法

Reader 类的所有方法见下表。

方法	描述
`int read()`	此方法返回输入中下一个字符的整数表示形式。如果遇到输入结束，则返回-1。
`int read(char buffer[])`	此方法用于读取指定的缓冲区。它返回成功读取的字符总数。如果遇到输入结束，则返回-1。
`int read(char buffer[], int loc, int nChars)`	此方法用于从指定位置的缓冲区中读取指定的 nChars。它返回成功读取的字符总数。
`void mark(int nchars)`	此方法用于标记输入流中的当前位置，直到读取 nChars 字符。
`void reset()`	此方法用于将输入指针重置为先前设置的标记。
`long skip(long nChars)`	此方法用于从输入流中跳过指定的字符，并返回跳过的字符数。
`boolean ready()`	如果下一个输入请求准备好了，这个方法返回一个布尔值 true。否则，它返回 false。
`void close()`	此方法用于关闭输入流。但是，如果程序试图访问输入，它会生成 IOException。

Java `Writer`类

此类用于将字符写入输出流。这些字符将采用 16 位 Unicode 格式。与 Reader 类相同，Writer 类也是一个抽象类，不能实例化。Writer 类的子类，用于在输出流中写入字符。

下表给出了 Writer 类的所有子类。

班级	描述
`BufferedWriter`	此类提供将字符写入缓冲区的方法。
`FileWriter`	这个类提供了向文件中写入字符的方法。
`CharArrayWriter`	此类提供将字符写入字符数组的方法。
`OutpuStreamWriter`	此类提供将字节转换为字符的方法。
`PipedWriter`	这个类提供了将字符写入管道输出流的方法。
`StringWriter`	此类提供将字符写入字符串的方法。

写作课的方法

下表给出了 Writer 类的方法。

方法	描述
`void write()`	此方法用于将数据写入输出流。
`void write(int i)`	此方法用于将单个字符写入输出流。
`void write(char buffer[])`	此方法用于将字符数组写入输出流。
`void write(char buffer [],int loc, int nChars)`	此方法用于将 nChars 字符从指定位置写入字符数组。
`void close ()`	此方法用于关闭输出流。但是，如果在关闭输出流后尝试写入输出流，则会生成 IOException。
`void flush ()`	此方法用于刷新输出流并写入等待的缓冲字符。

结论

在教程中，我们研究了 Java 中CharacterStream 类的概述。这些类属于 java.io 包。引入这个类是为了克服ByteStream 类的缺点。ByteStream 类只能处理 8 位字节，并且与 Unicode 字符不兼容。

Java 字节流类

Java `BufferedInputStream`

原文：https://www.studytonight.com/java-file-io/java-bufferedinputstream

在本教程中，我们将学习 Java 中的BufferedInputStream 类。Java 使用 BufferedInputStream 类从文件中读取数据，这个类使用缓冲区，因此速度更快，效率更高。当我们创建一个 BufferedInputStream 类的对象时，这会创建一个内部缓冲区数组。

句法

下面的代码是扩展FilterInputStream的BufferedInputStream类声明。

public class BufferedInputStream extends FilterInputStream

Java BufferedInputStream 构造器

BufferedInputStream 类有两个重载构造器，如下表所示。

构造器	描述
`BufferedInputStream(InputStream in)`	它创建一个`BufferedInputStream`并保存它的参数，输入流`in`，以备后用。
`BufferedInputStream(InputStream in, int size)`	它用指定的缓冲区大小创建一个`BufferedInputStream`，并保存它的参数，输入流`in`，以备后用。

Java `BufferedInputStream`方法

下表显示了 BufferedInputStream 类支持的不同方法及其用途。

方法	描述
`int available()`	此方法返回可以从输入流中读取的估计字节数，而不会被输入流的下一个调用方法阻塞。
`int read()`	这个方法从输入流中读取下一个字节的数据。
`int read(byte[] b, int off, int ln)`	此方法从给定的偏移量开始，将指定字节输入流中的字节读入指定的字节数组。
`void close()`	此方法关闭输入流并释放与该流关联的任何系统资源。
`void reset()`	此方法将流重新定位在此输入流上最后一次调用 mark 方法的位置。
`void mark(int readlimit)`	此方法查看输入流的 mark 方法的一般约定。
`long skip(long x)`	此方法跳过并丢弃输入流中的 x 字节数据。
`boolean markSupported()`

| 该方法测试输入流是否支持标记和重置方法。 |

使用`read()`方法的 Java BufferedInputStream 示例

在下面给出的程序中，我们从文件中读取数据，为了从文件中读取数据，我们创建了一个 FileInputStream 的对象，并将这个对象传递给 BufferedInputStream 类的构造器。使用BufferedInputStream 类的read()方法，我们逐个字符地读取每个字符，直到文件结束。文件的结尾将相当于 -1。

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{  
		try
		{    
			FileInputStream fin=new FileInputStream("E:\\studytonight\\myfile.txt");    
			BufferedInputStream in=new BufferedInputStream(fin);    
			int i;    
			while((i=in.read())!=-1)
			{    
				System.out.print((char)i);    
			}    
			in.close();    
			fin.close();    
		}
		catch(Exception e)
		{
			System.out.println(e.toString());
		}    
	}  
}

你好，今晚学习。

在上例中，我们学习了read()方法如何从文件中读取内容。现在我们将学习 skip()方法。

使用`skip()`方法的 Java BufferedInputStream 示例

当从文件中读取数据时，我们可以使用skip()方法跳过初始字节，该方法将一个参数作为要跳过的字节数。

在下面的程序中，我们调用了方法skip(5) ，所以它将跳过myfile.txt文件中的第一个5 字节。

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		FileInputStream file = new FileInputStream("E:\\studytonight\\myfile.txt");
		BufferedInputStream buffer = new BufferedInputStream(file);
		// Skips for the 5 bytes
		buffer.skip(5);
		int i = buffer.read();
		while (i != -1) {
			System.out.print((char) i);
			i = buffer.read();
		}
		buffer.close();
	}  
}

FGHIJKL
你好今晚学习
Hwllo World
1234567890

myfile.txt: 这是上面例子中用来读取的文件。

ABCDEFGHIJKL
Hello Studytonight
Hwllo World
1234567890

使用`available()`方法的 Java BufferedInputStream 示例

在下面的例子中，我们使用 available()方法从文件中获取可读取的字节。由于给定文件myfile.txt 包含 20 个字节用于读取，因此它将输出 20 个字节。

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
        FileInputStream file = new FileInputStream("E:\\studytonight\\myfile.txt");        
        BufferedInputStream buffer = new BufferedInputStream(file);
        System.out.println("Total bytes available at beginning " + buffer.available());
        buffer.close();
	}  
}

从 20 开始的可用字节总数

myfile.txt: 这是上面例子中用来读取的文件。

Hello Studytonight

结论

在本教程中，我们学习了如何使用 BufferedInputStream 类从文件中读取数据。当我们创建BufferedInputStream 类的对象时，这会创建一个内部缓冲区数组。因为我们在这个类中使用了缓冲区，所以它比其他方法快得多。

Java `FileOutputStream`类

原文：https://www.studytonight.com/java-file-io/java-fileoutputstream-class

在本教程中，我们将学习 Java 中的FileOutputStream。这个类是一个输出流，用于将数据写入文件。

句法

这是FileOutputStream 类的语法声明，我们可以看到这个类继承了OutputStream 它意味着我们可以使用FileOutputStream 类的一个对象调用这个类的所有方法。

public class FileOuputStream extends OutputStream

构造器

下表给出了不同的构造器:

构造器	描述
`FileOutputStream(File file)`	创建一个文件输出流，写入由指定的`File`对象表示的文件。
`FileOutputStream(FileDescriptor fdObj)`	创建要写入指定文件描述符的文件输出流，该文件描述符表示与文件系统中实际文件的现有连接。
`FileOutputStream(File file, boolean append)`	创建一个文件输出流，写入由指定的`File`对象表示的文件。
`FileOutputStream(String name)`	创建文件输出流，以写入具有指定名称的文件。
`FileOutputStream(String name, boolean append)`	创建文件输出流，以写入具有指定名称的文件。

方法

这些是文件输出流类支持的方法。

方法	描述
`protected void finalize()`	此方法用于清理与文件输出流的连接。
`void write(byte[] arr)`	该方法用于将`ary.length`字节从字节数组写入文件输出流。
`void write(byte[] arr, int off, int len)`	该方法用于将从偏移量`off`开始的字节数组中的`len` 字节写入文件输出流。
`void write(int b)`	此方法用于将指定的字节写入文件输出流。
`FileChannel getChannel()`	此方法用于返回与文件输出流关联的文件通道对象。
`FileDescriptor getFD()`	此方法用于返回与流关联的文件描述符。
`void close()`	此方法用于关闭文件输出流。

`write()` 方法示例:

在下面的程序中，我们将给定的文本转换为字节数组，因为write()方法只接受字节数组。要写这个字节数组，我们需要一个FileOutputStream 类的对象，我们在这个对象上调用write()方法写入文件。

import java.io.FileOutputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{  
		try
		{    
			byte arr[] = "Hello studytonight".getBytes();
			FileOutputStream fout=new FileOutputStream("E:\\studytonight\\myfile.txt");    
			fout.write(arr);    
			fout.close();    
			System.out.println("Text written to the file successfully.");    
		}
		catch(Exception e)
		{
			System.out.println(e.toString());
		}    
	}  
}

控制台输出:

文本成功写入文件。

文件输出:

你好，今晚学习

用于追加的文件输出流构造器示例:

下面给出了一个例子，我们用两个参数实现文件输出流:1)文件名的字符串值，2)追加的布尔值。这个例子将在我们每次执行程序时给定的文本附加到文件中。

import java.io.FileOutputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{  
		try
		{    
			//second parameter is for append
			FileOutputStream fout=new FileOutputStream("E:\\studytonight\\myfile.txt", true);    
			byte arr[] = "Hello studytonight\n".getBytes();
			fout.write(arr);    
			fout.close();    
			System.out.println("Text written to the file successfully.");    
		}
		catch(Exception e)
		{
			System.out.println(e.toString());
		}    
	}  
}

文本成功写入文件。

当我们执行上述程序三次时，myfile.txt中的数据将如下所示:

Hello studytonight
Hello studytonight
Hello studytonight

结论

在本文中，我们学习了如何使用OutputStream 类的write()方法将数据写入文件。此方法将字节数组中的字节写入文件输出流。

Java `FileInputStream`类

原文：https://www.studytonight.com/java-file-io/java-fileinputstream-class

在本教程中，我们将学习 Java 中的 FileInputStream 及其各种方法。这个类从文件中读取一个字节流，属于 java.io 包。

句法

我们可以看到FileInputStream 类的语法声明，默认情况下它继承了 InputStream 类，这意味着我们可以用FileInputStram 类的对象调用这个类的所有方法。

public class FileInputStream extends InputStream

方法

下表给出了FileInputStream 类的方法及其用途:

从文件读取数据的`FileInputStream`示例

下面给出的例子将在FileInputStream 类及其read()方法的帮助下从 myfile.txt 中读取数据。read()方法一次只读取一个字节，因此，我们在循环内部调用，这样它就可以读取所有字符。这将返回文件末尾的-1，我们将在那里停止。

import java.io.FileInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{  
		try
		{    
			FileInputStream fin=new FileInputStream("E:\\studytonight\\myfile.txt");    
			int i=0;    
			while((i=fin.read())!=-1){    
				System.out.print((char)i);    
			}      
			fin.close();  
		}
		catch(Exception e)
		{
			System.out.println(e.toString());
		}    
	}  
}

你好，今晚学习

`available()`方法示例

在下面给出的程序中，我们实现了一个可用的()方法来检查输入源中可供读取的字节数。正如我们第一次调用 available()方法时可以看到的，它显示有 18 个字节可供读取。现在我们调用 read()函数两次，这样它将减少从文件中读取的字节数，因此它将打印 16 个可用字节。我们可以使用可用方法来检查从输入源读取的可用字节数。

import java.io.FileInputStream;
public class StudyTonight
{
	public static void main(String args[])
	{
		try 
		{
			FileInputStream input = new FileInputStream("E:\\studytonight\\file.txt");
			System.out.println("Available bytes = " + input.available());
			input.read();
			input.read();
			System.out.println("Available bytes = " + input.available());
			input.close();
		}
		catch (Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

。

可用字节= 18
可用字节= 16

file.txt

Hello Studytonight

`skip()`方法示例

在给定的程序中，我们实现了 skip()方法。此方法将参数作为要从输入流中跳过的字节数。在下面的程序中，我们通过传递 5 作为参数来调用 skip 方法，这样它将跳过输入流中的前 5 个字节，因此当我们从该流中读取数据时，它将返回前 5 个字节之后的数据。例如，在给定的文件中，我们有一个数据“你好今晚研究”，我们跳过了前 5 个字节，所以它将直接打印“今晚研究”

import java.io.FileInputStream;
public class StudyTonight
{
	public static void main(String args[])
	{
		try 
		{
			FileInputStream input = new FileInputStream("E:\\studytonight\\file.txt");
			input.skip(5);
			int ch=0;
			while(ch!=-1)
			{
				System.out.print((char)ch);
				ch=input.read();
			}		
			input.close();
		}
		catch (Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

今晚学习

file.txt

Hello Studytonight

结论

在本教程中，我们学习了如何从给定文件中读取字节流。为了从文件中读取数据，我们使用了FileInputStream 类。

read()方法从文件中一个字节一个字节地读取数据，这样我们就可以从文件中读取整个数据。

Java `BufferedOutputStream`类

原文：https://www.studytonight.com/java-file-io/java-bufferedoutputstream-class

在本教程中，我们将学习 Java 中的BufferedOutputStream 类。这个类为输出流创建一个缓冲区，这样比直接写入文件更有效。它使处理比正常方法更快。

句法

OutputStream os= new BufferedOutputStream(new FileOutputStream("E:\\studytonight\\myfile.txt"));

Java `BufferedOutputStream`类构造器

构造器	描述
`BufferedOutputStream(OutputStream os)`	此方法创建新的缓冲输出流，用于将数据写入指定的输出流。
`BufferedOutputStream(OutputStream os, int size)`	此方法创建新的缓冲输出流，用于将数据写入具有指定缓冲区大小的指定输出流。

方法

使用 BufferedOutputStream 将数据写入文件的示例

在下面给出的例子中，我们将使用文件输出流和缓冲输出流向文件中写入字符串“今晚你好，学习”。与我们对简单文件输出流所做的一样，这里我们也使用write() 方法将该特定数据写入文件。

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{  
		FileOutputStream fout=new FileOutputStream("E:\\studytonight\\myfile.txt");    
		BufferedOutputStream bout=new BufferedOutputStream(fout);    
		String s="Hello Studytonight";    
		byte b[]=s.getBytes();    
		bout.write(b);    
		bout.flush();    
		bout.close();    
		fout.close();    
		System.out.println("Data written to the file successfully.");   
	}  
}

数据成功写入文件。

结论:

在本教程中，我们学习了BufferedOutputStream 课。BufferedOutputStream 创建一个缓冲区，因此与普通的文件输出流类相比，这是非常快速和有效的。

Java `SequenceInputStream`类

原文：https://www.studytonight.com/java-file-io/java-sequenceinputstream-class

在本教程中，我们将学习 Java 中的 SequenceInputStream 类。此类用于从多个流中读取数据。顾名思义，它按顺序读取数据，意思是一个接一个。

Java 序列输出流类声明

这是 SequenceInputStream 类的声明，我们可以看到 InputStream 类是在这个类中继承的。

public class SequenceInputStream extends InputStream

SequenceInputStream 类的构造器

构造器	描述
`SequenceInputStream(InputStream s1, InputStream s2)`	它通过按顺序读取两个输入流的数据来创建新的输入流，首先是 s1，然后是 s2。
`SequenceInputStream(Enumeration e)`	它通过读取类型为 input stream 的枚举的数据来创建新的输入流。

序列输出流类的方法

方法	描述
`int read()`	它用于从输入流中读取下一个字节的数据。
`int read(byte[] ary, int off, int len)`	它用于将输入流中的大量数据读入字节数组。
`int available()`	它用于返回可从输入流中读取的最大字节数。
`void close()`	它用于关闭输入流。

Java 序列输出流示例

在下面给出的例子中，我们使用SequenceInputStream 类从两个文件中读取数据。对于这两个文件，我们为两个文件创建了 FileInputStream 的两个对象，并将它们传递给SequenceInputStream 类的构造器。现在使用read() 方法，我们逐个读取两个文件的数据。我们可以看到这个程序的输出是两个文件的内容。

import java.io.FileInputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{  
		FileInputStream fileInputStream1=new FileInputStream("E:\\studytonight\\myfile1.txt");    
		FileInputStream fileInputStream2=new FileInputStream("E:\\studytonight\\myfile2.txt");    
		SequenceInputStream inst=new SequenceInputStream(fileInputStream1, fileInputStream2);    
		int c;    
		while((c=inst.read())!=-1)
		{    
			System.out.print((char)c);    
		}    
		inst.close();    
		fileInputStream1.close();    
		fileInputStream2.close();  
	}  
}

1234567890ABCDEFGHIJKL

我的文件 1.txt

1234567890

我的文件 2.txt

ABCDEFGHIJKL

从两个文件中读取数据并写入另一个文件的示例

在给出的例子中，我们将从两个文件中读取数据，并将相同的数据存储到output.txt文件中。为了读取数据，我们需要一个用于相应文件的FileInputStream 类的对象。为了从该文件中顺序读取，我们将使用SequenceInputStream 类并使用read()方法从这些文件中读取内容，并使用FileOutputStram 类的write() 方法将其写入output.txt文件。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{  
		FileInputStream fileInputStream1=new FileInputStream("E:\\studytonight\\myfile1.txt");    
		FileInputStream fileInputStream2=new FileInputStream("E:\\studytonight\\myfile2.txt");    
		FileOutputStream fout=new FileOutputStream("E:\\studytonight\\output.txt");      
		SequenceInputStream sis=new SequenceInputStream(fileInputStream1, fileInputStream2);    
		int i;    
		while((i=sis.read())!=-1)    
		{    
			fout.write(i);        
		}    
		sis.close();    
		fout.close();      
		fileInputStream1.close();      
		fileInputStream2.close();       
		System.out.println("Data is written to the file successfully...");  
	}    
}

数据成功写入文件...

我的文件 1.txt

1234567890

我的文件 2.txt

ABCDEFGHIJKL

输出. txt

1234567890ABCDEFGHIJKL

结论

在本教程中，我们学习了如何使用 SequenceInputStream 类从文件中顺序读取数据。此类用于从多个流中读取数据。顾名思义，它按顺序读取数据，意思是一个接一个。

Java `ByteArrayOutputStream`类

原文：https://www.studytonight.com/java-file-io/java-bytearrayoutputstream-class

在本教程中，我们将学习 Java 中的ByteArrayOutputStream 类。该类用于将公共数据写入多个文件。这个类流首先将数据转换成一个字节数组，当需要时，这个数组可以转换成许多流。

enlightened 了解这个类一个有趣的事实是这个类的缓冲区会根据数据自动增长。

句法

这是ByteArrayOutputStream 类的类声明，也继承了OutputStream。

public class ByteArrayOutputStream extends OutputStream

Java 字节数组输出流类构造器

这个类有两种不同的构造器，第一种具有 32 字节的初始容量，并根据需要增加，另一方面，对于第二种构造器，我们可以隐式传递缓冲区的大小。

构造器	描述
`ByteArrayOutputStream()`	创建初始容量为 32 字节的新字节数组输出流，但如果需要，其大小会增加。
`ByteArrayOutputStream(int size)`	创建一个新的字节数组输出流，具有指定大小的缓冲区容量，以字节为单位。

Java 字节数组输出流类方法

下表给出了该类的各种方法。

方法	描述
`int size()`	此方法用于返回缓冲区的当前大小。
`byte[] toByteArray()`	此方法用于创建新分配的字节数组。
`String toString()`	此方法用于使用平台默认字符集将内容转换为字符串解码字节。
`String toString(String charsetName)`	此方法用于使用指定的字符集名称将内容转换为字符串解码字节。
`void write(int b)`	此方法用于将指定的字节写入字节数组输出流。
`void write(byte[] b, int off, int len)`	此方法用于从偏移量`off` 开始将指定字节数组中的`len` 字节写入字节数组输出流。
`void writeTo(OutputStream out)`	此方法用于将字节数组输出流的完整内容写入指定的输出流。
`void reset()`	此方法用于将字节数组输出流的计数字段重置为零值。
`void close()`	此方法用于关闭字节数组输出流。

Java 字节数组输出流示例

在下面的例子中，我们将使用 ByteArrayOutputStream类的writeTo() 方法将相同的数据写入多个文件。

首先，我们创建了一个FileOutputStream 类的对象。最后，使用 writeTo()方法，我们将给定的内容写入两个文件。从输出中，我们可以看到两个文件中存在相同的文本。

import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{  
		FileOutputStream fout1=new FileOutputStream("E:\\studytonight\\myfile1.txt");    
		FileOutputStream fout2=new FileOutputStream("E:\\studytonight\\myfile2.txt");    
		ByteArrayOutputStream bout=new ByteArrayOutputStream();    
		bout.write('A');    
		bout.writeTo(fout1);    
		bout.writeTo(fout2);    
		bout.flush();       
		System.out.println("Data written to the file...");    
	}    
}

写入文件的数据...

我的文件 1.txt

我的文件 2.txt

结论

在本教程中，我们学习了 Java 中的ByteArrayOutputStream 类。通过使用这个类，我们可以将公共数据写入多个文件。该类支持size(), toByteArray(), toString(), toString(String charsetName), write(int b), write(byte[] b, int off, int len)等多种方法。

Java `ByteArrayInputStream`类

原文：https://www.studytonight.com/java-file-io/java-bytearrayinputstream-class

在本教程中，我们将学习 Java 中的ByteArrayInputStream 类。此类用于读取字节数组作为输入流。

ByteArrayInputStream 的缓冲区大小会根据数据自动增长。

句法

这是ByteArrayInputStream 类的语法声明，我们可以看到它继承了InputStream 类。

public class ByteArrayInputStream extends InputStream

Java `ByteArrayInputStream`类构造器

下表给出了该类的构造器。

构造器	描述
`ByteArrayInputStream(byte[] ary)`	创建一个新的`ByteArrayInputStream`，使用`ary` 作为其缓冲数组。
`ByteArrayInputStream(byte[] ary, int offset, int len)`	创建一个新的`ByteArrayInputStream`，使用`ary` 作为其缓冲数组，可以从数组中读取多达指定`len` 字节的数据。

Java `ByteArrayInputStream`类方法

下面提到了这个类的各种方法。

方法	描述
`int available()`	此方法用于返回可以从输入流中读取的剩余字节数。
`int read()`	此方法用于从输入流中读取下一个字节的数据。
`int read(byte[] ary, int off, int len)`	该方法用于从输入流的字节数组中读取多达`len` 字节的数据。
`boolean markSupported()`	此方法用于测试标记和重置方法的输入流。
`long skip(long x)`	该方法用于从输入流中跳过`x` 字节的输入。
`void mark(int readAheadLimit)`	此方法用于设置流中当前标记的位置。
`void reset()`	此方法用于重置字节数组的缓冲区。
`void close()`	此方法用于关闭`ByteArrayInputStream`。

Java `ByteArrayInputStream`示例

在下面的代码中，我们演示了ByteArrayInputStream 类是如何工作的。在这里，我们使用这个类的read()方法从字节数组中读取每个元素，并通过类型转换为字符来打印它，因为默认情况下，它将作为 ASCII 代码出现。

import java.io.ByteArrayInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{  
		byte[] buf = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};  
		ByteArrayInputStream byteArrayIS = new ByteArrayInputStream(buf);  
		int ch = 0;  
		while ((ch = byteArrayIS.read()) != -1) 
		{  
			System.out.print((char) ch); 
		}    
	}  
}

abcdefg

结论:

在本文中，我们学习了ByteArrayInputStream 类，这个类用于将字节数组作为流读取。ByteArrayInputStream 的缓冲区大小会根据数据自动增长。

Java `DataOutputStream`类

原文：https://www.studytonight.com/java-file-io/java-dataoutputstream-class

在本教程中，我们将学习 Java 中的DataOutputStream 类。这个类用于将原始数据写入文件。这个类很有帮助，因为后面我们用DataInputStream 类提取这个数据。这里的原始数据类型包括short、char、int、float、double 和boolean。DataOutputStream 类也称为过滤类，它将输出流包装成原始数据。

句法

这是数据输出流的语法声明。

public class DataOutputStream extends FilterOutputStream implements DataOutput

方法

方法	描述
int 大小()	它用于返回写入数据输出流的字节数。
无效写入(int b)	它用于将指定的字节写入基础输出流。
无效写入(字节[] b，int off，int len)	它用于将 len 字节的数据写入输出流。
void 布尔值(布尔值 v)	它用于将布尔值作为 1 字节值写入输出流。
void writeChar(int v)	它用于将 char 作为 2 字节值写入输出流。
无效的写字符	它用于将字符串作为字符序列写入输出流。
void writeByte(int v)	它用于将一个字节作为 1 字节值写入输出流。
无效写字节(字符串)	它用于将字符串作为字节序列写入输出流。
参见 writeInt(int v)	它用于向输出流写入一个 int
void writeShort(int v)	它用于向输出流写入一个短消息。
void writeShort(int v)	它用于向输出流写入一个短消息。
void writeLong(长 v)	它用于向输出流中写入一个 long。
空写输出(字符串)	它用于以可移植的方式使用 UTF-8 编码将字符串写入输出流。
空隙冲洗()

| 用于刷新数据输出流。 |

使用`writeInt()`方法的数据输出流类示例

在下面的程序中，我们正在实现 writeInt() 方法将数据写入文件。

import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		FileOutputStream file = new FileOutputStream("E:\\studytonight\\myfile.txt");  
        DataOutputStream data = new DataOutputStream(file);  
        data.writeInt(68);  
        data.flush();  
        data.close();  
        System.out.println("Data is written to the file successfully"); 
	}  
}

数据成功写入文件

我的文件.txt

数据输出流类方法示例

在下面的程序中，我们使用了各种方法，如writeDouble()、writeInt()、 writeBoolean()和writeChar()。这些方法将以原始数据类型存储给定的数据。现在我们可以看到，这些数据不是可读的格式，但是当我们使用DataInputStream 类访问它时，读取输入数据会更加方便。

import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		FileOutputStream file = new FileOutputStream("E:\\studytonight\\myfile.txt");  
        DataOutputStream data = new DataOutputStream(file);  
        data.writeDouble(2.1); 
        data.writeInt(45); 
        data.writeBoolean(true); 
        data.writeChar('S'); 
        data.flush();  
        data.close();  
        System.out.println("Data is written to the file successfully"); 
	}  
}

数据成功写入文件

我的文件.txt

@ ÌÌÌÌÌÍ   - S

结论

在本教程中，我们学习了 Java 中的DataOutputStream 类。此类用于将数据以基本数据类型存储到文件中，以便以后可以同样检索。

Java `DataInputStream`类

原文：https://www.studytonight.com/java-file-io/java-datainputstream-class

在本教程中，我们将学习 Java 中的DataInputStream 。这个类从数据流中读取原始数据，而不依赖于机器。Java 应用通常使用DataOutpuStream 来写数据，这些数据以后可以被DataInputStream读取。

句法

这是DataInputStream 类的内部语法声明。

public class DataInputStream extends FilterInputStream implements DataInput

方法

方法	描述
`int read(byte[] b)`	它用于从输入流中读取字节数。
`int read(byte[] b, int off, int len)`	它用于从输入流中读取`len` 字节的数据。
`int readInt()`	它用于读取输入字节并返回一个 int 值。
`byte readByte()`	它用于读取和返回一个输入字节。
`char readChar()`	它用于读取两个输入字节并返回一个字符值。
`double readDouble()`	它用于读取八个输入字节并返回一个双精度值。
`boolean readBoolean()`	它用于读取一个输入字节，如果字节非零则返回真，如果字节为零则返回假。
`int skipBytes(int x)`	它用于跳过输入流中的`x` 字节数据。
`String readUTF()`	它用于读取使用 UTF-8 格式编码的字符串。
`void readFully(byte[] b)`	它用于从输入流中读取字节，并将其存储到缓冲区数组中。
`void readFully(byte[] b, int off, int len)`	它用于从输入流中读取`len` 字节。

从文件中读取数据的 DataInputStream 类的示例

在下面给出的程序中，我们使用DataInputStream 类的read()方法从给定文件myfile.txt中读取数据。首先，我们将使用available()方法计算文件中可读取的字节数，并创建一个该大小的新字节数组。现在，我们需要使用 read()方法从文件中读取数据，然后逐个打印。

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		FileInputStream file = new FileInputStream("E:\\studytonight\\myfile.txt");  
		DataInputStream inst = new DataInputStream(file);  
		int count = file.available();  
		byte[] array = new byte[count];  
		inst.read(array);  
		for (byte b : array) {  
			char ch = (char) b;  
			System.out.print(ch);  
		}  
	}  
}

你好，今晚学习

我的文件.txt

Hello Studytonight

读写原始数据的示例:

下面的例子对于DataInputStream 类和DataOutputStream 类的实际使用都非常重要，这里我们首先将数据写入一个文件，然后再次读取该数据。当我们存储数据时，它不会是人类可读的形式，但是我们可以使用DataInputStream以原始类型正确地读取它。

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		DataOutputStream dataOutputStream =	new DataOutputStream(new FileOutputStream("E:\\studytonight\\myfile.txt"));
		dataOutputStream.writeInt(45);
		dataOutputStream.writeFloat(98.7F);
		dataOutputStream.writeLong(123456);
		dataOutputStream.close();
		DataInputStream dataInputStream =new DataInputStream(new FileInputStream("E:\\studytonight\\myfile.txt"));
		int   intData    = dataInputStream.readInt();
		float floatData = dataInputStream.readFloat();
		long  longData    = dataInputStream.readLong();
		dataInputStream.close();
		System.out.println("int data: " + intData);
		System.out.println("float data: " + floatData);
		System.out.println("long data: " + longData);
	}  
}

int 数据:45
float 数据:98.7
long 数据:123456

我的文件.txt

 -BÅff     â@

结论

在本教程中，我们学习了 Java 中的 DataInputStream 类及其方法。这个类从数据流中读取原始数据，而不依赖于机器。

Java `FilterOutputStream`类

原文：https://www.studytonight.com/java-file-io/java-filteroutputstream-class

在本教程中，我们将学习 Java 中的FilterOutputStream类。FilterOutputStream 类的 write()方法过滤数据并将其写入流，过滤是基于流完成的。

句法

下面的代码片段给出了FilterOutputStream 类的内部语法声明。

public class FilterOutputStream extends OutputStream

Java 筛选器输出流类方法

FilterOutputStream 类支持的所有方法如下表所示:

FilterOutputStream 类的示例

在这个程序中，我们使用FilterOutputStream 类的write()方法将数据写入文件 output.txt。

import java.io.File;
import java.io.FileOutputStream;
import java.io.FilterOutputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		File data = new File("E:\\studytonight\\output.txt");  
		FileOutputStream file = new FileOutputStream(data);  
		FilterOutputStream filter = new FilterOutputStream(file);  
		String s="Hello Studytonight";      
		byte b[]=s.getBytes();      
		filter.write(b);     
		filter.flush();  
		filter.close();  
		file.close();  
		System.out.println("Data is written to the file successfully...");  
	}  
}

数据成功写入文件...

输出. txt

Hello Studytonight

结论

在本教程中，我们学习了 FilterOutputStream 类及其各种方法。这个类过滤数据并将其写入流，过滤是基于流完成的。

Java `FilterInputStream`类

原文：https://www.studytonight.com/java-file-io/java-filterinputstream-class

在本教程中，我们将学习 Java 中的FilterInputStream 类。该类覆盖InputStream 类的所有方法，其版本将所有请求传递给包含的输入流。

句法

这是FilterInputStream 类的语法，我们可以看到它在扩展InputStream 类。

public class FilterInputStream extends InputStream

Java FilterInputStream 类方法

表中给出了FilterInputStream 类的方法。

方法	描述
`int available()`	它用于返回可以从输入流中读取的估计字节数。
`int read()`	它用于从输入流中读取下一个字节的数据。
`int read(byte[] b)`	它用于从输入流中读取最大字节长度的数据。
`long skip(long n)`	它用于跳过并丢弃输入流中的`n` 字节数据。
`boolean markSupported()`	它用于测试输入流是否支持标记和重置方法。
`void mark(int readlimit)`	它用于标记输入流中的当前位置。
`void reset()`	它用于重置输入流。
`void close()`	它用于关闭输入流。

`FilterInputStream`类方法示例

在下面的例子中，我们使用 FilterInputStream 类的 read()方法从output.txt文件中读取数据。

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FilterInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		File data = new File("E:\\studytonight\\output.txt");  
		FileInputStream  file = new FileInputStream(data);  
		FilterInputStream filter = new BufferedInputStream(file);  
		int ch =0;  
		while((ch=filter.read())!=-1){  
			System.out.print((char)ch);  
		}  
		file.close();  
		filter.close();   
	}  
}

你好，今晚学习

输出. txt

你好，今晚学习

FilterInputStream 类中的 `available()`示例

在给定的示例中，我们使用 available()方法来检查文件中有多少字节可供读取。在这个程序的输出中，我们可以看到最初我们总共有17 个字节可供读取，随着我们一个接一个地读取，这些字节逐渐减少。

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FilterInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		File data = new File("E:\\studytonight\\output.txt");  
		FileInputStream  file = new FileInputStream(data);  
		FilterInputStream filter = new BufferedInputStream(file);  
		int ch =0;  
		while((ch=filter.read())!=-1){  
			System.out.println(filter.available());  
		}  
		file.close();  
		filter.close();   
	}  
}

17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0

输出. txt

你好，今晚学习

结论:

在本教程中，我们学习了FilterInputStream 类及其各种方法。传递过滤数据的所有InputStream类都是 FilterInputStream 类的子类。

Java `ObjectStream`类

原文：https://www.studytonight.com/java-file-io/java-objectstreamclass

在本教程中，我们将学习 Java 中的ObjectStreamClass 。这个类也被称为类的序列化描述符。它包含类的名称和 serialVersionUID。

ObjectStreamClass 的方法

ObjectStreamClass 的不同方法如下:

方法	描述
`Class<?> forClass()`	它返回该版本映射到的本地虚拟机中的类。
`ObjectStreamField getField(String name)`	它通过名称获取这个类的字段。
`ObjectStreamField[] getFields()`	它返回此序列化类的字段数组。
`String getName()`	它返回由这个描述符描述的类名。
`long getSerialVersionUID()`	它返回这个类的 serialVersionUID。
`Static ObjectStreamClass lookup(Class<?> cl)`	它找到一个可以序列化的类的描述符。
`Static ObjectStreamClass lookupAny(Class<?> cl)`	它返回任何类的描述符，不管它是否实现 Serializable。
`String toString()`	它返回一个描述该`ObjectStream`类的字符串。

`ObjectStream`类及其方法示例

在下面的例子中，我们调用getFields()、getName()、getSerialVersionUID()和toString() 方法来获取类的相应信息。这里我们借助lookup()方法为java.lang包的Number 类创建了一个ObjectStreamClass 方法的对象。

package studytonight;
import java.io.ObjectStreamClass;
public class StudyTonight 
{
	public static void main(String args[])
	{
		ObjectStreamClass stream = ObjectStreamClass.lookup(Number.class); 

		System.out.println("Class Fields: "+stream.getFields()); 

		System.out.println("Class Name: " + stream.getName()); 

		System.out.println("Class SerialVersionUID: "+stream.getSerialVersionUID()); 

		System.out.println("Class String: "+stream.toString()); 
	}
}

类字段:【ljava . io . objectstreamfield；@3ac42916
类名称:java.lang.Number
类序列版本号:-8742448824652078965
类字符串:java.lang.Number:静态最终长序列版本号=-874248824652078965 l；

检查类实例的示例

在这个例子中，我们使用lookup()和lookupAny() 方法检查一个类的实例。这里lookup()方法找到一个可以序列化的类的描述符。另一方面， lookupAny()方法返回任何类的描述符，不管它是否实现 Serializable。

package studytonight;
import java.io.ObjectStreamClass;
import java.util.ArrayList;
public class StudyTonight 
{
	public static void main(String args[])
	{
		ObjectStreamClass objectStream1 = ObjectStreamClass.lookup(Number.class);
		System.out.println(objectStream1.forClass()); 
		ObjectStreamClass objectStream2 = ObjectStreamClass.lookupAny(ArrayList.class);         
		System.out.println(objectStream2.forClass()); 
	}
}

类 java.lang.Number
类 java.util.ArrayList

结论

在本教程中，我们学习了ObjectStreamClass。这个类也被称为类的序列化描述符。它包含类的名称和 serialVersionUID。它扩展了类对象并实现了可序列化。

Java `ObjectStreamField`类

原文：https://www.studytonight.com/java-file-io/java-objectstreamfield-class

在本教程中，我们将学习 Java 中的ObjectStreamField 类。此类是可序列化类中可序列化字段的描述。ObjectStreamFields 数组用于声明类的可序列化字段。

句法

public class ObjectStreamField extends Object implements Comparable<Object>

构造器

构造器	描述
`ObjectStreamField(String name, Class<?> type)`	此方法创建具有指定类型的可序列化字段。
`ObjectStreamField(String name, Class<?> type, boolean unshared)`	此方法创建一个 ObjectStreamField，表示具有给定名称和类型的可序列化字段。

方法

ObjectStreamField 类的方法如下:

上表getTypeCode()方法返回字符，即字段类型的字符编码。编码如下:

| B | 字节 |
| C | 茶 |
| D | 两倍 |
| F | 漂浮物 |
| 我 | （同 Internationalorganizations）国际组织 |
| J | 长的 |
| L | 类或接口 |
| S | 短的 |
| Z | 布尔 |
| [ | 排列 |

ObjectStreamField 示例

在下面的例子中，我们正在实现ObjectStreamField 类的getName()和getField()方法。此方法返回一个表示可序列化字段名称的字符串。

package studytonight;
import java.io.ObjectStreamClass;
import java.io.ObjectStreamField;
import java.util.Calendar;
public class StudyTonight 
{
	public static void main(String args[])
	{
		ObjectStreamClass osc = ObjectStreamClass.lookup(Integer.class);

		ObjectStreamField field = osc.getField("value");

		System.out.println("" + field.getName());

		ObjectStreamClass osc2 = ObjectStreamClass.lookup(Calendar.class);

		ObjectStreamField field2 = osc2.getField("lenient");

		System.out.println("" + field2.getName());
	}
}

值
从宽

示例:

在这个例子中，我们为整数和日历创建了一个新的ObjectStream，然后获取两者的类实例并打印出来。

package studytonight;
import java.io.ObjectStreamClass;
import java.util.Calendar;
public class StudyTonight 
{
	public static void main(String args[])
	{
		ObjectStreamClass osc = ObjectStreamClass.lookup(String.class);  
		System.out.println("" + osc.getField("value"));  

		ObjectStreamClass osc2 = ObjectStreamClass.lookup(Calendar.class);  
		System.out.println("" + osc2.getField("isTimeSet"));  
	}
}

零
Z 是时间集

结论:

在本教程中，我们学习了 Java 中的ObjectStreamField 类。此类是可序列化类中可序列化字段的描述。ObjectStreamFields 数组用于声明类的可序列化字段。

Java `Console`类

原文：https://www.studytonight.com/java-file-io/java-console-class

在本教程中，我们将学习 Java 中的Console 类。Java Console 类用于从控制台获取输入。这个类提供了从控制台读取文本的各种方法。

句法

这是Console类的语法声明。

public final class Console extends Object implements Flushable

Java `Console`类方法

方法	描述
`Reader reader()`	它用于检索与控制台关联的读取器对象。
`String readLine()`	它用于从控制台读取单行文本。
`String readLine(String fmt, Object... args)`	它提供格式化的提示，然后从控制台读取单行文本。
`char[] readPassword()`	它用于读取控制台上没有显示的密码。
`char[] readPassword(String fmt, Object... args)`	它提供格式化的提示，然后读取控制台上没有显示的密码。
`Console format(String fmt, Object... args)`	它用于将格式化的字符串写入控制台输出流。
`Console printf(String format, Object... args)`	它用于将字符串写入控制台输出流。
`It is used to write a string to the console output stream.`	它用于检索与控制台关联的 PrintWriter 对象。
`void flush()`	它用于刷新控制台。

Java 控制台示例

在下面的例子中，我们使用 readLine()方法从用户处读取数据。readLine()方法用于从控制台读取单行文本。

package studytonight;
import java.io.Console;
public class StudyTonight 
{
	public static void main(String args[])
	{
		Console console=System.console();    
		System.out.println("Enter your name: ");    
		String user=console.readLine();    
		System.out.println("Hello "+user);    
	}
}

输入你的名字:今晚学习
你好今晚学习

读取密码的 Java 控制台示例

在下面的例子中，我们正在使用readPassword()方法从用户那里读取密码，而读取该密码不会显示在控制台上。

package studytonight;
import java.io.Console;
public class StudyTonight 
{
	public static void main(String args[])
	{
		Console console=System.console();    
		System.out.println("Enter your password: ");    
		char[] ch=console.readPassword();    
		String pass=String.valueOf(ch);
		System.out.println("Password: "+pass);    
	}
}

输入您的密码:
密码:786

结论

在这个例子中，我们学习了 Java 中的 Console 类。Java Console 类用于从控制台获取输入。这个类提供了从控制台读取文本的各种方法。如果我们使用Console类读取密码，它将不会显示在控制台上。

Java `FilePermission`类

原文：https://www.studytonight.com/java-file-io/java-filepermission-class

在本教程中，我们将学习 Java 中的FilePermission 类。FilePermission类用于表示对文件或目录的访问。所有权限都与路径相关。

句法

以下语法是FilePermission类的声明。

public final class FilePermission extends Permission implements Serializable

构造器

方法	描述
`ByteArrayOutputStream()`	创建初始容量为 32 字节的新字节数组输出流，但如果需要，其大小会增加。
`ByteArrayOutputStream(int size)`	创建一个新的字节数组输出流，具有指定大小的缓冲区容量，以字节为单位。

Java `FilePermission`类方法

方法	描述
`int hashCode()`	它用于返回对象的哈希代码值。
`String getActions()`	它用于返回操作的“规范字符串表示”。
`boolean equals(Object obj)`	它用于检查两个文件权限对象是否相等。
`boolean implies(Permission p)`	它用于检查文件权限对象的指定权限。
`PermissionCollection newPermissionCollection()`	它用于返回用于存储文件权限对象的新权限集合对象。

文件权限可以是read、write、delete、readlink 和execute。

带有 getActions()方法的 Java 文件权限示例:

在下面的例子中，我们正在创建一个具有读取、删除和写入权限的文件myfile.txt。之后，我们使用getActions()方法检查给定文件的权限。

package studytonight;
import java.io.FilePermission;
public class StudyTonight 
{
	public static void main(String args[])
	{
		 FilePermission fp_obj = new FilePermission("myfile.txt", "read, delete, write"); 
		 System.out.print("File permissions for myfile.txt: "+fp_obj.getActions());
	}
}

【myfile.txt 文件权限:读、写、删除

带有 hashCode()方法的 Java 文件权限示例

在下面的例子中，我们为 FilePermission 对象生成 hashCode，该对象作为参数传递给这个函数。

package studytonight;
import java.io.FilePermission;
public class StudyTonight 
{
	public static void main(String args[])
	{
		FilePermission obj=new FilePermission("myfile.txt", "read, delete, write");   
		int hashCode = obj.hashCode(); 
		System.out.println("hashCode value of obj: " + hashCode); 
	}
}

obj 的 hashCode 值:1700113143

结论

在本教程中，我们学习了 Java 中的 FilePermission 类。FilePermission类用于表示对文件或目录的访问。所有权限都与路径相关。

Java `Writer`类

原文：https://www.studytonight.com/java-file-io/java-writer-class

在本教程中，我们将学习 Java 中的Writer类。这个类是java.io包的抽象类，所以我们不直接使用。我们可以使用它的子类。

作家的子类

缓冲区输出
类
FileWriter
StringWriter

构造器

对于Write 类，我们可以实现下面给出的两种类型的构造器变量。

构造器	描述
`protected Writer()`	它创建了一个新的字符流编写器，其关键部分将与编写器本身同步。
`protected Writer(Object lock)`	它创建一个新的字符流编写器，其关键部分将在给定的对象上同步。

写作课的方法

Writer 类支持的所有方法如下。

方法	描述
`Writer append(char c)`	它将指定的字符追加到该编写器中。
`Writer append(CharSequence csq)`	它将指定的字符序列附加到这个编写器
`Writer append(CharSequence csq, int start, int end)`	它将指定字符序列的子序列附加到这个编写器。
`abstract void close()`	它关闭了溪流，先冲洗它。
`abstract void flush()`	它冲向溪流。
`void write(char[] cbuf)`	它写一个字符数组。
`abstract void write(char[] cbuf, int off, int len)`	它写入字符数组的一部分。
`void write(int c)`	它只写一个字符。
`void write(String str)`	它写一个字符串。
`void write(String str, int off, int len)`	它写入字符串的一部分。

例 1

在这个例子中，我们使用FileWriter 类创建了一个Writer 对象。该写操作将把数据写入output.txt文件。以验证我们检查了文件并匹配了内容。

package studytonight;
import java.io.FileWriter;
import java.io.Writer;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			Writer writer = new FileWriter("E:\\studytonight\\output.txt");  
			writer.write("Hello Studytonight");  
			writer.close();  
			System.out.println("Content is written to the file successfully...");
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

内容成功写入文件...

输出. txt

Hello Studytonight

例 2

在下面的示例中，我们实现了如何向编写器追加 CharSequence。在追加该字符序列后，我们可以发现在输出中也添加了一个额外的字符串。

package studytonight;
import java.io.FileWriter;
import java.io.Writer;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			Writer writer = new FileWriter("E:\\studytonight\\output.txt");    			
			CharSequence char_seq = "Hello";
			//append method to append CharSequence
			writer.append(char_seq);
			writer.write("Hello Studytonight");
			writer.close();  
			System.out.println("Content is written to the file successfully...");
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

内容成功写入文件...

输出. txt

HelloHello Studytonight

结论

在本教程中，我们学习了Writer 课。对于这个类，大多数子类将覆盖这里定义的一些方法，以提供更高的效率和/或功能。

Java 字符流类

Java `FilterReader`

原文：https://www.studytonight.com/java-file-io/java-filterreader

在本教程中，我们将学习 Java 中的FilterReader 。FilterReader 类用于对读取器流执行过滤操作。这是一个基类，当我们试图实现自己的自定义过滤方法进行阅读时。这个类覆盖了Reader 类的所有方法。如果我们扩展这个类，那么我们将自动扩展一个 Reader 类。

构造器

FilterReader 类的构造器如下所示:

构造器	描述
`protected FilterReader(Reader in)`	它会创建一个新的过滤读取器。

方法

FilterReader类的所有方法如下:

方法	描述
`void close()`	此方法关闭流并释放与其关联的任何系统资源。
`void mark(int readAheadLimit)`	此方法标记流中的当前位置。
`boolean markSupported()`	此方法告知此流是否支持 mark()操作。
`boolean ready()`	这个方法告诉这个流是否准备好被读取。
`int read()`	此方法读取单个字符。
`int read(char[] cbuf, int off, int len)`	此方法将字符读入数组的一部分。
`void reset()`	此方法重置流。
`long skip(long n)`	此方法跳过字符。

FilterReader 类的示例

在下面的示例中，我们实现了 FilterReader 类的 read()方法来从文件中读取数据。这里我们使用的方法没有修改，所以我们将得到与文本文件中相同的结果。在下一个示例中，我们将看到如何定制 read 方法，以便按照我们的要求以特定的格式读取数据。

package studytonight;
import java.io.FileReader;
import java.io.FilterReader;
import java.io.Reader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			Reader reader = new FileReader("E:\\studytonight\\output.txt");  
			FilterReader filterReader = new FilterReader(reader) {};  
			int i;  
			while ((i = filterReader.read()) != -1) {  
				System.out.print((char) i);  
			}  
			filterReader.close();  
			reader.close();  
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

你好，今晚学习

输出. txt

Hello Studytonight

FilterReader 类的示例

在本例中，我们将看到如何通过覆盖类中的方法来将修改应用于 FilterReader 类的方法。这里我们将覆盖 read 方法，每当出现 ``' ' (空格)时，它将返回 '*' (星号)符号。为此，我们首先声明了 MyReader 类，并继承了 FilterReader 类，然后我们覆盖了上面提到的逻辑的读取方法。在输出中，我们可以看到每当出现空格时，它都会返回星号。

package studytonight;
import java.io.FileReader;
import java.io.FilterReader;
import java.io.IOException;
import java.io.Reader;
class MyReader extends FilterReader
{
	protected MyReader(Reader in) 
	{
		super(in);
	}

	public int read() throws IOException
	{  
		int x = super.read();  
		if ((char) x == ' ')  
			return ('*');  
		else  
			return x;  
	}  	
}

public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			Reader reader = new FileReader("E:\\studytonight\\output.txt");  
			MyReader filterReader = new MyReader(reader);  
			int i;  
			while ((i = filterReader.read()) != -1) {  
				System.out.print((char) i);  
			}  
			filterReader.close();  
			reader.close();  
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

你好*今晚学习

输出. txt

Hello Studytonight

FilterReader 类的示例

在这个例子中，我们实现了FIlterReader 类的各种方法。在这里，我们最初使用 StringReader 类创建了一个读取器。然后通过使用FilterReader 类的 skip()方法，它将跳过读取前 8 个字符，并指向第 9 个字符，这就是为什么当我们试图读取时，它将从第 9 个字符开始。我们可以使用ready()方法来检查读者是否准备好阅读。在程序中，我们从第 9 个位置开始向前读取 8 个字符，然后在调用 reset()方法后指针将回到初始位置。我们可以看到，当我们在重置方法后读取数据时，它会从头开始显示。

package studytonight;
import java.io.FilterReader;
import java.io.Reader;
import java.io.StringReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			Reader reader = new StringReader("Welcome to Studytonight"); 
			FilterReader filterReader = new FilterReader(reader){}; 
			char ch[] = new char[28]; 		
			filterReader.skip(8); 
			if(filterReader.ready()) 
			{ 
				filterReader.read(ch); 
				for (int i = 0; i < 8; i++)  
				{ 
					System.out.print(ch[i]); 
				} 
				System.out.print("\n");		

				filterReader.reset(); 
				for (int i = 0; i <7; i++) 
				{ 
					System.out.print((char)filterReader.read()); 
				} 
			} 
			filterReader.close(); 
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

学习
欢迎

结论

在本教程中，我们学习了FilterReader方法。FilterReader 类用于对读取器流执行过滤操作。这是一个基类，当我们试图实现自己的自定义过滤方法进行阅读时。

Java `FilterWriter`

原文：https://www.studytonight.com/java-file-io/java-filterwriter

在本教程中，我们将学习 Java 中的FilterWriter 类。FilterWriter 类是一个抽象类，这意味着我们不能实例化这个类。这个类的主要目的是编写过滤后的字符流。这个类提供了各种方法，将所有请求传递给包含的流。FilterWriter 方法的子类应该随时随地覆盖它的方法，以提供更多的功能。

语法:

FilterWriter 类是抽象类，这个类扩展了Writer 类。

public abstract class FilterWriter extends Writer

FilterWriter 构造器

FilterWriter 类的所有构造器如下表所示。

构造器	描述
`protected FilterWriter(Writer out)`	它创建一个`InputStream`类对象。

`FilterWriter`方法

下表列出了 FilterWriter 类的所有方法。

FilterWriter 示例

在本例中，我们使用了 FilterWriter 类的内置 write()函数，而没有通过覆盖它来添加任何额外的功能。首先我们创建了一个 FileWriter 的对象，然后我们使用 FilterWriter 在文件中写入数据，因为我们没有添加任何自定义方法，所以它会正常地在文件中写入数据。我们可以检查 output.txt 文件中的数据，它与我们提供的相同。

package studytonight;
import java.io.FileWriter;
import java.io.FilterWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			FileWriter fileWriter = new FileWriter("E:\\studytonight\\output.txt");         
			FilterWriter filterWriter = new FilterWriter(fileWriter) {};             
			filterWriter.write("Hello Studytonight");  
			filterWriter.close();  
			System.out.println("Data is written to the file successfully...");
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

数据成功写入文件...

输出. txt

Hello Studytonight

在上面的程序中，我们按原样实现了 FilterWriter 类的 write()方法，现在是时候通过定制来实现了。

FilterWriter 示例

在下面的例子中，我们实现了一个自定义的write()方法，而不是使用内置的方法，为此我们创建了一个单独的类，该类扩展了一个FilterWriter ，然后我们覆盖了 write 方法，它将以大写形式编写文本，而不考虑它的实际大小写。这里我们提供了文本“你好今晚研究”，但它将写“你好今晚研究”，我们可以从文件中的输出数据来验证它。

package studytonight;
import java.io.FileWriter;
import java.io.FilterWriter;
import java.io.IOException;
import java.io.Writer;
class MyFilter extends FilterWriter 
{  
	MyFilter(Writer out)
	{  
		super(out);  
	}  
	public void write(String str) throws IOException
	{  
		super.write(str.toUpperCase());  
	}  
}  
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			FileWriter fileWriter = new FileWriter("E:\\studytonight\\output.txt");         
			MyFilter customFilterWriter = new MyFilter(fileWriter);             
			customFilterWriter.write("Hello Studytonight");  
			customFilterWriter.close();  
			System.out.println("Data is written to the file successfully...");
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

数据成功写入文件...

输出. txt

HELLO STUDYTONIGHT

结论

在本教程中，我们学习了FilterWriter 类及其方法。FilterWriter 类是一个抽象类，这意味着我们不能实例化这个类。这个类的主要目的是编写过滤后的字符流。

Java `PushbackReader`类

原文：https://www.studytonight.com/java-file-io/java-pushbackreader-class

在本教程中，我们将学习 Java 中的PushbackReader 类。这个类是一个字符流类，它允许将字符推回到流中。这个类的 unread()方法允许我们推回字符。

句法

这是PushbackReader 类的语法声明，这个类扩展了FilterReader 类。

public class PushbackReader extends FilterReader

推送`Reader`类构造器

下表给出了推送Reader类的构造器:

构造器	描述
`PushbackReader(Reader in)`	这将创建一个新的带有一个字符推送缓冲区的推送读取器。
`PushbackReader(Reader in, int size)`	这将创建一个带有给定大小的推回缓冲区的新推回读取器。

推送`Reader`类方法

下表给出了该类的所有方法。

方法	描述
`int read()`	此方法用于读取单个字符。
`void mark(int readAheadLimit)`	此方法用于标记流中的当前位置。
`boolean ready()`	此方法用于判断流是否准备好被读取。
`boolean markSupported()`	此方法用于判断流是否支持 mark()操作。
`long skip(long n)`	此方法用于跳过字符。
`void unread (int c)`	此方法用于通过将字符复制到推回缓冲区来推回字符。
`void unread (char[] cbuf)`	此方法用于通过将字符数组复制到推回缓冲区来推回该数组。
`void reset()`	此方法用于重置流。
`void close()`	此方法用于关闭流。

推送`Reader`类示例

在下面给出的例子中，我们讨论的是read() 和skip()方法。这里我们可以看到，我们有一个字符串，使用这个字符串的字符串读取器，我们创建了一个推回Reader类的对象。现在我们应用read()方法从字符串中读取每个字符，但是我们也实现了skip()方法，因此它将打印替代字符。

package studytonight;
import java.io.PushbackReader;
import java.io.StringReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{  
			String str = "Hello Studytonight"; 
			StringReader reader = new StringReader(str); 
			PushbackReader pushbackReader = new PushbackReader(reader); 
			System.out.println("pushbackReader ready: " + pushbackReader.ready()); 
			for (int i = 0; i < 9; i++) 	
			{ 
				char ch = (char) pushbackReader.read(); 
				System.out.print(ch); 
				pushbackReader.skip(1); 
			} 
		}
		catch (Exception e)	{  
			System.out.print("Error: "+e.toString());
		}  
	}
}

pushbalreader 就绪:true
hlosyoih

推送`Reader`类示例

在这个例子中，我们实现了推回Reader类的 unread()方法，这里我们读取的前 5 个字符与我们在上面的文章中读取的相同。从字符串中读取 7 个字符后，我们使用未读方法推送 s，当我们尝试使用 read()方法读取一个新字符时，它将返回相同的字符。

package studytonight;
import java.io.PushbackReader;
import java.io.StringReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		String str = "Student of this class";
		StringReader reader = new StringReader(str);
		PushbackReader pushbackReader = new PushbackReader(reader, 20);
		try 
		{
			for (int i = 0; i < 7; i++)
			{
				char ch = (char) pushbackReader.read();
				System.out.print("" + ch);
			}
			pushbackReader.unread('s');
			char ch = (char) pushbackReader.read();
			System.out.println("" + ch);
			pushbackReader.close();
		}			
		catch (Exception e)	
		{  
			System.out.print("Error: "+e.toString());
		}  
	}
}

学生

Java `Reader`类

原文：https://www.studytonight.com/java-file-io/java-reader-class

在本教程中，我们将学习 Java 中的Reader类。这是一个抽象类，对于读取字符流非常有用。我们不能直接使用这个类，但是这个类的子类非常有用。

读者类的子类

类
类
档案管理员
档案管理员
StringReader

构造器

下面给出了这个类的构造器的所有变体。

构造器	描述
`protected Reader()`	它创建了一个新的字符流读取器，其关键部分将在读取器上同步。
`protected Reader(Object lock)`	它创建了一个新的字符流读取器，其关键部分将在给定的对象上同步。

方法

Reader 类支持的方法如下。

方法	描述
`abstract void close()`	此方法关闭流并释放与其关联的任何系统资源。
`void mark(int readAheadLimit)`	此方法标记流中的当前位置。
`boolean markSupported()`	此方法告知此流是否支持 mark()操作。
`int read()`	此方法读取单个字符。
`int read(char[] cbuf)`	此方法将字符读入数组。
`abstract int read(char[] cbuf, int off, int len)`	此方法将字符读入数组的一部分。
`int read(CharBuffer target)`	此方法尝试将字符读入指定的字符缓冲区。
`boolean ready()`	这个方法告诉这个流是否准备好被读取。
`void reset()`	此方法重置流。
`long skip(long n)`	此方法跳过字符。

例子

在下面的例子中，我们使用Reader 类读取数据。首先，我们使用FileReader类创建了一个读取器对象，然后使用 read()方法读取数据。

package studytonight;
import java.io.FileReader;
import java.io.Reader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{   			
			Reader reader = new FileReader("E:\\studytonight\\output.txt");  
			int data = reader.read();  
			while (data != -1) {  
				System.out.print((char) data);  
				data = reader.read();  
			}  
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

你好，今晚学习

输出. txt

Hello Studytonight

使用`Reader`类读取字符数组

在下面的示例中，我们使用 read()方法从文件中读取数据，该方法接受 char 数组作为具有起始偏移量和长度的参数。基本上，我们读取数据并将其存储在字符数组中。

package studytonight;
import java.io.FileReader;
import java.io.Reader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{   			
			Reader reader = new FileReader("E:\\studytonight\\output.txt");  
			char[] array = new char[128];
			int charsRead = reader.read(array, 0, array.length);
			while(charsRead != -1) {
			    System.out.println(new String(array, 0, charsRead));
			    charsRead = reader.read(array, 0, array.length);
			}

		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

你好，今晚学习

输出. txt

Hello Studytonight

结论:

在本教程中，我们学习了 Java 中的Reader 类。这个类是所有Reader 子类的基类。这个类像输入流一样工作，唯一的区别是它是基于字符的，而不是基于字节的。

Java `FileWriter`类

原文：https://www.studytonight.com/java-file-io/java-filewriter-class

在本教程中，我们将学习 Java 中的FileWriter 类。这个类用于在文件中写入数据。这个类扩展了OutputStreamWriter。这个类提供了直接写字符串的方法，所以我们不需要将字符串转换成字节数组。

`FileWriter`类的构造器

这个类有两种不同的构造器，如下所示。

构造器	描述
`FileWriter(String file)`	此构造器创建一个新文件。它获取字符串形式的文件名。
`FileWriter(File file)`	此构造器创建一个新文件。它获取文件对象中的文件名。

`FileWriter`类的方法

下表中提到了文件写类支持的所有方法。

方法	描述
`void write(String text)`	此方法用于将字符串写入`FileWriter`。
`void write(char c)`	此方法用于将字符写入`FileWriter`。
`void write(char[] c)`	该方法用于将字符数组写入`FileWriter`。
`void flush()`	此方法用于刷新`FileWriter`的数据。
`void close()`	此方法用于关闭`FileWriter`。

例子

在下面给出的例子中，我们使用FileWriter将数据写入文件。首先我们创建一个FileWriter 类的对象，然后我们使用read()方法写数据。

package studytonight;
import java.io.FileWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try{   		
			FileWriter filewriter=new FileWriter("E:\\studytonight\\output.txt");    
			filewriter.write("Welcome to Studytonight");    
			filewriter.close(); 
			System.out.print("Data Written to the file successfully...");
		}
		catch(Exception e){
			System.out.println("Error: "+e.toString());
		}
	}
}

数据成功写入文件...

输出. txt

Welcome to Studytonight

FileWriter 类中的 getEncoding()方法示例

在下面的例子中，我们使用getEncoding()方法来检查字符编码。我们可以看到在这个例子的输出中，我们得到了UTF8 作为这个FileWriter的字符编码。如果我们不指定在这种情况下，它将显示默认编码。

package studytonight;
import java.io.FileWriter;
import java.nio.charset.Charset;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{   		
			FileWriter filewriter=new FileWriter("E:\\studytonight\\output.txt",Charset.forName("UTF8"));        
			//getting encoding of filewriter
			System.out.println("Character Encoding of filewriter is: "+filewriter.getEncoding());
			filewriter.close(); 
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

file writer 的字符编码为:UTF8

结论:

在本教程中，我们学习了 Java 中的FileWriter 类。这个类属于 java.io 包，用于在文件中写入数据。我们还学会了获取用于写入数据的编码类型。

Java `FileReader`类

原文：https://www.studytonight.com/java-file-io/java-filereader-class

在本教程中，我们将学习 Java 中的FileReader 类。这个类帮助以字符流的形式从文件中读取数据。Java FileReader 是 Java Reader 类的子类，所以有很多相同的方法。

句法

这是FileReader 类的语法声明。该类扩展了InputStreamReader 类。

public class FileReader extends InputStreamReader

`FileReader`类的构造器

构造器	描述
`FileReader(String file)`	它获取字符串中的文件名。它以读取模式打开给定的文件。如果文件不存在，它将引发 FileNotFoundException。
`FileReader(File file)`	它获取文件实例中的文件名。它以读取模式打开给定的文件。如果文件不存在，它将引发 FileNotFoundException。

`FileReader`类的方法

方法	描述
`int read()`	此方法用于返回 ASCII 形式的字符。它在文件末尾返回-1。
`void close()`	此方法用于关闭`FileReader`类。

`FileReader`类中的 read()方法示例

在下面的例子中，我们从文件中读取数据。首先我们创建了一个FileReader，然后使用read() 方法读取每个字符，并将其打印在控制台上。

package studytonight;
import java.io.FileReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{   		
			FileReader fileReader=new FileReader("E:\\studytonight\\output.txt");    
			int i;    
			while((i=fileReader.read())!=-1)    
				System.out.print((char)i);    
			fileReader.close();    
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

欢迎今晚来学习

输出. txt

Welcome to Studytonight

`FileReader`中的 getEncoding()示例

在下面的例子中，我们正在实现 getEncoding()方法，该方法可用于获取用于在文件中存储数据的编码类型。我们可以看到在这个例子的输出中，我们得到了UTF8 作为这个fileReader2的字符编码。如果我们不指定在这种情况下，它将显示默认编码。

package studytonight;
import java.io.FileReader;
import java.nio.charset.Charset;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{   		
			FileReader fileReader1 = new FileReader("E:\\studytonight\\output.txt");
			FileReader fileReader2 = new FileReader("E:\\studytonight\\output.txt", Charset.forName("UTF8"));
			System.out.println("Character encoding of fileReader1: " + fileReader1.getEncoding());
			System.out.println("Character encoding of fileReader2: " + fileReader2.getEncoding());
			fileReader1.close();
			fileReader2.close();
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

FileReader 1 的字符编码:Cp1252
FileReader 2 的字符编码:UTF8

结论:

在本教程中，我们学习了FileReader 课。这个类使得以字符流的形式读取文件的内容成为可能。此类的 getEncoding()方法用于检查文件的编码。

Java `BufferedWriter`类

原文：https://www.studytonight.com/java-file-io/java-bufferedwriter-class

在本教程中，我们将学习 Java 中的BufferedWriter 类。该类用于为Writer 实例提供缓冲。通过使用这个类，我们可以提高性能。该类维护 8192 字符的内部缓冲区。如果我们正在执行写操作，那么它会将数据存储在缓冲区中，而不是硬盘中，一旦缓冲区完全填满，它会将完整的缓冲区写入硬盘。

句法

这是BufferedWriter类的语法声明，是对Writer类的扩展。

public class BufferedWriter extends Writer

Java BufferedWriter 类构造器

这个类提供了构造器的两种变体，如下表所示。

构造器	描述
`BufferedWriter(Writer wrt)`	它用于创建使用输出缓冲区默认大小的缓冲字符输出流。
`BufferedWriter(Writer wrt, int size)`	它用于创建使用指定输出缓冲区大小的缓冲字符输出流。

Java BufferedWriter 类方法

下表给出了该表的各种方法。

方法	描述
`void newLine()`	此方法用于通过编写行分隔符来添加新行。
`void write(int c)`	此方法用于编写单个字符。
`void write(char[] cbuf, int off, int len)`	此方法用于写入字符数组的一部分。
`void write(String s, int off, int len)`	此方法用于写入字符串的一部分。
`void flush()`	此方法用于刷新输入流。
`void close()`	此方法用于关闭输入流。

Java BufferedWriter 示例

在下面的例子中，我们使用的是 Java 中BufferedWriter 类的 write() 方法。这里我们用FileWriter创建了BufferedWriter ，然后创建了 8192 个字符的默认缓冲区。这里的缓冲区将有助于更有效地向文件中写入字符。

package studytonight;
import java.io.BufferedWriter;
import java.io.FileWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			FileWriter writer = new FileWriter("E:\\studytonight\\output.txt");  
			BufferedWriter buffer = new BufferedWriter(writer);  
			buffer.write("Hello Studytonight");  
			buffer.close();  
			System.out.println("Data is written to the file successfully..."); 
		}
		catch(Exception e)
		{
			System.out.print(false);
		}
	}
}

数据成功写入文件...

输出. txt

Hello Studytonight

Java BufferedWriter 示例

在这个例子中，我们实现了一个public void write(String arg, int offset, int length)，这里第一个参数arg 是一个要写入文件内部的字符串，offset 是一个索引，从这里我们将开始写入文件，length 是要写入的字符串的字符数。这个方法不返回值。

package studytonight;
import java.io.BufferedWriter;
import java.io.FileWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			FileWriter writer = new FileWriter("E:\\studytonight\\output.txt");  
			BufferedWriter buffer = new BufferedWriter(writer);  
			String str = "Hello Studytonight"; 
            buffer.write(str,5,str.length()-5); 
			buffer.close();  
			System.out.println("Data is written to the file successfully..."); 
		}
		catch(Exception e)
		{
			System.out.print(false);
		}
	}
}

数据成功写入文件...

输出. txt

 Studytonight

结论

在本教程中，我们学习了 Java 中的BufferedWriter 类。java.io 包的 BufferedWriter 类可以与其他编写器一起使用，以更高效地写入数据。

Java `BufferedReader`类

原文：https://www.studytonight.com/java-file-io/java-bufferedreader-class

在本教程中，我们将学习 Java 中的BufferedReader 类。这个类从字符输入流中读取文本。它在读取时将字符存储在缓冲区中，因此读取过程变得更加高效。我们可以指定缓冲区大小，否则，它将采用默认大小。

句法

这是BufferedReader 类 snd 的语法声明，这个类扩展了Reader 类。

public class BufferedReader extends Reader

Java `BufferedReader`类类构造器

构造器	描述
`BufferedReader(Reader rd)`	它用于创建使用输入缓冲区默认大小的缓冲字符输入流。
`BufferedReader(Reader rd, int size)`	它用于创建使用输入缓冲区指定大小的缓冲字符输入流。

Java `BufferedReader`类类方法

下面给出了 BufferedReader 类支持的所有方法。

方法	描述
`int read()`	此方法用于读取单个字符。
`int read(char[] cbuf, int off, int len)`	该方法用于将字符读入数组的一部分。
`boolean markSupported()`	此方法用于测试标记和重置方法的输入流支持。
`String readLine()`	此方法用于读取一行文本。
`boolean ready()`	此方法用于测试输入流是否准备好被读取。
`long skip(long n)`	此方法用于跳过字符。
`void reset()`	此方法将流重新定位在此输入流上最后一次调用 mark 方法的位置。
`void mark(int readAheadLimit)`	此方法用于标记流中的当前位置。
`void close()`	此方法关闭输入流并释放与该流关联的任何系统资源。

缓冲恐惧者示例

在本例中，我们使用read()方法从流中读取字符。这个方法一次读取一个字符，如果流的结尾到达，那么它将返回-1。在这里，我们将从流中读取，直到它到达末尾。我们一个接一个地读取字符，并在控制台上打印。当我们到达流的末尾时，我们停止循环。

package studytonight;
import java.io.BufferedReader;
import java.io.FileReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			FileReader fileReader=new FileReader("E:\\studytonight\\output.txt");    
			BufferedReader br=new BufferedReader(fileReader);    
			int i;    
			while((i=br.read())!=-1){  
				System.out.print((char)i);  
			}  
			br.close();    
			fileReader.close();    
		}
		catch(Exception e)
		{
			System.out.print(false);
		}
	}
}

这是一篇课文。

输出. txt

This is a text.

BufferedReader 中的`readLine()`方法示例

在这个例子中，我们实现了readLine()方法，这个方法读取一行文本。在此，该线被考虑直到'\n'或'\r' 发生。如果我们到达一个流的末尾，它将返回一个null 值。

package studytonight;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			BufferedReader reader =new BufferedReader(new InputStreamReader(System.in));
			System.out.println("Enter your name: ");
			String name = reader.readLine();   
			System.out.println("Hello "+name);
		}
		catch(Exception e)
		{
			System.out.print(false);
		}
	}
}

输入你的名字:
Java
你好 Java

结论

在本教程中，我们学习了 Java 中的BufferedReader 类。这个类从字符输入流中读取文本。它在读取时将字符存储在缓冲区中，因此读取过程变得更加高效。BufferedReader 类维护一个 8192 个字符的内部缓冲区。

Java `CharArrayReader`类

原文：https://www.studytonight.com/java-file-io/java-chararrayreader-class

在本教程中，我们将学习 Java 中的CharArrayReader 类。这个类使用字符数组创建一个字符缓冲区。该类提供了mark()、 read()、close(), reset()、 markSupported()、skip()和ready()等多种方法

句法

这是 Java 中CharArrayReader 类的语法声明。我们可以看到这个类继承了Reader 类。

public class CharArrayReader extends Reader

Java CharArrayReader 类方法

CharAraayReader 类的所有方法如下表所示

方法	描述
`int read()`	此方法用于读取单个字符
`int read(char[] b, int off, int len)`	此方法用于将字符读入数组部分。
`boolean ready()`	此方法用于判断流是否准备好读取。
`boolean markSupported()`	此方法用于判断流是否支持 mark()操作。
`long skip(long n)`	此方法用于跳过输入流中的字符。
`void mark(int readAheadLimit)`	此方法用于标记流中的当前位置。
`void reset()`	此方法用于将流重置为最近的标记。
`void close()`	此方法用于关闭流。

CharArrayReader 类示例

在下面的例子中，我们使用CharArrayReader 类实现read() 方法。我们从小溪中一个一个地读一个字，直到它到达小溪的尽头，小溪的尽头将是-1。

package studytonight;
import java.io.CharArrayReader;
public class StudyTonight 
{
	public static void main(String args[]) throws Exception
	{
		char[] arr = { 's', 't', 'u', 'd', 'y', 't', 'o', 'n', 'i', 'g', 'h', 't' };  
		CharArrayReader reader = new CharArrayReader(arr);  
		int ch = 0;  
		while ((ch = reader.read()) != -1) {  
			System.out.print((char)ch);  
		}  
	}
}

今晚学习

CharArrayReader 类示例

在下面的例子中，我们将实现mark(), reset()和markSupported()方法，这里 read 方法将读取一个字符并将其打印在屏幕上。然后使用 mark()方法标记特定位置的点，并使用markSupported()方法检查我们的位置是否被标记，使用 reset 方法流将重新定位我们标记位置的位置，并再次从该点提供值。

package studytonight;
import java.io.CharArrayReader;
public class StudyTonight 
{
	public static void main(String args[]) throws Exception
	{
		char[] arr = { 's', 't', 'u', 'd', 'y', 't', 'o', 'n', 'i', 'g', 'h', 't' };  
		CharArrayReader reader = new CharArrayReader(arr);  

		System.out.println("Element : "+(char)reader.read()); 
		System.out.println("Element : "+(char)reader.read()); 
		System.out.println("Element : "+(char)reader.read()); 
		reader.mark(0);          
		System.out.println("Element : "+(char)reader.read()); 
		System.out.println("Element : "+(char)reader.read());       

		if (reader.markSupported()) 
		{ 
			System.out.println("\nmark() is supported\n"); 
			reader.reset(); 
			System.out.println("Element : "+(char)reader.read()); 
			System.out.println("Element : "+(char)reader.read()); 
		} 
		else
		{
			System.out.println("mark() method not supported."); 
		}	
	}
}

元素:s
元素:t
元素:u
元素:d
元素:y

标记()被支持

元素:d
元素:y

结论

在本教程中，我们学习了 Java 中的CharArrayReader 类。CharArrayReader 类使用字符数组创建字符缓冲区。

使用mark()方法，我们可以设置位置，只要需要，我们就可以从该位置开始阅读。稍后，我们只能从这一点开始读取数据。

Java `CharArrayWriter`类

原文：https://www.studytonight.com/java-file-io/java-chararraywriter-class

在本教程中，我们将学习 Java 中的CharArrayWrite 类。此类创建一个用于写入数据的缓冲区。该缓冲区没有固定大小，当数据写入流时，它会自动增长。还有其他方法，如toCharArray()和toString()从缓冲区中检索数据。

句法

这是 CharArrayWriter 类的语法。

public class CharArrayWriter extends Writer

Java CharArrayWriter 类方法

CharArrayWriter 类的方法如下表所示。

方法	描述
`int size()`	此方法用于返回缓冲区的当前大小。
`char[] toCharArray()`	此方法用于返回输入数据的副本。
`String toString()`	此方法用于将输入数据转换为字符串。
`CharArrayWriter append(char c)`	此方法用于将指定的字符追加到编写器中。
`CharArrayWriter append(CharSequence csq)`	此方法用于将指定的字符序列附加到编写器。
`CharArrayWriter append(CharSequence csq, int start, int end)`	此方法用于将指定字符的子序列附加到编写器。
`void write(int c)`	此方法用于将字符写入缓冲区。
`void write(char[] c, int off, int len)`	此方法用于将字符写入缓冲区。
`void write(String str, int off, int len)`	此方法用于将字符串的一部分写入缓冲区。
`void writeTo(Writer out)`	此方法用于将缓冲区的内容写入不同的字符流。
`void flush()`	此方法用于冲洗流。
`void reset()`	此方法用于重置缓冲区。
`void close()`	此方法用于关闭流。

CharArrayWriter 类示例

在下面的例子中，我们使用CharArrayWriter 类操作来实现写操作。这里我们首先创建了 CharArrayWriter 类的一个对象。然后我们创建一个 FileWriter 类的对象，并使用 writeTo()方法将数据写入文件。

package studytonight;
import java.io.CharArrayWriter;
import java.io.FileWriter;
public class StudyTonight 
{
	public static void main(String args[]) throws Exception
	{
		CharArrayWriter writer=new CharArrayWriter();    
		writer.write("Hello Studytonight");    
		FileWriter fileWriter=new FileWriter("E:\studytonight\\output.txt");   
		writer.writeTo(fileWriter);    
		fileWriter.close();    
		System.out.println("Data is written to the file successfully...");    
	}
}

数据成功写入文件...

输出. txt

Hello Studytonight

CharArrayWriter 类示例

在这个例子中，我们正在实现public void write(String str, int offset, int length)方法。这里 str 是我们想要写入的字符串，offset 是字符串中的起始索引，length 是要从字符串中写入的字符数。我们可以在下面的程序中看到，我们正在使用toString()方法从CharArrayWriter 中提取字符串。

package studytonight;
import java.io.CharArrayWriter;
public class StudyTonight 
{
	public static void main(String args[]) throws Exception
	{
		CharArrayWriter writer = new CharArrayWriter(); 
		String str = "Hello Studytonight"; 
		writer.write(str, 6, 12);
		System.out.println(writer.toString()); 
	}
}

今晚学习

结论:

在本教程中，我们学习了 CharArrayWriter 类，这个类可以用来将公共数据写入多个文件。此类创建一个用于写入数据的缓冲区。该缓冲区没有固定大小，当数据写入流时，它会自动增长。

Java `PrintStream`类

原文：https://www.studytonight.com/java-file-io/java-printstream-class

在本教程中，我们将学习 Java 中的PrintStream 类。这个类提供了各种将数据写入另一个流的方法。此类将原始数据转换为文本格式，并将其写入输出流。

与其他输出流不同，a PrintStream 从不抛出IOException；或者，特殊情况设置一个内部标志，可以通过checkError 方法进行测试。

句法

这是PrintStream 类的语法声明。

public class PrintStream extends FilterOutputStream implements Closeable. Appendable

`PrintStream`类的方法

方法	描述
`void print(boolean b)`	它打印指定的布尔值。
`void print(char c)`	它打印指定的字符值。
`void print(char[] c)`	它打印指定的字符数组值。
`void print(int i)`	它打印指定的 int 值。
`void print(long l)`	它打印指定的长值。
`void print(float f)`	它打印指定的浮点值。
`void print(double d)`	它打印指定的双精度值。
`void print(String s)`	它打印指定的字符串值。
`void print(Object obj)`	它打印指定的对象值。
`void println(boolean b)`	它打印指定的布尔值并终止该行。
`void println(char c)`	它打印指定的字符值并终止该行。
`void println(char[] c)`	它打印指定的字符数组值并结束该行。
`void println(int i)`	它打印指定的 int 值并终止该行。
`void println(long l)`	它打印指定的长值并终止该行。
`void println(float f)`	它打印指定的浮点值并终止该行。
`void println(double d)`	它打印指定的双精度值并终止该行。
`void println(String s)`	它打印指定的字符串值并终止该行。
`void println(Object obj)`	它打印指定的对象值并终止该行。
`void println()`	它仅终止该行。
`void printf(Object format, Object... args)`	它将格式化的字符串写入当前流。
`void printf(Locale l, Object format, Object... args)`	它将格式化的字符串写入当前流。
`void format(Object format, Object... args)`	它使用指定的格式将格式化的字符串写入当前流。
`void format(Locale l, Object format, Object... args)`	它使用指定的格式将格式化的字符串写入当前流。

PrintStream println()方法示例

在下面给出的程序中，我们正在从PrintStream 类中实现println() 方法，该方法将打印数据。我们有两种变化不大的方法:

print() -该方法将给定的数据打印到输出流中。

println() -该方法将数据打印到输出流中，并将新行添加到输出的末尾。

在下面的程序中，我们没有创建PrintStream 类的实例，但是我们可以直接调用PrintStream 类的 print()方法。原因是System 是最后一个班，在那里PrintStream 型被宣布出局。

package studytonight;
public class StudyTonight 
{
	public static void main(String args[])
	{
		System.out.println("Hello Studytonight"); 
	}
}

你好，今晚学习

`PrintStream`打印()方法示例

在下面的例子中，我们创建了一个PrintStream 类的对象，这个流将存储在提供的文件中。使用 PrintStream 类的对象调用 print()方法后，它会将数据存储到给定的文件中。我们可以看到 output.txt 的内容，并验证它是否按预期工作。

package studytonight;
import java.io.PrintStream;
public class StudyTonight 
{
	public static void main(String args[])
	{
		String str = "Welcome to studytonight.com";
		try
		{
			PrintStream obj= new PrintStream("E:\\studytonight\\output.txt");
			obj.print(str);
			obj.close();
			System.out.print("Data is written to the file successfully...");
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

数据成功写入文件...

输出. txt

Welcome to studytonight.com

`PrintStream`示例

在给定的例子中，我们实现了一个带有两个参数的print()方法，第一个参数是格式化的字符串，第二个参数是一个值。在本例中%d将被12 取代，数据将作为I have 12 apples.写入文件。这种技术被称为格式化输出。

package studytonight;
import java.io.PrintStream;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			PrintStream output = new PrintStream("E:\\studytonight\\output.txt");
			int num = 12;
			output.printf("I have %d apples.", num);
			output.close();
			System.out.print("Data is written to the file successfully...");
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

数据成功写入文件...

输出. txt

I have 12 apples.

结论

在本教程中，我们学习了 Java 中的 PrintStream 类。这个类提供了各种将数据写入另一个流的方法。此类将原始数据转换为文本格式，并将其写入输出流。

Java `PrintWriter`类

原文：https://www.studytonight.com/java-file-io/java-printwriter-class

在本教程中，我们将学习 Java 中的PrintWriter 类。此类用于将对象的格式化表示写入文本输出流。这个类将原始数据转换成文本格式，然后将转换后的数据写入编写器。

句法

这是PrintWriter类的语法。该类扩展了Writer类。

public class PrintWriter extends Writer

PrintWriter 类的方法

下表给出了 PrintWriter 类支持的所有方法。

方法	描述
`void println(boolean x)`	此方法用于打印布尔值。
`void println(char[] x)`	此方法用于打印字符数组。
`void println(int x)`	此方法用于打印整数。
`PrintWriter append(char c)`	此方法用于将指定的字符追加到编写器中。
`PrintWriter append(CharSequence ch)`	此方法用于将指定的字符序列附加到编写器。
`PrintWriter append(CharSequence ch, int start, int end)`	此方法用于向编写器追加指定字符的子序列。
`boolean checkError()`	此方法用于刷新流并检查其错误状态。
`protected void setError()`	此方法用于指示发生了错误。
`protected void clearError()`	此方法用于清除流的错误状态。
`PrintWriter format(String format, Object... args)`	此方法用于使用指定的参数和格式字符串向编写器写入格式化字符串。
`void print(Object obj)`	此方法用于打印对象。
`void flush()`	此方法用于刷新流。
`void close()`	此方法用于关闭流。

PrintWriter 示例

在这个例子中，我们在控制台上写数据。首先我们创建了一个PrintWriter 类的对象，通过将System.in作为参数传递给 c，然后通过使用这个对象，我们调用这个类的write()方法，数据将被打印在控制台上。

package studytonight;
import java.io.PrintWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		PrintWriter writer = new PrintWriter(System.out);    
		writer.write("Welcome to Studytonight");        
		writer.flush();  
		writer.close();  
	}
}

欢迎今晚来学习

PrintWriter 示例

在这个例子中，我们在 PrintWriter 类的帮助下向文件中写入数据。这个例子类似于上面的例子，但是在创建PrintWriter 类的对象时，我们在构造器中传递了一个文件。之后write()方法会将数据写入提供的文件中。

package studytonight;
import java.io.File;
import java.io.PrintWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			PrintWriter writer= new PrintWriter(new File("E:\\studytonight\\output.txt"));  
			writer.write("Hello World");                                                   
			writer.flush();  
			writer.close();  
			System.out.println("Data is written to the file successfully...");
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

数据成功写入文件...

输出. txt

Hello World

结论

在本教程中，我们学习了 Java 中的，PrintWriter 类。此类用于将对象的格式化表示写入文本输出流。这个类将原始数据转换成文本格式，然后将转换后的数据写入编写器。

Java `OutputStreamWriter`

原文：https://www.studytonight.com/java-file-io/java-outputstreamwriter

在本教程中，我们将学习 Java 中的OutputStreamWriter 类。此类属于java.io套餐。这个类也被称为字节流和字符流之间的桥梁，因为这个类将其字符转换成字节。

构造器

下表给出了此类构造器的所有变体。

方法

下表给出了 OutputStreamWriter 类的所有方法。

方法	描述
`void close()`	它关闭了溪流，先冲洗它。
`void flush()`	它冲向溪流。
`String getEncoding()`	它返回该流使用的字符编码的名称。
`void write(char[] cbuf, int off, int len)`	它写入字符数组的一部分。
`void write(int c)`	它只写一个字符。
`void write(String str, int off, int len)`	它写入字符串的一部分。

OutputStreamWriter 的示例。

在下面的方法中，我们使用 OutputStreamWriter 类将数据写入文件，同时创建这个类的对象，我们将流作为参数传递给构造器，然后使用 write 方法将字符写入文件。

package studytonight;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			OutputStream stream = new FileOutputStream("E:\\studytonight\\output.txt"); 
			OutputStreamWriter streamWriter = new OutputStreamWriter(stream);            
			streamWriter.write(65); 
			streamWriter.write(66); 
			streamWriter.write(67); 
			streamWriter.write(68); 
			streamWriter.write(69);    
			streamWriter.flush();            
			streamWriter.close(); 
			System.out.println("Data is written to the file successfully...");
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

数据成功写入文件...

ABCDE

输出流编写器示例

在下面的例子中，我们实现了write()方法的重载方法。在方法 write(char[] str，int offset，int len)中，str 是我们想要写入的字符串，offset 是它将要写入的起始位置，last parameter len 是它将要写入的字符串的长度。

package studytonight;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			OutputStream stream = new FileOutputStream("E:\\studytonight\\output.txt"); 
			OutputStreamWriter streamWriter = new OutputStreamWriter(stream);            
			String str="Hello Studytonight";
			streamWriter.write(str, 6, 12);    
			streamWriter.flush();            
			streamWriter.close(); 
			System.out.println("Data is written to the file successfully...");
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

数据成功写入文件...

输出. txt

Studytonight

结论

在本教程中，我们学习了 Java 中的OutputStreamWriter 类。这个类也被称为字节流和字符流之间的桥梁，因为这个类将其字符转换成字节。

Java `InputStreamReader`

原文：https://www.studytonight.com/java-file-io/java-inputstreamreader

在本教程中，我们将学习 Java 中的InputStreamReader 类。这个类扩展了一个抽象类Reader。这个类将数据从字节格式转换成字符。

构造器

下表给出了InputStreamReader 类支持的构造器的所有变体。

构造器	描述
`InputStreamReader(InputStream in)`	此方法创建一个使用默认字符集的 InputStreamReader。
`InputStreamReader(InputStream in, Charset cs)`	此方法创建一个使用给定字符集的 InputStreamReader。
`InputStreamReader(InputStream in, CharsetDecoder dec)`	此方法创建一个使用给定字符集解码器的 InputStreamReader。
`InputStreamReader(InputStream in, String charsetName)`	此方法创建一个使用命名字符集的 InputStreamReader。

方法

InputStreamReader 类的方法如下表所示:

方法	描述
无效关闭()	此方法关闭流并释放与其关联的任何系统资源。
String getEncoding（）	此方法返回此流使用的字符编码的名称。
int read()	此方法读取单个字符。
`int read(char[] cbuf, int offset, int length)`	此方法将字符读入数组的一部分。
布尔就绪()	这个方法告诉这个流是否准备好被读取。

例 1

在下面的例子中，我们实现了InputStreamReader 从文件中读取数据。首先，我们通过在构造器中传递文件路径，使用 FileInputStream 类创建了一个输入流。然后使用 read()方法，我们逐个读取每个字符，直到流到达末尾。当我们到达流的末尾时，它返回-1。

package studytonight;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try  {  
			InputStream stream = new FileInputStream("E:\\studytonight\\output.txt");  
			Reader reader = new InputStreamReader(stream);  
			int data = reader.read();  
			while (data != -1) {  
				System.out.print((char) data);  
				data = reader.read();  
			}  
		} catch (Exception e) {  
			System.out.print("Error: "+e.toString());
		}  
	}
}

你好，今晚学习

输出. txt

Hello Studytonight

`InputStreamReader`示例

在这个例子中，我们正在学习InputStreamReader 课的 getEncoding()方法。此方法将返回给定InputStreamReader的字符编码。如果在这种情况下没有明确提到编码，它将返回默认编码。在这个例子中，我们将编码设置为 UTF8，我们可以在输出中看到它

package studytonight;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try{  
			FileInputStream file = new FileInputStream("E:\\studytonight\\output.txt");  
			InputStreamReader reader = new InputStreamReader(file, Charset.forName("UTF8"));  			
			System.out.println("Character Encoding of the reader is: "+reader.getEncoding());
		}
		catch (Exception e)	{  
			System.out.print("Error: "+e.toString());
		}  
	}
}

读取器的字符编码为:UTF8

结论

在本教程中，我们学习了InputStreamReader 类及其方法，该类将数据从字节格式转换为字符。

Java `PushbackInputStream`类

原文：https://www.studytonight.com/java-file-io/java-pushbackinputstream-class

在本教程中，我们将学习 Java 中的PushbackInputStream c类。这个类扩展了 FilterInputStream 类，并提供了在不中断输入流的情况下“查看”输入流的机制。这个类可以读一个已经读完的字节，并推回一个字节。

句法

这是推包InputStream类的语法声明，这个类扩展了 FilterInputStream。

public class PushbackInputStream extends FilterInputStream

推回`InputStream`类方法

推回输入流方法的所有方法都可以在下表中找到:

方法	描述
`int available()`	此方法用于返回可以从输入流中读取的字节数。
`int read()`	此方法用于从输入流中读取下一个字节的数据。
`void mark(int readlimit)`	此方法用于标记输入流中的当前位置。
`long skip(long x)`	此方法用于跳过和丢弃 x 字节的数据。
`void unread(int b)`	此方法用于通过将字节复制到推回缓冲区来推回字节。
`void unread(byte[] b)`	此方法用于通过将字节数组复制到推回缓冲区来推回字节数组。
`void reset()`	此方法用于重置输入流。
`void close()`	此方法用于关闭输入流。
`boolean markSupported()`	此方法用于检查位置是否标记。

推回输入流示例

在这个例子中，我们演示了available()方法如何在推回InputStream类中工作。这里我们已经声明了打印编写器，它将在控制台上给出输出。我们还使用 ByteArrayInputStream 在输入上创建了一个流，并且在创建推回InputStream类的对象时，我们将这个流传递给了构造器。available()方法返回可以从此输入流中读取的字节数。在这个例子中，我们以18 为例，因为字符串"Hello Studytonight"是18的长度。

package studytonight;
import java.io.ByteArrayInputStream;
import java.io.PrintWriter;
import java.io.PushbackInputStream;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{  
			PrintWriter writer = new PrintWriter(System.out, true); 
			String str = "Hello Studytonight"; 
			byte arr[] = str.getBytes(); 
			ByteArrayInputStream stream = new ByteArrayInputStream(arr); 
			PushbackInputStream push = new PushbackInputStream(stream);    
			writer.println("size of available bytes: " + push.available()); 	          
			writer.close(); 
		}
		catch (Exception e)	{  
			System.out.print("Error: "+e.toString());
		}  
	}
}

可用字节大小:18

推回输入流示例

在这个例子中，我们实现了推回InputStream类的 read()方法。这个 read()方法返回一个 0 到 255 的整数，这些整数对应于字符的 ASCII 码。在这里，我们创建了一个推回InputStream类的对象，并调用读取方法，直到它到达流的末尾。

package studytonight;
import java.io.ByteArrayInputStream;
import java.io.PrintWriter;
import java.io.PushbackInputStream;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{  
			PrintWriter writer = new PrintWriter(System.out, true); 
			String str = "Hello Studytonight"; 
			byte arr[] = str.getBytes(); 
			ByteArrayInputStream stream = new ByteArrayInputStream(arr); 
			PushbackInputStream push = new PushbackInputStream(stream); 
			int ch; 
			while((ch=push.read())!=-1) 
			{ 
				writer.print((char)ch); 
			} 
			writer.println(); 
			writer.close(); 
		}
		catch (Exception e)	{  
			System.out.print("Error: "+e.toString());
		}  
	}
}

你好，今晚学习

结论

在本文中，我们学习了推回InputStream类。这个类扩展了 FilterInputStream 类，并提供了在不中断输入流的情况下“查看”输入流的机制。这个类可以读一个已经读完的字节，并推回一个字节。

Java `StringWriter`类

原文：https://www.studytonight.com/java-file-io/java-stringwriter-class

在本教程中，我们将学习 Java 中的StringWriter 类。Java StringWriter 类是一个从字符串缓冲区收集输出的字符流，可以用来构造字符串。

Java StringWriter 类声明:

这是StringWriter 类的语法声明，这个类扩展了Writer 类。

public class StringWriter extends Writer

构造器:

下表给出了 StringWriter 类的两种变体:

构造器	描述
StringWriter()	这将使用默认的初始字符串缓冲区大小创建一个新的`StringWriter`。
字符串书写器(int initialSize)	这将使用指定的初始字符串缓冲区大小创建一个新的`StringWriter`。

StringWriter 类的方法:

StringWriter 类支持的所有方法如下表所示:

方法	描述
`void write(int c)`	此方法用于编写单个字符。
`void write(String str)`	此方法用于写入字符串。
`void write(String str, int off, int len)`	此方法用于写入字符串的一部分。
`void write(char[] cbuf, int off, int len)`	此方法用于写入字符数组的一部分。
`String toString()`	此方法用于以字符串形式返回缓冲区当前值。
`StringBuffer getBuffer()`	此方法用于返回字符串缓冲区。
`StringWriter append(char c)`	此方法用于将指定的字符追加到编写器中。
`StringWriter append(CharSequence csq)`	此方法用于将指定的字符序列附加到编写器。
`StringWriter append(CharSequence csq, int start, int end)`	此方法用于将指定字符序列的子序列附加到编写器。
`void flush()`	此方法用于冲洗流。
`void close()`	此方法用于关闭流。

StringWriter 类的示例:

在这个例子中，我们将看到如何使用 StringWriter 类从文件中读取数据。从文件中读取我们使用的主要概念是，我们可以使用 toString()方法将字符串缓冲区转换为字符串。

package studytonight;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.io.StringWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			char[] arr = new char[512];  
			StringWriter writer = new StringWriter();  
			FileInputStream input = new FileInputStream("E:\\studytonight\\output.txt");    
			BufferedReader buffer =  new BufferedReader(new InputStreamReader(input, "UTF-8"));    
			int c;  
			while ((c = buffer.read(arr)) != -1) {  
				writer.write(arr, 0, c);  
			}  
			System.out.println(writer.toString());        
			writer.close();  
			buffer.close();  
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

你好，今晚学习

输出. txt

Hello Studytonight

结论:

在本教程中，我们学习了 Java 中的StringWriter 类。Java StringWriter 类是一个从字符串缓冲区收集输出的字符流，可以用来构造字符串。

Java `StringReader`类

原文：https://www.studytonight.com/java-file-io/java-stringreader-class

在本教程中，我们将学习 Java 中的StringReader 类。在这个类中，我们可以指定一个字符串作为单独读取字符的来源。此类属于java.io套餐。

句法

这是StringReader类的语法声明。我们可以看到这个类扩展了 Reader 类。

public class StringReader extends Reader

`String`类的方法

StringReader 方法的所有方法如下表所示:

方法	描述
`int read()`	此方法用于读取单个字符。
`int read(char[] cbuf, int off, int len)`	此方法用于将字符读入数组的一部分。
`boolean ready()`	此方法用于判断流是否准备好被读取。
`boolean markSupported()`	此方法用于判断流是否支持 mark()操作。
`long skip(long ns)`	此方法用于跳过流中指定数量的字符
`void mark(int readAheadLimit)`	此方法用于标记流中的当前位置。
`void reset()`	此方法用于重置流。
`void close()`	此方法用于关闭流。

Java 字符串读取器示例

在下面的例子中，我们使用的是read()方法，这个方法逐个读取字符串的每个字符。我们也可以用另一种方式实现这个方法，即read(char[] array, int start, int length)这里array是来源，start 是我们要开始阅读的起始位置，length是字符串的长度。

package studytonight;
import java.io.StringReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try{
			String str = "Hello"; 
			StringReader reader= new StringReader(str); 
			int ch; 
			for (int i = 0; i < 5; i++) { 
				ch = reader.read(); 
				System.out.print((char)ch);
			} 
			reader.close(); 
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

你好

结论

在本教程中，我们学习了StringReader 课。此类指定一个字符串作为单独读取字符的源。这个班属于java.io班。

Java `PipedWriter`类

原文：https://www.studytonight.com/java-file-io/java-pipedwriter-class

在本教程中，我们将学习 Java 中的PipedWriter类。管道意味着两个正在运行的线程之间的链接，这个类是一个管道字符输出流。如果向连接的管道输出流提供数据字节的线程不再活动，则管道被称为断开。

enlightened 注:我们把PipedWriter连接到一个PipedReader上，一般PipedWriter 和PipedReade是用不同的螺纹。

句法

这是PipedWriter类的语法声明，我们可以看到它在扩展Writer 类。

public class PipedWriter extends Writer

构造器

PipedWriter 方法构造器的所有变体如下表所示:

构造器	描述
`PipedWriter()`	它创建了一个尚未连接到管道读取器的管道编写器。
`PipedWriter(PipedReader snk)`	它创建一个连接到指定管道读取器的管道编写器。

方法

PipedWriter类的所有方法如下表所示:

方法	描述
`void close()`	此方法关闭此管道输出流，并释放与此流关联的任何系统资源。
`void connect(PipedReader snk)`	此方法将`PipedWriter`连接到接收器。
`void flush()`	此方法刷新此输出流，并强制写出所有缓冲的输出字符。
`void write(char[] cbuf, int off, int len)`	该方法将从偏移处开始的指定字符数组中的`len` 字符写入该管道输出流。
`void write(int c)`	此方法将指定的字符写入管道输出流。

Java `PipedWriter`示例

在这个例子中，我们实现了 PipedWriter 类的write()方法来写数据。首先我们创建了PipedWriter 类和PipedReader 类的对象，然后使用 connect()方法连接了这两个方法。现在我们将字符写到PipedWriter 中，并再次使用PipedReader进行阅读。

package studytonight;
import java.io.PipedReader;
import java.io.PipedWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			PipedReader reader = new PipedReader(); 
			PipedWriter writer = new PipedWriter(); 
			reader.connect(writer); 

			writer.write(72); 
			System.out.println((char)reader.read()); 
			writer.write(69); 
			System.out.println((char)reader.read()); 
			writer.write(76); 
			System.out.println( (char)reader.read());   
			writer.write(76); 
			System.out.println( (char)reader.read());   
			writer.write(79); 
			System.out.println( (char)reader.read());   
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

H
E
L
L
O

Java `PipedWriter`示例

在本例中，write()方法将指定的字符写入PipedWriter。此外，我们还有另一个重载方法write(char[] arr, int offset, int maxlen)，在这个方法中，arr 是源数组，offset 是开始写入的索引，maxlen 是要写入的字符串的长度。

package studytonight;
import java.io.PipedReader;
import java.io.PipedWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			PipedReader reader = new PipedReader(); 
			PipedWriter writer = new PipedWriter(); 
			reader.connect(writer); 
			char[] arr = {'H', 'E', 'L', 'L', 'O'}; 
			writer.write(arr, 0, 5); 
			while(true) 
			{ 
				System.out.print((char) reader.read());           
			} 
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

你好

结论:

在本教程中，我们学习了 Java 中的PipedWriter类。管道意味着两个正在运行的线程之间的链接，这个类是一个管道字符输出流。

Java `PipedReader`类

原文：https://www.studytonight.com/java-file-io/java-pipedreader-class

在本教程中，我们将学习 Java 中的PipedReader 类。PipedReader类用于读取管道的数据，该数据是字符流的格式。在实现PipedReader时，我们必须注意这必须连接到不同线程使用的PipedWriter和一般的PipedReader 和PipedWriter，而不是在同一线程上运行。

注意:清管器必须连接到PipedWriter上。

句法

这是PipedReader类的语法声明，我们可以看到它在扩展Reader 类。

public class PipedReader extends Reader

`PipedReader`类的构造器

下表给出了构造器的所有变体。

构造器

描述

|
| --- | --- |
| PipedReader(int pipeSize) | 它创建一个PipedReader 使其尚未连接，并使用指定的管道大小作为管道的缓冲区。 |
| PipedReader(PipedWriter src) | 它创建了一个PipedReader ，以便连接到PipedWriter src。 |
| PipedReader(PipedWriter src, int pipeSize) | 它创建一个PipedReader ，以便连接到PipedWriter src，并使用管道缓冲区的指定管道大小。 |
| PipedReader() | 它创建了一个PipedReader，所以它还没有被连接。 |

管道恐惧器类的方法

下面给出的方法如下。

方法	描述
`void close()`	此方法关闭此管道流，并释放与该流关联的任何系统资源。
`void connect(PipedWriter src)`	此方法使管道读取器连接到`PipedWriter` src。
`int read()`	这个方法从这个管道流中读取数据的下一个字符。
`int read(char[] cbuf, int off, int len)`	这个方法从这个管道流中读取多达`len` 个字符的数据到一个字符数组中。
`boolean ready()`	这个方法告诉这个流是否准备好被读取。

示例:`PipedReader`读取()方法

在这个例子中，我们将从PipedReeader类中实现read()方法。首先，我们为类PipedReader和PipedWriter创建对象，然后使用connect() 方法连接它们。在这之后，我们简单地使用 PipedReader 和 PipedWriter 类的 read()和 write()方法进行读写。

package studytonight;
import java.io.PipedReader;
import java.io.PipedWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			PipedReader reader = new PipedReader(); 
			PipedWriter writer = new PipedWriter(); 
			reader.connect(writer); 			
			writer.write(72); 
			System.out.println((char)reader.read()); 
			writer.write(69); 
			System.out.println((char)reader.read()); 
			writer.write(76); 
			System.out.println( (char)reader.read());   
			writer.write(76); 
			System.out.println( (char)reader.read());   
			writer.write(79); 
			System.out.println( (char)reader.read());   
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

H
E
L
L
O

示例:使用移液器读取数组

这是一个简单的 Java PipedReader 示例，我们正在从字符数组中读取数据。如前所述，我们必须连接PipedReader 和PipedWriter，在本节目中，我们使用connect()方法连接PipedWriter 作家。连接后我们使用重载方法public int read(char[] arr, int offset, int maxlen)，这里arr 是数据源，offset 表示数据源的起始位置，我们将从这里开始读取数据。maxlength是要读取的数据的长度。对于该方法的每次调用，它将返回该索引上的一个字符。当索引到达源流的末尾时，该方法将返回 -1 。

package studytonight;
import java.io.PipedReader;
import java.io.PipedWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			PipedReader reader = new PipedReader(); 
			PipedWriter writer = new PipedWriter(); 
			reader.connect(writer); 
			char[] arr = {'H', 'E', 'L', 'L', 'O'}; 
			writer.write(arr, 0, 5); 
			while(true) 
			{ 
				System.out.print((char) reader.read());           
			} 
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

你好

结论

在本文中，我们学习了 Java 中的PipedReader 类。PipedReader 类用于读取管道的数据，该数据是字符流的格式。PipedReader必须连接到一个PipedWriter上。

Java `CharArrayWriter`

Java `CharArrayWriter.writeTo()`方法

原文：https://www.studytonight.com/java-file-io/chararraywriter-writeto-method-in-java

在本教程中，我们将从 Java 中的CharArrayWriter 类了解writeTo()方法。Java 中 CharArrayWriter 类的 writeTo(Writer)方法用于将 CharArrayWriter 的内容写入另一个字符流。

句法

这是writeTo()方法的语法，该方法接受 Writer，即作为目标流的输出流，不返回值。如果出现输入/输出错误，该方法将抛出异常。

public void writeTo(Writer out)    throws IOException

示例 CharArrayWriter 的 WriteTo 方法

在这个例子中，我们首先实现writeTo()方法，我们使用write()方法将数据写入CharArrayWriter ，然后在CharArrayWriter 上调用writeTo()方法，我们将其他 out 方法作为参数传递，它会将相同的数据复制到CharArrayWriter 的 out 对象中，该对象可以使用 toString()方法进行验证。

import java.io.CharArrayWriter;
public class StudyTonight 
{
	public static void main(String[] args) throws Exception
	{ 
		CharArrayWriter charArrayWriter = new CharArrayWriter(); 
		String str = "Hello Studytonight"; 
		charArrayWriter.write(str); 
		CharArrayWriter out = new CharArrayWriter(); 
		charArrayWriter.writeTo(out); 
		System.out.println(out.toString()); 
	} 
}

你好，今晚学习

示例 CharArrayWriter 的 WriteTo 方法

在这个例子中，我们正在实现writeTo()方法，首先我们已经使用write()方法将数据写入到CharArrayWriter 中，然后在CharArrayWriter 上，我们正在调用writeTo()方法，并且我们传递其他 out 方法作为参数，并且它将相同的数据复制到CharArrayWriter 的 out 对象中，该对象可以使用 toString()方法进行验证。

import java.io.CharArrayWriter;
import java.io.IOException;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		CharArrayWriter charArrayWriter = new CharArrayWriter(); 
		charArrayWriter.write("Hello Studytonight"); 
		CharArrayWriter out = new CharArrayWriter(); 
		charArrayWriter.writeTo(out); 
		System.out.println(out.toString()); 
	} 
}

你好，今晚学习

结论

在本教程中，我们学习了 Java 中的 CharArrayWriter 类。Java 中 CharArrayWriter 类的 writeTo(Writer) 方法用于将 CharArrayWriter 的内容写入另一个字符流。

Java `CharArrayWriter.write()`方法

原文：https://www.studytonight.com/java-file-io/chararraywriter-write-method-in-java

在本教程中，我们将学习 Java 中CharArrayWriter类的write()方法。write()方法用于将字符写入缓冲区。当数据写入流时，缓冲区会自动增长。可以使用 toCharArray()和 toString()方法检索数据。

句法

此方法用于以整数的形式向编写器写入字符。这种write()方法一次向CharArrayWriter写入一个字符。

public void write(int c)

此方法用于以字符数组的形式向编写器写入字符。这是一个重载方法。

public void write(char[] c, int offset, int length)

此方法用于以字符串数组的形式向编写器写入字符。这是一个重载方法。

public void write(String str, int offset, int length)

示例 Java 中的编写器字符

在这个例子中，我们将一个字符传递给CharArrayWriter 的 write()方法来检查写了什么，我们有一个方法 toString()，它会告诉我们字符数组写入器的数据

import java.io.CharArrayWriter;
public class StudyTonight 
{
	public static void main(String[] args) 
	{ 
		CharArrayWriter charArrayWriter = new CharArrayWriter(); 
		charArrayWriter.write(65); 
		System.out.println(charArrayWriter.toString()); 
	} 
}

示例 Java 中的编写器字符

在本例中，我们将一个字符数组传递给 write()方法，它将把它写入 CharArrayWriter 我们可以指定在传递字符的开始索引和结束索引后，要写入的数组中的字符范围。

import java.io.CharArrayWriter;
public class StudyTonight 
{
	public static void main(String[] args) 
	{ 
		CharArrayWriter charArrayWriter = new CharArrayWriter(); 
        char[] arr = { 'H', 'E', 'L', 'L', 'O', 'S', 'T', 'U', 'D', 'Y', 'T', 'O', 'N', 'I', 'G', 'H', 'T'}; 
        charArrayWriter.write(arr, 0, 5); 
		System.out.println(charArrayWriter.toString()); 
	} 
}

你好

示例 Java 中的编写器字符

在这个程序中，我们将字符串传递给 write()方法，我们还传递开始索引和结束索引，以确保它只从这个特定的范围写入数据。

import java.io.CharArrayWriter;
public class StudyTonight 
{
	public static void main(String[] args) 
	{ 
		CharArrayWriter charArrayWriter = new CharArrayWriter(); 
        String str = "Hello Studytonight"; 
        charArrayWriter.write(str, 8, 5); 
		System.out.println(charArrayWriter.toString()); 
	} 
}

你好

结论

在本教程中，我们学习了 Java 中 CharArrayWrite 类的 write()方法。Java CharArrayWriter 的 write()方法用于将字符写入缓冲区。

Java `CharArrayWriter.size()`方法

原文：https://www.studytonight.com/java-file-io/chararraywriter-size-method-in-java

在本教程中，我们将学习 Java 中CharaArrayWriter 类的size() 方法。该方法有助于获取字符写入器的当前缓冲区大小。

句法

这是 size()方法的语法声明此方法不接受任何参数，并返回当前缓冲区的大小。

public int size()

ChaArrayWriterClass 的 size()方法示例

在下面给出的例子中，我们向一个 CharArrayWriter 类的对象写入两个字符，这样它的大小就变成了 2，当我们在 CharArrayWriter 类上调用 size()方法时，这个方法将返回 2 作为缓冲区的大小。

import java.io.CharArrayWriter;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	    { 
	        CharArrayWriter arr = new CharArrayWriter(); 
	        arr.write(65);
	        arr.write(66);
	        //calculates the current size of buffer
	        int size = arr.size();
	        System.out.println("Current size of buffer: "+size);

	    } 
}

当前缓冲区大小:2

大小()方法示例

在这个例子中，我们不是写，而是将数据附加到 CharArrayWriter，然后检查缓冲区大小，它仍然会给出正确的输出。这表明它不依赖于向 CharSequence 写入数据的方法，但是输出取决于缓冲区的大小。

import java.io.CharArrayWriter;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException
	{
		CharArrayWriter charArrayWriter= new CharArrayWriter();

		CharSequence sequence1 = "study";
		CharSequence sequence2 = "tonight";

		charArrayWriter.append(sequence1);
		charArrayWriter.append(sequence2);

		System.out.println("String: "	+ charArrayWriter.toString());
		System.out.println("Size: "	+ charArrayWriter.size());
	}   
}

字符串:今晚学习
大小:12

结论:

在本教程中，我们学习了 CharArrayWriter 类的 size()方法。这个方法有助于获取 CharArrayWriter 当前缓冲区的大小。

Java `CharArrayWriter.toCharArray()`方法

原文：https://www.studytonight.com/java-file-io/chararraywriter-tochararray-method-in-java

在本教程中，我们将学习 Java 中的 t oCharArray() 方法。此方法在java.io包中可用此方法从流中返回字符数组。此方法是非静态方法，因此我们必须创建一个对象来调用此方法。

句法

这是 toCharArray()方法的语法，这个方法不接受任何参数但是返回 char 数组。

public char[] toCharArray();

enlightened 这里有一个有趣的注意点， toCharArray() 方法在将CharacterWriterArray 转换为字符数组时不会抛出异常。

toCharArray()方法示例

在这个例子中，我们有一个字符数组，并将其附加到字符数组写入器中。在将它写入 CharArrayEriter 之后，我们可以简单地使用 toCharArray()方法将其转换为 char 数组，它将返回一个字符数组。

import java.io.CharArrayWriter;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		CharArrayWriter writer = new CharArrayWriter(); 
		char[] myText = { 'H', 'E', 'L', 'L', 'O' }; 
		for (char c : myText)
		{ 
			writer.append(c); 
		} 
		char[] arr = writer.toCharArray();
		System.out.print("toCharArray : ");
		for (char c : arr) 
		{ 
			System.out.print(" " + c); 
		}
	} 
}

to chararray:H . E . L . O

toCharArray()方法示例:

在本例中，我们将给定的 CharArrayWriter 转换为与上述示例相同的字符数组，但不同的是，我们创建了带有附加字符序列的 CharArrayWriter，并且它仍然工作良好，因此我们可以得出结论，在所有情况下，toCharArray()方法都会将给定的 CharArrayWriter 转换为字符数组。

import java.io.CharArrayWriter;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException
	{
		CharArrayWriter charArrayWriter= new CharArrayWriter();

		CharSequence sequence1 = "study";
		CharSequence sequence2 = "tonight";

		charArrayWriter.append(sequence1);
		charArrayWriter.append(sequence2);

		char[] arr = charArrayWriter.toCharArray();
		System.out.print("toCharArray : ");
		for (char c : arr) 
		{ 
			System.out.print(" " + c); 
		}
	}   
}

toCharArray : s t u d y t o n i g h t

结论:

在本教程中，我们学习了 Java 中的CharArrayWriterto chararray()方法。此方法从流中返回字符数组。此方法用于将 CharacaterWriterArray 流转换为字符数组。

Java `CharArrayWriter.toString()`方法

原文：https://www.studytonight.com/java-file-io/chararraywriter-tostring-method-in-java

在本教程中，我们将学习 Java 中 CharArrayWriter 类的 toString()方法。这个方法属于java.io包。该方法用于将缓冲区数据表示为来自该CharArrayWriter流的字符串。此方法不会在流的字符串表示时引发异常。

句法

这是 Java 中 toString()方法的声明语法。它不接受任何参数。该方法的返回类型是字符串，它将现有缓冲区数据作为字符串返回

public String toString();

toString()方法示例

在这个例子中，我们使用 write 方法将 arr 写入到 CharArrayWriter 中，然后我们将它作为一个流获取。该方法用于将缓冲区数据表示为来自该CharArrayWriter流的字符串。

import java.io.CharArrayWriter;
public class StudyTonight 
{
	public static void main(String[] args) throws Exception 
	{  
		char[] arr = { 's', 't', 'u','d', 'y', 't' ,'o' ,'n' ,'i' ,'g', 'h', 't' };  
		CharArrayWriter charArrayWriter = new CharArrayWriter();  
		charArrayWriter.write(arr);  
		String str = charArrayWriter.toString();  
		System.out.print(str);  
	}    
}

今晚学习

toString()方法示例

这是演示 toString()方法的另一个示例。在这个例子中，我们使用 append 方法将数据写入 CharArrayWriter，我们使用 append 方法传递了两个字符串，它正在返回它。该方法用于将缓冲区数据表示为来自该CharArrayWriter流的字符串。

import java.io.CharArrayWriter;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException
	{
		CharArrayWriter charArrayWriter= new CharArrayWriter();

		CharSequence sequence1 = "study";
		CharSequence sequence2 = "tonight";

		charArrayWriter.append(sequence1);
		charArrayWriter.append(sequence2);

		System.out.println("String: "	+ charArrayWriter.toString());
	}   
}

字符串:今晚学习

结论:

在本教程中，我们学习了 Java 中的 toString()方法 CharArrayWriter toString()方法，该方法用于将缓冲区数据表示为来自这个CharArrayWriter流的字符串。此方法不会在流的字符串表示时引发异常。

Java `CharArrayWriter.append()`方法

原文：https://www.studytonight.com/java-file-io/chararraywriter-append-method-in-java

在本教程中，我们将从 Java 中的 CharArrayWriter 类中学习append()方法。该方法有三种不同的重载方法，以提供更好的追加方式。此方法将数据附加到 CharArrayWriter 上，并将字符附加到其中后返回 CharArrayWriter 。

句法

追加方法的这种重载方法会将一个字符作为参数追加一个字符数组写入器。该方法在追加字符后返回字符数组编辑器。

public CharArrayWriter append(char c)

追加方法的这个重载方法将把一个字符序列作为输入来追加一个 CharArrayWriter。该方法在追加字符后返回 CharArrayWriter 。

public CharArrayWriter append(CharSequence sequence)

追加方法的这个重载方法将把一个字符序列作为输入来追加一个 CharArrayWriter，因为它还需要两个参数作为起始索引，并作为结束索引来结束给定的字符序列。该方法在追加字符后返回 CharArrayWriter 。

public CharArrayWriter append(CharSequence sequence, int start, int end )

追加()方法的示例

这是 append()方法的重载方法之一，它将接收唯一的字符作为输入并将其追加，然后在将字符追加到其中后返回 CharArrayWriter 。

import java.io.CharArrayWriter;
public class StudyTonight 
{
	public static void main(String[] args) 
	{  
		CharArrayWriter charArrayWriter = new CharArrayWriter();  
		charArrayWriter.append('A');
		charArrayWriter.append('B');
		charArrayWriter.append('C');
		System.out.println(charArrayWriter.toString());  
	}  
}

ABC

追加()方法的示例

此方法将接收一个字符串并将其附加到 CharacterWriter。一旦字符串被附加到字符书写器，它将返回它。在下面给出的代码中，我们通过传递字符串调用了这个方法两次，在 toString 方法之后，我们检索到它，我们可以看到它附加了那些字符串。

import java.io.CharArrayWriter;
public class StudyTonight 
{
	public static void main(String[] args) 
	{  
		CharArrayWriter charArrayWriter = new CharArrayWriter();  
		charArrayWriter.append("Hello ");
		charArrayWriter.append("Studytonight");
		System.out.println(charArrayWriter.toString());  
	}  
}

你好，今晚学习

追加()方法的示例

这个例子与上面的例子非常相似，唯一的区别是在将 CharSequence 作为参数传递给 append 方法的同时，我们还传递了 start 和 end 参数，这些参数将确保给定的 CharSequence 根据它被切片。然后在追加字符后返回 CharArrayWriter 。

import java.io.CharArrayWriter;
public class StudyTonight 
{
	public static void main(String[] args) 
	{  
		CharArrayWriter charArrayWriter = new CharArrayWriter();  
		CharSequence charSequence="Welcome to Studytonight";
		charArrayWriter.append(charSequence, 3, 11);
		System.out.println(charArrayWriter.toString());  
	}  
}

来到

结论:

在本教程中，我们学习了 append()方法。该方法有三种不同的重载方法，以提供更好的追加方式。该方法将数据追加到字符写入器上，并将字符追加到其中后返回字符写入器。

Java `CharArrayWriter.flush()`方法

原文：https://www.studytonight.com/java-file-io/chararraywriter-flush-method-in-java

在本教程中，我们将学习 Java 中CharArrayWriter 类的 flush() 方法。Java 中的 CharArrayWriter 类的 flush() 方法用于刷新流。

句法

下面是 flush()方法的语法，这个方法不接受任何参数，也不返回任何东西。

public void flush()

例 1

下面是 flush()方法的例子，我们正在使用 write()方法将字符数组写入 CharArrayWriter 对象，它会将所有数据写入其中。写入数据后，我们调用 flush()方法，该方法将流刷新到基础流。

import java.io.CharArrayWriter;
import java.io.IOException;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
        char[] arr = {'S', 't', 'u', 'd', 'y', 't', 'o', 'n', 'i', 'g', 'h', 't'}; 

        CharArrayWriter charArrayWriter = new CharArrayWriter(); 

        for (char c: arr)
        { 
        	charArrayWriter.write(c); 
        } 

        System.out.println("Size of charArrayWriter : "+ charArrayWriter.size()); 

        charArrayWriter.flush(); 
	} 
}

字符写入器的大小:12

例 2

下面是 flush()方法的例子，我们正在使用 append()方法将字符数组写入 CharArrayWriter 对象，它会将所有数据写入其中。写入数据后，我们调用 flush()方法，该方法将流刷新到基础流。

import java.io.CharArrayWriter;
import java.io.IOException;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 

		CharArrayWriter chw = new CharArrayWriter();

        CharSequence csq = "Hello World";

        chw.append(csq);

        chw.flush();

        System.out.println(chw.toString());
	} 
}

你好世界

结论:

在本教程中，我们学习了 Java 中 CharArrayWriter 类的 flush()方法。Java 中 CharArrayWriter 类的 flush() 方法用于刷新流。

Java `CharArrayWriter.reset()`方法

原文：https://www.studytonight.com/java-file-io/chararraywriter-reset-method-in-java

在本教程中，我们将学习Java中CharArrayWriter 课的reset() 方法。CharArrayWriter类的reset() 方法用于重置流，这样您就可以再次使用它，而不会扔掉已经分配的流。

句法

这是 reset 方法的语法，该方法不接受任何参数，也不返回值。

 public void reset();

例 1

下面是chararraywriter类的 reset()方法的例子，首先我们追加字符串并打印，然后我们再次尝试写入数据，但是在此之前，我们调用了 reset()方法来重置缓冲区的分配。

import java.io.CharArrayWriter;
import java.io.IOException;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 

		CharArrayWriter chw = new CharArrayWriter();  
		CharSequence csq = "Hello Studytonight";  
		chw.append(csq);  
		System.out.println(csq);  
		chw.reset();  
		csq = "Hello World";  
		chw.append(csq);  
		System.out.println(chw.toString()); 
	} 
}

你好今晚学习
你好世界

例 2

这里我们可以看到调用reset()方法后 CharArrayWriter 的大小和调用reset()方法前的大小的区别。这个方法用来重置缓冲区，这样它就可以再次使用，而不会扔掉已经分配的缓冲区，这就是为什么我们得到的 CharArrayWriter 的缓冲区大小是 5，并且在 reset()方法调用后它是 0，因为所有分配的缓冲区都被清除了。

import java.io.CharArrayWriter;
import java.io.IOException;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		CharArrayWriter charArrayWriter= new CharArrayWriter(); 

		for (int c = 65; c < 70; c++) 
		{ 

			charArrayWriter.write(c); 
		} 
		System.out.println("Size of charArrayWriter: "+ charArrayWriter.size()); 

		charArrayWrite.reset(); 
		System.out.println("Size of charArrayWriter: "+ charArrayWriter.size()); 
	} 
}

字符写入器大小:5
字符写入器大小:0

结论:

在本教程中，我们从 Java 中的 CharArrayWriter 类中学习了 reset()方法。CharArrayWriter类的reset() 方法用于重置流，这样您就可以再次使用它，而不会扔掉已经分配的流。

Java `OutputStreamWriter`

Java `OutputStreamWriter.write()`方法

原文：https://www.studytonight.com/java-file-io/outputstreamwriter-write-method-in-java

在本教程中，我们将从 Java 中的 OutputStreamWriter 类中了解write() 方法。此方法用于将数据写入输出流。这个方法有三种重载方法。

例 1

在本例中，我们使用 write()方法将数据写入输出流，这里我们实现了 write()方法的重载方法之一。void write(String str，int off，int len)这个方法接受我们将要写在输出流上的字符串，我们还传递了从该点开始写入数据的偏移量，我们还传递了该数据的长度。基于所有这些参数，它将对数据进行切片并将其写入输出流。

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;

class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		String str = "Hello Studytonight";
		try
		{
			OutputStream outputStream = new FileOutputStream("E:\\studytonight\\output.txt");
			OutputStreamWriter writer = new OutputStreamWriter(outputStream);

			writer.write(str, 0, 5);
			writer.flush();	
		}
		catch (Exception ex)
		{
			ex.printStackTrace();
		}
	} 
}

输出. txt

Hello

例 2

在本例中，我们使用 write()方法将数据写入输出流，这里我们实现了write()方法的重载方法之一。void write(char c)该方法接受单个字符并将其写入输出流。

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;

class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		try
		{
			OutputStream outputStream = new FileOutputStream("E:\\studytonight\\output.txt");
			OutputStreamWriter writer = new OutputStreamWriter(outputStream);

			writer.write('A');
			writer.flush();	
		}
		catch (Exception ex)
		{
			ex.printStackTrace();
		}
	} 
}

输出. txt

例 3

在本例中，我们使用 write()方法将数据写入输出流，这里我们实现了 write()方法的重载方法之一。void write(char arr[]，int off，int len)这个方法接受我们将要在输出流上写入的字符串，我们还传递了从该点开始写入数据的偏移量，我们还传递了该数据的长度。基于所有这些参数，它将对数据进行切片并将其写入输出流。

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;

class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		char arr[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K'};
		try
		{
			OutputStream outputStream = new FileOutputStream("E:\\studytonight\\output.txt");
			OutputStreamWriter writer = new OutputStreamWriter(outputStream);

			writer.write(arr, 3, 5);
			writer.flush();	
		}
		catch (Exception ex)
		{
			ex.printStackTrace();
		}
	} 
}

输出. txt

DEFGH

结论

在本教程中，我们学习了 Java 中的 OutputStreamWriter write()方法。此方法用于将数据写入输出流。

Java `OutputStreamWriter.getEncoding()`方法

原文：https://www.studytonight.com/java-file-io/outputstreamwriter-getencoding-method-in-java

在本教程中，我们将学习 Java 中 OutputStreamWriter 类的getEncoding() 方法。此方法返回此流使用的字符编码的名称。如果编码具有历史名称，则返回该名称；否则，将返回编码的规范名称。

句法

这是getEncoding()方法的语法声明，它不取任何参数，返回对应流的编码。

public String getEncoding()

例 1

在本例中，我们将数据写入文件。一旦我们将文本写入输出流，流数据就有了特定的编码。为了检查编码，我们将调用方法 getEncoding()来检查流的编码。

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		try 
		{
			OutputStream outputStream = new FileOutputStream("E:\\studytonight\\output.txt");
			OutputStreamWriter writer = new OutputStreamWriter(outputStream);
			writer.write('A');
			writer.flush();
			System.out.println("" + writer.getEncoding());
		} 
		catch (Exception e)
		{
			System.out.print("Error: "+e.toString());
		}
	} 
}

Cp1252

例 2

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		char arr[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K'};
		try
		{
			OutputStream outputStream = new FileOutputStream("E:\\studytonight\\output.txt");
			OutputStreamWriter writer = new OutputStreamWriter(outputStream);

			writer.write(arr, 3, 5);

			System.out.print("Encoding: "+writer.getEncoding());

			writer.flush();	
		}
		catch (Exception e)
		{
			System.out.print("Error: "+e.toString());
		}
	} 
}

编码:Cp1252

结论

在本教程中，我们学习了 Java 中 OutputStreamWriter 类的 getEncoding()方法。此方法返回此流使用的字符编码的名称。

Java `OutputStreamWriter.close()`方法

原文：https://www.studytonight.com/java-file-io/outputstreamwriter-close-method-in-java

在本教程中，我们将在 Java 中学习 OutputStreamWriter 类的 close()方法。close()方法在 java.io 包中可用。此方法关闭流，首先刷新它。一旦流被关闭，进一步的 write()或 flush()调用将导致引发 IOException。关闭以前关闭的流没有效果。

句法

这是close() 方法的语法。方法的返回类型是 void，它不返回任何内容。

 public void close();

例 1

在这个例子中，我们创建了 OutputStreamWriter 对象，并向其写入数据，之后，我们调用 close()方法，该方法关闭流，首先刷新它。

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		try
		{
			OutputStream outputStream = new FileOutputStream("E:\\studytonight\\output.txt");
			OutputStreamWriter writer = new OutputStreamWriter(outputStream);

			writer.write('A');

			writer.close();	
		}
		catch (Exception e)
		{
			System.out.print("Error: "+e.toString());
		}
	} 
}

输出. txt

例 2

在这个例子中，我们创建了 OutputStreamWriter 对象，并向其写入数据，之后，我们调用 close()方法，该方法关闭流，首先刷新它。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		try
		{   
	         OutputStream os = new FileOutputStream("E:\\studytonight\\output.txt");
	         OutputStreamWriter writer = new OutputStreamWriter(os);

	         FileInputStream in = new FileInputStream("E:\\studytonight\\output.txt");

	         writer.write('S');

	         writer.close();

	         System.out.println("" + (char) in.read());
		}
		catch (Exception e)
		{
			System.out.print("Error: "+e.toString());
		}
	} 
}

输出. txt

结论

在本教程中，我们将在Java中学习 OutputStreamWriter 关闭()方法。close()方法用于关闭流前的第一次刷新，关闭流后调用的 write()或 flush()方法将导致异常。

Java `OutputStreamWriter.flush()`方法

原文：https://www.studytonight.com/java-file-io/outputstreamwriter-flush-method-in-java

在本教程中，我们将学习 Java 中 OutputStreamWriter 类的 flush()方法。该方法在java.io包中提供。这是一个非静态方法，只能用类对象访问，如果我们试图用类名访问这个方法，那么我们会得到一个错误。此方法刷新流。

句法

这是flush()方法的语法，不接受任何参数，方法的返回类型为 void，不返回任何内容。

public void flush()

例子

在这个例子中，我们正在创建一个 OutputStreamWriter 类的对象，并将数据写入其中。为了刷新流，我们在 OutputStreamWriter 上调用这个方法。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		try
		{   
	         OutputStream os = new FileOutputStream("E:\\studytonight\\output.txt");
	         OutputStreamWriter writer = new OutputStreamWriter(os);

	         FileInputStream in = new FileInputStream("E:\\studytonight\\output.txt");

	         writer.write('A');

	         writer.flush();

	         System.out.println("" + (char) in.read());
		}
		catch (Exception e)
		{
			System.out.print("Error: "+e.toString());
		}
	} 
}

输出. txt

结论

在本教程中，我们学习了 Java 中的 OutputStreamWriter flush()方法。此方法刷新流。该方法在java.io包中提供。它不接受任何参数，并且该方法的返回类型为 void，因此它不返回任何内容。

`ByteArrayInputStream`

Java `ByteArrayInputStream.available()`方法

原文：https://www.studytonight.com/java-file-io/java-bytearrayinputstream-available-method

在本教程中，我们将学习 Java 中Bytearrainputstream类的available()方法。此方法提供可以从此输入流中读取的剩余字节数。这是一个非静态方法，在 java.io 包中可用，只能使用类对象访问。它可能会在检查字节时引发异常。

语法:

这是此方法的语法声明。它不接受任何参数，并返回要从此输入流中读取的剩余字节总数。

public int available()

示例:可用的`ByteArrayInputStream`()方法

在本例中，通过使用 available()方法，我们将检查缓冲区中有多少字节可用，它将返回许多字节的 int 值。这里它返回值 4，我们可以清楚地看到四个元素在给定的缓冲区中。

import java.io.ByteArrayInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		byte[] buffer = { 4, 7, 8, 3, 1 }; 

		ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(buffer); 

		int number = byteArrayInputStream.available(); 

		System.out.println("Remaining bytes in buffer: "+ number); 
	}  
}

缓冲区剩余字节:5

示例:可用的`ByteArrayInputStream`()方法

在下面给出的缓冲区中，只有一个字节可用，因此该方法返回一个 1 值来指示给定缓冲区中有 1 个字节可用。

import java.io.ByteArrayInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		byte[] buffer = {1}; 

		ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(buffer); 

		int number = byteArrayInputStream.available(); 

		System.out.println("Remaining bytes in buffer: "+ number); 
	}  
}

缓冲区中的剩余字节:1

结论:

在本教程中，我们学习了 Java 中Bytearrainputstream类的available()方法，该方法用于返回当前输入流中读取器要读取的实际剩余字节数。

Java `ByteArrayInputStream.read()`方法

原文：https://www.studytonight.com/java-file-io/java-bytearrayinputstream-read-method

在本教程中，我们将学习 Java 中Bytearrainputstream类的read()方法。这个方法读取 ByteArrrayInputStream 的下一个字节，并且一次只从流中读取一个字节。这是一个非静态方法，在 java.io 包中可用，只能使用类对象访问。读取字节时，它可能会引发异常。

语法:

这是此方法的语法声明。它不接受任何参数，并返回以整数形式读取的字节。如果它到达流的末尾，它将返回-1。

public int read()

示例:`ByteArrayInputStream`读取()方法

我们使用 read()方法从缓冲区中读取数据，这个方法将返回 ASCII 码格式的整数，如果数据是字符形式，那么我们需要相应地输入大小写。

import java.io.ByteArrayInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		byte[] buf = {1, 2, 3, 4, 5}; 

		ByteArrayInputStream byteArrayInputStr = new ByteArrayInputStream(buf); 
		int b = 0; 
		while ((b = byteArrayInputStr.read()) != -1) 
		{ 
			System.out.print(" " + b); 
		}
	}  
}

1 2 3 4 5

示例:`ByteArrayInputStream`读取()方法

这里我们使用了 read 方法的另一个重载方法，它接受三个参数，第一个参数是我们想要存储数据的缓冲区，第二个参数是开始读取的起始位置，我们也称之为偏移量，第三个参数是数据的长度。

import java.io.ByteArrayInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 

		byte[] buf = {4, 8, 12, 16}; 

		ByteArrayInputStream byteArrayInputStr = new ByteArrayInputStream(buf); 

		byte[] b = new byte[2]; 

		int total_bytes = byteArrayInputStr.read(b, 0, 2); 

		System.out.println("Total bytes read: " + total_bytes); 

		for (byte ch : b) 
		{   
			System.out.print(ch+" "); 
		} 
	}  
}

读取的总字节数:2
4 8

结论:

在本教程中，我们学习了 Java 中Bytearrainputstream类的read()方法，该方法用于读取当前输入流的下一个字节，一次读取一个字节，并以整数的形式返回读取的字节，如果到达流的末尾，则返回-1。

Java `ByteArrayInputStream.markSupported()`方法

原文：https://www.studytonight.com/java-file-io/java-bytearrayinputstream-marksupported-method

在本教程中，我们将学习 Java 中Bytearrainputstream类的markSupported()方法。该方法用于验证流是否支持mark() and reset()`` 方法。如果流支持布尔值 true，则返回该值，否则返回 false。这是一个非静态方法，在 java.io 包中可用，只能使用类对象访问。如果通过类名访问，它将引发异常。

语法:

这是markSupported() 方法的语法声明，这个方法不接受任何参数。此方法返回一个布尔值，该值指示流的mark()和reset()方法的可支持性。

public boolean markSupported()

示例:`ByteArrayInputStream`标记支持()方法

这里我们检查当前流是否支持 mark()方法，在我们的例子中，这个方法返回一个真值，这意味着当前流支持 mark()方法。

import java.io.ByteArrayInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		byte[] buf = {1, 2, 3, 4};  
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(buf);  
        boolean isMarkSupported = byteArrayInputStream.markSupported();  
        System.out.println("Is mark supported : "+isMarkSupported);  
	}  
}

是否支持标记:真

示例:`ByteArrayInputStream`标记支持()方法

在这里，我们将探索这个markSupported()方法是如何工作的，首先我们检查这个方法是否支持标记方法，然后我们读取一些数据，在这一点上，我们通过调用 mark()方法来标记位置，然后我们再次读取数据，并在调用 reset 方法时调用 reset()方法，这将把流指针设置为最近标记的位置 snd，在这之后，如果我们调用 read 方法，它将再次从该点读取。

import java.io.ByteArrayInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		try 
		{
			byte[] buf = {65, 66, 67, 68, 69};
			ByteArrayInputStream bais = new ByteArrayInputStream(buf);

			boolean isMarkSupported = bais.markSupported();
			System.out.println("Is mark supported : "+isMarkSupported);

			System.out.println("Byte read "+ bais.read());
			System.out.println("Byte read "+ bais.read());
			System.out.println("Byte read "+ bais.read());

			System.out.println("Mark() invocation");

			bais.mark(0);
			System.out.println("Byte read "+ bais.read());
			System.out.println("Byte read "+ bais.read());

			System.out.println("Reset() invocation");

			bais.reset();
			System.out.println("Byte read "+ bais.read());
			System.out.println("Byte read "+ bais.read());

		} 
		catch(Exception e) 
		{
			e.printStackTrace();
		}
	}  
}

是否支持标记:真
以下为证明:
字节读取 65
字节读取 66
字节读取 67
标记()调用
字节读取 68
字节读取 69
重置()调用
字节读取 68
字节读取 69

结论:

在本教程中，我们学习了 Java 中Bytearrainputstream类的markSupported() 方法。Java 中 bytearrainputstream 类的markSupported()方法用于验证该流是否支持mark() and reset()`` 方法。如果流支持布尔值 true，则返回该值，否则返回 false。

Java `ByteArrayInputStream.skip(long)`方法

原文：https://www.studytonight.com/java-file-io/java-bytearrayinputstream-skip-method

在本教程中，我们将学习 Java 中Bytearrainputstream类的skip(long x)方法。此方法用于从输入流中跳过 x 字节的输入。这是一个非静态方法，在 java.io 包中可用，只能使用类对象访问。如果通过类名访问，它将引发异常。但是它不会在跳过字节时抛出异常。

语法:

这是skip(long x) 方法的语法声明。它接受单个强制参数 x ，该参数指定要跳过的字节数并返回跳过的字节数。

public long skip(long x)

示例:`ByteArrayInputStream`跳过()方法

在这个例子中，我们实现了 skip()方法来跳过输入流中的字符，在当前流中有 5 个元素。首先我们读取 5，然后使用参数 1 调用 skip 方法，这意味着它将只跳过一个字符，然后我们再次读取，因此在本例中，我们在读取时跳过了缓冲区中的元素 6。

import java.io.ByteArrayInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		try 
		{
			byte[] buf = { 5, 6, 7, 8, 9 }; 

			ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(buf); 

			System.out.println(byteArrayInputStream.read()); 

			byteArrayInputStream.skip(1); 

			System.out.println(byteArrayInputStream.read()); 
			System.out.println(byteArrayInputStream.read()); 
		} 
		catch(Exception e) 
		{
			e.printStackTrace();
		}
	}  
}

5
7
8

示例:`ByteArrayInputStream`跳过()方法

这个例子与上面给出的例子相同，但是这次我们跳过了前 3 个字符，所以它不会读取前 3 个字符，而是从第 4 个字符开始读取。

import java.io.ByteArrayInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		try 
		{
			byte[] buf = { 5, 6, 7, 8, 9 }; 

			ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(buf); 

			byteArrayInputStream.skip(3); 

			System.out.println(byteArrayInputStream.read()); 
			System.out.println(byteArrayInputStream.read()); 
		} 
		catch(Exception e) 
		{
			e.printStackTrace();
		}
	}  
}

8
9

结论:

在本教程中，我们学习了 Java 中Bytearrainputstream T5】类的skip(long x) 方法。Java 中 ByteArrayInputStream 类的skip(long x) 用于从输入流中跳过 x 字节的输入。它接受单个参数 x ，该参数指定要跳过的字节数，并返回跳过的字节数。

Java `ByteArrayInputStream.mark(int)`方法

原文：https://www.studytonight.com/java-file-io/java-bytearrayinputstream-mark-method

在本教程中，我们将学习 Java 中Bytearrainputstream类的mark(int readAheadLimit)方法。此方法用于设置流中当前标记的位置。默认情况下，标记ByteArrayInputStream标记在零位置。如果没有设置标记，那么标记的值就是传递给构造器的偏移量。

语法:

这是此方法的语法声明。它接受在标记位置无效之前可以读取的最大字节数限制，并且不返回任何值。

public void mark(int readAheadLimit)

示例 2:`ByteArrayInputStream`标记()方法

这里，我们使用 mark()方法标记流中的位置，以便稍后可以检索相同的位置并从这一点开始读取。

import java.io.ByteArrayInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		byte[] buf = { 1, 2, 3, 4, 5 }; 

        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(buf); 

        System.out.println(byteArrayInputStream.read()); 
        System.out.println(byteArrayInputStream.read()); 
        System.out.println(byteArrayInputStream.read()); 

        System.out.println("Mark() called"); 
        byteArrayInputStream.mark(0); 
        System.out.println(byteArrayInputStream.read()); 
        System.out.println(byteArrayInputStream.read()); 
	}  
}

1
2
3
马克()名为
4
5

示例 2:`ByteArrayInputStream`标记()方法

当我们调用 mark()方法时，它标记流中的位置，当我们调用 reset()方法时，我们开始从流中最近标记的位置读取数据。

import java.io.ByteArrayInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		byte[] buf = { 1, 2, 3 }; 

		ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(buf); 

		System.out.println(byteArrayInputStream.read()); 

		System.out.println("Mark() method called"); 

		byteArrayInputStream.mark(3); 
		System.out.println(byteArrayInputStream.read()); 
		System.out.println(byteArrayInputStream.read()); 
	}  
}

1
马克()法称为
2
3

结论:

在本教程中，我们学习了 Java 中Bytearrainputstream类的mark(int readAheadLimit)方法，该方法用于设置流中的当前标记位置。默认情况下，它在最初构造时标记在位置 0。

`FileInputStream`方法

Java `FileInputStream.available()`方法

原文：https://www.studytonight.com/java-file-io/java-fileinputstream-available-method

在本教程中，我们将学习 Java 中FileInputStream类的available()方法。此方法用于返回要从当前输入流中读取的剩余字节数，而不会被此FileInputStream的此方法的下一次调用阻塞。下一个方法调用也可以是另一个线程。这是一种非静态方法，在 java.io 包中提供。

句法

这是此方法的语法声明。它不接受任何参数，并返回该FileInputStream可以读取的剩余字节的大致数量。

public int available()

示例 1:检查 Java 流中的可用字节

在本例中，我们使用 available 方法检查流中可供读取的字节数，该方法返回的数字是 18，这表明流中可供读取的剩余字节总数是 18。

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		FileInputStream inputStream  = new FileInputStream("E:\\studytonight\\file.txt"); 

		DataInputStream dataInputStream = new DataInputStream(inputStream); 

		int count = inputStream.available(); 

		System.out.println("Total bytes available: "+count); 		 
	}  
}

可用字节总数:18

示例 2:检查 Java 流中的可用字节

在本例中，我们使用 available 方法检查流中可供读取的字节数，该方法返回的数字为 5，这表明流中剩余可供读取的字节总数为 15。

import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		byte[] byte_arr = { 10, 20, 30, 40, 50 }; 

        ByteArrayInputStream byteArrayInputStr = new ByteArrayInputStream(byte_arr); 

        DataInputStream dataInputStr = new DataInputStream(byteArrayInputStr); 

		int count = dataInputStr.available(); 

		System.out.println("Total bytes available: "+count); 		 
	}  
}

可用字节总数:5

结论:

在本教程中，我们学习了 Java 中FileInputStream类的available()方法，该方法返回要从当前输入流中读取的估计字节数，而不会被该FileInputStream的该方法的下一次调用阻塞。这个方法只能用类对象访问，如果我们试图用类名访问这个方法，那么我们会得到一个错误。

Java `FileInputStream.close()`方法

原文：https://www.studytonight.com/java-file-io/java-fileinputstream-close-method

在本教程中，我们将学习 Java 中FileInputStream类的close()方法。此方法用于关闭当前FileInputStream，并释放与此流链接的所有系统资源。这是一个非静态方法，在 java.io 包中可用。

句法

这是此方法的语法声明。它不接受任何参数，也不返回值。

public void close()

示例 1:在 Java 中关闭`FileInputStream`

我们可以使用 FileInputStream 的 close()方法来关闭 Java 中文件的实例。见下面的例子。

package com.studytonight;
import java.io.IOException;
import java.io.FileInputStream;
public class FileInputStreamDemo {
   public static void main(String[] args) throws IOException {
      FileInputStream fis = null;
      int i = 0;
      char c;      
      try {
         // create new file input stream
         fis = new FileInputStream("E://studytonight//output.txt");         
         // read byte from file input stream
         i = fis.read();         
         // convert integer from character
         c = (char)i;         
         // print character
         System.out.println(c);         
         // close file input stream
         fis.close();
         System.out.println("Close() invoked");         
         // tries to read byte from close file input stream
         i = fis.read();
         c = (char)i;
         System.out.println(c);

      } catch(Exception ex) {
         // if an I/O error occurs
         System.out.println("IOException: close called before read()");
      } finally {
         // releases all system resources from the streams
         if(fis!=null) {
            fis.close();
         }
      }
   }
}

IOException:读取前调用关闭()

输出. txt

ABCDEF

示例 2:在 Java 中关闭`FileInputStream`

在本例中，我们在从流中读取数据之前关闭了该流，因此与它相关的所有资源都将被删除。如果我们试图在关闭流后读取数据，它将抛出一个异常java.io.IOException: Stream closed。

import java.io.*;
public class CloseOfFIS {
 public static void main(String[] args) throws Exception {
  FileInputStream fis_stm = null;
  int count = 0;
  try {
   // Instantiates FileInputStream
   fis_stm = new FileInputStream("E://studytonight//output.txt");
   // By using read() method is to read
   // a byte from fis_stm
   count = fis_stm.read();
   // Display corresponding bytes value
   byte b = (byte) count;
   // Display value of b
   System.out.println("fis_stm.read(): " + b);
   // By using close() method is to close
   // close the stream     
   fis_stm.close();
   // when we call read() method after
   // closing the stream will result an exception
   count = fis_stm.read();

  } catch (Exception ex) {
   System.out.println(ex.toString());

  } finally {
   // with the help of this block is to
   // free all necessary resources linked
   // with the stream
   if (fis_stm != null) {
    fis_stm.close();
   }
  }
 }
}

fis _ STM . read():0
Java . io . io 异常:流关闭

结论

在本教程中，我们学习了 Java 中FileInputStream类的close()方法。此方法在被调用时将关闭当前流，并且不能对其执行进一步的操作。

Java `FileInputStream.skip()`方法

原文：https://www.studytonight.com/java-file-io/java-fileinputstream-skip-method

在本教程中，我们将学习 Java 中FileInputStream类的skip()方法。此方法用于跳过并丢弃此FileInputStream中给定数量的字节数据。这是一个非静态方法，在 java.io 包中可用。

句法

这是此方法的语法声明。它接受要跳过的“n”字节数作为参数，并返回跳过的确切字节数。

public long skip(long n)

示例 1:在 Java 中使用 FileInputStream 跳过字节

让我们看一个例子，其中我们使用 FileInputStream 的 skip()方法来跳过字节的数据。请看下面的例子。

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		int i;
		try 
		{
			InputStream inputStream = new FileInputStream("E:\\studytonight\\output.txt");
			while ((i = inputStream.read()) != -1)
			{
				char c = (char) i;
				System.out.print(c + " ");
				inputStream.skip(1);
			}

			inputStream.close();
		} 
		catch (Exception e)
		{
			e.printStackTrace();
		}
	}  
}

hlosyoih

示例 2:在 Java 中使用 FileInputStream 跳过字节

让我们看另一个例子，其中我们使用 FileInputStream 的 skip()方法来跳过文件流中的字节数据。请看下面的例子。

import java.io.*;
public class Studytonight {
 public static void main(String[] args) throws Exception {
  FileInputStream st = null;
  int count = 0;
  try {
   st = new FileInputStream("E:\Studytonight\output.txt");
   while ((count = st.read()) != -1) {   
    count = st.read();    
    byte b = (byte) count;    
    System.out.println("st.read(): " + b);
    long skip_byte = st.skip(2);
    System.out.println("st.skip(2): " + skip_byte);
    System.out.println();
   }
  } catch (Exception ex) {
   System.out.println(ex.toString());
  } finally {

   if (st != null) {
    st.close();
   }
  }
 }
}

ST . read():4
ST . skip(2):2
T3】ST . read():97
ST . skip(2):2
T6】ST . read():111
ST . skip(2):2
T9】ST . read():33
ST . skip(2):2

结论:

在本教程中，我们学习了 Java 中 FileInputStream 类的skip()方法，该方法从当前输入流中跳过给定的数据字节数，并返回实际跳过的字节数。它只能用类对象访问，如果我们试图用类名访问方法，那么我们会得到一个错误。

Java `FileChannel.getChannel()`方法

原文：https://www.studytonight.com/java-file-io/java-fileinputstream-getchannel-method

在本教程中，我们将学习 Java 中FileInputStream类的getChannel()方法。此方法用于返回与此FileInputStream相关联的离散文件通道对象。返回通道的位置是到目前为止从文件中读取的字节数。这是一种非静态方法，在 java.io 包中提供。

句法

这是此方法的语法声明。它不接受任何参数，并返回与此输入流链接的文件通道。

public FileChannel getChannel()

示例 Java 中的文件通道对象

在本例中，我们使用了文件通道类的 getChannel()方法，该方法返回文件通道的一个对象。

package com.studytonight;
import java.io.IOException;
import java.io.FileInputStream;
import java.nio.channels.FileChannel;
public class Studytonight {
   public static void main(String[] args) throws IOException {
      FileChannel fc = null;
      FileInputStream fis = null;
      int i = 0;
      long pos;
      char c;
      try {         
         fis = new FileInputStream("E:/Studytonight/output.txt");
         while((i = fis.read())!=-1) {
            fc = fis.getChannel();
            pos = fc.position();
            c = (char)i;
            System.out.print("No of bytes read: "+pos);
            System.out.println("; Char read: "+c);
         }
      } catch(Exception ex) {
         System.out.println("IOException: close called before read()");
      } finally {
         if(fis!=null)
            fis.close();
         if(fc!=null)
            fc.close();
      }
   }
}

输出. txt

CURIOUS

读取的字节数:1；字符读取:C
读取字节数:2；字符读取:U
读取的字节数:3；字符读取:R
读取字节数:4；字符读取:I
读取字节数:5；字符读取:0
读取字节数:6；字符读取:U
读取字节数:6；字符读数:S

示例 Java 中的文件通道对象

这是另一个用 Java 获取文件的 filechannel 对象的例子，我们可以用它来读写文件中的数据。

import java.io.*;
import java.nio.channels.*;
public class Studytonight {
 public static void main(String[] args) throws Exception {
  FileInputStream st = null;
  FileChannel std = null;
  int count = 0;
  try {
   st = new FileInputStream("E:\Studytonight\output.txt");
   while ((count = st.read()) != -1) {
    count = st.read();
    byte b = (byte) count;
    System.out.println("st.read(): " + b);
   }
   std = fis_stm.getChannel();
   System.out.println("st.getChannel(): " + std);
  } catch (Exception ex) {
   System.out.println(ex.toString());
  } finally {
   if (st != null) {
    st.close();
    if (std != null) {
     std.close();
    }
   }
  }
 }
}

ST . read():4
ST . read():97
ST . read():97
ST . read():8
ST . read():111
ST . read():108
ST . read():33
ST . read():33
ST . getchannel():sun . nio . ch . file channel mpl @ 31b 7 dea0

结论:

在本教程中，我们学习了 Java 中FileInputStream类的getChannel()方法，该方法返回与当前FileInputStream相关联的特定文件通道。它只能用类对象访问，如果我们试图用类名访问方法，那么我们会得到一个错误。

Java `FileDescriptor.getFD()`方法

原文：https://www.studytonight.com/java-file-io/java-fileinputstream-getfd-method

在本教程中，我们将学习 Java 中FileInputStream类的getFD()方法。此方法用于返回文件描述符的对象，该对象表示当前FileInputStream正在使用的文件系统中特定文件的连接。这是一个非静态方法，在 java.io 包中可用。

句法

这是此方法的语法声明。它不接受任何参数，并返回属于当前流的文件描述符对象

public final FileDescriptor getFD()

示例:用 Java 获取文件描述符

在这个例子中，我们使用的是 FileInputStream 类的 getFD()方法，该方法用于在 Java 中获取文件描述符。请看下面的例子。

package com.studytonight;
import java.io.FileDescriptor;
import java.io.IOException;
import java.io.FileInputStream;
public class FileInputStreamDemo {
   public static void main(String[] args) throws IOException {
      FileDescriptor fd = null;
      FileInputStream fis = null;
      boolean bool = false;
      try {
         // create new file input stream
         fis = new FileInputStream("C://test.txt");

         // get file descriptor
         fd = fis.getFD();

         // tests if the file is valid
         bool = fd.valid();

         // prints
         System.out.println("Valid file: "+bool);

      } catch(Exception ex) {
         // if an I/O error occurs
         ex.printStackTrace();
      } finally {
         // releases all system resources from the streams
         if(fis!=null)
            fis.close();
      }
   }
}

文件中的文本 c:/test.txt

ABCDEF

有效文件:真

示例 2:用 Java 获取文件描述符

在本例中，我们使用的 by using getFD()方法是返回与 Java 中的流链接的文件描述符。请看下面的例子。

import java.io.*;
public class GetFDOfFIS {
 public static void main(String[] args) throws Exception {
  FileInputStream fis_stm = null;
  FileDescriptor file_desc = null;
  try {
   fis_stm = new FileInputStream("C:\\studytonight.txt");
   // By using getFD() method is to return
   // FileDescriptor linked with the stream	
   file_desc = fis_stm.getFD();
   System.out.println("fis_stm.getFD(): " + file_desc);
  } catch (Exception ex) {
   System.out.println(ex.toString());
  } finally {
   // with the help of this block is to
   // free all necessary resources linked
   // with the stream
   if (fis_stm != null) {
    fis_stm.close();
   }
  }
 }
}

fis _ STM . getfd():Java . io . file descriptor @ 7 bfcd 12c

结论:

在本教程中，我们学习了 Java 中FileInputStream类的getFD()方法，该方法返回文件描述符对象，该对象表示与当前FileInputStream正在使用的文件系统中的确切文件的连接。它只能用类对象访问，如果我们试图用类名访问方法，那么我们会得到一个错误。

Java `FileInputStream.read()`方法

原文：https://www.studytonight.com/java-file-io/java-fileinputstream-read-method

在本教程中，我们将学习 Java 中FileInputStream类的read()方法。此方法用于从当前输入流中读取一个字节的数据。如果没有可用的输入，它将阻塞。这是一种非静态方法，在 java.io 包中提供。

句法

这是此方法的语法声明。它不接受任何参数，并返回数据的下一个字节，如果到达文件末尾，则返回-1。

public int read()

示例 1:用 Java 读取字节的数据

在这个例子中，我们使用 FileInputStream 类的 read()方法从输入流中读取字节。请看下面的例子。

package com.studytonight;

import java.io.IOException;
import java.io.FileInputStream;

public class FileInputStreamDemo {
   public static void main(String[] args) throws IOException {
      FileInputStream fis = null;
      int i = 0;
      char c;

      try 
      {
         fis = new FileInputStream("E://studytonight//output.txt");

         while((i = fis.read())!=-1) {
            c = (char)i;

            System.out.print(c);
         }

      } 
      catch(Exception e) 
      {
         System.out.println("Error: "+e.toString());
      }  
   }
}

输出. txt

Hello Studytonight

你好，今晚学习

示例 2:用 Java 读取字节的数据

这是理解 FileInputStream 类的 read()方法用法的另一个例子。请看下面的例子。

import java.io.FileInputStream;

public class Main {

  public static void main(String args[]) {

     try {
        FileInputStream input = new FileInputStream("E://studytonight//input.txt");

        System.out.println("Data in the file: ");

        // Reads the first byte
        int i = input.read();

       while(i != -1) {
           System.out.print((char)i);

           // Reads next byte from the file
           i = input.read();
        }
        input.close();
     }

     catch(Exception e) {
        e.getStackTrace();
     }
  }
}

input.txt

Let's be studytonight curious

文件中的数据:
今晚让我们好奇的学习

结论

在本教程中，我们学习了 Java 中FileInputStream类的read()方法。它从当前输入流中读取下一个字节的数据并返回。它只能用类对象访问，如果我们试图用类名访问方法，那么我们会得到一个错误。

Java `BufferedWriter`方法

Java `BufferedWriter.write()`方法

原文：https://www.studytonight.com/java-file-io/java-bufferedwriter-write-method

在本教程中，我们将从 Java 中的BufferedWriter 类中学习write()方法。此方法用于将数据写入缓冲区写入器。这个方法有三种重载方法:

句法

此方法用于写入具有指定开始和结束索引的字符串的一部分。

void write(String s, int off, int len)

此方法用于写入字符数组的一部分。

void write(char[] cbuf, int off, int len)

此方法用于编写单个字符。

void write(int c)

write()方法示例

在本例中，我们将三个参数作为字符串传递给函数，字符串是要写入的源，然后有一个偏移量作为第二个参数，它指示从哪里开始读取字符串的起始点，第三个参数是从哪里开始读取字符串的长度。这里我们有一个字符串“你好，今晚研究”，如果我们从索引 2 中计数 8 个位置，那么它将把文本“llo Stud”写入文件。

import java.io.BufferedWriter;
import java.io.FileWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			String str = "Hello Studytonight";
			FileWriter writer = new FileWriter("E:\\studytonight\\output.txt");  
			BufferedWriter buffer = new BufferedWriter(writer);  
			buffer.write(str, 2, 8);  
			buffer.close();  
			System.out.println("Data is written to the file successfully..."); 
		}
		catch(Exception e)
		{
			System.out.print(false);
		}
	}
}

数据成功写入文件...

输出. txt

llo Stud

例 2

这个例子类似于上面给出的例子，但不同的是，这里我们传递了一个字符数组作为源，然后偏移量作为索引，从这里我们将开始读取要写入缓冲区的文本和数据长度。

import java.io.BufferedWriter;
import java.io.FileWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			char arr[] = {'H', 'e', 'l', 'l', 'o', 'S', 't', 'u', 'd', 'y', 't', 'o', 'n', 'i', 'g', 'h', 't'};
			FileWriter writer = new FileWriter("E:\\studytonight\\output.txt");  
			BufferedWriter buffer = new BufferedWriter(writer);  
			buffer.write(arr, 2, 8);  
			buffer.close();  
			System.out.println("Data is written to the file successfully..."); 
		}
		catch(Exception e)
		{
			System.out.print(false);
		}
	}
}

数据成功写入文件...

输出. txt

lloStudy

写(整数)方法示例

在本例中，我们将一个整数作为数据源作为该特定字符的 ASCII 码传递，并且该方法将把该 ASCII 码写入 BufferedWriter。这里我们不需要传递长度，因为我们只有一个字符。

import java.io.BufferedWriter;
import java.io.FileWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			FileWriter writer = new FileWriter("E:\\studytonight\\output.txt");  
			BufferedWriter buffer = new BufferedWriter(writer);  
			buffer.write(65);  
			buffer.close();  
			System.out.println("Data is written to the file successfully..."); 
		}
		catch(Exception e)
		{
			System.out.print(false);
		}
	}
}

数据成功写入文件...

输出. txt

结论

在本教程中，我们学习了 Java 中 BufferedWriter 的 write()方法。这个方法有三种重载方法，void write(char[] cbuf, int off, int len)、void write(int c)和void write(String str, int off, int len)方法。

Java `BufferedWriter.newLine()`方法

原文：https://www.studytonight.com/java-file-io/java-bufferedwriter-newline-method

在本教程中，我们将学习 Java 中BufferedWriter 类的newLine()方法。此方法用于在缓冲区写新行。有了这个功能，BufferedWriter 将从下一行开始写。换行符()添加了一个行分隔符，行分隔符字符串由系统属性line.separator定义，并且不一定是单个换行符(' \n ')。

句法

下面是这个方法的语法。此方法不接受任何参数，也不返回值。

public void newLine() throws IOException

不使用换行符()的 BufferedWriter 示例:

在这个例子中，我们可以看到输出是单行的，唯一的原因是我们直接在 BufferedWriter 上写了两个字符，而没有使用 newLine()，所以它是单行写的。

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.StringWriter;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		StringWriter stringWriter = new StringWriter(); 
		BufferedWriter buffWriter = new BufferedWriter(stringWriter);
		buffWriter.write(65); 
		buffWriter.write(66); 
		buffWriter.flush(); 
		System.out.println( stringWriter.getBuffer()); 
	} 
}

BufferedWriter newLine()示例:

这个程序和上面给出的程序是一样的，唯一的区别是我们在写完第一个字符后使用了 newLine()方法，这就是为什么输出中的字符是多行的。我们两次调用了 newLine()方法，这就是为什么它在输出中添加了两行空行。

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.StringWriter;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		StringWriter stringWriter = new StringWriter(); 
		BufferedWriter buffWriter = new BufferedWriter(stringWriter);
		buffWriter.write(65); 
		buffWriter.newLine();
		buffWriter.newLine();
		buffWriter.write(66); 
		buffWriter.flush(); 
		System.out.println( stringWriter.getBuffer()); 
	} 
}

甲
T2【乙】

enlightened Java 中newLine()BufferedWriter类的方法用于将下一行分隔为新行。它用作缓冲写入器流中的写入分隔符。

结论:

在本教程中，我们学习了 Java 中 BufferedWriter 类的 newLine()方法。newLine()添加的是一个行分隔符，行分隔符字符串由系统属性line.separator定义，不一定是单个 newline ('\n ')字符。

Java `FileWriter`

Java `FileWriterclose.close()`方法

原文：https://www.studytonight.com/java-file-io/java-filewriter-close-method

在本教程中，我们将在 Java 中学习 F ileWriter 类的close()方法。此方法用于关闭此FileWriter流。当我们在关闭流后调用它的任何方法时，都不会产生异常。该方法在java.io包中提供。关闭编写器会释放其中的任何值或与之关联的任何资源。

句法

这是一个close() 方法的语法声明，它不接受任何参数，方法的返回类型是void，它什么也不返回。

public void close()

示例:关闭`FileWriter`

这里，在这个例子中，我们将实现 close()方法，一旦我们创建了编写器，我们就执行工作，然后调用 close()方法来释放与编写器相关的相应资源。当我们在关闭流后调用它的任何方法时，都不会产生异常。

import java.io.FileWriter;
import java.io.IOException;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		try
		{    
			FileWriter fileWriter=new FileWriter("E:\\studytonight\\output.txt");    
			String str = "Hello Studytonight";
			fileWriter.write(str);    
			fileWriter.close();    
			System.out.println("Data Written to the file successfully");
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}    
	} 
}

数据成功写入文件

输出. txt

Hello Studytonight

示例:关闭`FileWriter`实例

在这里，我们实现了 close()方法，在这个例子中，我们首先使用 write()方法向编写器写入数据，然后调用 close()方法来释放资源，当我们在关闭流后调用它的任何方法时都不会产生异常。

import java.io.FileWriter;
import java.io.IOException;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		try
		{    
			FileWriter fileWriter=new FileWriter("E:\\studytonight\\output.txt");    
			char c='A';
			fileWriter.write(c);    
			fileWriter.close();    
			System.out.println("Data Written to the file successfully");
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}    
	} 
}

数据成功写入文件

输出. txt

结论

在本例中，我们学习了 close()方法，该方法用于关闭FileWriter流。当我们在关闭流后调用它的任何方法时，都不会产生异常。该方法在java.io包中提供。

Java `FileWriter.flush()`方法

原文：https://www.studytonight.com/java-file-io/filewriter-flush-method-in-java

在本教程中，我们将在 Java 中学习 F ileWriter 类的flush()方法。此方法用于刷新编写器，这意味着此方法将删除编写器中存在的所有数据。它既不接受任何参数，也不返回值。

句法

这是flush()方法的语法声明，这个方法不把任何参数作为输入，也不返回任何东西，因为它的返回类型是 void。

public void flush()

示例 1: FileWriter 刷新()

在下面的例子中，我们正在实现 flush()方法是如何工作的，这个方法用于从写入器中移除写入的数据，这里我们已经将数据写入到写入器中，然后我们通过调用 flush()方法来刷新它。

import java.io.FileWriter;
import java.io.IOException;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		try
		{    
			FileWriter fileWriter=new FileWriter("E:\\studytonight\\output.txt");    
			String str = "Hello Studytonight";
			fileWriter.write(str);    
            fileWriter.flush(); 
            fileWriter.close();    
			System.out.println("Data Written to the file successfully");
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}    
	} 
}

数据成功写入文件

输出. txt

Hello Studytonight

示例 2: FileWriter 刷新()

这里，我们实现了一个flush() 方法的例子来清除编写器。一旦我们将数据写入其中，我们就称之为 flush 方法。此方法用于刷新编写器，这意味着此方法将删除编写器中存在的所有数据。

import java.io.FileWriter;
import java.io.IOException;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		try
		{    
			FileWriter fileWriter=new FileWriter("E:\\studytonight\\output.txt");    
			char c='A';
			fileWriter.write(c);    
            fileWriter.flush();    
			fileWriter.close();    
			System.out.println("Data Written to the file successfully");
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}    
	} 
}

数据成功写入文件

输出. txt

结论

在本教程中，我们学习了 Java 中 FileWriter 类的flush() 方法。此方法用于刷新编写器，这意味着此方法将删除编写器中存在的所有数据。它既不接受任何参数，也不返回值。

Java `InputStreamReader`方法

Java `InputStreamReader.read()`方法

原文：https://www.studytonight.com/java-file-io/java-inputstreamreader-read-method

在本教程中，我们将学习 Java 中 InputStreamReader 类的read()方法。此方法用于从当前流中读取并返回单个字符。它是一个非静态方法，在 java.io 包中可用，只能使用类对象访问。

句法

下面是这个方法的语法声明。它不接受任何参数，并返回实际读取的字符，如果到达流的末尾，则返回-1。

public int read()

示例 1:在`InputStreamReader`中读取字符

import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try  {  
			InputStream stream = new FileInputStream("E:\\studytonight\\output.txt");  
			Reader reader = new InputStreamReader(stream);  
			int data = reader.read();  
			while (data != -1) {  
				System.out.print((char) data);  
				data = reader.read();  
			}  
		} catch (Exception e) {  
			System.out.print("Error: "+e.toString());
		}  
	}
}

你好，今晚学习

输出. txt

Hello Studytonight

示例 1:在`InputStreamReader`中读取字符

在本例中，我们从流中读取数据，并将其复制到数组中，然后打印该数据。此方法从当前流中读取并返回一个字符。

import java.io.FileInputStream;
import java.io.InputStreamReader;
public class StudyTonight 
{
	public static void main(String[] args) 
	{		
		try
		{
			char[] array = new char[50];
			FileInputStream fileStream = new FileInputStream("E://studytonight//output.txt");
			InputStreamReader input = new InputStreamReader(fileStream);
			input.read(array); 
			System.out.println(array);
		}
		catch (Exception e)
		{
			System.out.print("Error: "+e.toString());
		}
	}
}

1
2
3

输出. txt

1
2
3

结论

在本教程中，我们学习了 Java 中 InputStreamReader 类的read()方法，该方法从当前流中读取并返回单个字符，如果到达流读取字符的末尾，则返回-1。

Java `InputStreamReader.ready()`方法

原文：https://www.studytonight.com/java-file-io/java-inputstreamreader-ready-method

在本教程中，我们将学习 Java 中 InputStreamReader 类的ready()方法。此方法验证当前流是否准备好由InputStreamReader读取。如果可以从基础字节流中读取字节，或者如果输入缓冲区不为空，则InputStreamReader准备就绪。

句法

下面是这个方法的语法声明。不接受任何参数。如果流准备好被读取，则返回true，否则返回false。

public boolean ready()

示例 1:`InputStreamReader`的准备方法

在这个例子中，我们将说明如何检查当前流是否准备好被InputStreamReader读取。如果可以从基础字节流中读取字节，或者如果输入缓冲区不为空，则InputStreamReader准备就绪。

import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try 
		{
			InputStream inputStream = new FileInputStream("E://studytonight//output.txt");
			InputStreamReader	inputStreamReader = new InputStreamReader(inputStream);

			boolean status = inputStreamReader.ready();
			System.out.println("inputStreamReader.ready(): " + status);
		}
		catch (Exception e)
		{
			System.out.println("Error: "+e.toString());
		}  
	}
}

inputstreamreader . ready():true

输出. txt

Hello Studytonight

示例 1:`InputStreamReader`的准备方法

在下面的示例中，我们使用 read 方法从文件中读取数据，虽然数据也打印了 ready()方法返回的值，但每次该方法都将返回真值，因为流已经准备好读取下一个值，除非所有字符读取完成。之后，它将返回假值，因为读取已经完成。

import java.io.FileInputStream;
import java.io.InputStreamReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		boolean bool = false;
		int i;
		char c;

		try
		{
			FileInputStream fileInputStream = new FileInputStream("E://studytonight//output.txt");
			InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);

			while((i = inputStreamReader.read())!=-1) 
			{
				c = (char)i;

				System.out.println("Character read: "+c);

				bool = inputStreamReader.ready();

				System.out.println("Ready to read: "+bool);
			}

		} 
		catch (Exception e)
		{
			System.out.println("Error: "+e.toString());
		}  
	}
}

人物读:H
准备读:真
人物读:e
准备读:真
人物读:l
准备读:真
人物读:l
准备读:真
人物读:o
准备读:真
人物读:
准备读:真
人物读:S
准备读:真
人物读:t
准备读:真人物读:d
准备读:真
人物读:y
准备读:真
人物读:t
准备读:真
人物读:o
准备读:真
人物读:n
准备读:真
人物读:i
准备读:真
人物读:g
准备读:真
人物读:h

输出. txt

Hello Studytonight

结论

在本教程中，我们学习了 Java 中InputStreamReader类的ready()方法，该方法告知当前流是否准备好被InputStreamReader读取。它返回true，如果流准备好了，否则，它返回false。

Java `InputStreamReader.getEncoding()`方法

原文：https://www.studytonight.com/java-file-io/inputstreamreader-getencoding-method-in-java

在本教程中，我们将学习 Java 中 InputStreamReader 类的getEncoding()方法。此方法提供当前流使用的字符编码的名称。如果流使用的是历史编码名称，它将返回该名称，否则，它将返回流的规范编码名称。

句法

下面是这个方法的语法声明。它不接受任何参数，并返回编码、历史或规范、流使用的名称，如果流关闭，则返回空值。

public String getEncoding()

示例 1:用 Java 编码`InputStreamReader`

package studytonight;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try{  
			FileInputStream file = new FileInputStream("E:\\studytonight\\output.txt");  
			InputStreamReader reader = new InputStreamReader(file, Charset.forName("UTF8"));  			
			System.out.println("Character Encoding of the reader is: "+reader.getEncoding());
		}
		catch (Exception e)	{  
			System.out.print("Error: "+e.toString());
		}  
	}
}

读取器的字符编码为:UTF8

示例 2:用 Java 编码`InputStreamReader`

。如果我们没有为流设置编码，那么这个方法将返回默认的编码，在这个例子中，我们没有设置任何编码，但是它返回了Cp1252 ，因为它被默认分配给了流。

import java.io.FileInputStream;
import java.io.InputStreamReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{  
			FileInputStream file = new FileInputStream("E:\\studytonight\\output.txt");  
			InputStreamReader reader = new InputStreamReader(file);  			
			System.out.println("Character Encoding of the reader is: "+reader.getEncoding());
		}
		catch (Exception e)	
		{  
			System.out.print("Error: "+e.toString());
		}  
	}
}

读取器的字符编码为:Cp1252

结论

在本教程中，我们将学习 Java 中 InputStreamReader 类的getEncoding()方法，该方法用于获取流使用的字符编码，该编码可能是历史的，也可能是规范的，具体取决于此。

Java `InputStreamReader.close()`方法

原文：https://www.studytonight.com/java-file-io/java-inputstreamreader-close-method

在本教程中，我们将学习 Java 中 InputStreamReader 类的close()方法。这个方法的工作是关闭 InputStreamReader 实例。调用此方法后，流上的read()、ready()、mark()、reset()或skip()方法的操作将引发 IOException。

句法

这是此方法的语法声明。它不接受任何参数，也不返回值。

public void close()

示例:关闭 Java 中的 InputStreamReader 实例

在这个例子中，一旦我们使用 InputStreamReader 从文件中读取数据，我们就使用 close()方法关闭这个流，这样它就不会有任何错误。我们关闭流以移除与之链接的资源。

import java.io.FileInputStream;
import java.io.InputStreamReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		int i;
		char c;
		try
		{
			FileInputStream	fileInputStream = new FileInputStream("E://studytonight//output.txt");
			InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
			i = inputStreamReader.read();
			c = (char)i;
			System.out.println(c);
			inputStreamReader.close();
			System.out.println("close() invoked");
		}
		catch (Exception e) 
		{
			System.out.print("Error: "+e.toString());
		} 
	}
}

H
关闭()被调用

输出. txt

Hello Studytonight

示例 2:关闭 Java 中的 InputStream 实例

import java.io.FileInputStream;
import java.io.InputStreamReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		int i;
		char c;
		try
		{
			FileInputStream	fileInputStream = new FileInputStream("E://studytonight//output.txt");
			InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
			inputStreamReader.close();
			System.out.println("close() invoked");
			i = inputStreamReader.read();
			c = (char)i;
			System.out.println(c);
		}
		catch (Exception e) 
		{
			System.out.print("Error: "+e.toString());
		} 
	}
}

close()调用了
错误:java.io.IOException:流关闭

输出. txt

Hello Studytonight

结论

在本教程中，我们学习了 Java 中 InputStreamReader 类的close()方法。此方法在被调用时将关闭当前流，并且不能对其执行进一步的操作。

Java `CharArrayReader`方法

Java `CharArrayReader.skip()`方法

原文：https://www.studytonight.com/java-file-io/java-chararrayreader-skip-method

在本教程中，我们将学习 Java 的 CharArrayReader 类的skip()方法。此方法的任务是跳过流中提供的字符数。方法会阻止流或引发异常，以防它通过跳过到达流的末尾。

句法

下面是这个方法的语法，其中要传递的字符数被接受为参数，实际跳过的字符数由方法返回。

public long skip(long n) throws IOException

示例:在 Java 中使用 Skip()方法跳过字符

在本例中，我们使用skip()方法跳过流中的字符，在调用该方法时，我们传递了 2 作为要跳过的字符数，这就是为什么输出会显示跳过 2 个字符后的流数据。

import java.io.CharArrayReader;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		try
		{
			char[] ch = { 'A', 'B', 'C', 'D', 'E' };  
			CharArrayReader charArrayReader = new CharArrayReader(ch);  
			int value = 0;  
			while ((value = charArrayReader.read()) != -1) 
			{  
				char c = (char) value;  
				System.out.print(c + " ");  
				charArrayReader.skip(2);  
			}  
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	} 
}

公元

示例 2:使用 CharArrayReader 跳过字符

这里，我们使用 skip()方法在从流中读取数据后跳过 1 个字符。当我们从这个流中读取数据时，我们将从这个流中获得备用数据输出。

import java.io.CharArrayReader;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		try
		{
			char[] ch = { 'A', 'B', 'C', 'D', 'E' };  
			CharArrayReader charArrayReader = new CharArrayReader(ch);  
			int value = 0;  
			while ((value = charArrayReader.read()) != -1) 
			{  
				char c = (char) value;  
				System.out.print(c + " ");  
				charArrayReader.skip(1);  
			}  
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	} 
}

阿、中、东

结论

在本教程中，我们学习了 Java 的 CharArrayReader 类的skip()方法，该方法用于跳过流中指定数量的字符，该数量在方法中作为参数传递。

Java `CharArrayReader.close()`方法

原文：https://www.studytonight.com/java-file-io/java-chararrayreader-close-method

在本教程中，我们将学习 Java 中 CharArrayReader 类的close()方法。此方法用于关闭字符数组读取器，并立即释放流中附加到它的所有资源。任何操作的调用，包括read ()、ready ()、mark ()、reset ()或skip ()方法，在close()方法被调用后，都会抛出一个 IOException。

句法

下面是这个方法的语法，它不需要参数，也不返回值。

public void close()

示例:使用 Close()方法关闭 Java 中的 Reader

在本例中，我们演示了close()方法的使用，当我们从流中读取数据时，我们使用close()方法关闭该流。调用此函数后，所有与流相关的资源都会被释放，在此之后我们就不能使用流了。

import java.io.CharArrayReader;
import java.io.IOException;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		CharArrayReader charArrayReader = null;  
		char[] arr = {'H', 'E', 'L', 'L', 'O'};  
		try 
		{  
			charArrayReader = new CharArrayReader(arr);  
			char c = (char)charArrayReader.read();  
			System.out.println(c);
			charArrayReader.close();  
		} 
		catch(IOException e) 
		{  
			System.out.print("Error: "+e.toString());  
		} 
	} 
}

示例 2:使用 Close()方法关闭 Java 中的 Reader

在这里，我们将看到在关闭流后尝试读取数据时会发生什么，当我们尝试从已经关闭且没有与之相关联的资源的流中读取数据时，它会导致一个异常，说:错误:java.io.IOException: Stream closed这就是我们不应该在读取之前关闭它的原因。

import java.io.CharArrayReader;
import java.io.IOException;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		CharArrayReader charArrayReader = null;  
		char[] arr = {'H', 'E', 'L', 'L', 'O'};  
		try 
		{  
			charArrayReader = new CharArrayReader(arr);  
			charArrayReader.close();  
			char c = (char)charArrayReader.read();  
			System.out.println(c);		
		} 
		catch(IOException e) 
		{  
			System.out.print("Error: "+e.toString());  
		} 
	} 
}

错误:java.io.IOException:流关闭

结论:

在本教程中，我们学习了 Java 中 CharArrayReader 类的close()方法，该方法关闭流并释放所有关联的资源，之后对流的任何操作都会引发 IOException。

Java `CharArrayReader.ready()`方法

原文：https://www.studytonight.com/java-file-io/java-chararrayreader-ready-method

在本教程中，我们将学习 Java 中 CharArrayReader 类的ready()方法。此方法检查流是否准备好被读取，并且众所周知，char 数组读取器始终准备好被读取。

句法

该方法不需要参数，返回布尔值true，如果流准备好被读取，则返回false。

public boolean ready() throws IOException

示例 CharArrayReader 的就绪方法

在这个例子中，我们将说明 ready()方法是如何工作的，通常，我们在从流中读取数据之前调用这个方法，因为如果流准备好读取，这个方法将返回true ，否则它将返回false 值。

import java.io.CharArrayReader;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		try 
		{
			char[] ch = { 'A', 'B', 'C', 'D', 'E' };

			CharArrayReader charArrayReader = new CharArrayReader(ch);

			boolean isReady = charArrayReader.ready();

			System.out.println("CharArrayReader is ready -> " + isReady);
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	} 
}

CharArrayReader 就绪- >真

示例 CharArrayReader 的就绪方法

这里，我们正在实现ready()方法来检查流是否准备好从流中读取数据，只有在流准备好读取数据之后，我们才会从流中读取数据。

import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		String s = "studytonight.com";  
		Reader reader = new StringReader(s);  
		try 
		{  
			if(reader.ready())
			{
				for (int i = 0; i < 12; i++)
				{  
					char c = (char) reader.read();  
					System.out.print("" + c);  
				}  
			}
			reader.close();  
		} 
		catch (IOException e) 
		{  
			System.out.println("Error: "+e.toString());  
		}  
	} 
}

今晚学习

结论

在本教程中，我们学习了 Java 中 CharArrayReader 类的ready()方法，该方法用于验证流是否准备好被读取，如果准备好，则返回布尔值true，否则返回false。

Java `CharArrayReader.read()`方法

原文：https://www.studytonight.com/java-file-io/java-chararrayreader-read-method

在本教程中，我们将学习 Java 中 CharArrayReader 类的read()方法。实现此方法是为了从流中读取单个字符。该方法阻塞流，直到它从流中获取一些输入，或者最终到达流的末尾，读取字符。

句法

此方法不需要参数，它以 0 到 65535 之间的整数值的形式返回从流中读取的字符，否则，如果到达流的末尾，它将返回-1。

public int read() throws IOException

示例:使用 CharArrayReader 方法读取数据

在本例中，我们使用CharArrayReader 类的read()方法从字符数组中读取数据，当我们读取数据时，该方法返回整数格式的ASCII 代码，因此我们必须将其类型转换为字符。我们将循环迭代 12 次，因为我们的字符数组包含 12 个字符。

import java.io.CharArrayReader;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		try 
		{ 
			char[] str = {'S', 't', 'u', 'd', 'y', 't', 'o', 'n', 'i', 'g', 'h', 't' }; 

			CharArrayReader reader = new CharArrayReader(str); 

			int ch; 
			for (int i = 0; i < 12; i++) 
			{ 
				ch = reader.read(); 
				System.out.print(" "+ (char)ch); 
			} 

			reader.close(); 
		} 
		catch (Exception e)
		{ 
			System.out.println("Error: "+e.toString()); 
		} 
	} 
}

新加坡元人民币

示例:使用 CharArrayReader 方法读取数据

在这里，我们从 string 中读取数据，但不是读取到控制台，而是使用另一种重载方法将其复制到字符缓冲区，然后打印出来。此方法返回复制的字符数。

import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		  String s = "studytonight";  
	      Reader reader = new StringReader(s);  
	      char charBuffer[] = new char[12];  
	      try 
	      {  
	         System.out.println(reader.read(charBuffer, 0, 12));  
	         System.out.println(charBuffer);  
	         reader.close();  
	      } 
	      catch (IOException e)
	      {  
	         System.out.println("Error: "+e.toString());
	      }  
	} 
}

12
今晚学习

结论

在本教程中，我们学习了 Java 中 CharArrayReader 类的read()方法，该方法用于从流中读取单个字符，并将其作为 0 到 65535 之间的整数值返回，或者如果到达流的末尾，则返回-1。

Java `CharArrayReader.标记()`方法

原文：https://www.studytonight.com/java-file-io/java-chararrayreader-mark-method

在本教程中，我们将学习 Java 中 CharArrayReader 类的mark()方法。该方法的工作是标记点的位置，从该位置开始读取流，调用reset()会再次将流带到mark()方法定位的点。

句法

这是此方法的语法，其中标记有效时可读取的最大字符数作为参数传递。此方法不返回任何值。

public void mark(int readAheadLimit)

示例 1:使用 CharArrayReader 标记位置

在这个例子中，我们将说明如何使用mark()方法来设置流中的位置标记，这里我们首先从字符数组中读取数据，然后调用mark()并再次读取数据，但是当我们调用reset()方法时，它使位置成为最近标记的位置，因此它将再次从该点开始读取。

import java.io.CharArrayReader;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		try 
		{
			char[] arr = {'s', 't', 'u', 'd', 'y', 't', 'o', 'n', 'i', 'g', 'h', 't'}; 
			char c;
			CharArrayReader reader = new CharArrayReader(arr); 
			c=(char)reader.read();
			System.out.println(c);  
			reader.mark(1);  
			c=(char)reader.read();
			System.out.println(c);  
			reader.reset();  
			c=(char)reader.read();
			System.out.println(c);  

			reader.close();			
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	} 
}

s
t
t

示例 2:使用 CharArrayReader 标记位置

这里我们用 mark()方法实现了一个有趣的例子，我们一个接一个地调用 mark()和 reset()方法，reset()方法将流的位置移动到最后一个标记的位置，这里最后一个标记的位置只是最近的位置，所以很明显它不会在输出中显示任何差异。

import java.io.CharArrayReader;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		try { 
            char[] arr = {'S', 't', 'u', 'd', 'y', 't', 'o', 'n', 'i', 'g', 'h', 't'}; 

            CharArrayReader reader = new CharArrayReader(arr);   

            int ch; 

            for (int i = 0; i < 5; i++) { 
                ch = reader.read(); 
                System.out.print((char)ch); 
            } 

            System.out.println(); 

            reader.mark(1); 

            reader.reset(); 

            for (int i = 0; i < 7; i++) 
            { 
                ch = reader.read(); 
                System.out.print((char)ch); 
            } 
        } 
        catch (Exception e)
		{ 
            System.out.println("Error: "+e.toString()); 
        } 
	} 
}

今晚学习

结论

在本教程中，我们学习了 Java 中 CharArrayReader 类的mark()方法，该方法用于指定如果在流中调用reset()方法，将从哪个位置开始流读取。

Java `CharArrayReader.reset()`方法

原文：https://www.studytonight.com/java-file-io/java-chararrayreader-reset-method

在本教程中，我们将学习 Java 中 CharArrayReader 类的reset()方法。此方法的调用会将流重置为最近标记的位置，或者重置为流的开头(如果流之前没有标记的话)。

句法

下面是这个方法的语法，不需要参数，也不返回任何值。

public void reset()

示例:在 Java 中重置流

在本例中，我们将演示 reset()方法的使用，首先我们在读取时标记位置，然后我们调用 reset()方法，这样它将通过 mark()方法在最近标记的位置重置流，从那时起，我们将从流中再次开始读取。

import java.io.CharArrayReader;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		try 
		{
			char[] arr = {'s', 't', 'u', 'd', 'y', 't', 'o', 'n', 'i', 'g', 'h', 't'}; 
			char c;
			CharArrayReader reader = new CharArrayReader(arr); 
			c=(char)reader.read();
			System.out.println(c);  
			reader.mark(1);  
			c=(char)reader.read();
			System.out.println(c);  
			reader.reset();  
			c=(char)reader.read();
			System.out.println(c);  

			reader.close();			
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	} 
}

s
t
t

示例 2:在 Java 中重置流

这里，我们通过 mark()方法标记流中的位置，并在此之后使用 reset()方法重置它，这样它就不会影响流的位置，因为当前位置和最后标记的位置是相同的，所以它将从流中连续读取。

import java.io.CharArrayReader;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		try { 
            char[] arr = {'S', 't', 'u', 'd', 'y', 't', 'o', 'n', 'i', 'g', 'h', 't'}; 

            CharArrayReader reader = new CharArrayReader(arr);   

            int ch; 

            for (int i = 0; i < 5; i++) { 
                ch = reader.read(); 
                System.out.print((char)ch); 
            } 

            System.out.println(); 

            reader.mark(1); 

            reader.reset(); 

            for (int i = 0; i < 7; i++) 
            { 
                ch = reader.read(); 
                System.out.print((char)ch); 
            } 
        } 
        catch (Exception e)
		{ 
            System.out.println("Error: "+e.toString()); 
        } 
	} 
}

今晚学习

结论

在本教程中，我们学习了 Java 中 CharArrayReader 类的reset()方法，该方法用于通过mark()方法将流重新定位到最后一个标记点，否则，如果之前没有标记，则定位到流的起点。

Java `CharArrayReader.markSupported()`方法

原文：https://www.studytonight.com/java-file-io/java-chararrayreader-marksupported-method

在本教程中，我们将学习 Java 中 CharArrayReader 类的markSupported()方法。该方法验证流是否支持mark()方法。char 数组读取器支持mark()方法。

句法

该方法不需要参数，返回类型为布尔型，如果可以调用mark()方法则返回 true，否则返回 false。

public boolean markSupported()

示例 1: CharArrayReader 标记支持

在这个例子中，我们将演示如何使用 markSupported()方法，我们使用这个方法来检查流是否支持 mark 方法。当我们调用此方法时，如果流支持 mark()方法，它将返回 true，如果不支持 mark()方法，它将返回 false。

import java.io.CharArrayReader;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		try 
		{ 
			char[] str = {'H', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd'}; 	  
			CharArrayReader reader = new CharArrayReader(str); 	  
			System.out.println("Is CharArrayReader markSupported: "+ reader.markSupported()); 	  
			reader.close(); 
		} 
		catch (Exception e) 
		{ 
			System.out.println("Error: "+e.toString()); 
		} 
	} 
}

是否支持 CharArrayReader 标记:真

示例 1: CharArrayReader 标记支持

这里我们将使用 markSupported()方法来检查当前流是否支持 mark()方法，当我们调用此方法时，如果流支持 mark()方法，它将返回 true，如果不支持 mark()方法，它将返回 false。

import java.io.CharArrayReader;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		char[] ch = {'H', 'e', 'l', 'l', 'o'};  
		CharArrayReader charArrayReader = new CharArrayReader(ch);  
		boolean bool = charArrayReader.markSupported();  
		System.out.println("Is mark supported : " + bool);  
	} 
}

是否支持标记:真

结论:

在本教程中，我们学习了 Java 中 CharArrayReader 类的markSupported()方法，该方法用于检查当前流是否支持mark()方法的调用。

Java `FilterReader`方法

Java `FilterReader.read()`方法

原文：https://www.studytonight.com/java-file-io/filterreader-read-method-in-java

在本教程中，我们将在 Java 中学习 FilterReader 类的read() 方法。此方法的任务是从给定的FilterReader中读取单个字符。这个read()方法一次从流中读取一个字符，并将其作为整数值返回。

句法

这是 read()方法的语法声明，该方法不接收任何参数，但返回整数格式的 ASCII 值。

public int read()

示例 1:过滤器读取器的读取方法

在下面的例子中，我们实现了FilterReader类的 read()方法来读取文件中的数据。这里，我们使用的方法没有修改，所以我们将得到与文本文件中相同的结果。在下一个示例中，我们将看到如何定制 read 方法，以便按照我们的要求以特定的格式读取数据。

package studytonight;
import java.io.FileReader;
import java.io.FilterReader;
import java.io.Reader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			Reader reader = new FileReader("E:\\studytonight\\output.txt");  
			FilterReader filterReader = new FilterReader(reader) {};  
			int i;  
			while ((i = filterReader.read()) != -1) {  
				System.out.print((char) i);  
			}  
			filterReader.close();  
			reader.close();  
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

你好，今晚学习

输出. txt

Hello Studytonight

示例 2:过滤器读取器的读取方法

在本例中，我们将看到如何通过覆盖类中的方法来将修改应用于 FilterReader 类的方法。这里我们将覆盖 read 方法，每当出现``' ' (空格)时，它将返回 '*' (星号)符号。为此，我们首先声明了 MyReader 类，并继承了 FilterReader 类，然后我们覆盖了上面提到的逻辑的读取方法。在输出中，我们可以看到每当出现空格时，它都会返回星号。

package studytonight;
import java.io.FileReader;
import java.io.FilterReader;
import java.io.IOException;
import java.io.Reader;
class MyReader extends FilterReader
{
	protected MyReader(Reader in) 
	{
		super(in);
	}

	public int read() throws IOException
	{  
		int x = super.read();  
		if ((char) x == ' ')  
			return ('*');  
		else  
			return x;  
	}  	
}

public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			Reader reader = new FileReader("E:\\studytonight\\output.txt");  
			MyReader filterReader = new MyReader(reader);  
			int i;  
			while ((i = filterReader.read()) != -1) {  
				System.out.print((char) i);  
			}  
			filterReader.close();  
			reader.close();  
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

你好，今晚学习

输出. txt

Hello Studytonight

结论

在本教程中，我们学习了 Java 中 FilterReader 类的 read()方法。此方法的任务是从给定的FilterReader中读取单个字符。这个read()方法一次从流中读取一个字符，并将其作为整数值返回。

Java `FilterReader.mark()`方法

原文：https://www.studytonight.com/java-file-io/filterreader-mark-method-in-java

在本教程中，我们将在 Java 中学习 FilterReader 类的mark()方法。此方法标记流中的当前位置，当我们调用 reset()方法时，我们可以通过 mark()方法检索最近标记的位置，并且我们可以从该位置开始读取。

句法

这是mark()方法的语法声明，这个方法不返回任何东西，因为它的返回类型是 void，但是它将一个参数作为readAheadLimit，基本上，它限制了可以读取的字符数量，同时仍然保留了标记。

public void mark(int readAheadLimit)

示例 1:过滤器读取器的标记方法

在本例中，我们将演示 mark()方法的使用，我们调用该方法来标记缓冲区的位置，当我们调用 reset 方法时，它将转到最近标记的位置，从该位置，我们可以进一步读取数据。

import java.io.FilterReader;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		FilterReader fr = null;
		Reader r = null;      

		try 
		{
			r = new StringReader("ABCDEF");

			fr = new FilterReader(r) {};

			System.out.println((char)fr.read());
			System.out.println((char)fr.read());

			fr.mark(0);
			System.out.println("mark() called");
			System.out.println((char)fr.read());
			System.out.println((char)fr.read());

			fr.reset();
			System.out.println("reset() called");
			System.out.println((char)fr.read());
			System.out.println((char)fr.read());

		} 
		catch(IOException e)
		{
			System.out.println("Error: "+e.toString());
		}  
	}
}

A
B
标记()称为
C
D
复位()称为
C
D

示例 2:过滤器读取器的标记方法

在这里，我们实现了 mark()方法，但是我们不会使用 reset()方法来显示这两种方法是如何一起工作的，当我们调用 mark()方法时，它会标记缓冲区的位置并开始读取数据。如果我们不调用 reset()方法，那么显然它在 read()方法的工作中不会显示任何差异。

import java.io.FilterReader;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		FilterReader fr = null;
		Reader r = null;      
		try 
		{
			r = new StringReader("ABCDEF");
			fr = new FilterReader(r) {};
			System.out.println((char)fr.read());
			System.out.println((char)fr.read());
			fr.mark(0);
			System.out.println("mark() called");
			System.out.println((char)fr.read());
			System.out.println((char)fr.read());
			System.out.println((char)fr.read());
			System.out.println((char)fr.read());
		} 
		catch(IOException e)
		{
			System.out.println("Error: "+e.toString());
		}  
	}
}

A
B
标记()称为
C
D
E
F

结论

在本教程中，我们学习了 Java 中 FilterReader 类的 mark()方法。此方法标记流中的当前位置，当我们调用 reset()方法时，我们可以通过 mark()方法检索最近标记的位置，并且我们可以从该位置开始读取。

Java `FilterReader.ready()`方法

原文：https://www.studytonight.com/java-file-io/filterreader-ready-method-in-java

在本教程中，我们将学习 Java 中 FilterReader 类的ready()方法。此方法用于检查该流是否准备好被读取。这是一个非静态方法，只能用类对象访问，如果我们试图用类名访问这个方法，那么我们会得到一个错误。

句法

这是一个ready()方法的语法声明，这个方法不接受任何参数，根据流是否准备好读取返回布尔值。

public boolean ready();

示例 1:过滤器读取器的准备方法

在这个例子中，我们调用 ready()方法来检查流是否准备好从中读取数据，这里这个方法返回的是真值，这意味着这个方法已经准备好读取数据了。

import java.io.FilterReader;
import java.io.Reader;
import java.io.StringReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			Reader reader = new StringReader("Welcome to Studytonight"); 
			FilterReader filterReader = new FilterReader(reader){}; 

			boolean isReady = filterReader.ready(); 
			System.out.println("Stream is ready to read:"+isReady);
			filterReader.close(); 
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

流已准备好读取:真

示例 2:过滤器读取器的准备方法

在这个例子中，我们实现了FIlterReader 类的各种方法。在这里，最初，我们使用 StringReader 类创建了一个读取器。然后通过使用FilterReader 类的 skip()方法，它将跳过读取前 8 个字符，并指向第 9 个字符，这就是为什么当我们试图读取时，它将从第 9 个字符开始。我们可以使用ready()方法来检查读者是否准备好阅读。在程序中，我们从第 9 个位置开始向前读取 8 个字符，然后在调用 reset()方法后指针将回到初始位置。我们可以看到，当我们在重置方法后读取数据时，它会从头开始显示。

import java.io.FilterReader;
import java.io.Reader;
import java.io.StringReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			Reader reader = new StringReader("Welcome to Studytonight"); 
			FilterReader filterReader = new FilterReader(reader){}; 
			char ch[] = new char[28]; 		
			filterReader.skip(8); 
			if(filterReader.ready()) 
			{ 
				filterReader.read(ch); 
				for (int i = 0; i < 8; i++)  
				{ 
					System.out.print(ch[i]); 
				} 
				System.out.print("\n");		

				filterReader.reset(); 
				for (int i = 0; i <7; i++) 
				{ 
					System.out.print((char)filterReader.read()); 
				} 
			} 
			filterReader.close(); 
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

学习

欢迎

结论

在本教程中，我们学习了 ready()方法，该方法用于检查该流是否准备好被读取。这是一个非静态方法，只能用类对象访问，如果我们试图用类名访问这个方法，那么我们会得到一个错误。

Java `FilterReader.close()`方法

原文：https://www.studytonight.com/java-file-io/java-filterreader-close-method

在本教程中，我们将学习 Java 中 FilterReader 类的close()方法。此方法关闭流并释放与其关联的所有系统资源。调用此方法会使调用read()、ready()、mark()、reset()或skip()方法无效。这个非静态方法在 java.io 包中可用，只能使用类对象访问，试图通过类名调用它会导致错误。

句法

这是此方法的语法声明，它不接受任何参数或返回值。

public void close()

示例 1:在 Java 中关闭 FilterReader

在这个例子中，我们已经创建了一个 FilterReader 流来读取数据，在这个特殊的例子中，我们正在检查这个流是否支持 mark()方法，一旦与这个流相关的操作完成，我们就调用 close()方法来释放所有链接的或者当前为这个流分配的资源，在这之后我们就不能使用这个流了。

import java.io.FilterReader;
import java.io.Reader;
import java.io.StringReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			Reader reader = new StringReader("Hello Studeytonight"); 
			FilterReader fileReader = new FilterReader(reader){};

			boolean isSupported = fileReader.markSupported();			
			System.out.println("The Stream Supports the mark() method: "+isSupported);	

			fileReader.close(); 
			System.out.println("FilterReader is closed successfully...");			
		}
		catch(Exception e)
		{
			System.out.print("Error: "+e.toString());
		}
	} 
}

流支持标记()方法:真
过滤器读取器成功关闭...

示例 1:在 Java 中关闭 FilterReader

在本例中，我们从FIlterReader 流中读取数据，读取完成后，我们使用 close()方法关闭该流，以释放与该流链接的所有资源。

import java.io.FilterReader;
import java.io.Reader;
import java.io.StringReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			Reader reader = new StringReader("Hello Studeytonight"); 
			int i;
			FilterReader filterReader = new FilterReader(reader) {};

			while ((i = filterReader.read()) != -1) {
				char  c = (char) i;
				System.out.print(c);
			}

			filterReader.close(); 
			System.out.println("\nFileReader is closed successfully...");
		}
		catch(Exception e)
		{
			System.out.print("Error: "+e.toString());
		}
	} 
}

学生好今晚
FileReader成功关闭...

结论

在本教程中，我们学习了 Java 中 FilterReader 类的close()方法，该方法用于关闭流并释放所有链接到它的资源。它在 java.io 包中可用，应该只使用类对象来访问。

Java `FilterReader.markSupported()`方法

原文：https://www.studytonight.com/java-file-io/java-filterreader-marksupported-method

在本教程中，我们将学习 Java 中 FilterReader 类的markSupported()方法。该方法验证该FileReader流是否支持mark()方法的操作。这是一个非静态方法，在 java.io 包中可用。它只能使用类对象来访问，因为试图用类名来访问它会抛出一个 IOException。

句法

这是此方法的语法声明。不需要参数。该方法的返回类型为布尔型，表示支持mark()方法则返回 true，否则返回 false。

public boolean markSupported()

示例 1:过滤器读取器中的标记支持

markSupported()方法用于检查当前缓冲区是否支持 mark()方法，在当前示例中，我们首先检查该方法是否支持 mark()方法，然后在流中的当前位置设置标记，这样可以避免可能的错误。

import java.io.FileReader;
import java.io.FilterReader;
import java.io.Reader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			Reader reader = new FileReader("E:\\studytonight\\output.txt");  
			FilterReader filterReader = new FilterReader(reader) {};  
			int i;  
			while ((i = filterReader.read()) != -1) {  
				System.out.print((char) i);  
			}  
			filterReader.close();  
			reader.close();  
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

你好，今晚学习

输出. txt

Hello Studytonight

示例 1:过滤器读取器中的标记支持

这是上面程序的简化版本，这里我们正在检查当前缓冲区是否支持 mark()方法，那么 markSupported()方法将返回true 值，否则将返回false 值。

import java.io.FilterReader;
import java.io.Reader;
import java.io.StringReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			Reader reader = new StringReader("Hello Studeytonight"); 
			FilterReader fileReader = new FilterReader(reader){};

			boolean isSupported = fileReader.markSupported();

			System.out.println("The Stream Supports the mark() method: "+isSupported);

			fileReader.close(); 
		}
		catch(Exception e)
		{
			System.out.print("Error: "+e.toString());
		}
	} 
}

流支持标记()方法:真

结论

在本教程中，我们学习了 Java 中 FilterReader 类的markSupported()方法，用于检查当前流是否支持mark()方法。如果是，则返回真，否则返回假。

Java `FilterReader.reset()`方法

原文：https://www.studytonight.com/java-file-io/java-filterreader-reset-method

在本教程中，我们将学习 Java 中 FilterReader 类的reset()方法。调用此方法将流重置到最近调用mark()方法的位置。这是一个非静态方法，在 java.io 包中可用，只能用类对象访问，否则用类名访问会抛出IOException。

句法

这是此方法的语法声明。它不接受任何参数或返回任何值，因为它的返回类型是 void。

public void reset()

示例 1:在 Java 中重置 FilterReader

在本例中，我们将说明 reset()方法的使用，该方法将流的当前读取位置移动到最近标记的位置。在这里，我们首先检查这个流是否支持 mark()方法和标记流开头的位置，然后我们读取前五个字符，然后我们调用 reset()方法，这样当我们调用 reset()方法时，它会将指针移动到流的初始位置，并再次从流的开头开始读取。

import java.io.FilterReader;
import java.io.Reader;
import java.io.StringReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			Reader reader = new StringReader("Hello Studytonight"); 
			FilterReader fileReader = new FilterReader(reader){}; 
			char ch[] = new char[8]; 

			if(fileReader.markSupported()) 
			{ 
				fileReader.mark(100); 
			} 
			fileReader.read(ch); 
			for (int i = 0; i < 5; i++)  
			{ 
				System.out.print(ch[i]); 
			} 
			fileReader.reset(); 
			for (int i = 0; i <5 ; i++) 
			{ 
				System.out.print((char)fileReader.read()); 
			} 
			fileReader.close(); 
		}
		catch(Exception e)
		{
			System.out.print("Error: "+e.toString());
		}
	} 
}

地狱深渊

示例 1:在 Java 中重置 FilterReader

如果我们一个接一个地调用 mark()和 reset()方法，那么显然它们不会显示任何效果，因为最近标记的位置和当前的读取位置是相同的。在这种情况下，它将继续从当前位置读取。

import java.io.FilterReader;
import java.io.Reader;
import java.io.StringReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			Reader reader = new StringReader("Hello Studytonight"); 
			FilterReader fileReader = new FilterReader(reader){};
			for (int i = 0; i <5 ; i++) 
			{ 
				System.out.print((char)fileReader.read()); 
			} 
			if(fileReader.markSupported()) 
			{ 
				fileReader.mark(100); 
			} 
			fileReader.reset(); 
			for (int i = 0; i <14; i++) 
			{ 
				System.out.print((char)fileReader.read()); 
			} 
			fileReader.close(); 
		}
		catch(Exception e)
		{
			System.out.print("Error: "+e.toString());
		}
	} 
}

你好，今晚学习

结论

在本教程中，我们学习了 Java 中 FilterReader 类的reset()方法，该方法用于将流重置到最近调用mark()方法的位置。

Java `FilterReader.skip()`方法

原文：https://www.studytonight.com/java-file-io/java-filterreader-skip-method

在本教程中，我们将学习 Java 中 FilterReader 类的skip()方法。这个方法，当被调用时，跳过这个过滤器读取器提供的 n 字符数。它是一个非静态方法，在 java.io 包中可用，只能使用类对象访问，当使用类名访问时会引发 IOException。

句法

下面是这个方法的语法声明。它以n要跳过的字符数为参数，返回跳过的字符总数。

public long skip(long n)

示例 1:跳过 Java 中的字符

在本例中，我们将使用方法skip() 在阅读时跳过流中的一些字符。在这里，我们每次从流中读取数据时都会调用这个方法，这样我们就可以将输出作为流的替换字符。

import java.io.FileReader;
import java.io.FilterReader;
import java.io.Reader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			Reader reader = new FileReader("E:\\studytonight\\output.txt");  
			FilterReader filterReader = new FilterReader(reader) {};  
			int i;  
			while ((i = filterReader.read()) != -1) 
			{  
				System.out.print((char) i);  
				filterReader.skip(1);
			}  
			filterReader.close();  
			reader.close();  
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

1 3 5 7 9

输出. txt

1 2 3 4 5 6 7 8 9 10

示例 1:跳过 Java 中的字符

通过使用 skip()方法，我们可以一次跳过多个字符，例如在下面给出的程序中，我们调用 skip()方法，并传递 4 作为跳过的参数，因此它将跳过流中的前 4 个字符，并从第 5 个字符开始读取。

import java.io.FileReader;
import java.io.FilterReader;
import java.io.Reader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			Reader reader = new FileReader("E:\\studytonight\\output.txt");  
			FilterReader filterReader = new FilterReader(reader) {};  
			int i;  			
			filterReader.skip(4);
			while ((i = filterReader.read()) != -1) 
			{  
				System.out.print((char) i);  
			}  
			filterReader.close();  
			reader.close();  
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

今晚

输出. txt

Studytonight

结论

在本教程中，我们学习了 Java 中 FilterReader 类的skip()方法，该方法用于跳过流中给定数量的字符，方法是将要跳过的字符数作为参数，并返回实际跳过的字符数。

Java `BufferedReader`

Java `BufferedReader.close()`方法

原文：https://www.studytonight.com/java-file-io/java-bufferedreader-close-method

在本教程中，我们将学习 Java 中bufferedeeder类的 close()方法。此方法用于关闭此BufferedReader 流，并释放与此流链接的所有其他系统资源。这是一个非静态方法，只能用类对象访问，如果我们试图用类名访问这个方法，那么我们会得到一个错误。

句法

这是 close()方法的语法声明，该方法不接受任何参数，也不返回任何参数。

public void close() throws IOException

示例 1:关闭缓冲区缓存器实例

在这个例子中，我们将实现 close()方法，首先我们从文件中读取所需的数据，一旦数据被成功读取，然后我们调用 close()方法来关闭我们从中读取数据的 BufferedReaader 流，它将释放与该流链接的所有其他系统资源。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
        FileReader fileReader  = new FileReader("E://studytonight//output.txt"); 

        BufferedReader buffReader = new BufferedReader(fileReader); 

        while (buffReader.ready()) 
        { 
        	char c = (char)buffReader.read();
            System.out.print(c);  
        } 
        fileReader.close();
        bufferReader.close();
	} 
}

你好，今晚学习

输出. txt

Hello Studytonight

示例 1:关闭`FileReader`实例

在这里，我们已经创建了BufferedReader，之后我们使用readLine()方法读取数据，然后我们调用 close()方法释放与之相关的所有系统资源。

import java.io.BufferedReader;
import java.io.FileReader;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		try 
		{
			FileReader	fileReader = new FileReader("E://studytonight//output.txt"); 
			BufferedReader buffReader = new BufferedReader(fileReader);
			System.out.println(buffReader.readLine()); 
			fileReader.close();
			buffReader.close();			
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	} 
}

ABC

输出. txt

ABC

结论

在本教程中，我们学习了 Java 中 BufferedReader 类的 close()方法。他的方法用于关闭这个BufferedReader 流，并释放与这个流链接的所有其他系统资源。这是一个非静态方法，只能用类对象访问，如果我们试图用类名访问这个方法，那么我们会得到一个错误。

Java `BufferedReader.skip()`方法

原文：https://www.studytonight.com/java-file-io/java-bufferedreader-skip-method

在本教程中，我们将学习 Java 中bufferedeeler类的skip()方法。在流中跳过在方法中作为参数传递的字符数。可以在java.io包中找到。

句法

下面是该方法的语法声明，“n”表示要跳过的字符数，它返回该方法跳过的实际字符数。

public long skip(long n) throws IOException

例 1

在这个例子中，我们使用FileReader和缓冲Reader类从文件中读取数据，我们还通过调用 ready() 方法检查缓冲读取器是否准备好读取。当缓冲读取器准备就绪时，我们打印每个字符，并使用 skip()方法跳过 1 个字符，我们将在输出屏幕上获得替换字符。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
        FileReader fileReader  = new FileReader("E://studytonight//output.txt"); 

        BufferedReader buffReader = new BufferedReader(fileReader); 

        while (buffReader.ready()) 
        { 
            System.out.print((char)buffReader.read());  
            buffReader.skip(1); 
        } 
	} 
}

hlosyoih

输出. txt

Hello Studytonight

例 2

这里我们实现的程序与上面例子中给出的相同，但是我们在每次迭代中从文件中读取时会跳过两个字符，所以这次输出会有所不同。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
        FileReader fileReader  = new FileReader("E://studytonight//output.txt"); 

        BufferedReader buffReader = new BufferedReader(fileReader); 

        while (buffReader.ready()) 
        { 
            System.out.print((char)buffReader.read());  
            buffReader.skip(2); 
        } 
	} 
}

Hlsdog

输出. txt

Hlsdog

结论

在本教程中，我们学习了 Java 中BufferedReader类的skip()方法，该方法用于跳过流中的 n 个字符。

Java `BufferedReade.read()`方法

原文：https://www.studytonight.com/java-file-io/java-bufferedreader-read-method

在本教程中，我们将在 Java 中学习bufferedeeler类的read()方法。此方法的任务是从给定的缓冲读取器中读取单个字符。这个read()方法一次从缓冲流中读取一个字符，并将其作为整数值返回。

句法

此方法以整数的形式返回由该方法读取的字符。如果已经到达流的末尾，该方法返回-1。

public int read() throws IOException

例 1

在这个例子中，我们实现了 buffere Reader 类的 read()来从源中读取数据，这里我们创建了 FileReader 并将其连接到 buffere reader，然后我们通过调用方法 ready()来检查缓冲的 reader 是否准备好了，一旦缓冲准备好了，我们就打印，直到它到达文件的末尾。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
        FileReader fileReader  = new FileReader("E://studytonight//output.txt"); 

        BufferedReader buffReader = new BufferedReader(fileReader); 

        while (buffReader.ready()) 
        { 
        	char c = (char)buffReader.read();
            System.out.print(c);  
        } 
	} 
}

你好，今晚学习

输出. txt

你好，今晚学习

例 2

import java.io.BufferedReader;
import java.io.FileReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			FileReader fileReader=new FileReader("E:\\studytonight\\output.txt");    
			BufferedReader br=new BufferedReader(fileReader);    
			int i;    
			while((i=br.read())!=-1){  
				System.out.print((char)i);  
			}  
			br.close();    
			fileReader.close();    
		}
		catch(Exception e)
		{
			System.out.print(false);
		}
	}
}

这是一篇课文。

输出. txt

这是一篇课文。

结论

在本教程中，我们学习了 Java 中bufferedeeler类的read() 方法，该方法从给定的缓冲读取器中读取单个字符，并将其作为整数值返回。

Java `BufferedReader.readLine()`方法

原文：https://www.studytonight.com/java-file-io/java-bufferedreader-readline-method

在本教程中，我们将学习buffere reader类的readLine() 方法。Java 中BufferedReader 类的readLine()方法是用来一次读取一行文本的。一条线的终点由这些符号‘\n’或‘\r’或EOF检测。

句法

这是 readLine()方法的语法声明，该方法不返回任何值，而是从输入源读取后返回一个字符串。

public String readLine() throws IOException

例 1

import java.io.BufferedReader;
import java.io.InputStreamReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			BufferedReader reader =new BufferedReader(new InputStreamReader(System.in));
			System.out.println("Enter your name: ");
			String name = reader.readLine();   
			System.out.println("Hello "+name);
		}
		catch(Exception e)
		{
			System.out.print(false);
		}
	}
}

输入你的名字:
Java
你好 Java

例 2

在本例中，我们从给定的文件中一行行地读取文本，该文件是输入数据的来源。readLine()方法一次读取整行。一条线的终点由这些符号‘\n’或‘\r’或EOF检测。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		String line = null;
		try 
		{
			FileReader	fileReader = new FileReader("E://studytonight//output.txt"); 
			BufferedReader br = new BufferedReader(fileReader);
			while ((line = br.readLine()) != null) 
			{
				System.out.println(line);
			}       
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	} 
}

你好，今晚学习

输出. txt

Hello studytonight

结论

在本教程中，我们学习了BufferedReader 类的readLine()方法。Java 中BufferedReader 类的readLine()方法用于一次读取一行文本。一条线的终点由这些符号‘\n’或‘\r’或EOF检测。

Java `BufferedReader.markSupported()`方法

原文：https://www.studytonight.com/java-file-io/bufferedreader-marksupported-method-in-java

在本教程中，我们将学习 Java 中buffere reader类的 markSupported() 方法。Java 中BufferedReader 类的markSupported() 方法用于验证流是否支持mark() 方法。如果流支持mark()，则返回布尔值 true，否则返回 false。

句法

这是markSupported() 方法的语法声明，这个方法不接受任何参数。此方法返回一个布尔值，指示流对 mark()方法的支持能力。

public boolean markSupported()

例 1

在本例中，我们正在检查给定的流是否支持 mark()方法，在本例中，markSupported()方法正在返回真值，这意味着该流支持 mark()方法

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		try 
		{
			FileReader	fileReader = new FileReader("E://studytonight//output.txt"); 
			BufferedReader br = new BufferedReader(fileReader);
			System.out.println(br.markSupported());  
			fileReader.close();
			br.close();
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	} 
}

真

例 2

在本例中，我们正在检查给定的流是否支持 mark()方法，在本例中，markSupported()方法返回了 false 值，这意味着该流不支持 mark()方法

import java.io.BufferedReader;
import java.io.FileReader;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		try 
		{
			FileReader	fileReader = new FileReader("E://abc.txt"); 
			BufferedReader br = new BufferedReader(fileReader);
			System.out.println(br.markSupported());  
			fileReader.close();
			br.close();
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	} 
}

假

结论:

在本教程中，我们学习了 Java 中buffere reader类的markSupported() 方法。Java 中BufferedReader 类的markSupported() 方法用于验证流是否支持mark() 方法。如果流支持mark()，则返回布尔值 true，否则返回 false。

Java `BufferedReader.ready()`方法

原文：https://www.studytonight.com/java-file-io/java-bufferedreader-ready-method

在本教程中，我们将在 Java 中学习buffere reader类的ready()方法。这个方法检查缓冲流是否准备好被读取。缓冲的字符流只在两种情况下进行，要么缓冲区不为空，要么主流准备就绪。

句法

这是这个方法的语法。该方法不需要参数，如果流准备好被读取，则返回true，否则返回false。

public boolean ready() throws IOException

示例 1:buffere reader ready()方法

在这个例子中，我们正在检查流是否准备好读取。在这个例子中，当我们调用 ready()方法时，它正在打印 true，这意味着给定的流已经准备好从中读取数据。

import java.io.BufferedReader;
import java.io.FileReader;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		try 
		{
			FileReader	fileReader = new FileReader("E://studytonight//output.txt"); 
			BufferedReader br = new BufferedReader(fileReader);

			boolean ready = br.ready();

			System.out.println("Stream is ready to read: "+ready);  
			fileReader.close();
			br.close();
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	} 
}

流已准备好读取:真

示例 2:buffere reader ready()方法

在本例中，我们检查流是否准备好读取，然后从流中读取字符，直到 ready()方法给出 true 输出。一旦 ready()方法返回 false 输出，我们就停止从中读取数据。

import java.io.BufferedReader;
import java.io.FileReader;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		try 
		{
			FileReader	fileReader = new FileReader("E://studytonight//output.txt"); 
			BufferedReader buffReader = new BufferedReader(fileReader);
			boolean ready = buffReader.ready();
			while (ready) 
			{ 
				System.out.print((char)buffReader.read()); 
				ready = buffReader.ready(); 
			} 
			fileReader.close();
			buffReader.close();			
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	} 
}

你好，今晚学习

结论

在本教程中，我们学习了 Java 中buffere reader类的ready()方法，该方法确认缓冲流是否准备好被读取，并根据读取结果返回真或假。

Java `BufferedReader.reset()`方法

原文：https://www.studytonight.com/java-file-io/java-bufferedreader-reset-method

在本教程中，我们将学习 Java 中bufferedeeder类的reset()方法。此方法的工作是将流重置到最近标记的位置，这使得同一字节再次可读。

句法

下面是这个方法的语法，这个方法不需要参数，也不返回值。

public void reset() throws IOException

示例 1:缓冲处理器复位()方法

在本例中，我们使用readLine()方法从流中读取行，然后在该点标记位置，之后我们调用 reset()方法，这样它会将流的位置重置到最近标记的位置，并再次从该点读取数据。

import java.io.BufferedReader;
import java.io.FileReader;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		try 
		{
			FileReader	fileReader = new FileReader("E://studytonight//output.txt"); 
			BufferedReader buffReader = new BufferedReader(fileReader);

			System.out.println(buffReader.readLine());  
			buffReader.mark(1);  
			System.out.println(buffReader.readLine());  
			buffReader.reset();  
			System.out.println(buffReader.readLine());  

			fileReader.close();
			buffReader.close();			
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	} 
}

你好今晚学习
欢迎今晚学习
欢迎今晚学习

输出. txt

Hello studytonight
Welcome to studytonight

示例 2:缓冲处理器复位()方法

这里我们实现了 reset()方法，我们可以在下面给出的代码中看到，首先我们读取行，并通过调用 mark()方法标记位置，然后我们再次使用 readLine()方法读取这两行，在调用 reset()方法之后，它将标记流在最近标记位置的位置，并从该点开始读取。

import java.io.BufferedReader;
import java.io.FileReader;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		try 
		{
			FileReader	fileReader = new FileReader("E://studytonight//output.txt"); 
			BufferedReader buffReader = new BufferedReader(fileReader);

			System.out.println(buffReader.readLine());  
			buffReader.mark(1);  
			System.out.println(buffReader.readLine());  
			System.out.println(buffReader.readLine());  
			System.out.println(buffReader.readLine());  
			System.out.println(buffReader.readLine());  
			buffReader.reset();
			System.out.println("After Calling the reset() method");
			System.out.println(buffReader.readLine());  
			System.out.println(buffReader.readLine());  
			System.out.println(buffReader.readLine());  
			fileReader.close();
			buffReader.close();			
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	} 
}

1
2
3
4
5
调用复位()方法后
2
3
4

输出. txt

结论

在本教程中，我们学习了 Java 中bufferedeeler类的reset()方法，该方法将流重置为最近的标记，如果标记的值已经无效或以前从未在流上标记过，则抛出异常。

Java `BufferedReader.mark()`方法

原文：https://www.studytonight.com/java-file-io/java-bufferedreader-mark-method

在本教程中，我们将学习 Java 中 BufferReader 类的mark()方法。此方法标记缓冲区读取器流中的当前位置。一旦这个方法被调用，同一个 BufferedReader 类的reset()方法随后被调用，这将流重置到最近的点。

句法

下面是这个方法的语法，其参数是readAheadLimit，表示在标记无效之前可以读取的最大字符数。该方法的返回类型为void。

public void mark(int readAheadLimit) throws IOException

示例 1:缓冲恐惧者标记()方法

在这个例子中，我们正在实现mark()方法，首先我们从BufferedReader 读取数据，然后调用mark() a 方法，这样我们就可以稍后从这个位置检索数据，我们再次开始读取数据。当我们调用 reset()方法时，它将通过mark() 方法在最近标记的位置设置流的位置，我们将从该位置开始读取数据。

import java.io.BufferedReader;
import java.io.FileReader;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		try 
		{
			FileReader	fileReader = new FileReader("E://studytonight//output.txt"); 
			BufferedReader buffReader = new BufferedReader(fileReader);

			System.out.println(buffReader.readLine());  
			buffReader.mark(1);  
			System.out.println(buffReader.readLine());  
			buffReader.reset();  
			System.out.println(buffReader.readLine());  

			fileReader.close();
			buffReader.close();			
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	} 
}

你好今晚学习
欢迎今晚学习
欢迎今晚学习

输出. txt

Hello studytonight
Welcome to studytonight

示例 2:缓冲恐惧者标记()方法

在这个例子中，我们通过调用 mark()方法来标记流中的位置，这样我们就可以在需要的时候从这些位置开始读取数据，这里我们首先读取数据并标记()位置。当我们调用 reset()方法时，它将通过mark() 方法将流的位置设置在最近标记的位置，我们将从该位置开始读取数据。

import java.io.BufferedReader;
import java.io.FileReader;
class StudyTonight
{
	public static void main(String[] args)  
	{ 
		try 
		{
			FileReader	fileReader = new FileReader("E://studytonight//output.txt"); 
			BufferedReader buffReader = new BufferedReader(fileReader);

			System.out.println(buffReader.readLine());  
			buffReader.mark(1);  
			System.out.println(buffReader.readLine());  
			System.out.println(buffReader.readLine());  
			System.out.println(buffReader.readLine());  
			System.out.println(buffReader.readLine());  
			buffReader.reset();
			System.out.println("After Calling the reset() method");
			System.out.println(buffReader.readLine());  
			System.out.println(buffReader.readLine());  
			System.out.println(buffReader.readLine());  
			fileReader.close();
			buffReader.close();			
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	} 
}

1
2
3
4
5
调用复位()方法后
2
3
4

输出. txt

结论

在本教程中，我们学习了 Java 中buffere reader类的mark()方法，该方法标记了缓冲区读取器流中的当前位置，而同一个类的reset()方法将该流固定在这一点上。

Java `FilterInputStream`方法

Java `FilterInputStream.read()`方法

原文：https://www.studytonight.com/java-file-io/java-filterinputstream-read-method

在本教程中，我们将学习 Java 中 FilterInputStream 类的read()方法。此方法用于从当前输入流中读取一个字节的数据。如果没有可用的输入，它将阻塞。这是一个非静态方法，在 java.io 包中可用。

句法

这是此方法的语法声明。它不接受任何参数，并返回数据的下一个字节，如果到达文件末尾，则返回-1。

public int read()

示例 1:用 Java 从输入流中读取字节

在下面的示例中，我们将从文件中读取数据。首先，我们通过在构造器中传递文件路径，使用 FilterInputStream 类创建了一个输入流。然后使用 read()方法，我们逐个读取每个字符，直到流到达末尾。当我们到达流的末尾时，它返回-1。

package com.studytonight;

import java.io.IOException;
import java.io.FilterInputStream;

public class studytonight {
   public static void main(String[] args) throws IOException {
      FilterInputStream st = null;
      int i = 0;
      char c;

      try
      {
         st = new FilterInputStream("E:/studytonight/output.txt");

         while((i = st.read())!=-1) 
         {

            c = (char)i;

            System.out.print(c);
         }

      }
      catch(Exception ex)
      {
         ex.printStackTrace();
      }  
   }
}

输出. txt

Hello Studytonight

你好，今晚学习

示例 2:用 Java 从输入流中读取字节

在本例中，我们从流中读取数据，然后打印该数据。此方法从当前流中读取并返回一个字节的数据。

import java.io.FilterInputStream;

public class StudyTonight{

  public static void main(String args[]) {

     try 
    {
        FilterInputStream input = new FilterInputStream("E:/studytonight/input.txt");

        System.out.println("Data in the file: ");

        int i = input.read();

       while(i != -1)
       {
           System.out.print((char)i);

           i = input.read();
        }
        input.close();
     }

     catch(Exception e)
     {
        e.getStackTrace();
     }
  }
}

input.txt

Let's be studytonight curious

文件中的数据:
今晚让我们好奇的学习

结论:

在本教程中，我们学习了 Java 中 FilterInputStream 类的read()方法。它从当前输入流中读取下一个字节的数据并返回。它只能用类对象访问，如果我们试图用类名访问方法，那么我们会得到一个错误。

Java `FilterInputStream .available()`方法

原文：https://www.studytonight.com/java-file-io/java-filterinputstream-available-method

在本教程中，我们将学习 Java 中 FilterInputStream 类的available()方法。此方法用于返回可从当前FilterInputStream中读取的可用字节总数，而不会被此方法的下一次调用中断，调用程序可以是同一个线程或另一个线程。

句法

这是此方法的语法声明。它不接受任何参数。它返回可以从给定输入流中读取的字节总数。

public int available() throws IOException

示例 1:在 Java 中查找可用字节

在下面的例子中，我们使用 available()方法从文件中获取可读取的字节。由于给定的文件输出.txt 包含 6 个字节用于读取，它将相应地给出输出。

package com.studytonight;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;

public class Studytonight {
   public static void main(String[] args) throws IOException {
      InputStream is = null; 
      FilterInputStream st = null; 
      int i = 0, j = 0;
      char c;

      try {

         is = new FileInputStream("E:/studytonight/output.txt");
         st = new BufferedInputStream(is);

         while((i = st.read())!=-1) {

            c = (char)i;

            System.out.print("Read: "+c);

            j = st.available();

            System.out.println("; Available bytes: "+j);
         }

      } catch(Exception e) {

         e.printStackTrace();
      } finally {

         if(is!=null)
            is.close();
         if(st!=null)
            st.close();
      }
   }
}

输出. txt

CURIOUS

读作:C；可用字节:6
读取:U；可用字节:5
读:R；可用字节:4
读:I；可用字节:3
读:0；可用字节:2
读取:U；可用字节:1
读取:S；可用字节:0

示例 1:在 Java 中查找可用字节

在下面的例子中，我们使用 available()方法从文件中获取可读取的字节。由于给定的文件输出.txt 包含 7 个要读取的字节，它将相应地给出输出。

import java.io.*;

public class Studytonight {
 public static void main(String[] args) throws Exception {
  FileInputStream st = null;
  FilterInputStream std = null;
  int count = 0;

  try {

   st = new FileInputStream("E:\Studytonight\output.txt");
   std = new BufferedInputStream(st);

   while ((count = st.read()) != -1) {

    int avail_bytes = st.available();

    byte b = (byte) count;

    System.out.print("st.available(): " + avail_bytes);
    System.out.println(" : " + "byte: " + b);
   }
  } catch (Exception ex) {
   System.out.println(ex.toString());
  } finally {

   if (st != null) {
    st.close();

    if (std != null) {
     std.close();
    }
   }
  }
 }
}

st.available(): 6:字节:100
st.available(): 5:字节:74
st.available(): 4:字节:118
st.available(): 3:字节:32
st.available(): 2:字节:46
st.available(): 1:字节:46
st.available(): 0:字节:46

结论

在本教程中，我们学习了 Java 中 FilterInputStream 类的available()方法，该方法返回可从给定FileInputStream中读取的剩余字节总数。它是 java.io 包中可用的非静态方法，只能用类对象访问，如果我们试图用类名访问该方法，那么我们将会得到一个错误。

Java `FilterInputStream.skip()`方法

原文：https://www.studytonight.com/java-file-io/java-filterinputstream-skip-method

在本教程中，我们将学习 Java 中 FilterInputStream 类的skip()方法。此方法用于跳过并丢弃当前FilterInputStream中的给定字节数。这是一种非静态方法，可在 java.io 包中获得。

句法

这是此方法的语法声明。它将“n”个要跳过的字节数作为参数，并返回跳过的字节总数。

public long skip(long n) throws IOException

示例:跳过`FilterInputStream`中的字节

在本例中，我们将使用 skip()方法从 Java 中的FilterInputStream中丢弃指定数量的字节。请看下面的例子。

import java.io.*;

public class studytonight {
 public static void main(String[] args) throws Exception {
  FileInputStream st = null;
  FilterInputStream std = null;
  int count = 0;

  try {

   st = new FileInputStream("E:\studytonight\output.txt");
   std = new BufferedInputStream(st);

   while ((count = st.read()) != -1) {

    char ch = (char) count;

    System.out.println("ch: " + ch);    

    long skip = st.skip(2);
    System.out.println("st.skip(2): " + skip);
   }
  } catch (Exception ex) {
   System.out.println(ex.toString());

  } finally {

   if (std != null) {
    st.close();

    if (st != null) {
     st.close();
    }
   }
  }
 }
}

ch:S
ST . skip(2):2
ch:a
ST . skip(2):2
ch:r
ST . skip(2):2
ch:。
st.skip(2): 2
ch:。
st.skip(2): 2

结论

在本教程中，我们学习了 Java 中 FilterInputStream 类的skip()方法，该方法跳过当前FilterInputStream中给定的“n”个字节，并返回跳过的确切字节数。它只能用类对象访问，如果我们试图用类名访问方法，那么我们会得到一个错误。

Java `FilterInputStream.markSupported()`方法

原文：https://www.studytonight.com/java-file-io/java-filterinputstream-marksupported-method

在本教程中，我们将学习 Java 中 FilterInputStream 类的 markSupported()方法。此方法用于验证当前筛选器输入流是否支持调用标记()和重置()方法。这是一种非静态方法，可在 java.io 包中获得。

句法

这是此方法的语法声明。它不接受任何参数。此方法的返回类型是布尔型的，即如果当前流支持 mark()和 reset()方法，则返回 true，否则返回 false。

public boolean markSupported()

示例 1:验证`FilterInputStream`中的标记支持

这里，我们正在检查当前流是否允许设置 mark 方法，如果当前流不允许 mark()方法，那么这个方法将返回 false 值。否则，它将返回真值。在本例中，此方法返回真值，这意味着 mark()方法支持给定的流。

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FilterInputStream;
import java.io.IOException;

public class StudyTonight
{
	public static void main(String args[])
	{
		try 
		{
			File file = new File("E:\\studytonight\\output.txt");

			FileInputStream fis = new FileInputStream(file);
			FilterInputStream filterIs = new BufferedInputStream(fis);

			System.out.println("is markSupported() ? " + filterIs.markSupported());

			fis.close();
			filterIs.close();
		} 
		catch (IOException ex) 
		{
			ex.printStackTrace();
		}
	}
}

是 markSupported()？真实的

示例 2:验证`FilterInputStream`中的标记支持

在给定的示例中，markSupported()方法返回了一个 false 值，该值指示当前流不支持 mark()方法，并且不需要调用 reset()方法

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FilterInputStream;
import java.io.IOException;

public class StudyTonight
{
	public static void main(String args[])
	{
		try 
		{
			File file = new File("E:\\studytonight\\myfile.txt");

			FileInputStream fis = new FileInputStream(file);
			FilterInputStream filterIs = new BufferedInputStream(fis);

			System.out.println("is markSupported() ? " + filterIs.markSupported());

			fis.close();
			filterIs.close();
		} 
		catch (IOException ex) 
		{
			ex.printStackTrace();
		}
	}
}

是 markSupported()？错误的

结论:

在本教程中，我们学习了 Java 中 FilterInputStream 类的 markSupported()方法，该方法检查当前FileInputStream是否支持 mark()和 reset()方法的调用。如果是，则返回布尔值 true，如果不是，则返回 false。它只能用类对象访问，如果我们试图用类名访问方法，我们会得到一个错误。

Java `FilterInputStream.mark()`方法

原文：https://www.studytonight.com/java-file-io/java-filterinputstream-mark-method

在本教程中，我们将学习 Java 中 FilterInputStream 类的 mark()方法。此方法用于设置特定FilterInputStream中的当前位置。reset()方法的后续调用会将流重新定位到该方法最近标记的点。这是一个非静态方法，在 java.io 包中可用。

句法

这是此方法的语法声明。它只接受一个参数作为标记位置无效之前可以从当前输入流中读取的最大字节数的限制。它不返回值。

public void mark(int readlimit)

示例 1:设置流中的当前位置

在本例中，我们通过调用方法 mark()来标记流的初始位置，在读取这两个字符之后，我们读取这两个字符，我们调用 reset()方法来将当前流的指针设置到最近标记的位置，如果我们尝试读取，那么它将从最后标记的位置给出输出数据。

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FilterInputStream;
import java.io.IOException;
public class StudyTonight
{
	public static void main(String args[])
	{
		 try
		 {			 
	            File file = new File("E:\\studytonight\\output.txt");
	            FileInputStream fis = new FileInputStream(file);
	            FilterInputStream filterIs = new BufferedInputStream(fis);	 
	            filterIs.mark(0);
	            System.out.println((char) filterIs.read());
	            System.out.println((char) filterIs.read());
	            System.out.println("Last mark call at 0th index:- ");
	            filterIs.reset();
	            System.out.println("reset() called ");
	            System.out.println((char) filterIs.read());
	            System.out.println((char) filterIs.read());
	            fis.close();
	            filterIs.close();
	        } 
		 	catch (IOException ex) 
		 	{
	            ex.printStackTrace();
	        }
	}
}

H
e
第 0 个指数的最后一次标记调用:-
reset()称为
H
e

输出. txt

Hello Studytonight

示例 2:设置流中的当前位置

在本例中，我们连续调用了 mark()和 reset()方法，因此它通常会给出与 read()方法相同的输出，因为流中最近标记的位置和当前读取位置是相同的。

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FilterInputStream;
import java.io.IOException;

public class StudyTonight
{
	public static void main(String args[])
	{
		 try
		 {			 
	            File file = new File("E:\\studytonight\\output.txt");

	            FileInputStream fis = new FileInputStream(file);
	            FilterInputStream filterIs = new BufferedInputStream(fis);	 	           

	            System.out.println((char) filterIs.read());
	            System.out.println((char) filterIs.read());
	            filterIs.mark(0);
	            filterIs.reset();
	            System.out.println("reset() called ");

	            System.out.println((char) filterIs.read());
	            System.out.println((char) filterIs.read());
	            System.out.println((char) filterIs.read());

	            fis.close();
	            filterIs.close();

	        } 
		 	catch (IOException ex) 
		 	{
	            ex.printStackTrace();
	        }
	}
}

H
e
复位()称为
l
l
o

输出. txt

Hello Studytonight

示例 3:设置流中的当前位置

这里，我们看一下如果找到多个方法，会考虑哪个 mark()方法，看完输出后我们可以得出一个结论，它只会考虑最近标记的最后一个位置。

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FilterInputStream;
import java.io.IOException;

public class StudyTonight
{
	public static void main(String args[])
	{
		 try
		 {			 
	            File file = new File("E:\\studytonight\\output.txt");

	            FileInputStream fis = new FileInputStream(file);
	            FilterInputStream filterIs = new BufferedInputStream(fis);	 	           

	            System.out.println((char) filterIs.read());
	            filterIs.mark(0);

	            System.out.println((char) filterIs.read());
	            filterIs.mark(0);

	            System.out.println((char) filterIs.read());
	            System.out.println((char) filterIs.read());
	            System.out.println((char) filterIs.read());

	            filterIs.reset();
	            System.out.println("reset() called ");

	            System.out.println((char) filterIs.read());
	            System.out.println((char) filterIs.read());

	            fis.close();
	            filterIs.close();

	        } 
		 	catch (IOException ex) 
		 	{
	            ex.printStackTrace();
	        }
	}
}

H
e
l
l
o
复位()称为
l
l

结论:

在本教程中，我们学习了 Java 中 FilterInputStream 类的 mark()方法，该方法将标记设置为给定FilterInputStream中的当前位置，并且后续调用 reset()方法将会将流重新定位到 mark()方法标记的最近点。它只能用类对象访问，如果我们试图用类名访问方法，我们会得到一个错误。

Java `FilterInputStream.reset()`方法

原文：https://www.studytonight.com/java-file-io/java-filterinputstream-reset-method

在本教程中，我们将学习 Java 中 FilterInputStream 类的 reset()方法。此方法用于将当前FilterInputStream重新定位到给定流中最近一次调用 mark()方法的位置。这是一种非静态方法，可在 java.io 包中获得。

句法

这是此方法的语法声明。它不接受任何参数，并且该方法的返回类型是无效的，即它不返回任何值。

public void reset()

示例 1:在 Java 中重置输入流中的标记

这里，我们实现了 reset()方法，将当前流的指针重置到最近标记的位置。首先，我们最初标记当前流的位置，然后我们从文件中读取数据，然后我们通过调用方法 reset()重置指向流的指针，这将把当前流的指针移动到最近标记的位置，最近标记的位置是第一个位置，因此它将再次从头开始读取数据。

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FilterInputStream;
import java.io.IOException;

public class StudyTonight
{
	public static void main(String args[])
	{
		 try
		 {			 
	            File file = new File("E:\\studytonight\\output.txt");

	            FileInputStream fis = new FileInputStream(file);
	            FilterInputStream filterIs = new BufferedInputStream(fis);	 

	            filterIs.mark(0);

	            System.out.println((char) filterIs.read());
	            System.out.println((char) filterIs.read());

	            System.out.println("Last mark call at 0th index:- ");
	            filterIs.reset();
	            System.out.println("reset() called ");

	            System.out.println((char) filterIs.read());
	            System.out.println((char) filterIs.read());

	            fis.close();
	            filterIs.close();

	        } 
		 	catch (IOException ex) 
		 	{
	            ex.printStackTrace();
	        }
	}
}

H
e
第 0 个指数的最后一次标记调用:-
reset()称为
H
e

输出. txt

Hello Studytonight

示例 2:在 Java 中重置输入流中的标记

在这个例子中，我们正在读取数据并标记位置，然后在标记位置之后，我们通过调用方法 reset()来重置该位置，因此很明显，它不会显示任何不同的输出，因为最近标记的位置和当前位置是相同的。

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FilterInputStream;
import java.io.IOException;

public class StudyTonight
{
	public static void main(String args[])
	{
		 try
		 {			 
	            File file = new File("E:\\studytonight\\output.txt");

	            FileInputStream fis = new FileInputStream(file);
	            FilterInputStream filterIs = new BufferedInputStream(fis);	 	           

	            System.out.println((char) filterIs.read());
	            System.out.println((char) filterIs.read());
	            filterIs.mark(0);
	            filterIs.reset();
	            System.out.println("reset() called ");

	            System.out.println((char) filterIs.read());
	            System.out.println((char) filterIs.read());
	            System.out.println((char) filterIs.read());

	            fis.close();
	            filterIs.close();

	        } 
		 	catch (IOException ex) 
		 	{
	            ex.printStackTrace();
	        }
	}
}

H
e
复位()称为
l
l
o

输出. txt

Hello Studytonight

示例 3:在 Java 中重置输入流中的标记

如果我们调用 reset()方法而不调用任何 mark()方法会发生什么？这将引发一个正在重置为无效标记的异常。因为在这种情况下，我们没有设置任何标记，所以 reset()方法不知道最近标记的最后一个位置。

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FilterInputStream;
import java.io.IOException;

public class StudyTonight
{
	public static void main(String args[])
	{
		 try
		 {			 
	            File file = new File("E:\\studytonight\\output.txt");

	            FileInputStream fis = new FileInputStream(file);
	            FilterInputStream filterIs = new BufferedInputStream(fis);	 

	            System.out.println((char) filterIs.read());
	            System.out.println((char) filterIs.read());

	            filterIs.reset();
	            System.out.println("reset() called ");

	            System.out.println((char) filterIs.read());
	            System.out.println((char) filterIs.read());

	            fis.close();
	            filterIs.close();

	        } 
		 	catch (IOException ex) 
		 	{
	            ex.printStackTrace();
	        }
	}
}

H
e
Java . io . io 异常:重置为无效标记

结论:

在本教程中，我们学习了 Java 中 FilterInputStream 类的 reset()方法，该方法将特定FileInputStream重置到给定输入流中最近调用 mark()方法的位置。它只能用类对象访问，如果我们试图用类名访问方法，我们会得到一个错误。

Java `FileReader`方法

Java `FileReader.read()`方法

原文：https://www.studytonight.com/java-file-io/java-filereader-read-method

在本教程中，我们将学习 Java 中FileReader类的read()方法。此方法用于读取和返回单个字符，其形式为包含所读取字符的字符值的整数值。

句法

此方法将读取的字符作为 0 到 65535 范围内的整数返回。如果它返回-1 作为 int 值，则所有数据都已被读取，并且可以关闭 FileReader。

public abstract int read()

示例 1:使用`FileReader`阅读

在本例中，我们调用 FileReader 类的 read()方法从文件中读取数据，该方法一次读取一个字符，并以整数格式返回其 ASCII 值。要打印实际数据，我们必须将其输入字符。

import java.io.FileReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{   		
			FileReader fileReader=new FileReader("E:\\studytonight\\output.txt");    
			char c=(char) fileReader.read();
			System.out.print(c);    
			fileReader.close();    
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

输出. txt

Studytonight

示例 2:使用`FileReader`读取

在下面的例子中，我们从文件中读取数据。首先我们创建了一个FileReader，然后使用read()方法读取每个字符，并将其打印在控制台上。

import java.io.FileReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{   		
			FileReader fileReader=new FileReader("E:\\studytonight\\output.txt");    
			int i;    
			while((i=fileReader.read())!=-1)    
				System.out.print((char)i);    
			fileReader.close();    
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

欢迎今晚来学习

输出. txt

Welcome to Studytonight

结论

在本教程中，我们学习了 Java 中 FileReader 类的read()方法，该方法用于读取单个字符并以整数值的形式返回，范围为 0 到 65535，如果已经到达流的末尾，则返回-1。

Java `FileReader.close()`方法

原文：https://www.studytonight.com/java-file-io/java-filereader-close-method

在本教程中，我们将学习 Java 中FileReader类的close()方法。此方法关闭流并释放与其链接的所有系统资源。一旦调用此方法，调用read()、ready()、mark()、reset()或skip()将抛出一个 IOException。

句法

此方法不接受任何参数或返回任何值。

public abstract void close()

示例 1:关闭`FileReader`实例

import java.io.FileReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{   		
			FileReader fileReader=new FileReader("E:\\studytonight\\output.txt");    
			int i;    
			while((i=fileReader.read())!=-1)    
				System.out.print((char)i);    
			fileReader.close();    
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

欢迎今晚来学习

输出. txt

Welcome to Studytonight

示例 1:关闭`FileReader`实例

这里有一个例子，当我们关闭当前流，然后尝试使用它时，它会抛出这样的异常，因为当前流所需的所有资源都被取消分配了。

import java.io.FilterReader;
import java.io.Reader;
import java.io.StringReader;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			Reader reader = new StringReader("Hello Studeytonight"); 
			int i;
			FilterReader filterReader = new FilterReader(reader) {};
			filterReader.close(); 

			while ((i = filterReader.read()) != -1) {
				char  c = (char) i;
				System.out.print(c);
			}
		}
		catch(Exception e)
		{
			System.out.print("Error: "+e.toString());
		}
	} 
}

错误:java.io.IOException:流关闭

结论

在本教程中，我们学习了 Java 中 FileReader 类的close()方法，该方法关闭流并释放与系统流相关联的所有资源。调用此方法会使流上的任何其他操作无效。

Java `FileWriter`

Java `FileWriter.write()`方法

原文：https://www.studytonight.com/java-file-io/filewriter-write-method-in-java

在本教程中，我们将在 Java 中学习 FileWriter 类的write()方法。此方法用于将数据写入文件。我们可以使用重载方法中的任何方法将数据写入文件。此方法可以接受字符串、字符和字符数组。

句法

这些是重载 write()方法的语法声明，这个方法接受完整的 String、简单字符和字符数组。此方法用于将字符串写入FileWriter。

public void write(String text)

此方法用于将单个字符写入 FileWriter。

public void write(char c)

此方法用于将字符数组写入FileWriter。

public void write(char[] c)

示例 1:使用`FileWriter`写入数据

在这个例子中，我们实现了 FileWriter 类的write()方法的例子。，此方法接受字符串并将其写入文件。为了更好地理解write()方法的概念，我们在控制台以及下面代码后面的文件中提供了输出。

import java.io.FileWriter;
import java.io.IOException;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		try
		{    
			FileWriter fileWriter=new FileWriter("E:\\studytonight\\output.txt");    
			String str = "Hello Studytonight";
			fileWriter.write(str);    
			fileWriter.close();    
			System.out.println("Data Written to the file successfully");
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}    
	} 
}

数据成功写入文件

输出. txt

Hello Studytonight

示例 2:使用`FileWriter`写入数据

这里，我们有一个只接受字符数组的方法 write，在获取字符数组后，它会将其写入我们拥有的FileWriter。将数据写入文件后，我们可以检查文件的数据，以验证源数据。

import java.io.FileWriter;
import java.io.IOException;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		try
		{    
			FileWriter fileWriter=new FileWriter("E:\\studytonight\\output.txt");    
			char arr[] = {'S', 't', 'u', 'd', 'y', 't', 'o', 'n', 'i', 'g', 'h', 't'};
			fileWriter.write(arr);    
			fileWriter.close();    
			System.out.println("Data Written to the file successfully");
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}    
	} 
}

数据成功写入文件

输出. txt

Studytonight

示例 3:使用`FileWriter`写入数据

这个例子类似于我们在上面的例子中看到的，方法接受字符并将其写入文件。为了更好地理解write()方法的概念，我们在控制台以及下面代码后面的文件中提供了输出。

import java.io.FileWriter;
import java.io.IOException;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		try
		{    
			FileWriter fileWriter=new FileWriter("E:\\studytonight\\output.txt");    
			char c='A';
			fileWriter.write(c);    
			fileWriter.close();    
			System.out.println("Data Written to the file successfully");
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}    
	} 
}

数据成功写入文件

输出. txt

结论

在本教程中，我们学习了 FileWriter 类的 write()方法。此方法用于将数据写入文件。我们可以使用重载方法中的任何方法将数据写入文件。此方法可以接受字符串、字符和字符数组。

Java `PipedWriter`

Java `PipedWriter.write()`方法

原文：https://www.studytonight.com/java-file-io/java-pipedwriter-write-method

在本教程中，我们将学习 Java 中 PipedWriter 类的 write()方法。此方法用于将数据写入输出管道流。

句法

这是 write()方法的语法声明，它不返回任何东西，因为它的返回类型是无效的。

public void write(char[] cbuf, int off, int len)

示例:`PipedWriter`写入()方法

import java.io.PipedReader;
import java.io.PipedWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			PipedReader reader = new PipedReader(); 
			PipedWriter writer = new PipedWriter(); 
			reader.connect(writer); 
			char[] arr = {'H', 'E', 'L', 'L', 'O'}; 
			writer.write(arr, 0, 5); 
			while(true) 
			{ 
				System.out.print((char) reader.read());           
			} 
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

你好

示例 2:`PipedWriter`写入()方法

在这个例子中，我们实现了PipedWriter类的 write()方法来写入数据。首先我们创建了PipedWriter 类和PipedReader 类的对象，然后使用 connect()方法连接了这两个方法。现在我们将字符写到PipedWriter 中，并再次使用PipedReader阅读。

import java.io.PipedReader;
import java.io.PipedWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			PipedReader reader = new PipedReader(); 
			PipedWriter writer = new PipedWriter(); 
			reader.connect(writer); 

			writer.write(72); 
			System.out.println((char)reader.read()); 
			writer.write(69); 
			System.out.println((char)reader.read()); 
			writer.write(76); 
			System.out.println( (char)reader.read());   
			writer.write(76); 
			System.out.println( (char)reader.read());   
			writer.write(79); 
			System.out.println( (char)reader.read());   
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

H
E
L
L
O

结论

在本教程中，我们学习了pipe dwriter类的 write()方法。这个方法有两个重载方法，它从指定字符数组的偏移量开始向这个管道输出流写入 len 字符。

Java `PipedWriter.close()`方法

原文：https://www.studytonight.com/java-file-io/pipedwriter-close-method-in-java

在本教程中，我们将学习 Java 中PipedWriter类的close()方法。此方法属于java.io 包，用于关闭此 PipedWriter 流，释放所有与该流链接的系统资源。

句法

这是 close()方法的语法声明，此方法不接受任何参数，也不返回任何参数，但它可能会在关闭流时引发异常。

public void close() throws IOException

示例 1:关闭`PipedWriter`实例

在下面的例子中，我们已经创建了一个PipedReader类的对象，并且在这个类的帮助下，我们创建了 PipeDreader 类的对象。在创建了这两个对象之后，我们调用了 PipedWriter 类上的 close()方法来释放与这个流链接的所有资源，在这种情况下它可以正常工作。

import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		PipedWriter pipedWriter = new PipedWriter();  
		PipedReader pipedReader = new PipedReader(pipedWriter);  
		pipedWriter.close();   
		System.out.println("PipedWriter is closed...");  
	} 
}

PipedWriter关闭...

示例 2:关闭`PipedWriter`实例

在这个例子中，我们试图说明当流已经关闭并且我们试图写入流时，它是如何抛出异常的。在这里，我们可以看到我们关闭了PipedWriter流，然后我们试图写入数据，这就是为什么它抛出了一个异常，并显示消息“管道未连接”

import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		try
		{
			PipedWriter pipedWriter = new PipedWriter();
			PipedReader pipedReader = new PipedReader();
			pipedWriter.close();
			pipedWriter.close();		 
			pipedWriter.write(65);
		} 
		catch (Exception e) 
		{
			System.out.println("Error: "+e.toString());
		}
	} 
}

错误:java.io.IOException:管道未连接

结论

在本教程中，我们学习了 close()方法PipedWriter类，该方法属于java.io 包，用于关闭这个PipedWriter流，释放所有与该流链接的系统资源。

Java `PipedWriter.flush()`方法

原文：https://www.studytonight.com/java-file-io/pipedwriter-flush-method-in-java

在本教程中，我们将学习 Java 中PipedWriter 类的flush()方法。该方法在 java.io包中提供。此方法用于刷新此pipe dwriter流，并强制从任何缓冲输出中写出字符。I t 是一个非静态的方法，它只能用类对象访问，如果我们试图用类名访问这个方法，那么我们会得到一个错误。

句法

这是flush()方法的语法声明，这个方法不接受任何参数，也不返回任何东西，因为它的返回类型是 void。

 public void flush();

例 1

在这个例子中，我们创建了PipedWriter 和PipedReader 类的对象，然后我们写入数据，然后我们使用 connect()方法连接了读取器和写入器。为了冲出小溪，我们称之为flush()法。

import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		PipedWriter writer = new PipedWriter();
		PipedReader reader = new PipedReader();

		try 
		{
			writer.connect(reader);
			writer.write(65);
			writer.flush();
			System.out.println("Writer flushed.");

			for (int i = 0; i < 2; i++) 
			{
				System.out.println("" + (char) reader.read());
			}
		} 
		catch (IOException ex) 
		{
			ex.printStackTrace();
		}
	} 
}

作家满脸通红。
A

例 1

在本例中，我们实现了 flush()方法来刷新给定的PipedWriter流，并强制从任何缓冲输出中写入字符。

import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		int val = 65;
		try 
		{
			PipedWriter pipedWriter = new PipedWriter();
			PipedReader pipedReader = new PipedReader();

			pipedWriter.connect(pipedReader);

			for (int i = 0; i < 3; ++i) 
			{
				pipedWriter.write(val);
				val++;
			}

			pipedWriter.flush();

			for (int i = 0; i < 3; ++i) 
			{			
				char ch = (char) pipedReader.read();
				System.out.print("" + ch);
			}

			pipedWriter.close();
			pipedWriter.close();
		} 
		catch (Exception e) 
		{
			System.out.println("Error: "+e.toString());
		}
	} 
}

ABC

结论:

在本教程中，我们学习了 flush()方法，该方法用于刷新此PipedWriter流，并强制从任何缓冲输出中写入字符。

Java `PipedReader`方法

Java `PipedReader.connect()`方法

原文：https://www.studytonight.com/java-file-io/pipedreader-connect-method-in-java

在本教程中，我们将在 Java 中学习PipedReader。当该PipedReader 先前没有连接到任何其他PipedWriter时，该方法用于使该PipedReader 连接到给定的PipedWriter (源)。

语法:

这是管道Writer类的连接方法的语法声明，它接受管道编写器的对象作为源，但是这个方法不返回任何东西。

public void connect(PipedWriter source);

示例:用 Java 连接 PipReader

在本例中，我们将了解 connect()方法是如何工作的，我们使用该方法将PipedWriter与管道检测器连接起来，换一种方式，我们可以说该方法使管道读取器连接到PipedWriter src。

import java.io.PipedReader;
import java.io.PipedWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			PipedReader reader = new PipedReader(); 
			PipedWriter writer = new PipedWriter(); 
			reader.connect(writer); 

			writer.write(72); 
			System.out.println((char)reader.read()); 
			writer.write(69); 
			System.out.println((char)reader.read()); 
			writer.write(76); 
			System.out.println( (char)reader.read());   
			writer.write(76); 
			System.out.println( (char)reader.read());   
			writer.write(79); 
			System.out.println( (char)reader.read());   
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

H E L L O

示例:用 Java 连接 PipReader

在这里，我们实现了管道检测器类的连接方法，我们使用这个方法来连接管道检测器和管道检测器。换句话说，我们可以说这个方法使管道读取器连接到PipedWriter src。

import java.io.PipedReader;
import java.io.PipedWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			PipedReader reader = new PipedReader(); 
			PipedWriter writer = new PipedWriter(); 
			reader.connect(writer); 
			char[] arr = {'H', 'E', 'L', 'L', 'O'}; 
			writer.write(arr, 0, 5); 
			while(true) 
			{ 
				System.out.print((char) reader.read());           
			} 
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

你好

结论

在本教程中，我们学习了PipedReader 类的connect() 方法，该方法用于在此PipedReader先前未连接到任何其他PipedWriter时，使此PipedReader 连接到给定的PipedWriter (源)。

Java `PipedReader.read()`方法

原文：https://www.studytonight.com/java-file-io/pipedreader-read-method-in-java

在本教程中，我们将学习 Java 中 PipedReader 类的 read()方法。这个方法从这个管道流中读取数据的下一个字符。如果因为已经到达流的末尾而没有可用的字符，则返回值-1。

句法

这是 read()方法的语法声明，该方法不接受任何参数，但返回整数格式的 ASCII 码。

public int read()

示例:使用管道检测器类读取字符

import java.io.PipedReader;
import java.io.PipedWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			PipedReader reader = new PipedReader(); 
			PipedWriter writer = new PipedWriter(); 
			reader.connect(writer); 			
			writer.write(72); 
			System.out.println((char)reader.read()); 
			writer.write(69); 
			System.out.println((char)reader.read()); 
			writer.write(76); 
			System.out.println( (char)reader.read());   
			writer.write(76); 
			System.out.println( (char)reader.read());   
			writer.write(79); 
			System.out.println( (char)reader.read());   
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

H E L L O

示例:使用管道检测器类读取字符

这里有一个简单的 Java PipedReader 示例，我们正在从字符数组中读取数据。如前所述，我们必须连接PipedReader 和PipedWriter，在本节目中，我们使用connect()方法连接PipedWriter 作家。

连接后，我们使用重载的方法public int read(char[] arr, int offset, int maxlen)，这里arr 是数据源，

offset 表示源的起始位置，我们将从该位置开始读取数据。maxlength是要读取的数据长度。

对于该方法的每次调用，它将返回该索引上的一个字符。当索引到达源流的末尾时，该方法将返回 -1 。

import java.io.PipedReader;
import java.io.PipedWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			PipedReader reader = new PipedReader(); 
			PipedWriter writer = new PipedWriter(); 
			reader.connect(writer); 
			char[] arr = {'H', 'E', 'L', 'L', 'O'}; 
			writer.write(arr, 0, 5); 
			while(true) 
			{ 
				System.out.print((char) reader.read());           
			} 
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

你好

结论:

在本教程中，我们学习了Java中PipedReader 类的 read()方法。这个方法从这个管道流中读取数据的下一个字符。如果因为已经到达流的末尾而没有可用的字符，则返回值-1。

Java `PipedReader.ready()`方法

原文：https://www.studytonight.com/java-file-io/java-pipedreader-ready-method

在本教程中，我们将在 Java 中学习管道工具类的ready()方法。此方法验证此管道检测器流是否准备好读取。如果循环缓冲区不为空，管道字符流就准备好了。它是一个非静态方法，在 java.io 包中可用，只能用类对象访问，试图用类名访问它会抛出一个 IOException。

句法

这是此方法的语法声明。它不接受任何参数，如果流准备好被读取，它返回true，否则它返回false。

public boolean ready()

示例:检查管道清洁器是否准备好

在下面的例子中，我们正在检查给定的管道检测器是否准备好读取，这里这个方法返回的真值表示给定的方法是读取的。

import java.io.PipedReader;
import java.io.PipedWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			PipedWriter pipedWriter=new PipedWriter();  
			PipedReader pipedReader=new PipedReader(pipedWriter);  
			pipedWriter.write("Hello Studytonight");  
			System.out.println("PipedReader is ready: "+pipedReader.ready());
			pipedReader.close();  
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

PipedReader准备好了:真

示例 2:检查管道清洁器是否准备好

在下面的例子中，我们正在检查给定的管道检测器是否准备好读取，这里这个方法返回一个假值，所以我们可以清楚地说给定的管道检测器没有准备好读取数据。

import java.io.PipedReader;
import java.io.PipedWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			PipedWriter pipedWriter=new PipedWriter();  
			PipedReader pipedReader=new PipedReader(pipedWriter);  
			boolean status = pipedReader.ready();
			System.out.println("pipedReader.ready(): " + status);
			pipedReader.close();
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

PipeDrader . ready():false

结论

在本教程中，我们在 Java 中学习了管道工具类的ready()方法。用于检查该管道检测器流是否准备好被读取。如果准备好了，它返回，不阻塞下一个read()的流，否则，它返回false。

Java `PipedReader.close()`方法

原文：https://www.studytonight.com/java-file-io/java-pipedreader-close-method

在本教程中，我们将在 Java 中学习移液器类的close()方法。该方法属于java.io 包，用于关闭该 PipedReader 流，释放所有与该流链接的系统资源。

句法

这是 close()方法的语法声明，此方法不接受任何参数，也不返回任何参数，但它可能会在关闭流时引发异常。

public void close() throws IOException

示例:在 Java 中关闭`PipedReader`实例

import java.io.PipedReader;
import java.io.PipedWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			PipedWriter pipedWriter=new PipedWriter();  
			PipedReader pipedReader=new PipedReader(pipedWriter);  
			pipedWriter.write("Hello Studytonight");  
			System.out.println("Closing pipedReader");  
			pipedReader.close();  
			System.out.println("Done!");
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

关闭清管器
完成！

示例:在 Java 中关闭`PipedReader`实例

在下面的程序中，我们在使用PipedReader 之前关闭它，所以它会抛出一个错误:java.io.IOException: Pipe closed，因为所有与之链接的资源都消失了，所以它不会正常工作。

import java.io.PipedReader;
import java.io.PipedWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			PipedWriter pipedWriter=new PipedWriter();  
			PipedReader pipedReader=new PipedReader(pipedWriter);  
			pipedReader.close();  

			pipedWriter.write("Hello Studytonight");  
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

错误:java.io.IOException:管道关闭

结论

在本教程中，我们学习了close()方法pipeldreader类，该方法属于java.io 包，用于关闭该 pipeldreader 流并释放所有与该流链接的系统资源。

`BufferedInputStream`方法

Java `BufferedInputStream.available()`方法

原文：https://www.studytonight.com/java-file-io/java-bufferedinputstream-available-method

在本教程中，我们将学习 Java 中 BufferedInputStream 类的可用()方法。此方法返回从输入流中读取的剩余字节数，而不会被该输入流的下一次方法调用阻塞。

句法

这是 available()方法的语法声明，它返回剩余的字节数，以便在不阻塞的情况下从该输入流中读取

public int available()

示例:Java BufferedInputStream 可用方法

在下面的例子中，我们使用 available()方法从文件中获取可读取的字节。由于给定文件myfile.txt 包含 20 个字节用于读取，因此它将输出 20 个字节。

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
        FileInputStream file = new FileInputStream("E:\\studytonight\\myfile.txt");        
        BufferedInputStream buffer = new BufferedInputStream(file);
        System.out.println("Total bytes available at beginning " + buffer.available());
        buffer.close();
	}  
}

从 20 开始的可用字节总数

myfile.txt: 这是上面例子中用来读取的文件。

Hello Studytonight

示例:Java BufferedInputStream 可用方法

在下面的代码中，当可读取的字节数大于 0 时，我们运行循环，在每次迭代中，我们读取字符并打印可读取的字节数。需要注意的重要观察是，在每次迭代中，可用字节何时减少。

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		FileInputStream file = new FileInputStream("E:\\studytonight\\output.txt");        
		BufferedInputStream buffer = new BufferedInputStream(file);
		while(buffer.available()>0)
		{
			System.out.println("Available bytes = " + buffer.available() );
			char ch =  (char)buffer.read();
			System.out.println("The character read = " + ch );
		}
		buffer.close();
	}  
}

可用字节= 18
字符读取= H
可用字节= 17
字符读取= e
可用字节= 16
字符读取= l
可用字节= 15
字符读取= l
可用字节= 14
字符读取= o
可用字节= 13
字符读取=
可用字节= 12
字符读取= S
可用字节= 11
字符读取= t
可用字节= 10
字符读取= u
可用字节= 9
字符读取= d
可用字节= 8
字符读取= y
可用字节= 7
字符读取= t
可用字节= 6
字符读取= o
可用字节= 5
字符读取= n
可用字节= 4
字符读取 = i
可用字节= 3
读取的字符= g
可用字节= 2
读取的字符= h
可用字节= 1
读取的字符= t

结论

在本教程中，我们学习了 Java 中 BufferedInputStream 类的可用方法，该方法返回从输入流中读取的剩余字节数，而不会被该输入流的下一次方法调用阻塞。

Java `StringWriter`方法

Java `StringWriter.write()`方法

原文：https://www.studytonight.com/java-file-io/stringwriter-write-method-in-java

在本教程中，我们将学习 Java 中 StringWriter 类的write() 方法。正如我们之前了解到的，这个类用于在流上写数据，这些 overloadings write()方法是写数据最重要的方法。此方法将数据写入流。

句法

这是 write()方法的语法声明，这个方法不返回任何东西。

public void write(String str,int off,int len)

例 1

在本例中，我们将演示在 StringWriter 类中使用 write 方法。这里我们将三个参数作为输入，这些参数是字符串的来源、偏移量(它是开始读取源数据的位置)和字符串的长度。当我们根据参数调用此方法时，它会将字符串写入缓冲区。

import java.io.IOException;
import java.io.StringWriter;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		String str = "Hello Studytonight";
		StringWriter stringWriter = new StringWriter();

		stringWriter.write(str, 0, 5);

		System.out.println("" + stringWriter.toString());
	} 
}

你好

例 2

在本例中，我们使用 write()方法的重载方法之一，该方法接受单个字符作为参数，并将其写入流。

import java.io.IOException;
import java.io.StringWriter;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		StringWriter stringWriter = new StringWriter();

		stringWriter.write('A');

		System.out.println("" + stringWriter.toString());
	} 
}

例 3

在本例中，我们将演示在 StringWriter 类中使用 write 方法。这里我们将三个参数作为输入，这些参数是 char 数组的来源、偏移量(它是开始读取源数据的位置)和字符串的长度。当我们根据参数调用此方法时，它会将特定范围的字符数组写入缓冲区。

import java.io.IOException;
import java.io.StringWriter;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		char arr[] = {'S', 't', 'u', 'd', 'y', 't', 'o', 'n', 'i', 'g', 'h', 't'};
		StringWriter stringWriter = new StringWriter();

		stringWriter.write(arr, 0, 5);

		System.out.println("" + stringWriter.toString());
	} 
}

学习

结论

在本教程中，我们学习了 Java 中 StringWriter 类的 write()方法。该方法用于将数据写入流中，并与其他重载方法一起提供对源数据的切片和范围的灵活性。

Java `StringWriter.toString()`方法

原文：https://www.studytonight.com/java-file-io/stringwriter-tostring-method-in-java

在本教程中，我们将学习 Java 中 StringWriter 类的 toString()方法。该方法用于用字符串表示缓冲区电流值。该方法在java.io包中提供。这是一个非静态方法，只能用类对象访问，如果我们试图用类名访问这个方法，那么我们会得到一个错误。

句法

这是 toString()方法的语法声明，它不接受任何参数并返回一个字符串。

public String toString();

例 1

在本例中，我们将看到如何使用toString()方法将数据写入StringWriter。当我们调用 toString()方法时，它将提取缓冲区的当前值，并以字符串的形式返回。

import java.io.IOException;
import java.io.StringWriter;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		StringWriter stringWriter = new StringWriter();  
		stringWriter.write("Hello Studytonight");  
		System.out.println("" + stringWriter.toString());
	} 
}

你好，今晚学习

例 2

在这个例子中，我们创建了一个 StringWriter 类的对象，然后我们调用 toString()方法来读取缓冲区的数据，它将以字符串格式返回缓冲区的值。

import java.io.IOException;
import java.io.StringWriter;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		try
		{ 
			StringWriter stringWriter = new StringWriter(); 

			String string = "Hello Studytonight"; 

			stringWriter.write(string); 

			System.out.println("String = "+ stringWriter.toString()); 
		} 
		catch (Exception e) 
		{ 
			System.out.println(e); 
		} 
	} 
}

字符串=你好今晚学习

结论

在本教程中，我们学习了 Java 中 StringWriter 类的toString()方法。这个方法用来用字符串表示缓冲区的当前值。t 是一个非静态的方法，它只能用类对象访问，如果我们试图用类名访问这个方法，那么我们会得到一个错误。

Java `StringWriter.getBuffer()`方法

原文：https://www.studytonight.com/java-file-io/stringwriter-getbuffer-method-in-java

在本教程中，我们将学习 Java 中 StringWriter 类的getBuffer()方法。此方法用于获取保存当前缓冲值的 StringBuffer。该方法在java.io包中提供。这是一个非静态方法，只能用类对象访问，如果我们试图用类名访问这个方法，那么我们会得到一个错误。

句法

这是getBuffer()方法的语法声明，不接受任何参数，返回StringBuffer。

public StringBuffer getBuffer();

例 1

在这个例子中，我们实现了StringWriter 类的 getBuiffer() 方法。首先，我们使用write() 方法将文本写入StringWriter ，以验证我们使用的是getBuffer() 方法，它将返回StringBuffer。；

import java.io.IOException;
import java.io.StringWriter;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		StringWriter stringWriter = new StringWriter();

		stringWriter.write("Hello Studytonight");

		System.out.println("" + stringWriter.getBuffer());
	} 
}

你好，今晚学习

例 2

下面是另一个例子来说明getBuffer() 方法是如何工作的。在将数据写入 StringWriter 之后，我们调用 getBuffer()方法，该方法将返回相应 StringWriter 持有的缓冲区。

import java.io.IOException;
import java.io.StringWriter;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		try
		{ 
			StringWriter writer = new StringWriter(); 
			String str = "Studytonight"; 
			writer.write(str); 
			StringBuffer stringBuffer = writer.getBuffer(); 

			System.out.println("StringBuffer = " + stringBuffer); 
		} 
		catch (Exception e) 
		{ 
			System.out.println(e); 
		} 
	} 
}

串缓冲=书房夜

结论

在本教程中，我们学习了Java中StringWriter 课的getBuffer()方法。此方法用于获取保存当前缓冲区值的 StringBuffer。此方法在 java.io 包中可用。

Java `StringWriter.flush()`方法

原文：https://www.studytonight.com/java-file-io/stringwriter-flush-method-in-java

在本教程中，我们将学习 Java 中 StringWriter 类的flush() 方法。此方法用于刷新编写器，这意味着此方法将删除编写器中存在的所有数据。它既不接受任何参数，也不返回值。

句法

这是flush()方法的语法声明，这个方法不接受任何参数作为输入，也不返回任何东西，因为它的返回类型是 void。

public void flush()

例 1

import java.io.IOException;
import java.io.StringWriter;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		StringWriter stringWriter = new StringWriter();

		String str = "Hello Studytonight";

		stringWriter.write(str);

		stringWriter.flush();

		System.out.println("" + stringWriter.toString());
	} 
}

你好，今晚学习

例 2

import java.io.IOException;
import java.io.StringWriter;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		try
		{ 
			StringWriter writer = new StringWriter(); 
			writer.write(65); 
			System.out.println(writer.toString()); 
			writer.flush(); 
		} 
		catch (Exception e)
		{ 
			System.out.println(e); 
		} 
	} 
}

结论

在本教程中，我们学习了 Java 中 StringWriter 类的flush() 方法。此方法用于刷新编写器，这意味着此方法将删除编写器中存在的所有数据。它既不接受任何参数，也不返回值。

Java `StringWriter.close()`方法

原文：https://www.studytonight.com/java-file-io/stringwriter-close-method-in-java

在本教程中，我们将学习 Java 中 StringWriter 类的close()方法。此方法用于关闭此StringWriter流。当我们在关闭流后调用它的任何方法时，都不会产生异常。该方法在java.io包中提供。关闭编写器会释放其中的任何值或与之关联的任何资源。

句法

这是一个close() 方法的语法声明，它不接受任何参数，方法的返回类型是void，它什么也不返回。

public void close()

例 1

import java.io.IOException;
import java.io.StringWriter;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		String str = "Hello Studytonight"; 
		try
		{ 
			StringWriter writer = new StringWriter(); 
			writer.write(str); 

			System.out.println(writer.toString()); 

			writer.close(); 
		} 
		catch (Exception e)
		{ 
			System.out.println(e); 
		} 
	} 
}

你好，今晚学习

例 2

import java.io.IOException;
import java.io.StringWriter;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		try 
		{ 
			StringWriter writer = new StringWriter(); 
			writer.write(65); 
			System.out.println(writer.toString()); 

			writer.close(); 
		} 
		catch (Exception e) 
		{ 
			System.out.println(e); 
		} 
	} 
}

结论

在这个例子中，我们学习了 close()方法，这个方法用于关闭这个 StringWriter 流。当我们在关闭流后调用它的任何方法时，都不会产生异常。该方法在java.io包中提供。

Java `StringWriter.append()`方法

原文：https://www.studytonight.com/java-file-io/stringwriter-append-method-in-java

在本教程中，我们将在 Java 中学习 StringWriter 类的append()方法。这个方法用于将字符序列附加到现有的字符串写入器中，这个方法有另外三个重载方法来提供对字符序列进行切片和相应编写的灵活性。

句法

这是append()方法的语法声明，该方法接受CharSequence作为参数并返回 StringWriter。

public StringWriter append(CharSequence csq)

例 1

在这个例子中，我们实现了我们正在使用的append()方法，该方法只接受一个字符并将其附加到编写器中。

import java.io.IOException;
import java.io.StringWriter;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		StringWriter stringWriter = new StringWriter();
		stringWriter.append('A');
		System.out.println("" + stringWriter.toString());
	} 
}

例 2

这里，在这个例子中，我们正在实现StringWriter类的另一个append()方法，这个方法接受CharSequence 并将其附加到现有的编写器中，这里我们可以看到使用toString()方法在 StringWriter 内部编写的CharSequence。

import java.io.*;  
public class StudyTonight
{  
	public static void main(String[] args) 
	{  
		CharSequence csq1="study";  
		CharSequence csq2="tonight";  
		StringWriter printWriter=new StringWriter();  
		printWriter.append(csq1);  
		printWriter.append(csq2);  
		System.out.println(printWriter.toString());
	}  
}

今晚学习

例 3

这里我们实现的是append()方法的另一个重载方法，这个方法接受三个参数，CharSequence 是数据的来源，起始索引和结束索引指定 CharSequence 的范围，然后将它追加到 StringWriter 中。

import java.io.IOException;
import java.io.StringWriter;
class StudyTonight
{
	public static void main(String[] args) throws IOException 
	{ 
		StringWriter stringWriter = new StringWriter();
		CharSequence charSequence = "Hello Studytonight";
		stringWriter.append(charSequence, 0, 5);
		System.out.println("" + stringWriter.toString());
	} 
}

你好

结论

在本教程中，我们学习了StringWriter类的append()方法。此方法用于将字符序列追加到现有的字符串编辑器中。

Java `DataInputStream`方法

Java `DataInputStream.readDouble()`方法

原文：https://www.studytonight.com/java-file-io/java-datainputstream-readdouble-method

在本教程中，我们将学习 Java 中 DataInputStream 类的readDouble()方法。此方法用于读取 8 个输入字节(即 64 位)，并返回一个双精度值。这是一个非静态方法，在 java.io 包中可用。

句法

这是此方法的语法声明。它不接受任何参数，并返回由当前输入流的下八个字节解释的双精度值。

public final double readDouble() throws IOException

示例:用 Java 中的 DataInputStram 读取数据

在本例中，我们以 double 类型从文件中读取数据，其大小将为 64 位，这里需要注意的重要观察是，即使提供的数据是Integer类型，它也会执行类型转换，并将其转换为 Double 类型。

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		FileInputStream inputStream  = new FileInputStream("E:\\studytonight\\output.txt"); 

		DataInputStream dataInputStream = new DataInputStream(inputStream); 

		while(dataInputStream.available()>0)
		{	           
            System.out.print(" "+dataInputStream.readDouble());  
        }  
	}  
}

17.0
15.0
26.0
31.0
40.0

输出. txt

示例:用 Java 中的 DataInputStram 读取数据

当我们尝试使用 readDouble()从文件中读取数据，并且数据不可用或者流的指针指向文件的结尾时，它将抛出一个异常 EOFException，即文件结尾异常。

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		FileInputStream inputStream  = new FileInputStream("E:\\studytonight\\file.txt"); 
		DataInputStream dataInputStream = new DataInputStream(inputStream); 
		while(dataInputStream.available()>0)
		{	           
            System.out.print(" "+dataInputStream.readDouble());  
        }  
	}  
}

线程“main”Java . io . eofexception
在 Java . base/Java . io . datainputstream . readfully(datainputstream . Java:201)
在 Java . base/Java . io . datainputstream . readlong(datainputstream . Java:420)
在 Java . base/Java . io . datainputstream . readdouble(datainputstream . Java:472)
在今晚的学习中出现异常。study south . main(study south . Java:16)

结论

在本教程中，我们学习了 Java 中 DataInputStream 类的readDouble()方法，该方法读取双精度值的 8 个输入字节并返回读取的双精度值。只能使用类对象访问此方法，尝试使用类名访问它将导致错误。

Java `DataInputStream.readBoolean()`方法

原文：https://www.studytonight.com/java-file-io/java-datainputstream-readboolean-method

在本教程中，我们将学习 Java 中 DataInputStream 类的readBoolean()方法。此方法用于检查该流是否读取布尔值。它读取一个输入字节，如果读取的字节为零，则返回 false，如果读取的字节非零，则返回 true。

句法

这是这个方法的语法。它不接受任何参数，并返回读取的布尔值，即真或假。

public final boolean readBoolean() throws IOException

示例:`DataInputStream`读取布尔()方法

下面的示例从字节流中读取值，这里我们有趣地注意到，除了 0(零)之外，它将非零值视为真值，这就是它仅在字节数组中出现零的位置打印假值的原因。

import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
        byte[] b = { 10, 5, 7, 1, 0 }; 
        ByteArrayInputStream byteArrayInputStr = new ByteArrayInputStream(b);   
        DataInputStream dataInputStr = new DataInputStream(byteArrayInputStr);   
        while (dataInputStr.available() > 0)
        { 
            System.out.println(dataInputStr.readBoolean()); 
        } 
	}  
}

真
真
真
真
假

示例:`DataInputStream`读取布尔()方法

这里，我们将说明另一个场景，我们将从字节数组中读取数据，但是这里有一些负值，但是 readByte()方法认为它们是真的，这意味着该方法认为零(0)为假，除此之外，所有值都是真的。

import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
        byte[] b = { -1, 10, 5, 6, 0 }; 
        ByteArrayInputStream byteArrayInputStr = new ByteArrayInputStream(b);   
        DataInputStream dataInputStr = new DataInputStream(byteArrayInputStr);   
        int count=dataInputStr.available();
        while (count > 0)
        { 
            System.out.println(dataInputStr.readBoolean()); 
            count--;
        } 
	}  
}

真
真
真
真
假

结论

在本教程中，我们学习了 Java 中 DataInputStream 类的readDouble()方法，用于检查当前流是否读取布尔值，如果是，则返回布尔值 true，如果不是，则返回布尔值 false。

Java `DataInputStream.skipBytes()`方法

原文：https://www.studytonight.com/java-file-io/java-datainputstream-skipbytes-method

在本教程中，我们将学习 Java 中 DataInputStream 类的skipBytes()方法。此方法用于从给定的 DataInputStream 中跳过给定的“n”字节数的数据。这是一个非静态的方法，在 java.io 包中提供，它从不抛出一个 EOFException。

句法

这是这个方法的语法。它以要跳过的字节数‘n’为参数，返回实际跳过的字节数。

public final int skipBytes(int n) throws IOException

示例:在 Java 中跳过字节

在这个例子中，我们实现了skipBytes()方法来跳过给定流中的字节数。在这里，我们可以看到我们传递了 6 作为参数来跳过 6 个字节，然后我们在跳过前 6 个字节后得到输出。

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		FileInputStream inputStream  = new FileInputStream("E:\\studytonight\\file.txt"); 
		DataInputStream dataInputStream = new DataInputStream(inputStream); 
		dataInputStream.skipBytes(6);
		int count = inputStream.available();
		byte[] byte_arr = new byte[count]; 
		int bytes = dataInputStream.read(byte_arr); 
		for (byte b : byte_arr)
		{ 
			System.out.print((char)b); 
		} 
	}  
}

今晚学习

输出. txt

Hello Studytonight

示例:获取 Java 中的跳过字节

这里，我们跳过给定流中的 2 个字节，这样它就不会从给定流中读取前 2 个字节，然后打印下一个数据。我们可以看到字节数组中只有 3 个字节的数据，前 2 个字节被跳过。

import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
        byte[] byte_arr = { 10, 20, 30, 40, 50 }; 
        ByteArrayInputStream byteArrayInputStr = new ByteArrayInputStream(byte_arr); 
        DataInputStream dataInputStr = new DataInputStream(byteArrayInputStr); 
        dataInputStr.skipBytes(2);  
        while (dataInputStr.available() > 0) 
        { 
            System.out.println(dataInputStr.readByte()); 
        } 
	}  
}

30
40
50

结论

在本教程中，我们学习了 Java 中 DataInputStream 类的skipBytes()方法，该方法从给定的输入流中跳过“n”个字节的数据，并返回跳过的确切字节数。

Java `DataInputStream.read()`方法

原文：https://www.studytonight.com/java-file-io/java-datainputstream-read-method

在本教程中，我们将学习 Java 中 DataInputStream 类的read()方法。这个方法的工作是从当前输入流中读取字节，并将它们存储在缓冲字节数组中。它是一个非静态方法，在 java.io 包中可用，只能用类对象访问，试图用类名调用它会导致错误。

句法

这是这个方法的语法。它接受 b 作为参数，该参数是字节缓冲区数组，数据将从该流中读入该数组。

public final int read(byte[] b) throws IOException

它返回以整数形式读取的实际字节数，如果到达流的末尾，则返回-1。

示例:用 Java 读取`DataInputStream`

在本例中，我们使用 read()方法从文件中读取数据，从文件中读取数据后，该方法将数据复制到传递的字节数组中，并返回指示从文件中读取的字节数的整数值。在这个例子中，我们读取了 18 个字节。

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		FileInputStream inputStream  = new FileInputStream("E:\\studytonight\\file.txt"); 
		DataInputStream dataInputStream = new DataInputStream(inputStream); 
		int count = inputStream.available(); 
		byte[] byte_arr = new byte[count]; 
		int bytes = dataInputStream.read(byte_arr); 
		System.out.println("Total bytes: "+bytes); 
		for (byte b : byte_arr)
		{ 
			System.out.print((char)b); 
		} 
	}  
}

总字节:18
你好今晚学习

示例 2:使用 Java 中的`DataInputStream`读取数据

这里，我们实现了 read()方法的另一个重载方法，在这里，我们可以通过传递 offset(开始指针)和要读取的数据长度来对数据进行切片，而不是从文档中读取整个数据。

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		FileInputStream inputStream  = new FileInputStream("E:\\studytonight\\file.txt"); 
		DataInputStream dataInputStream = new DataInputStream(inputStream); 
		int count = inputStream.available(); 
		byte[] byte_arr = new byte[count]; 
		int bytes = dataInputStream.read(byte_arr, 0, 5); 
		System.out.println("Total bytes: "+bytes); 
		for (byte b : byte_arr)
		{ 
			System.out.print((char)b); 
		} 
	}  
}

总字节:5
您好

结论

在本教程中，我们学习了 Java 中 DataInputStream 类的read()方法，该方法用于从当前输入流中读取字节并将其存储在缓冲字节数组中。它以整数形式返回实际读取的字节数，如果到达流的末尾并且没有更多数据可供读取，则返回-1。

Java `DataInputStream.readInt()`方法

原文：https://www.studytonight.com/java-file-io/java-datainputstream-readint-method

在本教程中，我们将学习 Java 中 DataInputStream 类的readInt()方法。此方法用于读取四个输入字节的数据值并返回一个整数值。

它从输入流中读取接下来的四个字节，并将它们解释为Integer类型。这是一个非静态方法，可在 java.io 包中获得。

句法

这是这个方法的语法。它不接受任何参数，并返回从当前输入流的下四个字节解释的整数值。

public final int readInt() throws IOException

示例:使用 Java 中的`DataInputStream`读取整数

在这个例子中，我们实现了 readInt()方法来从文件中读取Integer类型的数据。这里，我们将运行循环，直到数据在文件中可用，一旦数据在文件中不可用，我们将停止从文件中读取数据。

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		FileInputStream inputStream  = new FileInputStream("E:\\studytonight\\output.txt"); 
		DataInputStream dataInputStream = new DataInputStream(inputStream); 
		while(dataInputStream.available()>0)
		{	           
            System.out.print(" "+dataInputStream.readInt());  
        }  
	}  
}

1 2 3 4 5

file //output.txt

1 2 3 4 5

示例 2:使用 Java 中的 DataInputStream 读取整数数据

这里，我们使用readInt()方法从文件中读取数据，该示例与上面提到的示例相同，但是我们从读取数据的位置更改了文件。。示例文件中包含的数据显示在下面给出的文件中:

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		FileInputStream inputStream  = new FileInputStream("E:\\studytonight\\file.txt"); 
		DataInputStream dataInputStream = new DataInputStream(inputStream); 
		while(dataInputStream.available()>0)
		{	           
            System.out.print(" "+dataInputStream.readInt());  
        }  
	}  
}

10 20 30 40 50

file.txt

10 20 30 40 50

结论

在本教程中，我们学习了 Java 中 DataInputStream 类的read()方法，该方法从当前输入流中读取数据值的下四个字节，并将其作为整数值返回。必须仅使用类对象来访问它，因为尝试使用类名访问它将引发 IOException。

Java `DataInputStream.readByte()`方法

原文：https://www.studytonight.com/java-file-io/java-datainputstream-readbyte-method

在本教程中，我们将学习 Java 中 DataInputStream 类的readByte()方法。此方法用于读取和返回从当前输入流中读取的单个输入字节，该字节是-128 到+127 范围内的有符号值。

这是一个非静态方法，可在 java.io 包中获得。

句法

这是这个方法的语法。它不接受任何参数，并返回从当前输入流中读取的带符号 8 位字节值。

public final byte readByte() throws IOException

示例:用 Java 读取字节数组

在这个例子中，我们使用readByte()方法从字节数组中读取数据，这里它将一个接一个地返回数组元素，因为我们正在调用这个方法，直到数据在 DataInputStream 中可用。

import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
        byte[] byte_arr = { 10, 20, 30, 40, 50 }; 
        ByteArrayInputStream byteArrayInputStr = new ByteArrayInputStream(byte_arr); 
        DataInputStream dataInputStr = new DataInputStream(byteArrayInputStr);   
        while (dataInputStr.available() > 0) 
        { 
            System.out.println(dataInputStr.readByte()); 
        } 
	}  
}

10
20
30
40
50

示例 2:用 Java 读取字节数组

这里，我们讨论的是当流中没有数据时，DataInputStream抛出的异常，或者另一方面，我们可以说DataInputStream指针到达文件的末尾，它将抛出一个异常，即EOFException

import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
        byte[] byte_arr = {}; 
        ByteArrayInputStream byteArrayInputStr = new ByteArrayInputStream(byte_arr); 
        DataInputStream dataInputStr = new DataInputStream(byteArrayInputStr);   
        System.out.println(dataInputStr.readByte());          
	}  
}

在 Java . base/Java . io . datainputstream . read byte(datainputstream . Java:271)处的" main "线程 Java . io . eofeexception
中出现异常

结论

在本教程中，我们学习了 Java 中 DataInputStream 类的readByte()方法，该方法读取并返回单个输入字节，该字节是-128 到+127 范围内的有符号值。

Java `DataInputStream.readChar()`方法

原文：https://www.studytonight.com/java-file-io/java-datainputstream-readchar-method

在本教程中，我们将学习 Java 中 DataInputStream 类的readChar()方法。此方法用于读取两个输入字节(即 16 位)并返回一个字符值。它读取由数据输出流类的writechar()方法写入的字符字节。

句法

这是这个方法的语法。它不接受任何参数，并返回由当前输入流的两个字节解释的带符号字符值。

public final char readChar() throws IOException

示例:使用 Read char()方法读取字符

在这个例子中，我们正在实现readChar()方法，一次从文件中读取 16 位数据，首先我们检查流的指针是否在正确的位置，并且没有到达文件的末尾。这里，我们从文件中读取数据并在控制台上打印，作为参考，文件中的数据是在这个程序输出后给出的。

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		FileInputStream inputStream  = new FileInputStream("E:\\studytonight\\output.txt"); 
		DataInputStream dataInputStream = new DataInputStream(inputStream); 
		while(dataInputStream.available()>0)
		{	           
            System.out.print(" "+dataInputStream.readChar());  
        }  
	}  
}

A B C D E F

输出. txt
A B C D E F

示例:ReadChar()方法中的 EOFException

这里，我们面临一个异常，当我们在读取文件时到达文件的末尾时抛出。它抛出一个名为文件结束异常EOFException.的异常

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		FileInputStream inputStream  = new FileInputStream("E:\\studytonight\\output.txt"); 

		DataInputStream dataInputStream = new DataInputStream(inputStream); 

		System.out.print(" "+dataInputStream.readChar());          
	}  
}

线程“main”Java . io . eofexception
在 Java . base/Java . io . datainputstream . readchar(datainputstream . Java:369)
在今晚的学习中出现异常。study south . main(study south . Java:16)

结论

在本教程中，我们学习了 Java 中 DataInputStream 类的readChar()方法，该方法读取两个输入字节，并返回当前输入流的 DataOutputStream 类的writechar()方法编写的一个字符值。

Java `DataInputStream.readUTF()`方法

原文：https://www.studytonight.com/java-file-io/java-datainputstream-readutf-method

在本教程中，我们将学习 Java 中 DataInputStream 类的readUTF()方法。此方法用于读取使用修改的 UTF-8(统一文本格式)编码的字符串。字符串从 UTF 解码并作为字符串返回。

这是一个非静态方法，可在 java.io 包中获得。

句法

这是这个方法的声明。它不接受任何参数，并返回一个 Unicode 字符串。

public final String readUTF()

示例 1:用 Java 阅读 UTF 字符

此方法用于读取由 UTF-8 编码的数据，此方法以字符串的格式返回数据，在本例中，它返回“Hello World”。

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		FileInputStream inputStream  = new FileInputStream("E:\\studytonight\\file.txt"); 

		DataInputStream dataInputStream = new DataInputStream(inputStream); 

		while(dataInputStream.available()>0) 
		{
			String k = dataInputStream.readUTF();           
			System.out.print(k+" ");
		}
	}  
}

你好世界

示例 2:用 Java 阅读 UTF 字符

当没有要从文件中读取的数据时，它将抛出一个异常，也称为文件结束异常，因为此时指针指向最后一个位置并将抛出EOFException。

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class StudyTonight 
{
	public static void main(String[] args) throws IOException 
	{ 
		FileInputStream inputStream  = new FileInputStream("E:\\studytonight\\file.txt"); 
		DataInputStream dataInputStream = new DataInputStream(inputStream); 
		while(dataInputStream.available()>0) 
		{
			String k = dataInputStream.readUTF();           
			System.out.print(k+" ");
		}
	}  
}

执行绪「main」Java . io . eofeexception
at Java . base/Java . io . datainputstream . readfully(datainputstream . Java:201)
at Java . base/Java . io . datainputstream . read utf(datainputstream . Java:613)
at Java . base/Java . io . datainputstream . read utf(datainputstream . Java:568)】studytonight . main(studytonight . Java:16)

结论

在本教程中，我们学习了 Java 中 DataInputStream 类的readUTF()方法，该方法读取一个以 UTF-8 格式编码的字符串。字符串从 UTF 解码并作为字符串返回。

Java `FilterWriter`方法

Java `FilterWriter.flush()`方法

原文：https://www.studytonight.com/java-file-io/java-filterwriter-flush-method

在本教程中，我们将学习FilterWriter 课中的flush()方法。flush()方法属于java.io 包，用于从该 FilterWriter 流中清除字符串。这个方法是一个非静态的方法，它只能用类对象访问，如果我们试图用类名访问这个方法，那么我们会得到一个错误。此方法可能会在刷新流时引发异常。

句法

这是 flush 方法的语法声明。此方法将清空字符串。

public void flush()

IOException :当得到任何输入输出错误时，这个异常可能会抛出。

冲洗()方法的示例

在下面的示例中，我们使用 flush()方法从 FilterWriter 中清除字符串。

import java.io.FilterWriter;
import java.io.StringWriter;
import java.io.Writer;
public class StudyTonight
{
	public static void main(String[] args) 
	{
		try
		{
			Writer writer = new StringWriter(10);
			FilterWriter filterWriter = new FilterWriter(writer) {};
			filterWriter.write('S');
			filterWriter.write('t');
			filterWriter.write('u');
			filterWriter.write('d');
			filterWriter.write('y');
			filterWriter.flush();
			String str = writer.toString();
			System.out.println(str);
			filterWriter.flush();
		}
		catch(Exception e)
		{
			System.out.println("Exception: "+e.toString());
		}

	}
}

学习

这个方法是非静态方法，如果我们试图用类名调用它，它会导致一个错误:

FilterWriter.flush();

线程“main”Java . lang . error:未解决的编译问题:
无法从 FilterWriter 类型对非静态方法 flush()进行静态引用

结论

在本教程中，我们学习了 Java 中FileWriter类的flush()方法，该方法用于从FileWriter流中清除字符串。它是一个非静态方法，在 java.io 包中可用，只能用类对象访问，试图用类名访问它会导致错误。

Java `FilterWriter.write()`方法

原文：https://www.studytonight.com/java-file-io/java-filterwriter-write-method

在本教程中，我们将从 Java 中的FilterWriter 类学习write() 方法。我们使用 write()方法将数据写入 FilterWriter，我们有三种不同的 write()方法重载方法。

句法

该方法有三种重载形式，以支持各种数据及其切片部分。

这个重载方法将接收三个参数，一个字符数组，偏移量表示数据中的起始位置，最后一个参数表示数据的长度，这样它就写入了字符数组的一部分。

void write(char[] cbuf, int off, int len)

这是另一个重载方法，它将一个整数作为字符的 ASCII 码，并将其写入流，它只写入一个字符。

void write(int c)

这是另一个重载方法，它将接受字符串作为源数据，偏移量作为开始写入的起始位置以及要写入文件的数据长度。

void write(String str, int off, int len)

write()方法示例

在下面的程序中，我们从字符串数组 str 中写入数据，因为我们传递了偏移值 2，所以它将在跳过 0、1 和 2 个索引后从读取第三个索引开始，文本长度将为 8 个字符。

import java.io.FileWriter;
import java.io.FilterWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			char str[]={'s', 't', 'u', 'd', 'y', 't', 'o', 'n', 'i', 'g', 'h', 't'};
			FileWriter fileWriter = new FileWriter("E:\\studytonight\\output.txt");         
			FilterWriter filterWriter = new FilterWriter(fileWriter) {};             
			filterWriter.write(str, 2, 8);  
			filterWriter.close();  
			System.out.println("Data is written to the file successfully...");
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

数据成功写入文件...

输出. txt

udytonig

write()方法示例

在这个例子中，我们看到最简单的重载方法 write()，它将接受整数作为 ASCII 代码，并将它写入输出流。

import java.io.FileWriter;
import java.io.FilterWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			FileWriter fileWriter = new FileWriter("E:\\studytonight\\output.txt");         
			FilterWriter filterWriter = new FilterWriter(fileWriter) {};             
			filterWriter.write(65);  
			filterWriter.close();  
			System.out.println("Data is written to the file successfully...");
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

数据成功写入文件...

输出. txt

write()方法示例

这个例子类似于第一个例子，我们使用了字符数组，唯一的区别是这里我们使用了字符串而不是数组，我们传递 2 作为 ana 偏移量，8 是要写入输出流的字符串长度。

import java.io.FileWriter;
import java.io.FilterWriter;
public class StudyTonight 
{
	public static void main(String args[])
	{
		try
		{
			String str = "studytonight";
			FileWriter fileWriter = new FileWriter("E:\\studytonight\\output.txt");         
			FilterWriter filterWriter = new FilterWriter(fileWriter) {};             
			filterWriter.write(str, 2, 8);  
			filterWriter.close();  
			System.out.println("Data is written to the file successfully...");
		}
		catch(Exception e)
		{
			System.out.println("Error: "+e.toString());
		}
	}
}

数据成功写入文件...

输出. txt

udytonig

结论

在本教程中，我们学习了 Java 中 FilterWriter 的 write()方法。这个方法有三种重载方法，void write(char[] cbuf, int off, int len)、void write(int c)和void write(String str, int off, int len)方法。

posted @ 2024-10-24 18:13 绝不原创的飞龙阅读(3) 评论(0) 编辑收藏举报

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

StudyTonight-Java-中文教程-七-

StudyTonight Java 中文教程（七）

Java 中的字符流类

Java Reader类

读者课的方法

Java Writer类

写作课的方法

结论

Java 字节流类

Java BufferedInputStream

句法

Java BufferedInputStream 构造器

Java BufferedInputStream方法

使用read()方法的 Java BufferedInputStream 示例

使用skip()方法的 Java BufferedInputStream 示例

使用available()方法的 Java BufferedInputStream 示例

结论

Java FileOutputStream类

句法

构造器

方法

write() 方法示例:

用于追加的文件输出流构造器示例:

结论

Java FileInputStream类

句法

方法

从文件读取数据的FileInputStream示例

available()方法示例

skip()方法示例

结论

Java BufferedOutputStream类

句法

Java BufferedOutputStream类构造器

方法

使用 BufferedOutputStream 将数据写入文件的示例

结论:

Java SequenceInputStream类

Java 序列输出流类声明

SequenceInputStream 类的构造器

序列输出流类的方法

Java 序列输出流示例

从两个文件中读取数据并写入另一个文件的示例

结论

Java ByteArrayOutputStream类

句法

Java 字节数组输出流类构造器

Java 字节数组输出流类方法

Java 字节数组输出流示例

结论

Java ByteArrayInputStream类

句法

Java ByteArrayInputStream类构造器

Java ByteArrayInputStream类方法

Java ByteArrayInputStream示例

结论:

Java DataOutputStream类

句法

方法

使用writeInt()方法的数据输出流类示例

数据输出流类方法示例

结论

Java DataInputStream类

句法

方法

从文件中读取数据的 DataInputStream 类的示例

读写原始数据的示例:

结论

Java FilterOutputStream类

句法

Java 筛选器输出流类方法

FilterOutputStream 类的示例

结论

Java FilterInputStream类

句法

Java FilterInputStream 类方法

FilterInputStream类方法示例

FilterInputStream 类中的 available()示例

Java `Reader`类

Java `Writer`类

Java `BufferedInputStream`

Java `BufferedInputStream`方法

使用`read()`方法的 Java BufferedInputStream 示例

使用`skip()`方法的 Java BufferedInputStream 示例

使用`available()`方法的 Java BufferedInputStream 示例

Java `FileOutputStream`类

`write()` 方法示例:

Java `FileInputStream`类

从文件读取数据的`FileInputStream`示例

`available()`方法示例

`skip()`方法示例

Java `BufferedOutputStream`类

Java `BufferedOutputStream`类构造器

Java `SequenceInputStream`类

Java `ByteArrayOutputStream`类

Java `ByteArrayInputStream`类

Java `ByteArrayInputStream`类构造器

Java `ByteArrayInputStream`类方法

Java `ByteArrayInputStream`示例

Java `DataOutputStream`类

使用`writeInt()`方法的数据输出流类示例

Java `DataInputStream`类

Java `FilterOutputStream`类

Java `FilterInputStream`类

`FilterInputStream`类方法示例

FilterInputStream 类中的 `available()`示例

Java `ObjectStream`类

`ObjectStream`类及其方法示例

Java `ObjectStreamField`类

Java `Console`类

Java `Console`类方法

Java `FilePermission`类

Java `FilePermission`类方法

Java `Writer`类

Java `FilterReader`

Java `FilterWriter`

`FilterWriter`方法

Java `PushbackReader`类

推送`Reader`类构造器

推送`Reader`类方法

推送`Reader`类示例

推送`Reader`类示例

Java `Reader`类

使用`Reader`类读取字符数组

Java `FileWriter`类

`FileWriter`类的构造器

`FileWriter`类的方法

Java `FileReader`类

`FileReader`类的构造器