精华内容
下载资源
问答
  • java把文件写入内存---输出字节流

    千次阅读 2014-10-06 22:48:39
    // 把文件写入到内存 Map key对应数据 static Map files = new HashMap(); // public static void init() { loadfile("BOMB2.WAV"); loadfile("enemyshot.WAV"); loadfile("GRAY3WEA.WA


    // 资源管理类
    class ResManager {
    // 把文件写入到内存 Map key对应数据
    static Map<String, byte[]> files = new HashMap<String, byte[]>();


    //初始化把文件写入到内存
    public static void init() {
    loadfile("BOMB2.WAV");
    loadfile("enemyshot.WAV");
    loadfile("GRAY3WEA.WAV");
    loadfile("move.WAV");
    loadfile("myshot.WAV");
    loadfile("start.wav");
    }

    //写入内存方法
    private static void loadfile(String xx) {
    try {
    // 获取文件URL
    URL u = ResManager.class.getClassLoader().getResource(xx);
    // 把输入流转换成字节数组
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    // 把路径对应的数据转换成输入流
    InputStream tmpIs = u.openStream();
    // 缓冲数组
    byte[] data = new byte[512];
    int len = -1;
    // 取出输入流的字节
    while ((len = tmpIs.read(data)) != -1)
    // 把字节写入到data数组
    baos.write(data, 0, len);
    // 把写入到输出流的数据给ttt
    byte[] ttt = baos.toByteArray();

    // xx.toUpperCase把输入的字符串全部改为大写
    // 把key值对应的数据给files
    files.put(xx.toUpperCase(), ttt);
    baos.close();
    tmpIs.close();


    } catch (IOException e) {
    // TODO 自动生成的 catch 块
    e.printStackTrace();
    }


    }


    // 返回资源的URL
    public static URL getResURL(String xx) {
    URL url = ResManager.class.getClassLoader().getResource(xx);
    return url;
    }


    // 返回数据流
    public static InputStream getResStream(String xx) {
    // 获取内存中key值对应的数据
    byte[] b = files.get(xx.toUpperCase());
    // 把字节数组转换成输入流
    ByteArrayInputStream bais = new ByteArrayInputStream(b);
    return bais;
    }
    }
    展开全文
  • Java dbf文件写入远程服务器

    千次阅读 2015-11-17 14:21:35
    Java dbf文件写入远程服务器

    重要的事情说三遍,有木有,Java dbf文件写入远程服务器,第一遍,第二遍,第三遍…够了,王二,还有完没有,赶紧点

    需求

    今天早晨,王二(也就是我)接到一个需求:
    把行情的dbf库写入到远程windows server2003上!

    分析

    之前,我就写过一篇Java操作DBF文件数据库 ,但怎么把dbf写入到远程服务器上,这好像需要点什么。

    于是我就去问度娘啊,看看有没有什么封装好的jar包之类的,好拿来用用。
    折腾了一会关键字,终于找到了一篇Java读写Windows共享文件夹,感谢博主的良苦用心啊,于是为博主点了一个赞。

    拿来主义

    第一步,下载JCIFS
    网址: http://jcifs.samba.org/

    把jcifs-1.3.18.jar加入到项目jar包库中。

    第二步,设置共享文件夹,当然需要设置用户名密码的
    怎样让客户机访问windows2003服务器共享文件

    第三步,demo,先探探路通不通

        public static void main(String[] args) {
            try {
                // 定义DBFWriter实例用来写DBF文件
                DBFWriter writer = new DBFWriter();
                writer.setCharactersetName("GB2312");
    
                DBFField fields[] = new DBFField[1];
                // S1 HQZQDM 证券代码 Char 6
                fields[0] = new DBFField();
                fields[0].setName("S1");
                fields[0].setDataType(DBFField.FIELD_TYPE_C);
                fields[0].setFieldLength(6);
    
                writer.setFields(fields);
    
                Object[] obj1 = new Object[1];
                obj1[0] = "000001";
                writer.addRecord(obj1);
    
                String remoteUrl = "smb://abc:123@127.168.1.11/dbf/PENGBO.dbf";
                SmbFile smbFile = new SmbFile(remoteUrl);
                smbFile.connect(); //尝试连接  
    
                OutputStream fos = new  BufferedOutputStream(smbFile.getOutputStream());
                writer.write(fos);
                fos.close();
    
            } catch (Exception e) {
                logger.error(e.getMessage());
                logger.error(e.getMessage(), e);
            }
    
        }

    注意remoteUrl

    1. smb:,不知道啥意思,应该是一种协议吧?王二,你这么一知半解,不好吧?额,那问问度娘吧

      SMB(Server Message Block)是协议名,它能被用于Wap连接和客户端与服务器之间的信息沟通。

    2. abc:123,你共享权限中指定的用户名和密码

    3. 127.168.1.11,自然是远程ip了
    4. dbf,共享的文件夹
    5. PENGBO.dbf,dbf文件名喽
    6. 第六,也没啥,如果上面5点没有说清楚,那么请私信王二,或者嘛,问度娘,美貌如花,有问必答????

    run一下
    这里写图片描述

    写到这应该算完结了吧,我觉得也是,可是王二偏要说再写点,好吧,我就应了自己吧!

    修葺

    其实吧,写到上面这里,也确实算完了,无奈王二天生一颗追求完美的心,这面这段代码有点小遗憾,smbFile.connect(); //尝试连接特别花费时间,而行情的dbf库实时刷新,这样肯定不行!

    那么需要做的就是,你看下面步骤,我决定放大招:

    第一步,项目启动时初始化好远程连接

    写一个DBFListener类吧

        private static Logger logger = Logger.getLogger(DBFListener.class);
    
        private SmbFile smbFile = null;
        private File file = null;
    
        public void start() {
    
            try {
                if (Commonstants.remote_flag_dbf) {//需要远程写dbf
                    String remoteUrl = "smb://" + Commonstants.username_dbf + ":" + Commonstants.password_dbf + "@"
                            + Commonstants.path_info_dbf;
    
                    smbFile = new SmbFile(remoteUrl);
                    smbFile.connect();
    
                    logger.info("dbf 远程连接启动成功!");
                } else {
                    file = new File(Commonstants.path_info_dbf);
    
                    logger.info("dbf 本地文件创建成功!");
                }
            } catch (Exception e) {
                logger.error(e.getMessage());
                logger.error(e.getMessage(), e);
            }
        }
    
        // 行情变化时,对行情进行写入
        public void writeDBF(List<Quotation> dbfQuotations) {
            ExecutorService pool = Executors.newSingleThreadExecutor();
            pool.execute(new Thread(new DBFThread(smbFile, dbfQuotations, file)));
            pool.shutdown();
    
            logger.info("dbf写入线程启动...");
        }

    项目运行时,尝试连接远程dbf服务器

            logger.info("行情服务器开始连接dbf服务");
            int j = 1;
            DBFListener dbfListener = new DBFListener();
            while (true) {
                try {
                    dbfListener.start();
                    break;
                } catch (Exception e) {
                    logger.info("5秒后开始尝试第" + (++j) + "次连接dbf服务,发生重连原因:" + e.getMessage());
    
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e1) {
                        logger.error(e1.getMessage(), e1);
                    }
                }
            }
    
            DBFManager.setdbfListener(dbfListener);

    第二步,模块化dbf操作
    写一个dbf操作类DBFOperation

        public static void writeDBFByQuotation(SmbFile smbFile, List<Quotation> quotaionList, File file) {
            try {
                // 定义DBFWriter实例用来写DBF文件
                DBFWriter writer = new DBFWriter();
                writer.setCharactersetName("GB2312");
    
                DBFField fields[] = new DBFField[30];
                // S1 HQZQDM 证券代码 Char 6
                fields[0] = new DBFField();
                fields[0].setName("S1");
                fields[0].setDataType(DBFField.FIELD_TYPE_C);
                fields[0].setFieldLength(6);
    ...
                if (file!=null) {
                    FileOutputStream fos = new FileOutputStream(file);
                    writer.write(fos);
                    fos.close();
                }
    
                if (smbFile != null) {
                    OutputStream fos = new  BufferedOutputStream(smbFile.getOutputStream());
                    writer.write(fos);
                    fos.close();
                }           

    第三步,行情来时,写进去

            dbfListener.writeDBF(dbfQuotations);
            logger.info("写入DBF数据库结束");

    这代码没法贴全,只好捡重要的贴出来,权当给一个参考。主要的思路就是,系统初始化就加载好SmbFile对象,然后对dbf写入进行封装,更灵活的应对远程写入还是本地写入,最后呢,行情刷新时能够启动线程写入,而不影响当前线程的性能。王二的编程能力很一般,虽然他老是不承认,没办法,谁让我就是王二呢?!


    相关文章

    王二语录

    那么人生何处不爬虫,爬虫请标http://blog.csdn.net/qing_gee
    如果你能心无旁骛,专心致志地做好自己的事,做最好的自己,你就能在不知不觉中超越他人,跨越平庸的鸿沟,脱颖而出!—–写™的真好,可惜不是我王二写的!

    展开全文
  • Java读取txt文件写入txt文件

    万次阅读 多人点赞 2016-05-25 23:16:26
    原文: Java读取txt文件写入txt文件Java程序时经常碰到要读如txt或写入txt文件的情况,但是由于要定义好多变量,经常记不住,每次都要查,特此整理一下,简单易用,方便好懂! package edu.thu.keyword.test; ...

    2018-10-19更新

    网友推荐更加简洁的写法,修改之后的代码;
    项目实用优化,增加java7中的try-with-resources写法

    package com.nickwong.code;
    
    import java.io.*;
    
    /**
     * Created by Nickwong on 31/07/2018.
     * 根据1-8楼的建议,优化了代码
     */
    public class ReadTxt {
    
        public static void main(String args[]) {
            readFile();
            writeFile();
        }
    
        /**
         * 读入TXT文件
         */
        public static void readFile() {
            String pathname = "input.txt"; // 绝对路径或相对路径都可以,写入文件时演示相对路径,读取以上路径的input.txt文件
            //防止文件建立或读取失败,用catch捕捉错误并打印,也可以throw;
            //不关闭文件会导致资源的泄露,读写文件都同理
            //Java7的try-with-resources可以优雅关闭文件,异常时自动关闭文件;详细解读https://stackoverflow.com/a/12665271
            try (FileReader reader = new FileReader(pathname);
                 BufferedReader br = new BufferedReader(reader) // 建立一个对象,它把文件内容转成计算机能读懂的语言
            ) {
                String line;
                //网友推荐更加简洁的写法
                while ((line = br.readLine()) != null) {
                    // 一次读入一行数据
                    System.out.println(line);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 写入TXT文件
         */
        public static void writeFile() {
            try {
                File writeName = new File("output.txt"); // 相对路径,如果没有则要建立一个新的output.txt文件
                writeName.createNewFile(); // 创建新文件,有同名的文件的话直接覆盖
                try (FileWriter writer = new FileWriter(writeName);
                     BufferedWriter out = new BufferedWriter(writer)
                ) {
                    out.write("我会写入文件啦1\r\n"); // \r\n即为换行
                    out.write("我会写入文件啦2\r\n"); // \r\n即为换行
                    out.flush(); // 把缓存区内容压入文件
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    
    

    ##参考原文: Java读取txt文件和写入txt文件##

    写Java程序时经常碰到要读如txt或写入txt文件的情况,但是由于要定义好多变量,经常记不住,每次都要查,特此整理一下,简单易用,方便好懂!

        package edu.thu.keyword.test;  
          
        import java.io.File;  
        import java.io.InputStreamReader;  
        import java.io.BufferedReader;  
        import java.io.BufferedWriter;  
        import java.io.FileInputStream;  
        import java.io.FileWriter;  
          
        public class cin_txt {  
            static void main(String args[]) {  
                try { // 防止文件建立或读取失败,用catch捕捉错误并打印,也可以throw  
          
                    /* 读入TXT文件 */  
                    String pathname = "D:\\twitter\\13_9_6\\dataset\\en\\input.txt"; // 绝对路径或相对路径都可以,这里是绝对路径,写入文件时演示相对路径  
                    File filename = new File(pathname); // 要读取以上路径的input。txt文件  
                    InputStreamReader reader = new InputStreamReader(  
                            new FileInputStream(filename)); // 建立一个输入流对象reader  
                    BufferedReader br = new BufferedReader(reader); // 建立一个对象,它把文件内容转成计算机能读懂的语言  
                    String line = "";  
                    line = br.readLine();  
                    while (line != null) {  
                        line = br.readLine(); // 一次读入一行数据  
                    }  
          
                    /* 写入Txt文件 */  
                    File writename = new File(".\\result\\en\\output.txt"); // 相对路径,如果没有则要建立一个新的output。txt文件  
                    writename.createNewFile(); // 创建新文件  
                    BufferedWriter out = new BufferedWriter(new FileWriter(writename));  
                    out.write("我会写入文件啦\r\n"); // \r\n即为换行  
                    out.flush(); // 把缓存区内容压入文件  
                    out.close(); // 最后记得关闭文件  
          
                } catch (Exception e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
    
    展开全文
  • Java实现文件写入——IO流(输入输出流详解)

    万次阅读 多人点赞 2017-09-09 20:43:12
    输入输出的重要性: &nbsp;&nbsp;&nbsp;&nbsp;...输入和输出功能是Java对...程序从输入流读取数据,向输出流写入数据。Java是面向对象的程序语言,每一个数据流都是一个对象,它们提供了各种支持“...

    输入输出的重要性:

         输入和输出功能是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());
    
    	}
    
    }
    
    

    运行结果如下:

    文件名称:FileInfo.java
    文件是否存在:true
    文件的相对路径:src\com\zch\io\FileInfo.java
    文件的绝对路径:D:\Java\IO\src\com\zch\io\FileInfo.java
    是否为可执行文件:true
    文件可以读取:true
    文件可以写入:true
    文件上级路径:src\com\zch\io
    文件大小:1195B
    文件最后修改时间:Sat Sep 09 21:30:10 CST 2017
    是否文件类型:true
    是否为文件夹:false
    

    在使用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();
    		}
    		
    	}
    }
    
    


    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输出流在控制台输出字符串\n".getBytes();		//创建bytes数组
    	
    	try {
    		output.write(bytes);
    		
    		bytes = "输出内容:\n".getBytes();
    		output.write(bytes);        //向流中写入数据
    		
    		bytes = "Java数据交互管道——IO流 \n".getBytes();
    		output.write(bytes);
    		
    		output.close();
    		
    	} catch (IOException e) {
    		// TODO Auto-generated catch block
    		e.printStackTrace();
    	}
    	}
    }
    
    

    输出结果如下:

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



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


         文件字节输入流可以从指定路径的文件中读取字节数据。文件字节输入流类继承InputStream类,并实现了读取输入流的各种方法。

           创建文件字节输入流创建的构造方法语法如下:

    • 语法1:以File对象为参数创建FileInputStream实例
    new FileInputStream(File file)
    
    • 语法2:以文件对象的绝对路径为参数创建FIleInputStream实例
    new FileInputStream(String filepath)
    

    4、文件字节输出流类:FileOutputStream

          文件字节输出流关联指定文件路径的文件,数据通过文件字节输出流以字节为单位输出并保存到文件中。文件字节输出流继承自OutputStream类,并实现OutputStream类的各种方法。

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

    • 语法1:以File对象为参数创建FileOutputStream实例
    new FileOutputStream(File file)
    
    • 语法2:以文件对象的绝对路径为参数创建FIleOutputStream实例
    new FileOutputStream(String filepath)
    
    

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

    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、字符输入流抽象类: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);
    
    
    • 语法2:
    new FileReader(String path);
    
    

    下面通过实例介绍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();
    			}
    			
    		}
    	}
    }
    
    
    

    运行结果如下图:

    这里写图片描述
    这里写图片描述


    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();
    		}
    	}
    }
    
    
    

    运行后创建了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); // 递归调用方法本身
    			}
    
    		}
    
    	}
    }
    
    
    

    运行本实例,会将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();
    		}
    	}
    }
    
    
    

    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("文件删除失败!");
    		}
    	}
    }
    
    
    
    展开全文
  • java 文件写入和读取

    千次阅读 2019-06-04 22:35:23
    java文件的写入和读取 内容描述: 使用 Scanner 类从文件中读取文本數据, 使用 PrintWriter 类向文本文件写入数据 文件的写入: 向文本文件写入的UML图: 代码展示: // 文件的创建和数据写入 package java_test...
  • java 读取文件写入到新文件

    千次阅读 2018-08-23 13:39:51
    * 目标文件写到新路径 * @param fileURL 目标文件目录 * @param readFileName 原文件 * @param writeFileName 新文件目录 * @throws IOException */ public void copyFile2(String fileURL,Stri...
  • java 创建文件写入字符串并读取字符

    千次阅读 2019-06-24 10:48:53
    java 创建文件写入字符串并读取字符 使用java创建txt文件并进行读写 package file; import java.io.*; import java.io.FileWriter; public class FileTest { public static void main(String[] args) { File a=...
  • Java文件写入操作

    千次阅读 2019-07-02 14:35:30
    import java.io.File; import java.io.FileOutputStream; import java.io.FilenameFilter; import java.io.IOException; import java.util.Arrays; import java.util.Comparator; //文件夹操作 public c...
  • 我使用了FileItem类将文件写入到服务器,但是我该如何判断是否写入成功,文件已经存在那个地址上
  • java文件写入或追加续写

    万次阅读 2018-01-16 14:58:56
    java文件写入或追加续写 代码实例,例如: import java.io.File; import java.io.FileOutputStream; import java.io.OutputStreamWriter; import java.util.ArrayList; import java.util.HashMap; import java....
  • Java 读取文件写入文件

    千次阅读 2018-12-20 10:31:55
    提示:下面是基于jdk1.7的写法(自动关闭IO...读取文件 /** * 获取文件内容 * @param file 文件 * @return 内容 */ public static String getText(File file){ try(FileInputStream fis = new FileInputStr...
  • JAVA读取与写入文件

    千次阅读 2020-11-10 09:12:34
    简单的展示Java 文件输入输出流File读取写入文件的快速实现,方便大家记忆与快速使用。
  • Java使用FileOutputStream写入文件

    万次阅读 2017-01-05 18:02:29
    From: .../* 使用FileOutputStream写入文件,FileOutputStream的write() 方法只接受byte[] 类型 的参数,所以需要将string通过getBytes()方法转换为字节数
  • Java读取、写入txt文件

    千次阅读 2019-06-02 19:19:04
    JAVA读取、写入txt文件 1、读取 public String GetLogString(String logpath){ System.out.println("----------------开始读取日志----------------"); File logfile = new File(logpath+"\\log.txt"); ...
  • Java使用BufferedWriter写入文件

    千次阅读 2017-01-05 18:56:08
    from: .../* 使用BufferedWriter写入文件内容,BufferedWriter与FileWriter结合使用, 好比BufferedReader与FileReader结合使用,File、FileInputSt
  • java读取文件写入到word文档中

    千次阅读 2017-12-19 17:50:26
    今天突然想要看看流对文件的读取写入操作,之前一直没有怎么弄过关于流这方面,最近要做的项目会用到所以看了看别人的东西,现在就简单的发表下心得,希望大家多多提出意见,我们共同进步,一起走上技术巅峰 下面直接上...
  • Java将对象写入Excel文件

    万次阅读 2019-09-07 18:07:02
    本文通过poi依赖实现将java对象写入excel之中,核心理念是通过反射获取Java对象的getter方法和属性,通过getter方法获取要写入excel中的值,再通过属性上的自定义注解获取excel标题行,然后以文件流的方式写入excel...
  • Java OutputStream写入文件文件复制

    万次阅读 2017-08-14 17:14:24
    2,当然,还支持一个字节一个字节的读写,那么一个字节一个字节的读写,读出来的字节和写入的字节都是用的int类型的参数。3,int参数只会使用它的8个二进制位,也就是说类似于将int强行转换为byte,我感觉很无聊的...
  • Java文件转换写入byte[]

    千次阅读 2017-07-05 10:46:17
    Java文件转换写入byte[]
  • JAVA 写入文件

    千次阅读 2018-01-24 11:25:14
    package File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream;... * 使用FileInputStream将一个文件的内容输出到控制台,并使用FileOutputStr
  • java文件写入内容

    千次阅读 2019-03-20 14:11:30
    import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.util.Scanner; public class test1 { public static void main(String[] args) { @SuppressWarnings("resourc....
  • Java 写入文件

    千次阅读 2018-10-05 18:51:00
    import java.io.BufferedWriter; import java.io.FileWriter; import java.io.IOException; public class BufferedWriterDemo { public static void main(String...
  • Java创建文件写入字符串

    万次阅读 2015-12-31 10:27:19
    Java创建文件写入字符串,如果文件存在则只写入字符串。 String sourceString = "sourceString"; //待写入字符串 byte[] sourceByte = sourceString.getBytes(); if(null != sourceByte){ try { File ...
  • java写入文件的几种方法(一)

    万次阅读 多人点赞 2019-01-16 11:42:58
    1. FileWritter写入文件 FileWritter, 字符流写入字符到文件。默认情况下,它会使用新的内容取代所有现有的内容,如下: new FileWriter(file); 然而,当指定一个true (Boolean)值作为FileWritter构造函数的第...
  • public void getText(){ response.setHeader("Content-Disposition", "attachment;filename=" + new String(("omd_services.sql").getBytes(), "iso-8859-1"));..."utf-8":防止写入文件乱码 "\r\n":追加数据
  • java将数据写入文件

    万次阅读 2018-06-21 19:54:25
    import java.io.File; import java.io.FileWriter; import java.io.IOException; import java.io.Writer; public class Test2 { public static void main(String[] args) throws IOException { File file =n...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 493,669
精华内容 197,467
关键字:

java把文件写入

java 订阅