1 package com.service.impl;
  2 import java.awt.image.BufferedImage;
  3 import java.io.BufferedInputStream;
  4 import java.io.BufferedOutputStream;
  5 import java.io.File;
  6 import java.io.FileInputStream;
  7 import java.io.FileNotFoundException;
  8 import java.io.FileOutputStream;
  9 import java.io.FileReader;
 10 import java.io.FileWriter;
 11 import java.io.IOException;
 12 
 13 public class JavaIo {
 14     public static void main(String[] args) throws IOException {
 15         File file= new File("D:/test/a1.txt");
 16         System.out.println(file.exists());
 17         try {
 18             file.createNewFile();
 19             System.out.println(file.exists());
 20             System.out.println(file.getName());//获取文件的名字
 21             System.out.println(file.getAbsolutePath());//获取文件的绝对路径
 22             System.out.println(file.getPath());//获取文件的相对路径
 23             System.out.println(file.getParent());//获取文件的父路径
 24             System.out.println(file.canRead());//文件是否可读
 25             System.out.println(file.canWrite());//文件是否可写
 26             System.out.println(file.length());//文件的长度
 27             System.out.println(file.lastModified());//文件最后一次修改的时间
 28             System.out.println(file.isDirectory());//判断文件是否是一个目录
 29             System.out.println(file.isHidden());//文件是否隐藏
 30             System.out.println(file.isFile());//判断文件是否存在
 31         } catch (IOException e) {
 32             // TODO Auto-generated catch block
 33             e.printStackTrace();
 34         }
 35         
 36         
 37         //list()获取某个目录下所有的文件或者文件夹:
 38         
 39         File file=new File("D:/");//指定文件目录
 40                 String[] str=file.list();//获取指定目录下的所有文件或者文件夹的名称数组
 41                  for(String s : str){//加强for循环遍历输出
 42                      System.out.println(s);
 43                 }
 44                  
 45                  
 46                  
 47          File file=new File("D:/");//指定文件路径
 48                 File[] f=file.listFiles();//获取指定目录下的所有文件或者文件夹的File数组
 49                for(File fi : f){//加强for循环遍历输出
 50                    System.out.println(fi);
 51                }
 52         
 53             //获取test目录下的JPG格式文件,不包含及子文件夹
 54             File file = new File("D:\\test");
 55             String[] a = file.list();
 56             for(String s:a) {
 57                 if(s.endsWith(".JPG")) {
 58                     System.out.println(s);
 59                 }
 60             }
 61         
 62         //获取test目录下一级目录JPG格式的文件,并输出路径及文件名
 63         File file = new File("D:/test");
 64         File[] b = file.listFiles();
 65         for(File f:b) {
 66             if(f.isDirectory()) {
 67                 String[] s = f.list();
 68                 for(String c:s) {
 69                     if(c.endsWith(".JPG")) {
 70                         System.out.println(f+"****"+c);
 71                     }
 72                 }
 73             }
 74         }
 75         
 76         //FileInputStream和FileOutputStream进行拷贝文本或者图片或者歌曲
 77         
 78             FileInputStream fis = new FileInputStream("D:/test/a1.txt");
 79             FileOutputStream fos = new FileOutputStream("D:/test/test1/sss.txt", true);
 80             int a;
 81             while((a=fis.read())!=-1) {
 82                 fos.write(a);
 83             }
 84             fis.close();
 85             fos.close();
 86         
 87         
 88         /** A:缓冲思想
 89           * 字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多,
 90           * 这是加入了数组这样的缓冲区效果,java本身在设计的时候,
 91           * 也考虑到了这样的设计思想,所以提供了字节缓冲区流
 92         * B.BufferedInputStream
 93           * BufferedInputStream内置了一个缓冲区(数组)
 94           * 从BufferedInputStream中读取一个字节时
 95           * BufferedInputStream会一次性从文件中读取8192个, 存在缓冲区中, 返回给程序一个
 96           * 程序再次读取时, 就不用找文件了, 直接从缓冲区中获取
 97           * 直到缓冲区中所有的都被使用过, 才重新从文件中读取8192个
 98         * C.BufferedOutputStream
 99           * BufferedOutputStream也内置了一个缓冲区(数组)
100           * 程序向流中写出字节时, 不会直接写到文件, 先写到缓冲区中
101           * 直到缓冲区写满, BufferedOutputStream才会把缓冲区中的数据一次性写到文件里*/
102         
103         
104         //FileInputStream和FileOutputStream定义小数组进行读写操作
105         
106         FileInputStream fis = new FileInputStream("D:/test/a1.txt");
107         FileOutputStream fos = new FileOutputStream("D:/test/test1/nnn.txt",true);//true 表示可以继续往里写,不写true默认为覆盖nnn.txt文件
108         int a;
109         byte[] b = new byte[1024*8] ;
110         while((a=fis.read(b))!=-1) {
111             fos.write(b,0,a);
112         }
113         fis.close();
114         fos.close();
115         
116         
117         
118         
119         FileInputStream fis = new FileInputStream("D:/test/a1.txt");
120         FileOutputStream fos = new FileOutputStream("D:/test/test1/buffered.txt",true);
121         
122         BufferedInputStream bis = new BufferedInputStream(fis);
123         BufferedOutputStream bos = new BufferedOutputStream(fos);
124         int a;
125         while((a=bis.read())!=-1) {
126             bos.write(a);
127         }
128         
129         bis.close();
130         bos.close();
131         
132         
133         /*      面试题:小数组的读写和带Buffered的读取哪个更快?
134 
135                 * 定义小数组如果是8192个字节大小和Buffered比较的话
136                 * 定义小数组会略胜一筹,因为读和写操作的是同一个数组
137                 * 而Buffered操作的是两个数组
138                 IO流(flush和close方法的区别) 
139                 flush()方法: 用来刷新缓冲区的,刷新后可以再次写出(字节缓冲流内置缓冲区,如果没有读取出来,可以使用flush()刷新来)
140                 close()方法:用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出
141                 8:字符流FileReader和FileWriter
142                 字符流是什么
143                   * 字符流是可以直接读写字符的IO流
144                   * 字符流读取字符, 就要先读取到字节数据, 然后转为字符. 如果要写出字符, 需要把字符转为字节再写出.    
145                 IO流(什么情况下使用字符流)
146                 * 字符流也可以拷贝文本文件, 但不推荐使用. 因为读取时会把字节转为字符, 写出时还要把字符转回字节.
147                 * 程序需要读取一段文本, 或者需要写出一段文本的时候可以使用字符流
148                 * 读取的时候是按照字符的大小读取的,不会出现半个中文
149                 * 写出的时候可以直接将字符串写出,不用转换为字节数组
150                  
151                 IO流(字符流是否可以拷贝非纯文本的文件)
152                 * 不可以拷贝非纯文本的文件
153                 * 因为在读的时候会将字节转换为字符,在转换过程中,可能找不到对应的字符,就会用?代替,写出的时候会将字符转换成字节写出去
154                 * 如果是?,直接写出,这样写出之后的文件就乱了,看不了了*/
155         
156         
157         
158         
159         //字符流的拷贝,容易出现乱码
160                  FileReader fr2 = new FileReader("D:/test/a1.txt");
161                  FileWriter fw2 = new FileWriter("D:/test/test1/FileWriter.txt");
162                  
163                  int ch;
164                  while((ch = fr2.read()) != -1) {
165                     fw2.write(ch);
166                 }
167          
168                  fr2.close();
169                  fw2.close();
170                  
171                  
172                  FileReader fr2 = new FileReader("D:/test/a1.txt");
173                  FileWriter fw2 = new FileWriter("D:/test/test1/FileWriter.txt");
174                  BufferedReader br = new BufferedReader(fr2);
175                  BufferedWriter bw = new BufferedWriter(fw2);
176                  
177                  int ch;
178                  while((ch = br.read()) != -1) {
179                      bw.write(ch);
180                 }
181          
182                  br.close();
183                  bw.close();        
184         
185     }
186 
187 }

 

posted on 2019-03-05 18:24  菜鸟01号  阅读(116)  评论(0编辑  收藏  举报