IO流

File类

File更应该叫做一个路径（文件路径或者文件夹路径）

构造方法

File(String pathname)    //根据一个路径得到File对象
File(String parent, String child)    //根据一个目录和一个子文件/目录得到File对象
File(File parent, String child)    //根据一个父File对象和一个子文件/目录得到File对象

创建

public
4000
boolean createNewFile()     //创建文件 如果存在这样的文件，就不创建了
public boolean mkdir()      //创建文件夹 如果存在这样的文件夹，就不创建了
public boolean mkdirs()    //创建文件夹,如果父文件夹不存在，会帮你创建出来

重命名

public boolean renameTo(File dest)    //把文件重命名为指定的文件路径

如果路径名相同，就是改名；如果路径名不同，就是改名并剪切。

删除

public boolean delete()    //删除文件或者文件夹

要删除一个文件夹时，该文件夹内必须为空

判断

public boolean isDirectory()    //判断是否是目录
public boolean isFile()    //判断是否是文件
public boolean exists()    //判断是否存在
public boolean canRead()    //判断是否可读
public boolean canWrite()    //判断是否可写
public boolean isHidden()    //判断是否隐藏

获取

public String getAbsolutePath()    //获取绝对路径
public String getPath()     //获取路径
public String getName()    //获取名称
public long length()    //获取长度。字节数
public long lastModified()    //获取最后一次的修改时间，毫秒值
public String[] list()    //获取指定目录下的所有文件或者文件夹的名称数组
public File[] listFiles()    //获取指定目录下的所有文件或者文件夹的File数组

文件名称过滤器

public String[] list(FilenameFilter filter)
public File[] listFiles(FileFilter filter)

例如：判断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称

IO流

IO流常用父类

字节流的抽象父类：

InputStream
OutputStream

字符流的抽象父类：

Reader
Writer

IO程序书写

使用前，导入IO包中的类
使用时，进行IO异常处理
使用后，释放资源

FileInputStream

read()一次读取一个字节。

FileInputStream fis = new FileInputStream("aaa.txt");   //创建一个文件输入流对象,并关联aaa.txt
int len;                                                  //定义变量,记录每次读到的字节
while((len = fis.read()) != -1) {                         //将每次读到的字节赋值给b并判断是否是-1
System.out.println(b);                              //打印每一个字节
}
fis.close();                                            //关闭流释放资源

read()方法读取的是一个字节,为什么返回是int,而不是byte:
因为字节输入流可以操作任意类型的文件,比如图片音频等,这些文件底层都是以二进制形式的存储的,如果每次读取都返回byte,有可能在读到中间的时候遇到111111111，那么这11111111是byte类型的-1,我们的程序是遇到-1就会停止不读了,后面的数据就读不到了,所以在读取的时候用int类型接收,如果11111111会在其前面补上24个0凑足4个字节,那么byte类型的-1就变成int类型的255了这样可以保证整个数据读完,而结束标记的-1就是int类型。

FileOutputStream

write()一次写出一个字节。

FileOutputStream fos = new FileOutputStream("bbb.txt"); //如果没有bbb.txt,会创建出一个
//fos.write(97);   //虽然写出的是一个int数,但是在写出的时候会将前面的24个0去掉,所以写出的一个byte
fos.write(98);
fos.write(99);
fos.close();

FileOutputStream追加

FileOutputStream的构造方法写出数据如何实现数据的追加写入。

FileOutputStream fos = new FileOutputStream("bbb.txt",true);    //如果没有bbb.txt,会创建出一个
//fos.write(97);    //虽然写出的是一个int数,但是在写出的时候会将前面的24个0去掉,所以写出的一个byte
fos.write(98);
fos.write(99);
fos.close();

拷贝文件，FileInputStream读取，FileOutputStream写出

FileInputStream fis = new FileInputStream("a.mp3");   //创建输入流对象,关联a.mp3
FileOutputStream fos = new FileOutputStream("copy.mp3");   //创建输出流对象,关联copy.mp3
int len;
while((len = fis.read()) != -1) {
fos.write(len);
}
fis.close();
fos.close();

字节数组拷贝之available()方法

int read(byte[] b)    一次读取一个字节数组
write(byte[] b)    一次写出一个字节数组
available()    获取读的文件所有的字节个数
      弊端:有可能会内存溢出

FileInputStream fis = new FileInputStream("a.mp3");
FileOutputStream fos = new FileOutputStream("copy.mp3");
byte[] arr = new byte[fis.available()];    //根据文件大小做一个字节数组
fis.read(arr);    //将文件上的所有字节读取到数组中
fos.write(arr);   //将数组中的所有字节一次写到了文件上
fis.close();
fos.close();

BufferedInputStream和BufferOutputStream拷贝

缓冲思想

字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区效果，java本身在设计的时候，也考虑到了这样的设计思想(装饰设计模式后面讲解)，所以提供了字节缓冲区流.
BufferedInputStream
BufferedInputStream内置了一个缓冲区(数组)，从BufferedInputStream中读取一个字节时，BufferedInputStream会一次性从文件中读取8192个, 存在缓冲区中, 返回给程序一个，程序再次读取时, 就不用找文件了, 直接从缓冲区中获取，直到缓冲区中所有的都被使用过, 才重新从文件中读取8192个。
BufferedOutputStream
BufferedOutputStream也内置了一个缓冲区(数组)，程序向流中写出字节时, 不会直接写到文件, 先写到缓冲区中，直到缓冲区写满, BufferedOutputStream才会把缓冲区中的数据一次性写到文件里。

FileInputStream fis = new FileInputStream("a.mp3");          //创建文件输入流对象,关联a.mp3
BufferedInputStream bis = new BufferedInputStream(fis);      //创建缓冲区对fis装饰
FileOutputStream fos = new FileOutputStream("copy.mp3");     //创建输出流对象,关联copy.mp3
BufferedOutputStream bos = new BufferedOutputStream(fos);    //创建缓冲区对fos装饰
int len;
while((len = bis.read()) != -1) {
bos.write(len);
}
bis.close();     //只关装饰后的对象bis,bos即可
bos.close();

小数组的读写和带Buffered的读取哪个更快?

定义小数组如果是8192个字节大小和Buffered比较的话，定义小数组会略胜一筹,因为读和写操作的是同一个数组，而Buffered操作的是两个数组

flush()方法

用来刷新缓冲区的,刷新后可以再次写出

close()方法

用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会在关闭流之前刷新缓冲区,关闭后不能再写出

图片加密

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.jpg"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.jpg"));
int len;
while((len = bis.read()) != -1) {
bos.write(len ^ 123);
}
bis.close();
bos.close();

拷贝文件

File file = new File("C:/a.jpg");                 //封装成File对象
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(file.getName());
int len;
byte[] arr = new byte[8192];                //定义缓冲区
while((len = fis.read(arr)) != -1) {
fos.write(arr,0,len);
}
fis.close();
fos.close();

http://www.itheima.com/apply/21272.html
http://bbs.itheima.com/thread-271031-1-1.html