黑马程序员---IO流（二）

------<a href="http://www.itheima.com"
target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一、字节流

1，字节流的基本对象：InputStream，OutputStream。

BufferedInputStream，BufferedOutputStream。

package 博客9_IO流二;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class 字节流读写Demo
{
public static void main(String[] args) throws IOException
{
//WriteFile();
//ReadFile_1();
//ReadFile_2();
ReadFile_3();

}
public static void ReadFile_3() throws IOException
{
FileInputStream fis = new FileInputStream("Write.txt");
byte [] by = new byte[fis.available()];//定义一个大小刚好的缓冲区，但是这样做容易内存溢出，需要小心
fis.read(by);
System.out.println(new String(by));
fis.close();
}
public static void ReadFile_2() throws IOException
{
FileInputStream fis = new FileInputStream("Write.txt");
byte [] by = new byte[1024];
int len = 0;
while((len=fis.read(by))!=-1)
{
System.out.println(new String(by,0,len));
}
fis.close();
}
public static void ReadFile_1()throws IOException
{
FileInputStream fis = new FileInputStream("Write.txt");
int ch = 0;
while((ch=fis.read())!=-1)
{
System.out.println((char)ch);
}
fis.close();
}
public static void WriteFile()throws IOException
{
FileOutputStream fops = new FileOutputStream("Write.txt");
fops.write("abcdefg".getBytes());
//注意：字节流在写入的时候和字符流不同，即便是不刷新，写入文档里也会有内容。
fops.close();
}
}

2，自定义字节流缓冲区。

<pre name="code" class="java" style="font-size: 14px;">package 博客9_IO流二;
import java.io.*;
class MyBufferedInputStream
{
private InputStream in;
private int count=0,pos=0;
private byte[] buf = new byte[1024];
MyBufferedInputStream(InputStream in)
{
this.in = in;
}
public int myRead() throws IOException
{
//通过in对象读取数据，并存储到硬盘中
if(count == 0)
{
count = in.read(buf);
if(count<0)
return -1;
pos=0;
byte b = buf[pos];
count--;
pos++;
return b&255;//在返回值的前面补0，否则会复制失败
}
else if(count>0)
{
byte b = buf[pos];
count--;
pos++;
return b&255;
}
return -1;
}
public void Myclose() throws IOException {
// TODO Auto-generated method stub
in.close();
}
}
class MyBufferedInputStreamText
{
public static void main(String[] args)throws IOException
{
copy();
}
public static void copy() throws IOException
{
MyBufferedInputStream mbr = new MyBufferedInputStream(new FileInputStream("HashSetDemo.java"));
BufferedOutputStream bufs = new BufferedOutputStream(new FileOutputStream("Writer_2.java"));
int b = 0;
while((b=mbr.myRead())!=-1)
{
bufs.write(b);
}
mbr.Myclose();
bufs.close();
}
}

<strong><span style="font-size:18px;">二、读取键盘录入</span></strong>1，读取键盘录入：
System.out：对应的是标准的输出设备，控制台。

System.in：对应的是标准输入设备，键盘。

package 博客9_IO流二;

import java.io.IOException;
import java.io.InputStream;
/*
* 需求：当录入一行数据后，就将该数据打印，如果录入的是“over”的话，则程序停止
* */
public class 键盘录入
{
public static void main(String[] args)throws IOException
{
InputStream in = System.in;
StringBuilder sb = new StringBuilder();
while(true)
{
int ch = in.read();
if(ch=='\r')
{
continue;
}
if(ch=='\n')
{
String s = sb.toString();
if("over".equals(s))
break;
System.out.println(s.toUpperCase());
sb.delete(0,sb.length());
}
else
sb.append((char)ch);
}
}
}
2，读取转换流：用转换流的方式简化上述代码。

package 博客9_IO流二;

import java.io.*;

public class 转换流 {

public static void main(String[] args)throws IOException {
// TODO Auto-generated method stub
//获取键盘录入对象，使用转换流，并将字符串存入缓冲区
BufferedReader bufr= new BufferedReader(new InputStreamReader(System.in));
String line = null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
System.out.println(line.toUpperCase());
}
bufr.close();
}
}

3，流操作的基本规律：通过两个明确来完成。
a，明确源和目的。

源：输入流。InputStream Reader。

目的：输出流。OutputStream Writer。

b，操作的数据是否是纯文本。

是：字符流

不是：字节流

c：当体系明确后，再明确要使用哪个具体的对象，并通过设备来区分。

源设备：内存，硬盘，键盘。

目的设备：内存，硬盘，控制台。
三、File类简述

File类：用来将文件或者文件夹封装成对象的类，方便对文件与文件夹的属性信息进行操作。File对象可以作为参数传递给流的构造函数。

File类的特点：可以将已有的或者还没有的文件或者文件夹封装成对象。

创建File类对象：File f = new File("文件名“）或者File f = new File（”目录“，”文件名“）

目录分隔符：File.separator。

File类的常见方法：

1，创建：File.createNewFile（）；在指定位置创建文件，如果该文件已经存在，则创建失败，返回false。

mkdir（）；创建单级目录的文件夹。

mkdirs（）；创建多级目录的文件夹。

2，删除：Boolean delete（）；deleteOnExit（）；程序结束时删掉。

3，判断：canExecute（）；判断文件是否能执行。

boolean exists（）；判断文件是否存在。

isDirectory（）；判断是不是目录。

isFile（）；判断是不是文件。

注意：在判断文件对象是否是文件或者目录时，必须要 先判断该文件对象封装的内容是否存在。

4，获取信息：getName（）；getPath（）；lastModified（）；--->最后一次修改的时间。length（）；

getParent（）；该方法返回的是绝对路径中的父目录，如果获取的是相对路径，则返回为空。

四、递归

需求：列出指定目录下文件或者文件夹，要求包含子目录中的内容。

因为目录中还有目录，所以只要使用同一个列出目录功能的函数完成即可。在列出过程种出现的还是目录的话，可以再次调用本功能，也就是函数自身调用自身，这种编程手法，即成为递归。

使用递归时应注意：

1，限定递归条件。

2，要注意递归的次数，避免内存溢出。package 博客9_IO流二;
import java.io.*;
public class 递归
{
public static void main(String[] args)throws IOException
{
File dir = new File("f:\\java学习");
showDir(dir);
}
public static void showDir(File dir)
{
System.out.println(dir);
File [] files = dir.listFiles();
for(int x = 0 ; x < files.length;x++)
{
if(files[x].isDirectory())
showDir(files[x]);//递归，再次调用showDir函数来获取子目录
else
System.out.println(files[x]);
}
}
}