package org.westos_03;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/**
* 复制文件
* 需求:将当前项目下的DataStreamDemo.java中的内容复制到当前项目下Copy.java文件中
*
* 分析:
* 数据源:DataStreamDemo.java---->BufferedReader---->读数据--->readLine()
* 目的地:Copy.java------>BufferedWriter---->写数据
*
*/
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
/*//1)封装数据源
BufferedReader br = new BufferedReader(new FileReader("DataStreamDemo.java")) ;
//2)封装目的地
BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java")) ;
//使用BufferedReader中的特有功能读写操作
String line = null ;
while((line=br.readLine())!=null){
//写数据
bw.write(line) ;
//换行
bw.newLine() ;
//刷新流
bw.flush() ;
}
//释放资源
bw.close() ;
br.close() ;*/
//改进
// 1)封装数据源
BufferedReader br = new BufferedReader(new FileReader("DataStreamDemo.java")) ;
2)封装目的地
//创建字符打印流对象,并且启动自动刷新功能
PrintWriter pw = new PrintWriter(new FileWriter("Copy.java"), true) ;
//读写操作
String line = null ;
while((line=br.readLine())!=null){
//写数据
pw.println(line) ;
}
//关闭资源
pw.close() ;
br.close() ;
}
}
**
* DataOutputStream和DataInputStream
* 都属于数据流:可以针对Java基本数据类型的数据进行读写操作
*
* DataOutputStream构造方法
* public DataOutputStream(OutputStream out)
package org.westos_01;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class DataStreamDemo {
public static void main(String[] args) throws IOException {
// write();
read();
}
//读数据
private static void read() throws FileNotFoundException, IOException {
//读数据
//创建数据输入流对象
DataInputStream dis = new DataInputStream(
new FileInputStream("dos.txt"));
//读数据
byte b = dis.readByte() ;
int i = dis.readInt() ;
short s = dis.readShort() ;
long l = dis.readLong() ;
char ch = dis.readChar() ;
boolean flag = dis.readBoolean() ;
float f = dis.readFloat() ;
double d = dis.readDouble() ;
//释放资源
dis.close() ;
System.out.println(b);
System.out.println(i);
System.out.println(s);
System.out.println(l);
System.out.println(ch);
System.out.println(flag);
System.out.println(f);
System.out.println(d);
}
//写数据
private static void write() throws FileNotFoundException, IOException {
//创建数据输出流对象
DataOutputStream dos = new DataOutputStream(new FileOutputStream(
"dos.txt"));
//写数据
dos.writeByte(100) ;
dos.writeInt(1000) ;
dos.writeShort(120) ;
dos.writeLong(1000000L);
dos.writeChar('A') ;
dos.writeBoolean(true) ;
dos.writeFloat(12.34F) ;
dos.writeDouble(12.56) ;
//释放资源
dos.close() ;
}
}
* ByteArrayInputStream和ByteArrayOutStream(重点)
* 内存操作流:针对内存的数据进行操作的,程序一结束,这些内存中的数据就消失掉了!
* 特点:针对小文件进行操作!(聊天室项目中使用它进行发送文件)
*
*
* ByteArrayOutputStream:
* public ByteArrayOutputStream():创建默认的缓冲区大小的内存操作输出流(单位是字节)
* 成员方法:
* public byte[] toByteArray()创建一个新分配的 byte 数组(将内存操作输出流对象转换成字节数组)
* void reset():重置内存操作输出流
* ByteArrayInputStream:内存操作输入流:
* public ByteArrayInputStream(byte[] buf):参数数一个字节数组(缓冲数组)
*
package day19;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
public class ByteArrayStreamDemo {
public static void main(String[] args) {
//创建内存操作输出流对象、
ByteArrayOutputStream baos = new ByteArrayOutputStream();
//写数据
for(int x=0;x<5;x++){
baos.write("hello"+x).getBytes());
}
//将内存操作输出流对象转换成字节数组
//public byte[] toByteArray()创建一个新分配的 byte 数组(将内存操作输出流对象转换成字节数组)
byte[] buffer = baos.toByteArray() ;
//创建内存操作输入流对象
ByteArrayInputStream bais = new ByteArrayInputStream(buffer) ;
//一次读取一个字节
int by = 0 ;
while((by=bais.read())!=-1){
System.out.print((char)by);
}
//关闭
// bais.close() ;
}
}
}* 复制文件
* 需求:将当前项目下的DataStreamDemo.java中的内容复制到当前项目下Copy.java文件中
*
* 分析:
* 数据源:DataStreamDemo.java---->BufferedReader---->读数据--->readLine()
* 目的地:Copy.java------>BufferedWriter---->写数据
package org.westos_03;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/**
* 复制文件
* 需求:将当前项目下的DataStreamDemo.java中的内容复制到当前项目下Copy.java文件中
*
* 分析:
* 数据源:DataStreamDemo.java---->BufferedReader---->读数据--->readLine()
* 目的地:Copy.java------>BufferedWriter---->写数据
*
*/
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
/*//1)封装数据源
BufferedReader br = new BufferedReader(new FileReader("DataStreamDemo.java")) ;
//2)封装目的地
BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java")) ;
//使用BufferedReader中的特有功能读写操作
String line = null ;
while((line=br.readLine())!=null){
//写数据
bw.write(line) ;
//换行
bw.newLine() ;
//刷新流
bw.flush() ;
}
//释放资源
bw.close() ;
br.close() ;*/
//改进
// 1)封装数据源
BufferedReader br = new BufferedReader(new FileReader("DataStreamDemo.java")) ;
2)封装目的地
//创建字符打印流对象,并且启动自动刷新功能
PrintWriter pw = new PrintWriter(new FileWriter("Copy.java"), true) ;
//读写操作
String line = null ;
while((line=br.readLine())!=null){
//写数据
pw.println(line) ;
}
//关闭资源
pw.close() ;
br.close() ;
}
}
* 打印流:
* 字节打印流:PrintStream
* 字符打印流:PrintWriter
* 打印流特点:
* 1)在复制文件的,打印流不能操作数据源,只能操作目的地的数据(只能输出数据)
* 2)打印流可以有自动刷新的功能
* 3)打印流可以直接针对文本文件进行操作:
* 什么情况下是直接可以针对文本文件进行操作?
* 查API的时候,看流中构造方法,只要构造方法的参数有File类或者是String类型,都可以针对文本文件进行操作
* FileInputStream
* FileOutputStream
* FileReader
* FileWriter
*
* PrintWriter:
* 构造方法:
* public PrintWriter(String fileName)
*
package org.westos_03;
import java.io.IOException;
import java.io.PrintWriter;
public class PrintWriterDemo {
public static void main(String[] args) throws IOException {
//创建字符打印流对象
PrintWriter pw = new PrintWriter("pw.txt") ;
//写数据
pw.write("hello") ;
pw.write("world") ;
pw.write("Java") ;
//刷新
pw.flush() ;
//释放资源
pw.close() ;
}
}
* PrintWriter:有自动刷新功能:
* public PrintWriter(Writer out,boolean autoFlush)
* 第二个参数指定为true,则启动自动刷新
* PrintWriter pw = new PrintWriter(new FileWriter("pw.txt"),true) ;
* 加入自动刷新功能并且在写数据的时候,使用println():换行
*
* println("hello")
*
*
*
* 相当于:
* pw.write("") ;
* pw.newLine() ;
* pw.flush() ;
*
*
package day19;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
public class PrintWriterDemo {
public static void main(String[] args) throws IOException {
@SuppressWarnings("resource")
PrintWriter pw=new PrintWriter(new FileWriter("pw2.txt"));
//使用println
//public void println(string x):打印字符串，并且终止该行
pw.print("hello");
pw.print("world");
//关闭流资源
pw.close();
}
}
* 键盘录入的两种方式
* 1)Scanner类
* Scanner sc = new Scanner(System.in) ;
* 2)使用IO流的形式进行录入数据
* BufferedReader br = new BufferedReader(new InputStreamReader(System.in)) ;
package day19;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class SystemInDemo {
public static void main(String[] args) throws IOException {
//另一种录入数据的方式
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
//录入数据
System.out.println("请输入一个字符串");
String Line=br.readLine();
System.err.println();
System.out.println("请输入一个整形数据");
String s=br.readLine();
int a = Integer.parseInt(s) ;//long l = Long.pareLong(s) ;
System.out.println("您输入的整数是:"+a);
}
}
* 标准输入和输出流
* System类中有两个字段:
* in:----->InputStream is = System.in ;
* out----->PrintStream ps = System.out ;
* System.out.println();
* @author Apple
*/
package org.westos_04;
import java.io.PrintStream;
public class SystemOutDemo {
public static void main(String[] args) {
//经常使用输出语句
System.out.println("helloworld") ;
System.out.println("helloworld") ;
//字节打印流
PrintStream ps = System.out ;
//字节打印流调用PrintStream类中的方法
// ps.print() ;这个方法不存在
ps.println("javaweb") ;//打印一个字符串数据并且终止当前行
ps.println() ;
}
}
* 使用BufferedReader完成了录入数据:
* 使该流封装字符转换输入流,然后使用字符转换输入流封装字节流
*
* 按照上述方式,将BufferedWriter层层封装标准输出流,将数据打印控制台
package org.westos_04;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
public class SystemOutDemo2 {
public static void main(String[] args) {
/*PrintStream ps = System.out ;
//写入一个分隔符:newLine()是BufferedWriter类中的方法
// BufferedWriter bw = new BufferedWriter(ps) ;
//将字节打印流转换成字符流
OutputStreamWriter osw = new OutputStreamWriter(ps) ;
//创建字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(osw) ;*/
BufferedWriter bw = null ;
try {
bw = new BufferedWriter(new OutputStreamWriter(
System.out));
//写数据
bw.write("hello") ;
bw.newLine() ;
bw.write("world") ;
bw.newLine() ;
bw.write("Javaweb") ;
bw.newLine() ;
//刷新
bw.flush() ;
} catch (IOException e) {
e.printStackTrace();
}finally{
//对流对象进行判断
if( bw!=null){
try {
bw.close() ;
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}* java.io
* RandomAccessFile:随机访问流:此类的实例支持对随机访问文件的读取和写入
* 不是实际意义上的流,因为它继承自Object类
* 常用的构造方法:
* public RandomAccessFile(String name, String mode)
参数一:指定该文件的路径
package org.westos_05;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomAccessFileDemo {
public static void main(String[] args) throws IOException {
// write();
read();
}
//读数据
private static void read() throws FileNotFoundException, IOException {
RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw") ;
读数据
//public long getFilePointer():返回此文件中的当前偏移量。 文件开头的偏移量（以字节为单位
byte b = raf.readByte() ;
System.out.println(b);
System.out.println("getFilePointer:"+raf.getFilePointer());
char ch = raf.readChar() ;
System.out.println(ch);
String str = raf.readUTF() ;
System.out.println(str);
//关闭资源
raf.close() ;
}
//写数据
private static void write() throws FileNotFoundException, IOException {
//创建随机访问流对象
RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw") ;
//写数据
raf.writeByte(100) ;
raf.writeChar('a') ;
raf.writeUTF("中国") ;
//关闭资源
raf.close() ;
}
}
* SequenceInputStream:合并流(读数据):表示其他输入流的逻辑串联
* 合并流在复制文件的时候,只能操作数据源,不能操作目的地
*
* 之前的操作:
* a.txt-->b.txt
* c.txt--->d.txt
*
* 现在有合并流(将两个文件中的内容复制到另一个文件中)
* a.txt+b.txt--->c.txt文件中
* 构造方法:
* public SequenceInputStream(InputStream s1,InputStream s2)
*
* 需求:将DataStreamDemo.java和ByteArrayStreamDemo.java两个java文件中的内容复制到
* Copy.java文件中
*
* 分析:
* 1)数据源:DataStreamDemo.java和ByteArrayStreamDemo.java----->SequenceInputStream----->分别读取第一个和第二个java文件
* 2)目的地:Copy.java----->BufferedOutputStream---->写数据
package org.westos_06;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
public class SequenceInputStreamDemo {
public static void main(String[] args) throws IOException {
//分别封装这个两个java文件
InputStream s1 = new FileInputStream("DataStreamDemo.java") ;
InputStream s2 = new FileInputStream("ByteArrayStreamDemo.java") ;
//创建合并流对象
SequenceInputStream sis = new SequenceInputStream(s1, s2) ;
//封装目的地
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream("Copy.java"));
//一次一个字节数组
byte[] bys = new byte[1024] ;
int len = 0 ;
while((len = sis.read(bys))!=-1){
//写数据
bos.write(bys, 0, len) ;
bos.flush() ;
}
// 释放资源
sis.close() ;
bos.close() ;
}
}* 序列化流:将对象像流的方式或者网络传输中的数据写数据.对象---->流数据:ObjectOutputStream
* 反序列化:将流数据或者网络传输中的流数据读取出来.流数据---->还原成对象:ObjectInputStream
* @author Apple
*
* ObjectOutputStream中的成员方法:
* public final void writeObject(Object obj):将obj对象写入到当前的序列化流中
* ObjectInputStream中的成员方法:
* public final Object readObject():从当前反序列化流中读取一个对象
package org.westos_07;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/
public class ObjectStreamDemo {
public static void main(String[] args) throws Exception {
// write() ;
read();
}
//读数据
private static void read() throws IOException, FileNotFoundException,
ClassNotFoundException {
//反序列化:将当前流数据--->对象
//创建一个反序列化流对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
"oos.txt"));
//使用反序列化:将流数据--->对象
Object obj = ois.readObject() ;
//关闭资源
ois.close() ;
System.out.println(obj);
}
//序列化
private static void write() throws IOException {
//创建一个对象
Person p = new Person("高圆圆", 27) ;
//创建一个序列化流对象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
"oos.txt"));
//写数据
// writeObject(Object obj)
oos.writeObject(p) ;
//释放资源
oos.close() ;
}
}
1765
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
