精华内容
下载资源
问答
  • java文件读写

    2017-09-14 17:44:06
    java文件读写,这是本人总结的java读写文件的一下操作 java文件读写,这是本人总结的java读写文件的一下操作 java文件读写,这是本人总结的java读写文件的一下操作
  • java 文件读写

    2014-01-04 17:24:32
    java文件读写,读取properties配置文件,读取目录及文件
  • Java文件读写

    万次阅读 多人点赞 2019-06-07 21:17:16
    LAB11(文件读写): 1.FileInputStream(文件输入流)是从系统的某个文件中获得输入字节 FileOutputStream(File file)是向File对象的文件写入数据 2.无参的read()方法返回int类型,返回值是数据下一个字节的字节...

    1.%g用于输出科学计数法

    2.用printf输出换行除了’\n’,还可以用’%n’

    3.File类的几个构造方法:
    1)File(String directoryPath)
    2)File(String directoryPath,String filename)
    3)File(File dirObj,String filename)
    4)File(URI uri)
    注意,这里的对象指的可能是一个我们通常所说的文件,也可能是一个目录(路径);可以是个具体存在的文件,也可以是个尚未存在的文件。

    4.所谓的数据流是指一组有顺序的、有起点和终点的字节集合

    5.Java程序不能直接操纵I/O设备,而是在程序和设备之间加入了一个中间介质,这就是流。流是数据传输的抽象表达,与具体设备无关,程序一旦建立了流,就可以不用理会起点或终点是何种设备

    6.输入流将数据从文件、标准输入或者其它外部设备输入加载到内存。

    7.输入输出数据流:
    1)以字节流传输的输入数据流都是抽象类InputStream的子类;以字符流传输的输入数据流都是抽象类Reader的子类。
    2)以字节流传输的输出数据流都是抽象类OutputStream的子类;以字符流传输的输出数据流都是抽象类Writer的子类。

    8.类File一般不涉及文件内部的具体内容,而是从整体上对文件进行处理,如获取各种各样的文件消息或者删除文件。类File不仅可以对文件进行操作,而且还可以对路径进行操作。

    9.父目录:当前所在目录的上一层目录(文件夹)
    子目录:当前所在目录的下一层目录(文件夹)

    10.mark()通常与reset()方法配合使用,可重复读取输入流所指定的字节数据。例如:若fis是一个输入流,如果想读取相同的字 节数据到字节数组b1和b2中,可通过以下语句实 现,先标记输入流中当前位置,读取数据后重置 读取位置。

    fis.mark(5);
    byte[] b1=new byte[5], byte[] b2=new byte[5],
     fis.read(b1,0,5);
    fis.reset();
     Fis.read(b2,0,5);
    

    11.mark(int readlimit)方法表示标记当前位置,并保证在mark以后最多可以读取readlimit字节数据。reset()方法表示重置移动读取指针到上一次mark的地方。

    12.FileOutputStream用于向本地文件中写入数据,注意,是往本地文件中写入,不是向控制台输出。

    13.FileInputStream不支持缓冲和做标记

    14.InputStream和OutputStream都是抽象类,不能通过new OutputStream()的方法构造各自的实例。我们可以通过构造它们的子类的实例方式构造该类型的实例(类似于List和Arraylist的关系)。一个构造InputStreamReader实例的例子:

    new InputStreamReader(new FileInputStream("data.txt"));
    

    15.FilterInputStream:过滤器输入流是其它带过滤器的输入流的超类,它的方法和InputStream的方法完全一样,也就是说前者只是简单地重写了后者的所有方法。
    1)它的构造方法是FilterInputStream(InputStream in)。过滤器输入流以一个InputStream为自己的数据。
    2)成员变量:protected InputStream in。在构造方法里会对这个变量赋值,即this.in=in

    16.当创建BufferedInputStream或者BufferedOutputStream的实例时,均会在内存中开辟一个字节数组的存储单元(一般称为缓存),默认为512字节,用来存放数据流中的数据。

    17.通常情况下,缓冲区的大小应为内存页或者磁盘块等的整数倍,以避免页或块的浪费。

    18.write(int b):将b转成二进制后,把b的低8位写到输出流。把所有32位都写到输出流的函数是writeInt(int b)。

    19.使用对象流读取和写入对象时,要保证对象是串行化的。(串行化的概念:指对象通过把自己转化为一系列字节,记录字节的状态数据,以便再次利用的这个过程)

    20.串行化(Serializable)是Java.io包中定义的一个接口。这个接口中没有定义任何方法,只是一个特殊的标记,用来告诉编译器,这个对象参加了串行化的协议,可以把它串行化。一个类要具有可串行化的特性就必须实现接口Java.io.Serializable。

    21.有些对象不能串行化,例如Thread对象,FileInputStream对象以及FileOutputStream对象等,因为其状态是暂时的。

    22.对不希望串行化的对象要用关键字transient修饰。

    23.创建管道输入流对象(PipeInputStream):

    public PipeInputStream();
    public PipeInputStream(PipeOutputStream src);
    

    24.创建管道输出流对象(PipeOutputStream):

    public PipeOutputStream();
    public PipeOutputStream(PipeInputStream src)
    

    25.被连接的管道流必须没有与任何别的管道流连接,否则会抛出IOException异常,管t道输出流是往管道中写数据,管道输入流是往管道中读数据。(类似文件和文件流的关系)因为InputStream本来就是字节输入流,InputStream对应的字符流是Reader类。

    26.InputStreamReader类继承自Reader类,通过其read方法从字节流中读取一个或者多个字节数据转换为字符数据。它可以接一个缓冲流来提高效率。OutputStreamWriter同理。

    27.InputStream构造方法摘要 :出处

    1)InputStreamReader (InputStream  in)  创建一个使用默认字符集的 InputStreamReader。 
    2)InputStreamReader (InputStream  in, Charset  cs)  创建使用给定字符集的 InputStreamReader。 
    3)InputStreamReader (InputStream  in, CharsetDecoder  dec)   创建使用给定字符集解码器的 InputStreamReader。 
    4)InputStreamReader (InputStream  in, String  charsetName)  创建使用指定字符集的 InputStreamReader。
    

    28.一种高效的写法:

    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    

    29.与InputStreamReader是字节转字符不同,OutputStreamWriter是字符转字节。反正外界传进来是字节,往外界输出的也是字节。

    30.BufferReader的两个构造方法:

    BufferedReader(Reader in);
    BufferedReader(Reader in,int size);
    

    31.小结:
    1)File,FileStream是处理本地文件的类
    2)DataStream是一个过滤流的子类,借此可以读写各种基本数据。
    3)BufferedStream的作用是在数据送到目的地之前先缓存,达到一定数量时再送到目的地,以提高程序的运行效率。
    4)PipedStream适合于一个处理的输出作为另一个处理的输入的情况。

    LAB11(文件读写):
    1.FileInputStream(文件输入流)是从系统的某个文件中获得输入字节
    FileOutputStream(File file)是向File对象的文件写入数据

    2.无参的read()方法返回int类型,返回值是数据下一个字节的字节码,如果已到达流的最后面了,就返回-1;带参数的read()方法返回的是读取的字节数(到达数据的末端返回值为-1)

    3.read()源码:

    //带参
        public int read(byte b[], int off, int len) throws IOException {
        //这里是一些前期判断,我们的buffer[]数组不能为空,偏移量一开始不能比0小,要读取的字节长度也不能比0小
            if (b == null) {
                throw new NullPointerException();
            } else if (off < 0 || len < 0 || len > b.length - off) {
                throw new IndexOutOfBoundsException();
            } else if (len == 0) {
                return 0;
            }
    
            int c = read();
            if (c == -1) {
                return -1;
            }
            b[off] = (byte)c;
    
            int i = 1;
            try {
                for (; i < len ; i++) {
                    c = read();
                    if (c == -1) {
                        break;
                    }
                    b[off + i] = (byte)c;
                }
            } catch (IOException ee) {
            }
            return i;
        }
        //--------------------分割线--------------------------
        public int read(byte b[]) throws IOException {
            return read(b, 0, b.length);
        }
    
    //不带参
    /**
         * Reads the next byte of data from the input stream. The value byte is
         * returned as an <code>int</code> in the range <code>0</code> to
         * <code>255</code>. If no byte is available because the end of the stream
         * has been reached, the value <code>-1</code> is returned. This method
         * blocks until input data is available, the end of the stream is detected,
         * or an exception is thrown.
         *
         * <p> A subclass must provide an implementation of this method.
         *
         * @return     the next byte of data, or <code>-1</code> if the end of the
         *             stream is reached.
         * @exception  IOException  if an I/O error occurs.
         */
        public abstract int read() throws IOException;
    

    4.用FileInputStream向文件中写入内容的步骤:
    1)建立File对象:File in=new File(String pathname)
    2)构造字符串:String text=“XXXXX”
    3)字符串转byte,并指定编码方式:byte[] a=text.getBytes(“UTF-8”)
    4)建立文件输出流:FileOutputStream o=new FileOutputStream(File filename)
    5)开始写入:o.write(a)
    6)关闭输出流:o.close()

    5.删除String中的特定字符串:用replace方法即可,把待删除字符串替换成""即可达到删除字符串的目的。

    6.获取子字符串:String.subString(int beginindex,int endindex),endindex表示子字符串在原字符串中的结束位置,也就是’\0’的位置。这个方法还可以用来拼接字符串,从而实现删除特定位置字符串的目的。

    7.FileReader介绍:
    1)Reader类是定义Java的流式字符输入模式的抽象类。
    2)writer类是定义流式字符输出的抽象类
    3)FileReader类创建了一个可以读取文件内容的Reader类
    4)FileWriter创建一个可以写文件的Writer类
    用FileReader类写文件示例:

      import  java.io.*;
    
        class FileWriterDemo {
    
            public static void  main (String args[ ]) throws Exception {
    
                String source = "learn how to write to file";
    
                FileWriter  f1 = new FileWriter("file1.txt");
    
                for  (int i=0; i<buffer.length; i +=2) {
    
                    f1.write (buffer[i]);
    
                 }
    
                fo.close();
    
                 FileWriter f2 = new FileWriter("file2.txt");
    
                f2.write(buffer);
    
                f2.close();
    
                FileWriter  f3 = new FileWriter ("file3.txt");
    
                f2.write(buffer,buffer.length-buffer.length/4, buffer.length/4);
    
            }
    
    }
    

    8.用FileWriter.write(String)向文件中写入字符串时,如果字符串中有换行,那么构造这个字符串的时候你得在换行符\n前加一个\r,因为在Windows系统里面\r\n才是换行

    9.解决读取文件时乱码问题:先FileInputStream,然后InputStreamReader,最后是BufferedReader,就是文件–》按字节读取–》按流读取

    public static void copyFile (String sourceFile, String targetFile) throws IOException {
            FileWriter fw_o=new FileWriter(targetFile);
            FileInputStream fis=new FileInputStream(sourceFile);
            InputStreamReader fr=new InputStreamReader(fis,"gbk");//重点是这个,我也不知道为什么用utf-8不行
            BufferedReader br=new BufferedReader(fr);
            BufferedWriter bw=new BufferedWriter(fw_o);
            String s=new String();
            int i=0;
            while ((s=br.readLine())!=null){
                System.out.println(s);
                bw.write(s);
                bw.newLine();
            }
            bw.close();
        }
    

    原文件内容:
    在这里插入图片描述
    运行输出:
    在这里插入图片描述

    展开全文
  • java文件读写操作大全java文件读写操作大全java文件读写操作大全java文件读写操作大全java文件读写操作大全
  • JAVA文件读写

    2015-04-17 23:51:10
    一、文件创建: File f = new File("E:/javatest/filetest/filetest1");// f指向E:/javatest/filetest/filetest1 File类型的值其实就是一个目录,一个字符串 f.mkdirs();//创建目录 f.mkdirs()和 f.mkdir()都...

    一、文件创建:

    File f = new File("E:/javatest/filetest/filetest1");//  f指向E:/javatest/filetest/filetest1  File类型的值其实就是一个目录,一个字符串

    f.mkdirs();//创建目录    f.mkdirs()和 f.mkdir()都可以创建目录,区别是前者可以在现有目录上创建多级目录,后者只能在现有目录上创建一级目录




    list()方法返回的是没完整路径的文件名 listFiles()方法有完整路径的文件名
    
    
    
    
    二、文件读写
    得总结一下几个大类以及之间的关系

    一 FileInputStream 方式读写 可以读写 jpg doc txt等文件,因为  以字节流 方式传输

    二 FileReader 方式读写 只能读写txt文件,因为以 字符流 方式传输

    BufferedReader 从字符输入流中读取文本,缓冲各个字符,从而提供字符、数组和行的高效读取。
    // FileInputStream(file):读取本地文件中的字节数据,文件可以通过文件系统中的 File 对象 file 指定
    //InputStreamReader:字节流通向字符流的桥梁:它使用指定的 charset 读取字节并将其解码为字符(字节流文件,编码方式)java.io.BufferedReader与java.io.BufferedWriter类各拥有8192字符的缓冲区。当 BufferedReader在读取文本文件时,会先尽量从文件中读入字符数据并置入缓冲区,而之后若使用read()方法,会先从缓冲区中进行读取。如 果缓冲区数据不足,才会再从文件中读取,使用BufferedWriter时,写入的数据并不会先输出至目的地,而是先存储至缓冲区中。如果缓冲区中的数 据满了,才会一次对目的地进行写出。例如一个文件,通过缓冲区可减少对硬盘的输入/输出动作,以提高文件存取的效率


    展开全文
  • java 文件读写 java 文件读写java 文件读写 java 文件读写java 文件读写 java 文件读写java 文件读写 java 文件读写
  • 主要为大家详细介绍了java文件读写工具类,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Java文件读写操作

    千次阅读 2017-08-14 09:45:54
    Java文件读写操作

    代码

    1. package fileOperation;
    2.     
    3. import java.io.BufferedReader;
    4. import java.io.BufferedWriter;
    5. import java.io.File;
    6. import java.io.FileOutputStream;
    7. import java.io.FileReader;
    8. import java.io.FileWriter;
    9. import java.io.IOException;
    10. import java.io.OutputStreamWriter;
    11.     
    12. public class FileOperation {
    13.     
    14.     public static void main(String[] args) {
    15.         String filePath = "D:/test/test.txt";
    16.         String content = "第一行\n第二行\n";
    17.         String content2 = "第三行\n第四行\n";
    18.         createFile(filePath);
    19.         writeFile(filePath, content);
    20.         writeFile(filePath, content2);
    21.         readFile(filePath);
    22.     }
    23.     
    24.     /*
    25.     *按行读取文件
    26.     */
    27.     public static void readFile(String filePath) {
    28.         File file = new File(filePath);
    29.         BufferedReader reader = null;
    30.         try {
    31.             reader = new BufferedReader(new FileReader(file));
    32.             String tempString = null;
    33.             while ((tempString = reader.readLine()) != null) {
    34.                 System.out.println(tempString);
    35.             }
    36.             reader.close();
    37.         } catch (IOException e) {
    38.             e.printStackTrace();
    39.         } finally {
    40.             if (reader != null) {
    41.                 try {
    42.                     reader.close();
    43.                 } catch (IOException e1) {
    44.                 }
    45.             }
    46.         }
    47.     }
    48.     
    49.     /*
    50.     *以追加方式写文件
    51.     */
    52.     public static void writeFile(String filePath, String conent) {
    53.         BufferedWriter out = null;
    54.         try {
    55.             out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filePath, true)));
    56.             out.write(conent);
    57.         } catch (Exception e) {
    58.             e.printStackTrace();
    59.         } finally {
    60.             try {
    61.                 if (out != null) {
    62.                     out.close();
    63.                 }
    64.             } catch (IOException e) {
    65.                 e.printStackTrace();
    66.             }
    67.         }
    68.     }
    69.     
    70.     /*
    71.     *创建文件
    72.     */
    73.     public static void createFile(String filePath) {
    74.         File file = new File(filePath);
    75.         if (file.exists()) {
    76.             //System.out.println("文件已存在");
    77.         } else {
    78.             try {
    79.                 File fileParent = file.getParentFile();
    80.                 if (fileParent != null) {
    81.                     if (!fileParent.exists()) {
    82.                         fileParent.mkdirs();
    83.                     }
    84.                 }
    85.                 file.createNewFile();
    86.             } catch (IOException e) {
    87.                 e.printStackTrace();
    88.             }
    89.         }
    90.     }
    91.     
    92.     /*
    93.     *以追加方式写文件,效率低
    94.     */
    95.     public static void writeFileByFileWriter(String filePath, String content) {
    96.         FileWriter writer = null;
    97.         try {
    98.             writer = new FileWriter(new File(filePath), true);
    99.             writer.write(content);
    100.         } catch (IOException e) {
    101.             e.printStackTrace();
    102.         } finally {
    103.             try {
    104.                 if (writer != null) {
    105.                     writer.close();
    106.                 }
    107.             } catch (IOException e) {
    108.                 e.printStackTrace();
    109.             }
    110.         }
    111.     }
    112.     
    113. }

    结果

    1. 第一行
    2. 第二行
    3. 第三行
    4. 第四行
    展开全文
  • Java文件读写文件方式总结
    Java文件读写文件方式总结
    
    展开全文
  • JAVA 文件读写操作

    2011-03-16 15:56:57
    JAVA 文件读写操作 在 JDK 1.0 中,通常是用 InputStream & OutputStream 这两个基类来进行读写操作的。 InputStream 中的 FileInputStream 类似一个文件句柄,通过它来对文件进行操作
  • java文件读写操作

    2009-09-07 15:36:05
    java学习笔记,新手入门,java文件读写的一些例子!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,408
精华内容 6,563
关键字:

java文件读写

java 订阅