I/O编程—
title: 2017-3-28JavaDay13
tags: 新建,模板,小书匠
grammar_cjkRuby: true
I/O编程
- java.io.file
- File对象代表磁盘上的一个文件和目录
文件过滤器 File类
public static void main(String[] args)throws Exception{
File f=new File("F:\\1.txt"); //绝对路径
FIle f1=new File("F:\\","1.txt");
File dir=new File("F:\\");
File f3=new File(dir,"1.txt");
f.creatNewFile(); // 创建新文件
f.makedir(); //创建新目录
f.delect(); //删除文件
f.exists(); // 文件对象所代表的文件或目录是否存在
f.isDirectory(); //判断文件对象所代表的时文件还是目录
file f=new File("F:\\corejava");
FileFilrer f1=new MyFilter(); //可用匿名内部类
File[] fs=dir.listFile(); //遍历目录中的文件数组 即实现ls功能
for(File.f:fs)
{
if(f.isFile())System.out.println("wenjian"+f.GetName());
if(f.isFile()System.out.println("dir"+f.GetName()));
}
//利用匿名内部类创建一个对象实现接口
File[] fs=dir.listFiles(new FileFilter()
{
public booleab accept(File f)
{
String name=f.getName();
if(name.endsWith()"zip")
return ture;
}
else
return false;
});
// 使用匿名内部类实现接口
}
class MyFilter implements FileFilter{
public boolean accept(File f) // f该目录中的每一个文件或子目录
{
//接口回调
return false; //全部过滤掉
if(f.isDirectory())return false;
String name=f.getName();
if(name.endsWith("zip"))return ture; // 典型的接口回调
else
return false;
//打印目录中的zip文件
// 利用一个类创建接口，匿名内部类实现
}
}请打印出该目录下所有的.java文件, 无层次限制
使用递归方法解决上题
fite f=new file("F:\\corejava");
File[] fs=dir.listFIle(new FIleFilter()
{
public boolean accept(FIle f)
{
String name=f.getName();
if(name.endsWith("java"))
return ture;
else return false;
}
return false;
});
for(FIle f:fs)
{
if( f.isFIle())System.out.println(f.getAbsolutPath);
else
printjavaFiles(); //printJavaFiles为打印java文件
}
返回a的阶乘
int m(int a)
if(a==0)reuturn 1;
else return a*m(a-1);
// 递归思想I/O流
- I/O 流
- 流：对象，用来在JVM和外部数据源之间传输数据 （ 管道）连接JVM和外部数据源之间传输的管道
流对象的三种分类 - 按数据方向分：输入流和输出流 大部分为单向流
- 按数据的单位：字节流和字符流
- 按流功能：节点流和过滤流
- 节点流：实际传输数据的流
- 过滤流： 给节点流增强功能 实际不是传输数据
- 字节流：以字节为单位，可以处理一切数据
字符流：以字符为单位，只能处理文本数据
**InputStream/OutPutStream 字节流的父类
FileInputstream/FileOutputStream文件字节流 节点流**“`makedown
public static void main(Strimg[] args)throw Exception{
OutputStream os=new FileOutputStream(“1.txt”,ture);//创建流
//ture是否追加
os.write(“A”); // write(int a)把字节A写入文件
os.write(byte []bs); //把字节数据bs全部写出去
write(byte []bs,int of, int len);//八字阶数组的一段写出去，由后面两个参数决定那段数组， int off数组下标,int len//数组长度String str=”Hello world”;
OutputStream=new FileOutputStream(“1.txt”);
byte[]bs=str.getByte();//把字符串转成数组
os.write(bs);
os.close();// 关闭流 释放资源
//输出流public static void mian(String[] args)throw Exception{
InputStream=new InputStream(“1.txt);
//输入流中由三个读方法
int read(); 从文件中杜伊个字节，返回-1结束。
int read(byte[] bs);// 从文件中读多个字节，看字节数组的长度。读满bs，返回值为实际读到的字节数，以1为结束。
int read(byte[] bs,int off,int len);// 从文件中读多个字节，放入bs中的一段，返回为实际读到的字节数，已-1为结束。
//int read(byte[] bs)
public static void main(String[] args)throw Expection{
byte[]bs=new byte[6];
while(ture)
{
int i=is.read(bs);
if(i==-1)break;
for(byte b:bs);
{
System.out.println((char)b+” “)
}
System .out.pritnln();
}
is.close();
}//int read() while(ture) { int i=is.read(); if(i==)break;//保证读一次打印一次 else System.out.println((char)i); } System.out.pritnln(); is.close(); //输入流}
## 输出异常处理Exception
```makedown
public static void main(String[] args){
String str="Hello world";
OutputStream=null;
try{
os=new FileOutputStream("1.txt");
byte[] bs=str.getByte();
os.write(bs);
}
catch(IOException e)
{
e.printStackTrace();
}
finally{
try{
if(os!=null)os.close();
}
catch(IOException e)
{
e.printStackTrace();
}
}
}
<div class="se-preview-section-delimiter"></div>
字节数组 过滤流
public static void main(String[] args)throw Exception{
long l=1234567890123456789L;
OutputSrtream os=new FileOutpurStream("1.dat");
DataOutputStream out=new DataOutputStream(os);
out.writeLong(l);
out.close();
//查看文件内数据
InputStream is=new FileInputStream("1.dat");
DataOutputStream in=new DataInputStream(is);
long l2=in.readLong();
in.close();
System.out.println(l2);//读出文件内荣
}四个步骤
- 创建节点流
- 封装过滤流
- 读/写数据
- 关闭流
DataInputStream/DataOutputStram可直接读写八种基本类型和字符串,readUTF()/writeUTF()
BufferedInputStream/BufferedOutputStream
作用：缓冲 提高I/O的效率
### 字节数组 过滤流
```markdown?linenums
public static void main(String[] args)throw Exception{
long l=1234567890123456789L;
OutputSrtream os=new FileOutpurStream("1.dat");
DataOutputStream out=new DataOutputStream(os);
out.writeLong(l);
out.close();
//查看文件内数据
InputStream is=new FileInputStream("1.dat");
DataOutputStream in=new DataInputStream(is);
long l2=in.readLong();
in.close();
System.out.println(l2);//读出文件内荣
}
<div class="se-preview-section-delimiter"></div>
四个步骤
- 创建节点流
- 封装过滤流
- 读/写数据
- 关闭流
DataInputStream/DataOutputStram可直接读写八种基本类型和字符串,readUTF()/writeUTF()
BufferedInputStream/BufferedOutputStream
作用：缓冲 提高I/O的效率
public static void main(String[] args)throw Exception{
FileOutputSrtream fos=new FileOutputStream("1.txt");
BufferedOutputStream out=new BufferedOutputStream(fos); //缓冲区
out.write('A');
out.flush(); // 清空缓冲区
}四个步骤
- 创建节点流
- 封装过滤流
- 读/写数据
- 关闭流
**DataInputStream/DataOutputStram可直接读写八种基本类型和字符串,readUTF()/writeUTF()**
**BufferedInputStream/BufferedOutputStream**
作用：缓冲 提高I/O的效率
```makefile?linenums
public static void main(String[] args)throw Exception{
FileOutputSrtream fos=new FileOutputStream("1.txt");
BufferedOutputStream out=new BufferedOutputStream(fos); //缓冲区
out.write('A');
out.flush(); // 清空缓冲区
}
<div class="se-preview-section-delimiter"></div>
**
过滤流：以节点流作为节点构造而出过滤流
printStream:过滤流、输出流 写8种基本类型并且缓冲（System.out,print）
PipedIuputStream/PipedOutputStream 节点流 管道流 用来在线程间交换数据
RandomAccessFile:随机访问文件 断点续传**
字符流
字符流：以字符为单位，只能处理处理文本数据，同样可处理字符的编解码问题。
字符的编解码：
- 乱码：当字符的编码方式和解码方式不同时，可能会造成乱码（英语除外）。
- ASIII码值解决英文编码，Unicode.UTF-8
String str="2017年";
byte[] bs1=str.getByte("GBK");
String srt2=new String(bs1,"Big5");
System.out.println(str);
System.out.println(str2);// 编码错误
//解决乱码错误 Big5-->GBK
byte[]bs2=new str2.getByte("BIg5");
String str3=new String(bs3,"GBK");
System.out.println("str3");
<div class="se-preview-section-delimiter"></div>
- 字符流
- Reader/Writer 字符流的父类
- FileReader/File 文件字符流 节点流 少用
- BufferReader/PrintWriter 缓冲流 过滤流
- InPutStreamReader/OutPutStreamWriter 桥转换 在桥转换的时候指定编解码方式
-
字节流转换字符流
严格按照四个步骤
FileOutPutStream fos=new FileOutPutStream(“poem.txt”);
Writer ow=new Out PutStreamWiter(fos); //字节流转换字符流
PrintWriter out=new PrintWrite(ow);
out.println("....");
out.println("....");
out.println("....");
out.println("....");
out.close();
// 字符流的读和写
InPutStream fis=new FileInPutStream("poem.txt");
Reader fr=new InPutStreamReader(fr);
BufferedReader in=new BufferedReader(fr);
while(ture){
String str=in.readLIne();
if(str=null)break;
String str=in.readLine();// 读到换行符结束
System.out.println(str);
}
in.close();
}
<div class="se-preview-section-delimiter"></div>
对象序列化
对象序列化：将对象通过流传输
*ObjectOutPutStream/ObjectInputStream 只有实现了Serializable接口的对象才能序列化，不仅对象本身需要实现Seriallizabel接口 ，对象属性类型也需要实现该接口。
*
把对象拆开传输再组合。 可拆可装–可序列化
//把对象分割，并读对象
student s=new student("zs",18);
FileOutputStream fos=new FileOutputStream(obj.txt);
ObjectOUtputStram out=new ObjectOutputStream(fos);
out.writeObect(s);
out.flush();
out.close();
//回写被分割的对象
FileINputStream fis=new FileINputStram("obj.txt");
ObjectInputStream in =new ObjectINputStram(fis);
Student o1=(Student)in.readObject();
Student o2=(Student)in.readObject();
in.close();
class student implements **Serializable**{ //标准字
private String name;
**transient** int age; //reansient修饰的属性为临时属性，不参与序列化
public stufent(){
super();
}
public student(String anem,int age)
{
super();
this.name=name;
this.age=age;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name=name;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age=age;
}
}
2360
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
