写出inputstream和outputstream的常用方法
转换流:指定编码读取文本文件InputStreamReader和写出文本文件OutputS。。。
转换流:指定编码读取⽂本⽂件InputStreamReader和写出⽂本⽂件OutputS。
⼀、字符编码和字符集1、字符编码计算机中储存的信息都是⽤⼆进制数表⽰的,⽽我们在屏幕上看到的数字、英⽂、标点符号、汉字等字符是⼆进制数转换之后的结果。
按照某种规则,将字符存储到计算机中,称为编码。
反之,将存储在计算机中的⼆进制数按照某种规则解析显⽰出来,称为解码。
如说,按照A规则存储,同样按照A规则解析,那么就能显⽰正确的⽂本f符号。
反之,按照A规则存储,再按照B规则解析,就会导致乱码现象。
字符编码 Character Encoding : 就是⼀套⾃然语⾔的字符与⼆进制数之间的对应规则。
在计算机中,所有的数据在存储和运算时都要使⽤⼆进制数表⽰(因为计算机⽤⾼电平和低电平分别表⽰1和0),例如,像a、b、c、d这样的52个字母(包括⼤写)以及0、1等数字还有⼀些常⽤的符号(例如*、#、@等)在计算机中存储时也要使⽤⼆进制数来表⽰,⽽具体⽤哪些⼆进制数字表⽰哪个符号,当然每个⼈都可以约定⾃⼰的⼀套(这就叫编码),⽽⼤家如果要想互相通信⽽不造成混乱,那么⼤家就必须使⽤相同的编码规则,于是美国有关的标准化组织就出台了ASCII编码,统⼀规定了上述常⽤符号⽤哪些⼆进制数来表⽰。
2、字符集字符集 Charset :也叫编码表。
是⼀个系统⽀持的所有字符的集合,包括各国家⽂字、标点符号、图形符号、数字等。
计算机要准确的存储和识别各种字符集符号,需要进⾏字符编码,⼀套字符集必然⾄少有⼀套字符编码。
常见字符集有ASCII字符集、GBK 字符集、Unicode字符集等。
可见,当指定了编码,它所对应的字符集⾃然就指定了,所以编码才是我们最终要关⼼的。
1)、ASCII字符集ASCII(American Standard Code for Information Interchange,美国信息交换标准代码)是基于拉丁字母的⼀套电脑编码系统,⽤于显⽰现代英语,主要包括控制字符(回车键、退格、换⾏键等)和可显⽰字符(英⽂⼤⼩写字符、阿拉伯数字和西⽂符号)。
ioutils常用方法
ioutils常用方法ioutils是Java编程语言中的一个类,它提供了一些常用的方法来处理输入和输出操作。
在本文中,我们将介绍一些ioutils常用方法,并详细说明它们的功能和用法。
1. readBytes方法readBytes方法用于从输入流中读取字节数据,并将其存储在字节数组中。
该方法的语法如下:```javapublic static byte[] readBytes(InputStream input) throws IOException```使用该方法时,我们需要传入一个输入流对象作为参数,并且需要处理可能抛出的IOException异常。
该方法将返回一个字节数组,其中包含从输入流中读取的数据。
2. write方法write方法用于将字节数组中的数据写入到输出流中。
该方法的语法如下:```javapublic static void write(byte[] data, OutputStream output) throws IOException```使用该方法时,我们需要传入一个字节数组和一个输出流对象作为参数,并且需要处理可能抛出的IOException异常。
该方法将把字节数组中的数据写入到输出流中。
3. copy方法copy方法用于将输入流中的数据复制到输出流中。
该方法的语法如下:```javapublic static long copy(InputStream input, OutputStream output) throws IOException```使用该方法时,我们需要传入一个输入流对象和一个输出流对象作为参数,并且需要处理可能抛出的IOException异常。
该方法将返回复制的字节数。
4. closeQuietly方法closeQuietly方法用于关闭输入流或输出流,而无需显式地处理可能抛出的IOException异常。
该方法的语法如下:```javapublic static void closeQuietly(Closeable closeable)```使用该方法时,我们只需要传入一个可关闭的对象作为参数,该方法将自动关闭该对象。
IO1
I/O流概述 流概述
流是一个很形象的概念。
流提供一条通道程序, I/O 流提供一条通道程序,可以使用这条通道把源中的字节 序列送给目的地。 序列送给目的地。
I/O流概述 流概述
为进行数据的输入/输出操作,Java中把不同的输入/输出源(键 盘、文件、网络连接等)抽象表述为“流”(stream)。 数据流(Stream):是一组有顺序的、有起点和终点的字节集 合,是对输入和输出的总称和抽象。 java.io包中定义了多个流类型(类或抽象类)来实现输入/输出功能 。 按照流的方向划分, 两种基本的流
接下来看read()方法,使用read()方法读取一个文件,并把内容打印出来。
int read()
private void fun5() { try { File f = new File("c:/1.txt"); long length =f.length(); int length2 = (int)length; FileInputStream fis = new FileInputStream("c:/1.txt"); byte[] buf = new byte[length2]; for (int i = 0; i < buf.length; i++) { buf[i] = (byte)fis.read() ; } String str = new String(buf); System.out.println(str); //不会再打印很多空格 fis.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }
JavaIO流详解(三)----字节流InputStream和OutPutStream
JavaIO流详解(三)----字节流InputStream和OutPutStream我们都知道在计算机中,⽆论是⽂本、图⽚、⾳频还是视频,所有的⽂件都是以⼆进制(字节)形式存在的,IO流中针对字节的输⼊输出提供了⼀系列的流,统称为字节流。
字节流是程序中最常⽤的流。
在JDK中,提供了两个抽象类InputStream和OutputStream,它们是字节流的顶级⽗类,所有的字节输⼊流都继承⾃InputStream,所有的字节输出流都继承⾃OutputStream。
既然⼆者是抽象类,那么就不能实例化,都是依赖于具体继承它们的⼦类去实现。
但⼆者抽象类中也包含它们各⾃的⽅法,如果我们先了解清楚抽象类中每⼀个⽅法的含义,那么对于后续具体的⼦类将会有⾮常⼤的帮助。
1、字节输⼊流InputStreamInputStream是所有字节输⼊流的⽗类,定义了所有字节输⼊流都具有的共同特征。
其内部提供的⽅法如下:image上图中的三个read()⽅法都是⽤来读数据的。
int read():每次读取⼀个字节,返回读取到的字节。
int read(byte[] b):每次读取b 数组长度的字节数,然后返回读取的字节的个数[注意与read() ⽅法的区别],读到末尾时返回-1。
int read(byte[] b,int off,int len):每次读取b 数组长度的字节数,从数组b 的索引为off 的位置开始,长度为len个字节。
⼩贴⼠:close⽅法,当完成流的操作时,必须调⽤此⽅法,释放系统资源。
其中InputStream的实现类FileInputStream是专门⽤于读取⽂件中的数据,通过它将⽬标设备上的数据读⼊到程序。
FileInputStream的构造⽅法:FileInputStream(File file):通过打开与实际⽂件的连接来创建⼀个FileInputStream ,该⽂件由⽂件系统中的File对象file命名。
Java 输入输出 的 基本原理及示例
来自:亿淘城_减肥榜的个人笔记谢谢你的支持(*^__^*) 嘻嘻……Java I/O原理→基本概念:•I/O(Input/Output)•数据源(Data Source)•数据宿(Data Sink)→Java中把不同的数据源与程序间的数据传输都抽象表述为“流”(Stream),java.io包中定义了多种I/O流类型实现数据I/O功能。
→I/O流分类:•输入流(Input Stream)和输出流(Output Stream)•节点流(Node Stream)和处理流(Processing Stream)•字符流(Character Stream)和字节流(Byte Stream)#输入流(Input Stream)和输出流(Output Stream)1.输入流只能从中读取数据,而不能向其写数据;2.输出流则只能向其写出数据,而不能从中读取数据;3.特例:java.io.RandomAccessFile类。
#节点流(Node Stream)和处理流(Processing Stream)1.节点流直接连接到数据源2.处理流是对一个已存在的流的连接和封装,通过所封装的刘的功能调用实现增强的数据读写功能,处理流并不直接连到数据源#字符流(Character Stream)和字节流(Byte Stream)1.字节流以字节为单位进行数据传输,每次传送一个或多个字节。
2.字符流以字符为单位进行数据传输,每次传送一个或多个字符。
※Java命名惯例:凡是以InputStream 或OutputStream结尾的类型均为字节流,凡是以Reader 或Writer 结尾的均为字符流。
InputStream抽象类java.io.InputStream 是所有字节输入流类型的父类,该类中定义了以字节为单位读取数据的基本方法,并在其子类中进行了分化和实现。
◆三个基本的 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()OnputStreamJava.io.OutputStream 与java.io.InputStream对应,是所有字节输出流类型的抽象父类。
05.IO流、异常处理
05.IO流、异常处理基本IO操作RAF 提供了文件随机读写功能,但是没有提供复杂数据的读写功能。
Java 提供了另外一套可以灵活扩展的API: IO流。
IO流在节点流基础之上提供了丰富的的扩展功能,利用这些扩展流可以大大简化IO程序的开发。
1. InputStream与OutputStream1.1. 输入与输出流按照数据流向分为输入流和输入流:什么是输入:输入是一个从外界进入到程序的方向,通常我们需要“读取”外界的数据时,使用输入。
所以输入是用来读取数据的。
InputStream 代表输入流经常缩写为in/包含核心方法read()/关闭方法 close()什么是输出:输出是一个从程序发送到外界的方向,通常我们需要”写出”数据到外界时,使用输出。
所以输出是用来写出数据的。
OutputStream 代表输出流经常缩写为out/包含核心方法write()/关闭方法close() 这两个流是抽象类,不能直接使用。
在实际工作中使用其实现类:文件输出流FileOutputStream1.2. 节点流与处理流按照流是否直接与特定的地方(如磁盘、内存、设备等) 相连,分为节点流和处理流两类。
节点流:可以从或向一个特定的地方(节点)读写数据。
//节点流是流最原始的数据源,提供流最基本的功能。
处理流:是对一个已存在的流的连接和封装,通过所封装的流的功能调用实现数据读写。
//也称为高级流,过滤流,处理流是在其他流的基础之上扩展出更高级的功能。
处理流的核心特点是必须依赖于另外一个流,自己不能独立功能,处理流是对另外的流进行扩展。
处理流的构造方法总是要带一个其他的流对象做参数。
一个流对象经过其他流的多次包装,称为流的链接。
2. 文件流2.1. 创建FOS对象(重写模式)FileOutputStream是文件的字节输出流,我们使用该流可以以字节为单位将数据写入文件。
构造方法:FileOutputStream(File file)创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
JSP FileInputStream和FileOutputStream类
JSP FileInputStream和FileOutputStream类字节流由两个类层次结构定义。
在顶层有两个抽象类:InputStream和OutputStream。
每个抽象类都有多个具体的子类,这些子类对不同的外设进行处理,例如磁盘文件,网络连接,甚至是内存缓冲区。
要使用流类,必须导入java.io包。
把文件中的数据读取出来或者向文件中写入数据,可以利用字节流FileInputStream和FileOutputStream来实现。
二种操作的实现过程大致相同,首先都是在文件和程序建立一个管道(可以将该操作虚拟为一个管道或通道),管道建立好后,可以向文件中读取或者写入数据,操作完毕后,关闭该管道。
1.FileInputStream类FileInputStream是Java流中比较常用的一种,它是从java.io.InputStream中继承过来的简单输入类。
FileInputStream表示从文件系统的某个文件中获取输入字节,哪些文件可用取决于主机环境。
通过使用FileInputStream可以访问文件的一个字节、几个字节或整个文件。
FileInputStream常用构造函数如表7-6所示:表7-6 FileInputStream构造函数可以使用上面表格中的构造函数创建输入流的实例化对象。
在创建过程中,这些构造函数可能引发FileNotFoundException异常,需要使用try-catch语句进行捕获。
下面的例子创建了两个使用同样磁盘文件且各含一个上述构造函数的FileInput第一个构造函数可能更常用到,第二个构造函数允许在把文件赋给输入流之前用File方法进一步检查文件。
当一个FileInputStream被创建时,它可以被公开读取,即在程序和文件之间建立通道。
2.FileOutputStream类文件输出流是用于将数据写入File或FileDescriptor的输出流。
文件是否可用或能否可以被创建取决于基础平台。
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及C++中的一个重要的机制,通过流能使我们能自由地控制包括文件,内存,IO设备等等中的数据的流向。
如:可以从文件输入流中获取数据,经处理后再通过网络输出流把数据输出到网络设备上;或利用对像输出流把一个程序中的对象输出到一个格式流文件中,并通过网络流对象将其输出到远程机器上,然后在远程机器上利用对象输入流将对象还原。
像这些机制是别的高级语言所不能比拟的。
但要掌握好这些流对象,流的概念是很重要的。
流是一串连续不继的数据的集合,就像水管一里的水流,在水管的一端一点一点地供水,而在水管的另一端看到的是一股连续不断的水流。
数据写入程序可以是一段一段地向数据流管道中写入数据,这些数据段会按先向顺序形成一个长的数据流。
对数据的读取程序来说,看不到数据流在写入时的分段情况,每次可以读取其中的任意长度的数据,但只能先读取前面的数据后,再读取后面的数据。
不管写入时是将数据分多次写入,还是作为一个整体一次写入,读取时的效果都是完全一样的。
在JAVA中的流按流动方向可以分为输入流及输出流两种,按流的处理位置可分为节点流和包装流。
输入流,输出流是以程序为参考点来说的,所谓的输入流就是程序从中获取数据的流,输出流就是程序要其写数据的流。
在输入流的一边是程序,而另一边就是流的数据源。
而输出流的一边则目标,一边就是程序。
其实流可以想像成是一条长河,在上游有一水库提供水源,河边住着一户人,随时都可以从河边取到水,同时,这户人也可以把一些废水倒进河里,使得废水可以流进大海。
这里所提到河就是一个数据的流动通道,而水库就好比是计算机上的一切数据源,包括磁盘文件,内存,IO设备,键盘等等,JAVA提供了非常完善的输入流类来把这些数据源挂接到流上使得程序能从这些输入流中获取所需的数据。
河边上的用户就是程序,它能随时随地从流中取得数据,只要有数据源挂接到这个通道上可以。
而大海就是程序处理完数据后要流向的目的地,这些目的地包抱磁盘文件,内存,IO设备,显示器等,这些目的地只是相对程序来说的,它们也可能是别的进程的输入流。
IO流之ZipInputStream和ZipOutputStream的认识及常用使用(转)。。。
IO流之ZipInputStream和ZipOutputStream的认识及常⽤使⽤(转)。
ZipInputStream和ZipOutputStream定义压缩流在⽇常中经常会使⽤到zip或rar这样的压缩⽂件,更加便利了我们⽇常⽂件的传输和使⽤。
当然在java中也提供了相应的输⼊输出流来压缩和解压gzip、zip和rar这样的⽂件。
ZipInputStream“压缩⽂件输⼊流”,⽤于读取磁盘上的压缩⽂件ZipOutputStream“压缩⽂件输出流”,⽤于将程序中的压缩流写出到磁盘上。
通常需要使⽤ZipFile ZipInputStream/ZipOutputStream ZipEntry级File完成解压缩操作。
其他相似流在JAVA IO中,不仅可以实现ZIP压缩格式的输⼊、输出,也可以实现JAR及GZIP⽂件格式的压缩:JAR压缩的⽀持类保存在java.util.jar包中,常⽤的类有如下⼏个:JAR压缩输出流:JarOutputStreamJAR压缩输⼊流:JarInputStreamJAR⽂件:JARFileJAR实体:JAREntryGZIP是⽤于UNIX系统的⽂件压缩,在Linux中经常会使⽤到*.gz的⽂件,就是GZIP格式,GZIP压缩的⽀持类保存在java.util.zip包中,常⽤的类有如下⼏个:GZIP压缩输出流:GZIPOutputStreamGZIP压缩输⼊流:GZIPInputStream使⽤⽤例压缩// 压缩⼊⼝1public static void compress(String srcPath, String destPath,boolean dirFlag) throws Exception {compress(new File(srcPath), new File(destPath), dirFlag);}// 压缩⼊⼝2public static void compress(String srcPath, String destPath) throws Exception {compress(new File(srcPath), new File(destPath), DEFAULT_DIR);}// 压缩⼊⼝3public static void compress(File srcFile, File destFile, boolean dirFlag) throws Exception {compress(srcFile, new ZipOutputStream(new FileOutputStream(destFile)), dirFlag);}public static void compress(File srcFile, ZipOutputStream zos, boolean dirFlag) throws Exception {// 需要解压的压缩⽂件对象// 压缩输出流// 是否在压缩⽂件时创建⼀个⽗⽂件夹后再压缩if (srcFile.isDirectory()) {if (dirFlag) {doCompress(zos, srcFile, srcFile.getName() + File.separator);} else {doCompress(zos, srcFile, "");}} else {doCompress(zos, srcFile, "");}zos.close();}public static void doCompress(ZipOutputStream zos, File file, String baseDir) throws Exception {if (file.isDirectory()) {// 递归循环,只压缩其中所有⽂件File[] files = file.listFiles();for (int i = 0; i < files.length; i++) {doCompress(zos, files[i], baseDir);}} else {// 进⾏⽂件压缩的操作byte[] buff = new byte[DEFAULT_BUFF_SIZE];InputStream in = new FileInputStream(file);zos.putNextEntry(new ZipEntry(baseDir + File.separator + file.getName()));int len;while ((len = in.read(buff,0 ,DEFAULT_BUFF_SIZE)) != -1) {zos.write(buff, 0, len);}in.close();}}解压/*** Default buff byte size**/private static final int DEFAULT_BUFF_SIZE = 1024;/*** Default basedir value**/private static final boolean DEFAULT_DIR = false;// 程序⼊⼝1public static void decompress(String srcPath) throws Exception {decompress(new File(srcPath));}// 程序⼊⼝2public static void decompress(File srcFile) throws Exception {File baseFile = srcFile.getParentFile();decompress(srcFile, baseFile);}// 程序⼊⼝3public static void decompress(String srcPath, String destPath) throws Exception {decompress(new File(srcPath), new File(destPath));}// 程序基本⼊⼝public static void decompress(File srcFile, File destFile) throws Exception { CheckedInputStream cis = new CheckedInputStream(new FileInputStream(srcFile), new CRC32()); ZipInputStream zis = new ZipInputStream(cis);// 解压操作doDecompress(destFile, zis);zis.close();}private static void doDecompress(File destFile, ZipInputStream zis) throws Exception {ZipEntry zipEntry = null;while ((zipEntry = zis.getNextEntry()) != null) {String dir = destFile.getPath() + File.separator + zipEntry.getName();File dirFile = new File(dir);// 如果⽗⽂件夹不存在,则递归创建其⽗⽂件夹fileProber(dirFile);if (zipEntry.isDirectory()) {// 如果zipEntry是⽬录,则创建⽬录dirFile.mkdirs();} else {// 解压压缩⽂件的其中具体的⼀个zipEntry对象doDecompressFile(dirFile, zis);}zis.closeEntry();}}// ⼀般意义上的⽂件复制操作private static void doDecompressFile(File destFile, ZipInputStream zis) throws Exception { BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));int len;byte[] buff = new byte[DEFAULT_BUFF_SIZE];while ((len = zis.read(buff, 0 ,DEFAULT_BUFF_SIZE)) != -1) {bos.write(buff, 0, len);}bos.close();}/*** ⽂件探测** When the parent file not exist.Create it.** @param dirFile* @throws Exception*/public static void fileProber(File dirFile) throws Exception {File parentFile = dirFile.getParentFile();if (!parentFile.exists()) {fileProber(parentFile);parentFile.mkdirs();}}⼯具类/*** Copyright © 2018, LeonKeh* <p>* All Rights Reserved.*/package cn.cherry.se.l_io_zipoutputinputstream;import java.io.*;import java.util.zip.*;/*** ZIP 解压缩⼯具包** @author Leon* @version 2018/6/6 23:07*/public class ZipUtils {/*** Default buff byte size**/private static final int DEFAULT_BUFF_SIZE = 1024;/*** Default basedir value**/private static final boolean DEFAULT_DIR = false;public static void decompress(String srcPath) throws Exception {decompress(new File(srcPath));}public static void decompress(File srcFile) throws Exception {File baseFile = srcFile.getParentFile();decompress(srcFile, baseFile);}public static void decompress(String srcPath, String destPath) throws Exception {decompress(new File(srcPath), new File(destPath));}public static void decompress(File srcFile, File destFile) throws Exception { CheckedInputStream cis = new CheckedInputStream(new FileInputStream(srcFile), new CRC32());ZipInputStream zis = new ZipInputStream(cis);doDecompress(destFile, zis);zis.close();}private static void doDecompress(File destFile, ZipInputStream zis) throws Exception {ZipEntry zipEntry = null;while ((zipEntry = zis.getNextEntry()) != null) {String dir = destFile.getPath() + File.separator + zipEntry.getName();File dirFile = new File(dir);fileProber(dirFile);if (zipEntry.isDirectory()) {dirFile.mkdirs();} else {doDecompressFile(dirFile, zis);}zis.closeEntry();}}private static void doDecompressFile(File destFile, ZipInputStream zis) throws Exception { BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));int len;byte[] buff = new byte[DEFAULT_BUFF_SIZE];while ((len = zis.read(buff, 0 ,DEFAULT_BUFF_SIZE)) != -1) {bos.write(buff, 0, len);}bos.close();}/*** ⽂件探测** When the parent file not exist.Create it.** @param dirFile* @throws Exception*/public static void fileProber(File dirFile) throws Exception {File parentFile = dirFile.getParentFile();if (!parentFile.exists()) {fileProber(parentFile);parentFile.mkdirs();}}public static void compress(String srcPath, String destPath,boolean dirFlag) throws Exception { compress(new File(srcPath), new File(destPath), dirFlag);}public static void compress(String srcPath, String destPath) throws Exception {compress(new File(srcPath), new File(destPath), DEFAULT_DIR);}public static void compress(File srcFile, File destFile, boolean dirFlag) throws Exception { compress(srcFile, new ZipOutputStream(new FileOutputStream(destFile)), dirFlag);}public static void compress(File srcFile, ZipOutputStream zos, boolean dirFlag) throws Exception { if (srcFile.isDirectory()) {if (dirFlag) {doCompress(zos, srcFile, srcFile.getName() + File.separator);} else {doCompress(zos, srcFile, "");}} else {doCompress(zos, srcFile, "");}zos.close();}public static void doCompress(ZipOutputStream zos, File file, String baseDir) throws Exception { if (file.isDirectory()) {File[] files = file.listFiles();for (int i = 0; i < files.length; i++) {doCompress(zos, files[i], baseDir);}} else {byte[] buff = new byte[DEFAULT_BUFF_SIZE];InputStream in = new FileInputStream(file);zos.putNextEntry(new ZipEntry(baseDir + File.separator + file.getName()));int len;while ((len = in.read(buff,0 ,DEFAULT_BUFF_SIZE)) != -1) {zos.write(buff, 0, len);}in.close();}}ZipInputStream 默认utf-8编码会存在中⽂乱码,解决⽅式:使⽤gbk编码。
DataOutputStream和DataInputStream的作用
DataOutputStream和DataInputStream的作用DataOutputStream类的作用是将Java的基本数据类型和字符串以二进制格式写入输出流中。
它提供了一系列的write方法,可以写入不同类型的数据,如整数、浮点数、字符、布尔值等。
DataOutputStream还提供了一些特殊的方法,如writeUTF用于写入字符串,writeBytes用于写入字节数组等。
它还提供了缓冲区来提高写入性能。
下面是一个使用DataOutputStream写入数据到文件的示例:```javatry (DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.bin")))dos.writeInt(10);dos.writeDouble(3.14);dos.writeUTF("Hello, world!");} catch (IOException e)e.printStackTrace(;```DataInputStream类的作用是从输入流中读取二进制数据,并将其转换为Java的基本数据类型和字符串。
它提供了一系列的read方法,可以读取不同类型的数据,如整数、浮点数、字符、布尔值等。
DataInputStream还提供了一些特殊的方法,如readUTF用于读取字符串,readFully用于读取字节数组等。
它也提供了缓冲区来提高读取性能。
下面是一个使用DataInputStream从文件中读取数据的示例:```javatry (DataInputStream dis = new DataInputStream(new FileInputStream("data.bin")))int intValue = dis.readInt(;double doubleValue = dis.readDouble(;String stringValue = dis.readUTF(;System.out.println(intValue);System.out.println(doubleValue);System.out.println(stringValue);} catch (IOException e)e.printStackTrace(;```DataOutputStream和DataInputStream通常用于在文件和网络之间传输数据。
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字符集中的所有字符。
将输出流(OutputStream)转化为输入流(InputStream)的方法(二)
将输出流(OutputStream)转化为输入流(InputStream)
的方法(二)
Java代码
下面是关于PipedOutputStream 的API介绍
传送输出流可以连接到传送输入流,以创建通信管道。
传送输出流是管道的发送端。
通常,数据由某个线程写入PipedOutputStream 对象,并由其他线程从连接的PipedInputStream 读取。
不建议对这两个对象尝试使用单个线程,因为这样可能会死锁该线程。
下面是关于 PipedInputStream 的API介绍
传送输入流应该连接到传送输出流;传送输入流会提供要写入传送输出流的所有数据字节。
通常,数据由某个线程从
PipedInputStream 对象读取,并由其他线程将其写入到相应的PipedOutputStream。
不建议对这两个对象尝试使用单个线程,因为这样可能会死锁该线程。
传送输入流包含一个缓冲区,可在缓冲区限定的范围内将读操作和写操作分离开。
Java实现InputStream的任意拷贝方式
Java实现InputStream的任意拷贝方式Java提供了多种方式来实现InputStream的拷贝。
在下面的文章中,我将介绍三种常见的实现方法。
1.使用循环读取和写入这是最基本的一种方法。
我们可以通过创建一个缓冲区,然后在循环中从输入流读取数据块,并将其写入输出流中。
以下是一个示例代码:```javapublic static void copy(InputStream input, OutputStream output) throws IOExceptionbyte[] buffer = new byte[1024];int bytesRead;while ((bytesRead = input.read(buffer)) != -1)output.write(buffer, 0, bytesRead);}```这种方法的优点是简单直接,适用于较小的文件。
然而,它的缺点是需要手动控制循环和缓冲区的大小,不能适应更大的文件。
```javapublic static void copy(InputStream input, OutputStream output) throws IOExceptionIOUtils.copy(input, output);```这种方法的优点是代码简洁,适用于任意大小的文件。
它还提供了更多的功能选项,如自动关闭流等。
3. 使用Java NIO库Java NIO库提供了非阻塞IO操作的功能,可以更高效地实现流的拷贝。
我们可以使用其中的Channels和Buffers来读取和写入数据。
以下是一个示例代码:```javaimport java.nio.channels.FileChannel;import java.nio.file.Paths;import java.nio.file.StandardOpenOption;public static void copy(InputStream input, OutputStream output) throws IOExceptiontry (FileChannel sourceChannel =FileChannel.open(Paths.get("input.txt"),StandardOpenOption.READ);FileChannel targetChannel =FileChannel.open(Paths.get("output.txt"), StandardOpenOption.CREATE, StandardOpenOption.WRITE))sourceChannel.transferTo(0, sourceChannel.size(, targetChannel);}```这种方法的优点是高效且适用于大文件的拷贝。
bufferedoutputstream转换fileinputstream方法
bufferedoutputstream转换fileinputstream方法BufferedOutputStream转换FileInputStream方法在Java中,BufferedOutputStream和FileInputStream是两个常用的类,分别用于向输出流写入数据和从文件中读取数据。
有时候我们可能需要将一个BufferedOutputStream对象转换为FileInputStream对象,以便读取之前写入的数据。
本文将详细介绍各种方法来实现这一转换。
方法一:利用ByteArrayOutputStream1.创建一个ByteArrayOutputStream对象,用于存储BufferedOutputStream写入的数据。
2.将BufferedOutputStream对象的数据写入ByteArrayOutputStream中。
3.使用toByteArray()方法,将ByteArrayOutputStream对象转换为字节数组。
4.创建一个ByteArrayInputStream对象,将字节数组作为参数传入。
5.最后,将ByteArrayInputStream对象传给FileInputStream的构造函数,创建一个FileInputStream对象。
(new FileOutputStream(""));// 将数据写入bosByteArrayOutputStream baos = new ByteArrayOutputStream(); (baos);byte[] data = ();ByteArrayInputStream bais = new ByteArrayInputStream(dat a);FileInputStream fis = new FileInputStream(bais);通过以上步骤,你就成功地将BufferedOutputStream对象转换为了FileInputStream对象。
Java InputStream和OutputStream,Reader和Writer的辨析
Java InputStream和OutputStream,Reader和Writer的辨析对Java 的文件操作中的一些概念做了个总结,资料收集+自己理解。
文本文件I/O:概念辨析:File 类:File 类中提供了文件的创建、目录的创建、删除、文件列表、获取文件有关信息等操作,不涉及文件内容的读和写,读与写的操作要靠write() 和read() 方法。
Writer 和Reader:Writer 和Reader 用于字符流的写入和读取,也就是说写入和读取的单位是字符,如果读与写的操作不涉及字符,那么是不需要Writer 和Reader 的。
Writer 类(抽象类),子类必须实现的方法仅有write()、flush()、close()。
继承了此类的类是用于写操作的“Writer”。
Reader 类(抽象类),子类必须实现的方法仅有read()、close()。
继承了此类的类是用于读操作的“Reader”write()方法和read()方法:write()方法是将数据写入到文件(广义概念,包括字节流什么的)中。
read()方法是将文件(广义概念,包括字节流什么的)中的数据读出到缓冲目标上。
InputStream和OutputStream:InputStream:此抽象类是表示字节输入流的所有类的超类。
字节输入流相当于是一个将要输入目标文件的“流”。
InputStream有read() 方法而没有write()方法,因为它本身代表将要输入目的文件的一个“流”OutputStream:此抽象类是表示输出字节流的所有类的超类。
输出流接受输出字节并将这些字节发送到某个接收器。
是从文件中将要输出到某个目标的“流”。
OutputStream有write()方法而没有read()方法。
InputStreamReader和OutputStreamWriter:InputStreamReader是字节流通向字符流的桥梁:它使用指定的charset 读取字节并将其解码为字符。
文件输入输出流
文件输入输出流文件输入输出流是在计算机中进行文件读写操作的一种机制。
通过文件输入输出流,我们可以从文件中读取数据或者将数据写入文件中。
在程序开辟中,文件输入输出流常用于读取配置文件、读取和写入日志文件、进行数据持久化等操作。
文件输入输出流的基本概念和使用方法如下:1. 文件输入流(FileInputStream):用于从文件中读取数据。
- 创建文件输入流对象:可以使用FileInputStream类的构造方法来创建一个文件输入流对象。
需要提供文件路径作为参数。
- 读取数据:可以使用文件输入流对象的read()方法来读取数据。
read()方法会返回一个整数值,表示读取到的字节数据。
当读取到文件末尾时,read()方法会返回-1。
2. 文件输出流(FileOutputStream):用于将数据写入文件中。
- 创建文件输出流对象:可以使用FileOutputStream类的构造方法来创建一个文件输出流对象。
需要提供文件路径作为参数。
如果文件不存在,会自动创建新文件;如果文件已存在,会清空文件内容。
- 写入数据:可以使用文件输出流对象的write()方法来写入数据。
write()方法接受一个字节数组作为参数,将字节数组中的数据写入文件中。
文件输入输出流的使用示例:```javaimport java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;public class FileIOExample {public static void main(String[] args) {// 文件输入流示例try {FileInputStream inputStream = new FileInputStream("input.txt");int data;while ((data = inputStream.read()) != -1) {System.out.print((char) data);}inputStream.close();} catch (IOException e) {e.printStackTrace();}// 文件输出流示例try {FileOutputStream outputStream = new FileOutputStream("output.txt"); String data = "Hello, World!";byte[] bytes = data.getBytes();outputStream.write(bytes);outputStream.close();} catch (IOException e) {e.printStackTrace();}}}```在上面的示例中,我们通过文件输入流读取了名为"input.txt"的文件中的数据,并使用文件输出流将字符串"Hello, World!"写入了名为"output.txt"的文件中。
java IO流
一、IO流的三种分类方式1.按流的方向分为:输入流和输出流2.按流的数据单位不同分为:字节流和字符流3.按流的功能不同分为:节点流和处理流二、IO流的四大抽象类:字符流:Reader Writer字节流:InputStream(读数据)OutputStream(写数据)三、InputStream的基本方法int read()throws IOException读取一个字节以整数形式返回,如果返回-1已到输入流的末尾void close()throws IOException关闭流释放内存资源long skip(long n)throws IOException跳过n个字节不读四、OutputStream的基本方法void write(int b)throws IOException向输出流写入一个字节数据void flush()throws IOException将输出流中缓冲的数据全部写出到目的地五、Writer的基本方法void write(int c)throws IOException向输出流写入一个字符数据void write(String str)throws IOException将一个字符串中的字符写入到输出流void write(String str,int offset,int length)将一个字符串从offset开始的length个字符写入到输出流void flush()throws IOException将输出流中缓冲的数据全部写出到目的地六、Reader的基本方法int read()throws IOException读取一个字符以整数形式返回,如果返回-1已到输入流的末尾七、节点流类型点击查看大图八、访问文件之FileInputStream和FileOutputStream继承基类用于向文件中输入输出字节九、访问文件之FileReader和FileWriter继承基类用于向文件中输入输出字符----输出流在构造函数第二个参数可以设置true意义为跟在已有文件后进行输入----此类流会抛出FileNotFoundException需要对其进行显示捕捉十、缓冲流:缓冲流要套接在相应的节点流之上,提高了读写的效率。
java inputstream 和 outputstream使用方法
java inputstream 和 outputstream使用方法Java中的InputStream和OutputStream是用于处理字节流的抽象类。
它们是Java IO库中非常重要的部分,用于读取和写入数据。
InputStream的使用方法:1. 创建一个InputStream对象,可以通过继承InputStream类或实现InputStream接口来创建子类或实现类。
2. 使用read()方法读取数据,该方法会返回一个字节数组。
可以多次调用read()方法来读取多个字节,直到所有数据都被读取完毕。
3. 使用close()方法关闭InputStream对象,释放相关资源。
下面是一个简单的示例代码,演示如何使用InputStream读取文件中的数据:```javaimport ;import ;public class InputStreamExample {public static void main(String[] args) {try {FileInputStream fis = new FileInputStream(""); byte[] buffer = new byte[1024];int bytesRead = (buffer);while (bytesRead != -1) {// 处理读取到的数据(new String(buffer, 0, bytesRead));bytesRead = (buffer);}();} catch (IOException e) {();}}}```OutputStream的使用方法:1. 创建一个OutputStream对象,可以通过继承OutputStream类或实现OutputStream接口来创建子类或实现类。
2. 使用write()方法写入数据,该方法需要一个字节数组作为参数。
可以多次调用write()方法来写入多个字节,直到所有数据都被写入完毕。
inputstream 的用法
inputstream 的用法inputstream的用法1. 什么是inputstreaminputstream是包中的一个抽象类,它是字节输入流的父类。
它定义了一系列读取字节流的方法,用于从输入源(如文件、网络连接等)读取字节数据。
2. inputstream的常用方法•int read(): 从输入流中读取一个字节的数据,并返回读取的字节(以int类型返回)。
如果已经到达输入流的末尾,则返回-1。
•int read(byte[] b): 从输入流中读取最多个字节的数据,并存储到字节数组b中。
返回实际读取的字节数。
如果已经到达输入流的末尾,则返回-1。
•int read(byte[] b, int off, int len): 从输入流中读取最多len个字节的数据,并存储到字节数组b的偏移量off处开始的位置。
返回实际读取的字节数。
如果已经到达输入流的末尾,则返回-1。
•long skip(long n): 跳过输入流中的n个字节,并返回实际跳过的字节数。
如果无法跳过指定的字节数,则返回0。
•int available(): 返回输入流中可以读取的字节数。
•void close(): 关闭输入流,释放与之关联的资源。
3. inputstream的用法示例读取文件内容下面的示例演示了如何使用inputstream从文件中读取数据:import ;import ;import ;public class FileInputStreamExample {public static void main(String[] args) {try {InputStream inputStream = new FileInputStrea m("");int data;while ((data = ()) != -1) {// 处理读取的字节数据((char) data);}();} catch (IOException e) {();}}}在这个示例中,我们创建了一个FileInputStream对象来读取名为的文件。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
任务名称:inputstream和outputstream的常用方法
一、什么是InputStream和OutputStream
在Java中,InputStream和OutputStream是两个重要的抽象类,用于处理输入和输出流。
InputStream用于读取数据流,而OutputStream用于写入数据流。
这两个类是Java I/O库的核心组成部分,提供了丰富的方法来读取和写入不同类型的数据。
二、InputStream的常用方法
1. read()方法
read()方法是InputStream类中最基本的方法之一,用于从输入流中读取一个字节的数据。
它的返回值是int类型,表示读取的字节数据的ASCII值。
如果已经到达流的末尾,则返回-1。
2. read(byte[] b)方法
read(byte[] b)方法是InputStream类中另一个常用的方法,用于从输入流中读取多个字节的数据,并存储到指定的字节数组中。
该方法返回值是int类型,表示实际读取的字节数。
如果已经到达流的末尾,则返回-1。
3. available()方法
available()方法用于获取输入流中可读取的字节数。
它的返回值是int类型,表示可读取的字节数。
4. close()方法
close()方法用于关闭输入流。
在使用完输入流后,应该调用该方法来释放资源。
三、OutputStream的常用方法
1. write(int b)方法
write(int b)方法是OutputStream类中最基本的方法之一,用于向输出流中写入一个字节的数据。
参数b是要写入的字节数据的ASCII值。
2. write(byte[] b)方法
write(byte[] b)方法是OutputStream类中另一个常用的方法,用于向输出流中写入一个字节数组的数据。
参数b是要写入的字节数组。
3. flush()方法
flush()方法用于刷新输出流。
在使用输出流写入数据后,有时需要立即将数据发送出去,而不是等到缓冲区满或关闭流时才发送。
此时可以调用flush()方法来实现。
4. close()方法
close()方法用于关闭输出流。
在使用完输出流后,应该调用该方法来释放资源。
四、使用InputStream和OutputStream读写文件
使用InputStream和OutputStream可以方便地读写文件。
下面是一个示例代码:import java.io.*;
public class FileReadWriteExample {
public static void main(String[] args) {
try {
// 创建输入流
InputStream inputStream = new FileInputStream("input.txt");
// 创建输出流
OutputStream outputStream = new FileOutputStream("output.txt");
// 读取并写入数据
int data;
while ((data = inputStream.read()) != -1) {
outputStream.write(data);
}
// 关闭流
inputStream.close();
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
以上代码中,我们创建了一个输入流和一个输出流,然后使用while循环来读取输入流中的数据,并写入到输出流中。
最后,我们关闭了输入流和输出流。
五、总结
本文介绍了InputStream和OutputStream的常用方法,并给出了一个使用示例。
InputStream提供了read()和read(byte[] b)等方法来读取输入流中的数据,而OutputStream提供了write()和write(byte[] b)等方法来写入输出流中的数据。
此外,还介绍了一些其他常用的方法,如available()、close()和flush()。
通过学习和掌握这些方法,我们可以方便地进行输入和输出流的操作,实现文件的读写等功能。