第53节:Java当中的IO流(上)

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

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

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

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

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

File
public 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

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

// 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

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
public static final String separator
与系统有关的默认 -> 名称分隔符,表示为字符串

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

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

File.pathSeparator: -> String-File
File.pathSeparatorChar: -> char-File
Separator: -> String-File
SeparatorChar: -> char-File
class: -> Class<java.io.File>
File.listRoots(): -> File[]-File

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

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

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
// 如果想要什么路径可以用改方法,自己也可以查api
System.out.println(file.getAbsolutePath());
// 可以得到结果 默认路径

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.IOException
public 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);

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

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

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());
 }
}

java.io
接口FilenameFilter
public interface FilenameFilter

accept
boolean 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());
}

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);
  }
 }
}

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());
   } 
 }
}

// one
public static void main(String[] args){
 show();
}
public static void show(){
 show();
}
// java.lang.StackOverflowError
栈内存溢出
// two
public 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);
}

// 4
int getSum(4){
 if(4==1){
  return 1;
 }
 return 4 + getSum(4-1);
}
// 3
int getSum(3){
 if(3==1){
  return 1;
 }
 return 3 + getSum(3-1);
}
// 2
int 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());
   }
  }
 }
}

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

public abstract class OutputStream
extends Object
implements Closeable, Flushable

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

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

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();
 }
}

public FileOutputStream(File file, boolean append) throws FileNotFoundException

public class FileOutputStreamDemo{
 // 定义常量
 private static final String LINE_SEPARATOR = System.getProperty("line.separator");

 public static void main(String[] args){
  // FileOutputStream(File file, boolean append)
  File file = new File("hello\\hello.txt");
  FileOutputStream fos = new FileOutputStream(file,true);
  // 换行
  String str = LINE_SEPARATOR + "dashu";
  
  // fos.write("dashucoding".getBytes());
  fos.write(str.getBytes());
  // fos.write("\r\n hahahadashucoding".getBytes());
  fos.close();
 }
}

public class FileOutputStreamDemo{
 File file = new File("hello\\hello.txt");
 // 异常
 FileOutputStream fos = null;
 try {
 fos = new FileOutputStream(file);
 fos.write("dashucoding".getBytes());
 // 捕捉
 }catch (IOException e){
  System.out.println(e.toString());
 }finally{
 // 健壮性
 if(fos != null){
 
  try{
  fos.close();
 }catch(IOException e){
  throw new RuntimeException("");
 }
 }
 } 
}

java.io
类 InputStream
java.lang.Object
-> java.io.InputStream

public abstract class InputStream extends Object implements Closeable

public abstract int read() throws IOException
返回为下一个数据字节
抛出定位IOException

java.io
类 FileInputStream
java.lang.Object
-> java.io.InputStream
-> java.io.FileInputStream

public class FileInputStream extends InputStream

FileInputStream(File file)
FileInputStream(FileDescriptor Obj)
FileInputStream(String name)

public class FileInputStreamDemo{
 public static void main(String[] args) throws IOException {
  // 创建文件,读取文件中的数据
  File file = new File("hello\\hello.txt");
  // 创建一个字节输入流对象
 FileInputStream fis = new FileInputStream(file);
 // 读取数据
 int char = fis.read();
 System.out.println(char);
 // 关闭资源
 fis.close();
 }
}

int c1=fis.read();
// (char)c1
int c2=fis.read();
// (char)c2
一直返回到-1为止

int char = 0;
while( (char=fis.read()) != -1){
 System.out.println("char="+(char)char);
}

read
public int read(byted[] b) throws IOException
从输入流中读取一定数量的字节
参数b为缓冲区

String(byte[] bytes)
String(byte[] bytes, int offset, int length)

java.lang.StringIndexOutOfBoundsException

File file = new File("hello\\hello.txt");
FileInputStream fis = new FileInputStream(file);
byte[] buff = new byte[1024];
int len = 0;
while( (len = fis.read(buff)) != -1){
 System.out.println(new String(buff,0,len));
}

// file.txt
FileInputStream fis = new FileInputStream("file.txt");

// copy_file.txt
FileOutputStream fos = new FileOutputStream("copy_file.txt");

public class CopyFileDemo{
 public static void main(String[] args) throws IOException{
  File srcFile  = new File("file.txt");
  File desFile = new File("copy_file.txt");
  //  字节流输入流,输出流
 FileInputStream fis = new FileInputStream(srcFile);
 FileOutputStream fos = new FileOutputStream(desFile);
 // 输入流
 int ch = 0;
 while( (ch=fis.read()) != -1){
  fos.write(ch)
 }
 // 关闭资源
 fos.close();
 fis.close();
}

write(byte[] b)
write(byte[] b, int off, int len)
write(int b)

public class CopyFileByBufferDemo{
 public static void main(String[] args) throws IOException {
  File srcFile = new File("file.txt");
  File desFile = new File("copy_file.txt");
 FileInputStream fis = new FileInputStream(srcFile);
 FileOutputStream fos = new FileOutputStream(desFile);
 // 缓冲区 
byte[] buff = new byte[1024];
 int len = 0;
 while( (len=fis.read(buff) != -1){
  fos.write(buff,0,len);
 }
 fos.close();
 fis.close();
 }
}

public int available() throws IOException
抛出IO错误

public class ByteStreamDemo{
 public static void main(String[] args) throws IOException {
  // 字节输入流 available()
 FileInputStream fis = new FileInputStream("hello.txt");
 // 可以打印出文件的大小
 System.out.println(fis.available());
 fis.close();
 } 
}

byte[] buff = new byte[fis.available()]; 
// 但是建议不使用,只可以去获取相关文件的大小
fis.read(buff);
String str = new String(buff);
System.out.println(str);