最基础的读取文件

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException; public class FileIOTest {
public static void main(String[] args) {
File file = new File("E:/abc.txt");
FileInputStream is = null;
try {
is = new FileInputStream(file);
byte[] bytes = new byte[3]; //缓冲容器
int len = -1; //接收长度
while ((len = is.read(bytes)) != -1) {
//字符数组-->字符串,解码
String s = new String(bytes, 0, len);
System.out.println(s);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
          if(is != null){
            is.clise();
          } } catch (IOException e) {
e.printStackTrace();
}
}
}
}

从文件读取到另一个文件

package com.svs;

import java.io.*;

public class IOTest {
public static void main(String[] args) {
File file = new File("E:/abc.txt");
FileInputStream is = null;
FileOutputStream os = null;
try {
is = new FileInputStream(file);
os = new FileOutputStream("F:/abc.txt");
byte[] bytes = new byte[3];
int len = -1;
while ((len=is.read(bytes)) != -1){
os.write(bytes,0,len);
os.flush();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
try {//先打开的后关闭
         if(os != null){
  os.close();
         }
         if(is != null){
   is.close();
         }
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

IO流的工具类,抽离出读取、写入、关闭

import java.io.*;

public class FileUtil {
public static void main(String[] args) {
copy("D:/123441.jpg", "E:/123441.jpg");
} /**
* 流的读取与写入
*
* @param srcPath
* @param destPath
*/
public static void copy(String srcPath, String destPath) {
File src = new File(srcPath);
File dest = new File(destPath);
try (InputStream is = new FileInputStream(src);
OutputStream os = new FileOutputStream(dest)) {
byte[] flush = new byte[1024 * 2]; //缓冲容器
int len = -1; //接收长度
while ((len = is.read(flush)) != -1) {
os.write(flush, 0, len);
os.flush(); //刷新缓存
}
} catch (IOException e) {
e.printStackTrace();
}
} }

使用字节数组流读取数据

补充:流的来源或目的地并不一定是文件,也可以是内存中的一块空间,例如一个字节数组。就需使用字节数组流处理,且字节数组流不用关闭。

package com.svs;

import java.io.*;

public class ByteArrayStreamFileUtil {
public static void main(String[] args) {
//使用字节数组流读取,写入数据,字节数组流是不用关闭的
try {
//从硬盘中读取文件,存储到内存中
InputStream is = new FileInputStream("E:/aa.jpg");
ByteArrayOutputStream baos = new ByteArrayOutputStream();
copy(is, baos);
//从内存中读取数据,存储到硬盘中
InputStream bais = new ByteArrayInputStream(baos.toByteArray());
OutputStream os = new FileOutputStream("F:/aa.jpg");
copy(bais, os);
closeIO(is, os);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 流的读取与写入
*
* @param is
* @param os
*/
public static void copy(InputStream is, OutputStream os) {
try {
byte[] flush = new byte[1024 * 2]; //缓冲容器
int len = -1; //接收长度
while ((len = is.read(flush)) != -1) {
os.write(flush, 0, len);
os.flush(); //刷新缓存
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
is.close();
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
} /**
* 关闭流
*
* @param is
* @param os
*/
public static void closeIO(InputStream is, OutputStream os) {
try { //先打开的先关闭
if (os != null) {
os.close();
}
if (is != null) {
is.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

总结:ByteArrayOutputStream或ByteArrayInputStream是内存读写流,不同于指向硬盘的流,它内部是使用字节数组读内存的,这个字节数组是它的成员变量,当这个数组不再使用变成垃圾的时候,Java的垃圾回收机制会将它回收,所以不需要关流。也就是说,指向内存的流可以不用关闭,指向存储卡/硬盘的流一定要关闭。 

使用字节数组流读取数据-升级版

JDK1.7之后引入

try(    ){
}catch(){
}

方法,省去finally,进行自动关闭。(这是使用 try-with-resources 资源自动释放特性)

package com.svs;

import java.io.*;

public class ByteArrayStreamFileUtil2 {
public static void main(String[] args) {
//JDK1.7之后,引入try(){}方法进行关闭
try (InputStream is = new FileInputStream("E:/aa.jpg");
OutputStream os = new FileOutputStream("F:/aa.jpg");) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
copy(is, baos);
InputStream bais = new ByteArrayInputStream(baos.toByteArray());
copy(bais, os);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 流的读取与写入
*
* @param is
* @param os
*/
public static void copy(InputStream is, OutputStream os) {
try {
byte[] flush = new byte[1024 * 2]; //缓冲容器
int len = -1; //接收长度
while ((len = is.read(flush)) != -1) {
os.write(flush, 0, len);
os.flush(); //刷新缓存
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
is.close();
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

字节缓冲流

BufferedInputStream,BufferedOutputStream。字节缓冲流是对读取【性能】的提升,使用字节流时建议加上字节缓冲流。

import java.io.*;

/**
* @Description: 字节缓冲流 BufferedInputStream BufferedOutputStream
* @Description: 字节缓冲流是对读取【性能】的提升,使用字节流时建议加上字节缓冲流
*/ public class BufferedStream {
public static void main(String[] args) {
// long l1= System.currentTimeMillis();
copy("D:/123441.jpg", "E:/123441.jpg");
// long l2= System.currentTimeMillis();
// System.out.println(l2-l1);
} /**
* 流的读取与写入
*
* @param srcPath
* @param destPath
*/
public static void copy(String srcPath, String destPath) {
File src = new File(srcPath);
File dest = new File(destPath);
try (InputStream is = new BufferedInputStream(new FileInputStream(src));
OutputStream os = new BufferedOutputStream(new FileOutputStream(dest))) {
byte[] flush = new byte[1024 * 2]; //缓冲容器
int len = -1; //接收长度
while ((len = is.read(flush)) != -1) {
os.write(flush, 0, len);
os.flush(); //刷新缓存
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

字符缓冲流

import java.io.*;

/**
* @Description: 字符缓冲流 BufferedInputStream BufferedOutputStream
* @Description: 字符缓冲流是对读取【性能】的提升,使用字符流时建议加上字符缓冲流
*/ public class BufferedRWStream {
public static void main(String[] args) {
copy("D:/123441.txt", "E:/123441.txt");
} /**
* 流的读取与写入
*
* @param srcPath
* @param destPath
*/
public static void copy(String srcPath, String destPath) {
File src = new File(srcPath);
File dest = new File(destPath);
try (BufferedReader br = new BufferedReader(new FileReader(src));
BufferedWriter bw = new BufferedWriter(new FileWriter(dest))) {
String line = null;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
bw.flush(); //刷新缓存
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

转换流

InputStreamReader OutputSttreamWriter。
1、以字符流的形式操作字节流(纯文本);2、指定字符集(API手册查看)
import java.io.*;

/**
* @Description: 转换流 InputStreamReader OutputSttreamWriter
* @Description: 1、以字符流的形式操作字节流(纯文本)
* @Description: 2、指定字符集(API手册查看)
*/ public class ConvertTest {
public static void main(String[] args) {
//操作System.in和System.out,均是字节流
try(BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(System.out))){
//循环获取键盘的输入(exit退出),输出此内容
String msg="";
while (!"exit".equals(msg)){
msg=reader.readLine(); //循环读取
writer.write(msg); //循环写出
writer.newLine();
writer.flush(); //强制刷新
}
} catch (IOException e) {
e.printStackTrace();
} }
}

commons-io

Apache下的commonsIO,其中有封装好的FileUtil工具类,实际开发中无需写原生代码,拿来即用即可。

下载链接:http://commons.apache.org/proper/commons-io/download_io.cgi

Java基础IO流 ,文件读取,由易至难的更多相关文章

  1. Java中IO流文件读取、写入和复制

    //构造文件File类 File f=new File(fileName); //判断是否为目录 f.isDirectory(); //获取目录下的文件名 String[] fileName=f.li ...

  2. Java基础-IO流对象之随机访问文件(RandomAccessFile)

    Java基础-IO流对象之随机访问文件(RandomAccessFile) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.RandomAccessFile简介 此类的实例支持对 ...

  3. Java基础IO流(二)字节流小案例

    JAVA基础IO流(一)https://www.cnblogs.com/deepSleeping/p/9693601.html ①读取指定文件内容,按照16进制输出到控制台 其中,Integer.to ...

  4. Java基础-IO流对象之序列化(ObjectOutputStream)与反序列化(ObjectInputStream)

    Java基础-IO流对象之序列化(ObjectOutputStream)与反序列化(ObjectInputStream) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.对象的序 ...

  5. java基础-IO流对象之Properties集合

    java基础-IO流对象之Properties集合 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.Properties集合的特点 Properties类表示了一个持久的属性集. ...

  6. Java基础-IO流对象之字符缓冲流(BufferedWriter与BufferedReader)

    Java基础-IO流对象之字符缓冲流(BufferedWriter与BufferedReader) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.字符缓冲流 字符缓冲流根据流的 ...

  7. Java基础-IO流对象之字节缓冲流(BufferedOutputStream与BufferedInputStream)

    Java基础-IO流对象之字节缓冲流(BufferedOutputStream与BufferedInputStream) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 在我们学习字 ...

  8. Java基础-IO流对象之转换流(InputStreamReader与OutoutStreamWriter)

    Java基础-IO流对象之转换流(InputStreamReader与OutoutStreamWriter) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.转换流概述 我们之前 ...

  9. Java基础-IO流对象之字符类(FileWrite与FileReader)

    Java基础-IO流对象之字符类(FileWrite与FileReader) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.常见编码简介 1>ASCII 我们知道计算机是 ...

  10. Java基础-IO流对象之字节流(Stream)

    Java基础-IO流对象之字节流(Stream) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 在前面我分享的笔记中,我们一直都是在操作文件或者文件夹,并没有给文件中写任何数据.现 ...

随机推荐

  1. 吴裕雄--天生自然C语言开发:强制类型转换

    #include <stdio.h> int main() { , count = ; double mean; mean = (double) sum / count; printf(& ...

  2. ABC:Meaningful Mean

    题目描述 You are given an integer sequence of length N, a= {a1,a2,…,aN}, and an integer K. a has N(N+1)⁄ ...

  3. K3CLOUD表关联

    销售订单关联发货通知单 销售订单表 T_SAL_ORDER A T_SAL_ORDERENTRY B T_SAL_ORDERENTRY_LK C 发货通知单表 T_SAL_DELIVERYNOTICE ...

  4. 学习python-20191217(1)-Python Flask高级编程开发鱼书_第04章_应用、蓝图与视图函数

    视频01: flask框架:最上层是app,它就像一个插线板一样,比如可以插入蓝图,还可以插入其他各种flask插件. 每个蓝图又可以插入很多视图函数,并可指定静态文件夹和模板文件夹. 好的代码结构, ...

  5. webservice入门程序学习中经验总结

    ***第一步:创建客户端服务 1)创建一个服务接口 2)创建一个实现类实现接口 3)创建一个方法开启服务 这三步注意点:::实现类上必须添加@WebService标签 :::发布服务的时候用到的函数是 ...

  6. JDK源码看Java域名解析

    前言 在互联网中通信需要借助 IP 地址来定位到主机,而 IP 地址由很多数字组成,对于人类来说记住某些组合数字很困难,于是,为了方便大家记住某地址而引入主机名和域名. 早期的网络中的机器数量很少,能 ...

  7. 《hdu 4540 威威猫打地鼠》

    威威猫系列故事——打地鼠 Time Limit: 300/100 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others)Total ...

  8. id0-rsa WP合集

    忙里偷闲做做题wwwwwwwwwwwww Intro to Hashing Intro to PGP Hello PGP Hello OpenSSL Intro to RSA Caesar Hello ...

  9. JS数字千分

    JS数字千分: 1.例子:1000--->1,000 2.实现如下: salesToFormat: function (num) { var num = (num || 0).toString( ...

  10. cesium入门示例-探测效果

    动画实现方式通过多个canvas实现,参考的https://www.yueyanshaosun.cn/ysCesium/views/5_geometricObj2_entityCanvas.html ...