java中的File的使用

java中File的基础使用

文件的几个常用方法
创建文件句柄。
File是java.io里边的类。
如下代码是创建文件的方法:

//获取文件的句柄
        File file=new File("f:\\java\\code\\file\\1.txt");
        //如果是非后缀文件也是可以的
        File file2=new File("f:\\java\\code\\file\\2");
        
        try {
            //创建文件
            file.createNewFile();
            file2.createNewFile();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        //file.isDirectory()  and  file.isFile() 是用来判断是文件还是目录的。
        System.out.println(file.isFile());
        System.out.println("Is file2 file:"+file2.isFile());

目录的创建

    File file0=new File("f:\\java\\code\\file\0.txt");
        File file1=new File("f:\\java\\code\\file");
        //file1.exists();判断目录是否存在，如果存在才创建目录
        System.out.println(file0.exists());
        System.out.println(file1.exists());
        
        //目录的创建
        File mk1=new File(file1,"dir");
        //如果目录不存在则创建目录
        if(!mk1.exists()) {
            mk1.mkdir();
            //如果创建多级目录则是mk1.mkdirs();
        }

输入流FileInputStream

输入流的使用和实例，如下代码:

try {
            FileInputStream fis=new FileInputStream("f:\\java\\code\\file\\1.txt");
            //fis.read()每次只能读取一个字节,如果没有字节读取了，则返回-1
            int n=0;
            while((n=fis.read())!=-1) {
                //读取出来是一个ascii码，需要转成字符
                System.out.print((char)n);
            }
            fis.close();//关闭输入流
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }catch(IOException e) {
            e.printStackTrace();
        }

FileInputStream读取到的字节放入到字节数组中，然后转换成字符，如下：

//读取的字节放入到容器中
        try {
            FileInputStream fis=new FileInputStream("f:\\java\\code\\file\\1.txt");
            //创建一个字节的容器
            byte[] b=new byte[100];
            //读取到的字节放入到这个容器里边
            fis.read(b);
            //把字节容器的内容转换成字符
            System.out.println(new String(b));
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch(IOException e) {
            e.printStackTrace();
        }   

输出流FileOutputStream

使用如下:

FileOutputStream fot;
        //如果第二个参数为true是追加，否则是覆盖的写入方式
        try {
            fot =new FileOutputStream("f:\\java\\code\\file\\1.txt",true);
            fot.write('a');//只能增加一个字符
            fot.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }  catch(IOException e) {
            e.printStackTrace();
        }
        

java IO拷贝图片

如下代码：

try {
            //读取文件
            FileInputStream fis=new FileInputStream("f:\\java\\code\\file\\timg.jpg");
            //读取的文件写入成新的文件
            FileOutputStream fos=new FileOutputStream("f:\\java\\code\\file\\timg2.jpg");
            //每次读取多少
            byte [] b=new byte[1024];
            //循环读取
            int n=0;
            while((n=fis.read(b))!=-1) {
                //把读取到的内容写入到输出流里边,如果参数是0到n表示的是每次读取个数0到n的位置而不是整个b数组
                //每次读取都是byte的大小，如果最后一次读取少于byte数组大小也以这个大小读取，所以设置了第2个参数和第三个参数
                fos.write(b,0,n);
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch(IOException e) {
            e.printStackTrace();
        }
        

java的缓冲流

BufferInputStream
BufferOutputStream

实例代码如下:

FileInputStream fis;
        FileOutputStream fos;
        try {
            fis = new FileInputStream("f:\\java\\code\\file\\1.txt");
            fos =new FileOutputStream("f:\\java\\code\\file\\2.txt");
            //缓冲输入流，里边是放输入流的
            BufferedInputStream bis=new BufferedInputStream(fis);
            //缓冲输出流放里边放输出流作为参数
            BufferedOutputStream bos=new BufferedOutputStream(fos);
            //输出流读取的内容是在缓冲里边，如果缓冲没有满，则不会写入到文件，如果写入到文件,需要强制清除缓冲如:flush或者close
            bos.write('a');
            bos.flush();//清除缓冲流把内容写入到文件。
            System.out.print((char)bis.read());//读取的结果是h
            
            bos.close();//关闭流，也会有写入文件的强制作用
            fos.close();
            fis.close();
            bis.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch(IOException e) {
            e.printStackTrace();
        }

字符字节转换流

InputStreamReader
OutputStreamWriter

如下代码使用:

/**
         * 字符字节转换流的使用其实和缓冲流是比较类似的，就是从之前的字节容器存储变成了字节容器存储
         */
        FileInputStream fis;
        FileOutputStream fos;
        try {
            fis = new FileInputStream("f:\\java\\code\\file\\1.txt");
            fos=new FileOutputStream("f:\\java\\code\\file\\3.txt");
            InputStreamReader isr=new InputStreamReader(fis);
            OutputStreamWriter osr=new OutputStreamWriter(fos);
            int n=0;
            char[] cbuf=new char[10];
            while((n=isr.read(cbuf))!=-1) {
                System.out.print(cbuf);//可以直接输出，因为是字节转换了字符
                //把读取到内容写入到文件里边
                osr.write(cbuf);
                osr.flush();//强制输入到文件里边。
            }
            //关闭流的操作就省略了
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch(IOException e) {
            e.printStackTrace();
        }
        

java中IO对象化和反对象化

ObjectInputStream 参数是输入流 fis
ObjectOutputStream 参数是输出流 ois
ois.writeObject(对象) 写入对象到某个文件里边
oos.readObject();//读取后的结果强制转化为对象。