Java培训-IO流

  1. 流的概念：

    流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。

  2. 字符流和字节流的区别：

    （1）读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。

    （2）处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。

    （3）字节流在操作的时候本身是不会用到缓冲区的，是文件本身的直接操作的；而字符流在操作的时候下后是会用到缓冲区的，是通过缓冲区来操作文件，我们将在下面验证这一点。

    结论：优先选用字节流。首先因为硬盘上的所有文件都是以字节的形式进行传输或者保存的，包括图片等内容。但是字符只是在内存中才会形成的，所以在开发中，字节流使用广泛。

  3. IO流类图结构

  4. 字符流

    处理字符类型文件（用记事本可以直接打开，正常显示）

    字符输入|输出流

    Reader  输入流

    BufferReader  带缓冲区的输入流

    Buffered  凡是带Buffered的都是带缓冲区，实现原理利用数组实现。

    实现

    方法：

    readLine(); 按行读取

    Writer  输出流

    PrintWriter  输出流

    方法：

    println("打雷啦!下雨啦！回家收衣服啦！");

    writer("\n\r");  换行

  5. InputStreamReader 字节流与字符流转换

    构造器：

    Reader=InputStreamReader(InputStream is);

  6. 无论何种情况，外部资源流必须都关闭

    Ctrl+T 查找该类所拥有子类

  7. 字节流

    InputStream 是所有的输入字节流的父类，它是一个抽象类。

    ByteArrayInputStream、
    StringBufferInputStream、FileInputStream 是三种基本的介质流，它们分别从Byte
    数组、StringBuffer、和本地文件中读取数据。PipedInputStream 是从与其它线程共用的管道中读取数

  8. 将一个文件夹里的文件复制到另一个文件夹
/**
     * @param oldFile
     *            被拷贝的文件夹
     * @param copyFile
     *            拷贝文件存放的文件夹
     */
    public void copyFile(String oldString, String copyString) {
        File oldFile = new File(oldString);
        File copyFile = new File(copyString);
        BufferedReader br = null;
        // 用bufferWriter只能复制一个文件？
        File[] dirFile = oldFile.listFiles();
        PrintWriter bw = null;
        for (int i = 0; i < dirFile.length; i++) {
            try {
                br = new BufferedReader(new FileReader(dirFile[i]));
                bw = new PrintWriter(new FileWriter(copyString + "/"
                        + dirFile[i].getName()));
                String str = null;
                while ((str = br.readLine()) != null) {
                    // 中文乱码：
                    bw.println(str);
                    bw.flush();
                }
 
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if(bw!=null)
                    bw.close();
                    if(br!=null)
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

9.读取属性文件

/**
     * 读取属性文件
     */
    public void getPropertiesFile(){
        Properties prop=new Properties();
        File file=new File("user.properties");
        InputStream is;
        try {
            is=new FileInputStream(file);
            prop.load(is);
            String username=prop.getProperty("username");
            System.out.println(username);
        } catch (IOException e) {
            e.printStackTrace();
        }    
    }

10.写属性文件

/**
     * 写属性文件
     */
    public void setProperties(){
        Properties prop=new Properties();
        try {
            FileOutputStream fos=new FileOutputStream("test.properties");
            prop.setProperty("001", "第一名");
            prop.setProperty("002", "第二名");
            prop.setProperty("003", "第三名");
             
            prop.store(fos, "我是注释，请注意！以#开头！");
            fos.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
         
    }

11.实现对属性文件的增、改操作

package com.mig.jbs.io;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Properties;
import java.util.Scanner;
 
public class PropertiesFileCRUD {
 
    static Properties prop = new Properties();
    static Scanner sc = new Scanner(System.in);
    static File file = new File("test.properties");
    static String username;
    static String password;
    static boolean b;
     
    //循环判断属性文件是否存在相同的键
    public boolean loopCompare(){
        FileInputStream fis;
        b=false;
        try {
            fis=new FileInputStream(file);
            prop.load(fis);
            @SuppressWarnings("unchecked")
            //返回属性列表中所有键的枚举
            Enumeration enu=prop.propertyNames();
            //测试此枚举中是否包含更多的元素，如果
            while(enu.hasMoreElements()){
                String name=(String) enu.nextElement();
                //判断属性列表中是否已经包含了此键
                if(username.equals(name)){
                    b=true;
                    System.out.println(password);
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return b;
    }
     
    //分割用户输入数据，得到属性文件数据
    public String[] propertiesSplit(String input){
        System.out.println(input);
        String[] str=input.split("=");
        username=str[0];
        password=str[1];
        return str;
    }
     
 
    // 创建新的属性文件数据
    public void doCreate() {
        try {
            FileOutputStream fos=new FileOutputStream(file);
            prop.setProperty(username, password);
            prop.store(fos, null);
            fos.close();
            System.out.println("用户添加成功！");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    // 更新属性表
    public void doUpdate() {
        try {
            FileOutputStream fos=new FileOutputStream(file);
            prop.setProperty(username, password);
            prop.store(fos, null);
            fos.close();
            System.out.println("用户信息更新成功！");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
    }
 
    //输入属性文件数据
    public  void init() {
        String input=sc.nextLine();
        if(input.equals(-1)){
            System.exit(0);
        }else{
            propertiesSplit(input);
            loopCompare();
            if(b){
                doUpdate();
            }else{
                doCreate();
            }
            init();
        }
    }
     
    public static void main(String[] args) {
        System.out.println("如果你要退出程序请输入-1");
        System.out.println("如果你需要添加或修改用户信息请按格式XXXX=XXXXX");
        System.out.println("请输入你要输入的信息");
        PropertiesFileCRUD pfc=new PropertiesFileCRUD();
        pfc.init();
    }
}

12.将文件分割成指定份数，并将分割后的文件合并

public class SplitFileDemo {
     
    /**
     * @param oldFile 要分割的文件
     * @param per 要分割的份数
     * @param newFile 分割后的文件
     */
    public void splitFile(File oldFile,int per,File newFile){
        try {
            FileInputStream fis=new FileInputStream(oldFile);
            System.out.println(newFile.toString());
            //被分割文件的长度
            long totalSize=oldFile.length();
            //分割的每一份长度
            long splitSize=totalSize/per;
            String suffix=suffixFile(oldFile);
            byte[] buff=new byte[1024];
            int len,sum;
            for (int i = 1; i <=per; i++) {
                sum=0;
                FileOutputStream fos=new FileOutputStream(newFile.toString()+i+"."+suffix);
                if(i==per){
                    splitSize=totalSize-splitSize*(i-1);
                }
                while((len=fis.read(buff))!=-1){
                    sum=len+sum;
                    fos.write(buff, 0, len);
                    if(sum>=splitSize){
                        break;
                    }                    
                }
            }
             
            //文件合并
            FileInputStream fis2 = null;
            FileOutputStream fos2 = new FileOutputStream("c:/"+oldFile.getName());
            for (int i = 1; i <=per; i++) {
                fis2 = new FileInputStream(newFile.toString()+i+"."+suffix);
                while ((len = fis2.read(buff)) != -1) {
                    fos2.write(buff, 0, len);
                }
            }
 
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
     
    /**
     * @param file 获取文件的后缀名
     */
    public String suffixFile(File file){
        String filename=file.getName();
        int index=filename.lastIndexOf(".");
        String suffix=filename.substring(index+1);
        return suffix;
         
    }
时间： 2024-11-20 11:08:09

Java培训-IO流的相关文章

Java培训-IO流补充

1.RandomAccessFile: 支持文件读写. 构造器 RandomAccessFile(String file,String mode) Mode: r  读 rw 读写 read()-. Write()-. Seek(long pos) 跳过pos字节,pos+1开始读取或写入 skipBytes(int n)丢弃n个字节,不抛异常 public void rw(){           try {               RandomAccessFile raf=new Ran

java常用IO流数据流小结

  类名 常用方法 说明 输入流 InputStream int read(); 只能读字节流,虽然返回值是int,但只有低8位起作用. DataInputStream Type readType(); 可以读二进制流,可以读byte,short,int,long,double等二进制流. BufferedReader String readLine(); 可以读文本行. 输出流 OutputStream void write(int); 只能写字节流,虽然形参是int,但只有低8为起作用. D

【Java】IO流简单分辨

转载请注明原文地址:http://www.cnblogs.com/ygj0930/p/5827509.html Java的IO流体系十分庞大,并且体系层次稍复杂,很容易记混或记错.在此,我把平时经常用到的几个流类的简易区分以及体系层次整理出来,方便记忆与辨析.本人对IO了解尚浅,文章如有错漏,恳请前辈指正,感激不尽! 字节流体系: 基类:InputStream/outputStream(抽象类,不能new) 子类: 文件IO字节流:FileInputStream/FileoutputStream

JAVA中IO流总结

本文是在学习中的总结,欢迎转载但请注明出处:http://write.blog.csdn.net/postedit/42119261 我想你对JAVA的IO流有所了解,平时使用的也比较的多,但是对于其具体分类和继承体系可能知道的并不多,可能也很少去看相关的API文档,找出其中的关系和各自的应用情形.本文简单对常用的IO流进行分类整理,并简单举例说明其应用.希望本文对你有所帮助. (A)IO流大致分为两种: (1)字节流:对应抽象类为InputStream(输入流)和 OutputStream(输

【JAVA的 IO流之FileInputStream和FileOutputStream】

java的 IO流即输入输出流,流是一组有顺序的,有起点和终点的字节结合,是对数据传输的总称.即数据在两设备间的传输称为流,流的本质是数据传输. IO流可以分为字节流和字符流.给出相应的IO结构图: 在接下来的一段时间里,将会慢慢介绍各种流的使用,本篇博客先介绍字节流的FileOutputStream和相对应的FileInputStream. 一.FileOutputStream(文件输出流) OutputStream是一个抽象类,抽象类必须通过子类实现.现在要向文件里输出就要用FileOutp

java的IO流，字节流和字符流

java操作文件都是通过流来处理的,(其实其他很多语言也是这样) 第一:java的IO流,分为:输入流 和 输出流(这真是废话,这是从流向的角度来说的) 第二:java的所有IO流,只分为:字节流 和 字符流(其实就是传输的颗粒,传输的基本单位) 总结:凡是处理纯文本的优先考虑字符流:其他的才考虑使用字节流

Java之IO流---字节流

1.1 IO流的引入 IO流在很多语言已有体现,诸如C语言的stdio.h,C++中的iostream.Java中的IO流大抵是用于在控制台.磁盘.内存上进行数据的读写操作,完成数据的传递. 我们可以对它进行如下分类: 按处理的数据类型可分为字节流与字符流 按流的流向可分为输入流(in)与输出流(out) 按流的功能可分为节点流(Node)和过滤流(Filter) 本篇侧重于梳理字节流相关的知识,毕竟作为字符流的前辈,它还是非常重要的.下篇继续梳理字符流. 1.2 IO流的继承体系图 大概描述了

Java笔记-IO流的运用

1.InputStream和System.in(Scanner) InputStream 输出流以字节为单位来获取数据,且需要复杂的判断并创建字节数组作为缓冲 另外字节转换为字符时容易出现中文乱码的情况:Scanner Java扫描器类,可以从输入流中读取指定类型的数据或字符串. 对于字符数据的读取,应该使用Scanner扫描器进行封装,然后获取字符串类型的数据 2. out和err out和err是System类的两个static类成员变量: out:主要是输出调试信息的输出流,以黑色显示 e

java的Io流学习

Java中io流的学习(一)File:https://blog.csdn.net/qq_41061437/article/details/81672859 Java中io流的学习(二)FileInputStream和FileOutputStream:https://blog.csdn.net/qq_41061437/article/details/81742175 Java中io流的学习(三)BuffereInputStream和BuffereOutputStream:https://blog.