Java IO (三) 之 常用节点流及练习1

最新推荐文章于 2021-03-02 06:11:55 发布
最新推荐文章于 2021-03-02 06:11:55 发布
阅读量254 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43952245/article/details/90065426
版权

文章目录

数据源

定义：提供原始数据的媒介（也就是存放数据的地方)。可以是数据库、内存、程序、文件以及网络连接和IO设备

注：一切以程序为中心。文件–>程序（输入流）；程序–>文件（输出流）

下面是关于Java输入流和输出流的常用实现类，也是我接下介绍IO主要内容，可以在这里大致扫一眼，混个眼熟就行啦！因为这也不是一下子就能记住的，等你看完下面几个章节的内容相信就可以将下面的图记个差不多啦

流的分类

  1. 按流向分类：

      输入流：数据源到程序（InputStream、Reader）读进来
  输出流：程序到目的地（OutStream、Writer）写出去

  2. 按功能分类：（是否直接操作数据源）

      节点流：可以直接从数据源或目的地中读写数据
  处理流（包装流）：不直接连接到数据源和目的地，是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。

    注：节点流是处于io操作的第一站，所有操作必须通过他来进行。

  3. 按照数据分类

  •   字节流：按照字节读取数据（InputStream、OutputStream）
  字符流：按照字符读取数据（Reader、Writer)
    注：操作字符：即我们可以看懂的纯文本，汉语、英语。由于要让计算机认识，所以字符流的底层还是基于字节流的操作（自动的在码表中进行转换）。

IO节点流

  1. 字节流：按照字节读取数据（音频、视频、word、excel）inputStream、outputStream
  2. 字符流：按照字符读取数据（处理的数据为文本，字符时）Reader、Writer

注：能使用字符流的地方一定可以使用字节流处理，但是可以使用字节流的地方不一定可以使用字符流来处理。

要知道的：

  1. 在计算机里面的文件是存储在硬盘上，Java虽然需要和文件打交道，但是它是不可以直接对硬盘进行操作，而是通过虚拟机和我们的操作系统进行交互(向操作系统进行申请)，所以File代表的是Java和文件的一种联系.。
  2. java虚拟机无权调用垃圾回收机制，只能通知操作系统可以释放资源了

四大抽象类

即：InputStream、OutputStream、Reader、Writer（心细的你可能会发现他们是上图中介绍的节点流中的当源头为文件时的主要内容。）

这四个类属于抽象流类，不能在程序中直接实例化使用，可以使用其派生的类。

IO读取文件的标准步骤

  1. 创建源（选择要搬家的房子）
  2. 选择流（选择搬家公司）
  3. 具体操作（选择搬家方式）
  4. 释放资源（打发搬家公司走人）

文件、java程序和IO流之间的关系如下：(此过程灰常之重要，要理解记忆)


1. InputStream：字节输入流的父类，数据单位为字节

//从输入流读取数据的下一个字节。  
abstract int read() 
//从输入流读取一些字节数，并将它们存储到缓冲区 b 。(返回的读取的字节数) 
int read(byte[] b) 
//关闭此输入流并释放与流相关联的任何系统资源。  
void close()

2. OutputStream：字节输出流的父类，数据单位为字节

注：在我们操作IO的时候内部会有一个类似于缓冲器，当这个缓冲器达到一定数值才会将里面的数据缓冲出去，如果没有达到指定数值，则缓冲器里面的数据则会驻留在内存中；此时为了避免数据能够缓冲出去，需要强制刷新flush或者关闭资源也会强制刷新。

//写入字符数组的一部分。  
void write(char[] cbuf, int off, int len) 
//写一个字符  
void write(int c) 
//写一个字符串的一部分。  
void write(String str, int off, int len) 
//刷新流。    
void flush()
//关闭流，先刷新。  
void close()

3. Reader：字符输入流的父类，数据单位为字符

//读一个字符 
int read() 
//将字符读入数组。  
int read(char[] cbuf) 
//关闭流并释放与之相关联的任何系统资源。  
abstract void close()

4. Writer：字符输出流的父类，数据单位为字符

//写入一个字符数组。  
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) 
//刷新流。 
abstract void flush() 
//关闭流，先刷新。 
abstract void close()

相关方法详解

你要知道的：在Java7中，InputStream被定义为一个抽象类，相应的，该类下的read()方法也是一个抽象方法，这也就意味着必须有一个类继承InputStream并且实现这个read方法。 可以看出下面在这三个方法中，只有参数列表为空的read方法定义为抽象方法，这也就意味着在直接继承自InputStream的所有子类中，必须重写这个方法.

//从输入流读取数据的下一个字节。  
abstract int read() 
//从输入流读取一些字节数，并将它们存储到缓冲区 b 。  
int read(byte[] b) 
//从输入流读取最多len字节的数据到一个字节数组。  
int read(byte[] b, int off, int len)

1.常用方法 read()

/**
*方法详解:
* (1)从输入流读取数据的下一个字节。 值字节被返回作为int范围0至255 。
* (2)如果没有字节可用，因为已经到达流的末尾，则返回值-1 ;该方法阻塞直到输入数据可用，检测到流的结尾，或抛* *    出异常。 
* (3)一个子类必须提供这个方法的一个实现。
* (4)返回的结果：数据的下一个字节，如果达到流的末尾， -1 。
*/
public abstract int read()throws IOException

通俗大白话版本：

注1：这个方法的返回值是int类型.

注2：这个方法每次从数据源中读取一个byte并返回

要知道的：一个byte表示8个二进制位，那么这8个二进制位就是一个0-255之间的十进制数字，实际上在Java中，byte就是一个0-255之间的整数，而将从文件中读取的二进制转化成十进制这一过程是由read()方法完成的。 也就是说，read()这个方法完成的事情就是从数据源中读取8个二进制位，并将这8个0或1转换成十进制的整数，然后将其返回。
2.常用方法 read(byte[] b)

/*
* (1)从输入流读取一些字节数，并将它们存储到缓冲区b 。 实际读取的字节数作为整数返回。（返回值为23则说明读取*  了23个字节） 
* (2)该方法阻塞直到输入数据可用，检测到文件结束或抛出异常。 
* (3)如果b的长度为零，则不会读取字节并返回0 ; 否则，尝试读取至少一个字节。 如果没有字节可用，因为流在文件  *    末尾，则返回值-1 ; 否则，读取至少一个字节并存储到b 。 
*
* 第一个字节读取存储在元素b[0] ，下一个字节存入b[1]等等。 读取的字节数最多等于b的长度。 令k为实际读取的字* 节数; 这些字节将存储在元素b[0]至b[ k -1] ，使元素b[ k ]至b[b.length-1]不受影响。 
* 该read(b)用于类方法InputStream具有相同的效果为： 
*	方法1：read(b, 0, b.length)  
*   方法2：read(b,0,k)
*/
public int read(byte[] b)
         throws IOException

通俗大白话版本

注1：这个方法使用一个byte的数组作为一个缓冲区，每次从数据源中读取和缓冲区大小（二进制位）相同的数据并将其存在缓冲区中。读取的字节数最多等于数组的个数当然byte数组中存放的仍然是0-255的整数，(将二进制转换为十进制这个过程仍然是read方法实现的。 )

注2：虽然我们可以指定缓冲区的大小，但是read方法在读取数据的时候仍然是按照字节来读取的。在utf-8等变长编码中，一个复杂字符（比如汉字）所占字节往往大于1，并且长度往往是不固定的。（参照UTF-8编码规则）按照字节读取数据会将字符割裂，这就导致我们在使用read(byte[] b)方法读取文件时，虽然指定了缓冲区的大小，但是仍然会出现乱码。

下面的“标尺，小车”是为了方便记忆所给的描述，感觉啰嗦的话可以忽略

实战1：字节数据的读取（FileInputStream）
//标准版
/**
 * 1.创建源
 * 2.选择流（字节输入流:InputStream）
 * 3.操作（读数据）
 * 4.关闭资源
 * @描述：按照每个字节的进行读取（标准版）
 * 操作工具：标尺
 */
public class IoTest02 {
	public static void main(String[] args) {
		//1.创建源
		File file = new File("E:/Java workspace/gui_gu/src2/com/sxt/IO/test.txt");
		//2.选择流（文件字节输入流）
		InputStream in = null;
		try {
			in = new FileInputStream(file);
			//3.操作（读取数据）
			int temp;//标尺：操作之前需要判断源文件是否有字节可读
			try {
				while((temp = in.read())!=-1){
					System.out.println((char)temp);
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}finally{
			//4.关闭资源
			try {
				if(in != null){
					in.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
	}
}

实战练习2：按照指定字节数组的形式进行数据的读取

/**
 * 1.创建源
 * 2.选择流（字节输入流：InputStream）
 * 3.操作（读取数据）
 * 4.关闭
 * @描述：将数据按照字节数组的形式进行读取（升级版推荐使用）
 * 操作工具：小车(byte[])、标尺
 */
public class IoTest03 {
	public static void main(String[] args) {
		//1.创建源
		File file = new File("E:/Java workspace/gui_gu/src2/com/sxt/IO/test.txt");
		//2.选择流（文件字节输入流）
		InputStream in = null;
		try {
			in = new FileInputStream(file);
			//3.操作（读取数据）
			//3.1缓冲容器（以指定字节数的形式存放进去）（准备小车和标尺）
			byte[] flush = new byte[3];//小车：将读取的数据存放在这里面
			int len = -1;//标尺：用来判断是否还有数据可读
			try {
                //3.2开始读取数据并装进刚才准备好的小车中（flush字节数组）
				while((len = in.read(flush)) != -1){
					//字节数组-->字符串（解码）（将小车中的数据进行包装并显示）
					String str = new String(flush,0,len);
					System.out.println(str);
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}finally{
			if(in != null){
				try {
                    //4.关闭
					in.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

FileInputStream

定义：通过字节的方式读取文件，可以读取任意类型的文件。（图片、视频等）；如果是全字符读取可以考虑FileReader

FileOutputStream

定义：通过字节的方式写出或追加数据到文件，适合所有类型的文件（图片、视频等）；如果是全字符可以考虑FileWriter

实战练习3：通过字节的方式写出或追加数据到文件

/**
 * 1、创建源
 * 2、选择流（字节输出流：OutputStream）
 * 3、操作（写出）
 * 4、关闭
 * @描述：以字节的方式写出数据到文件
 *  操作工具：小车(byte[])、要写出的数据
 */
public class OutTest {
	public static void main(String[] args) {
		//1、创建源（如果源文件不存在则会自动创建）
		File dest = new File("destination.txt");
		OutputStream out = null;
		try {
			//2、选择流（文件字节输出流）
			//out = new FileOutputStream(dest,true);追加写入
			out = new FileOutputStream(dest);
			//3.操作（写出）
            //3.1准备要写出的数据，并放进一个字节数组中
			String str = "Believes Yourself!";//准备数据
			byte[] b = str.getBytes();//将数据放进小车中
			try {
                 //3.2:开始写出输入（将装满数据的小车写出）
				out.write(b);
				//3.3为了防止数据驻留在内存，每次写出后可以flash一下哦
				out.flush();
			} catch (IOException e) {
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}finally{
			//关闭
			if(out != null){
				try {
					out.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		
		
	}
}
实战1_3：字节数据的拷贝
package com.sxt.IO;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class Copy {

	/**
	 * 1、创建数据源头和目的源
	 * 2、选择流：字节输入流和输出流（InputStream、OutputStream）
	 * 3、操作：读取操作和写出操作
	 * 4、关闭：先打开的后关闭
	 * 操作工具：小车（byte[]）、标尺
	 *@描述：通过文件输入流和文件输出流完成文件的复制操作
	 * @param args
	 */
	public static void main(String[] args) {
		File src = new File("src.txt");
		File des = new File("des.txt");
		copy(src,des);
	}
	public static void copy(File src,File des){
		//2.1、选择输入流
		InputStream in = null;
		OutputStream out = null;
		try {
			in = new FileInputStream(src);
		} catch (FileNotFoundException e1) {
			
			e1.printStackTrace();
		}
		try {
			//2.2、选择输出流
			out = new FileOutputStream(des);
			//3.1、文件的读取操作（准备小车和标尺）
			int tem;//标尺：判断是否还有可读的数据
			byte[] flush = new byte[1024];//小车：用来存放读取的数据
			try {
                //3.2、文件的读取操作（将数据进行读取操作并放进小车中）
				while((tem = in.read(flush))!=-1){
					//3.3、文件的写出操作（将装满数据从小车进行写出操作）
					out.write(flush,0,tem);
					out.flush();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}finally{
			if(out != null){
				try {
					//4.1、关闭资源
					in.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(in != null){
				try {
					//4.2、关闭资源
					in.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}
实战2： 字符数据的读取FileReader
package com.sxt.IO;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;

/**
 * 1.创建源
 * 2.选择流(字符输入流：Reader)
 * 3.操作
 * 4.释放
 * @描述：通过字符输入流来完成数据的读取
 * 操作工具；标尺、小车(char[])
 */
public class ReaderTest {
	public static void main(String[] args) {
		//1.创建源
		File file = new File("hello.txt");
		//2.选择流
		Reader reader = null;
		try {
			reader = new FileReader(file);
			//3.读取数据（操作）:当读取的数据不存在时返回-1
			int len;//标尺
			char[] flush = new char[1024];//小车
			while((len = reader.read(flush))!=-1){
				//字符数组-->字符串（打包整理）
				String str = new String(flush,0,len);
				System.out.println(str);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			//4.关闭资源
			try {
				if(reader != null){
					reader.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

实战练习6：通过使用字符输出流里来进行数据的写出

package com.sxt.IO;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

/**
 * 1.准备源
 * 2.选择流(字符输出流：Writer）
 * 3.写出操作
 * 4.关闭
 * @描述：通过字符输出流完成数据的写出
 * 操作工具：小车(char[])、要写出的数据
 */
public class WriterTest {
	public static void main(String[] args) {
		//1.准备源
		File des = new File("des.txt");
		//2.选择字符输出流
		Writer writer = null;
		try {
			 writer = new FileWriter(des);
		} catch (IOException e) {
			e.printStackTrace();
		}
		//3.读取操作
		//3.1准备要写出的数据
		String data = "我能行！加油！";
		//3.2准备小车
		char[] flush = new char[1024];
		//3.3将数据放进小车中
		flush = data.toCharArray();
		try {
			//3.3读取操作
			writer.write(flush);
			//3.4flush操作
			writer.flush();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(writer != null){
				try {
					writer.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}		
	}
}
实战2_1：字符数据的写出FileWriter
package com.sxt.IO;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;

/**
 * 1.创建源
 * 2.选择流(字符输出流)
 * 3.操作
 * 4.释放
 * @描述：按照每个字节的进行读取
 * 和字节输出流的差别：选择流的不同、小车的类型不同
 */
public class ReaderTest {
	public static void main(String[] args) {
		//创建源
		File file = new File("hello.txt");
		//选择流
		Reader reader = null;
		try {
			reader = new FileReader(file);
			//读取数据（操作）:当读取的数据不存在时返回-1
			int len;
			char[] flush = new char[1024];
			while((len = reader.read(flush))!=-1){
				//字符数组-->字符串
				String str = new String(flush,0,len);
				System.out.println(str);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			//关闭资源
			try {
				if(reader != null){
					reader.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}
实战2-2:字符数据的拷贝
package com.sxt.IO;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

/**
 * 1.准备源（数据源和目的源）
 * 2.选择流（字符输入流和字符输出流：Reader、Writer）
 * 3.操作
 * 4.关闭（先打开的后关闭）
 * @描述：通过字符输出流和字符输入流来完成文件的复制
 * 操作工具：小车(char[])、标尺
 */
public class Copy_read_writer {
	public static void main(String[] args) {
		//1.准备源
		File src = new File("src.txt");
		File des = new File("des.txt");
		//2.选择流
		Reader reader = null;
		Writer writer = null;
		try {
			 reader = new FileReader(src);
			 writer = new FileWriter(des);
		//3.操作
			//3.1准备小车
			char[] flush = new char[1024];
			//3.2准备标尺
			int len;
			//3.3读取数据并装进小车
			while((len = reader.read(flush))!= -1){
				//3.4将装满数据的小车进行写出操作
				writer.write(flush);
				//3.4flush操作
				writer.flush();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			//4.关闭
			if(writer != null){
				try {
					writer.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(reader !=  null){
				try {
					reader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		
		
	}
}
实战总结
  1. 以上处理的流都有一个共同特点：即源头都是文件（FileInputStream、FileOutputStream）
  2. 源头处于硬盘上，而JVM是无法直接访问硬盘上的资源，必须借助操作系统；因此操作完成后要释放资源
Lomon6
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java IO详解（五)------包装流
06-19 291
File 类的介绍：http://www.cnblogs.com/ysocean/p/6851878.html Java IO 流的分类介绍：http://www.cnblogs.com/ysocean/p/6854098.html Java IO 字节输入输出流：http://www.cnblogs.com/ysocean/p/6854541.html Java IO 字符输入输出流：https://i.cnblogs.com/EditPosts.aspx?postid=6859242 　　.
java学习笔记97--字节流中的常用节点流
onepiece_loves的博客
03-25 273
注:java中常用的io流都在java.io包中 1)InputStream //从输入流中读取数据的下一个字节 //如果到达流的末尾则返回 -1 public abstract int read(); //把读到的字节存到字节数组b中,并返回本次读到了多少个字节 public int read(byte[] ...
java中常用的节点流与处理流
如风
10-13 814
public static void main(String[] args) { //一、JAVA常用的节点流： //------1.文件流 （文件输入流：FileInputStream 文件输出流：FileOutputStrean ） File inpfile=new File("D:\\test\\1122.png"); File out...
[Java] 各种流的分类及区别
weixin_30917213的博客
02-22 881
流在Java中是指计算中流动的缓冲区。 从外部设备流向中央处理器的数据流成为“输入流”，反之成为“输出流”。 字符流和字节流的主要区别： 1.字节流读取的时候，读到一个字节就返回一个字节；字符流使用了字节流读到一个或多个字节（中文对应的字节数是两个，在UTF-8码表中是3个字节）时。先去查指定的编码表，将查到的字符返回。 2.字节流可以处理所有类型数据，如：图片，MP3，...
Java IO流经典练习题详解
HY845638534的博客
02-20 7262
                                       Java IO流经典练习题 转载于：https://blog.csdn.net/wenzhi20102321/article/details/52582705 博主对转载的原代码进行了调试，改了一些小问题后，亲测可用。   本文对javaIO流的13道经典的练习题做解答，里面有详细的思路解析，做题时最好养成先写思...
java web学习笔记
山海可平的博客
12-18 280
创建java web项目 idea+tomcat7 新建web项目 目录结构如下 配置tomcat 运行，并通过浏览器访问 Servlet 什么是servlet servlet 是java web 开发的基石，它是运行在servlet容器中（tomcat）中，负责与客户端进行通信。 servlet功能： 创建 并返回基于客户端请求的动态html页面。 与数据库进行通信 Servlet 使用 Servlet本身是一组接口，自定义一个类，实现servlet接口，这个类就具备了接收客户端请求
Java核心基础编程精讲-IO流
06-21
1. **File类**：File类是Java中的一个核心类，位于java.io包下，用于文件和目录的操作。通过File类，你可以创建、删除、重命名文件和目录，获取文件的基本属性如大小、最后修改时间等。File类还提供了判断文件是否...
Java-IO流基础例题 & 例题源码 & PPT教学文档（黑马程序员详细版）.rar
07-24
Java IO流还分为节点流和处理流，节点流直接连接到数据源或目的地，如FileInputStream和FileOutputStream；处理流则建立在其他流之上，用于增强或改变原有流的功能，如BufferedReader和PrintWriter。 二、Java IO流...
JAVA IO流的讲解资源
01-05
Java中的流还可以按照方向分为输入流（Input Stream）和输出流（Output Stream），按照数据单位分为字节流（Byte Stream）和字符流（Char Stream），按照功能分为节点流（直接连接到数据源或目的地）和处理流（在...
彻底明白java的io系统
05-30
Java的IO系统是Java编程中的核心部分，它允许程序与外部世界进行数据交换，包括读取文件、写入文件、网络通信以及设备交互等。理解并掌握Java的IO系统对于任何Java开发者，尤其是新手，都是至关重要的。在这个实例...
Percolation:Coursera 算法课第 1 周练习
06-25
例如，可能会使用ArrayList、HashSet或其他集合类来表示图的节点和边，以及利用Java的IO库读取输入和输出结果。 在这个编程作业中，你需要实现一个渗滤系统，能够接受用户输入的网格大小和一系列渗透操作，然后判断...
本java类能将jpg图片文件
liheqian_0083
04-22 129
package com.binghe.pub.util; import java.io.*;import com.sun.image.codec.jpeg.*;import java.awt.image.*;import java.awt.*;import java.applet.*; //缩略图类， //本java类能将jpg图片文件，进行等比或非等比的大小转换。 //具体使用方法 //s_pi...
java IO经典练习题
chenjiandatyy的博客
12-14 5375
Java IO流经典练习题   本文对javaIO流的13道经典的练习题做解答，里面有详细的思路解析，做题时最好养成先写思路在编程的习惯。   一．练习的题目 （一） 在电脑D盘下创建一个文件为HelloWorld.txt文件，判断他是文件还是目录，在创建一个目 录IOTest,之后将HelloWorld.txt移动到IOTest目录下去；之后遍历IOTest这
JAVA IO操作总结：节点流和处理流
郭滋滋儿
01-01 584
JAVA IO操作总结——节点流和处理流
java 发送附件1是文件，附件2是图片，内容含有图片的邮件
qingcyb的博客
11-11 614
QQ交流群：808973145 package com.common; import java.io.File; import java.util.Properties; import javax.activation.DataHandler; import javax.activation.DataSource; import javax.activation.FileDataSource;...
JAVA：IO流 之 节点流与处理流
黑白灰的博客
06-18 763
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/jingzi123456789/article/details/72123937 流的分类 按数据流的方向不同：输入流，输出流。 按处理数据单位不同：字节流，字符流。 （1） 字节流：数据流中最小的数据单元是字节。 （2）字符流：数据流中最小的数据单元是字符， Java中的字符是Unicode编码，...
输入输出流-缓冲流,过滤流,包装流
wyp164的专栏
06-13 4211
输入输出流-缓冲流,过滤流,包装流JAVA中的IO分类可以分为输入/输出流，还可以分为字节流和字符流，还可以分为基础流和过滤流，可以根据自己的需要使用。一般的应用使用过滤流（实际上是功能增强的流）的时候比较多应用程序对不同的外部设备操作所使用的流类的对象是不同的。针对不同外部设备操作所使用的流的过程中全部都是：InputStream ，Reader， OutputStream， Wri
Java下列属于节点流的是_JAVA：IO流 之 节点流与处理流（2）
weixin_39767887的博客
03-02 763
1. 流的分类按数据流的方向不同：输入流，输出流。按处理数据单位不同：字节流，字符流。(1) 字节流：数据流中最小的数据单元是字节。(2)字符流：数据流中最小的数据单元是字符， Java中的字符是Unicode编码，一个字符占用两个字节。按功能不同：节点流，处理流。(1)程序用于直接操作目标设备所对应的类叫节点流。(2)程序通过一个间接流类去调用节点流类，以达到更加灵活方便地读写各种类型的数据，这...
java io类详解_Java IO详解一（流及其类的关系）
weixin_32563347的博客
02-26 214
1.什么是流？流是一组有顺序，有起点、终点点的字节集合，其本质是数据传输，根据数据传输特性将其抽象为各种类方便数据操作。2.流的类结构3.流的分类流分为字节流与字符流，输入流与输出流字节流与字符流字节流：字节流一次能读入或读出8位二进制字符流：字符流一次能读入或读出16位二进制字节流能处理一切数据类型，字符流只能处理字符类型的数据4.输入流与输出流输入流只能进行读操作，输出流只能进行写操作5.In...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值