Java学习IO流(一)
IO流概述
之前的程序，数据都是在内存中，一旦程序运行结束，数据就没有了。IO流的出现就是把运算完的数据都保存下来，下次运行程序时还能使用。把数据持久化的存储，就是把内存中的数据存储到内存以外的其他持久化的设备（光盘、硬盘、U盘等）上。
当需要把内存中的数据存储到持久化设备上这个动作称为输出（写）Output操作。
当把持久设备上的数据读取到内存中的这个动作称为输入（读）Input操作。
因此我们把这种输入和输出动作称为IO操作。
File类
File类有两个静态成员变量和三个构造方法
1、pathSeparator 与系统有关的路径分隔符 ;
2、separator 与系统有关的默认名称分隔符 \
构造方法：1、File（String pathname）
2、File（File parent，String child）
3、File(String parent，String child)
package com.oracle.demo1;
import java.io.File;
public class FileDemo {
public static void main(String[] args) {
// 与系统有关的路径分隔符 ;
String pathseparator = File.pathSeparator;
System.out.println(pathseparator);
// 与系统有关的默认名称分隔符 \
String separator = File.separator;
System.out.println(separator);
// 构造方法一 File(String pathname)
File f = new File("d:\\eclipsework1");
System.out.println(f);
// 构造方法二 File(File parent,String child)
File parent = new File("d:");
File f2 = new File(parent, "eclipsework1");
System.out.println(f2);
// 构造方法三 File(String parent, String child)
File f3 = new File("d:", "eclipsework1");
System.out.println(f3);
}
}
File类常用的方法
1、创建文件
|
boolean |
2、创建文件夹
|
boolean |
mkdir() 单级目录 |
|
boolean |
mkdirs() 多级目录 |
3、删除
|
boolean |
delete() |
4、判断此文件是否存在
|
boolean |
exists() |
5、判断此文件是否是文件夹
|
boolean |
6、获取绝对路径
7、获取文件名
|
getName() |
8、获取路径
|
getPath() |
9、长度
|
long |
length() |
package com.oracle.demo1;
import java.io.File;
import java.io.IOException;
public class FileDemo2 {
public static void main(String[] args) throws IOException {
// 创建文件
// File f = new File("d:\\eclipse\\demo.java");
// boolean b = f.createNewFile();
// System.out.println(b);
// 创建文件夹用mkdir()(多级目录用mkdirs())
// File f2 = new File("d:\\eclipse\\test\\test2");
// boolean b = f2.mkdirs();
// System.out.println(b);
// 删除(删除的文件不走回收站，直接从硬盘上删除)
// File f2 = new File("d:\\eclipse\\test\\test2");
// boolean b = f2.delete();
// System.out.println(b);
// 判断路径是否存在
// File f = new File("d:\\eclipse");
// boolean b = f.exists();
// System.out.println(b);
// 文件File、目录（文件夹）directory、路径path
// boolean isDirectory() 判断这个文件对象是否是文件夹
//System.out.println(f.isDirectory());
//文件的获取
//绝对路径
File f=new File("d:\\eclipsework1");
//相对路径
File f1=new File("src");
System.out.println(f.getAbsolutePath());
System.out.println(f.getName());
System.out.println(f.getPath());
System.out.println(f.length());
}
}
listFiles()方法
listFiles()方法用来获取一个目录中所有的文件和文件夹，得到的结果是一个数组或者集合
package com.oracle.demo1;
import java.io.File;
public class ListFileDemo {
public static void main(String[] args) {
// 创建你要获取的路径对象
File f = new File("D:\\java\\jdk");
// 获取此路径下文件的文件数组
File[] f2 = f.listFiles();
// 遍历数组得到文件
for (File file : f2) {
System.out.println(file);
}
System.out.println(f2.length);
}
}
注：在获取指定目录下的文件或者文件夹时必须满足下面两个条件
1，指定的目录必须是存在的，
2，指定的必须是目录。否则容易引发返回数组为null，出现NullPointerException
文件过滤器
当我们需要文件中某个指定的文件时，就需要用到文件过滤器。在File类中重载了listFiles方法，并接受指定的过滤器
package com.oracle.demo1;
import java.io.File;
import java.io.FileFilter;
public class MyFilter implements FileFilter{
public boolean accept(File pathname) {
String p=pathname.getName();
return p.endsWith(".exe");
}
}
package com.oracle.demo1;
import java.io.File;
public class FileDemo3 {
public static void main(String[] args) {
File f = new File("d:\\java\\jdk\\bin");
File[] f2 = f.listFiles(new MyFilter());
for (File f3 : f2) {
System.out.println(f3);
}
}
}
递归调用
递归：就是在当前的方法内调用自己的现象
package com.oracle.demo2;
public class demo1 {
public static void main(String[] args) {
// 求1......n的值
int sum = getsum(100);
System.out.println(sum);
System.out.println(get(5));
}
// 递归调用
public static int getsum(int a) {
if(a==1){
return 1;
}
return a + getsum(a - 1);
}
//递归求阶乘
public static int get(int b){
if(b==1){
return 1;
}
return b*get(b-1);
}
}
注：递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
练习：1、递归打印指定目录及子目录下的所有文件
2、递归调用打印d:\java\jdk下所有的.exe文件
3、使用文件名称过滤器筛选将指定文件夹下的小于200K的小文件获取并打印
package com.oracle.demo2;
import java.io.File;
public class demo4 {
public static void main(String[] args) {
File file = new File("d:\\java\\jdk");
getFileAll(file);
}
//获取指定目录以及子目录中的所有的文件
public static void getFileAll(File file) {
File[] files = file.listFiles();
//遍历当前目录下的所有文件和文件夹
for (File f : files) {
//判断当前遍历到的是否为目录
if(f.isDirectory()){
//是目录，继续获取这个目录下的所有文件和文件夹
getFileAll(f);
}else{
//不是目录，说明当前f就是文件，那么就打印出来
System.out.println(f);
}
}
}
}
package com.oracle.demo2;
import java.io.File;
public class LianXi {
public static void main(String[] args) {
File file=new File("d:\\java\\jdk");
get(file);
}
public static void get(File f){
//获取文件数组
File[] file2=f.listFiles(new MyFileFilterDemo());
//遍历当前文件下所有的文件
for(File f2:file2){
if(f2.isDirectory()){
get(f2);
}else{
System.out.println(f2);
}
}
}
}
package com.oracle.demo2;
import java.io.File;
import java.io.FileFilter;
public class MyFileFilterDemo implements FileFilter{
public boolean accept(File pathname) {
if(pathname.isDirectory()){
return true;
}
String p=pathname.getName();
return p.endsWith(".exe");
}
}
package com.oracle.demo2;
import java.io.File;
public class Demo01 {
public static void main(String[] args) {
// 1.使用文件名称过滤器筛选将指定文件夹下的小于200K的小文件获取并打印。
File file = new File("d:\\java\\jdk");
get(file);
}
public static void get(File f){
//获取指定路径文件数组
File[] file2=f.listFiles(new MyFileDemo());
//遍历得到所有文件
for(File f2:file2){
//如果是文件夹，就继续遍历里面的文件
if(f2.isDirectory()){
get(f2);
}else{
System.out.println(f2);
}
}
}
}
package com.oracle.demo2;
import java.io.File;
import java.io.FileFilter;
public class MyFileDemo implements FileFilter {
public boolean accept(File pathname) {
if(pathname.isDirectory()){
return true;
}
if(pathname.length()/1024<200){
return true;
}
return false;
}
}
字节流
前面学的File类的一些方法操作的都是空的文件或者文件夹，没有往里面去写任何数据，现在就通过字节流去往文件中写入数据
字节输出流OutputStream
OutputStream是一个抽象类，表示所有输出字节流的所有类的祖宗类，操作的数据都是字节
常用的方法：3个write()和1个close()方法
OutputStream类之FileOutputStream子类
FileOutputStream用于写入数据到文件
构造方法：
FileOutputStream(File file)：默认的覆盖文件
FileOutputStream(String name)：默认的覆盖文件
FileOutputStream（String name,boolean append）
注：若appand是true，则表示可以续写文件
若append是false，则表示覆盖文件
package com.oracle.demo3;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class OutputStreamDemo {
/*
* FileOutputStream创建对象，调用构造方法时 如果你这个文件对象中的文件存在，那么就给你覆盖 如果不存在，给你创建 new
* FileOutputStream(f); 如果构造方法传一个值的时候等价于new FileOutputStream(f,false);会给你覆盖
* 如果new FileOutputStream(f,true);那么可以文件续写，不给你覆盖 加“\r\n”
*
* 字节流操作的单位是字节 write()方法，一次只能写入一个字节 100代表SACII值里面的d
* 流对象的使用步骤
* 1、创建流子类的对象，绑定数据
* 2、调用write()方法
* 3、关闭流对象，调用close()方法，释放资源
*/
public static void main(String[] args) throws IOException {
// File f = new File("d:\\eclipse\\demo.txt");
// FileOutputStream fos = new FileOutputStream(f, true);
// fos.write(49);
// fos.write(48);
// fos.write(48);
// 如果你传入的是负数，那么就走汉字
// 一个汉字占两个字节，一个数字占一个字节
// byte[] b={-12,-23,-30,-45};
// 传字节数组的write方法
// fos.write(b);
// void write(byte[] b,int off,int len);
// fos.write(b, 1, 2);
// 需求：传入Hello getBytes()返回一个字节数组
// fos.write("\r\njava".getBytes());
// fos.close();
// 创建一个java.txt
File f = new File("e:\\test\\java.txt");
FileOutputStream fos = new FileOutputStream(f, true);
fos.write("Java是世界上最好的语言".getBytes());
fos.close();
}
}
输出流的操作步骤：
- 创建流对象
- 调用write（）方法：每次只写入一个字节
- 关闭colse
IO异常处理
package com.oracle.demo3;
import java.io.FileOutputStream;
import java.io.IOException;
public class ThrowsDemo {
/*IOException处理细节
* 1、保证流对象的作用域足够（在块外面声明，在块里面赋值）
* 2、catch里面怎么处理异常
* IO异常一旦出现，一般不能处理
* 第一：输出异常信息；第二：throw new RuntimeException
* 3、流对象建立失败，还需要关闭资源么？
* 加一个判断，if(fos!=null)
* */
public static void main(String[] args) {
FileOutputStream fos = null;
try {
fos = new FileOutputStream("e:\\test\\java.txt");
fos.write("Java是世界上最好的语言".getBytes());
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException("文件写入失败，请重试");
} finally {
try {
if (fos != null) {
fos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
字节输入流InputStream
InputStream此抽象类，是表示字节输入流的所有类的祖宗类。，定义了字节输入流的基本共性功能方法。
int read():读取一个字节并返回，没有字节返回-1.
int read(byte[]): 读取一定量的字节数，并存储到字节数组中，返回读取到的字节数
InputStream类之FileInputStream子类
构造方法：
输入流操作步骤：
- 创建流对象
- Read（）
- close（）
package com.oracle.demo3;
import java.io.FileInputStream;
import java.io.IOException;
public class InputStreamDemo {
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis = new FileInputStream("e:\\test\\java.txt");
// read()方法一次只能读取一个字节 如果到达流的末尾，则返回 -1。
// int b = fis.read();
// byte[] b = new byte[100];
// int c = fis.read(b);
// for (byte b1 : b) {
// System.out.println(b1);
// }
// System.out.println(c);
// 1、read
int len = 0;
while ((len = fis.read()) != -1) {
System.out.print((char) len);
}
// 2、read(byte[] b)
byte[] b = new byte[1024];
int l = 0;
while((l=fis.read())!=-1)
System.out.println(new String(b, 0, l));
} catch (IOException ex) {
ex.printStackTrace();
throw new RuntimeException("文件读取失败，请重试");
} finally {
try {
fis.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
}
