java--IO流（1）--黑马程序员

时间：2015-08-07 00:05:21 阅读：212 评论：0 收藏：0 [点我收藏+]

标签：

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

IO流（1）

主要内容：《异常的处理、Finally语句、File类创建功能、删除功能、重命名功能、判断功能、基本获取功能、高级获取功能、文件过滤器、递归、IO流基类、FileOutputStream 》

1.异常的处理

1.在main方法中，使用try...catch处理可能会发生的异常。
也用来捕获调用方法时，被抛出的异常；
2.在方法内部：建议：可以"捕获"异常，但不要"处理"。使用throws或throw抛出，由调用方去处理；

2.finally语句

格式：
try{
可能出现异常的代码
读取网络信息：
1.打开网络连接；
2.读取网络数据；
3.关闭网络连接；
}catch(异常类型变量名){
异常出现时，被执行的代码；
}finally{
这里代码的特点：无论是否发生异常，都会被执行的代码；
一般将释放资源等一些的相关代码放到这里；
}

 1 public class Demo {
 2     public static void main(String[] args) {
 3         int a = 10;
 4         int b = 2;
 5         try{
 6             System.out.println(a / b);
 7         }catch(ArithmeticException e){
 8             System.out.println("出现异常了，这里是catch语句，异常信息：" + e.getMessage());
 9         }finally{
10             System.out.println("这里是finally语句，无论是否发生异常，都会被执行的语句！");
11         }
12     }
13 }

3.异常的注意事项--子类重写父类方法时

1.父类方法没有抛出异常：
子类：
1.可以不抛出任何异常；
2.可以抛出任何的运行时异常；
3.不能抛出"非运行时异常"；
2.父类方法抛出"运行时异常":
子类：
1.可以不抛出任何异常；
2.可以抛出任何的运行时异常；
3.不能抛出"非运行时异常"；
3.父类方法抛出"非运行时异常"：
子类：
1.可以不抛出任何异常；
2.可以抛出任何的运行时异常；
3.可以抛出跟父类相同的"非运行时异常"，不能抛出比父类更多的"非运行时异常"；

总结：
无论父类是否抛出异常：
子类：1.可以不抛出任何异常；
2.可以抛出任何的运行时异常；
如果父类抛出的是"非运行时异常"：
子类：可以抛出跟父类相同的"非运行时异常"，不能抛出比父类更多的"非运行时异常"；

4.File类

java.io.File类：

1.它代表磁盘上的"文件"或"目录"；
2.它内部封装了一些方法，可以查看此"文件"或"目录"的一些信息：
文件/目录是否存在、判断是"文件"还是"目录"、文件\目录大小、修改时间、是否可读、是否可写....

3.构造方法：
public File(String pathname):
public File(String parent,String child)
public File(File parent,String child)

 1 public class Demo {
 2     public static void main(String[] args) {
 3         //1.public File(String pathname)
 4         File file1 = new File("D:\\output.txt");//绝对路径；
 5         File file2 = new File("output.txt");//相对路径；位置在：应用程序根目录；
 6         
 7         //2.public File(String parent,String child)
 8         File file3 = new File("D:\\","output.txt");//效果同file1
 9         
10         //3.public File(File parent,String child)
11         File file4 = new File("D:\\");//OK的，构造一个"目录"
12         File file5 = new File(file4,"output.txt");//效果同file3和file1
13         
14         //******************注意：***************************
15         //File的构造方法接收的是String,是否是有效的路径无所谓，后期可以通过File内部的一些方法进行判断；
16         //下面的构造是不会抛出异常的；
17         File file6 = new File("jfdafjsak;jfds;lajfioe;ajf;lsajfkdsa;lj");
18         
19         System.out.println("程序结束");
20     }
21 }

5.File类_创建功能

创建功能
public boolean createNewFile()：创建文件
public boolean mkdir()：创建目录
public boolean mkdirs()：创建多级目录

 1 public class Demo {
 2     public static void main(String[] args) throws IOException {
 3         File file1 = new File("D:\\aaa.txt");//绝对路径：
 4         
 5         //1.public boolean createNewFile()
 6         boolean b1 = file1.createNewFile();
 7     //    System.out.println("创建文件结果：" + b1);
 8         
 9         File file2 = new File("aaa.txt");//相对路径：在项目根目录下创建aaa.txt
10         file2.createNewFile();
11         
12         //2.public boolean mkdir()
13         File file3 = new File("test");
14     //    file3.createNewFile();//仍然建立的是文件，只不过没有后缀名；
15         file3.mkdir();//建立目录
16         
17         File file4 = new File("aaa\\bbb\\ccc");
18     //    file4.mkdir();//多级目录，不能使用此方法
19         System.out.println("建立多级目录：" + file4.mkdirs());
20         
21     }
22 }

6.File类——删除功能

public boolean delete():用于删除"文件"和"目录"。
如果删除目录，不能删除多级目录；如果要删除多级目录，后期我们使用"递归方法"

 1 public class Demo {
 2     public static void main(String[] args) {
 3         File file1 = new File("aaa.txt");
 4         System.out.println("删除文件:" + file1.delete());
 5         
 6         File file2 = new File("test");
 7         System.out.println("删除单级目录test：" + file2.delete());
 8         
 9         
10     }
11 }

7.File类_重命名功能

重命名功能

public boolean renameTo(File dest)

1.相同目录下：重命名操作；
2.不同目录下：相当于，重命名并剪切；

 1 public class Demo {
 2     public static void main(String[] args) {
 3         File file1 = new File("D:\\bbb.txt");
 4         
 5         File newFile = new File("D:\\aaa.txt");
 6         
 7         System.out.println("重命名：" + file1.renameTo(newFile));
 8         
 9         File file3 = new File("D:\\aaa.txt");
10         System.out.println("将aaa.txt重命名：" + 
11                                 file3.renameTo(new File("bbb.txt")));
12         
13     }
14 }

8.File类_判断功能

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

 1 public class Demo {
 2     public static void main(String[] args) {
 3         File file1 = new File("D:\\aaa.txt");
 4         File file2 = new File("aaa");
 5         
 6         System.out.println("file1是否是文件：" + file1.isFile());//true
 7         System.out.println("file1是否是目录：" + file1.isDirectory());//false
 8         
 9         System.out.println("file2是否是文件：" + file2.isFile());//false
10         System.out.println("file2是否是目录：" + file2.isDirectory());//true
11         
12         System.out.println("file1是否存在：" + file1.exists());//true
13         
14         File file3 = new File("fdjiosapufieojf");
15         System.out.println("file3是否存在：" + file3.exists());//false
16         
17         System.out.println("file1是否可读：" + file1.canRead());
18         System.out.println("file1是否可写：" + file1.canWrite());
19         System.out.println("file1是否隐藏：" + file1.isHidden());
20         
21         
22     }
23 }

9.File类_基本获取功能

基本获取功能
public String getAbsolutePath():获取绝对路径
public String getPath()：获取File封装的路径
public String getName()：获取文件/目录的名称
public long length()：获取文件/目录的大小；单位：字节
public long lastModified()：获取最后修改时间；单位：毫秒

 1 public class Demo {
 2     public static void main(String[] args) {
 3         File file1 = new File("D:\\aaa.txt");
 4         File file2 = new File("bbb.txt");
 5         
 6         System.out.println("file1的绝对路径：" + file1.getAbsolutePath());
 7         System.out.println("file2的绝对路径：" + file2.getAbsolutePath());
 8         
 9         System.out.println("file1的getPath()：" + file1.getPath());
10         System.out.println("file2的getPath()：" + file2.getPath());
11         
12         System.out.println("file1的getName()：" + file1.getName());
13         System.out.println("file2的getName()：" + file2.getName());
14         
15         System.out.println("file1的length() ： " + file1.length());
16         System.out.println("file1的lashModified()：" + file1.lastModified());
17         //将毫秒转换为日期表示的字符串
18         //毫秒-->Date-->String
19         Date date = new Date(file1.lastModified());
20         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
21         String str = sdf.format(date);
22         System.out.println("最后修改时间：" + str);
23     }
24 }

10.File类_高级获取功能

高级获取功能
public String[] list():获取此目录下所有的文件和目录的名称；
public File[] listFiles()：获取此目录下，所有文件和目录的File数组；

怎么使用：

1.如果仅仅需要此目录下的文件或目录的"名称"，没有其它后续操作，就使用list();
2.如果需要对此目录下的子文件或子目录进行后续操作，例如：查找某些文件，对某些文件重命名，这时为了方便
后续操作，使用listFile()方法。

 1 public class Demo {
 2     public static void main(String[] args) {
 3         File file1 = new File("D:\\");
 4         String[] files = file1.list();
 5         for(String s : files){
 6             System.out.println(s);
 7         }
 8         
 9         File[] fileArray = file1.listFiles();
10         for(File f : fileArray){
11             System.out.println(f.getAbsolutePath());
12         }
13     }
14 }

11.File类_文件过滤器

文件过滤器改进输出指定目录下指定后缀名的文件名称案例

public String[] list(FilenameFilter filter)
FilenameFilter(接口)：文件过滤器：

 1 public class Demo {
 2     public static void main(String[] args) {
 3         File file = new File("D:\\aaa");
 4         
 5         String[] fileNameArray = file.list(new FilenameFilter(){
 6             @Override
 7             public boolean accept(File dir, String name) {
 8                 
 9             //    return false;//所有文件都不匹配
10             //    return true;//所有文件都匹配；
11                 //写我们自己的匹配规则；
12                 //先看一下方法的参数是什么
13             //    System.out.println(dir + "----" + name);
14                 //将dir和name构造一个File对象。用于判断是否是"文件"
15                 File file = new File(dir,name);
16                 if(file.isFile() && file.getName().endsWith(".txt")){
17                     return true;
18                 }
19                 return false;
20             }});
21         
22         for(String fileName : fileNameArray){
23             System.out.println(fileName);
24         }
25         
26     }
27 }

12.递归概述和注意事项

递归调用：方法可以调用它自己；

注意事项：
1.要有出口，否则就是死递归；
2.次数不能太多，否则就内存溢出；递归调用比循环的开销要大得多；
3.构造方法不能递归使用
4.有些问题可以使用"循环"处理，那么就尽量不要使用"递归"。

 1 class Student{
 2     Student(){
 3     //    this();//编译错误：调用自己：无参的构造方法；
 4         
 5     //    this(10);
 6     }
 7     Student(int n){
 8     //    this();
 9     }
10 }
11 public class Demo {
12     static int num = 1;
13     public static void main(String[] args) {
14         
15         show();
16     }
17     public static void show(){
18         System.out.println("show --> num = " + num);
19         num++;
20         if(num > 5){
21             //结束方法
22             return;
23         }
24         //递归调用
25         show();
26     }
27 }

13.递归列出某目录下的所有Java文件

递归输出指定目录下所有的java文件的绝对路径案例

题目：列出D:\\20150118目录下的所有Java文件

1.使用File封装原目录：D:\\20150118;
2.列出目录下所有文件和目录；listFiles()
3.遍历；
4.判断是否是Java文件:
是：输出
否：判断是否是目录：
是：回到2(从2到此，做一个方法，作为递归调用的方法)
否：不管；

 1 public class Demo {
 2     public static void main(String[] args) {
 3         //1.封装原目录
 4         File file = new File("D:\\20150118");
 5         //2.递归调用
 6         findFile(file,".java");
 7     }
 8     
 9     public static void findFile(File file ,String flag){
10         File[] fileArray = file.listFiles();
11         for(File f : fileArray){
12             if(f.isFile() && f.getName().endsWith(flag)){
13                 //输出绝对路径
14                 System.out.println(f.getAbsolutePath());
15             }else if(f.isDirectory()){
16                 //递归调用
17                 findFile(f,flag);
18             }
19         }
20     }
21 }

14.递归删除带内容的目录案例

递归删除带内容的目录案例

1.我们知道，删除文件和目录使用：File的delete()方法，但delete()方法只能删除空目录，
如果目录下有内容，则无法删除。
2.所以，我们要递归删除目录下的所有文件，然后再删除目录；

步骤：
1.封装原目录；D:\\bbb - 副本
2.判断：原目录是否是文件：
是：直接删除
否：1).列出目录下所有的文件和目录；
2).遍历：
获取每个文件和目录，回到2(到2做一个递归方法)

 1 public class Demo {
 2     public static void main(String[] args) {
 3         File file = new File("D:\\bbb - 副本");
 4         deleteFile(file);
 5         System.out.println("删除完毕！");
 6     }
 7 
 8     private static void deleteFile(File file) {
 9         if(file.isFile()){//判断是一个文件
10             file.delete();
11         }else{//是一个目录
12             File[] fileArray = file.listFiles();
13             for(File f : fileArray){
14                 deleteFile(f);
15             }
16             //删除目录
17             file.delete();
18         }
19     }
20 }

15.IO流基类概述和需求分析

IO流基类概述和一个简单的需求分析

类层次结构：
字节流：
输出流：OutputStream(抽象的)
输入流：InputStream(抽象的)
字符流：
输出流：Writer(抽象的)
输入流：Reader(抽象的)

练习：向项目根目录下的一个文件：output.txt写入一个字符串:HelloWorld

1.向文件中写数据：使用输出流：OutputStream
2.向文件中写：使用子类：FileOutputStream;

构造方法：
FileOutputStream(String name)：使用name作为文件路径，构造一个通向这个文件的输出流管道；
FileOutputStream(File file)：使用File作为文件路径，构造一个通向这个文件的输出流管道；

 1 public class Demo {
 2     public static void main(String[] args) throws FileNotFoundException {
 3         //文件可以不存在，会自动创建一个；
 4     //    FileOutputStream out = new FileOutputStream("output.txt");//相对路径，项目根目录下；
 5         //使用File构造
 6         FileOutputStream out2 = new FileOutputStream(new File("output.txt"));
 7         
 8         
 9         
10     }
11 }

16.FileOutputStream写入数据

public void write(int b)：输出一个字节；
public void write(byte[] b)：输出一个byte数组(常用)
public void write(byte[] b,int off,int len)：输出一个byte数组的一部分(常用)

关闭流：

close();

 1 public class Demo {
 2     public static void main(String[] args) throws IOException {
 3         FileOutputStream out = new FileOutputStream("output.txt");
 4         //1.public void write(int b)
 5         out.write(97);//写入的是对应的字符；
 6         
 7         //2.public void write(byte[] b)
 8         byte[] byteArray = {97,98,99,100};
 9         out.write(byteArray);
10         
11         //写入字符串
12         String str = "你好Java";
13         out.write(str.getBytes());
14         
15         //3.public void write(byte[] b,int off,int len)
16         out.write(byteArray,2,2);//写入：cd
17         
18         //使用死循环，模拟一下程序继续做其它事情
19         /*while(true){
20             
21         }*/
22         //大家养成习惯，流打开后，一定关闭
23         out.close();
24         
25         
26     }
27 }

17.FileOutputStream_实现换行和追加写入

换行符：
windows:\r\n

追加写入：
需要使用FileOutputStream另外的构造方法：
public FileOutputStream(File file,boolean append)：如果append为true,则为追加写入；
public FileOutputStream(String fileName , boolean append):

 1 public class Demo {
 2     public static void main(String[] args) throws IOException {
 3         FileOutputStream out = new FileOutputStream("output.txt",true);
 4         
 5         
 6         out.write("Hello".getBytes());
 7         out.write("你好Java".getBytes());
 8         
 9         out.close();
10         
11     }
12 }

18.FileOutputStream_加入异常处理

 1 public class Demo {
 2     public static void main(String[] args) {
 3         FileOutputStream out = null;
 4         try {
 5             out = new FileOutputStream("output.txt");
 6             out.write("你好".getBytes());
 7         } catch (FileNotFoundException e) {
 8             System.out.println("无法建立与文件的连接，请联系系统管理员！");
 9             //将e中的信息写入到日志
10         } catch (IOException e) {
11             System.out.println("在写入数据时发生异常，请联系系统管理员！");
12             //将e中的信息写入到日志
13         }finally{
14             try {
15                 out.close();
16             } catch (IOException e) {
17                 //将e中的信息写入到日志
18             }
19         }
20         
21     }
22 }

java--IO流（1）--黑马程序员

标签：

原文地址：http://www.cnblogs.com/linmusen/p/4709271.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行