io输入输出流

​
​

活动地址：CSDN21天学习挑战赛

输入输出流—对文件进行读【打开】写【修改】操作的java类库。
文件—把数据持久化到磁盘的载体
—文件的组成
1.文件的属性【文件名称，文件大小，文件类型，创建时间…】
2.文件内容【输入输出流】
我们要想通过java提供的输入输出流读写文件中的内容就得先学会操作文件。
Java中为我们提供了一个专门操作文件的java类–java.io.File类
9.1.File类的对象创建和常用方法？
File类的定义 public class File
File类的静态成员变量

public class TestFile1 {
    public static void main(String[] args) {
        //static String pathSeparator 与系统相关的路径分隔符，为方便起见，表示为字符串
        //static char pathSeparatorChar 与系统相关路径分隔符
        //static String separator 与系统相关的默认名称-分隔符字符，以方便的方式表示为字符串
        //static char separatorChar 与系统相关的默认名称分隔符
        System.out.println("static String pathSeparator=="+ File.pathSeparator);
        System.out.println("static char pathSeparatorChar=="+File.pathSeparatorChar);
        System.out.println("static String separator=="+File.separator);
        System.out.println("static char separatorChar=="+File.separatorChar);
        //separator/separatorChar---路径分隔符号【\】
        //假设我输出一个文件路径【D:\test\TestFile1.text】
        System.out.println("文件的路径----D:\test\nannanFile1.text");
        //此时我们输出的文件路径不正确，因为java程序将字串中的“\t”解释成制表符,
        //将“\n”解释成了回车输出，此时我们就无法正确的输出/描述一个文件路径。
        //我们要怎么办，可以通过“\\”将文件的路径分割符转义。
        System.out.println("文件的路径--D:\\test\\TestFile1.text");
        //既然我们可以通过“\\”转义路径分隔符，那么为什么还需要File类提供静态成员变量来表示路径分割符？？？
        //原因1:在=使用的时候并不全知道"\"与哪一个字母组合就会是一个特殊字符。
        //原因2：不同的计算机操作系统的路径分割符是不一样  例如"\"windows操作系统分隔符   "/"Linux分隔符.
        //为了不配特殊字符和可以在任何操作系统上完整的表示一个路径分割符号，
        //所以java就将路径分割符号做成了静态成员变量,以适应不同的操作系统和排除特殊字符。
        System.out.println("文件的路径--D:"+File.separator+"test"+File.separator+"name.text");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

构造方法

注意:文件File类的对象创建以后，不会生成实际的文件。

public class TestFile2 {
    public static void main(String[] args) {
        //File(String pathname)通过非定的文件路径字符串创建新的File实例
        String filepath1="D:"+ File.separator+"test"+File.separator+"testFile2.test";
        File file1 = new File(filepath1);
        //File(String parent, String child) 通过给定的文件位置字符串和给定的文件名称字符串创建新的 File实例。
        String path1 = "D:"+File.separator+"test";
        String name="testFile1.test";
        File fil2=new File(path1,name);
        //File(File parent, String child) 通过给定的文件位置File对象和给定的文件名称字符串创建新的 File实例。
        String path2 = "D:"+File.separator+"test";
        File filepath2=new File(path2);
        String name2="names.test";
        File file3 = new File(filepath2,name2);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

实例方法

public class TestFile3 {
    public static void main(String[] args) throws Exception  {
        String  path="D:"+ File.separator+"test";
        String  filepath="D:"+File.separator+"test"+File.separator+"names.txt";
        //创建保存文件的文件对象
        File file1=new File(path);
        //创建保存文件的文件对象
        File file2=new File(filepath);
        /**
         //创建文件夹
         //boolean	exists() 判断路径名表示的文件或目录是否存在。
         System.out.println(file1.exists());
         if(!file1.exists()) {
         //boolean mkdirs() 创建新的文件夹
         boolean dirfile = file1.mkdirs();
         if(dirfile) {
         if(!file2.exists()) {
         //boolean	createNewFile() 创建新文件
         file2.createNewFile();
         }
         }
         }else {
         //boolean	delete()  删除文件/文件夹
         //删除文件夹的时候要将该文件夹下的文件和子文件夹全部删除
         file1.delete();
         }
         */
        //boolean	canRead() 判断文件是否可读
        System.out.println("canRead=="+file2.canRead());
        //boolean	canWrite() 判断文件是否可写
        System.out.println("canWrite=="+file2.canWrite());
        //isHidden() 判断文件是否为隐藏文件。
        System.out.println("isHidden=="+file2.isHidden());
        //isFile() 判断文件对象是否为普通文件。
        System.out.println("isFile=="+file2.isFile());
        //boolean	isDirectory() 判断文件对象是否为目录。
        System.out.println("isDirectory=="+file2.isDirectory());
        //String	getPath() 得到文件对象的路径名字符串。
        System.out.println("getPath=="+file2.getPath());
        //String	getName() 得到文件对象所表示的文件或目录的名称。
        System.out.println("getName=="+file2.getName());
        //String	getParent() 得到文件对象所表示的路径的父目录路径
        System.out.println("getParent=="+file2.getParent());
        //long	length() 得到文件对象所表示的文件的长度。
        System.out.println("length=="+file2.length()+"字节");
        //long	lastModified() 得到文件对象所表示的文件上次修改的时间。
        String time=new SimpleDateFormat("yyyy/MM/dd E HH:mm").format(new Date(file2.lastModified()));
        System.out.println("lastModified=="+time);

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

public class TestFile4 {
    public static void main(String[] args) throws Exception  {
        /**
         //得到指定的文件夹下的文件和子文件夹名称
         String path="D:"+File.separator+"HBuilderX";
         File file1=new File(path);
         String names[]=file1.list();
         for(String name:names) {
         System.out.println(name);
         }
         */
        //得到指定的文件夹下的文件和子文件夹对象
        String path="D:"+ File.separator+"HBuilderX";
        File file1=new File(path);
        File files[]=file1.listFiles();
        for(File D:files) {
            //得到子文件/子文件夹的名称
            String name=D.getName();
            //得到子文件/子文件夹的修改时间
            String time=new SimpleDateFormat("yyyy/MM/dd E HH:mm").format(new Date(D.lastModified()));
            //判断文件对象是否是一个文件
            String len="";
            String type="";
            if(D.isFile()) {
                len=D.length()+"字节";
                type=getType(name);
            }
            StringBuilder stringBuilder=new StringBuilder();
            stringBuilder.append(name+"\t");
            stringBuilder.append(time+"\t");
            stringBuilder.append(type+"\t");
            stringBuilder.append(len);
            System.out.println(stringBuilder.toString());
        }
    }
    /**
     * 得到文件类型
     * @param name
     * @return
     */
    public  static  String getType(String name) {
        String type="";
        String houz=name.substring(name.lastIndexOf("."));
        if(houz.equalsIgnoreCase(".mp4")) {
            type="MP4文件";
        }
        if(houz.equalsIgnoreCase(".docx")) {
            type="DOCX文档";
        }
        if(houz.equalsIgnoreCase(".chm")) {
            type="编译的html文件";
        }
        if(houz.equalsIgnoreCase(".java")) {
            type="java源文件";
        }
        if(houz.equalsIgnoreCase(".html")) {
            type="网页文件";
        }
        if(houz.equalsIgnoreCase(".png")) {
            type="PNG图片";
        }
        return type;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

9.2.IO流的划分与区别【字节流与字符流】？
IO流用来读写文件的内容
流–数据的流动轨迹。
1.按照数据的流动方向
输入流—将数据读取到我们的处理程序中所形成的数据的流动轨迹就是输入流【读取数据】
输出流—将我们程序处理以后的数据写出到某一个文件中所形成的数据的流动轨迹就是输出流【写出数据】
2.按照每一次读写数据的大小
字节流—每一次读写一个字节【8位2进制】的数据量的流【字节流】
由于所有的数据都可被换算成字节，所以字节流是可以读写任何类型的数据 【文本，视频，音频，图片】
字符流—每一次读写一个字符【16位2进制】的数据量的流【字符流】
不能读写任何类型的数据，只能读写文本类型的数据。
IO流的综合划分