js怎么实现io流写入txt文档？

Posted 2023-04-26

var fso=new ActiveXObject("Scripting.FileSystemObject");
var f1=fso.createtextfile("e:\\b.txt",true); //
f1.WriteLine("第一行文字");
这些我都会，我的问题是我想打开b.txt在第一行文字后边继续写。问如何实现

1、首先用java生成txt文件有有两种方式，一种是通过字符流（或字节流），另一种是直接调用PrintWriter类。字符流（字节流）代码如下：import java.io.File;import java.io。

2、FileOutputStream;public class TxtWirte public void DOWriteTxt(String file, String txt)   try   FileOutputStream os = new FileOutputStream(new File(file), true);  。

3、os.write((txt + "\\n").getBytes());  catch (Exception e)    e.printStackTrace();  public static void main(String[] args)   new TxtWirte().DOWriteTxt("D:\\\\问好.txt", "你好！"); 。

4、调用PrintWriter类：import java.io.*;public class C    public static void main( String[ ] args ) throws Exception   PrintWriter pw = new PrintWriter( new FileWriter( "D;\\\\问好.txt" ) ); 。

5、pw.print("你好" );pw.close();如果要生成doc文件，将“D:\\\\问好.txt”改成“D:\\\\问好.doc”即可。的：java写一定内容到指定路径的文件中程序源码。

6、最后循环控制变  FileOutputStream outfile=null;  //文档输出对  //生成对象outfile。就完成了。

参考技术A 一帮烂厨子 就会瞎扯淡。发没用的代码有么
var fso=new ActiveXObject("Scripting.FileSystemObject"); //实例化
f1 = fso.OpenTextFile("c:\\test.txt",8,true);//这样就能继续写了。分清WriteLine，和Write
f1.WriteLine(" 这是回车行");
//f1.Write("这才是一行文字： ");
f1.Close();
鄙视一楼二楼这种看见分就瞎答的本回答被提问者采纳 参考技术B

先把原有的内容读取出来，比如：

readAsString:function(file)

   var ado=new ActiveXObject("adodb.stream");

   ado.Type=2;

   ado.Mode=3;

   ado.Open();

   ado.LoadFromFile(file);

   var str=ado.ReadText();

   ado.Close();

   return str;

  

然后再写入一次

参考技术C 建议你用ajax后台处理吧。前台ActiveXObject貌似只兼容IE

Java实现文件写入——IO流（输入输出流详解）

输入输出的重要性：
     输入和输出功能是Java对程序处理数据能力的提高，Java以流的形式处理数据。流是一组有序的数据序列，根据操作的类型，分为输入流和输出流。

     程序从输入流读取数据，向输出流写入数据。Java是面向对象的程序语言，每一个数据流都是一个对象，它们提供了各种支持“读入”与“写入”操作的流类。

Java的输入输出功能来自java.io 包中的InputStream类、OutputStream类、Reader类和Writer类以及继承它们的各种子类。

（一）解析文件处理的奥秘



1、学习使用文件类 ： File类

     File类用于封装系统的文件和目录的相关信息。在该类中定义了一些与平台无关的方法来操作文件。例如文件的大小、修改时间、文件路径等。
创建 File 对象可以通过下面3种方式：

方法1：    方法2：    方法3：
new File(String pathName)    File file = new File(“E://1.txt”)    new File(String parent , String child)
parent :父抽象路径名；child：子路径名字符串
2、如何获取文件信息
File 类是对文件和文件夹的抽象，包含了对文件和文件夹的多种属性和操作方法。File类的常用方法如下表：

返回    方法    说明
String    getName    获取文件名称
String    getParent    获取文件的父路径字符串
String    getPath    获取文件的相对路径字符串
String    getAbsolutePath    获取文件的绝对路径字符串
boolean    exists    判断文件或者文件夹是否存在
boolean    isFile    判断是不是文件类型
boolean    isDirectory    判断是不是文件夹类型
boolean    delete    删除文件或文件夹，如果删除成功返回结果为true
boolean    mkdir    创建文件夹，创建成功返回true
boolean    setReadOnly    设置文件或文件夹的只读属性
long    length    获取文件的长度
long    lastModified    获取文件的最后修改时间
String[ ]    list    获取文件夹中的文件和子文件夹的名称，并存放到字符串数组中
下面通过实例介绍File类获取文件信息

package com.zch.io;

import java.io.File;
import java.util.Date;

/**
 * 在src根目录下创建FileInfo类，在该类的主方法中创建文件对象，通过File类的相关方法，获取文件的相关信息
 *
 * @author zch
 *
 */
public class FileInfo {
    public static void main(String[] args) {

        String filePath = "src/com/zch/io/FileInfo.java";
        // 根据指定路径创建文件对象
        File file = new File(filePath);
        System.out.println("文件名称:" + file.getName());
        System.out.println("文件是否存在：" + file.exists());
        System.out.println("文件的相对路径：" + file.getPath());
        System.out.println("文件的绝对路径：" + file.getAbsolutePath());
        System.out.println("是否为可执行文件：" + file.canExecute());
        System.out.println("文件可以读取：" + file.canRead());
        System.out.println("文件可以写入：" + file.canWrite());
        System.out.println("文件上级路径：" + file.getParent());
        System.out.println("文件大小：" + file.length() + "B");
        System.out.println("文件最后修改时间：" + new Date(file.lastModified()));
        System.out.println("是否文件类型：" + file.isFile());
        System.out.println("是否为文件夹：" + file.isDirectory());

    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
运行结果如下：

文件名称:FileInfo.java
文件是否存在：true
文件的相对路径：srccomzchioFileInfo.java
文件的绝对路径：D:JavaIOsrccomzchioFileInfo.java
是否为可执行文件：true
文件可以读取：true
文件可以写入：true
文件上级路径：srccomzchio
文件大小：1195B
文件最后修改时间：Sat Sep 09 21:30:10 CST 2017
是否文件类型：true
是否为文件夹：false
1
2
3
4
5
6
7
8
9
10
11
12
在使用delete()方法删除File对象时，如果删除的对象是目录，该目录中的内容必须为空。

（二）使用字节输入输出流
     字节流用于处理二进制数据的读取和写入，它以字节为单位，InputStream类和OutputStream类是字节流的抽象类，它们定义了数据流读取和写入的基本方法。各个子类会依其特点实现或覆盖这些方法。

1、字节数入流抽象类InputStream

      InputStream 类是字节输入流的抽象类，定义了操作输入流的各种方法，这些方法如表：

返回    方法    说明
int    available()    返回当前输入流的数据读取方法可以读取的有效字节数量
Abstract int    read()    从当前数据流中读取一个字节。若已达到流结尾，则返回-1
int    read(byte[ ] bytes)    从当前输入流读取一定的byte数据，并存取在数组中，然后返回读取的byte数据的数量，若已到达流结尾，则返回-1。
void    reset()    将当前的输入流重新定位到最后一次调用mark()方法时的位置
void    mark(int readlimit)    在当前输入流中做标记位置，当调用reset()方法时将返回到该位置，从标记位置开始，到再读入readlimit个字符为止，这个标记都维持有效。
Boolean    markSupported()    测试当前输入流是否支持mark()和reset()方法，只要其中一个不支持，则返回false
long    skip(long n)    跳过和丢弃当前输入的n个字节数据
void    close()    关闭当前输入流，并释放任何与之相关联的系统资源
     InputStream 类是抽象类，不能通过new关键字来创建该实例对象，需要其子类创建该实例对象。下面通过实例如何使用InputStream从控制台获取用户输入的数据信息。

package com.zch.io;

import java.io.IOException;
import java.io.InputStream;

/**
 * 创建InputStream实例inp，并将其赋值为System类的in属性，定义为控制台输入流，从inp输入流中获取字节信息，
 * 用这些字节信息创建字符串，并将其在控制台上输出。
 * @author zch
 *
 */
public class InputMessage {
    public static void main(String[] args) {
        InputStream inp = System.in;
        
        byte[] bytes = new byte[1024];
        
        try {
            while(inp.read() != -1){
                //根据用户输入的信息创建字符串
                
                String str = new String(bytes).trim();
                
            }
            inp.close();        //关闭流
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

2、字节输出流抽象类OutputStream类

OutputStream定义了输出流的各种方法，如下表：
返回    方法    说明
void    write(byte[ ] b)    将byte[ ] 数组中的数据写入当前输出流
void    write(byte[] b ,int off, int len)    将byte[ ]数组下标off开始的len长度的数据写入当前输出流
Abstract void    write（int b)    写入一个byte数据到当前输出流
void    flush()    刷新当前输出流，并强制写入所有缓冲的字节数据
void    close（）    关闭当前输出流
     和InputStream类一样，OutputStream 类是抽象类，不能通过new关键字来创建该实例对象，需要其子类创建该实例对象。

package com.zch.io;

import java.io.IOException;
import java.io.OutputStream;

/**
 * 创建OutputStream实例out,并将其赋值为System.out标准输出流。通过write()方法向流写入数据。
 * @author zch
 *
 */
public class OutputData {
    public static void main(String[] args) {
    OutputStream output = System.out;            //实例化OutputStream对象
    
    byte[] bytes = "使用OutputStream输出流在控制台输出字符串 ".getBytes();        //创建bytes数组
    
    try {
        output.write(bytes);
        
        bytes = "输出内容： ".getBytes();
        output.write(bytes);        //向流中写入数据
        
        bytes = "Java数据交互管道——IO流 ".getBytes();
        output.write(bytes);
        
        output.close();
        
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
输出结果如下：

使用OutputStream输出流在控制台输出字符串
输出内容：
   Java数据交互管道——IO流

1
2
3
4



3、文件字节输入流类 ： FileInputStream类

     文件字节输入流可以从指定路径的文件中读取字节数据。文件字节输入流类继承InputStream类，并实现了读取输入流的各种方法。
       创建文件字节输入流创建的构造方法语法如下：

语法1：以File对象为参数创建FileInputStream实例
new FileInputStream（File file）
1
语法2：以文件对象的绝对路径为参数创建FIleInputStream实例
new FileInputStream（String filepath）
1
4、文件字节输出流类：FileOutputStream
      文件字节输出流关联指定文件路径的文件，数据通过文件字节输出流以字节为单位输出并保存到文件中。文件字节输出流继承自OutputStream类，并实现OutputStream类的各种方法。

       文件字节输出流的构造方法语法如下：

语法1：以File对象为参数创建FileOutputStream实例
new FileOutputStream（File file）
1
语法2：以文件对象的绝对路径为参数创建FIleOutputStream实例
new FileOutputStream（String filepath）

1
2
下面通过实例介绍文件的写入和读取：

package com.zch.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 创建OutputStream实例out,并将其赋值为System.out标准输出流，通过write方法向流中写入数据
 *
 * @author zch
 *
 */
public class FileCreate {
    public static void main(String[] args) {
        File file = new File("D:/", "word.txt");  //创建文件对象

        try {
            if (!file.exists()) {                //如果文件不存在则新建文件
                file.createNewFile();            

            }
            FileOutputStream output = new FileOutputStream(file);

            byte[] bytes = "Java数据交流管道——IO流".getBytes();

            output.write(bytes);                //将数组的信息写入文件中

            output.close();

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        try {
            FileInputStream input = new FileInputStream(file);

            byte[] bytes2 = new byte[1024];

            int len = input.read(bytes2);

            System.out.println("文件中的信息是：" + new String(bytes2, 0, len));

            input.close();

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
（三） 使用字符输入输出流
      字符输入输出流 与 字节输入输出流有相同的功能，但传送数据的方式不一样，字节流以字节为单位传送数据，可以使任何类型的数据，例如文本、音频、视频、图片等。字符流以字符为单位传送数据，只能传送文本类型的数据。使用字符输入输出流的好处是，当读取中文时不会出现乱码问题，而使用字节输入输出流时，却不能保证这一点。

1、字符输入流抽象类：Reader类
该类定义了操作字符输入流的方法，如下表：

返回    方法    说明
boolean    ready()    判断此数据流是否准备好
int    read()    读入一个字符，若已读到流结尾，则返回值为-1
int    read(char[ ])    读取一些字符到char[ ]数组内，并返回所读入的字符的数量，若已到达流结尾，则返回-1
Abscract int    read(char[ ] chars,int off,int len)    读取一些字符到char[ ]数组下标从off开始到off+len的位置，并返回所读入的字符的数量，若已到达流结尾，则返回-1；
void    reset()    将当前输入流重新定位到最后一次mark（）方法时的位置
void    mark(int readLimit)    将当前输入流中做标记，当调用reset方法时将返回到该位置，从标记位置开始，到再读入readLimit个字符为止，这个标记都维持有效
boolean    markSupported    测试当前输入流是否支持mark()方法和reset()方法。只要有一个方法不支持，则返回-1
long    skip(long n)    跳过参数n指定的字符数量，并返回所跳过字符的数量
Abstract void    close()    关闭字符输入流，并释放与之关联的所有资源



2、字符输出流类Writer类
       Writer 类主要是用于解决字符输入流的类，其地位与Reader类在输入流的地位和作用是相同的，也是所有字符输出流的流类。


Writer类的主要方法如下：

返回    方法    说明
void    write(char[ ] cbuf)    将字符数组的数据写入字符输出流
Abstract void    write(char[ ] cbuf int off ,int len)    将字符数组从下标off 开始向输入流写入长度为len的数据
void    write(int c )    向字符输入流中写入一个字符数据
void    write(String str )    向输入流中写入一个字符串数据
void    write(String str , int off ,int len)    向输入流中写入一个字符串从off 开始长度为len的数据
Abstract void    flush()    刷新当前输出流，并强制写入所有缓冲区的字节数据
void    close()    向输出流中写入缓冲区的数据，然后关闭当前输出流，释放所有与当前输出流相关联的系统资源

3、文件字符输入流FileReader
       文件字符输入流与文件字节输入流的功能相似，但是传送数据的方式不一样，字节流以字节为单位传送数据，可以使文本、视频、音频、图片等。字符流以字符为单位传送数据，只能传送文本类型的数据。

创建字符输入流常用的构造方法：

语法1：
new FileReader（File file）;

1
2
语法2：
new FileReader(String path);

1
2
下面通过实例介绍FileReader类读取指定磁盘文件的内容。

package com.zch.io;

import java.io.File;
import java.io.FileReader;

public class FileInAndOut {
    public static void main(String[] args) {
        //定义指定磁盘的文件的File对象
        File file = new File("D://word.txt");
        
        if(! file.exists()){
            System.out.println("对不起，不包含指定路径的文件");
        }else{
            //根据指定路径的File对象创建FileReader对象
            try {
                FileReader fr = new FileReader(file);
                
                char[] data = new char[23];            //定义char数组
                
                int length = 0;
                
                while((length = fr.read(data))>0){            //循环读取文件中的数据
                    String str = new String(data,0,length);            //根据读取文件的内容创建String 对象
                    System.out.println(str);                //输出读取内容
                }
                fr.close();                                //关闭流
                
                
                
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
运行结果如下图：




4、文件字符输出流FileWriter
       文件字符输出流继承自Writer类，提供了向文件输出的各种方法，数据通过文件字符输出流以字符为单位输出并保存到文件中。

package com.zch.io;
/**
 * 通过给定的String类型参数的指定文件名称与路径，创建FileWriter类。
 *
 * @author zch
 */
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileWriterDemo {
    public static void main(String[] args) {
        File file = new File("D://word2.txt");        //创建指定文件
        
        try {
        if(! file.exists()){
                file.createNewFile();                //如果指定文件不存在，新建文件
            
        }
        
        FileReader fr = new FileReader("D://word.txt");
        
        FileWriter fw = new FileWriter(file);                //创建FileWriter对象
        
        int length = 0;
        while((length = fr.read()) != -1){            //如果没有读到文件末尾
            fw.write(length);            //向文件写入数据
            
        }
        fr.close();                            //关闭流
        fw.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
运行后创建了Word2.txt 文件，并向其中写入数据


（四）IO流实战：
1、Java IO流实现复制文件夹
       通过IO不仅可以复制文件，还可以复制文件夹，但是文件夹内，可能包含其他文件夹，因此需要对他们进行分别复制。

package com.zch.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class CopyFile {
    public static void main(String[] args) {
        File sourceFile = null;
        File desFile = null;

        String sourceFolder = "D://简历2";
        String copyFolder = "D://copy";

        sourceFile = new File(sourceFolder);

        if (!sourceFile.isDirectory() || !sourceFile.exists()) {
            System.out.println("源文件夹不存在!");
        } else {
            desFile = new File(copyFolder);
            desFile.mkdir();

            copy(sourceFile.listFiles(), desFile);
            System.out.println("文件夹复制成功！");
        }
    }
/**
 * 创建copy方法，该方法接收文件数组和目标文件夹两个参数，如果目标文件夹不存在，则调用mkdir（）方法创建文件夹，然后再循环中将文件数组
 * 中的每个文件对象写到目标文件夹内。
 * @param fl
 * @param file
 */
    public static void copy(File[] fl, File file) {
        if (!file.exists()) { // 如果文件夹不存在
            file.mkdir(); // 建立新的文件夹
        }

        for (int i = 0; i < fl.length; i++) {
            if (fl[i].isFile()) { // 如果是文件类型，则复制文件
                try {
                    FileInputStream fis = new FileInputStream(fl[i]);
                    FileOutputStream out = new FileOutputStream(new File(
                            file.getPath() + File.separator + fl[i].getName()));

                    int count = fis.available();
                    byte[] data = new byte[count];

                    if ((fis.read(data)) != -1) {
                        out.write(data);
                    }
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

            if (fl[i].isDirectory()) { // 如果是文件夹类型
                File des = new File(file.getPath() + File.separator
                        + fl[i].getName());
                des.mkdir(); // 在目标文件夹中创建相同的文件夹
                copy(fl[i].listFiles(), des); // 递归调用方法本身
            }

        }

    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
运行本实例，会将D盘中的简历文件中的内容复制到D盘的copy文件夹中，而且包含文件夹的子文件夹

2、Java IO流实现分行向文件中写入数据
      FileWriter类可以向文件写入字符数据，如果将FileWriter类封装到BufferWriter类的缓冲字符流中，能够实现缓冲字符输出流，并且可以通过读输出流的newLine()方法，来实现数据的分行写入。

package com.zch.io;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

/**
 * 创建BranchWriter类，在主方法中定义文件对象，将该对象作为参数创建BufferedWriter类实例，
 * 调用该实例的writer方法将数据写入文件中，然后 调用newLine()方法写入换行符，实现分行向文件写入数据。
 *
 * @author zch
 *
 */
public class BranchWriter {
    public static void main(String[] args) {
        String filePath = "D://BranchWriter.txt";

        File file = new File(filePath);

        try {
            if (!file.exists()) {
                file.createNewFile();
            }
            FileWriter fw = new FileWriter(file); // 创建文件输出流

            BufferedWriter bw = new BufferedWriter(fw); // 使用缓冲区数据流封装输出流
            for (int i = 0; i < 100; i++) {                //循环写入100行数据
                
                bw.write("Java交互管道——IO流".toCharArray());// 写入数据到输出流
                
                bw.newLine(); // 写入换行符
                
                bw.flush(); // 刷新缓冲区
            }

            System.out.println("成功写入数据！");

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
3、删除指定文件
       File类的delete()方法可以实现删除指定的文件，首先使用目标文件路径创建File类的实例对象，然后再调用File类的delete()方法。

package com.zch.io;

import java.io.File;

public class FileDelete {

    public static void main(String[] args) {
        String filePath = "D://word.txt";

        File file = new File(filePath);
        delFile(file);
    }

    public static void delFile(File file) {
        if (!file.exists()) {
            System.out.println("文件不存在！");
            return;
        }
        boolean rs = file.delete();
        if (rs) {
            System.out.println("文件删除成功！");
        } else {
            System.out.println("文件删除失败！");
        }
    }
}