在程序设计语言中，数据的保存是基本，如果某程序语言不能保存数据那么该语言是不可能存在的，JAVA是当今最流行的面向对象设计语言之一，在保存数据中也有自己独特的一面，字节流和字符流
1，字节流是由字节构成的，字符流是由字符构成的 字节流和字符流都是继承的InputStream和OutPutStream ,java中两种最基本的就是字节流和字符流
类 FileInputStream 从文件系统中的某个文件中获得输入字节
类 FileOutputStream 文件输出流是用于将数据写入 File 或 FileDescriptor 的输出流。文件是否可用或能否可以被创建取决于基础平台。特别是某些平台一次只允许一个 FileOutputStream（或其他文件写入对象）打开文件进行写入。在这种情况下，如果所涉及的文件已经打开，则此类中的构造方法将失败。
2，数据流：用于传输的管道
3.java.io 输入流 InputStream 输出流 OutputStream
4.对文件系统的输入和输出 字节流：数据在管道中是以字节的方式传输的
文件输入流 FileInputStream
文件输出流 FileOutputStream
将字节流包装到缓冲流中，传输的速度回提高几百倍，在下面的代码中我们将做测试
缓冲字节输入流 BufferedInputStream
缓冲字节输出流 BufferedOutputStream
5，使用FileInputStream来一字节一个字节的读取字节：在写代码之前先看api文档中字节输入流中有哪些方法，
在java输入流中，如果程序读取的文件不存在 程序是不会自动的创建该文件，输出流则会自己创建
在工程中创建一个FileInputstream01.txt 文本，里面写"中国式"个字符
package FileIO0523;
/**
* 字节流的操作
* 使用FileInputStream来一字节一个字节的读取字节
*/
import java.io.File;
import java.io.FileInputStream;
public class FileInputstream01 {
public static void main(String[] args) {
//创建文件的对象
File file = new File("FileInputstream01.txt");
try{
//try-catch是因为这个文件可能不存在，程序可能会无法执行抛出异常
//使用文本创建输入流对象
FileInputStream fis =new FileInputStream(file);
// for(int i=0;i<file.length();i++){
// //byte ch = (byte) fis.read();
// char ch = (char) fis.read();
// System.out.println(ch);
// }
//根据文件的长度来创建一个byte数组用来保存字节
//
byte[] by= new byte[(int) (file.length())];
fis.read(by);
String str = new String(by);
System.out.println(str);
// fis.read();
fis.close();
//}
}catch(Exception e){
e.printStackTrace();
}
}
}
运行结果; 中国式
分析read()；也可以用来判断读的字节，当read为-1的时候表示已经是最后一个字节了
fis.read(by);将by数组中的字符一个一个读出来
String str = new String(by);通过使用平台的默认字符集解码指定的 byte 数组 ， 构造一个
新的 String
System.out.println(str);
将这个String打印出来
fis.close();关闭这个输入流，java程序是运行在java虚拟机上面的，虚拟机的运行空间是由系统内存分配的，如果不关闭输入流空间，会导致大量的内存浪费，及内存空间不足
6，使用FileOutputStream来一字节一个字节的写字节：在写代码之前先看api文档中字节输入流中有哪些方法，
在java输入输出的文件操作中，如果该文件在程序要输出时不存在 程序会自动的创建该文件 ，
package FileIO0523;
import java.io.File;
import java.io.FileOutputStream;
/**
* 创建一个字节输出流
* @author Administrator
*
*/
public class FileoutputStream01 {
public static void main(String[] args) {
String str ="湖南长沙";
//由于是静态方法可直接通过方法名来调用
put01(str);
}
//创建一个静态的方法，方便在主函数中来调用该方法
public static void put01(String str){
//创建文件对象，文件输出对象会在输出时候判断
// 该文件是否存在，如果不存在会自动创建该标准文件
File file = new File("FileoutputStream01.txt");
try{
//通过文件创建输出字节流的对象
//创建输出流
//参数一：要写入的文件
//参数二：是否需要将数据追到数据的末尾ture表示追加到末尾，false表示覆盖
FileOutputStream stream = new FileOutputStream(file,true);
//将字符串保存到数组中
byte[] buf=str.getBytes();
//将数组中的元素写出来
stream.write(buf);
//强制的从内存写到硬盘中
stream.flush();
//关闭流
stream.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
运行结果： 湖南长沙
分析:该程序在写出字符时会先判断要写出的文件是否存在，如果不存会自动的创建
7，如何在一个程序中将读取到的方法写到文件中去：下面是一个复制程序:
package FileIO0523;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
/**
* 文件流的操作
*
*
*
*/
public class FIleIO2 {
public static void main(String args[]) {
String path = "C:\\Users\\Administrator\\Desktop\\import";
String path1 = "F:\\file1\\import";
// 创建文件对象
File f = new File(path);
File f1 = new File(path1);
long t1 = System.currentTimeMillis();
byte[] str = readFile(f);
writeFile(f1, str);
long t2 = System.currentTimeMillis();
System.out.println("复制完成！耗时：" + (t2 - t1) + "ms");
}
public static void writeFile(File f, byte[] bs) {
try {
// 根据文件对象建立文件输出流
// 参数1：要写入数据的文件路径
// 参数2：是否将数据追加到文件末尾
FileOutputStream fos = new FileOutputStream(f, false);
// 将输出流包装成缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(fos);
// 使用缓冲流将数组写入输出流
bos.write(bs);
// 强制将管道中的数据输出到目标，保证数据写完整
bos.flush();
// 关闭输出流
fos.close();
} catch (Exception ef) {
ef.printStackTrace();
}
}
/**
* 读取文件数据的方法
*
* @param f
* 要读读取的文件路径
*/
public static byte[] readFile(File f) {
try {
// 根据文件建立建立文件输入流
FileInputStream fis = new FileInputStream(f);
// 将文件输入流打包成缓冲输入流
BufferedInputStream bis = new BufferedInputStream(fis);
int len = bis.available();// 得到流中的字节数
// 方式一：通过流的长度决定读的次数
// while(len>0){
// //读取流中的一个字节
// int b = fis.read();
// System.out.println("字节:"+b);
// len = fis.available();
// }
byte[] bs = new byte[len];
// 方式二，通过读取的字节判断读取的次数〉若为-1，就结束
// int i=0;
// int b = fis.read();
// while(b!=-1){
// System.out.println("字节:"+b);
// //将字节保存到字节数组
// bs[i]=(byte)b;
// i++;
//
// b = fis.read();
// }
// 方式三：直接将数据读取到字节数组，数组有多大，就读取多少次
bis.read(bs);
fis.close();
return bs;
} catch (Exception ef) {
ef.printStackTrace();
}
return null;
}
}
分析：在这个复制程序中创建两个方法分别是读和写，在程序的执行中会先调用读的方法，将读取到的内容保存到数组中 在读的方法中不直接打印出来 通过return返回主函数中以数组的形式来接受；并且该数组要作为参数传递到写的方法中；
7，作业：在一个方法中完成文件的复制
分析：方法中要包读和写的操作
package FileIO0523;
/**
* 不可以拷贝文件夹，图片
*/
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
/**
* 作业：在一个方法中完成文件的复制
* @author Administrator
*
*/
public class copyinputoutput02 {
public static void main(String[] args) {
//源文件的地址
String path1 ="C:\\Users\\Administrator\\Desktop\\文件操作.rar";
//copy的地址
String path2 = "F:\\file1\\文件操作.rar";
File file1 = new File(path1);
File file2 = new File(path2);
copy02(file1,file2);
System.out.println("拷贝完成");
}
public static void copy02(File file1,File file2){
try{
//读
FileInputStream fis= new FileInputStream(file1);
//创建输入缓冲流
BufferedInputStream bis = new BufferedInputStream(fis);
//根据读到文件的大小来创建数组
byte[] by = new byte[(int) (file1.length())];
//读取
bis.read(by);
//关闭流
fis.close();
//写
FileOutputStream fos = new FileOutputStream(file2);
//创建输出缓冲流
BufferedOutputStream bos = new BufferedOutputStream(fos);
//直接写保存在数组中的数据
bos.write(by);
//强制写出来
bos.flush();
//关闭流空间
fos.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
分析：该程序的可读性高，在一个方法中不做任何的返回，将读取到的数据保存到根据读取的文件大小创建的数组中，写的方法可以调用；