旗下导航:搜·么
当前位置:网站首页 > JAVA教程 > 正文

java中IO流对文件操纵的代码示例【JAVA教程】,java

作者:搜教程发布时间:2019-11-27分类:JAVA教程浏览:66评论:0


导读:本篇文章给人人带来的内容是关于java中IO流对文件操纵的代码示例,有肯定的参考价值,有须要的朋侪能够参考一下,愿望对你有所协助。Io流根据分类有两种分类流向方...
本篇文章给人人带来的内容是关于java中IO流对文件操纵的代码示例,有肯定的参考价值,有须要的朋侪能够参考一下,愿望对你有所协助。

Io流

根据分类 有两种分类

流向方向: 有输入流和输出流

根据操纵范例有:字撙节和字符流

根据流向方向

字撙节的一些操纵    
        //读文件
        FileInputStream fis = new FileInputStream("java.txt");
        int temp = fis.read()//一次读取一个字节
        System.out.println(temp); //打印的字母的码值  读取完返回-1
        System.out.println((char)temp);//打印字母
        
        
        byte[] arr = new byte[6]; //定义byte数组通知体系一次读取几个字节,削减内存和硬盘之间的通讯,能够进步效力
        int temp = bis.read(arr); //有参的read要领返回的int值是读取了几个字节
        System.out.println(new String(arr, 0, temp)); // 
        
        //写文件
        FileOutputStream fos = new FileOutputStream("file" + File.separator + "1024.txt",true);
            //假如该文件不存在,则会自动建立
            //传入true会在文件内容的背面写入笔墨,而不会掩盖之前的内容
            //开辟中文件分隔符最好不要直接写\  而是写 File.separator
            
        
        String msg = "Hello World";
        fos.write("\n".getBytes());//换行,并向文件写入  String.getBytes() 由于要以字节的情势传入
        fos.write(msg.getBytes());
        
        
        String msg = "好好进修";
        //一个汉字占2个字节,向内里一次传入3个字节会致使乱码
        fos.write(msg.getBytes(), 0, 3);
        
        
        byte[] arr = new byte[6];//一次性写这么多字节
        int temp = fis.read(arr);
        fos.write(arr, 0, temp);

        fos.flush();//革新
        
        
        //新的jdk7写法是在try括号()内里写文件的链接, 如许末了就不必封闭了,会自动封闭
        
        //缓冲输入流底层默许建立一个大小是8192长度的byte数组
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("java.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("file" + File.separator + "good.txt"));
        
        int temp = bis.read();//temp依旧为ascii玛  每次一个

一些演习

应用BufferedInputStream 和 BufferedOutputStream 完成将一个文件copy到另一个文件

package com.wpbxx.stream;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferFileCopy {

    public static void main(String[] args) {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            bis = new BufferedInputStream(new FileInputStream("java.txt"));
            bos = new BufferedOutputStream(new FileOutputStream("file" + File.separator + "good.txt"));
            int temp;
            while((temp = bis.read()) != -1){
                bos.write(temp);
            }
            bos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            try {
                bis.close();
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            
        }
        
    }

}

文件的加密 将一个字节异或一个数字完成 在传输时举行文件的加密

package com.wpbxx.stream;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class CodeFile {

    public static void main(String[] args) {
        //jdk7新写法
        try (
                BufferedInputStream bis = new BufferedInputStream(new FileInputStream("图片.png"));
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("code.png"));
                ) {
            
            int temp;
            while((temp = bis.read()) != -1){
                bos.write(temp ^ 88);
            }
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

文件解密

package com.wpbxx.stream;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class DecodeFile {

    public static void main(String[] args) {
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("code.png"));
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("decode.png"));) {
            int temp;
            while ((temp = bis.read()) != -1) {
                bos.write(temp ^ 88);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

字符流的一些操纵 能够处置惩罚乱码的题目

//读
        //注重:字符流不能读取非文本文件
        FileReader fr = new FileReader("java.txt");
        int temp;
        while ((temp = fr.read()) != -1) {
            System.out.println((char) temp); //一次一个字符
        }
        //运用缓冲字符流
        BufferedReader br = new BufferedReader(new FileReader("word.txt"));
        String msg;
        while((msg = br.readLine()) != null){  //一次能够读取一行
            System.out.println(msg); 
        }
        //写
        FileWriter fw = new FileWriter("word.txt");
        fw.write("我喜好进修java");
        fw.write(97);
        
        BufferedWriter bw = new BufferedWriter(new FileWriter("newbuffered.txt"));
        bw.write("你好");
        bw.newLine();//回车换行
        bw.write("java");

同样是copy文件

package com.wpbxx.chario;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/**
 * 运用缓冲流拷贝文件
 * 注重:字符流不能读取非文本文件
 */
public class BufferFileCopy {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("java.txt"));
            BufferedWriter bw = new BufferedWriter(new FileWriter("file" + File.separator + "hellojava.txt"));    
                ) {
            String msg;
            while((msg = br.readLine()) != null){
                bw.write(msg);
                bw.newLine();
            }
            bw.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e1) {
            e1.printStackTrace();
        }
    }

}

经由过程java中的File类完成对文件的一些操纵

File file1 = new File("D:\\hello.txt");
        //假如文件存在,就不建立了,返回false,假如不存在就会建立,返回true
        System.out.println(file1.createNewFile());
        
        File file2 = new File("D:\\new");
        //假如文件夹存在,就不建立了,返回false,假如不存在就会建立,返回true
        System.out.println(file2.mkdir());
        
        File file3 = new File("D:\\wpbxx\\1024");
        //能够建立多级目次,假如文件夹存在,就不建立了,返回false,假如不存在就会建立,返回true
        System.out.println(file3.mkdirs());
        
        File file4 = new File("D:\\wpbxx\\1024.txt");
        //只能建立文件夹
        System.out.println(file4.mkdirs());
        
        File file5 = new File("1026.txt");
        //假如不写盘符,会默许在项目标根目次内里建立
        System.out.println(file5.createNewFile());
        System.out.println(file5.exists());
        
        //旧名字
        File oldFile1 = new File("D:\\world.txt");
        //新名字
        File newFile1 = new File("D:\\wpbxx\\java.txt");
        //假如两个文件途径不一致,则会将旧文件剪切到新的文件途径中再重命名
        oldFile1.renameTo(newFile1);
        
        
        //不会将文件放到回收站中,而是直接删除
        File del = new File("D:\\wpbxx\\java.txt");
        
        File del1 = new File("D:\\wpbxx");
        //假如文件夹下有其他文件,则不会删除
        System.out.println(del1.delete());
        
                File file2 = new File("D:\\new.txt");
        //推断是不是是文件夹
        System.out.println(file2.isDirectory());
        //推断是不是是文件
        System.out.println(file2.isFile());
        
        //推断文件是不是存在
        System.out.println(file2.exists());
        
        File file3 = new File("D:\\hidden");
        //推断文件是不是隐蔽
        System.out.println(file3.isHidden());
        
        
        File file1 = new File("1024.txt");
        //检察相对途径
        System.out.println(file1.getAbsolutePath());
        //文件的大小,单元是字节
        System.out.println(file1.length());
        //末了修正时刻
        Date date = new Date(file1.lastModified());
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        System.out.println(sdf.format(date));
        
        File file2 = new File("F:\\wpbxx\\代码\\code\\chapter-08");
        //猎取目次下的同级文件或文件夹的称号
        String[] nameArray = file2.list();
        for(String name : nameArray){
            System.out.println(name);
        }

几个小演习

package com.wpbxx.exercise;

import java.io.File;
import java.util.Scanner;

/**
 * 题目:从键盘吸收一个途径,将这个途径下的一切文件和文件夹的名字根据层级打印。
 * 比方:
 *    wpbxx
 *              java
 *                  XXX.java
 *                  XXX.jpg
 *              php
 *                  XXX.php
 *              readme.txt
 * 
 * 剖析:猎取途径File对象中的File数组
 *     遍历数组,获得File对象
 *     打印文件或文件夹的名字
 *     假如是一个文件夹的话,运用递归反复上面的操纵
 */
public class FileNames {
    
    //用来纪录缩进的次数
    private static int count = 0;

    public static void main(String[] args) {
        
        File file = getFile();
        
        getFileNames(file);
    }
    
    //每次挪用该要领时,申明进入到一个新的文件夹的内部,须要增添一个缩进
    private static void getFileNames(File file) {
        //猎取途径File对象中的File数组
        File[] fileArray = file.listFiles();
        
        //遍历数组,获得File对象
        for(int i=0; i<fileArray.length; i++){
            
            //经由过程遍历count来掌握打印几个缩进
            for(int j=0; j<count; j++){
                System.out.print("\t");
            }
            
            //打印文件或文件夹的名字
            System.out.println(fileArray[i]);
            
            
            
            //假如是一个文件夹的话,运用递归反复上面的操纵
            if(fileArray[i].isDirectory()){
                count++;
                getFileNames(fileArray[i]);//数组遍历完末了一个File对象时,申明当前文件夹已遍历完毕,须要做自减运算
                count--;
            }
            
        }
    }
    
    //猎取用户输入途径的File对象
    private static File getFile() {
        
        System.out.println("请输入一个文件夹途径:");
        
        Scanner sc = new Scanner(System.in);
        //猎取用户输入的途径,用户输入的途径有多是毛病的,须要举行推断
        while(true){
            String input = sc.nextLine();
            File file = new File(input);
            if(!file.exists()){
                System.out.println("您输入的文件途径有误,请从新输入文件途径:");
            }else if(file.isFile()){
                //假如用户输入的途径是一个文件
                System.out.println("您输入的途径是一个文件,请输入一个文件夹的途径");
            }else{
                return file;
            }
        }
    }
    
    

}

package com.wpbxx.exercise;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 题目:收费版软件有试用次数,应用IO流的学问,模仿一个能够试用3次的功用,翻开3次以后提醒用户购置正版软件
 * 
 * 剖析:将试用的次数做加密处置惩罚后写到txt文件中
 *     运用IO流相干的学问将txt文件中的内容读取到内存中
 *     假如读取的内容小于0时提醒用户购置正版软件
 *     假如大于0小于即是3时,将试用次数做自减运算以后写出到txt文件中
 */
public class Trial {

    public static void main(String[] args) {
        //code();
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            bis = new BufferedInputStream(new FileInputStream("src" + File.separator + "com"
                    + File.separator + "monkey1024" + File.separator + "exercise" + File.separator + "config.txt"));
            int temp = bis.read();
            //解密处置惩罚
            int count = temp ^ 66;
            if(count > 0 && count <= 3){
                count--;
                System.out.println("您的试用次数还盈余" + count + "次");
                bos = new BufferedOutputStream(new FileOutputStream("src" + File.separator + "com"
                        + File.separator + "monkey1024" + File.separator + "exercise" + File.separator + "config.txt"));
                //做加密处置惩罚
                bos.write(count ^ 66);
                bos.flush();
            }else{
                System.out.println("您的试用次数已超越限定,请购置正版软件!");
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            try {
                //防止涌现空指针
                if(bis != null){
                    bis.close();
                }
                if(bos != null){
                    bos.close();
                }
                
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    //试用次数加密处置惩罚
    private static void code() {
        BufferedOutputStream bos = null;
        try {
            bos = new BufferedOutputStream(new FileOutputStream("src" + File.separator + "com"
                    + File.separator + "monkey1024" + File.separator + "exercise" + File.separator + "config.txt"));
            //加密处置惩罚
            bos.write(3 ^ 66);
            bos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            try {
                //防止涌现空指针非常
                if(bos != null){
                    bos.close();
                }
                
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }


}

package com.wpbxx.exercise;
import java.io.File;
/**
 * 题目:统计项目根目次下以.txt末端的文件数目,并将文件名打印出来
 * 剖析:猎取项目根目次下的文件名
 *     对文件名举行推断是不是是以.txt末端
 */
public class FindTxt {
    public static void main(String[] args) {
        File file = new File("F:\\wpbxx\\01-JavaSE\\代码\\code\\chapter-08");
        File[] fileArray = file.listFiles(); //返回一个File列表就是该目次下的File列表
        
        //统计涌现次数
        int count = 0;
        for(File name : fileArray){
            String s = name.toString();
            
            //推断是不是是以.txt文件末端
            if(s.endsWith(".txt")){
                if(name.isFile()){
                    count++;
                    System.out.println(name);
                }
            }
        }
        
        System.out.println("以.txt文件末端的数目是" + count + "个");
        
    }
}

package com.monkey1024.file;

import java.io.File;
import java.io.FilenameFilter;

/**
 * 题目:统计项目根目次下以.txt末端的文件数目,并将文件名打印出来
 * 运用文件过滤器完成上述需求
 */
public class FilenameFilterTest01 {

    public static void main(String[] args) {
        File file = new File("F:\\monkey1024\\01-JavaSE\\代码\\code\\chapter-08");
        String[] nameArray = file.list(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name){
                //猎取根目次下每一个文件的File对象
                File file1 = new File(dir, name);
                //编写挑选前提
                return file1.isFile() && file1.getName().endsWith(".txt");
            }
        });
        
        System.out.println("以.txt末端的文件个数是" + nameArray.length + "个");
        
        for(String name : nameArray){
            System.out.println(name);
        }
    }

}

package com.wpbxx.file;
import java.io.File;
import java.io.FilenameFilter;
/**
 * 题目:统计项目根目次下以.txt末端的文件数目,并将文件名打印出来
 * 运用文件过滤器完成上述需求
 */
public class FilenameFilterTest01 {
    public static void main(String[] args) {
        File file = new File("F:\\wpbxx\\01-JavaSE\\代码\\code\\chapter-08");
        String[] nameArray = file.list(new FilenameFilter() {//重写accept要领  
            @Override
            public boolean accept(File dir, String name){//将过滤的划定规矩写进来
                //猎取根目次下每一个文件的File对象
                File file1 = new File(dir, name);
                //编写挑选前提
                return file1.isFile() && file1.getName().endsWith(".txt");
            }
        });
        System.out.println("以.txt末端的文件个数是" + nameArray.length + "个");
        for(String name : nameArray){
            System.out.println(name);
        }
    }
}

对对象的读取

为啥要对对象读取?

日常平凡我们在Java内存中的对象,是无 法举行IO操纵或许网络通讯的,由于在举行IO操纵或许网络通讯的时刻,人家基础不知道内存中的对象是个什么东西,因而必需将对象以某种体式格局示意出来,即 存储对象中的状况。一个Java对象的示意有林林总总的体式格局,Java自身也提供给了用户一种示意对象的体式格局,那就是序列化。换句话说,序列化只是示意对 象的一种体式格局罢了。OK,有了序列化,那末必定有反序列化,我们先看一下序列化、反序列化是什么意义。

序列化:将一个对象转换成一串二进制示意的字节数组,经由过程保留或转移这些字节数据来到达耐久化的目标。

反序列化:将字节数组从新组织成对象。

序列化只须要完成java.io.Serializable接口就能够了。序列化的时刻有一个serialVersionUID参数,Java序列化机制是经由过程在运行时推断类的serialVersionUID来考证版本一致性的。 在举行反序列化,Java假造时机把传过来的字撙节中的serialVersionUID和当地响应实体类的serialVersionUID举行比较, 假如雷同就认为是一致的实体类,能够举行反序列化,不然Java假造时机拒相对这个实体类举行反序列化并抛出非常。serialVersionUID有两 种生成体式格局:

假如一个类的对象支撑序列化和反序列化,须要完成Serializable,Serializable中没有任何要领,只是相当于一个标记

有一个类

package com.monkey1024.serializable;

import java.io.Serializable;

/**
 * 假如一个类的对象支撑序列化和反序列化,须要完成Serializable
 * Serializable中没有任何要领
 */
public class Student implements Serializable{
    
    
    /**
     * 自动生成序列化版本号
     */
    private static final long serialVersionUID = -716323668524282676L;

    private String name;
    
    //增加属性后,运用反序列化时会报出InvalidClassException
    //transient润饰的变量不会被序列化
    transient private int age;
    
    private boolean sex;
    
    public boolean isSex() {
        return sex;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
}

然后我们对这个类举行序列化和反序列化

Student zhangsan = new Student();
        zhangsan.setName("张三");
        zhangsan.setAge(20);
        //写
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("zhangsan"));
        oos.writeObject(zhangsan);
        oos.flush();
        
        //读
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("zhangsan"));
        Student s = (Student)ois.readObject();
        System.out.println(s.getName());
        System.out.println(s.getAge());

以上就是java中IO流对文件操纵的代码示例的细致内容,更多请关注ki4网别的相干文章!

标签:java


欢迎 发表评论: