大纲
流的概念
内存与存储设备之间传输数据的通道。
水库（内存）与洗脸盆（存储设备） <输出output>
流的分类
1.按方向
水库，程序（内存）与洗脸盆 ，文件（存储设备） <输出output>
存储设备 到 内存 <输入input>
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6oYATwQg-1632659446979)(C:\Users\74771\AppData\Roaming\Typora\typora-user-images\1632560671045.png)]
2.按单位
字节流：以字节（1B=8bit）为单位，可以读写所有数据
字符流：以字符为单位，只能读写文本数据
3.按功能
节点流：具有实际传输数据的读写功能
过滤流：在节点流的基础是之上增强功能
字节流
FileInputStream的使用
public class filelnputStream {
先抛出一个异常
public static void main(String[] args) throws Exception{
FileInputStream fis = new FileInputStream("d:\\aaa.txt");
//单字节读取//
int data = 0;//
while((data=fis.read())!=-1){//
System.out.println((char)data);//
}
System.out.println("========================");
//一次读取多个字节
byte[] buf = new byte[10];
int count = 0;
while((count = fis.read(buf))!=-1){
System.out.println(new String(buf));
}
记得要close
fis.close();
FileOutputStream的使用
public static void main(String[] args) throws Exception{
FileOutputStream fos = new FileOutputStream("d:\\bbb.txt");
//用ture 后可以，重复的追加相同的内容，即程序运行多少次，就写入多少次
FileOutputStream fos = new FileOutputStream("d:\\bbb.txt",true);
//写入文件
String s ="元素共赏";
fos.write(s.getBytes());
fos.close();
}}
字节流复制文件，照片之类的
public class pictureCopy {
public static void main(String[] args) throws Exception{
FileInputStream fis = new FileInputStream("d:\\001.jpg"); 把右边的输入（input）进左边
FileOutputStream fos = new FileOutputStream("d:\\002.jpg"); 把左边的输出（output）进右边
byte[] buf = new byte[1024];
//用 count 计数的原因：防止读的数据不是1024即byte的整数倍，发生重复
//使其能更好刚刚一字不落的打印一组数据
int count=0;
while((count=fis.read(buf))!=-1){
fos.write(buf,0,count);
打印 sout（new String(buf,0,count));
}
fis.close();
fos.close();
BufferedInputStream 的使用
- 提高IO的效率，减少访问磁盘的效率
- 数据存储在缓冲区中，flush是将缓存区的内容写入文件中，也可以直接close
public class bufferedInputStream {
public static void main(String[] args) throws Exception {
//先要实例化个字节输入流
FileInputStream fis = new FileInputStream("d:\\aaa.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
int data=0;
while((data = bis.read())!=-1){
System.out.print((char)data);
}
bis.close();
###也可以自己写缓冲区
byte[] buf = new byte[1024];
//用 count 计数的原因：防止读的数据不是1024即byte的整数倍，发生重复
//使其能更好刚刚一字不落的打印一组数据
int count=0;
while((count=fis.read(buf))!=-1){
fos.write(buf,0,count);
打印 sout（new String(buf,0,count));
}
bufferedOutputStream的使用
public class bufferedOutputStream {
public static void main(String[] args) throws Exception{
FileOutputStream fos = new FileOutputStream("d:buffer.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
//写入文件
for (int i = 0; i < 10; i++) {
//变为字节类型getBytes
bos.write("helloworld\n".getBytes());//默认8k的缓冲区
bos.flush();//将文件刷新到硬盘，即所写入的文件中，否则都在8k的缓冲区里
}
bos.close();//close函数同样会调用flush方法 }}
对象流的使用
序列化
public class objectOutputStream {
public static void main(String[] args) throws Exception{
FileOutputStream fos = new FileOutputStream("d:stu.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
要先给Student 接口化//public class Student implements Serializable
//标志其可以被序列化，本身没有任何作用
Student stu = new Student("李白",22);
//不能直接用write ，因为是Object类的
oos.writeObject(stu);
oos.close(); }
反序列化
public class objectInputStream {
public static void main(String[] args) throws Exception{
FileInputStream fis = new FileInputStream("d:\\stu.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
Student student = (Student) ois.readObject();
ois.close(); System.out.println(student); }
序列化注意事项
- 序列化类必须要实现Serializable 接口
- 序列化类中对象属性要求实现Serializable 接口
- 序列化版本号 ID serialVersionUID ，保证序列化的类和反序列化的类是同一个类
- 使用 transient（瞬间的）修饰属性，这个属性不能被序列化
- 静态属性不能序列化
- 序列化多个对象，可以借助集合实现
用数组一下子写好几个
//Output
public class objectOutputStream {
public static void main(String[] args) throws Exception{
FileOutputStream fos = new FileOutputStream("d:stu.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
Student stu = new Student("李白",22);
Student stu2 = new Student("杜甫",32);
ArrayList<Student> list = new ArrayList<>();
list.add(stu);
list.add(stu2);
oos.writeObject(list);
//不能直接用write ，因为是Object类的
// oos.writeObject(stu);
oos.close(); }
//Input
FileInputStream fis = new FileInputStream("d:\\stu.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
ArrayList<Student> list = (ArrayList<Student>)ois.readObject();
ois.close();
//System.out.println(student);
System.out.println(list);
字符流
字符编码
ISO -8859-1收录除ascll外，还有西欧，希腊语
UTF-8 针对Unicode 码表的可变长度字符编码
gbk 国标 中国
FileReader的使用，读中文
public static void main(String[] args)throws Exception {
FileReader fr = new FileReader("d:\\hello.txt");
//读一个字符//
int data = 0;//
while((data = fr.read())!=-1){//
System.out.print((char)data);//
}
//用数组的方式来进行
char[] buf = new char[1024];
int count = 0;
while((count=fr.read(buf))!=-1){
System.out.println(new String(buf,0,count));
//也可以
System.out.println(buf);
}
fr.close();
fileWriter的使用
public s tatic void main(String[] args) throws Exception{
FileWriter fw = new FileWriter("d:\\writr.txt");
fw.write("依旧烟笼十里堤");
fw.close();
字符文件的复制
文件类型必须是一样的，用的Object类型的的一直乱码，必须是字符类的文件！！
不能复制图片或者二进制文件，要用字节流复制
public static void main(String[] args) throws Exception{
FileReader fr = new FileReader("d:\\hello.txt");
FileWriter fw = new FileWriter("d:\\stu3.txt");
int data = 0;
while((data=fr.read())!=-1)
{
fw.write(data);
}
bufferedReader的使用
br.readLine()要点，虽说是按行读，但不为空是就会一直读下去
public static void main(String[] args) throws Exception{
FileReader fr = new FileReader("d:aaa.txt");
BufferedReader br = new BufferedReader(fr);//
int data;//
//单个读
while((data = br.read())!=-1){//
System.out.print((char) data);//
}
//按行读，BufferedReader的特色
String s= null;
while((s=br.readLine())!=null){
System.out.println(s);
}
br.close(); }
BufferedWriter的使用
bw.newLine()自动换行
public static void main(String[] args)throws Exception {
FileWriter fw = new FileWriter("d:\\aaa.txt");
BufferedWriter bw = new BufferedWriter(fw);
for (int i = 0; i < 10; i++) {
bw.write("失向来之烟霞");
bw.newLine(); }
其他流
打印流 PrintWriter
public static void main(String[] args) throws Exception{
PrintWriter pw = new PrintWriter("d:\\print.txt");
pw.println(187);
pw.println(1.2);
pw.println(true);
pw.println('A');
pw.println("nihao");
pw.close();
转换流InputStreamReader
InputStreamReader = 字节流的InputStream + 字符流的Reader
关键是编码的转换
public static void main(String[] args)throws Exception {
FileInputStream fis = new FileInputStream("d:\\aaa.txt");
InputStreamReader isr = new InputStreamReader(fis,"utf-8");
int data = 0;
while((data = isr.read())!=-1){
System.out.print((char) data);
}
isr.close();
OutputStreamWriter
OutputStreamWriter = 字节流的OutputStream + 字符流的Writer
关键是编码的转换
public static void main(String[] args)throws Exception {
FileOutputStream fos = new FileOutputStream("d:\\info.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
osw.write("世间行乐亦如此");
osw.close();}
文件类
文件操作
public static void main(String[] args) throws Exception{
separator();
fileOpe();
}
//分隔符
public static void separator(){
System.out.println("路径分隔符"+ File.pathSeparator);
System.out.println("名称分隔符" + File.separator); }
//创建文件
public static void fileOpe()throws Exception {
File file = new File("D:\\file,txt");
System.out.println(file.toString());
if (!file.exists()) {
boolean b = file.createNewFile();
System.out.println("创建结果" + b);
}
//删除文件
//直接删除//
System.out.println("删除结果" + file.delete());
//使用jvm 退出时删除//
file.deleteOnExit();
//使进程在5秒后结束//
Thread.sleep(5000);
//获取文件信息
System.out.println("获取文件绝对路径"+file.getAbsolutePath());
System.out.println("获取路径"+file.getPath());
System.out.println("获取文件名"+file.getName());
System.out.println("获取父目录"+file.getParent());
System.out.println("获取文件长度"+file.length());
System.out.println("文件创建时间"+new Date(file.lastModified()).toLocaleString());
//判断
System.out.println("是否可写"+file.canWrite());
System.out.println("是否是文件"+file.isFile());
System.out.println("是否隐藏"+file.isHidden());
}
文件夹和过滤器的使用
比文件操作多了遍历
public class fileJia {
public static void main(String[] args) throws Exception{
directoryOpe(); }
public static void directoryOpe()throws Exception{
// 创建文件夹
File dir = new File("d:\\aaa\\bbb\\ccc");
System.out.println(dir.toString());
if(!dir.exists()){
//dir.mkdir(); 只能创建单级目录
System.out.println("创建结果"+dir.mkdirs());//创建多级
}
//删除文件夹
//直接删除
System.out.println(dir.delete());
//使用jvm删除
dir.deleteOnExit();
Thread.sleep(5000);
//获取信息
System.out.println("获取文件绝对路径"+dir.getAbsolutePath());
System.out.println("获取路径"+dir.getPath());
System.out.println("获取文件名"+dir.getName());
System.out.println("获取父目录"+dir.getParent());
System.out.println("文件创建时间"+new Date(dir.lastModified()).toLocaleString());
//判断
System.out.println("是否是文件夹"+dir.isDirectory());
System.out.println("是否隐藏"+dir.isHidden());
//遍历文件夹
File dir2 = new File("D:\\360极速浏览器下载");
String[] S = dir2.list();
for(String s:S){
System.out.println(s); }
System.out.println("-------fileFilter-----");
File[] file2 = dir2.list(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
if (dir.getName().endsWith(".jpg")){
return ture
}
return false;
}
})
for(File f:file2){
System.out.println(f);
}
}
递归遍历和删除
在for 循环中递归
public class diGui {
public static void main(String[] args) {
listDir(new File("d:\\aaa"));
deleteDir(new File("d:\\aaa"));
}
遍历，在循环中递归
public static void listDir(File dir){
File[] files = dir.listFiles();
System.out.println(dir.getAbsolutePath());
if(files!=null&&files.length>0){
for (File file:files){
if (file.isDirectory()){
listDir(file); //递归
}
else{
System.out.println(file);
}
}
}
}
删除，在循环中递归
public static void deleteDir(File dir){
File[] files = new dir.listFiles();
if (files!=null&&files.length>0){
for(File file:files){
if(file.isDirectory()){
deleteDir(file);//递归
}
else{
//删除文件
System.out.println(file.getAbsolutePath()+"删除"+file.delete()); } } }
Properties集合的使用
和流有关的方法
- list
- -store
- load方法
public class propertiesBase {
public static void main(String[] args) throws Exception{
//创建集合
Properties properties =new Properties();
//添加数据
properties.setProperty("username","zhangsan");
properties.setProperty("age","20");
System.out.println(properties);
//遍历//
for(Properties.Entry<String,String> en:properties.entrySet()){//
System.out.println(en);//
}
//遍历用properties.stringPropertyNames()得到属性名的集合，
Set<String> pronames = properties.stringPropertyNames();
for(String pro:pronames){ System.out.println(pro+"==="+properties.getProperty(pro));
}
//和流有关的方法
// -----list方法----
PrintWriter pw = new PrintWriter("d:\\prent.txt");
properties.list(pw);
pw.close();
// -----store方法----
FileOutputStream fos = new FileOutputStream("d:\\store.properties");
properties.store(fos,"注释");
fos.close();
// -----load方法----
Properties properties2 = new Properties();
FileInputStream fis = new FileInputStream("d:\\store.properties");
properties2.load(fis);
fis.close();
System.out.println(properties2); }
扫一扫
235
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
