file io_file ios只有图库和相机 - CSDN
精华内容
参与话题
  • JAVA中FileIO

    2020-08-30 20:02:28
    作用:操作文件本身,如名字遍历删除,如果需要操作文件中的内容,我们必须使用Io来完成 window一般用\分割文件 然后 但是java中用//这个或者\ 操作File常见方法: String getName():获取文件名称 String getPath()...

    File(文件夹/目录)

    作用:操作文件本身,如名字遍历删除,如果需要操作文件中的内容,我们必须使用Io来完成

    window一般用\分割文件 然后 但是java中用//这个或者\

    操作File常见方法:

    • String getName():获取文件名称

    • String getPath():获取文件路径

    • String getAbsolutePath():获取绝对路径

      相对路径和绝对路径:

      假如一个学生是我们班级的,我们只需要说他的名字就好,但是要是其他班级的就需要说明,是哪个班级的谁谁谁

    • File getParentFile():获取上级目录文件

      当一直向上找的时候,找到根目录的时候,在点一次就会返回null

    • boolean exists():判断文件是否存在

    • boolean isFile() :是否是文件

    • boolean isDirectory():判断是否是目录

    • boolean delete() :删除文件

    • boolean mkdirs():创建当前目录和上级目录

    • File[] listFiles() :列出所有文件对象

      递归:调用自己的方法

      演示一个递归操作 ,遍历一个文件夹的所有文件(包括子文件)

      注意:使用递归操作的时候,一定要给自己的方法一个出口 ,在递归调用的时候就是使用方法

       package cn.wolfd._02_filesDir;
      
      import java.io.File;
      
      public class FileDemodir {
          public static void main(String[] args) {
          //需求 : 遍历当前文件夹的所有文件(包括所有的子文件)
              File file = new File("F:\\java学习资料\\预习资料\\基础班资料\\第四阶段-基础高级阶段\\04-IO\\day01\\笔记");
              listFiles(file);
          }
          public static void listFiles(File file){
              //判断当前传入地址是否是文件
              if (file.isDirectory()){
                  //如果是 就列出所有文件的对象
                  File[] files = file.listFiles();
                  //判断文件中是否有元素 如果不为空 那么就将此file遍历
                  //遍历之后对没有文件夹执行listFile判断 如果是一个文件夹就继续遍历
                  //如果不是文件夹,就直接打印名字
                  if (files!=null){
                      for (File file1 : files) {
                          listFiles(file1);
                      }
                  }
                  //最后才会打印出 最开始的文件夹名字
                  System.out.println(file);
              }
          }
      }
      
      

    字符集

    Unicode 万国码

    GBK家族一个汉字为两个字符集

    UTF-8亚洲通用字符集 一个汉字三个字节,支持中文,建议在开发中使用

    ISO–8859-410 老外服务器编码格式,常用

    ASCLL和ISO-8859-1不能存中文会乱码

    编码和解码

    编码-将字符串转为一个byte[]数组(转为计算机能看懂的语言)

    //编码操作:String -> byte[]
    byte[] data = input.getBytes(“UTF-8”);

    解码-将byte[]数组转为String (转为人能看懂得语言)

    //解码操作:byte[] -> String

    String ret = new String(data, “ISO-8859-1”);

    乱码的原因—编码的字符集不一样

    解决方案-将乱码转为二进制byte[] 然后我们再将二进制数组,转为我们想要的字符集就可以了

    IO

    io我们都是站在内存角度说的,所以说我们读取进来,就是input 就是输入道内存中 output就是输出从内存中输出出去

    读进来,写出去-----

    流的分类

    节点流 基本流

    包装流 功能更强大的节点流

    输入流和输出流的参考点 只有内存 没有其他

    • read 将文件中数据读进来
    • write 将程序中的数据写道文件中

    四大基本流

    流向 字节流(单位是字节) 字符流(单位是文字符)
    输入流 InputStream Reader
    输出流 OutputString Writer

    IO操作模板

    1:创建目标源对象
        一般都是创建一个文件对象
    2:创建io流对象(一个文件和程序的连接渠道)
        这个就是字节流字符流的各种形式
    3:具体的Io流操作
        read方法 将文件中的读取到程序中
        writer方法 将程序中写出道文件中
    4:关闭资源(勿忘) 当使用完不关闭浪费资源,关闭之后也就不能使用流了
        流对象.close(); 用完关闭就好了
    

    InputStream

    属于Io包 一个抽象类 一堆儿子

    常用方法

    1:close() 正常关闭

    2:read() 一次读取一个字节

    3:read(byte[] buff) 读取多个字节

    4:available()方法可以自动算读取多少个字节

    int available1 = in.available();
    byte[] buff = new byte[available1];
    
    public static void main(String[] args) throws IOException {
            //从指定文件按照字节为单位将数组读取到程序中
            //1:只当操作的源文件
            File file = new File("files/src.txt");
            System.out.println(file.exists());
            //2:创建输入流对象
            FileInputStream in = new FileInputStream(file);
            //3.执行read方法完成读取操作 提前准备一下接受的
            byte[] buff = new byte[3];
            int available = 0;
            int len = 0; 
            //每次数组都是添加到buffer数组中,后面可能存在元素覆盖不完的问题
            while((len = in.read(buff))!=-1){
                //只转换到读取到的字节数 
                System.out.print(new String(buff,0,3));
            }
            //4关闭资源
            in.close();
        }
    

    OutputStream

    属于Io包 一个抽象类 一堆儿子

    常用方法

    1.close(); 正常关闭

    2:finalize()清理文件的连接,并且保证没有更多的引用流时,将调用此文件输出流的close方法

    3:getChannel() 返回与此文件输出流相关练习的唯一FileChannel对象

    4:write();写出一个字节

    5:write(byte[] buff);写出多个字节

    6:write(byte[] buff,int off,int len);写出多个字节

    public static void main(String[] args) throws IOException {
            //1确定一个目标文件
            File file = new File("files/dest.txt");
            //2:创建文件输出流对象
            // public FileOutputStream(File file, boolean append)
            //如果再构造器的boolean输入true此时就可以实现追加输出
            FileOutputStream os = new FileOutputStream(file,true);
            //3:执行write方法完成输出操作
            os.write(65);
            os.write(66);
    
            os.write(new byte[]{65,66,67,68,69,70,100});
            //直接输入字符串 再输出的时候直接转换为byte数组 直接写出
            os.write("wolfd".getBytes());
            //用中文的时候 就不要轻易用
            os.write("wolfd".getBytes(),0,2);
            //4:关闭资源
            os.close();
        }
    

    Write

    常用方法

    1.close(); 正常关闭

    2:write();写出一个字符

    3:write(char[] buff);写出多个字符

    4:write(char[] buff,int off,int len);写出多个字符

    5:构造器(File ,boolean b) 当b为true的时候就不覆盖文件中内容

    public static void main(String[] args) throws IOException {
            //1:确定目标文件的路径,2创建输出流对象
            FileWriter fileWriter = new FileWriter("files/dest.txt",true);
            //3:执行write方法完成写出的操作
            fileWriter.write(65);
            fileWriter.write("中立群塔千百,知乎,知乎,摆渡荷载");
            fileWriter.write(new char[]{'A','B','C','D','E'},0,2);
            //4关闭资源
            fileWriter.close();
        }
    

    Reader

    (char 默认为null 读取的时候给定一个范围)

    常用方法

    1:close() 正常关闭

    2:read() 一次读取一个字符

    3:read(char[] buff) 读取多个字符

    4:read(cahr[] buff,int off,int len);

    public static void main(String[] args) throws IOException {
            FileReader reader = new FileReader("files/dest.txt");
            //一次读取一个字符
            int c = reader.read();
         
            System.out.println((char)c);
    
            //一次读取多个字符
            char[] cuff = new char[3];
            int read = reader.read(cuff);
            System.out.println(new String(cuff));
            int len=0;
        //精髓代码区
            while ((len=reader.read(cuff))!=-1){
                System.out.print(new 				                String(cuff,0,len));
            }
            reader.close();
        }
    

    总结:------字节流和字符流 就是单位不同,

    开发中纯文本的通常用字符流更方便,如果有图片或视频我们必须使用字节流 ,使用字符流的时候可以使用带范围的构造器,

    文件拷贝操作

    我们上边学习了io的操作,接下来我们具体实战一下,完成以下文件拷贝的操作 以及正确的处理异常以及原因

    1:正常拷贝文件的操作

    private static void copy() throws Exception{
        //1:creat target file
        File src = new File("file/copy_before.txt");
        File dest = new File("file/copy_after.txt");
        //2:creat IO Object
        FileReader in = new FileRead(src);
        FileReader out = new Filewiter(dest);
        //3:具体的IO操作
        int len = -1;//记录以及读取了多个字符
    	char[] buff = new char[1024];//每次可以读取1024个字符
    	len = in.read(buff);//先读取一次
    	while(len > 0) {
    		//边读边写
    		out.write(buff, 0, len);
    		len = in.read(buff);//再继续读取
    	}
    	//4):关闭资源(勿忘)
    	out.close();
    	in.close();
    }
    

    上面的代码,采用抛出异常的方式进行编写,接下来我们演示在代码内进行处理

    2:有异常处理的文件拷贝工作

    private static void copy2() {
    	//1):创建源或者目标对象
    	File src = new File("file/copy_before.txt");
    	File dest = new File("file/copy_after.txt");
    
    	//把需要关闭的资源,声明在try之外
    	FileReader in = null;
    	FileWriter out = null;
    	try {
    		//可能出现异常的代码
    		//2):创建IO流对象
    		in = new FileReader(src);
    		out = new FileWriter(dest);
    		//3):具体的IO操作
    		int len = -1;//记录以及读取了多个字符
    		char[] buff = new char[1024];//每次可以读取1024个字符
    		len = in.read(buff);//先读取一次
    		while (len > 0) {
    			out.write(buff, 0, len);
    			len = in.read(buff);//再继续读取
    		}
    	} catch (Exception e) {
    		e.printStackTrace();
    	} finally {
    		//4):关闭资源(勿忘)
    		try {
    			if (out != null) {
    				out.close();
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		try {
    			if (in != null) {
    				in.close();
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }
    

    第三种改良版本

    private static void copy2() {
    	//1):创建源或者目标对象
    	File src = new File("file/copy_before.txt");
    	File dest = new File("file/copy_after.txt");
    
    	//把需要关闭的资源,声明在try之外
    	
    	try(
            //指定可以自动关闭资源的io
        FileReader in =in = new FileReader(src);
    	FileWriter out = out = new FileWriter(dest);
        
        ) {
    		//3):具体的IO操作
    		int len = -1;//记录以及读取了多个字符
    		char[] buff = new char[1024];//每次可以读取1024个字符
    		len = in.read(buff);//先读取一次
    		while (len > 0) {
    			out.write(buff, 0, len);
    			len = in.read(buff);//再继续读取
    		}
    	} catch (Exception e) {
    		e.printStackTrace();
    	}
        //等全部执行完毕之后自动关闭
    }
    

    总结:

    (1):ctrl + alt + t 可以选择代码被什么包围,可以用于快速处理异常

    (2):如果规避空指针异常错误 判断当!=null这样就可以

    (3):因为四大基本类型都实现了closeable接口 (实现了此接口然后在处理异常时候,可以自动关闭io但是要在try(这里面 定义需要关闭的资源对象,全部初始化){}catch(){})

    缓冲流

    作用:减少磁盘IO工作量,提高效率

    原理:内置8192(字节/字符),其实就是数组,将我们需要的字节和字符缓存起来,等存满8192个字节在进行输出,此时问题来了,如果没满就不输入了吗,当然不是

    输出条件一:当8192个字符都装满的情况下都装满了 输出条件二:当执行close的时候自动执行输出操作(刷新)

    四个基本缓冲流

    BufferedInputStream / BufferedOutputStream / BufferedReader / BufferedWriter
    

    用法

    private static void copy3() throws Exception {
    	//1):创建源或者目标对象
    	File src = new File("file/郭德纲-报菜名.mp3");
    	File dest = new File("file/郭德纲-报菜名2.mp3");
    	//2):创建IO流对象
    	BufferedInputStream bis = 
    new BufferedInputStream(new FileInputStream(src), 8192);
    	BufferedOutputStream bos = 
    new BufferedOutputStream(new FileOutputStream(dest), 8192);
    	//3):具体的IO操作
    	int len = -1;//记录以及读取了多个字符
    	byte[] buff = new byte[1024];//每次可以读取1024个字符
    	len = bis.read(buff);//先读取一次
    	while (len > 0) {
    		//边读边写
    		bos.write(buff, 0, len);
    		len = bis.read(buff);//再继续读取
    	}
    	//4):关闭资源(勿忘)
    	bos.close();
    	bis.close();
    }
    

    对象序列化

    序列化作用:把java堆内存中的对象数据,通过某种关系把对象数据存储到磁盘上或者网络上

    反序列化作用:把磁盘文件中的对象的数据或者把网络节点上的对象数据恢复成Java对象的过程。

    如果要做序列化操作和反序列化操 必须实现Serializable接口,如果版本号不一致,那么就会反序列化失败

    可以通过IO中的对象流来做序列化和反序列化操作。

    • ObjectOutputStream:通过writeObject方法做序列化操作的

    • ObjectInputStream:通过readObject方法做反序列化操作的

    使用transient修饰的字段不会被序列化

    class User implements Serializable {
    	private String name;
    	private transient String password;
    	private int age;
    	......//省略一万行代码
    }
    
    
    public class ObjectStreamDemo {
    	public static void main(String[] args) throws Exception {
    		String file = "file/obj.txt";
    		ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));
    		User u = new User("Will", "1111", 17);
    		out.writeObject(u);
    		out.close();
    		//--------------------------------------
    		ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
    		Object obj = in.readObject();
    		in.close();
    		System.out.println(obj);
    	}
    }
    

    java.io.InvalidClassException 异常

    版本号不一致 序列化的版本号发生了改变
    对象的serialVersionUID被改变了
        
    为了避免代码版本升级而造成反序列化因版本不兼容而失败的问题,在开发中我们可以故意在类中提供一个固定的serialVersionUID值。
        class User implements Serializable {
    	private static final long serialVersionUID = 1L;
         //TODO
    }
    无论如何结构都不能改变类的结构
    

    Scanner

    作用:对文件做扫描可以对文件进行操作

    常用方法:

    判断文件中是否有下一行 hasNextLine()

    如果文中没有下一行那么久跳出nextLine()

    标准IO

    标准的输入:通过键盘录入数据给程序

    标准的输出:在屏幕上显示程序数据

    在System类中有两个常量int和out分别就表示了标准流:

    InputStream in	= System.in;
    PrintStream out = System.out;
    
    展开全文
  • File 删除功能 f1.delete(); 删除文件夹或者目录。 绝对路径:完整的路径名,直接可以表示他做对应的文件。 相对路径:需要使用其他路径信息对其经行解释。 删除注意事项 如果一个目录中有内容(目录或者文件夹)...

    File

    删除功能
    f1.delete(); 删除文件夹或者目录。

    • 绝对路径:完整的路径名,直接可以表示他做对应的文件。
    • 相对路径:需要使用其他路径信息对其经行解释。

    删除注意事项

    • 如果一个目录中有内容(目录或者文件夹),就不能直接删除这个目录,必须将其内容删除后才可删除该目录。

    IO流

    概述

    • IO:输入输出
    • 流:抽象概念,数据传输的总称。数据在设备间的传输称为流,即流的本质是数据传输。
    • IO流用来处理数据传输。

    分类

    • 按数据流向:输入流(读)、输出流(写)
    • 按数据类型:字节流(输入流、输出流)、字符流(输入流、输出流)

    默认按照数据类型分。

    字节流写数据
    字节流抽象基类:

    • InputStream:输入流的超类
    • OutputStream:输出流的超类

    FileOutputStream:文件输出流将数据写入File

    //FileOutputStream(String name)创建文件输出流
    FileOutputStream fo = new FileOutputStream("0828\\a.text");
    //FileOutputStream(new File(name))创建文件输出流
    FileOutputStream fos = new FileOutputStream(new File("0828\\a.text"));
    
      //写入文件输出流,一次写一个字节数据,
            fo.write(97);//a
            fo.write(57);//9
            fo.write(55);//7
            //写入byte数组
    //      byte[] b = {44,67,89,89,98};
            byte[] b = "sowdvfdiog".getBytes();
            fo.write(b);
           //换行,系统记事本用\r
            fo.write("\n".getBytes());
            //输入指定位置的字节
            fo.write(b,0,b.length);
    
    //释放资源
    fo.close();

    追加写入

    FileOutputStream fo1 = new FileOutputStream("0828\\a.text",true)

    默认在头部写,即重写文件,使用true,在文件尾部写,可实现追加写入。

    异常处理(除了抛出异常外的处理方法)

    FileOutputStream fo = null;
    try {
        fo = new FileOutputStream("0828\\b.text", true);
        fo.write("woooooo".getBytes());
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        //如过路径不存在不能创建文件,那么文件就为null,fo.close();会空指针异常
        //提前处理
        if (fo != null) {
            try {
                fo.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    读取文件中的数据
    按一个一个字节方式读取

            FileInputStream fi = new FileInputStream("0828\\a.text");
            //读一个字节a
            int read = fi.read();
            System.out.println(read);
            System.out.println((char)read);
    
            //第二次读
            int read1 = fi.read();
            System.out.println(read1);
            System.out.println((char)read1);
    
            //读取全部数据
    //        int by = fi.read();
    //        while (by != -1){
    //            System.out.print((char)by);
    //            //继续向下读取
    //            by = fi.read();
    //        }
    
            //优化读取全部数据,标准代码
            int by;
            while ((by = fi.read()) != -1)
                System.out.print((char)by);
            fi.close();

    按一个一个字节数组的方式读取数据

    byte [] bys = new byte[1024];//1024及其整数倍
    int len;
    while ((len=fi.read(bys))!=-1){
        //转成字符串输出
        System.out.print(new String(bys,0,len));
    }

    字节缓冲流
    BufferOutputStream:缓冲输出流,应用程序可以像底层输出流写入字节,不必为每个写入的字节导致底层系统的调用。
    BufferInputStream:创建一个内部缓冲区数组,可以一次很多字节。
    构造方法:

    • 字节缓冲输出流:BufferedOutputStream(OutputStream out)
    • 字节缓冲输入流:BufferedInputStream(InputStream out)
    • 字节缓冲流只提供缓冲区,读写数据还是得依靠基本的字节流对象进行操作。
    FileInputStream fi = new FileInputStream("E:\\a.txt");
    FileOutputStream fo = new FileOutputStream("0829\\a.txt");
    展开全文
  • 文件IO操作大全

    千次阅读 2017-06-10 13:38:39
    一、文件基本知识 “文件是指一组相关数据的有序集合”,这个数据集的名称就是文件名。所有文件都是通过流的形式进行输入输出操作的。流是一个数据字节的序列。流入程序的流称为输入流,流出程序的流称为输出流。...

    一、文件基本知识

    “文件是指一组相关数据的有序集合”,这个数据集的名称就是文件名。所有文件都是通过流的形式进行输入输出操作的。流是一个数据字节的序列。流入程序的流称为输入流,流出程序的流称为输出流。

    流可分为两大类:文本流二进制流

    (1)文本刘是一种字符序列,仅包含字符。

    (2)二进制流是一种二进制序列,与外设中的字节序列一一对应,不对字节中的内容进行转换,如遇到换行符也不会执行换行操作。


    文本又可以分为文本文件二进制文本文件两大类。

    (1)文本文件又称ASCII文件,也称字符文件。这种文件保存时,每个字符对应一个字节,用于存放对应的ASCII码。可通过输出设备显示,是我们能够读懂的内容。

    (2)二进制文件是由0和1组成的一段序列,用二进制的方式保存文件内容。虽然二进制也能够输出显示,但是只有机器能够读懂它的意思。


    二、文件的基本操作

    1.文件指针

    文件指针是缓冲文件系统中的关键概念,C系统为每个打开的文件在内存中开辟一个缓冲区,用于存放文件的有关信息,这些信息包括文件名,状态和文件存储位置等等。

    文件指针是一个有指向文件有关信息的指针,它保存在FILE结构体变量中。该结构体类型由系统定义,声明如下:

    typedef struct
    {
        short level;                /*缓冲区的使用量*/
        unsigned flags;             /*标志文件状态*/
        char fd;                    /*文件号*/
        unsigned char hold;         /* 无缓冲区取消字符输入*/
        short bsize;                /*缓冲区大小默认值512*/
        unsigned char *buffer;      /*缓冲区指针*/
        unsigned ar *curp;          /*无活动指针*/
        unsigned istemp;            /*草稿文件标识*/
        short token;                /*做正确性检测*/
    }FILE;
    

    2.文件打开fopen()和关闭fclose()

    (1)文件打开fopen()

    fopen()函数是ANSIC规定的标准输入/输出函数库中的函数。打开文件的操作就是创建一个流。

    头文件:#include <stdio.h>

    函数调用形式:fp = fopen("文件名","使用文件方式");

    功能:以某种使用方式打开文件

    返回值:若文件打开成功返回 一个有确定指向的FILE指针,打开失败则返回NULL。


    使用方式含义

    r打开只读文件,该文件必须存在。
    r+打开可读写的文件,该文件必须存在。
    w打开只写文件,若文件存在则文件长度清为0,即该文件内容会消失。若文件不存在则建立该文件。
    w+打开可读写文件,若文件存在则文件长度清为零,即该文件内容会消失。若文件不存在则建立该文件。
    a以附加的方式打开只写文件。若文件不存在,则会建立该文件,如果文件存在,写入的数据会被加到文件尾,即文件原先的内容会被保留。
    a+以附加方式打开可读写的文件。若文件不存在,则会建立该文件,如果文件存在,写入的数据会被加到文件尾后,即文件原先的内容会被保留。

    rb打开一个二进制文件,只允许读数据

    rb+打开一个二进制文件,允许读和写

    wb打开或建立一个二进制文件,只允许写数据

    wb+打开或建立一个二进制文件,允许读和写

    ab打开一个二进制文件,并在文件末尾写数据

    ab+打开一个二进制文件,允许读,或在文件末追加数据

    总结以上使用方式的特点:

    ①r(read)代表读,w(write)代表写,a(append)追加。

    ②r为打开只读文件,即文件存在才能读;w为打开只写文件,若文件不存在则建立,文件存在则先将文件内容清空再写数据;a为追加的方式写入数据,即文件不存在则建立,若文件存在,原文件内容不清空,并在末尾写入数据。

    ③b代表二进制的标识,意思是对二进制文件操作

    ④+代表可读和可写


    (2)文件关闭fcolse()

    文件使用完毕后,应将其关闭,关闭的意思是文件指针变量不再指向该文件。如果不将已打开的文件关闭的话,是危险的。

    头文件:#include <stdio.h>

    函数调用形式:fclose(文件指针名);

    功能:关闭文件指针fp指向的文件

    返回值:若正常关闭文件返回值为0,关闭失败则返回EOF(即-1)。


    3.文件读/写函数

    (1)写字符函数——fputc()

    头文件:#include <stdio.h>

    函数调用形式:fputc(字符,文件指针名);

    功能:把一个字符写到fp所指向的文件中去。

    返回值:输出成供返回值就是输出的字符,输出失败返回EOF(即-1)

    函数实现:通过fputc写入一个字符到fputc.txt文件中

    #include <stdio.h>
    #include <stdlib.h>
    int main()
    {
        FILE *fp;//定义一个指向FILE类型结构体的指针变量fp
        char ch;
        if((fp = fopen("C:\\Users\\Administrator\\Desktop\\fputc.txt","w")) == NULL)//以只写方式打开文件,这里注意是用两个“\”
        {
            printf("打开文件失败!\n");
            exit(0);
        }
        ch = getchar();     //获取从键盘输入的字符
        while(ch != '#')    //输入#停止输入
        {
            fputc(ch,fp);   //将ch字符写入到文件中
            ch = getchar();
        }
        fclose(fp);         //关闭fp指向的文件
        return 0;
    }



    (2)读字符函数——fgetc()

    头文件:#include <stdio.h>

    函数调用形式:字符变量 = fgetc(文件指针名);

    功能:从文件指针指向的磁盘文件中读取一个字符

    返回值:函数遇到文件结束符时将返回一个文件结束标志EOF(即-1)。

    函数实现:通过fgetc读出fgetc.txt文件中内容

    #include <stdio.h>
    #include <stdlib.h>
    int main()
    {
        FILE *fp;//定义一个指向FILE类型结构体的指针变量fp
        char ch;
        if((fp = fopen("C:\\Users\\Administrator\\Desktop\\fgetc.txt","r")) == NULL)//以只读方式打开文件,文件必须存在
        {
            printf("打开文件失败!\n");
            exit(0);
        }
        ch = fgetc(fp);     //获取从键盘输入的字符
        while(ch != EOF)    //输入#停止输入
        {
            putchar(ch);    //将ch字符写入到文件中
            ch = fgetc(fp); //重复使用fgetc读取文件内容
        }
        fclose(fp);         //关闭fp指向的文件
        return 0;
    }
    


    (3)写字符串函数——fputs()

    头文件:#include <stdio.h>

    函数调用形式:fputs(字符串,文件指针);

    功能:向指定的文件写入一个字符串,其中字符串可以是字符串常量,也可以是字符数组名、指针或变量

    返回值:若成功则返回写出的字符个数,返回EOF则表示有错误发生。

    函数实现:使用fputs向指定的磁盘文件写入字符串

    #include <stdio.h>
    #include <process.h>
    int main()
    {
        FILE *fp;
        char filename[30],str[30];
        printf("请输入文件路径:\n");
        scanf("%s",filename);
        if((fp = fopen(filename,"w")) == NULL)//以只写方式打开文件
        {
            printf("打开文件失败!\n");
            getchar();//输入任意键继续
            exit(0);
        }
        printf("请输入字符串:\n");
        getchar();
        gets(str);
        fputs(str,fp);  //将str写入到指定的文件中
        fclose(fp);     //关闭文件
        return 0;
    }
    



    (4)读字符串函数——fgets()

    头文件:#include <stdio.h>

    函数调用形式:fgets(字符数组名,n,文件指针)

    功能:从指定的文件中读取一个字符串到字符数组中。n表示所得到的字符串中字符的个数。

    返回值:若成功则返回数组首地址,返回NULL则表示有错误发生。


    函数实现:使用fgets()读取磁盘文件中的文件内容

    #include <stdio.h>
    #include <process.h>
    int main()
    {
        FILE *fp;
        char filename[30],str[100];
            printf("请输入文件路径:\n");
        scanf("%s",filename);
        if((fp = fopen(filename,"r")) == NULL)//以只读方式打开文件
        {
            printf("打开文件失败!\n");
            getchar();//输入任意键继续
            exit(0);
        }
        fgets(str,sizeof(str),fp);//读出文件中的内容,若成功则返回str的内容
        printf("%s\n",str);
        fclose(fp);     //关闭文件
        return 0;
    }
    


    (5)格式化写入函数——fprintf()

    格式化就是把想要输出的数据,按照一定的格式输出。

    头文件:#include <stdio.h>

    函数调用形式:ch = fprintf(文件类型指针,格式字符串,输出列表)

    功能:fprintf(fp,"%d",i);将整型变量i的值按%d的格式输出到fp所指向的文件上。

    返回值:成功时返回转换的字节数,失败时返回一个负数

    函数实现:使用fprintf将数字以字符形式写入磁盘文件

    #include <stdio.h>
    #include <process.h>
    int main()
    {
        FILE *fp;
        int i = 65;
        char filename[30];
        printf("请输入文件路径:\n");
        scanf("%s",filename);
        if((fp = fopen(filename,"w")) == NULL)//以只写方式打开文件
        {
            printf("打开文件失败!\n");
            getchar();//输入任意键继续
            exit(0);
        }
        fprintf(fp,"%c",i);
        fclose(fp);     //关闭文件
        return 0;
    }
    




    (6)格式化读取函数——fscanf()

    头文件:#include <stdio.h>

    函数调用形式:ch = fprintf(文件类型指针,格式字符串,输入列表)

    功能:fprintf(fp,"%d",i);读入fp所指向的文件上的i值

    返回值:成功时返回转换的字节数,失败时返回一个负数

    函数实现:使用fscanf将磁盘中的字符以整数形式输出

    #include <stdio.h>
    #include <process.h>
    int main()
    {
        FILE *fp;
        int i ,j;
        char filename[30];
        printf("请输入文件路径:\n");
        scanf("%s",filename);
        if((fp = fopen(filename,"r")) == NULL)//以只读方式打开文件
        {
            printf("打开文件失败!\n");
            getchar();//输入任意键继续
            exit(0);
        }
        for(i = 0 ; i < 14 ; i++)
        {
            fscanf(fp,"%c",&j);
            printf("%d 是 : %5d\n",i+1,j);
        }
        fclose(fp);     //关闭文件
        return 0;
    }
    



    (7)数据块读/写函数——fread()/fwrite)()

    头文件:#include <stdio.h>

    函数调用形式:fread(buffer,size,count,fp)fwrite(buffer,size,count,fp);

    功能:从fp所指的文件中读入/写入count次,每次读出大小为size个字节,并将读入/输出的信息保存在buffer地址中

    返回值:若成功返回实际/读入/写入的count数目

    函数实现:使用fread和fwrite实现将录入的通讯录信息保存到磁盘文件中,在录入完信息后,要将所录入的信息全部显示出来。

    #include <stdio.h>
    #include <process.h>
    struct address_list
    {
        char name[10];
        char adr[20];
        char tel[15];
    }info[100];
    
    void save(char *name,int n)
    {
        FILE *fp;
        int i;
        if((fp = fopen(name,"wb")) == NULL)//以只写方式打开二进制文件
        {
            printf("打开文件失败!\n");
            exit(0);
        }
        for(i = 0 ; i < n ; i++)
            if(fwrite(&info[i],sizeof(struct address_list),1,fp) != 1)
                printf("文件写入失败!\n");
        fclose(fp);
    }
    
    void show(char *name,int n)
    {
        int i;
        FILE *fp;
        if((fp = fopen(name,"rb")) == NULL)//以只读方式打开二进制文件
        {
            printf("打开文件失败!\n");
            exit(0);
        }
        for(i = 0 ; i < n ; i++)
        {
            fread(&info[i],sizeof(struct address_list),1,fp);
            printf("%15s%20s%20s\n",info[i].name,info[i].adr,info[i].tel);
        }
        fclose(fp);
    }
    
    int main()
    {
        int i,n;
        char filename[30];
        printf("请输入学生个数:");
        scanf("%d",&n);
        printf("请输入文件路径:\n");
        scanf("%s",filename);
        printf("请输入学生的姓名、地址和电话:\n");
        for( i = 0 ; i < n ; i++)
        {
            printf("NO.%d",i+1);
            scanf("%s%s%s",info[i].name,info[i].adr,info[i].tel);
            save(filename,n);
        }
        show(filename,n);
        return 0;
    }
    


    4.定位文件

    (1)随记读写操作——fseek()

    头文件:#include <stdio.h>

    函数调用形式:fseek(文件类型指针,位移量,起始点);

    功能:用来移动文件内部位置指针。位移量表示移动的字节数,要求位移量是long型数据,以便在文件长度大于64kb时不会出错

    起始点的表示方法

    文件首  :表示符号为SEEK-SET,数字表示0

    文件当前位置: 表示符号为SEEK-CUR,数字表示1

    文件末尾:表示符号为SEEK-END,数字表示2

    函数实现:向任意一个二进制文件中写入一个长度大于7的字符串,然后从该字符串的第7个字符开始输出余下字符。

    #include <stdio.h>
    #include <process.h>
    int main()
    {
        FILE *fp;
        int i ,j;
        char filename[30],str[50];
        printf("请输入文件路径:\n");
        scanf("%s",filename);
        if((fp = fopen(filename,"wb")) == NULL)//以只写方式打开二进制文件
        {
            printf("打开文件失败!\n");
            getchar();//输入任意键继续
            exit(0);
        }
        printf("请输入字符串:\n");
        getchar();
        gets(str);
        fputs(str,fp);  //将str写入到指定的文件中
        fclose(fp);     //关闭文件
        if((fp = fopen(filename,"rb")) == NULL)//以只读方式打开二进制文件
        {
            printf("打开文件失败!\n");
            getchar();//输入任意键继续
            exit(0);
        }
        fseek(fp,6l,0);
        fgets(str,sizeof(str),fp);
        putchar('\n');
        puts(str);
        fclose(fp);     //关闭文件
        return 0;
    }

    (2)返回位置指针——rewind()

    头文件:#include <stdio.h>

    函数调用形式:int rewind(文件类型指针);

    功能:使位置指针重新返回文件的开头

    函数实现:先输出一个文件的内容,再使用rewind返回文件开头,再输出一次。

    #include <stdio.h>
    #include <process.h>
    int main()
    {
        FILE *fp;
        char ch,filename[30];
        printf("请输入文件路径:\n");
        scanf("%s",filename);
        if((fp = fopen(filename,"r")) == NULL)//以读方式打开二进制文件
        {
            printf("打开文件失败!\n");
            exit(0);
        }
        ch = fgetc(fp);
        while(ch != EOF)
        {
            putchar(ch);
            ch = fgetc(fp);
        }
        printf("\n");
        rewind(fp);
        ch = fgetc(fp);
        while(ch != EOF)
        {
            putchar(ch);
            ch = fgetc(fp);
        }
        printf("\n");
        fclose(fp);     //关闭文件
        return 0;
    }
    



    (3)得到文件位置——ftell()

    头文件:#include <stdio.h>

    函数调用形式:long ftell(文件类型指针);

    功能:得到流式文件中的当前位置,用相对于文件开头的位移量来表示

    返回值:当返回值为-1L时表示出错。

    函数实现:使用ftell求文件中的字符串长度

    #include <stdio.h>
    #include <process.h>
    int main()
    {
        FILE *fp;
        int n;
        char ch,filename[30];
        printf("请输入文件路径:\n");
        scanf("%s",filename);
        if((fp = fopen(filename,"r")) == NULL)//以读方式打开文件
        {
            printf("打开文件失败!\n");
            exit(0);
        }
        ch = fgetc(fp);
        while(ch != EOF)
        {
            putchar(ch);
            ch = fgetc(fp);
        }
        n = ftell(fp);
        printf("\n这个字符串的长度为:%d\n",n);
        fclose(fp);     //关闭文件
        return 0;
    }
    



    展开全文
  • Java-IO流——File类介绍

    千次阅读 2018-10-23 18:32:53
    java.io.File代表与平台无关的文件或目录。也就是说可以通过File类在Java程序中操作文件或目录。 File类只能用来操作文件或目录(包括新建、删除、重命名文件和目录等操作),但不能用来访问文件中的内容。 如果...

    File类概述

    • java.io.File代表与平台无关的文件或目录。也就是说可以通过File类在Java程序中操作文件或目录。
    • File类只能用来操作文件或目录(包括新建、删除、重命名文件和目录等操作),但不能用来访问文件中的内容。
    • 如果需要访问文件中的内容,则需要使用输入/输出流。

    绝对路径和相对路径、路径分隔符
    1. Windows中绝对路径以盘符开头;Linux中绝对路径以斜线/开头;
    2. 不以盘符和斜线/开头的路径就是相对路径。默认情况下,系统总是依据用户的工作路径来解释相对路径,这个路径由系统属性user.dir指定,通常也就是运行java虚拟机时所在的路径。
    3. Windows的路径分隔符使用反斜线\(Linux中使用斜线/),而Java程序中的反斜线表示转义字符,所以如果需要在Windows的路径中包括反斜线,则应该使用两条反斜线\\,如:C:\\adb\\text.txt
    4. Java程序支持将斜线/当成平台无关的路径分隔符,所以Java程序中表示Windows系统的路径分隔符\\可以用斜线/代替。

    一、File类的构造方法

    1. public File(String pathname):根据指定的路径(可以是绝对路径或相对路径)创建File对象。
    2. public File(String parent, String child):根据指定的父文件夹和子文件或者子文件夹创建File对象
    3. public File(File parent, String child):根据指定的父文件夹对象和子文件或者子文件夹创建File对象
    4. public File(URI uri):根据URI表示的文件或目录的路径创建对象,如file:/F:/迅雷下载/test.txt

    二、File类其他成员方法

    访问文件或目录的名称和路径的方法

    1. public String getName(): 返回File构造方法中传入路径表示的文件名或目录名(如果是目录名则是最后一级子目录名)

    2. public String getPath(): 返回File构造方法中传入的路径名

    3. public String getParent():返回File构造方法中传入文件或目录路径的父目录,如果传入路径没有父目录,则返回null

    4. public String getAbsolutePath(): 返回File对象表示的文件或目录的绝对路径名

    5. public File getAbsoluteFile(): 返回一个通过此File对象表示的文件或目录的绝对路径名重新new出来的一个File对象

      • 即使File对象表示的文件或目录不存在,也不影响上述方法获取File对象表示的文件或目录的名称和路径。

          File f2 = new File("F:/迅雷下载/java基础/day19-异常、IO-File/day19_code/讲师代码/day19_File/bbb/ccc/text.txt");
          System.out.println(f2.exists());
          System.out.println(f2.getName());
          System.out.println(f2.getPath());
          System.out.println(f2.getParent());
          System.out.println(f2.getAbsolutePath());
          
          System.out.println("------------------");
          File f3 = new File("bbb/ccc/text.txt");
          System.out.println(f3.exists());
          System.out.println(f3.getName());
          System.out.println(f3.getPath());
          System.out.println(f3.getParent());
          System.out.println(f3.getAbsolutePath());
          
          System.out.println("------------------");
          File f4 = new File("text.txt");
          System.out.println(f4.exists());
          System.out.println(f4.getName());
          System.out.println(f4.getPath());
          System.out.println(f4.getParent());
          System.out.println(f4.getAbsolutePath());
        
          System.out.println("------------------");
          File absoluteFile = f4.getAbsoluteFile();
          System.out.println(absoluteFile.exists());
          System.out.println(absoluteFile.getName());
          System.out.println(absoluteFile.getPath());
          System.out.println(absoluteFile.getParent());
          System.out.println(absoluteFile.getAbsolutePath());
        

        在这里插入图片描述

    6. public boolean renameTo(File dest): 重命名此File对象表示的文件或目录,重命名成功返回true,失败返回false。

      • 如果此File对象表示的文件或目录不存在,则重命名会失败;
      • 如果dest表示的文件或目录存在,则重命名失败;
      • 如果此File对象表示文件,则即使dest构造方法传入的是一个没有文件名后缀的目录路径,则重命名也成功,相当于将原来的带后缀扩展名的文件改成了不带后缀扩展名的文件。当然,重命名时,也可以将dest的传入路径改成其他后缀扩展名格式的文件名。
      • 如果此File对象表示目录,则即使dest构造方法传入的是一个带后缀扩展名的文件路径,那么重命名也成功,相当于将后缀扩展名也当成是目录名的一部分。
      • 如果dest构造方法传入的文件或文件夹的路径跟此File对象表示的文件或文件夹不在同一级目录下,则相当于移动原文件或目录到dest表示的路径中去。
      • 重命名成功后,此File对象表示的文件或目录不再存在;而由于将原文件或目录移动到dest表示的路径中去了,所以dest表示文件或目录由不存在变为存在。

    文件或目录检测相关的方法

    1. public boolean exists(): 判断此File对象表示的文件或目录是否存在
    2. public boolean canWrite():判断此File对象表示的文件或目录是否可写
    3. public boolean canRead():判断此File对象表示的文件或目录是否可读
    4. public boolean isFile():判断此File对象是否是表示文件,而非目录
    5. public boolean isDirectory():判断此File对象是否是表示目录,而非文件
    6. public boolean isAbsolute():判断此File对象的构造方法传入的路径是否是绝对路径

    获取常规文件信息的方法

    1. public long lastModified():返回文件的最后修改时间
    2. public long length():返回文件内容的长度

    文件或目录操作相关的方法

    1. public boolean createNewFile():创建一个此File对象所表示的文件,返回true则创建成功,false则失败。

      • 如果此File对象表示的文件存在,则创建失败;
      • 如果此File对象表示的是一个存在的目录,则创建失败;
      • 如果此File对象构造方法传入路径表示的文件不存在,则创建成功。即使此路径是一个不带文件后缀扩展名的目录路径,只要此路径目录不存在,也能创建成功,新建的文件名就是路径最后一级子目录名
    2. public boolean mkdir():创建一个此File对象表示的目录,返回true则创建成功,false则失败。

      • 如果此File对象表示的是一个存在的目录,则创建失败;
      • 如果表示的是一个存在的文件,则也创建失败;
      • 如果此File对象传入路径表示的目录不存在,则创建成功(其中如果传入路径包含父目录,则要保证父目录存在,否则也会创建失败)。另外,即使传入路径是一个带文件后缀名的文件路径,只要此路径文件不存在,也能创建成功,新建目录的最后一级子目录名就是包含后缀名的文件名。
    3. public boolean mkdirs():创建一个此File对象表示的目录,如果File对象构造方法的传入路径包括父目录,则当父目录不存在时,也会自动创建不存在的父目录。返回true创建成功,false则失败。

      • 如果此File对象表示一个存在的文件或目录,则创建失败;
      • 如果此File对象构造方法的传入路径只是一级目录路径(即不包含父目录),并且此路径表示的目录不存在,则也能创建成功;
      • mkdir方法相比较,只是多了一个当传入路径包含父目录,且此父目录不存在时,会自动创建父目录的功能。
    4. public boolean delete():删除此File对象表示的文件或目录,返回true则删除成功,false则失败。

      • 如果此File对象表示的文件或目录不存在,则删除失败;
      • 如果此File对象表示的是一个目录,则当此目录下存在子目录或文件时,需把此目录下的所有子目录和文件都删除后,才能将此目录删除成功。
      • Java程序的删除不走回收站!
    5. public void deleteOnExit():注册一个删除钩子,指定当Java虚拟机退出时,删除此File对象表示的文件或目录。

    6. public static File createTempFile(String prefix, String suffix): 在默认的临时文件目录中创建一个临时的空文件,使用给定的前缀、系统生成的随机数、给定的后缀作为文件名。

      • 这是一个静态方法,可以直接通过File类来调用;
      • prefix字符串长度必须不少于3个字节,否则会报java.lang.IllegalArgumentException: Prefix string too short异常;
      • suffix参数可以为null,此时将使用默认的后缀".tmp";
    7. public static File createTempFile(String prefix, String suffix, File directory):在directory指定的父目录中创建一个临时的空文件。

       try {
       	File f2 = File.createTempFile("zengk", null);
       	System.out.println(f2.getPath());
       	System.out.println(f2.getAbsolutePath());
       } catch (IOException e) {
       	e.printStackTrace();
       }
      
       System.out.println("---------------");		
      
       try {
       	File f2 = File.createTempFile("zengk", ".java", new File("./"));
       	System.out.println(f2.getPath());
       	System.out.println(f2.getAbsolutePath());
       } catch (IOException e) {
       	e.printStackTrace();
       }
      

      在这里插入图片描述

    遍历文件或目录的方法

    1. public String[] list()

      • 若此File对象表示已存在的目录,则返回此目录下的所有文件名(不包括子目录中的文件)和一级子目录名的字符串数组;若此目录为空,则返回一个空数组;
      • 若此File对象表示已存在的文件,则返回null;
      • 若此File对象表示的目录或文件不存在,则返回null。
    2. public File[] listFiles():作用同list()方法类似,只不过返回的数组元素是表示文件或目录的File对象。

    3. public static File[] listRoots():返回系统所有的根路径的File对象。Windows中返回的就是盘符。

    文件过滤器相关的方法

    1. public File[] listFiles(FilenameFilter filter):返回此File对象下通过FilenameFilter过滤器过滤后的所有文件和一级子目录

    2. public File[] listFiles(FileFilter filter):返回此File对象下通过FileFilter过滤器过滤后的所有文件和一级子目录

      • FilenameFilter和FileFilter过滤器的区别就是accept抽象方法接收的形参不同,FilenameFilter的accept方法接收文件的父目录dir和文件名name,一般是在accept方法重写时通过new File(dir, name)得到文件的File对象。而FileFilter的accept方法直接接收文件的File对象,较FilenameFilter省略了new一个File对象的步骤。

          //FilenameFilter类的定义
          package java.io;
          public interface FilenameFilter {
              boolean accept(File dir, String name);
          }
        
          //FileFilter类的定义
          package java.io;
          public interface FileFilter {
              boolean accept(File pathname);
          }
        
          //listFiles(FilenameFilter filter)方法的定义
          public File[] listFiles(FilenameFilter filter) {
              String ss[] = list();
              if (ss == null) return null;
              ArrayList<File> files = new ArrayList<>();
              for (String s : ss)
                  if ((filter == null) || filter.accept(this, s))
                      files.add(new File(s, this));
              return files.toArray(new File[files.size()]);
          }
          
          //listFiles(FileFilter filter)方法的定义
          public File[] listFiles(FileFilter filter) {
              String ss[] = list();
              if (ss == null) return null;
              ArrayList<File> files = new ArrayList<>();
              for (String s : ss) {
                  File f = new File(s, this);
                  if ((filter == null) || filter.accept(f))
                      files.add(f);
              }
              return files.toArray(new File[files.size()]);
          }
        
          举例:
          File file = new File("d:\\");
          String[] strArray = file.list(new FilenameFilter() {
          	@Override
          	public boolean accept(File dir, String name) {
          		// 判断是否是文件,是否是以.mp4结尾
          		File file = new File(dir, name);
          		return file.isFile() && name.endsWith(".mp4");
          	}
          });
        
          File file = new File("d:\\");
          String[] strArray = file.list(new FileFilter() {
          	@Override
          	public boolean accept(File pathname) {
          		// 判断是否是文件,是否是以.mp4结尾
          		return pathname.isFile() && pathname.endsWith(".mp4");
          	}
          });
        

    文件过滤器的应用

    1. 删除目录下的所有文件(包括所有子目录下的文件)和所有子目录(需要用到递归)

       File file = new File("D:\\test");
       //删除test文件夹
       deleteFiles(file);
      
       private static void deleteFiles(File file) {
       	File[] fileArray = file.listFiles();
       	
       	if (fileArray != null) {
       		//如果封装的文件夹不为空,那么就进行遍历,获得每一个文件或文件夹
       		for (File f : fileArray) {
       			if (f.isDirectory()) {
       				//如果被封装文件夹的子文件还是个文件夹,那么继续封装起来进行判断
       				deleteFiles(f);
       			} else {
       				//如果被封装起来的子文件夹正好就是个文件,那么直接删除
       				System.out.println(f.getName() + "***" + f.delete());
       			}
       		}
       	} 
       	System.out.println(file.getName() + "***" + file.delete());
       }
      
    2. 遍历目录下的所有文件路径

       File file = new File("D:\\test");
       showFiles(file);
      
       private static void showFiles(File file) {
       	// 获取该目录下的所有文件或者文件夹的File[]数组。
       	File[] fileArray = file.listFiles();
      
       	if(fileArray != null){
       		// 遍历File[]数组,获取到每一个File对象
       		for (File f : fileArray) {
       			// 判断该File对数是否是目录
       			if (f.isDirectory()) {
       				showFiles(f);
       			} else {
       				// 输入文件路径
       				System.out.println(f.getAbsolutePath());
       			}
       		}
       	}
      
       	System.out.println(file.getAbsolutePath());
       }
      
    展开全文
  • 文件IO 第一天(标准IO

    千次阅读 2018-08-06 21:40:23
     定义:文件(File)是一个具有符号名字的一组相关联元素的有序序列。文件可以包含的内容十分广泛,操作系统和用户都可以将具有一定独立功能的一个程序模块、一组数据或一组文字命名为一个文件。  文件名:这个...
  • Linux文件IO

    千次阅读 2018-09-18 19:15:28
    1 基本文件操作 1.1函数说明  open()函数:用于打开或创建文件, 在打开或创建文件时可以指定文件的属性及用户的权限等各种参数。  close()函数:用于关闭一个被打开的文件。 当一个进程终止时, 所有被它...
  • Java基础 file IO

    2017-12-12 08:25:47
    java.io.File类 代表磁盘上的一个文件或者目录的对象 该对象属性中包含了文件或目录的相关信息,如名称、长度、所含文件个数等,调用它的方法则可以完成对文件或目录的常用管理操作,例如,创建、删除等操作。 ...
  • Python中FileIO

    千次阅读 2017-05-29 20:36:47
    class io.FileIO(name, mode=’r’, closefd=True, opener=None)  FileIO表示包含字节数据的操作系统级文件。它实现了RawIOBase接口(当然也实现了IOBase接口)。  FileIO中的参数nane可以是以下两种的任一种: ...
  • SCST<iSCSi> BlockIO Vs FileIO

    千次阅读 2013-09-02 11:10:47
    iSCSi有BlockIO以及FileIO两种模式,此次通过dd对两种模式下的性能做初步测试。 1.BlockIO 1.1 Write [root@euca-nc send_targets]# dd if=/dev/zero of=/dev/sdb bs=1M count=20480 20480+0 records in 20480+...
  • 读取LIO创建的fileio backstore的内容

    千次阅读 2015-08-06 18:48:17
    LIO支持多种的backstore,但是最简单,而且最灵活的,应该就是fileio了。 但是有一个缺点,就是不容易看到里面的内容。 不容易是不容易,但是也有方法可以做到的。 查看Sparc Solaris格式化后的fileio backstore ...
  • 读取一堆文件或者图片时,突然matlab报这个错..Message Catalog MATLAB:FileIO was not loaded from the file. Please check file location, format or contents网上说的是文件句柄没有关闭,,fclose(all),,,我试了试...
  • 浅析IOFILE结构及利用

    千次阅读 2018-11-21 19:24:32
    浅析IOFILE结构及利用 本文首发于先知社区 在hctf中遇到了这么一个题,也借这个题专门去补了补自己在IOFILE这一块知识点的知识。 libio.h中的结构 struct _IO_FILE { int _flags; /* High-order word is _IO_...
  • Java.io.File类的使用

    千次阅读 2019-04-15 12:18:19
    1简介 在一个程序员编程生涯的过程中,File类的使用是不可跨越的基础,因为有些应用场景导致程序员们必须掌握常用类的使用,比如说文件上传...File类是java.io包中唯一代表磁盘文件本身对象。File类定义了一些与平台...
  • Java中的File类和IO

    千次阅读 2019-08-19 20:40:38
    1.File:翻译是文件,用于表达java中的路径名。 2.路径:用于表示文件或者文件夹在当前系统中的位置 3.路径的分类: 绝对路径 相对路径 4.绝对路径:没有任何的歧义,也没有任何的前提条件 Windows,从盘符开始的...
  • IO流:IO流用来处理设备之间的数据传输,上传文件和下载文件因为IO流操作的对象就是File文件,而且操作过程中会出现很多的异常,所以还要学习异常和File文件类异常:Java程序在运行过程中出现的错误Throwable是所有...
  • Error:Internal error: (java.io.IOException) Cannot create empty file: C:\Users\鏋楁案鍩�\.IntelliJIdea2019.1\system\compile-server\schoolrollsystem_d8001572\timestamps\data java.io.IOException: ...
  • Sysbench对磁盘IO进行性能测试

    千次阅读 2017-07-08 23:48:02
    SysBench 是一款开源的、跨平台的、模块化的、多线程的性能测试工具, 通过高负载地运行在数据库上, 可以执行 CPU/内存/线程/IO/数据库 等方面的性能测试. 用于评估操作系统的性能参数. 主要用于评估测试各种不同...
  • qml 实现文本编辑器

    千次阅读 2017-02-11 21:09:03
    实现文本编辑器要文件的 IO 功能,但是 QML 并没有提供,所以...#ifndef FILEIO_H #define FILEIO_H #include #include #include class FileIO : public QObject { Q_OBJECT public: Q_PROPERTY(QString source
  • 本文创建时间:2018-12-01 Windows 下安装 Scrapy 报错 安装环境 Windows 10, 安装时间 2018-12-01 pip install scrapy 报错。 主要报错内容: raiser.c c:\python\python37\include\pyconfig.h(59): fatal error...
  • C语言 文件IO的使用

    千次阅读 2018-01-22 17:10:57
    简单介绍C语言文件操作函数的用法(可以直接使用): fopen fclose fprintf fscanf fputc fgetc fread fwrite ... 函数原型: FILE *fopen( const char *filename, const char *mode
1 2 3 4 5 ... 20
收藏数 860,638
精华内容 344,255
关键字:

file io