在程序设计语言中,数据的保存是基本,如果某程序语言不能保存数据那么该语言是不可能存在的,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();
}
}
}
分析:该程序的可读性高,在一个方法中不做任何的返回,将读取到的数据保存到根据读取的文件大小创建的数组中,写的方法可以调用;