锐客网

  1. 首页 > 睿知 > it技术 > >

输出流java代码范例 java输出流输出文件

输出IT技术

用JAVA输入输出流知识编写一段代码 ， 实现的功能是：统计一个文件中字母“a”或“A”出现的总次数 。楼上的回答是正确的，我给补充更完整一点 。import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;public class Aa {
public static void main(String[] args) throws Exception {
File file = new File("e:/Aa2.txt");
if(file.exists()==false){
System.out.println("文件不存在");
return;
}
if(file.isDirectory()){
System.out.println("这是一个目录");
return;
}
FileInputStream aa=new FileInputStream(file);
DataInputStream hc=new DataInputStream(aa);
int count=0;
byte z;
try{
while(true)
{
z=hc.readByte();
if(z==65||z==97)
count;
}
}catch(Exception ex)
{
System.out.print("文件中A和a出现的总次数是：" count);
}
}}
增加的内容是如果文件不存在或者地址只是一个文件夹的话，就抛出异常“文件不存在”或者“这是一个目录”还可以判断如果文件不存在的话，就创建这个文件，但是用户题目没有需求，所以就不写了
java怎么输出？java控制台输出由print( ) 和 println( )来完成最为简单 。这两种方法由rintStream(System.out引用的对象类型)定义 。尽管System.out是一个字节流，用它作为简单程序的输出是可行的 。因为PrintStream是从OutputStream派生的输出流，它同样实现低级方法write()，write()可用来向控制台写数据 。PrintStream 定义的write( )的最简单的形式如下：
void write(int byteval)
该方法按照byteval指定的数目向文件写字节 。尽管byteval 定义成整数，但只有低位的8个字节被写入 。下面的短例用 write()向屏幕输出字符“A”，然后是新的行 。
// Demonstrate System.out.write().
class WriteDemo {
public static void main(String args[]) {
int b;
b = 'A';
System.out.write(b);
System.out.write('\n');
}
}
一般不常用write()来完成向控制台的输出（尽管这样做在某些场合非常有用），因为print()和println() 更容易用 。
四、PrintWriter类
尽管Java允许用System.out向控制台写数据，但建议仅用在调试程序时或在例程中 。对于实际的程序，Java推荐的向控制台写数据的方法是用PrintWriter流 。PrintWriter是基于字符的类 。用基于字符类向控制台写数据使程序更为国际化 。PrintWriter定义了多个构造函数，这里所用到的一个如下：
PrintWriter(OutputStream outputStream, boolean flushOnNewline)
outputStream是OutputStream类的对象，flushOnNewline控制Java是否在println()方法被调用时刷新输出流 。如果flushOnNewline为true，刷新自动发生，若为false，则不发生 。
PrintWriter支持所有类型（包括Object）的print( )和println( )方法，这样，就可以像用ystem.out那样用这些方法 。如果遇到不同类型的情况，PrintWriter方法调用对象的toString()方法并打印结果 。用PrintWriter向外设写数据，指定输出流为System.out并在每一新行后刷新流 。例如这行代码创建了与控制台输出相连的PrintWriter类 。
PrintWriter pw = new PrintWriter(System.out, true);
下面的应用程序说明了用PrintWriter处理控制台输出的方法：
// Demonstrate PrintWriter
import java.io.*;
public class PrintWriterDemo {
public static void main(String args[]) {
PrintWriter pw = new PrintWriter(System.out, true);
pw.println("This is a string");
int i = -7;
pw.println(i);
double d = 4.5e-7;
pw.println(d);
}
}
该程序的输出如下：
This is a string
-7
4.5E-7
io包支持Java的基本I/O（输入/输出）系统，包括文件的输入/输出 。对输入/输出的支持是来源于Java的内核API库，而不是语言关键字 。
一、输入/输出基础
很多实际的Java应用程序不是基于文本的控制台程序 。尽管基于文本的程序作为教学实例是很出色的，它们无法胜任JAVA在实际中的重要应用 。Java对外设输入/输出的支持也是有限的 ， 并且用起来有些笨拙——甚至是在简单的例子程序中 。基于文本的控制台输入/输出对于Java程序并不是十分重要 。
Java 提供了与文件和网络相关的强大的和灵活的输入/输出支持，Java的输入/输出系统是紧密相连并且是具有一致性的 。
1.1 流的概念
Java程序通过流来完成输入/输出 。流是生产或消费信息的抽象 。流通过Java的输入/输出系统与物理设备链接 。尽管与它们链接的物理设备不尽相同，所有流的行为具有同样的方式 。这样，相同的输入/输出类和方法适用于所有类型的外部设备 。这意味着一个输入流能够抽象多种不同类型的输入：从磁盘文件 ， 从键盘或从网络套接字 。同样，一个输出流可以输出到控制台，磁盘文件或相连的网络 。流是处理输入/输出的一个洁净的方法，例如它不需要代码理解键盘和网络的不同 。Java中流的实现是在java.io包定义的类层次结构内部的 。
1.2 字节流和字符流
要使用流类 ， 必须导入Java.io包 。Java 2 定义了两种类型的流：字节类和字符类 。字节流（byte stream）为处理字节的输入和输出提供了方便的方法 。例如使用字节流读取或书写二进制数据 。字符流（character stream）为字符的输入和输出处理提供了方便 。它们采用了统一的编码标准，因而可以国际化 。在某些场合，字符流比字节流更有效 。在最底层，所有的输入/输出都是字节形式的 。基于字符的流只为处理字符提供方便有效的方法 。下面是对字节流和字符流的概述 。
1.2.1 字节流类
字节流由两个类层次结构定义 。在顶层有两个抽象类：InputStream 和 OutputStream 。每个抽象类都有多个具体的子类，这些子类对不同的外设进行处理，例如磁盘文件，网络连接 ， 甚至是内存缓冲区 。字节流类显示于表1-1中 。
表1-1 字节流类
流类 含义
BufferedInputStream缓冲输入流
BufferedOutputStream缓冲输出流
ByteArrayInputStream从字节数组读取的输入流
ByteArrayOutputStream向字节数组写入的输出流
DataInputStream包含读取Java标准数据类型方法的输入流
DataOutputStream包含编写Java标准数据类型方法的输出流
FileInputStream读取文件的输入流
FileOutputStream写文件的输出流
FilterInputStream实现InputStream
FilterOutputStream实现OutputStream
InputStream描述流输入的抽象类
OutputStream描述流输出的抽象类
PipedInputStream输入管道
PipedOutputStream输出管道
PrintStream包含print()和println()的输出流
PushbackInputStream 支持向输入流返回一个字节的单字节的“unget”的输入流
RandomAccessFile支持随机文件输入/输出
SequenceInputStream两个或两个以上顺序读取的输入流组成的输入流
抽象类InputStream 和 OutputStream定义了实现其他流类的关键方法 。最重要的两种方法是read()和write()，它们分别对数据的字节进行读写 。两种方法都在InputStream 和OutputStream中被定义为抽象方法 。它们被派生的流类重载 。
1.2.2 字符流类
字符流类由两个类层次结构定义 。顶层有两个抽象类：Reader和Writer 。这些抽象类处理统一编码的字符流 。Java中这些类含有多个具体的子类 。字符流类如表1-2所示 。
表1-2 字符流的输入/输出类
抽象类Reader和Writer定义了几个实现其他流类的关键方法 。其中两个最重要的是read()和write()，它们分别进行字符数据的读和写 。这些方法被派生流类重载 。
1.3 预定义流
所有的Java程序自动导入java.lang包 。该包定义了一个名为System的类 ， 该类封装了运行时环境的多个方面 。System 同时包含三个预定义的流变量，in ， out和err 。这些成员在System中是被定义成public 和static型的，这意味着它们可以不引用特定的System对象而被用于程序的其他部分 。
System.out是标准的输出流 。默认情况下，它是一个控制台 。System.in是标准输入，默认情况下，它指的是键盘 。System.err指的是标准错误流 ， 它默认是控制台 。然而 ， 这些流可以重定向到任何兼容的输入/输出设备 。System.in 是inputStream的对象；System.out和System.err是PrintStream的对象 。它们都是字节流，尽管它们用来读写外设的字符 。但可以用基于字符的流来包装它们 。
二、读取控制台输入
在Java 1.0中 ， 完成控制台输入的惟一途径是字节流，使用该方法的老代码依然存在 。今天，运用字节流读取控制台输入在技术上仍是可行的，但这样做需要用到不被赞成的方法，这种做法不值得推荐 。Java 2中读取控制台输入的首选方法是字符流，它使程序容易符合国际标准并且易于维护 。
Java没有像标准C的函数scanf()或C输入操作符那样的统一的控制台输入方法 。Java中，控制台输入由从System.in读取数据来完成 。为获得属于控制台的字符流，在BufferedReader对象中包装System.in 。BufferedReader 支持缓冲输入流查看批注 。它最常见的构造函数如下：
BufferedReader(Reader inputReader)
这里 ， inputReader是链接被创建的BufferedReader实例的流 。Reader是一个抽象类 。它的一个具体的子类是InputStreamReader，该子类把字节转换成字符查看批注 。为获得链接System.in的一个InputStreamReader的对象，用下面的构造函数：
InputStreamReader(InputStream inputStream)
因为System .in引用了InputStream 类型的对象，它可以用于inputStream 。综上所述，下面的一行代码创建了与键盘相连的BufferedReader对象 。
BufferedReader br = new BufferedReader(new
InputStreamReader(System.in));
当该语句执行后 ， br是通过System.in生成的链接控制台的字符流 。
2.1 读取字符
从BufferedReader读取字符，用read() 。这里所用的read()版本如下：
int read( ) throws IOException
该方法每次执行都从输入流读取一个字符然后以整型返回 。当遇到流的末尾时它返回-1 。可以看到，它要引发一个IOException异常 。下面的例程演示了read()方法，从控制台读取字符直到用户键入“q”：
// Use a BufferedReader to read characters from the console.
import java.io.*;
class BRRead {
public static void main(String args[])
throws IOException
{
char c;
BufferedReader br = new
BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter characters, 'q' to quit.");
// read characters
do {
c = (char) br.read();
System.out.println(c);
} while(c != 'q');
}
}
下面是程序运行：
Enter characters, 'q' to quit.
123abcq
1
2
3
a
b
c
q
2.2 读取字符串
从键盘读取字符串 ， 使用readLine() 。它是BufferedReader 类的成员 。它的通常形式如下：
String readLine( ) throws IOException
它返回一个String对象 。下面的例子阐述了BufferedReader类和readLine()方法；程序读取和显示文本的行直到键入“stop”：
// Read a string from console using a BufferedReader.
import java.io.*;
class BRReadLines {
public static void main(String args[])
throws IOException
{
// create a BufferedReader using System.in
BufferedReader br = new BufferedReader(new
InputStreamReader(System.in));
String str;
System.out.println("Enter lines of text.");
System.out.println("Enter 'stop' to quit.");
do {
str = br.readLine();
System.out.println(str);
} while(!str.equals("stop"));
}
}
下面的例程生成了一个小文本编辑器 。它创建了一个String对象的数组，然后依行读取文本 ， 把文本每一行存入数组 。它将读取到100行或直到按“stop”才停止 。该例运用一个BufferedReader类来从控制台读取数据 。
// A tiny editor.
import java.io.*;
class TinyEdit {
public static void main(String args[])
throws IOException
{
// create a BufferedReader using System.in
BufferedReader br = new BufferedReader(new
InputStreamReader(System.in));
String str[] = new String[100];
System.out.println("Enter lines of text.");
System.out.println("Enter 'stop' to quit.");
for(int i=0; i100; i) {
str[i] = br.readLine();
if(str[i].equals("stop")) break;
}
System.out.println("\nHere is your file:");
// display the lines
for(int i=0; i100; i) {
if(str[i].equals("stop")) break;
System.out.println(str[i]);
}
}
}
下面是输出部分：
Enter lines of text.
Enter ‘stop’ to quit.
This is line one.
This is line two.
Java makes working with strings easy.
Just create String objects.
stop
Here is your file:
This is line one.
This is line two.
Java makes working with strings easy.
Just create String objects.
java输入输出流与文件，求源代码！感谢大佬！输出流java代码范例你好输出流java代码范例，java输出流java代码范例的API中提供了用于对象输入输出文件的操作，实例代码如下输出流java代码范例：
定义单词类如下(注意：输出流java代码范例你定义的类要实现Serializable接口)
public class Words implements Serializable {
private int size;
private String[] words;
public Words(){};
public Words(String...strs){
this.words = strs;
this.size = strs.length;
}
@Override
public String toString() {
return "Words{"
"size="size
", words="Arrays.toString(words)
'}';
}
}
2. 对象输入输出api测试类
public class ObjIOTest {
public static void main(String[] args) {
String path = "d:/myIOTest.txt";
ObjIOTest objIOTest = new ObjIOTest();
Words words = new Words("hello", "my", "dear", "friend");
try {
objIOTest.writeObject(path,words);
Words wordsFromFile = (Words)objIOTest.readObject(path);
System.out.println(wordsFromFile.toString());
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
//java serialize a object to file
public void writeObject(String path,Object map) throws IOException{
File f=new File(path);
FileOutputStream out=new FileOutputStream(f);
ObjectOutputStream objwrite=new ObjectOutputStream(out);
objwrite.writeObject(map);
objwrite.flush();
objwrite.close();
}
// read the object from the file
public Object readObject(String path) throws IOException, ClassNotFoundException{
FileInputStream in=new FileInputStream(path);
ObjectInputStream objread=new ObjectInputStream(in);
Object map=objread.readObject();
objread.close();
return map;
}
}
把两段代码拷贝到一个包下即可运行了，希望您的问题得到解答
java输入输出流怎么写 ， stream代表的是任何有能力产出数据的数据源，或是任何有能力接收数据的接收源 。在Java的IO中，所有的stream（包括Inputstream和Out stream）都包括两种类型：
(1)字节流
表示以字节为单位从stream中读取或往stream中写入信息，即io包中的inputstream类和outputstream类的派生类 。通常用来读取二进制数据，如图象和声音 。
（2）字符流
以Unicode字符为导向的stream，表示以Unicode字符为单位从stream中读取或往stream中写入信息 。
区别：
Reader和Writer要解决的，最主要的问题就是国际化 。原先的I/O类库只支持8位的字节流，因此不可能很好地处理16位的Unicode字符流 。Unicode是国际化的字符集(更何况Java内置的char就是16位的Unicode字符)，这样加了Reader和Writer之后，所有的I/O就都支持Unicode了 。此外新类库的性能也比旧的好 。
但是，Read和Write并不是取代InputStream和OutputStream ， 有时，你还必须同时使用"基于byte的类"和"基于字符的类" 。为此，它还提供了两个"适配器(adapter)"类 。InputStreamReader负责将InputStream转化成Reader，而OutputStreamWriter则将OutputStream转化成Writer 。
一．流的层次结构
定义：
（1）java将读取数据对象成为输入流，能向其写入的对象叫输出流 。结构图如下：输入流：
输出流
二．InputStream类
inputstream类和outputstream类都为抽象类，不能创建对象，可以通过子类来实例化 。
InputStream是输入字节数据用的类，所以InputStream类提供了3种重载的read方法.Inputstream类中的常用方法：
（1）public abstract int read( )：读取一个byte的数据，返回值是高位补0的int类型值 。
（2）public int read(byte b[ ])：读取b.length个字节的数据放到b数组中 。返回值是读取的字节数 。该方法实际上是调用下一个方法实现的
（3）public int read(byte b[ ], int off, int len)：从输入流中最多读取len个字节的数据，存放到偏移量为off的b数组中 。
（4）public int available( )：返回输入流中可以读取的字节数 。注意：若输入阻塞 ， 当前线程将被挂起，如果InputStream对象调用这个方法的话，它只会返回0 ， 这个方法必须由继承InputStream类的子类对象调用才有用，
（5）public long skip(long n)：忽略输入流中的n个字节，返回值是实际忽略的字节数, 跳过一些字节来读取
（6）public int close( ) ：我们在使用完后 ， 必须对我们打开的流进行关闭.
三．OutputStream类
OutputStream提供了3个write方法来做数据的输出，这个是和InputStream是相对应的 。
1. public void write(byte b[ ])：将参数b中的字节写到输出流 。
2. public void write(byte b[ ], int off, int len) ：将参数b的从偏移量off开始的len个字节写到输出流 。
3. public abstract void write(int b) ：先将int转换为byte类型，把低字节写入到输出流中 。
4. public void flush( ) : 将数据缓冲区中数据全部输出，并清空缓冲区 。
5. public void close( ) : 关闭输出流并释放与流相关的系统资源 。
注意：
1. 上述各方法都有可能引起异常 。
2. InputStream和OutputStream都是抽象类，不能创建这种类型的对象 。
四．FileInputStream类
FileInputStream类是InputStream类的子类 ， 用来处理以文件作为数据输入源的数据流 。使用方法：
方式1：
File fin=new File("d:/abc.txt");
FileInputStream in=new FileInputStream(fin);
方式2：
FileInputStream in=new
FileInputStream("d: /abc.txt");
方式3：
构造函数将 FileDescriptor()对象作为其参数 。
FileDescriptor() fd=new FileDescriptor();
FileInputStream f2=new FileInputStream(fd);
五．FileOutputStream类
FileOutputStream类用来处理以文件作为数据输出目的数据流；一个表示文件名的字符串，也可以是File或FileDescriptor对象 。
创建一个文件流对象有两种方法：
方式1：
File f=new File("d:/abc.txt");
FileOutputStream out=new FileOutputStream (f);
方式2：
FileOutputStream out=new
FileOutputStream("d:/abc.txt");
方式3：构造函数将 FileDescriptor()对象作为其参数 。
FileDescriptor() fd=new FileDescriptor();
FileOutputStream f2=new FileOutputStream(fd);
方式4：构造函数将文件名作为其第一参数，将布尔值作为第二参数 。
FileOutputStream f=new FileOutputStream("d:/abc.txt",true);
注意：
（1）文件中写数据时，若文件已经存在，则覆盖存在的文件；（2）的读/写操作结束时，应调用close方法关闭流 。
举例：2-1
六．File类
File类与InputStream / OutputStream类同属于一个包 ， 它不允许访问文件内容 。
File类主要用于命名文件、查询文件属性和处理文件目录 。
举例：2-2
七．从一个流构造另一个流
java的流类提供了结构化方法，如，底层流和高层过滤流 。
而高层流不是从输入设备读取，而是从其他流读取 。同样高层输出流也不是写入输出设备，而是写入其他流 。
使用"分层对象(layered objects)"，为单个对象动态地，透明地添加功能的做法，被称为Decorator Pattern 。Decorator模式要求所有包覆在原始对象之外的对象，都必须具有与之完全相同的接口 。这使得decorator的用法变得非常的透明--无论对象是否被decorate过，传给它的消息总是相同的 。这也是Java I/O类库要有"filter(过滤器)"类的原因：抽象的"filter"类是所有decorator的基类 。Decorator模式常用于如下的情形：如果用继承来解决各种需求的话 ， 类的数量会多到不切实际的地步 。Java的I/O类库需要提供很多功能的组合 ， 于是decorator模式就有了用武之地 。
为InputStream和OutputStream定义decorator类接口的类，分别是FilterInputStream和FilterOutputStream 。
7.1 FilterInputStream
FilterInputStream的种类
类
功能
构造函数的参数
用法
DataInputStream
与DataOutputStream配合使用，这样你就能以一种"可携带的方式(portable fashion)"从流里读取primitives了（int，char，long等）
InputStream
包含了一整套读取primitive数据的接口 。
BufferedInputStream
用这个类来解决"每次要用数据的时候都要进行物理读取"的问题 。你的意思是"用缓冲区 。"
InputStream，以及可选的缓冲区的容量
它本身并不提供接口，只是提供一个缓冲区 。需要连到一个"有接口的对象(interface object)" 。
LineNumberInputStream
跟踪输入流的行号；有getLineNumber( )和setLineNumber(int)方法
InputStream
只是加一个行号，所以还得连一个"有接口的对象" 。
PushbackInputStream
有一个"弹压单字节"的缓冲区(has a one byte push-back buffer)，这样你就能把最后读到的那个字节再压回去了 。
InputStream
主要用于编译器的扫描程序 。可能是为支持Java的编译器而设计的 。用的机会不多 。
FilterOutputStream的种类
类
功能
构造函数的参数
用法
DataOutputStream
与DataInputStream配合使用 ， 这样你就可以用一种"可携带的方式(portable fashion)"往流里写primitive了(int, char, long,等)
OutputStream
包括写入primitive数据的全套接口 。
PrintStream
负责生成带格式的输出(formatted output) 。DataOutputStrem负责数据的存储，而PrintStream负责数据的显示 。
一个OutputStream以及一个可选的boolean值 。这个boolean值表示，要不要清空换行符后面的缓冲区 。
应该是OutputStream对象的最终包覆层 。用的机会很多 。
BufferedOutputStream
用 这个类解决"每次往流里写数据 ， 都要进行物理操作"的问题 。也就是说"用缓冲区" 。用flush( )清空缓冲区 。
OutputStream ， 以及一个可选的缓冲区大小
本身并不提供接口，只是加了一个缓冲区 。需要链接一个有接口的对象 。
DataInputStream类对象可以读取各种类型的数据 。
DataOutputStream类对象可以写各种类型的数据；
创建这两类对象时，必须使新建立的对象指向构造函数中的参数对象 。例如：
FileInputStream in=new FileInputStream("d:/abc.txt");
DataInputStream din=new DataInputStream(in);
7.2BufferInputStream和bufferOutputStream
允许程序在不降低系统性能的情况下一次一个字节的从流中读取数据 。
BufferInputstream定义了两种构造函数
（1）BufferInputStream b= new BufferInputstream(in);
（2）BufferInputStream b=new BufferInputStream(in,size)
第二个参数表示指定缓冲器的大小 。
同样BufferOutputStream也有两种构造函数 。一次一个字节的向流中写数据 。
7.3printstream
用于写入文本或基本类型
两种构造函数方法：
PrintStream ps=new PrintStream(out);
PrintStream ps=new PrintStream(out, autoflush)
第二个参数为布尔值，控制每次输出换行符时java是否刷新输出流 。
八．字符流的读取和写入
java.io.Reader 和 java.io.InputStream 组成了 Java 输入类 。Reader 用于读入16位字符 ， 也就是 Unicode 编码的字符；而 InputStream 用于读入 ASCII 字符和二进制数据 。
Reader的体系结构
（1）FileReader
FileReader主要用来读取字符文件 ， 使用缺省的字符编码，有三种构造函数：
--将文件名作为字符串
FileReader f=new FileReader(“c:/temp.txt”);
--构造函数将File对象作为其参数 。
File f=new file(“c:/temp.txt”);
FileReader f1=new FileReader(f);
--构造函数将FileDescriptor对象作为参数
FileDescriptor() fd=new FileDescriptor()
FileReader f2=new FileReader(fd);
(2)charArrayReader
将字符数组作为输入流,构造函数为：
public CharArrayReader(char[] ch);
(3)StringReader
读取字符串，构造函数如下：
public StringReader(String s);
(4)InputStreamReader
从输入流读取字节，在将它们转换成字符 。
Public inputstreamReader(inputstream is);
(5)FilterReader
允许过滤字符流
protected filterReader(Reader r);
(6)BufferReader
接受Reader对象作为参数，并对其添加字符缓冲器，使用readline()方法可以读取一行 。
Public BufferReader(Reader r);
Writer类体系结构
（1）FileWrite
将字符类型数据写入文件，使用缺省字符编码和缓冲器大小 。
Public FileWrite(file f);
(2)chararrayWrite()
将字符缓冲器用作输出 。
Public CharArrayWrite();
(3)PrintWrite
生成格式化输出
public PrintWriter(outputstream os);
(4)filterWriter
用于写入过滤字符流
protected FilterWriter(Writer w);
FilterOutputStream的种类
类
功能
构造函数的参数
用法
DataOutputStream
与DataInputStream配合使用，这样你就可以用一种"可携带的方式(portable fashion)"往流里写primitive了(int, char, long,等)
OutputStream
包括写入primitive数据的全套接口 。
PrintStream
负责生成带格式的输出(formatted output) 。DataOutputStrem负责数据的存储，而PrintStream负责数据的显示 。
一个OutputStream以及一个可选的boolean值 。这个boolean值表示，要不要清空换行符后面的缓冲区 。
应该是OutputStream对象的最终包覆层 。用的机会很多 。
BufferedOutputStream
用 这个类解决"每次往流里写数据 ， 都要进行物理操作"的问题 。也就是说"用缓冲区" 。用flush( )清空缓冲区 。
OutputStream， 以及一个可选的缓冲区大小
本身并不提供接口，只是加了一个缓冲区 。需要链接一个有接口的对象 。
DataInputStream类对象可以读取各种类型的数据 。
DataOutputStream类对象可以写各种类型的数据；
创建这两类对象时 ， 必须使新建立的对象指向构造函数中的参数对象 。例如：
FileInputStream in=new FileInputStream("d:/abc.txt");
DataInputStream din=new DataInputStream(in);
7.2BufferInputStream和bufferOutputStream
允许程序在不降低系统性能的情况下一次一个字节的从流中读取数据 。
BufferInputstream定义了两种构造函数
（1）BufferInputStream b= new BufferInputstream(in);
（2）BufferInputStream b=new BufferInputStream(in,size)
第二个参数表示指定缓冲器的大小 。
同样BufferOutputStream也有两种构造函数 。一次一个字节的向流中写数据 。
7.3printstream
用于写入文本或基本类型
两种构造函数方法：
PrintStream ps=new PrintStream(out);
PrintStream ps=new PrintStream(out, autoflush)
第二个参数为布尔值，控制每次输出换行符时java是否刷新输出流
【输出流java代码范例 java输出流输出文件】输出流java代码范例的介绍就聊到这里吧 ， 感谢你花时间阅读本站内容，更多关于java输出流输出文件、输出流java代码范例的信息别忘了在本站进行查找喔 。

    推荐阅读


    上一篇：如何在荣耀枪神游戏中获取服务器？ 荣耀枪神服务器怎么获得

    下一篇：用云服务器购买火车票究竟有哪些优势？ 怎么用云服务器购买火车票