Java输入输出流详细用法

合集下载

java输入输出流实验报告总结

java输入输出流实验报告总结

java输入输出流实验报告总结Java输入输出流是Java中非常重要的概念,也是Java程序设计的基础。

在Java 程序中,输入输出流用于处理与设备之间的数据传输,例如键盘、鼠标、文件等。

Java的输入输出流主要包含两种类型:字节流和字符流。

字节流以字节为最小读写单位,而字符流以字符为最小读写单位。

Java的输入流有很多种类型,例如:InputStream、ByteArrayInputStream、FileInputStream等。

这些输入流的共同特点是读取外部数据到程序中。

Java的输出流也有多种类型,例如:OutputStream、ByteArrayOutputStream、FileOutputStream等。

这些输出流的共同特点是将程序中的数据输出到外部。

下面将以实验报告的形式进行总结,详细介绍Java输入输出流的原理和使用方法。

实验一:字节流输入输出1. 实验目的:掌握字节流输入输出的基本使用方法。

2. 实验内容:编写一个程序,实现从文件中读取数据,然后将数据输出到另一个文件中。

3. 实验步骤:a. 创建一个输入流对象,用于读取原始文件的数据。

b. 创建一个输出流对象,用于将读取到的数据输出到目标文件中。

c. 循环读取输入流中的数据,直到读取到文件末尾。

d. 将读取到的数据写入输出流中。

e. 关闭输入流和输出流。

4. 实验结果:成功读取原始文件中的数据,并将数据输出到目标文件中。

实验二:字符流输入输出1. 实验目的:掌握字符流输入输出的基本使用方法。

2. 实验内容:编写一个程序,实现从键盘输入文字,然后将文字输出到屏幕上。

3. 实验步骤:a. 创建一个字符输入流对象,用于读取键盘输入的文字。

b. 创建一个字符输出流对象,用于将读取到的文字输出到屏幕上。

c. 循环读取输入流中的文字,直到读取到换行符。

d. 将读取到的文字写入输出流中。

e. 关闭输入流和输出流。

4. 实验结果:成功从键盘输入文字,并将文字输出到屏幕上。

java中的输入输出语句

java中的输入输出语句

在Java中,你可以使用System.out来进行标准输出,使用System.in来进行标准输入。

以下是一些基本的输入输出语句示例:1. 标准输出(System.out):public class HelloWorld {public static void main(String[] args) {System.out.println("Hello, World!");}}上述示例中,System.out.println用于将文本输出到控制台。

2. 标准输入(System.in):import java.util.Scanner;public class UserInput {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.print("Enter your name: ");String name = scanner.nextLine();System.out.print("Enter your age: ");int age = scanner.nextInt();System.out.println("Hello, " + name + "! You are " + age + " years old.");}}上述示例中,Scanner类用于从控制台读取用户的输入。

scanner.nextLine()用于读取一行文本,而scanner.nextInt()用于读取整数。

3. 格式化输出(System.out.printf):public class FormatOutput {public static void main(String[] args) {String name = "John";int age = 25;System.out.printf("Hello, %s! You are %d years old.%n", name, age);}}上述示例中,System.out.printf允许你使用格式字符串输出,并在其中插入变量的值。

【Java】字节流-从文件输入,输出到文件

【Java】字节流-从文件输入,输出到文件

【Java】字节流-从⽂件输⼊,输出到⽂件假如需要复制⼀张图⽚,⼀份word,⼀个rar包。

可以以字节流的⽅式,读取⽂件,然后输出到⽬标⽂件夹。

以复制⼀张4M的图⽚举例。

每次读⼀个字节:ch = (char)System.in.read(); //读⼊⼀个字符,返回读到的字节的int表⽰⽅式,读到末尾返回-1复制时候⼀个字节⼀个字节的读取、写⼊,这样是很慢的。

设置⼀个⽤来缓冲的字符数组,会让复制的过程快很多(每次读⼊的字节变多)。

⽅便阅读,类的名称⽤中⽂描述import java.io.*;public class字节流的缓冲区 {public static void main(String[] args) throws Exception {FileInputStream in=new FileInputStream("E:\\photo\\IMG.jpg");//FileOutputStream中的⽂件不存在,将⾃动新建⽂件OutputStream out=new FileOutputStream("E:\\test.jpg");byte[] buff=new byte[1024];int b;long beginTime=System.currentTimeMillis();while ((b=in.read(buff))!=-1) {out.write(buff,0,b);}long endTime=System.currentTimeMillis();System.out.println("运⾏时长为: "+(endTime-beginTime)+"毫秒");in.close();out.close();System.out.println("正常运⾏!");}}这⾥设置的字节数组是1024个字节。

java inputstream用法

java inputstream用法

java inputstream用法在 Java 中,`InputStream` 是一个抽象类,它表示输入流,用于从不同的数据源读取数据。

通过使用 `InputStream`,可以读取文件、网络连接、内存缓冲区等数据源中的数据。

以下是 `InputStream` 的一些常见用法:1. 创建 `InputStream` 对象:可以通过各种方法创建具体的 `InputStream` 对象,例如通过文件路径创建文件输入流,或者通过网络连接创建网络输入流。

2. 读取数据:使用 `read()` 方法从输入流中读取数据。

`read()` 方法返回读取到的字节数,如果到达流的末尾,则返回 -1。

3. 处理数据:根据需要对读取到的数据进行处理,例如将字节转换为字符、解析数据格式等。

4. 关闭输入流:使用完毕后,务必调用 `close()` 方法关闭输入流,释放相关资源。

下面是一个简单的示例,演示如何使用 `InputStream` 读取文件内容:```javaimport java.io.InputStream;import java.io.FileInputStream;public class InputStreamExample {public static void main(String[] args) {// 替换为实际的文件路径String filePath = "path/to/your/file.txt";try (InputStream inputStream = new FileInputStream(filePath)) {// 创建缓冲区byte[] buffer = new byte[1024];int bytesRead;while ((bytesRead = inputStream.read(buffer)) != -1) {// 处理读取到的数据String data = new String(buffer, 0, bytesRead);System.out.println("读取到的数据:" + data);}} catch (Exception e) {e.printStackTrace();}}}```在上述示例中,创建了一个 `FileInputStream` 对象来读取文件,并使用循环逐字节地读取数据。

(JAVA)从零开始之--对象输入输出流ObjectInputStream、ObjectO。。。

(JAVA)从零开始之--对象输入输出流ObjectInputStream、ObjectO。。。

(JAVA)从零开始之--对象输⼊输出流ObjectInputStream、ObjectO。

对象的输⼊输出流 : 主要的作⽤是⽤于写⼊对象信息与读取对象信息。

对象信息⼀旦写到⽂件上那么对象的信息就可以做到持久化了 对象的输出流: ObjectOutputStream 对象的输⼊流: ObjectInputStream使⽤:对象的输出流将指定的对象写⼊到⽂件的过程,就是将对象序列化的过程,对象的输⼊流将指定序列化好的⽂件读出来的过程,就是对象反序列化的过程。

既然对象的输出流将对象写⼊到⽂件中称之为对象的序列化,那么可想⽽知对象所对应的class必须要实现Serializable接⼝。

(查看源码可得知:Serializable接⼝没有任何的⽅法,只是作为⼀个标识接⼝存在)。

1、将User类的对象序列化1class User implements Serializable{//必须实现Serializable接⼝2 String uid;3 String pwd;4public User(String _uid,String _pwd){5this.uid = _uid;6this.pwd = _pwd;7 }8 @Override9public String toString() {10return "账号:"+this.uid+" 密码:"+this.pwd;11 }12 }1314public class Demo1 {1516public static void main(String[] args) throws IOException {17//假设将对象信息写⼊到obj.txt⽂件中,事先已经在硬盘中建⽴了⼀个obj.txt⽂件18 File f = new File("F:\\obj.txt");19 writeObjec(f);20 System.out.println("OK");21 }2223//定义⽅法把对象的信息写到硬盘上------>对象的序列化。

java输入输出语句例子

java输入输出语句例子

java输入输出语句例子Java语言中的输入输出语句是开发者经常使用的重要命令之一。

在本文中,我们将通过几个例子来展示Java中如何使用输入输出语句。

1. 导入Java中的I/O库在使用Java中的输入输出语句之前,我们需要先导入Java中的I/O库。

通过这个库,我们可以轻松地从键盘读取输入、从文件中读取输入和将输出写入文件。

在Java中,我们通常使用java.io包中的类来处理输入输出任务。

为了导入这个包,我们只需要在Java程序的开头添加以下代码:```import java.io.*```2. 使用Java中的输入输出语句一旦我们导入了Java中的I/O库,我们就可以开始使用Java中的输入输出语句了。

以下是几个例子:- 读取键盘输入并将其打印出来```import java.io.*public class InputOutputExample{public static void main(String args[]) throws IOException{BufferedReader inp = new BufferedReader(new InputStreamReader(System.in));System.out.println("Enter your name: ");String name = inp.readLine();System.out.println("Hi " + name + ", nice to meet you!"); }}```在这个例子中,我们创建了一个BufferedReader对象,并使用它来读取来自键盘的输入。

我们使用System.in作为我们的输入源,并使用InputStreamReader将它们从字节流转换为字符流。

最后,我们使用BufferedReader的readLine()方法来读取用户输入。

《java输入输出》课件

《java输入输出》课件
System.out.format
通过格式化字符串将数据输出到控制台。
String.format
将数据格式化字符串并返回格式化结果。
异常处理
1
try -catch语句
通过添加try-catch语句来处理异常。
2
fin ally 语句
无论是否发生异常,finally语句块中的代码都会执行。
3
自定义异常
开发自定义异常来处理特殊情况。
字符输入输出
字符读取
使用Reader类读取字符信息。
字符写入
使用Writer类向文件中写入字符信息,可支持中文。
二进制输入输出
1 输入
使用BufferedInputStream类从二进制文件中读取信息。
2 输出
使用BufferedOutputStream类将信息写入二进制文件中。
格式化输入输出
控制台输出
使用System.out.print来在控制台输出信息。
键盘输入
使用Scanner类从键盘获取用户输入的信息。
文件输入输出
1
文件读取
使用File类和Scanner类从文件中读取信息。
2
文件写入
使用FileWriter类和PrintWriter类信息写入文件中。
3
二进制文件读写
使用InputStream和OutputStream类读写二进制文件。
《java输入输出》PPT课件
本课程将教您如何处理各种输入输出并展示Java编程语言的强大功能。
输入输出概述
输入
从外部读取数据到计算机中,例如键盘输入。
处理
综合输入和输出,对外部数据做出处理。
输出
将数据从计算机输出到外部,例如屏幕输出。

JAva第 6 章 Java的输入输出.ppt

JAva第 6 章 Java的输入输出.ppt
"rwd" 文件可读可写,并且要求每次更改 文件内容时同步写到存储设备中。
2020/8/16
2020/8/16
Java面向对象程序设计教程
9
输入输出类的分类
文件I/O :FileInputStream 内存缓冲区I/O :BufferedInputStream 存取I/O :DataInputStream 管道I/O :PipedInputStream 过滤器I/O :FilterInputStream
2020/8/16
Java面向对象程序设计教程
10
标准流及其重定向
System.out是标准的输出流,默认情况下, 它是一个控制台。
System.in是标准输入流,默认情况下, 它指的是键盘。
System.err指的是标准错误流,它默认是 控制台。
这些流可以重定向到任何兼容的输入/输出 设备。
6.3 数据持久化
• 6.3.1 对象串行化 • 6.3.2 XML文件的输入输出 • 6.3.3 JDBC入门
6.4 文件类的应用
• 6.4.1 File类 • 6.4.2 File类应用举例
2020/8/16
Java面向对象程序设计教程
2
6.1 流输入/输出类的层次结构
流的概念
流(Stream)是有序的数据序列,它有源(输入流)与 目的(输出流)。
举例:RedirectSample.java
2020/8/16
Java面向对象程序设计教程
11
IOException及其子类
在java.io中,每一个特定的I/O错误都是 用异常IOException及其子类来报告的。
最常见的I/O异常有 FileNotFoundException、 EOFException、 InterruptedIOException、 UTFDataFormatError等。

java 标准输入输出流

java  标准输入输出流

java 标准输入输出流
计算机系统都有标准的输入设备和标准输出设备。

对一般系统而言,标准输入设备通常是键盘,而标准输出设备是屏幕。

Java程序经常需要从键盘上输入数据,从屏幕上输出数据,为此频繁创建输入/输出流对象将很不方便。

因此,Java语言事先定义好了两个对象,分别对系统的标准输入和标准输出相联系,如System.in和System.out,另外还定义了标准的System.err错误输出流。

System.in是标准输入流,是InputStream类的实例。

可以使用read()方法从键盘上读取字节,也可以将它包装成数据流读取各种类型的数据和字符串。

在使用System.in的read()方法时,由于read()方法在定义时抛出了IOException 异常,所以必须使用try-catch结构捕获异常或声明抛出异常;
System.out和System.err是标准输出流和标准错误输出流,是PrintStream类的实例。

如果从标准输入流键盘上输入基本数据类型,可以将标准输入流包装成具有缓
执行上述代码,结果如图12-12所示。

图12-12 System.in 标准输入流。

java中inputstream用法

java中inputstream用法

java中inputstream用法Java中的InputStream是一个抽象类,它是所有输入流的父类。

InputStream提供了一些方法来读取字节流,可以从文件、网络、内存等多种数据源中读取数据。

本文将详细介绍Java中InputStream 的用法。

一、InputStream概述1.1 InputStream的作用InputStream用于从各种数据源中读取字节流。

它提供了一些方法来读取字节流,并且可以处理不同类型的数据源,包括文件、网络、内存等。

1.2 InputStream的继承关系InputStream是一个抽象类,它有许多子类,如FileInputStream、ByteArrayInputStream、PipedInputStream等。

1.3 InputStream的常用方法常用方法如下:- int read():从输入流中读取一个字节,并返回该字节的值。

如果已经到达流的末尾,则返回-1。

- int read(byte[] b):从输入流中读取一定量的字节,并将其存储在缓冲区数组b中。

返回实际读取的字节数。

- int read(byte[] b, int off, int len):从输入流中读取最多len个字节,并将其存储在缓冲区数组b中,开始存储位置为off。

返回实际读取的字节数。

- long skip(long n):跳过并丢弃此输入流中n个字节。

- int available():返回此输入流可以不受阻塞地从此输入流中读取(或跳过)的字节数。

- void close():关闭此输入流并释放与该流关联的所有系统资源。

二、InputStream子类2.1 FileInputStreamFileInputStream用于从文件中读取数据。

它继承自InputStream类,可以使用read()方法从文件中读取一个字节,并返回该字节的值。

如果已经到达文件的末尾,则返回-1。

2.2 ByteArrayInputStreamByteArrayInputStream用于从内存中读取数据。

JAVA输入输出流

JAVA输入输出流
三个基本的read方法:
int read() int read(byte[] buffer) int read(byte[] buffer, int offset, int length)
其它方法:
void close() int available() skip(long n) boolean markSupported() void mark(int readlimit) void reset()
9.4常用输入输出流类(2)
FileReader-文件字符输入流
构造方法: public FileReader(String name) throws FileNotFoundException public FileReader(File file) throws FileNotFoundException
方法:参见InputStream FileOutputStream-文件字节输出流
构造方法: public FileOutputStream(String name) throws FileNotFoundException public FileOutputStream(File file) throws FileNotFoundException 方法:参见OutputStream
//标准输出流System.out是字节输出流
//把标准输出流转化成缓冲字节输出流 /用BufferedOutputStream中函数Write输出 //数据从缓冲区中全部输出
import java.io.*; public class Test3 { public static void main(String[] args) throws IOException{ String s = "Hello"; OutputStreamWriter o = new OutputStreamWriter(System.out); o.write(s); 把标准字节输出流转化 成字符输出流 o.flush(); } }

java08(第8章输入输出流)

java08(第8章输入输出流)

在java.io包中定义了很多这二个基本类具体实现 包中定义了很多这二个基本类具体实现 输入输出功能的子类, 输入输出功能的子类,表8.1为部分常用字节输入 为部分常用字节输入 流类和字节输出流子类的功能。 流类和字节输出流子类的功能。
表8.1
类 名 FileInputStream 和 FileOutputStream ByteArrayInputStream和 ByteArrayOutputStream ObjectInputStream 和 ObjectOutputStream FilterInputStream 和 FilterOutputStream DataInputStream 和 DataOutputStream BufferedInputStream 和 BufferedOutputStream
【例8-1 】
1. /* 读取文件 */ 2. import java.io.FileInputStream; 3. import javax.swing.JOptionPane; 4. class Example8_1 5. { public static void main( String args[ ]) 6. { byte buffer[ ] = new byte[2056]; 7. String str; 8. try{ 9. File file=new File("d:/jtest/test.dat"); 10. FileInputStream fileInput = new FileInputStream(file); 11. int bytes = fileInput.read( buffer, 0, 2056 ); //读到的字节数 读到的字节数 12. str = new String( buffer, 0, bytes ); 13. } 14. catch(Exception e) 15. { 16. str= e.toString(); 17. } 18. JOptionPane.showMessageDialog(null,str); 19. System.exit(0); //退出程序 退出程序 20. } 21. }

java中基本输入输出流的解释

java中基本输入输出流的解释

java中基本输入输出流的解释1.网络程序的很大一部分是简单的输入输出,即从一个系统向另一个系统移动字节。

字节就是字节,在很大程度上,读服务器发送的数据与读取文件没什么不同;向客户传送数据与写入一个文件也没有什么区别。

Java中输入和输出组织不同于大多数其他语言。

它是建立在流(stream)上。

不同的基本流类(如java.io.FileInputStream和.TelnetOutputStream)用于读写特定的数据资源。

但是所有的基本输出流使用同一种基本方法读数据。

过滤器流可以连接到输入流或输出流。

它可以修改已经读出或写人的数据(例如,加密或压缩数据),或者可以简单地提供附加方法将已经读出或写入的数据转化成其他格式。

最后Reader和Writer也可以链接到输入流和输出流,从而允许程序读出和写入文本(即字符)而不是字节。

如果使用正确,Reader和Writer能够处理多种类型的字符编码,包括SJIS和UTF-8等多字节字符集。

一、输出流java的基本输出流是 java.io.OutputStream.public abstract class OutputStreamn public abstract void write(int b) throws IOExceptionn public void write(byte[] data) throws IOExceptionn public void write(byte[] data,int offset,int length) throws IOExceptionn public void flush() throws IOExceptionn public void close() throws IOExceptionOutputStream的子类使用这些方法向指定媒体写入数据。

我始终相信,我们理解了为什么它们存在,就会更好地记住它们,好,现在开始说一下OutputStream类的方法的由来public abstract void write(int b) throws IOExceptionOutputStream的基本方法是write(int b)。

java io流详解

java io流详解

java io流详解Java IO流是Java中的一个重要概念,它被用于文件的输入和输出,网络数据传输等方面。

本文将详细介绍Java IO流的使用以及其相关的知识点,让大家能够更好地了解并使用该重要技术。

一、流概述流是Java中非常重要的一个概念。

流实际上是一种在程序和存储设备之间传输信息的方式。

Java中的流是基于输入/输出(I/O)操作的,使用Java IO流,程序就可以从文件或网络中读取信息,也可以将信息写入到文件或网络中。

二、Java IO流分类Java IO流分为两类:字节流和字符流:1. 字节流是以字节(Int流)为单位传输数据,它适合传输二进制文件(如图片、音乐)等数据。

2. 字符流是以字符为单位传输数据,它适合传输文本文件等数据。

字节流又分为输入字节流和输出字节流,字符流又分为输入字符流和输出字符流。

三、Java IO流的基本操作1. 数据的输入:使用Java IO流读取文件的数据,可以使用FileInputStream类。

使用Java io输入流的步骤具体如下:① 创建输入流对象,即FileInputStream类。

② 读取数据,即使用read()方法读取数据。

③ 关闭读取流,即使用close()方法。

2. 数据的输出:使用Java IO流将数据写入到文件中,可以使用FileOutputStream类。

使用Java io输出流的步骤具体如下:① 创建输出流对象,即FileOutputStream类。

② 写入数据,即使用write()方法将数据写入文件中。

③ 关闭输出流,即使用close()方法。

3. 文件的复制:使用Java IO流可以轻松实现文件的复制。

具体操作步骤如下:① 创建输入流对象,即FileInputStream类。

② 创建输出流对象,即FileOutputStream类。

③ 读取数据,即使用read()方法读取数据,并调用write()方法写入到输出流中。

④ 关闭输入流和输出流。

java 输入窗口和输出窗口写法

java 输入窗口和输出窗口写法

一、背景介绍1. Java是一种面向对象的编程语言,广泛应用于企业级应用开发和互联网应用开发领域。

2. 在Java编程中,输入窗口和输出窗口是常用的交互界面,用于接收用户输入和显示程序运行结果。

3. 本文将介绍Java中输入窗口和输出窗口的写法,以及常见的应用场景。

二、输入窗口的写法1. 使用Scanner类来实现输入窗口。

Scanner scanner = new Scanner(System.in);String input = scanner.nextLine();// 读取用户输入并存储到变量input中2. 使用JOptionPane类来实现图形化输入窗口。

String input = JOptionPane.showInputDialog("请输入内容:");// 弹出带有输入框的窗口,等待用户输入,并将用户输入的内容存储到变量input中三、输出窗口的写法1. 使用System.out.println()来实现控制台输出。

System.out.println("Hello, World!");// 在控制台输出字符串"Hello, World!"2. 使用JOptionPane类来实现图形化输出窗口。

JOptionPane.showMessageDialog(null, "Hello, World!"); // 弹出带有消息提示框的窗口,显示字符串"Hello, World!"四、输入窗口和输出窗口的应用场景1. 输入窗口的应用- 用户信息输入:例如登录界面、注册界面等需要用户输入信息的场景。

- 数据采集:例如统计调查、问卷调查等需要用户提供信息的场景。

2. 输出窗口的应用- 程序执行结果展示:用户操作的反馈信息、程序执行的结果展示等应用场景。

- 提示信息显示:警告、错误提示、成功提示等信息的显示。

Java输入输出流(一)——常用的输入输出流

Java输入输出流(一)——常用的输入输出流

Java输⼊输出流(⼀)——常⽤的输⼊输出流1.流的概念:在Java中,流是从源到⽬的地的字节的有序序列。

Java中有两种基本的流——输⼊流(InputStream)和输出流(OutputStream)。

根据流相对于程序的另⼀个端点的不同,分为节点流和过滤流。

(1)节点流:以特定源如磁盘⽂件、内存某区域或者线程之间的管道为端点的构造输⼊输出流,是⼀种基本的流。

(2)过滤流:以其他已经存在的流为端点构造的输⼊输出流。

根据流中的数据单位分为字节流和字符流。

(1)字节流:流中的数据是以8位字节为单位进⾏读写,以InputStream和OutputStream为基础类。

(2)字符流:流中的数据是以16为字符为单位进⾏读写,以Reader和Writer为基础类。

2.字节流InputStream和OutputStream是字节流的两个顶层⽗类,提供了输⼊流类和输出流类的通⽤API。

2.1 输⼊字节流InputStream基本⽅法:(1)基本读⽅法;: int read() int read(byte[] b) int read(byte[] b,int off,int len)(2) 关闭流:void close()(3) 返回输⼊流中还有多少可读字节 int available()(4) 跳过指定字节 long skip(long n)(5) 回读数据 boolean markSupported() void Mark(int readlimt) void reset()2.2 输出字符流OutputStream基本⽅法:(1)基本写⽅法:void write(int c) void write(byte[] b) void write(byte[] b,int off,int len)(2) 关闭流:void close()(3)q强制输出:void flush()3.字符流:Reader和Writer是字符流的顶层⽗类,字符流能够处理Unicode字符集中的所有字符。

详解Java中ByteArray字节数组的输入输出流的用法

详解Java中ByteArray字节数组的输入输出流的用法

详解Java中ByteArray字节数组的输⼊输出流的⽤法ByteArrayInputStream 介绍ByteArrayInputStream 是字节数组输⼊流。

它继承于InputStream。

它包含⼀个内部缓冲区,该缓冲区包含从流中读取的字节;通俗点说,它的内部缓冲区就是⼀个字节数组,⽽ByteArrayInputStream本质就是通过字节数组来实现的。

我们都知道,InputStream通过read()向外提供接⼝,供它们来读取字节数据;⽽ByteArrayInputStream 的内部额外的定义了⼀个计数器,它被⽤来跟踪 read() ⽅法要读取的下⼀个字节。

⽰例代码关于ByteArrayInputStream中API的详细⽤法,参考⽰例代码(ByteArrayInputStreamTest.java):import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;/*** ByteArrayInputStream 测试程序*/public class ByteArrayInputStreamTest {private static final int LEN = 5;// 对应英⽂字母“abcddefghijklmnopqrsttuvwxyz”private static final byte[] ArrayLetters = {0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A};public static void main(String[] args) {String tmp = new String(ArrayLetters);System.out.println("ArrayLetters="+tmp);tesByteArrayInputStream() ;}/*** ByteArrayInputStream的API测试函数*/private static void tesByteArrayInputStream() {// 创建ByteArrayInputStream字节流,内容是ArrayLetters数组ByteArrayInputStream bais = new ByteArrayInputStream(ArrayLetters);// 从字节流中读取5个字节for (int i=0; i<LEN; i++) {// 若能继续读取下⼀个字节,则读取下⼀个字节if (bais.available() >= 0) {// 读取“字节流的下⼀个字节”int tmp = bais.read();System.out.printf("%d : 0x%s\n", i, Integer.toHexString(tmp));}}// 若“该字节流”不⽀持标记功能,则直接退出if (!bais.markSupported()) {System.out.println("make not supported!");return ;}// 标记“字节流中下⼀个被读取的位置”。

java 标准输入输出流 print 和println输出的区别

java 标准输入输出流 print 和println输出的区别

java 标准输入输出流print 和println输出的区别
标准输入输出流
1、System类中的静态对象in,标准输入流in
在程序开始之后它会自动开启,对应至键盘或其他的输入来源
2、System.out:标准的输出对象,System类中的静态对象out,标准输出流out
(1)、提供标注输出流(Stream)输出
标准的输出对象的作用:支持定向输出
(2)、通常对应至显示输出(终端机输出)
(3)、可以将输出重新导向至一个文件
如:在当前文件夹下创建一个out.txt文档。

javademo>out.txt 意思是将demo中的结果输出到out.txt中。

javademo>>out.txt 意思是将demo中的结果追加定向输出到out.txt中。

(及保留之前的输出信息
3、System.err:标准的错误输出对象
注:(1)、System.err不支持定向输出
(2)、标准错误输出流err,直接输出到屏幕,让用户马上知道错误
在java中print 和println输出的区别
打印效果
注意:
print()//System.out.print();
print()//System..out.println();如果没有值,就相当于换行原文地址:/showtopic-2241.aspx。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
String str=in.readLine(); byte b[]=str.getBytes(“ISO-8859-1”);l String str=new String(b); read() 读取一个字节数据
readChar()读取一个字符数据 readByte()读取一个字节 readInt(),readDouble(),readlong(),readShort()等 写文件方法: writeChars(String s) 写一个字符串 writeBytes(String s) 写一个字符串 writeChar(char c)写一个字符 write(byte b[]) 写 b.length 个字节到文件 writeDouble(double v),writeFloat(float f),writeInt(int i)等等 3. 注意: 要用 try{}catch(){} 写入结束后要用 close()关闭 六、 数组流 数组流是以数组作为源,来写入和读取计算机内存的。数组流不对文件进行操作。 1. 字节数组输入流 ByteArrayInputStream 构造方法:
} 6. 文件的创建与删除
Public Boolean createNewFile(); File.delete(); 7. 运行可执行文件 Runtime ec=Runtime.getRuntime(); ec.exec(String command); 例 7-1:ec.exec(“notepad”);打开记事本 例 7-2:打开 QQ 登录界面 Runtime ec=Runtime.getRuntime(); File file=new File(“QQ 绝对路径”,”QQ.exe”); try {
e1.pห้องสมุดไป่ตู้intStackTrace(); } catch (Exception e1) {
e1.printStackTrace(); }
二、 文件字节流 1. 文件字节输入流 FileInputStream
创建: FileInputStream(String name); FileInputStream(File file); 方法: Int read();读出一个字符 Int read(byte[] b);读取到数组 b 中,读出 b.length 的长度,返回实际读取的长度 Int read(byte[] b,int off,int len);读取到数组 b 中,从 off 处开始,读出 len 长度,返回实际 读取的长度
Public Boolean accept(File dir,String name){ Return name.endsWith(“.java”);
} } File files[]=file.listFiles(filter); For(File f:files){
System.out.println(f.getName());
ByteArrayInputStream(byte [] b); ByteArrayInputStream(byte [] b, int off, int len); 数组 b 为输入流的源,从数组 b 里读出数据 方法: Public int read();从源中顺序的读出一个字节 Public int read(byte[]b);从源中读出 b.length 个字节,存放到数组 b 中,若未读出字节, 返回-1 Public int read(byte[]b,int off,int len);从源中读出 len 个字节,存放到数组 b 中,若未读 出字节,返回-1 注意: 要用 try{}catch(){} 写入结束后要用 close()关闭 2. 字节数组输出流 构造方法:
当返回值为-1 时,读取完毕 注意: 要用 try{}catch(){} 读取结束后要用 close()关闭 2. 文件字节输出流 FileOutputStream 创建: FileOutputStream(String name); FileOutputStream(File file); 方法: Public void write(byte b[]); Public void write(byte b[],int off,int len); 注意: 要用 try{}catch(){} 写入结束后要用 close()关闭 三、 文件字符流 1. 文件字符输入流 FileReader 创建: FileReader(String filename); FileReader(File filename); 方法: Int read(); 读出一个字符 Int read(char [] c); 读取到数组 c 中,返回实际读取的字符个数 Int read(char [] c,int off,int len); 读取到数组 c 中,从 off 开始,读取 len 个字符,返回实 际读取的字符个数 注意: 要用 try{}catch(){} 写入结束后要用 close()关闭 2. 文件字符输出流 FileWriter 创建: FileWriter(String filename); FileWriter(File filename); 方法: Void write(int n); 写入一个字符 Void write(char [] c); 写入字符数组 c Void write(char[] c,int off,int len); 将 c 从 off 开始的 len 个字符写入源 注意: 要用 try{}catch(){} 写入结束后要用 close()关闭 四、 缓冲流
ec.exec(f.getAbsolutePath()); } catch (IOException e) {
e.printStackTrace(); } 例 7-4:打开浏览器,且打开设置好的界面 Desktop dp=Desktop.getDesktop(); try {
dp.browse(new .URI("/")); } catch (IOException e1) {
缓冲流称为上层流,它们的源和目的地必须是字符输入流和输出流,把字符输入输出 流成为底层流,java 采用缓存技术将上层流和底层流连接,底层字符输入流首先将数 据读取缓存,BufferedReader 流再从缓存读取数据;BufferedWriter 流将数据写入缓存, 底层字符输出流会不断地将缓存中的数据写入到目的地。用 BufferedWriter 流调用 flush()刷新缓存或调用 close()方法关闭时,即使缓存没有溢出,底层流也会立刻将缓存
输入输出流
一、 File 类 1. File 对象的四种构造方法
File(String filename); File(String directoryPath); File(String directoryPath,String filename); File(File f ,String filename); 2. File 类的属性 public String getName(); public boolean canRead(); public boolean canWrite(); public boolean exits(); public long length(); public String getAbsolutePath();//获取文件的绝对路径 public String getParent();//获取文件的父目录 public boolean isFile(); public boolean isDirectory(); public boolean isHidden(); public long lastModified();//获取文件最后修改的时间(时间是从 1970 年午夜至文件最后 修改时刻的毫秒数) 3. 创建目录(创建文件夹) public boolean mkdir();//创建成功返回 true,否则返回 false 4. 列出目录中的文件 如果 File 对象是一个目录,可以调用下面方法列出该目录下的文件和子目录 Public String [] list(); Public File[] listFiles(); 5. 列出目录中特定类型的文件 Public String [] list(FilenameFilter obj); Public File[] listFiles(FilenameFilter obj); FilenameFilter 是一个接口,该接口有一个方法: Public Boolean accept(File dir,String name); 例: File file=new File(“路径”); FilenameFilter filter=new FilenameFilter(){
的内容写入目的地。 1. 缓冲输入流 BufferedReader
创建: BufferedReader(Reader in);由于 FileReader 是 Reader 的子类,所以常用下面的方法 BufferedReader(FileReader in); 方法: String readLine(); 读出一行字符,返回一个字符串,读取完毕返回 Null Int read(); 读出一个字符,读取完毕返回-1 Int read(char [] c); 读取到数组 c 中,返回实际读取的字符个数, 读取完毕返回-1 Int read(char [] c,int off,int len); 读取到数组 c 中,从 off 开始,读取 len 个字符,返回 实际读取的字符个数, 读取完毕返回-1 注意: 要用 try{}catch(){} 写入结束后要用 close()关闭,先关闭 FileReader,在关闭 BufferedReader 2. 缓冲输出流 BufferedWriter 创建: BufferedWriter(Writer out); 由于 FileWriter 是 Writer 的子类,所以常用下面的方法 BufferedWriter(FileWriter out); 方法: Void newline(); 写入一个回车符 Void write(int n); 写入一个字符 Void write(char [] c); 写入字符数组 c Void write(char[] c,int off,int len); 将 c 从 off 开始的 len 个字符写入源 注意: 要用 try{}catch(){} 写入结束后要用 close()关闭,先关闭 BufferedWriter,再关闭 FileWriter 五、 随机流 1. RandomAccessFile 类的两个构造方法: RandomAccessFile(String name,String mode); RandomAccessFile(File file,String mode); RandomAccessFile 类既可以读取文件,也可以写入数据到文件,mode 取 r(只读)或 rw(可读写),决定创建的流对文件的访问权限 2. 方法: 定位读写位置方法: seek(long a) 定位 RandomAccessFile 流的读写位置 getFilePointer() 获取流的当前读写位置 length() 获取文件长度 读文件方法: readLine() 从文件读取一行文本,但如果有中文会出现乱码,需要先用 ISO-8859-1 重 新编码,例:
相关文档
最新文档