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

------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 }
时间： 2024-10-14 22:01:18

java--IO流（1）--黑马程序员的相关文章

java--努力且进步着：面向对象（1）《java进阶篇》--黑马程序员

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 面向对象 主要内容:<  思想概述.设计实现.成员变量和局部变量.类名作为形参.匿名对象.封装.private关键字.this关键字 > 1 面向对象思想概述 面向对象是基于面向过程的编程思想 面向对象思想特点 是一种更符合我们思想习惯的思想 可以将复杂的事情简单化 将我们从执行者变成了指挥者 2 面向对象开发设计以及特征 软件整个的开发流程: 1.分析: 2.设计: 3.编程(开发): 需

java中的继承 黑马程序员

通过继承实现代码复用.Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的.继承而得到的类称为子类,被继承的类称为父类.子类不能继承父类中访问权限为private的成员变量和方法.子类可以重写父类的方法,及命名与父类同名的成员变量.但Java不支持多重继承,即一个类从多个超类派生的能力. class A { A(){} private int x=10;//A类的私有成员变量(不可以被继承) protected int y=20;//A类的保护成员变量(可以被继承)

java 多线程的理解 黑马程序员

public class MultiThread { public static void main(String args[]) { System.out.println("我是主线程!"); //下面创建线程实例thread1 ThreadUseExtends thread1=new ThreadUseExtends(); //创建thread2时以实现了Runnable接口的THhreadUseRunnable类实例为参数 Thread thread2=new Thread(ne

黑马程序员——java基础---IO(input output)流字符流

黑马程序员——java基础---IO(input output)流字符流 ------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- io(input output)流特点: 1,io流用来处理数据之间的传输 2,java对数据的操作是通过流的方式: 3,java用于操作流的对象都在io包中: 4,流按操作数据分为两种:字节流和字符流: 5,流按流向分为:输入流和输出流. 注意:流只能操作数据,而不能操作文件. 3.IO流的常用基类: 1)字节流的抽象

黑马程序员——Java基础--IO流(一)---字符流和字节流

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 一.IO流的介绍及体系 IO流用来处理设备之间的数据传输.java对数据的操作是通过流的方式.java用于操作流的对象都在IO包中. 输入流和输出流相对于内存设备而言:将外设中的数据读取到内存中:输入.将内存中的数据写出到外设中:输出. 流按照操作数据分为两种:字节流和字符流. 字符流的由来:其实就是字节流读取文字字节数据后,不直接操作而是先查指定的编码表,获取对应的文字,再对这个文字进行操作

黑马程序员之——Java基础 IO流——第四部分

-----------android培训.java培训.java学习型技术博客.期待与您交流!------------ 第一讲:黑马程序员_毕向东_Java基础视频教程第21天-01-IO流(对象的序列化) 一,对象序列化的概念:将堆内存中的对象存入硬盘,保留对象中的数据,称之为对象的持久化(或序列化). 二,ObjectInputStream和ObjectOutputStream类的了解: ObjectInputStream  特有方法:public final Object  readObj

黑马程序员之——Java基础 IO流——第三部分

-----------android培训.java培训.java学习型技术博客.期待与您交流!------------ 第一讲:黑马程序员_毕向东_Java基础视频教程第20天-01-IO流(File概述) 一,File 类的了解: 用于将文件或者文件夹封装成对象. 方便对文件与文件夹进行操作. File对象可作为参数传递给流对象的构造方法. File 类的声明:public class File extends Object implements Serializable, Comparabl

黑马程序员之——第二部分----Java基础 IO流

-----------android培训.java培训.java学习型技术博客.期待与您交流!------------ 第一讲,黑马程序员_毕向东_Java基础视频教程第19天-01-IO流(BufferedWriter) 一,字符流的缓冲区概述: 缓冲区的出现提高了对数据的读写效率. 对应类:BufferedWriter,BuuferedReader. 缓冲区要结合流才可以使用.       ====缓冲区是为了提高流的操作效率出现的,所以在创建缓冲区之前必须要现有流对象==== 在流的基础上

黑马程序员-Java IO流

--Java培训.Android培训.iOS培训..Net培训.期待与您交流!-- 一.概述 Java中与IO相关的类有很多,都集中在java.io中,都是以流的形式操作的,流是有一定的顺序,像一个管道一样,它的本质是传输数据.根据数据类型的不同可以分为字节流和字符流,根据流向的不同可以分为输入流和输出流. 字符流:因为数据有不同的编码,可以对字符进行不同的操作,其本质还是基于字节流,然后再查询相应的码表.一般用于处理纯文本数据. 字节流:可以处理所有类型数据,二进制文件(图片,音频等). 输入

黑马程序员——Java基础---IO(下)

黑马程序员——Java基础---IO(下) ------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------ 一.概述 Java除了基本的字节流.字符流之外,还提供了File类.properties类.打印流.序列流等和输入输出相关的类,它们能够帮助我们更好的处理信息.下面将对它们进行简单的介绍. 一.正