java

FileInputStream： 用于从文件中读取内容到程序

package io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputTest {
    public static void main(String[] args){

        //创建流
        FileInputStream fis1 = null;
        FileInputStream fis2 = null;
        FileInputStream fis3 = null;
        FileInputStream fis4 = null;
        //放在前面声明，方便在try之后关掉，保证程序健壮性
        try {
            fis1 = new FileInputStream("C:\Users\Administrator\Desktop\test\filetest.txt");
            //可以用String或者file创建, 路径必须对，不然过不了编译

            int fis_i = fis1.read();   //读取一个字节，方法返回值为int
            System.out.println(fis_i);//输出字节的unicode
            //72
            char fis_c = (char)fis_i;//int可以转成char方便查看
            System.out.println(fis_c);
            //H

            //利用循环显示所有内容
            for(int i = fis1.read(); i != -1; i = fis1.read() ){
                System.out.print((char)i);
            }
            System.out.println();
            //ello world.    本来应该是Hello world. ，但是H 被上面那个int i = fis.read(); 读取了，所以ii没有读到。
            //Hello I/O.     文件中的回车和符号等也可以读到

            fis2 = new FileInputStream("C:\Users\Administrator\Desktop\test\filetest.txt");
            byte fis2_b[] = new byte[5];
            fis2.read(fis2_b);
            for(int i = 0; i < fis2_b.length; i++ ){
                System.out.print((char)fis2_b[i]);
            }
            System.out.println();
            //Hello
            //因为数组长度所以只存了一部分内容。

            for(int i = fis2.read(fis2_b); i != -1; i = fis2.read(fis2_b) ){ //fis1.read(char[])返回值为读取的字段数量,没有读取的时候返回-1
                System.out.println("---" + new String(fis2_b) + "---" + i); //利用String(char[]) 构造方法把fis_2转化为String直接输出
            }
            //--- worl---5
            //---d.
            //H---5
            //---ello ---5
            //---I/O. ---4
            //第1次输出：空格worl
            //第2次输出：d句号回车/换行H
            //第3次输出：ello空格
            //第4次输出：I/O句号
            //总共24个字节
            //txt换行后后面有/r/n字符（回车符，换行符）

            fis3 = new FileInputStream("C:\Users\Administrator\Desktop\test\filetest.txt");
            Long fis3_l = fis3.skip(14);   //跳过15个字节开始读取，用于多线程读取（迅雷？），另外试了一下，可以用负数向前跳。。。也许有用？
            System.out.println(fis3_l);
            byte[] fis3_b = new byte[10];
            fis3.read(fis3_b);
            System.out.println(new String(fis3_b));//输出字节的unicode
            //15
            //Hello I/O.    直接开始第二行的读取

            //available
            //Inputstream.available()方法返回的值是该inputstream在不被阻塞的情况下一次可以读取到的数据长度,返回值为int
            fis4 = new FileInputStream("C:\Users\Administrator\Desktop\test\filetest.txt");
            System.out.println(fis4.available());
            byte[] fis4_b = new byte[fis4.available()];
            fis4.read(fis4_b);
            System.out.println(new String(fis4_b));
            //24
            //Hello world.
            //Hello I/O.
            //可以直接用数组全读完啦！

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) { //FileNotFoundException 继承了 IOException， 上面那个不写也行
            e.printStackTrace();
        }finally {  //使用fianlly保证流能关闭
            if(fis1 != null){
                try {
                    fis1.close(); //关闭流
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fis2 != null){
                try {
                    fis2.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fis3 != null){
                try {
                    fis3.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fis4 != null){
                try {
                    fis4.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }
}

FileOutputStream： 往文件内写入数据

package io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputTest {
    public static void main(String[] args){
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("C:\Users\Administrator\Desktop\test\fileWriteTest.txt");//文件可以不存在，如果不存在则会新建一个,但是文件路径需要存在
            fos.write(97);  //byte类型
            fos.write('b'); // byte自动转化为byte
            //txt内写入了ab
            fos.flush();//以前需要写上这句才能生效，现在最新本版本不写也可以，不过为了适应各种环境最好全写上，把字节流输入文件

            fos = new FileOutputStream("C:\Users\Administrator\Desktop\test\fileWriteTest.txt");
            fos.write("abcd".getBytes()); //把String转化为byte[]，然后传入，可以直接写入
            fos.flush();
            //txt内写入了abcd，把之前的ab覆盖了。

            fos = new FileOutputStream("C:\Users\Administrator\Desktop\test\fileWriteTest.txt",true);//append表示是否添加，不写默认为false也就是覆盖
            fos.write("efgh".getBytes()); //把String转化为byte[]，然后传入，可以直接写入
            fos.flush();
            //abcdefgh



        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}