I/O 字节流
-
两种基本的流：1. 输入流Inputstream
2. 输出流 Outputsteam
-
两种流采用相同顺序读写方式：1. 过程：打开流--->执行读(写)操作--->关闭流
2. 节点流：从特定地方读写的流类，
例如：磁盘或一块内存区域
3. 过滤流：使用一个已经存在的输入流或者输出流连接创键的输入流
或者输出流叫过滤或者处理流，它要对相连的另一个流进行
某种转换。
4. OutputStream是抽象顶层父类，不能实现实例化，因此实现功能是由派生子类
-
数据读取方法：1. 基本读法: read()；(读一个字节返回，如返回-1，则文件结束)
read(byte [] b) (将数据读入字节数组b中，返回所读字节数)
2. close()（数据读取完成，关闭流）
4. long skip (long n) (跳过（扔掉）n个字符)
5. mark(int) (标记当前流，并建立int大小缓冲区)
6. void reset() (返回标签处)
7. 字节流数组用toString避免乱码
package src;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class TestFileInputStream1
{
public static void main(String[] args) throws IOException
{
FileInputStream fin=new FileInputStream("data.dat");//创建字节输入流对象fin
int c,count=0;
while ((c=fin.read())!=-1) //读一个字节，如果不为-1，就没有达到文件末尾
{
System.out.print((char) c);//以字符形式输出。如果有汉字，输出为乱码，因为一个汉字占两个字节
count++;
}
System.out.println("\n共读取"+count+"个字节");
fin.close();//关闭fin;
}
}
----------------------------
package src;
import java.io.*;
public class TestFileInputStream3
{
public static void main(String[] args)
{
try
{
FileInputStream fin = new FileInputStream("data.dat");//创建字节输入流对象fin
byte buf[] = new byte[fin.available()];////创建字节数组，长度为fin中未读的字节数。
int count; //记录实际读取字节数
count=fin.read(buf); //从文件输入流fin中读取字节数据
//count=fin.read(buf,0,buf.length); //从文件输入流fin中读取字节数据到buf数组
System.out.println("共读取"+count+"个字节");
System.out.print(new String(buf));
fin.close(); //关闭fin输入流
}
catch (IOException ioe)
{
System.out.println("I/O异常");
}
}
}
-
基本读法：1. write(int c) (向输出流中写一个字节)
2. write(byte[]b) (向输出中写一个字节数组)
3. write(byte b,int offset, int length) (将字节数组b中由offset和length指示的数据块写入)
4. fluch() (将强制将缓存的输出数据写出去)
注意：必须将字符串转换为字节数组。
package src;
import java.io.*;
public class TestFileOutputStream1
{
public static void main(String[] args)
{
try
{
FileOutputStream fout = new FileOutputStream("data.dat");//创建文件输出流对象fout
String str="more and more";
byte buf[] = str.getBytes();//将字符串str转化为字节数组
for (int i=0;i<buf.length;i++)
fout.write(buf[i]); //逐个字节写入
System.out.print("写入文件成功!");
fout.close(); //关闭fout
}
catch (IOException ioe)
{
System.out.println("I/O异常");
}
}
}
----------------------------
package IOinputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
public class outStream1
{
public static void main(String[] args) throws Exception
{
FileOutputStream fileOutputStream=new FileOutputStream("d:/A.txt");
String s="写入成功";
byte [] a=s.getBytes();//将字符串str转化为字节数组
//fileOutputStream.write(a);
fileOutputStream.write(a,0,a.length);
System.out.println(a);
fileOutputStream.close;//关闭
}
}
总结：
2. read(byte [] b) 因为读取的字节数在数组中，可以直接读取。
例：记录读取字节数=对象.read(数组名)
-
写方法：1. write()：要一个字节一个字节读，得用循环来读取
2. write(byte [] b) : 直接读取。
例：对象.write(数组);
多个流构成一个流键
package src;
import java.io.*;
public class Test1
{
public static void main(String[] args)
{
try
{
FileInputStream fin = new FileInputStream("indata.dat");//创建文件输入流对象fin
BufferedInputStream in =new BufferedInputStream( fin);//组合生成输入流对象in
byte buf[] = new byte[in.available()];//定义字节数组，长度为in的未读字节数。
in.read(buf);//将in流中的数据读入到数组buf
System.out.println(new String(buf));//输出buf中的内容
in.close(); //关闭in输入流
fin.close();//关闭fin输入流
}
catch (IOException ioe)
{
System.out.println("I/O异常");
}
}
}
------------------------
package src;
import java.io.*;
public class Test2
{
public static void main(String[] args)
{
try
{
FileOutputStream fout = new FileOutputStream("outdata.dat");//创建文件输出流对象fout
BufferedOutputStream out=new BufferedOutputStream(fout);//组合生成输出流对象out
String str="more and more";
byte buf[] = str.getBytes();//将字符串str转化为字节数组
out.write(buf); //将数组中内容写入到输出流
System.out.print("写入文件成功!");
out.close();//关闭out输入流
fout.close(); //关闭fout输入流
}
catch (IOException ioe)
{
System.out.println("I/O异常");
}
}
}
