java基础10（IO流）-字节流
IO流
输入与输出【参照物是程序】
如果从键盘、文件、网络甚至是另一个进程（程序或系统）将数据读入到程序或系统中，称为输入
如果是将程序或系统中的数据写到屏幕、硬件上的文件、网络上的另一端或者是一个进程（程序或系统），称为输出
IO流的分类
- 根据数据流向不同分为：输入流和输出流
输入流: 程序可以从中读取数据的流
输出流: 程序能向其中写入数据的流
- 根据数据处理类不同分为：字节流和字符流
字节流：以字节为单位传输数据的流
字符流：以字符为单位传输数据的流
注：数据所在文件若能用win下记事本打开则用字符流
IO流类结构图
读数据
InputStream读取数据
int read() ： 从此输入流中读取一个数据字节 int read(byte[] b): 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。返回值是一次读取字节数组的个数
int read(byte[] b, int off, int len): 从此输入流中将最多 len 个字节的数据读入一个 byte 数组中
InputStream读取数据（一次读取一个字节）
import java.io.FileInputStream;import java.io.IOException;
public class FileInputStreamDemo{
public static void main(String[] args) throws IOException{
FileInputStream file = new FileInputStream("/home/hadoop/1.txt");
/*
int by = file.read();//一次读取一个字节
System.out.println(by);
System.out.println((char) by);
*/
//方式1（一次读取一个字节）
int by = 0;
while((by = file.read()) != -1){
// System.out.print(by);//不转的话读出来全是数字
System.out.print((char)by);//这里需要注意文件中如果有中文将出问题，因为将中文也转成char了;要读取的文件中有换行符，直接读取过来，所以这里不需要换行符
}
file.close();
}
}
InputStream读取数据（一次读取一个字节数组）
import java.io.FileInputStream;import java.io.IOException;
public class FileInputStreamDemo2{
public static void main(String[] args)throws IOException{
FileInputStream fis = new FileInputStream("/home/hadoop/1.txt");
byte[] bys = new byte[1024];
int len = 0;
while((len = fis.read(bys)) != -1){ //读取到的实际长度是-1就没有数据了
System.out.print(new String(bys,0,len));//进行转换
}
fis.close();
}
}
BufferedInputStream读取数据(一次读一个字节)
import java.io.BufferedInputStream;import java.io.FileInputStream;
import java.io.IOException;
public class BufferedInputStreamDemo{
public static void main(String[] args)throws IOException{
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("/home/hadoop/1.txt"));
int by =0;
while((by = bis.read()) != -1){
System.out.print((char)by);
}
bis.close();
}
}
BufferedInputStream读取数据(一次读一个字节数组)
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class BufferedInputStreamDemo{
public static void main(String[] args)throws IOException{
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("/home/hadoop/1.txt"));
byte[] bys = new byte[1024];
int len = 0;
while((len = bis.read(bys)) != -1){
System.out.print(new String(bys,0,len));
}
bis.close();
}
}
写数据
OutputStream写数据
void write(byte[] b):将 b.length 个字节从指定的 byte 数组写入此输出流void write(byte[] b, int off, int len): 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
void write(int b): 将指定的字节写入此输出流。
FileOutputStream写数据（写一个字节）
import java.io.FileOutputStream;import java.io.IOException;
public class FileOutputStreamDemo{
public static void main(String[] args)throws IOException{
/* //创建字节输出流对象
File file = new File("/home/hadoop/1.txt");
FileOutputStream fos = new FileOutputStream(File file);
*/
FileOutputStream fos = new FileOutputStream("/home/hadoop/wu.txt",true);//true表示追加数据
fos.write("wujiadong".getBytes());//将字符串转成字节数组
fos.write(97);//写一个字节
fos.close();
}
}
FileOutputStream写数据（写一个字节数组和写字节数组的部分）
import java.io.FileOutputStream;import java.io.IOException;
public class FileOutputStreamDemo{
public static void main(String[] args)throws IOException{
/* //创建字节输出流对象
File file = new File("/home/hadoop/1.txt");
FileOutputStream fos = new FileOutputStream(File file);
*/
FileOutputStream fos = new FileOutputStream("/home/hadoop/wu.txt",true);
byte[] bys = {97,98,99,100};
fos.write(bys);//写一个字节数组
fos.write(bys,1,3);//写一个字节数组的一部分
fos.close();
}
}
BufferedOutputStream写数据
import java.io.FileOutputStream;import java.io.IOException;
import java.io.BufferedOutputStream;
public class BufferedOutputStreamDemo{
public static void main(String[] args)throws IOException{
// FileOutputStream fis = new FileOutputStream("/home/hadoop/wu2.txt");
// BufferedOutputStream bos = new BufferedOutputStream(fis);
//简单写法
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("/home/hadoop/wu3.txt"));
//写数据
bos.write("hello,wujiadong".getBytes());
//释放资源
bos.close();
}
}
读写数据练习
复制数据
import java.io.FileInputStream;import java.io.FileOutputStream;
import java.io.IOException;
public class CopyFileDemo{
public static void main(String[] args) throws IOException {
//封装数据源
FileInputStream fis = new FileInputStream("/home/hadoop/11.txt");
//封装目的地
FileOutputStream fos = new FileOutputStream("/home/hadoop/a.txt");
//复制数据
int by = 0;
while((by = fis.read()) != -1){
fos.write(by);
}
//释放资源
fis.close();
fos.close();
}
}
---------------------------------------
注：这种方法一次读一个字节，比较慢
----------------------------------------
复制数据
import java.io.FileInputStream;import java.io.FileOutputStream;
import java.io.IOException;
public class CopyFileDemo1{
public static void main(String[] args)throws IOException{
//封装数据源
FileInputStream fis = new FileInputStream("/home/hadoop/11.txt");
FileOutputStream fos = new FileOutputStream("/home/hadoop/wu.txt");
//复制数据
byte[] bys = new byte[1024];
int len = 0;
while((len = fis.read(bys)) != -1){
fos.write(bys,0,len);
}
//释放资源
fis.close();
fos.close();
}
}
字节流4种方式复制文件
/* * 字节流4种方式复制文件
* 基本字节流一次读写一个字节
* 基本字节流一次读写一个字节数组
* 高效字节流一次读写一个字节
* 高效字节流一次读写一个字节数组
*/
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
public class CopyDemo{
public static void main(String[] args)throws IOException{
long start = System.currentTimeMillis();
// method1("/home/hadoop/1.txt","/home/hadoop/javatest/1.txt");
// method2("/home/hadoop/1.txt","/home/hadoop/javatest/1.txt");
// method3("/home/hadoop/1.txt","/home/hadoop/javatest/1.txt");
method4("/home/hadoop/1.txt","/home/hadoop/javatest/1.txt");
long end = System.currentTimeMillis();
System.out.println("共耗时："+(end - start)+"mm");
}
public static void method1(String srcString,String desString)throws IOException{
FileInputStream fis = new FileInputStream(srcString);
FileOutputStream fos = new FileOutputStream(desString);
//方法1：读写一个字节
int by = 0;
while((by = fis.read()) != -1){
fos.write(by);
}
fis.close();
fos.close();
}
public static void method2(String srcString,String desString)throws IOException{
FileInputStream fis = new FileInputStream(srcString);
FileOutputStream fos = new FileOutputStream(desString);
//方式2：读取一个字节数组
byte[] bys = new byte[1024];
int len = 0;
while((len = fis.read(bys)) != -1){
fos.write(bys,0,len);
}
fis.close();
fos.close();
}
public static void method3(String srcString,String desString)throws IOException{
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcString));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desString));
//方式3：高效读取一个字节
int by = 0;
while((by = bis.read()) != -1){
bos.write(by);
}
bis.close();
bos.close();
}
public static void method4(String srcString,String desString)throws IOException{
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcString));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desString));
//高效读取一个字节数组
byte[] bys = new byte[1024];
int len = 0;
while((len = bis.read(bys)) != -1){
bos.write(bys,0,len);
}
bis.close();
bos.close();
}
}
以上是 java基础10（IO流）-字节流 的全部内容， 来源链接： utcz.com/z/391904.html
