Java I/O简述

　　一、Java I/O概述

　　　　Java中包括两种输入输出流，分为字节流和字符流。其中字节流以字节为单位来进行处理输入输出操作，而字符流则以字符为单位进行处理输入输出操作。

　　　　字节流是最基本的，所有的InputStream和OutputStream的子类都是,主要用在处理二进制数据，它是按字节来处理的
　　　　但实际中很多的数据是文本，又提出了字符流的概念，它是按虚拟机的encode来处理，也就是要进行字符集的转化
　　　　这两个之间通过 InputStreamReader,OutputStreamWriter来关联，实际上是通过byte[]和String来关联
　　　　在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的

　　　　在从字节流转化为字符流时，实际上就是byte[]转化为String时，
　　　　　　　　public String(byte bytes[], String charsetName)
　　　　有一个关键的参数字符集编码，通常我们都省略了，那系统就用操作系统的lang
　　　　而在字符流转化为字节流时，实际上是String转化为byte[]时，
　　　　byte[]    String.getBytes(String charsetName)
　　　　也是一样的道理

　　　　至于java.io中还出现了许多其他的流，按主要是为了提高性能和使用方便，
　　　　如BufferedInputStream,PipedInputStream等

　　二、主要类和其主要方法

　　　　1.File类

　　　　　　主要方法见下面代码：

import java.io.File;
import java.io.IOException;

/**
 *
 * @author fengkuirui
 * @date 2017-02-09
 * File类的主要方法测试;
 */
public class FileTest {
    public static void main(String[] args) throws IOException {
        File file = new File(".");//当前路径创建File对象;
        //输出文件名
        System.out.println(file.getName());//.
        //输出当前文件的绝对路径
        System.out.println(file.getAbsoluteFile());//D:\JAVA\SE\IO\.
        //获取相对路径得父路径
        System.out.println(file.getParent());//null
        //获取上一级目录
        System.out.println(file.getAbsoluteFile().getParent());//D:\JAVA\SE\IO
        //在当前路径下创建一个临时文件
        File temp = File.createTempFile("aaa",".txt",file);
        //指定当JVM退出时删除文件
        temp.deleteOnExit();
        //以当前时间作为新的文件名创建新文件
        File file2 = new File(System.currentTimeMillis()+"");
        //判断新建文件是否存在
        System.out.println(file2.exists());//false
        //用其创建文件
        file2.createNewFile();
        //创建目录
        file2.mkdir();
        //使用list()方法列出当前路径下的所有文件和路径
        String[] fileList = file.list();
        System.out.println("当前路路径下的所有文件和目录");
        for(String f : fileList){
            System.out.println(f);
        }
        //listRoot()静态的方法列出所有的磁盘根目录
        File[] roots = File.listRoots();
        System.out.println("==系统所有的根路径如下：");
        for(File root : roots){
            System.out.println(root);
        }

        System.out.println();

    }
}

　　　　运行结果如下：

　　　　　　

　　　　2.、FileInputStream和FileoutputStream

　　　　　　　　

import java.io.FileInputStream;

/**
 * Created by fengkuirui on 2016/10/27.
 * 演示应用FileInputStream读取文件类的基本使用，对文件进行进行读取
 *
 */
public class MyFileInputStream {
    /**
     *  显示读取文件中的内容，输出到控制台
     * @param path :文件的绝对路径加上文件名
     */
    public void ReadFile(String path){
        FileInputStream fis = null; //初始化文件流为空
        byte [] buffer = new byte[1024]; //读取缓存为1024个字节
        int n ;
        try{
            int i = 0;//记录读取的次数
            fis = new FileInputStream(path);
            while ((n = (fis.read(buffer))) != -1){//直至读取完毕后，结束此时 n = -1
                System.out.write(buffer,0,n);//将文件输出到控制台
                i++;//统计读取的次数
                System.out.println("=--------=");
                System.out.println(n);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(fis != null){
                    fis.close();//关闭
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        MyFileInputStream mfis = new MyFileInputStream();
        mfis.ReadFile("E://read.txt");//送的为绝对路径
    }
}

import java.io.FileOutputStream;
import java.io.PrintStream;

/**
 * Created by fengkuirui on 2016/10/27.
 * 用FileOutputStream写入文件
 */
public class MyFileOutputStream {
    /**
     * 将内容保存到文件
     * @param path :要保存的文件的绝对路径，包含文件名和后缀;
     *
     */
    public void WriteFile(String path){
        FileOutputStream fos = null;
        //声明一个PrintStream流
        PrintStream prints;
        try{
            fos = new FileOutputStream(path,true);//默认为覆盖内容的形式，如果设为true，为追加内容的方式
            prints = new PrintStream(fos);
            prints.println("世界这么大，我想去看看");
            prints.println("可是我没有时间啊");
            prints.close();
            System.out.println("写入文件完毕！");
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(fos != null){
                    fos.flush();
                    fos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }

        }

    }
    public static void main(String[] args) {
        MyFileOutputStream mfos = new MyFileOutputStream();
        mfos.WriteFile("E://write.txt");
    }
}

　　　　3.Reader和Writer

　　　　　　

import java.io.BufferedReader;
import java.io.FileReader;

/**
 * Created by fengkuirui on 2016/10/27.
 * 利用字符流读取文件
 */
public class MyReader {
    public void readFile(String path){
        FileReader fr = null;
        String str ;
        try{
            fr = new FileReader(path);
            BufferedReader buf = new BufferedReader(fr);//包装流
            str = new String();
            int i =0 ;
            while((str = buf.readLine()) != null){//每次只读一行
                System.out.println(str);
                System.out.println(i);
                i++;
                System.out.println("++++++++++++++");
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            try{

            }catch (Exception e){
                e.printStackTrace();
            }
        }

    }
    public static void main(String[] args) {
        MyReader reader = new MyReader();
        reader.readFile("E://read.txt");
    }
}

import java.io.FileWriter;
import java.io.PrintWriter;

/**
 * Created by fengkuirui on 2016/10/27.
 * 字符流写入文件
 */
public class MyWriter {
    /**
     *
     * @param path ：要保存的文件的路径和名称加后缀
     */
    public void writeFile(String path){
        FileWriter fw = null;
        PrintWriter prints = null;
        try{
            fw = new FileWriter(path);
            prints = new PrintWriter(fw);//包装流;
            prints.println("我要学习Java，决不放弃！");
            prints.println("Never give up");
        }catch (Exception e){
            e.printStackTrace();
        }finally{

            if(prints != null){
                prints.flush();
                prints.close();
            }
        }
    }

    public static void main(String[] args) {
        MyWriter myw = new MyWriter();
        myw.writeFile("E://write.txt");
        MyReader myr = new MyReader();
        myr.readFile("E://write.txt");
    }
}

　　　　4.BufferStream

　　　　　　　　

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;

/**
 * Created by fengkuirui on 2016/10/27.
 * 包装流到缓冲流
 * 提高读取速度
 */
public class MyBufferStream {
    /**
     *
     * @param path :读取文件的路径
     */
    public void read(String path){
        File file = null;
        FileInputStream fis = null;
        BufferedInputStream bis = null;
        try{
            file = new File(path);//声明文件
            fis = new FileInputStream(file);//文件输入流
            bis = new BufferedInputStream(fis,1024);//设置缓存大小为1024字节
            byte[] data = new byte[(int)file.length()];
            while(bis.read(data) != -1){
                String str=new String(data);
                System.out.print(str);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(bis != null){
                    bis.close();
                }

                if(fis != null){
                    fis.close();
                }

            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        MyBufferStream mbs = new MyBufferStream();
        mbs.read("E://read.txt");
    }
}

　　　　5.RandomAccessFile

　　　　　　

import java.io.File;
import java.io.RandomAccessFile;

/**
 * Created by fengkuirui on 2016/10/27.
 * 利用RandomAccessFile 进行文件的合并
 */
public class MyRandomAccessFile {

    public void insert(String path1, String path2){
        File file1 = null;
        File file2 = null;
        RandomAccessFile raf1 = null;
        RandomAccessFile raf2 = null;
        try{
            file1 = new File(path1);
            file2 = new File(path2);
            raf1 = new RandomAccessFile(file1,"rw");
            raf2 = new RandomAccessFile(file2,"rw");
            byte[] buffer = new byte[1024];
            raf1.seek(raf1.length());//定位到最后，在最后添加；
            int n ;
            while((n=(raf2.read(buffer))) != -1){
                raf1.write(buffer,0,n);
            }
            raf1.close();
            raf2.close();
        } catch(Exception e){
            e.printStackTrace();
        }finally{
            try{

            }catch(Exception e){
                e.printStackTrace();
            }
        }

    }
    public static void main(String[] args) {
        MyRandomAccessFile mraf = new MyRandomAccessFile();
        mraf.insert("E://read.txt","E://write.txt");
        MyFileInputStream mfis = new MyFileInputStream();
        mfis.ReadFile("E://read.txt");
    }
}

　　　　6.ByteArrayStream

　　　　　　

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;

/**
 * Created by fengkuirui on 2016/10/27.
 * ByteArrayInputStream and ByteArrayOutputStream ,
 * 直接将多个数据转化成字节数组
 */
public class MyByteArrayStream {
   public void get(){
       int a = 1;
       int b = 12;
       int c = 123;
       ByteArrayOutputStream baos = new ByteArrayOutputStream();
       baos.write(a);
       baos.write(b);
       baos.write(c);
       byte[] buffer = baos.toByteArray();
       System.out.println("将字节流转换为字节数组为：");
       for(byte i : buffer){
           System.out.println(i);
       }
       //将字节数组转换为字节流
       ByteArrayInputStream bais = new ByteArrayInputStream(buffer);
        int bb;
       while((bb = bais.read()) != -1){
           System.out.println(bb);
       }
   }

    public static void main(String[] args) {
        MyByteArrayStream mbaos = new MyByteArrayStream();
        mbaos.get();
    }
}
时间： 2024-11-02 15:43:33

Java I/O简述的相关文章

Java内存管理简述

转自:http://www.codeceo.com/article/java-memory-area.html 一.概述 Java虚拟机在执行Java程序的过程中会把它所管理的内存划分为若干不同的数据区域,这些区域都有各自的用途以及创建和销毁的时间.Java虚拟机所管理的内存将会包括以下几个运行时数据区域,如下图所示: 下面就每一个区域进行阐述. 二.运行时数据区域 程序计数器 程序计数器,可以看做是当前线程所执行的字节码的行号指示器.在虚拟机的概念模型里,字节码解释器工作就是通过改变程序计数器

JAVA 编码中文简述

中文编码问题虽然是个老问题,但对不熟悉的人来说还是不好处理的.不过Java中已经有了一套比较成熟的解决方案. 首先对中文编码格式予以简单介绍:中文编码有三套国标:GB2312,GBK,GB18030,从前到后互为超集.GBK最为常见.这里不展开介绍,具体可以谷歌. 不过国际上通用的还是UTF-8,如果我们自己写中文的话,最好以UTF-8的方式编码,不然处理起来真的很麻烦. 下面以Java读文件为例,说明一下java处理中文编码的方法. java可以按字符读,也可以按字节流读,不管怎么样,读中文的

java内存模型简述

java内存模型的主要目标是 定义程序中各个变量的访问规则,即在虚拟机中将变量存储到内存和从内存中取出变量这样的底层细节.如下是内存关系: java线程 <==> 工作内存 <==> 主内存,大部分数据存储在主内存中,线程的工作内存保存了被该线程使用到的变量的主内存副本拷贝,线程的操作都必须在工作内存中进行线程间值的传递均需要通过主内存来完成.

【Simple Java】Java内存泄露简述

Java的一个最显著的优势是内存管理.你只需要简单的创建对象而不需要负责释放空间,因为Java的垃圾回收器会负责内存的回收.然而,情况并不是这样简单,内存泄露还是经常会在Java应用程序中出现. 本篇文章将介绍什么是内存泄露,为什么会发生,以及怎样阻止内存泄露. 什么是内存泄露 内存泄露的定义:对于应用程序来说,当对象已经不再被使用,但是Java的垃圾回收器不能回收它们的时候,就产生了内存泄露. 要理解这个定义,我们需要理解对象在内存中的状态.如下图所示,展示了哪些对象是无用对象,哪些是未被引用

java动态代理简述

代理模式 一个典型的动态代理创建对象过程可分为以下四个步骤:1.通过实现InvocationHandler接口创建自己的调用处理器 IvocationHandler handler = new InvocationHandlerImpl(...);2.通过为Proxy类指定ClassLoader对象和一组interface创建动态代理类Class clazz = Proxy.getProxyClass(classLoader,new Class[]{...});3.通过反射机制获取动态代理类的构

java内存空间简述

JVM的内存空间: 1. 寄存器 (Registers):最快的保存区域,位于处理器内部,由编译器分配.主要作用是记录当前线程所执行的字节码的行号.字节码解释器工作时就是通过改变当前线程的程序计数器选取下一条字节码指令来工作.任何分支.循环.方法调用.判断.异常处理.线程等待以及恢复线程.递归等都是通过这个计数器来完成.为了多线程的实现,每条线程都会有独立的程序计数器来记录当前指令的行号,以使得线程等待结束后能恢复到正确的位置执行.这块内存也被称为"线程私有"的内存.如果调用的方法是n

JAVA异常机制简述

1.类的继承结构 在JAVA所有的异常对象都是Throwable类的一个子类的实例 Exception包含两个分支,由于程序错误导致的异常属于RuntimeException,比如数组下标越界,空指针等.非程序本身问题的异常属于其他异常,譬如IO引起的异常. 派生自Error类或RuntimeException类的所有异常都属于为检查异常,而其他所有的异常都属于已检查异常,我们只需要为已经常异常指定异常处理器即可,换句话说,原则上,我们只需要为已检查异常编写catch语句. 2.方法异常的声明

java基础-容器简述

常用的容器有list.queue.set.map list有ArrayList.LinkedList,还有一个CopyOnWriteArrayList: queue有LinkedList.ArrayQueue.LinkedBlockingQueue.ConcurrentLinkedQueue: map有HashMap.TreeMap.ConcurrentHashMap.ConcurrentSkipListMap: set内部一般会使用map做存储,有HashSet.TreeSet.CopyOnW

Java有关问题

1.JDK及Eclipse目录结构操作 1)打开JDK目录结构 pwd cd /opt cd jdk ls 2)打开Eclipse的目录结构 cd .. cd eclipse ls 2.JDK的安装及配置 安装 Oracle官方提供了两种对Java SE平台的产品一JRE和JDK,可以从官方网站免费下载(http://www.oracle .com/technetwork/java/index.html). 除了下载JDK之外,开发人员一般还要下载Java官方文档,这是学习和开发Java语言必备