1 大纲：
一、节点流
1、字节数组 字节 节点流
输入流:ByteArrayInputStream read(byte[] b, int off, int len) + close()
输出流:ByteArrayOutputStream write(byte[] b, int off, int len) +toByteArray() 不要使用多态
二、处理流
1、基本类型+String 保留数据+类型
输入流:DataInputStream readXxx
输出流:DataOutputStream writeXxx
2、引用类型 (对象) 保留数据+类型
反序列化 输入流:ObjectInputStream readObject()
序列化 输出流:ObjectOutputStream writeObject()
注意:
1)、先序列化后反序列化；反序列化顺序必须与序列化一致
2)、不是所有的对象都可以序列化， java.io.Serializable
不是所有的属性都需要序列化，transient
3、打印流 PrintStream println() print()
4、三个常量 : System.in /out/err System.setIn() setOut() setErr()
2 代码
2.1 字节流使用： 用的不多吧，不知道为何设计出这个api来，操作和 fileinputstream fileoutputsteam一样
/**
* 字节数组 节点流
* 数组的长度有限 ，数据量不会很大
*
* 文件内容不用太大
* 1、文件 --程序->字节数组
* 2、字节数组 --程序->文件
*
*
*
* @author Administrator
*
*/
public class ByteArrayDemo01 {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
read(write());
}
/**
* 输出流 操作与文件输出流 有些不同， 有新增方法，不能使用多态
* @throws IOException
*/
public static byte[] write() throws IOException{
//目的地
byte[] dest;
//选择流 不同点
ByteArrayOutputStream bos =new ByteArrayOutputStream();
//操作 写出
String msg ="操作与 文件输入流操作一致";
byte[] info =msg.getBytes();
bos.write(info, 0, info.length);
//获取数据 , 创建一个新分配的 byte 数组
dest =bos.toByteArray();
//释放资源
bos.close();
return dest;
}
/**
* 输入流 操作与 文件输入流操作一致
* 读取字节数组
* @throws IOException
*/
public static void read(byte[] src) throws IOException{
//数据源传入
//选择流
InputStream is =new BufferedInputStream(
new ByteArrayInputStream(
src
)
);
//操作
byte[] flush =new byte[1024];
int len =0;
while(-1!=(len=is.read(flush))){
System.out.println(new String(flush,0,len));
}
//释放资源
is.close();
}
}
/**
*1、文件 --程序->字节数组
*1)、文件输入流
* 字节数组输出流
*
*
* 2、字节数组 --程序->文件
* 1)、字节数组输入流
* 文件输出流
* @author Administrator
*
*/
public class ByteArrayDemo02 {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
byte[] data =getBytesFromFile("e:/xp/test/1.jpg");
toFileFromByteArray(data,"e:/xp/test/arr.jpg");
}
/**
* 2、字节数组 --程序->文件
*/
public static void toFileFromByteArray(byte[] src,String destPath) throws IOException{
//创建源
//目的地
File dest=new File(destPath);
//选择流
//字节数组输入流
InputStream is =new BufferedInputStream(new ByteArrayInputStream(src));
//文件输出流
OutputStream os =new BufferedOutputStream(new FileOutputStream(dest));
//操作 不断读取字节数组
byte[] flush =new byte[1];
int len =0;
while(-1!=(len =is.read(flush))){
//写出到文件中
os.write(flush, 0, len);
}
os.flush();
//释放资源
os.close();
is.close();
}
/**
* 1、文件 --程序->字节数组
* @return
* @throws IOException
*/
public static byte[] getBytesFromFile(String srcPath) throws IOException{
//创建文件源
File src =new File(srcPath);
//创建字节数组目的地
byte[] dest =null;
//选择流
//文件输入流
InputStream is =new BufferedInputStream(new FileInputStream(src));
//字节数组输出流 不能使用多态
ByteArrayOutputStream bos =new ByteArrayOutputStream();
//操作 不断读取文件 写出到字节数组流中
byte[] flush =new byte[1024];
int len =0;
while(-1!=(len =is.read(flush))){
//写出到字节数组流中
bos.write(flush, 0, len);
}
bos.flush();
//获取数据
dest =bos.toByteArray();
bos.close();
is.close();
return dest;
}
}
2.2 DataInputStream DataOutputStream 将数据和类型都写出去
官网解释：
数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据
注意看代码中的注释， 写出去的数据顺序必须要和读取的数据类型顺序保持一致， 这点和
hadoop中 自定义 javabean在跨机器传输时， 写出和写入严格按照顺序一致，我想hadoop在设计的时候就是用javase的这两个类来实现的。
/**
* 数据类型(基本+String)处理流
* 1、输入流 DataInputStream readXxx()
* 2、输出流 DataOutputStream writeXxx()
* 新增方法不能使用多态
*
* java.io.EOFException :没有读取到相关的内容
* @author Administrator
*
*/
public class DataDemo01 {
/**
* @param args
*/
public static void main(String[] args) {
try {
//write("e:/xp/test/data.txt"); // 将字符和字符格式都写到磁盘中，此时双击磁盘文件会是乱码 因为这种文件是给计算机看的 不是给人来看的
read("e:/xp/test/data.txt");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 从文件读取数据+类型
* @throws IOException
*/
public static void read(String destPath) throws IOException{
//创建源
File src =new File(destPath);
//选择流
DataInputStream dis =new DataInputStream(
new BufferedInputStream(
new FileInputStream(src)
)
);
//操作 读取的顺序与写出一致 必须存在才能读取
//不一致，数据存在问题
long num2 =dis.readLong();
double num1 =dis.readDouble();
String str =dis.readUTF();
dis.close();
System.out.println(num2+"-->"+str);
}
/**
* 数据+类型输出到文件 将 数据类型和数据值写到磁盘中
* @throws IOException
*/
public static void write(String destPath) throws IOException{
double point =2.5;
long num=100L;
String str ="数据类型";
//创建源
File dest =new File(destPath);
//选择流 DataOutputStream
DataOutputStream dos =new DataOutputStream(
new BufferedOutputStream(
new FileOutputStream(dest)
)
);
//操作 写出的顺序 为读取准备
dos.writeDouble(point);
dos.writeLong(num);
dos.writeUTF(str);
dos.flush();
//释放资源
dos.close();
}
}
/**
* 数据类型(基本+String)处理流
* 1、输入流 DataInputStream readXxx()
* 2、输出流 DataOutputStream writeXxx()
* 新增方法不能使用多态
*
* java.io.EOFException :没有读取到相关的内容
* @author Administrator
*
*/
public class DataDemo02 {
/**
* @param args
*/
public static void main(String[] args) {
try {
byte[] data=write();
read(data);
System.out.println(data.length);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 从字节数组读取数据+类型
* @throws IOException
*/
public static void read(byte[] src) throws IOException{
//选择流
DataInputStream dis =new DataInputStream(
new BufferedInputStream(
new ByteArrayInputStream(src)
)
);
//操作 读取的顺序与写出一致 必须存在才能读取
double num1 =dis.readDouble();
long num2 =dis.readLong();
String str =dis.readUTF();
dis.close();
System.out.println(num1+"-->"+num2+"-->"+str);
}
/**
* 数据+类型输出到字节数组中
* @throws IOException
*/
public static byte[] write() throws IOException{
//目标数组
byte[] dest =null;
double point =2.5;
long num=100L;
String str ="数据类型";
//选择流 ByteArrayOutputStream DataOutputStream
ByteArrayOutputStream bos =new ByteArrayOutputStream();
DataOutputStream dos =new DataOutputStream(
new BufferedOutputStream(
bos
)
);
//操作 写出的顺序 为读取准备
dos.writeDouble(point);
dos.writeLong(num);
dos.writeUTF(str);
dos.flush();
dest =bos.toByteArray();
//释放资源
dos.close();
return dest;
}
}
2.3 序列化和反序列化 ObjectOutputStream ObjectInputStream
public class Employee implements java.io.Serializable {
//不需要序列化
private transient String name;
private double salary;
public Employee() {
}
public Employee(String name, double salary) {
super();
this.name = name;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
/**
* 不是所有的對象都可以序列化 java.io.NotSerializableException
* 不是所有的屬性都需要序列化 transient
* @author Administrator
*
*/
public class ObjectDemo01 {
/**
* @param args
* @throws ClassNotFoundException
*/
public static void main(String[] args) throws ClassNotFoundException {
try {
seri("e:/xp/test/ser.txt");
read("e:/xp/test/ser.txt");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//反序列化 将计算机世界中的数字影射到人类世界中
public static void read(String destPath) throws IOException, ClassNotFoundException{
//创建源
File src =new File(destPath);
//选择流
ObjectInputStream dis =new ObjectInputStream(
new BufferedInputStream(
new FileInputStream(src)
)
);
//操作 读取的顺序与写出一致 必须存在才能读取
//不一致，数据存在问题
Object obj =dis.readObject();
if(obj instanceof Employee){
Employee emp=(Employee)obj;
System.out.println(emp.getName());
System.out.println(emp.getSalary());
}
obj =dis.readObject();
int[] arr=(int[])obj;
System.out.println(Arrays.toString(arr));
dis.close();
}
//序列化 人类识别的字符写到磁盘中
public static void seri(String destPath) throws IOException{
Employee emp =new Employee("bjsxt",1000000);
int[] arr ={1,2,3,45};
//创建源
File dest =new File(destPath);
//选择流 ObjectOutputStream
ObjectOutputStream dos =new ObjectOutputStream(
new BufferedOutputStream(
new FileOutputStream(dest)
)
);
//操作 写出的顺序 为读取准备
dos.writeObject(emp);
dos.writeObject(arr);
//释放资源
dos.close();
}
}
2.4 打印流： 请仔细阅读注释部分的总结，精华都在这 PrintStream
/**
* PrintStream 打印流 -->处理流 PrintStream 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式
重定向输出 可以用两个方式：
1 ps = new PrintStream(dest) ; ps.print(xxx)
2 System.setOut(PrintStream out) ; System.out.println("a"); 其中System.out System.in System.erro返回的对象都是PrintStream， System.out.println 等同于上面1的 ps.print(xxx)
* @author Administrator
*
*/
public class PrintStreamDemo01 {
/**
* @param args
* @throws FileNotFoundException
*/
public static void main(String[] args) throws FileNotFoundException {
System.out.println("test");
PrintStream ps =System.out; //
ps.println(false);
//输出到文件
File src = new File("e:/xp/test/print.txt");
ps = new PrintStream(new BufferedOutputStream(new FileOutputStream(src))); // 创建新的打印流 将打印的数据输出到目标文件中
ps.println("io is so easy....");
ps.close();
}
}
**
* 三个常量
* 1、System.in 输入流 键盘输入
* 2、System.out 输出流 控制台输出
* System.err
*
* ==>重定向
* setIn()
* setOut()
* setErr()
* FileDescriptor.in 控制台的输入流 可以在System.class中找到
* FileDescriptor.out 控制台的输入流 可以在System.class中找到
* @author Administrator
*
*/
public class SystemDemo01 {
/**
* @param args
* @throws FileNotFoundException
打印流改变输出方式 答应到文件 然后在切换回来打印到控制台
*/
public static void main(String[] args) throws FileNotFoundException {
//test1();
//test2();
//重定向
// 如果为 true，则每当写入 byte 数组、调用其中一个 println 方法或写入换行符或字节 ('\n') 时都会刷新输出缓冲区
System.setOut(new PrintStream(new BufferedOutputStream(new FileOutputStream("e:/xp/test/print.txt")),true));
System.out.println("a"); //控制台 -->文件
System.out.println("test");
//回控制台
System.setOut(new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.out)),true)); // FileDescriptor.in是控制台使用的标准输入流
System.out.println("back....");
}
public static void test2() throws FileNotFoundException{
InputStream is =System.in; //键盘输入
is = new BufferedInputStream(new FileInputStream("e:/xp/test/print.txt"));
Scanner sc = new Scanner(is);
//System.out.println("请输入:");
System.out.println(sc.nextLine());
}
public static void test1(){
System.out.println("test");
System.err.println("err");
}
}
相关推荐
在IT领域，IO流（Input/Output Stream）和XML解析是两个重要的概念，它们在数据处理和信息交换中起着核心作用。 IO流是Java编程语言中的一个关键特性，用于处理程序与外部设备（如硬盘、网络、内存等）之间的数据...
Java中的IO流是Java核心库的重要组成部分，它用于在不同数据源之间传输数据。Java IO流分为两大类：字符流（Character Stream）和字节流（Byte Stream）。字符流处理单个字符，而字节流处理8位的字节序列。它们又...
### JAVA IO流概念及其应用详解 ...通过对以上知识点的学习，我们可以了解到JAVA IO流在处理文件和其他设备上的数据时的强大功能。掌握好这些基本概念和技巧，能够帮助开发者更好地处理各种数据操作需求。
在Java中，IO流被设计为处理任何类型的数据，包括字符、字节甚至对象。本练习旨在帮助初学者理解和掌握Java IO流的基础知识。 一、IO流的概念 IO流在Java中分为两大类：输入流（Input Stream）和输出流（Output ...
在实际开发中，我们通常会结合使用不同的流类型来构建复杂的流处理链，例如使用InputStreamReader包装InputStream，然后用BufferedReader进一步包装，以高效地读取文本数据。同样，输出时可以使用OutputStreamWriter...
这些基本流类是所有其他IO流类的基础。 输入流用于将数据从源（如硬盘、网络、内存等）读取到程序中，输出流则负责将数据从程序写入目的地。Java提供了许多不同的流类来适应各种特定需求，例如FileInputStream和...
字节流是Java IO流中最基本的流类型，可以处理一切类型的数据。字节流可以分为两种：输入流和输出流。 a) 输入流：InputStream InputStream是字节流的输入流，负责从外部世界输入数据到Java应用程序中。常用的...
本文将深入探讨`Map`集合的特性和遍历方式，以及`Set`特性的排序，并介绍如何使用`IO流`，特别是字节流和字符流。 首先，我们来了解`Map`集合的基本概念。`Map`接口是Java集合框架的一部分，它不直接继承自`...
Java中的IO流是Java语言处理输入输出操作的重要组成部分，它为数据传输提供了强大的支持。本文将深入探讨Java的IO流实例应用，旨在帮助开发者更好地理解和掌握这一关键概念。 IO流在Java中分为两大类：字符流...
Java IO流技术是Java平台中用于处理输入输出的重要机制，其核心在于数据的传输，从数据源到程序或从程序到目的地...在实际编程中，根据需求选择适当的流类型，结合处理流进行优化，可以构建出高效、灵活的IO解决方案。
Java IO流是Java编程语言中用于处理输入输出操作的一个重要概念。它允许程序读取数据源或向数据目的地写入数据。Java中的IO流主要分为输入流和输出流两大类，每类又可以根据数据处理方式的不同细分为多种具体实现。...
文件流是指在程序中用于文件输入输出的对象， Java 中提供了多种文件流类型，包括 InputStream 和 OutputStream 两大类。 InputStream 是 Java 中的输入流接口，用于读取文件的内容，常用的 InputStream 子类包括 ...
总的来说，Java IO流是Java程序进行输入输出操作的基础，无论是读取配置文件、处理用户输入、还是与其他系统交换数据，都离不开IO流。通过深入学习和实践，开发者可以有效地管理和控制程序的数据流动，从而实现各种...
`IO流`允许程序读取或写入数据到各种类型的源和目标，如键盘、显示器、文件、网络连接等。本部分的io流详解内容主要涵盖以下几个方面： 1. **流的分类**： - 根据数据传输方向，流可以分为输入流（Input Stream）...
### Java IO流详解 #### 一、Input和Output Stream概览 在Java中，输入输出流（简称IO流）是用来处理文件读写的核心技术之一。它主要包括两类：以字节为导向的流和以字符为导向的流。 ##### 1.1 以字节为导向的流...
字节流是最基本的IO流类型，处理的数据单位是字节，主要类包括InputStream和OutputStream。InputStream代表所有输入字节流的超类，常见的子类有FileInputStream，用于从文件中读取字节。OutputStream则是所有输出...
### Java IO流基础知识点 #### 一、IO流概述 - **定义**：在Java中，IO流（Input/Output Streams）是用来处理输入输出的基本工具。流是一种有序的数据集合，通常涉及从源到目的地的数据传输过程。源可以是文件、...
在Java编程语言中，IO流（Input/Output流）是用来处理数据输入与输出的重要工具。在文本文件的复制过程中，通常会用到三种主要的流类型：字节流（Byte Stream）、字符流（Character Stream）以及缓冲流（Buffered ...
本示例是关于如何使用Java中的IO流进行实际操作的演示，主要包括字节流和字符流的使用。字节流处理的是原始的八位字节数据，而字符流则处理Unicode字符集中的字符。下面我们将深入探讨这两个主要流类型及其应用场景...
在实际编程中，根据需求选择合适的流类型是非常重要的。例如，当你需要读取一个文本文件时，可以选择使用`FileReader`和`BufferedReader`；如果是处理二进制文件，如图片，那么`FileInputStream`和`...