java文件操作总结

Love The Way You Lie 2021-10-01 10:00 268阅读 0赞

RandomAccessFile 相关API的使用

pointer=0; 文件指针
            写方法 raf.write(int) -->只写一个字节 后8位，同时指针指向下一个位置，准备再次写入
            读方法 int b = raf.read()-->读一个字节
            读写文件完成后一定要关闭

public static void testrandomaccessfile() throws IOException {
            File demo=new File("demo");
            if(!demo.exists())
                demo.mkdir();
            File file=new File(demo,"raf.dat");
            if(!file.exists())
                file.createNewFile();
            RandomAccessFile raf=new RandomAccessFile(file,"rw");
            //指针位置
            System.out.println(raf.getFilePointer());
            raf.write('A');//只写了一个字节
            System.out.println(raf.getFilePointer());
            raf.write('B');
            int i=0x7fffffff;
            //用write方法 每次只能写一个字节，如果要把i写进去就得写4次
            raf.write(i>>>24);//高8位
            raf.write(i>>>16);
            raf.write(i>>>8);
            raf.write(i);
            System.out.println(raf.getFilePointer());
    
            //可以直接写一个int
            raf.writeInt(i);
    
            String s ="中";
            byte[] gbk=s.getBytes("gbk");
            raf.write(gbk);//写入字节数组
            System.out.println(raf.length());
            //读文件必须把指针移到头部
            raf.seek(0);
            //一次性读取。把文件中内容读取到字节数组中
            byte[] buf=new byte[(int)raf.length()];
            raf.read(buf);
            System.out.println(Arrays.toString(buf));
            for(byte b:buf){
                System.out.println(Integer.toHexString(b&0xff)+" ");
            }
            raf.close();
        }

writeInt()方法源码，每次写入一位

![5057999-1bdcdcd9b91d2d5c.png][]

image.png

IO流（输入流，输出流）  
字节流，字符流  
1.字节流  
1）InputStream、OutputStream  
InputStream抽象了应用程序读取数据的方式  
OutputStream抽象了应用程序写出数据的方式  
2）EOF=End 读到-1就读到结尾  
3）输入流基本方法  
int b=in.read(); 读取一个字节无符号填充到int的低八位。-1是EOF  
in.read(byte\[\] buf)读取数据填充到字节数组buf  
in.read(byte\[\] buf,int start,int size)读取数据填充到字节数组buf，从buf的start位置开始，存放size长度的数据  
4）输出流基本方法  
out.write(int b)写出一个byte到流，b的低8位  
out.write(byte\[\] buf)将buf字节数组都写入到流  
out.write(byte\[\] buf,int start,int size)  
5)FileInputStream--->具体实现了在文件上读取数据  
6)FileOutputStream 实现了向文件中写出byte数据的方法  
7)DataOutputStream/DataInputStream  
对流功能的扩展，可以更加方便的读取Int,long,字符等类型数据  
DataOutputStream  
writeInt()/writeDouble()/writeUTF()  
DataOutputStream dos=new DataOutputStream(new FileOutputStream(file));  
8)BufferedInputStream&BufferedOutputStream  
这两个流类为IO提供了带缓冲区的操作，一般打开文件进行写入或读取操作时，都会加上缓冲，这种流模式提高了IO的性能

从应用程序中把输入放入文件，相当于将一缸水倒入到另一个缸中：  
FileOutputStream--->write方法党羽与一滴一滴把水转移过去  
DataOutputStream--->writexxx()方法会方便一些，相当于一瓢一瓢转移  
BufferedOutputStream--->write方法更方便，相当于一瓢一瓢水先放入桶中，再从桶中导入到另一个缸中

**使用in.read()方法**

/*
        读取指定文件内容，按照16进制输出到控制台
        并且每输出10个byte换行
         */
        public static void printHex(String filename) throws IOException {
            //把文件作为字节流进行读操作
            FileInputStream in=new FileInputStream(filename);
            int b;
            int i=1;
            while((b=in.read())!=-1){
                if(b<=0xf) {
                    //单位数前面补0
                    System.out.print("0");
                }
                System.out.print(Integer.toHexString(b)+" ");//将整形b转换为16进制的字符串
                if(i++%10==0)
                    System.out.println();
            }
            in.close();
        }

**使用in.read(byte\[\] buf , int start , int size)**  
将数据读取到字节数组中，返回数据大小，循环输出字节数组

public static void printHexByByteArray(String filename)throws IOException{
            FileInputStream in=new FileInputStream(filename);
            byte[] buf=new byte[20*1024];
            //从in中批量读取字节，放入到buf这个字节数组中，从第0个位置开始放，
            //最多放buf.length个 返回的是读到的字节的个数
            /*
            int bytes=in.read(buf,0, buf.length);//一次性读完，说明字节数组足够大
            int j=1;
            for(int i=0;i<bytes;i++){
                if((buf[i]&0xff)>0&&(buf[i]&0xff)<=0xf){
                    System.out.print("0");
                }
                System.out.print(Integer.toHexString(buf[i])+" ");
                if(j++%10==0)
                    System.out.println();
            }*/
    
            //循环利用buf数组，防止开辟数组空间不够用情况
            int bytes=0;
            int j=1;
            while((bytes=in.read(buf,0,buf.length))!=-1){
                for(int i=0;i<bytes;i++) {
                    //为了避免数据类型转换错误，将高24位清零
                    System.out.print(Integer.toHexString(buf[i] & 0xff) + " ");
                    if(j++%10==0)
                        System.out.println();
                }
            }
        }

文件的复制  
//如果文件不存在直接创建，如果存在，删除后创建。 如果append=true，不存在的时候则追加  
FileOutputStream out=new FileOutputStream("demo/out.dat");

public static void copyFile(File srcFile,File destFile)throws IOException{
            if(!srcFile.exists())
                throw new IllegalArgumentException("文件"+srcFile+"不存在");
            if(!srcFile.isFile())
                throw new IllegalArgumentException(srcFile+"不是文件");
            FileInputStream in=new FileInputStream(srcFile);
            FileOutputStream out=new FileOutputStream(destFile);
            byte[] buf=new byte[8*1024];
            int b;
            while((b=in.read(buf,0,buf.length))!=-1){
                out.write(buf,0,b);
                out.flush();//最好加上
            }
            in.close();
            out.close();
        }

//利用带缓冲的字节流
        public static void copytFileByBuffer(File srcFile,File destFile)throws IOException{
            if(!srcFile.exists())
                throw new IllegalArgumentException("文件"+srcFile+"不存在");
            if(!srcFile.isFile())
                throw new IllegalArgumentException(srcFile+"不是文件");
            BufferedInputStream bis=new BufferedInputStream(new FileInputStream(srcFile));
            BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(destFile));
            int c;
            while((c=bis.read())!=-1){
                bos.write(c);
                bos.flush();//刷新缓冲区
            }
            bis.close();
            bos.close();
        }

2.字符流  
1）编码问题  
2）认识文本和文本文件  
java的文本 (char)是16位无符号整数，是字符的unicode编码（双字节编码）  
文件是byte byte byte...的数据序列  
文本文件是文本(char)序列按照某种编码方案（utf-8,utf-16be,gbk）序列化为byte的存储结果  
3）字符流 （reader writer）---> 操作的是文本文件  
字符的处理 一次处理一个字符  
字符的底层仍然是基本的字节序列  
字符流的基本实现  
InputStreamReader 完成byte流解析为char流，按照编码解析  
OutputStreamWriter 提供char流到byte流，按照编码处理

//注意编码问题
    
    public class IsrAndOswDemo {
        public static void main(String[] args) throws IOException {
            FileInputStream in=new FileInputStream("G:\\11.txt");
            InputStreamReader isr=new InputStreamReader(in,"utf-8");//默认项目的编码
            FileOutputStream out=new FileOutputStream("G:\\12.txt");
            OutputStreamWriter osw=new OutputStreamWriter(out,"utf-8");
    //        int c;
    //        while((c=isr.read())!=-1){
    //            System.out.print((char)c);
    //        }
            char[] buffer=new char[8*1024];
            int c;
            while((c=isr.read(buffer,0,buffer.length))!=-1){
                String s=new String(buffer,0,c);
                System.out.println(s);
                osw.write(buffer,0,c);
                osw.flush();
            }
            isr.close();
            osw.close();
    
        }
    }

FileReader/FileWriter

public class FrAndFwDemo {
        public static void main(String[] args) throws IOException {
            FileReader fr=new FileReader("g:\\11.txt");
            FileWriter fw=new FileWriter("g:\\13.txt");
            char[] buffer=new char[2056];
            int c;
            while((c=fr.read(buffer,0,buffer.length))!=-1){
                fw.write(buffer,0,c);
                fw.flush();
            }
            fr.close();
            fw.close();
    
        }
    }

字符流的过滤器  
BufferedReader ---> readLine 一次读一行  
BufferedWriter/PrintWriter --->写一行

public class BrAndBwOrPwDemo {
        public static void main(String[] args) throws IOException{
            BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("g:\\11.txt")));
           // BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("g:\\123.txt")));
            PrintWriter pw=new PrintWriter("g:\\1234.txt");
            String line;
            while((line=br.readLine())!=null){
                System.out.println(line);
                pw.println(line);
                pw.flush();
    //            bw.write(line);
    //            //单独写出换行操作
    //            bw.newLine();//换行操作
    //            bw.flush();
            }
            pw.close();
            br.close();
    //        bw.close();
        }
    }

[5057999-1bdcdcd9b91d2d5c.png]: /images/20210811/602dc2a43ab44604a93bcabcfd559c75.png