黑马程序员——Java基础--------IO流（二）

-------android培训、java培训、期待与您交流！ ----------

IO流（二）

标准输入输出流

System类中的字段：in out，它们代表了系统标准的输入和输出设备

System.in标准输入流，默认设备，键盘

System.out标准输出流，默认设备，屏幕

获取用户键盘录入数据，并将数据打印在控制台上，如果用户输入的是over，结束

package IO;

import java.io.IOException;
import java.io.InputStream;

public class ReadKey {

public static void main(String[] args) throws IOException {
//1，创建容器。
StringBuilder sb = new StringBuilder();

//2，获取键盘读取流。
InputStream in = System.in;

//3，定义变量记录读取到的字节，并循环获取。
int ch = 0;

while((ch=in.read())!=-1){

//			在存储之前需要判断是否是换行标记 ,因为换行标记不存储。
if(ch=='\r')
continue;
if(ch=='\n'){
String temp = sb.toString();
if("over".equals(temp))
break;
System.out.println(temp.toUpperCase());
//清空缓冲区
sb.delete(0, sb.length());
}else{

//加入否则，不是换行存，是换行不存
//将读取到的字节存储到StringBuilder中。
sb.append((char)ch);
}

}
System.out.println(sb.toString());

}

}

转换流：字节与字符之间的桥梁

InputStreamReader将字节转成字符的桥梁

OutputStreamWriter将字符流转成字节流的桥梁

当字节流中的数据都是字符时，转成字符流操作更高效

IO流的操作规律总结：

1，明确体系：

数据源：InputStream ，Reader

数据汇：OutputStream，Writer

2，明确数据：因为数据分两种：字节，字符。

数据源：是否是纯文本数据?

是：Reader

否：InputStream

数据汇：

是：Writer

否：OutputStream

到这里就可以明确具体要使用哪一个体系了。

剩下的就是要明确使用这个体系中的哪个对象。

3，明确设备：

数据源：

键盘：System.in

硬盘：FileXXX

内存：数组。

网络：socket  socket.getInputStream();

数据汇：

控制台：System.out

硬盘：FileXXX

内存：数组

网络：socket socket.getOutputStream();

4，明确额外功能：

1，需要转换？是，使用转换流。InputStreamReader OutputStreamWriter

2，需要高效？是，使用缓冲区。Buffered

将键盘录入的数据写入到一个文件中。

package IO;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;

public class TransStreamDemo {

public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//键盘录入写到文件中，操作的数据是文本数据，源是System.in，所以用到转换流，为了高效，用缓存
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

//创建字符输出流，与目的想关联
BufferedWriter bw = new BufferedWriter(new FileWriter("F://Demo.txt"));

String s = null;
while((s=br.readLine())!=null){
bw.write(s);
bw.newLine();
bw.flush();
}

//关闭流
br.close();
bw.close();
}

}

当用到指定编码表的时候，必须使用转换流，在构造对象是，要指定编码表

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(F://Trans.txt),"GBK");

高效:

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(F://Trans.txt),"utf-8"));

InputStreamReader isr = new InputStreamReader(new FileInputStream("F://Trans.txt"),"GBK");

结合：

BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("F://Trans.txt"),"GBK"));

什么时候用转换流：

1.源或者目的对应的设备是字节流，但操作的是文本数据，可以使用转换流作为桥梁，提高对文本操作的便捷

2.一旦操作的文本涉及到具体的指定编码表时，要使用转换流

File类：

用来将文件或者文件夹封装成对象

方便对文件与文件夹的属性信息进行操作

File对象可以作为参数传递给流的构造函数

File的构造函数可以将一个已存在，或者不存在的文件或者目录封装成File对象

File对象的常见方法。

1，获取。

1.1 获取文件名称。String getName()

1.2 获取文件路径。String getAbsolutePath()绝对路径,getPath()相对路径。

1.3 获取文件大小。lenth();返回类型long

1.4 获取文件修改时间。lastModified()最后一次修改的时间；返回类型long

2，创建与删除。

创建文件createNewFile()要拋IO异常，返回类型是boolean，真创建，假不创建

createTempFile(String prefix, String suffix)在默认临时文件目录中创建一个空文件，使用给定前缀和后缀名

createTempFile(String prefix, String suffix, File directory(路径)) 在指定目录中创建一个文件，使用给定的前缀和后缀名

Delete()删除文件,返回类型boolean，也得有IO异常

deleteOnExit() 文件创建了，在虚拟机退出时将其删掉

创建文件夹

创建文件夹mkdir,返回类型boolean，创建单级目录

创建多级目录mkdirs

删除文件夹delete,如果里面有文件不会删，但里面要是空文件夹就把最里面删掉

如果文件正被流所操作，也删不掉

3，判断。

exists():是否存在
isFile()：是不是文件呢
isDirectory():是否是路径

 4， 重命名

renameTo(File)返回boolean,如果不是一个盘或者文件夹就是剪切

package IO;

import java.io.File;
import java.io.IOException;

public class FileDemo {

public static void main(String[] args) throws IOException {
//创建一个File对象
File f = new File("F://Demo.txt");
//创建文件
f.createNewFile();
//获取绝对路径
System.out.println(f.getAbsolutePath());//F:\Demo.txt
//获取父类路径
System.out.println(f.getParent());//F:\
//获取文件名
System.out.println(f.getName());//Demo.txt
//获取文件大小
System.out.println(f.length());//0
//获取修改时间
System.out.println(f.lastModified());//1441540562602
//判断是否存在
System.out.println(f.exists());//true
//判断是否是文件
System.out.println(f.isFile());//true
//判断是否是目录
System.out.println(f.isDirectory());//false

}

}

5，listRoots():返回可用文件系统根目录的数组
list():返回当前目录下的文件名称文件夹名称(包括隐藏文件)的字符串数组
listFiles():返回当前目录的文件数组

package IO;

import java.io.File;

public class FileList {

public static void main(String[] args) {
//获取根目录
for(File file:File.listRoots()){
System.out.println(file.toString());
}
//获取目录下文件名
File f = new File("F://");
for(String s :f.list()){
System.out.println(s);
}
//获取目录下文件
for(File ff:f.listFiles()){
System.out.println(ff.toString());
}
}

}

过滤器接口

FileFilter和FilenameFilter

实现他们的类可用于过滤器指定的文件，

将FileFilter或FilenameFilter的实例传递给listFiles()，list()即可

获取指定目录下的Java文件

package IO;

import java.io.File;
import java.io.FilenameFilter;

public class FilterByJava implements FilenameFilter {

String name;

public FilterByJava(String name) {
super();
this.name = name;
}

@Override
public boolean accept(File dir, String name) {
// TODO Auto-generated method stub
return name.endsWith(this.name);
}

}

package IO;

import java.io.File;

public class FilterDemo {

public static void main(String[] args) {

File f = new File("F://");

File[] ff=f.listFiles(new FilterByJava("java"));

for(File file : ff){
System.out.println(file.toString());
}

String [] s = f.list(new FilterByJava("java"));
for(String ss:s){
System.out.println(ss);
}
}

}

递归：函数自身直接或间接调用到自身，就是递归

什么时候用:

一个功能在被重复使用，并每次使用时，参与运算的结果和上一次调用有关。 这时可以用递归来解决问题。

注意：

1，递归一定明确条件。否则容易栈溢出。 

2，注意一下递归的次数

深度遍历：遍历目录中所有的内容

删除一个目录中的所有文件

package IO;

import java.io.File;

public class RemoveDirTest {

public static void main(String[] args) {

File dir  = new File("G:\\A");
//如果不是目录，输出，不是目录文件
if(!dir.isDirectory()){
System.out.println("清输入正确目录");
}
removeDir(dir);
}

public static void removeDir(File dir) {
//获取目录中所有文件
File[] files = dir.listFiles();

for(File file : files){
//如果是文件夹，递归操作
if(file.isDirectory()){
removeDir(file);
}else{
System.out.println(file+":"+file.delete());
}
}
System.out.println(files);
System.out.println(dir+":"+dir.delete()+"haha");//干掉文件夹
}

}