标题图

Java当中的IO流

在Java中,字符串string可以用来操作文本数据内容,字符串缓冲区是什么呢?其实就是个容器,也是用来存储很多的数据类型的字符串,基本数据类型包装类的出现可以用来解决字符串和基本数据类型之间的转换问题.

"字符串" 转换parseXxx() -- 基本数据类型"123456" -> parseInt -> 123456

基本数据类型包装类的出现,也提供了更多的操作.

对于集合框架,对象多来,便于存储和操作.

add put 添加存储, Collection - IteratorMap - Set - Iterator

IO流的出现是为了存储数据和读取数据的操作.数据存储到内存中如,对象,字符串,日期,系统信息等.内存和硬盘的关系是input输入和output输出的关系.所以输出输出就可以简称io了哦.(还不知道为啥io?因为input和output)

Java提供了io技术的操作,数据是在硬盘上的,在文件中体现的,所以要了解文件的相关信息,在学习过程中,遇到不会的就百度,先百度,一般问题都可以解决的.

了解Java中的File文件

java.io类 Filejava.lang.Object
 -> java.io.File知道的实现接口:Serializable,Comparable<File>

文件继承和实现:

public class File extends Object implements Serializable,Comparable<File>

File的字段:

构造方法:

File

public File(String pathname)通过将给定路径名 字符串转换为抽象路径名来创建一个新 File 实例.
参数为pathname: 路径名 字符串
抛出:NullPointerException,如果pathname为null的话

Filepublic File(String parent, String child)
根据parent路径名,字符串类型,和 child 路径名, 字符串类型, 创建一个新的File实例.
参数:parent为父路径名字符串
child为子路径名字符串
抛出的异常为:
NullPointerException:如果child为null

构造函数

File(File parent, String child)
File(String pathname)
File(String parent, String child)
File(URI uri)

import java.io.File;public class FileDemo{
 public static void main(String[] args){ // 创建路径
  String pathName = "e:\java\demo";// 创建文件对象,将demo文件夹封装成File对象
  File f = new File(pathName);
 }
}

同理可以改为文件路径:

// File(String pathname)String pathName = "e:\java\demo\demo.java";
File f = new File(pathName);// 将文件封装成File对象

结果为:

e:\java\demo\demo.java

在Java中的File对象,可以封装不存在的文件和文件夹,虽然没有,但是也可以生成创建,变成对象.

// File(String parent, String child)File f = new File("e:\java\demo","demo.java");// 同样可以创建,结果为:e:\java\demo\demo.java

File(File parent, String child)

// File(File parent, String child)// 是将parent 封装成File对象了File dir = new File("e:\java\demo");
File f = new File(dir,"demo.java");// 结果为:e:\java\demo\demo.java

要点:

盘符: "/"标题为UNIX中的根目录,"\\"表示为 Microsoft Windows UNC 路径名.

private static final String PILE_SEPARATOR = System.getProperty("file.separator");// File f = new File("e:" + PILE_SEPARATOR + "java\demo\demo.java");File f = new File("e:" + PILE_SEPARATOR + "java"+ PILE_SEPARATOR +"demo"+ PILE_SEPARATOR +"demo.java");

separator 相关

separatorpublic static final String separator
与系统有关的默认 -> 名称分隔符,表示为字符串

separatorCharpublic static final char separatorChar
与系统有关的默认 -> 名称分隔符

pathSeparatorCharpublic static final char pathSeparatorChar
与系统有关的 -> 路径分隔符

进一步优化:

File.pathSeparator: -> String-FileFile.pathSeparatorChar: -> char-FileSeparator: -> String-FileSeparatorChar: -> char-Fileclass: -> Class<java.io.File>File.listRoots(): -> File[]-File

// File.separatorFile f = new File("e:" + File.separator + "java"+ File.separator +"demo"+ File.separator +"demo.java");

File方法

文件属性:

文件类型
位置
大小
占用空间
修建时间
修改时间
访问时间
属性

FileMethodDemo

public class FileMethodDemo{
 public static void main(String[] args){  // 封装文件 java目录文件
  File file = new File("e:\java\demo\demo.java");
 }
}

File file = new File(" ");
System.out.println(file);// 结果为 空
               // 结果什么也没显示如果:
File file = new File(".");// 结果.
如果:
File file = new File("hello.txt");// 结果hello.txt// 如果想要什么路径可以用改方法,自己也可以查apiSystem.out.println(file.getAbsolutePath());// 可以得到结果 默认路径

可以查看系统信息,为SystemInfo文件,看看默认路径

File file = new File("hello.java");// 相对路径String absPath = file.getAbsolutePath();// 拿的是new File()中的写啥拿啥, File中封装的路径是啥,就拿啥哦~String path = file.getPath();// 获取文件名String filename = file.getName();// 文件长度long size = file.length();// 文件修改时间long time = file.lastModified();// 可以修改时间String date = DateFormat.getDateInstance(DateFormat.LONG).format(new Date(time));String date = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG).format(new Date(time));

用文件类方法,对文件进行创建和删除操作

File.canExecute(): 为可不可以执行,就是文件类型为xxx.exe的,相信你也看过这种.
返回类型为boolean

文件可读可写:

File.canRead(): 可读
返回类型为boolean

File.canWrite(): 可写
返回类型为boolean

创建文件

file.createNewFile();// 声明异常import java.io.IOExceptionpublic static void main(String[] args) throws IOException {
}

public class FileMethodDemo{ public static void main(String[] args) throws IOException {  // 创建文件
  File file = new File("e:\hello.txt");  // 文件不存在,则创建为true
  // 文件存在,则不创建为false
  // 路径错误,内存不够,则IOException
  boolean b = file.createNewFile();
  System.out.println("b=" + b);
 }
}

删除文件

File file = new File("e:\hello.txt");
boolean b = file.delete();// 彻底删除,不存在回收站中// 注意如果文件不存在,进行删除为false如果文件正在使用,进行删除为false

对文件进行判断存不存在

boolean b = file.exists();
System.out.println("b="+b);

对目录进行创建,删除,判断

dir.mkdir(); 为创建一个目录
dir.mkdirs(); 为创建一个路径,创建目录中的目录

File dir = new File("e:\hello)";boolean b = dir.mkdir();// 创建目录

File dir = new File("e:\hello\da\shu\dashu)";boolean b = dir.mkdirs();// 创建多级目录

删除目录

File dir = new File("e:\hello\da\shu\dashu)";
boolean b = dir.delete();// 注意删除目录,无法直接删除,只能删除最后一个目录
如果目录中还有目录,也不能一次性删除

要判断是文件还是目录

File.isFile(); // 判断是否是文件File.isDirectory(); // 判断是否是目录

为啥要判断呢?

File file = new File("e:\hello.txt");// hello.txtFile file = new File("e:\hello");// hello也可以是文件哦~给个
file.createNewFile();// 就可以创建了哦~没有扩展名的文件

因为这个可以是目录也可以是文件啊~不信自己建立一个,叫名为hello.txt的目录试试.

使用方法

File dir = new File("e:\java");// 遍历目录,获取目录文件名String[] names = dir.list();for(String name : names) {
 System.out.println(name);
}

listFiles():
返回类型为File[]
返回一个抽象路径名数组,路径名

File dir = new File("e:\java");
File[] files = dir.listFile();for(Files file : files){
 System.out.println(file.getName());
}// 如果目录不存在抛出: 
java.lang.NullPointerException// Java的健壮性要进行健壮性的判断,防止错误

对文件进行过滤,进行筛选

// 获取目录下的所有文件File dir = new File("e:\java");
File[] files = dir.listFiles();for(Files file : files){ // 进行筛选  
 if(file.getName().endsWith(".java")){
  System.out.println(file.getName());
 }
}

listFiles()
返回类型为File[]
返回一个抽象路径名的数组,路径名为表示此抽象路径名表示的目录中的文件

listFiles(FileFilter filter)
返回为File[]
返回为抽象路径名数组,这些路径名表示此抽象路径名表示的目录中满足指定的过滤器的文件和目录

listFiles(FilenameFilter filter)
返回为File[]
返回为抽象路径名数组,这些路径名表示此抽象路径名表示的目录中满足指定的过滤器的文件和目录

接口FilenameFilter

java.io
接口FilenameFilterpublic interface FilenameFilter

方法:

acceptboolean accept(File dir, String name)参数:
dir为文件所在目录
name为文件名

public class FilenameFilterByJava implements FilenameFilter { @Override
 public boolean accept(File dir, String name) {  return name.endsWith(".java");
 }
}

File dir = new File("E:\java");
File[] files = dir.listFiles(new FilenameFilterByJava());for(File file : files){
 System.out.println(files.getName());
}

listFiles内部代码

public File[] listFiles(FilenameFilter filter){ // 使用了File类中的方法list(),获取了所有名称数组
 String s[] = list();// 健壮性判断
 if(s == null) return null; // 创建一个集合,类型为File类型
 ArrayList<File> files = new ArrayList<>(); // 遍历数据名字
 for(String str : s)  if((filter == null) || filter.accept(this, s))
   files.add(new File(s, this));  // 集合转数组,不用增删操作
  return files.toArray(new File[files.size()]);
}

public class FilenameFilterByBuffix implements FilenameFilter { private String suffix; public FilenameFilterByBuffix(String suffix){  super();  this.suffix = suffix;
 } @Override
 public boolean accept(File dir, String name){  return name.endsWith(suffix);
 }
}

// 这时候改为File dir = new File("E:\java");// File[] files = dir.listFiles(new FilenameFilterByJava());File[] files = dir.listFiles(new FilenameFilterByBuffix(".java"));

文件夹过滤

public class FileFilterByDir implements FileFilter{ @Override 
 public boolean accept(File pathname){  return pathname.isDirectory();
 }
}

public class FileMethodDemo{
 public static void main(String[] args){
  File dir = new File("E:\java");
  File[] files = dir.listFiles( new FileFilterByDir() );  for(File file : files){
   System.out.println(file);
  }
 }
}

FileTest

public class FileTest{
 public static void main(String[] args){
  File dir = new File("E:\java");
  File[] files = dir.listFiles();  // 遍历
  for(File file :  files){   if(file.isDirectory()){

    File[] filess = file.listFiles();
    fot(File f : filess){
     System.out.println(f.getName());
    }
   }
   System.out.println(file.getName());
  }
 }
}

升华

File dir = new File("e:\java");
listAll(dir);// 创建一个方法public static void listAll(File dir){
 System.out.println("dir:" + dir.getName());
 File[] files = dir.listFiles(); for(File file : files){ 
  if(file.isDirectory()){
   listAll(file);
  }else{
   System.out.println("file:" + file.getName());
   } 
 }
}

File 类中的方法

// onepublic static void main(String[] args){
 show();
}public static void show(){
 show();
}// java.lang.StackOverflowError栈内存溢出// twopublic static void main(String[] args){
 show();
}public static void show(){
 showdashu();
}public static void showdashu(){
 show();
}

求和新大陆

public static void main(String[] args){ // 总和
 int sum = getSum(4);
 System.out.println("sum="+sum);
}public static int getSum(int num){ // 如果求和数字,导入为1,则返回为1
 if(num == 1){  return 1;
 } // 求和
 return num + getSum(num-1);
}

// 4int getSum(4){ if(4==1){  return 1;
 } return 4 + getSum(4-1);
}// 3int getSum(3){ if(3==1){  return 1;
 } return 3 + getSum(3-1);
}// 2int getSum(2){ if(2==1){  return 1;
 } return 2 + getSum(2-1);
}// 1 int getSum(1){ if(1==1){  return 1;
 } return 1 + getSum(1-1);
}// 注意如果数字大,就会不断进栈,会导致栈溢出

队列

遍历子目录,如果有子目录就将目录存储到容器中,然后遍历容器,从容器中取出子目录,递归的方法,容易将栈溢出.如果在容器中目录中没有目录了,就可以取出来了.

队列结构,先进先出

// 泛型class Queue<E>{
 // 构造队列对象
 private LinkedList<E> link; public Queue(){
  link = new LinkedList<E>();
 } // 添加元素
 public void myAdd(E obj){  //第一个
  link.addFirst(obj);
 } // 获取
 public E myGet(){  // 最后
  return link.removeLast();
 }// 进行判断
 public boolean isNull(){  return link.isEmpty();
 }
}

File dir = new File("e:\java");
Queue<File> queue = new Queue<File>();// 遍历目录File[] files = dir.listFiles();for(File file : files){ // 判断有子目录,就存储到队列中
 if(file.isDirectory()){  queue.myAdd(file);
}else{
 System.out.println(file.getName());
}
}
System.out.println(queue.isNull());// 遍历while(!queue.isNull()){ // 遍历子目录
 File subDir = queue.myGet();
 File[] subFiles = subDir.listFiles(); for(File subFile : subFiles){  if(subFile.isDirectory()){   // 继续将子目录存储到队列中
   queue.myAdd(subFile);
   }else{
    System.out.println(subFile.getName());
   }
  }
 }
}

IO流-数据存储操作

输入输出流-IO流操作:输出output,输入input

java.io 为通过数据流,序列化和文件系统提供系统输入和输出的

java.io类 OutputStreamjava.lang.Object-> java.io.OutputStream实现的接口:Closeable,Flushable知道的子类ByteArrayOutputStream,FileOutputStream,FilterOutputStream,ObjectOutputStream,OutputStream,FiledOutputStream

public abstract class OutputStreamextends Objectimplements Closeable, Flushable

抽象类OutputStream表示为输出字节流的所有类的超类,构造方法OutputSteam(),操作字节

OutputStream为输出字节流的超类,是操作字节数据的,具有输出字节流的基本功能哦~

public abstract class OutputStreamextends Objectimplements Closeable, Flushable输出流是把这些字节发送到某个接收器中

方法:

从类java.lang.Object 继承的方法有:

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait,

FileOutputStream
往文件写

public class FileOutputStreamDemo{ public static void main(String[] args){  // 创建文件夹
  File dir = new File("hello");  // 健壮性
  if(!dir.exists()){
   dir.mkdir();
  }  // 创建文件
  File file = new File(dir,"hello.txt");  // 用于创建操作文件的字节输出流对象
  // 输出流创建文件,不存在就创建新的,存在就删掉进行覆盖
  FileOutputStream fos = new FileOutputStream(file);  // 调用父类的write
 byte[] data = "dashucoding".getBytes();
 fos.write(data) // 关闭流
 fos.close();
 }
}

作者：达叔小生
链接：https://www.jianshu.com/p/c30ad72499c1