注意这里的b 在write时也用到了b 来表示长度.

字节流写一次后, 最好加上.flush()

加上true，表示如果该文件不存在则直接创建，如果存在，则追加内容

写入流 最后加入 "flush()" 视频中说: 对字节流 flush"可写可不写"

3333333

33333333333333333

如果想追加（不删除原来的内容），设置参数 true

222222222222222

222222222

11111111111111111

FileOutputStream 实现了向文件中写出byte数据的方法，其.write()方法只能写8位

输出流FileOutputStream fileout=new FileOutputStream("路径"，文件原本内容处理方式(true为追加，false为覆盖。));

如果路径所指文件不存在，则直接创建，如果存在，则删除后创建  

用中间变量buf从源文件读取内容，向目标文件写入内容。

文件输出流FileOutputStream

（6）FileOutputStream 实现了向文件中写出byte数据的方法

flush()这个函数是清空的意思，用于清空缓冲区的数据流，进行流的操作时，数据先被读到内存中，然后再用数据写到文件中，那么当你数据读完时，我们如果这时调用close()方法关闭读写流，这时就可能造成数据丢失，为什么呢，因为，读入数据完成时不代表写入数据完成，一部分数据可能会留在缓存区中，为了理解这个问题，我们举一个例子：

比如，在农村，几乎每家都有抽水机，抽水机的作用是什么呢，就是把水井里的水抽到水缸中，这时我们就会用水管连接抽水机和水缸(水管就好比是缓冲区)，当我们想把水井中的水都抽到水缸中时，我们就让抽水机工作抽水，如果我们发现水井里的水刚好抽完时，我们就会关掉抽水机的开关停止抽水，那么这时，管道里就会遗留一部分水，抽水就是读数据，水缸进水就是写数据，水管充当缓存区的角色，不知道这样是不是具象化了呢

那么这样一来我们如果中途调用close()方法，输出区也还是有数据的，就像水缸里有水，只是在缓冲区遗留了一部分，这时如果我们先调用flush()方法，就会强制把数据输出，缓存区就清空了，最后再关闭读写流调用close()就完成了。

--------------------- 

作者：Hunter_first 

来源：CSDN 

原文：https://blog.csdn.net/lsx991947534/article/details/45065773 

截图write只能写8位

FileOutputStream是输出字节流

/**
 * FileOutputStream实现了向文件中写出byte数据的方法
 */
public class FileOutDemo {
    public static void main(String[] args) throws IOException {
        //如果该文件不存在，则直接创建；如果存在，则追加内容
//        FileOutputStream out = new FileOutputStream("demo/out.dat",true);
        //如果该文件不存在，则直接创建；如果存在，则删除后创建
        FileOutputStream out = new FileOutputStream("demo/out.dat");
        out.write('A');//写出A的低八位
        out.write('B');//写出B的低八位
        int a = 10;//write只能写八位，那么写一个int就需要四次，每次八位
        out.write(a>>>24);
        out.write(a>>>16);
        out.write(a>>>8);
        out.write(a);
        byte[] utf = "中国".getBytes("utf-8");
        out.write(utf);
        out.close();
        //把写入的内容打印出来
        IOUtil.printHex("demo/out.dat");

    }
}

//copy文件
public class IOUtilTest3 {
    public static void main(String[] args){
        try {
            IOUtil.copyFile(new File("D:\\ceshi\\word\\nihao.txt"),
                    new File("D:\\ceshi\\word\\nihao1.txt"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
public class IOUtil {
    public static void copyFile(File srcFile,File destFile) throws IOException{
        if (!srcFile.exists()){
            throw new IllegalArgumentException("文件"+srcFile+"不存在");
    }
        if (!srcFile.isFile()){
            throw new IllegalArgumentException(srcFile+"不是文件");
    }
        FileInputStream in = new FileInputStream(srcFile);
        FileOutputStream out = new FileOutputStream(destFile);
        byte[] buf = new byte[8*1024];
        int b;
        while ((b = in.read(buf,0,buf.length))!=-1){
            out.write(buf,0,b);
            out.flush();//最好加上
        }
        in.close();
        out.close();
    }
}

public class FileOutDemo{
public static void main(String []args)throws IOException{
//如果该文件不存在，则直接创建，如果存在，删除后创建
FileOutputStream out=new FileOutputStream("demo/out.dat");
out.write('A');//写出‘A’的低八位
out.write("B");//写出了‘B’的低八位
int a=10;//write只能写八位，那么写一个int需要写4次，每次8位
out.write(a>>>24);
out.write(a>>>16);
out.write(a>>>8);
out.write(a);
byte[] gbk="中国".getBytes("gbk");
out.write(gbk);
out.close();
}}
IOUtil.java
public static void copyFile(File srcFile,File destFile)throws IOException{
if(!srcFile.exists()){
throw new IllegalArgumentException(srcFile+"不是文件");
}
if(!srcFile.isFile()){
throw new IllegalArgumentException(srcFile+"不是文件");}
FileInputStream in=new FileInputStream(srcFile);
FileOutputStream out=new FileOutputStream(destFile);
byte[] buf=new byte[8*1024];
int b;
while((b=in.read(buf,0,buf.length))!=-1){
out.write(buf,0,b);
out,flush();//最好加上
}
in.close();
out.close();}

文件输出流FileOutputStream

如果文件不存在，则直接创建，如果存在，删除后创建(在源文件后写入)

FileOutputStream out=new FileOutputStream(fileName(,boolean));

输出流基本方法，write只能写入八位

out.write(int b);写入一个byte到流，b的低八位

out.write(byte[] buf)将buf字节数组都写入到流

out.write(byte[] buf,int start,int size)

6)FileOutputStream 实现了向文件中写出byte的数据方法

要增加内容，设为true,否则会被清空掉 FileOutputStream out = new FileOutputStream("demo/out.dat"，true);

写入的区别

1.如果字节数组的长度够大，（也就是比源文件的字节大小要大）则一次就能读取完流中的字节数据，此时循环只执行一次...
2.如果字节数组的长度不够大，（也就是比源文件的字节大小要小）则需要几次才能读完，每读取一次,把读取到的字节写入到输出流中，直到全部读写完毕
/* 假设源文件占250个字节，设定的字节数组长度为100
则第一次从输入流中读取100个字节存放到缓冲区的0-100的位置
并将缓冲区0-100位置的字节写入到输出流中。
第二次同样从输入流中读取100个字节存放到缓冲区的0-100的位置，这时会覆盖第一次存放在缓冲区的对应字节
并将缓冲0-100位置的字节存写入到输出流中
第三次从输入流中读取50个字节存放到缓冲区的0-50的位置,会覆盖第二次存放在缓冲区的对应字节
并将缓冲区0-50的字节写入到输出流中
第四次返回值是-1,也就是EOF标志,循环结束，已实现源文件和目标文件的完整复制
*/

输入、输出是相对于字节流或者字符流而言的：
1：输入，是将字节或者字符从文件中输入到流中
2：输出，是将字节或者字符从流中输出到文件中
/**
* 文件拷贝，字节批量读取
* @param srcFile
* @param destFile
* @throws IOException
*
* JAVA的throw和throws區別：
* http://zhidao.baidu.com/link?url=cOoyefusSFJRvXFuNK3vAVS_mGcE3jgWSy8CiwZk5y-N8Fa-m_cwRrNVEneXKkwMOTYHz8MIIS13gAz91Y4vZ_
*/
public static void copyFile(File srcFile,File destFile)throws IOException{
if(!srcFile.exists()){
throw new IllegalArgumentException("文件:"+srcFile+"不存在");
}
if(!srcFile.isFile()){
throw new IllegalArgumentException(srcFile+"不是文件");
}
FileInputStream in = new FileInputStream(srcFile);
FileOutputStream out = new FileOutputStream(destFile);
byte[] buf = new byte[8*1024];
int b ;
    while((b = in.read(buf,0,buf.length))!=-1){
    //講buf數組裡的內容讀入到該輸出流中（out）
    out.write(buf,0,b);
    out.flush();//最好加上
    }
    in.close();
    out.close();

}

IO流（输入流、输出流）

字节流、字符流

1. 字节流

1）InputStream、OutputStream 两个都抽象类 

InputStream抽象了应用程序读取数据的方式

OutputStream抽象了应用程序写出数据的方式

2）EOF = End 读到-1就读到结尾

3）输入流基本方法

int b = in.read();读取一个字节（=8位）无符号填充到int低八位 -1是EOF

in.read(byte[ ] buf)  读取数据填充到字节数组buf

in.read(byte[ ] buf,int start,int size) 读取数据到字节数组buf 从buf的start位置开始存放size长度的数据

4）输出流基本方法

out.write(int b) 写出一个byte到流，b的低8位

out.write(byte[ ] buf)将buf字节数组都写入到流

out.write(byte[ ] buf,int start,int size)字节数组buf从start位置开始写size长度的字节到流

5）FileInputStream--->具体实现了在文件上读取数据

6）FileOutputStream--->实现了向文件中写出byte数据的方法

字节流---FileOutputStream(文件输出流)

 public static void copyFile(File srcFile,File destFile) throws IOException{
  if(!srcFile.exists()){
   throw new IllegalArgumentException("文件"+srcFile+"不存在");
  }
  if(!srcFile.isFile()){
   throw new IllegalArgumentException(srcFile+"不是文件");
  }
  FileInputStream in = new FileInputStream(srcFile);
  FileOutputStream out = new FileOutputStream(destFile);
  byte[] buf = new byte[8*1024];
  int b;
  while((b = in.read(buf,0,buf.length))!=-1){
   out.write(buf, 0, b);
   out.flush();//最好加上
  }
  in.close();
  out.close();
 }

java中需要手动释放的资源常见的有以下两个：

1. 流相关资源

   流相关资源一般遵循：

   1）先开后关，先开的输入流，再开的输出流，通过读取输入流写入输出流中，那么应该先关输出流，再关输入流，但是一般关闭输入输出流操作都是在读写完成后的finally中执行的，所以即使先关输入流，再关输出流也不会任何问题，因为读写操作没有进行了。

   2）先关外层，再关内层。如BufferedInputStream包装了一个FileInputStream，那么先

   关BufferedInputStream，再关FileInputStream。但要注意的是由于一般处理流持有节点流引用，处理流都会在自己的close方法中去关闭节点流，因此我们只要关闭外层的处理流即可，如果多此一举的关闭节点流反而会报错。如BufferedInputStream包装了FileInputStream，我们只要关闭BufferedInputStream即可

   3）只关处理流，不关节点流，原因见上述第二条

   流相关文章参考：http://blog.csdn.net/u012250875/article/details/78341874

2. jdbc相关资源

   Connection，PrepareStatement，ResultSet三个资源。这三个资源的获取顺序是：

   先获得一个jdbc连接对象Connection，再通过连接对象获得一个sql预处理对象PrepareStatement，如果是查询的话最后还会通过PrepareStatement对象获取一个结果集ResultSet对象，关闭顺序与获取顺序正好相反。先关ResultSet，再关PrepareStatement，最后关Connection。

创建FileOutputStream,用new FileOutputStream(String path)的方法，

如果文件不存在这直接创建，如果存在则删除后创建