本章内容
1,file类
2,递归
3,IO流
4,字符流,字符缓冲区
5,装饰者模式
6,字节流,字节流缓冲区
7,转换流
8,其他流
9,编码问题
一、file类
- 用来将文件或者文件夹封装成对象
- 方便对文件与文件夹的属性信息进行操作
- FILe能新建,删除,重命名文件与目录,但file不能访问文件内容
File(String pathname)
可以把一个存在或者不存在的文件(文件目录)封装成一个对象
File(String parent, String child)
File(File parent, String child)
判断:
* exists() 判断文件或者文件夹是否存在
* isDirectory() 判断文件对象是不是一个文件夹
* isFile() 判断文件对象是不是一个文件
* isAbsolute() 判断当前路径是不是绝对路径
* isHidden() 判断文件是否隐藏
获取类方法
* getAbsolutePath() 获取文件的绝对路径,返回路径字符串
* getAbsoluteFile() 获取文件的绝对路径,返回File对象
* getParentFile() 获取当前路径的父路径,以File对象的形式返回父路径
* getParent() 获取当前路径的父路径,以字符串形式返回父路径
* getPath() 获取当前路径
* getName() 获取当前文件或文件夹名称
* lastModified() 获取文件最后修改时间
* length() 获取文件长度
* getTotalSpace() 获取分区总大小
* renameTo(File newFile) 给文件改名字
* list() 以字符串形式返回当前路径下的所有文件和文件夹
* listFiles() 以File对象的形式返回当前路径下的所有文件和文件夹
package Test1;
import java.io.File;
import java.io.IOException;
import java.util.Date;
import org.junit.Test;
public class Demo {
/*
* File(String pathname)
* 可以把一个存在或者不存在的文件(文件目录)封装成一个对象
*
* File(String parent, String child)
*File(File parent, String child)
*/
@Test
public void testConstructor(){
// /斜杠 \反斜杠
File f1 = new File("E:/practice/b.txt");//绝对路径
File f2 = new File("E:/xxxx");
File f3 = new File("E:/practice","b.txt");
File parent = new File("E:/practice");
File f4 = new File(parent,"b.txt");
}
/*
* 创建和删除文件:
*
* CreateNewFile() 指定的文件不存在,就创建文件返回true,否则false
* mkdir() 创建单级文件夹
* mkdirs() 创建多级文件夹
*
* delete() 删除单个文件或者多个文件夹
*/
@Test
public void testCreateAndDelete() throws IOException{
File f = new File("F:/pp");
boolean flag = f.createNewFile();
System.out.println(flag);
// boolean mkidir = f.mkdirs();
// System.out.println(mkidir);
// boolean delete = f.delete();
// System.out.println(delete);
}
/*
* 判断
* exists() 判断文件或者文件夹是否存在
* isDirectoery()判断文件对象是不是文件
* isFile() 判断文件对象是不是一个文件
* isAbsolute();
* isHidden();
*
*
*/
@Test
public void testPanduan(){
File f1 = new File("F:/pp");
// boolean exists = f1.exists();
// System.out.println(exists);
// boolean directory = f1.isDirectory();
// System.out.println(directory);
// boolean file = f1.isFile();
// System.out.println(file);
boolean file = f1.isAbsolute();
boolean hidden = f1.isHidden();
System.out.println(file);
}
/*
* 获取类方法
* getAbsoluteFile() 获取文件的绝对路径, 返回Flle对象
* getAbsolutePath() 获取文件的绝对路径,返回路径字符串
* getParentFile() 获取当前路径的父路径,以File对象的形式返回路径
* getPath() 获取当前路径
* getName() 获取当前文件夹或文件的名称
* lastModified() 获取文件最后修改时间
* length() 获取文件的长度
* getTotalSpace() 获取文件占用磁盘的大小,分区的大小
*/
@Test
public void testGet(){
File f1 = new File("F:/pp");
File f2 = new File("F:/xcc");
File absoluteFile = f1.getAbsoluteFile();
String absolutePath = f1.getAbsolutePath();
File parentFile = f1.getParentFile();
String path = f1.getPath();
String name = f1.getName();
long lastModified = f2.lastModified();
long length = f1.length();
long totalSpace = f2.getTotalSpace();
boolean renameTo = f1.renameTo(f2);
System.out.println(renameTo);
Date d = new Date(lastModified);
System.out.println(d.toLocaleString());
System.err.println(totalSpace);
}
/*
* List() 以字符串形式返回当前路径下的所有 文件和文件夹
* ListFiles 以File对象的形式返回当前路径下的所有文件和文件夹
*
*
*/
@Test
public void testList(){
File f = new File("F:/K/A");
String[] list = f.list();
for(String str : list){
System.out.println(str);
}
System.out.println();
System.out.println();
File[] listFiles = f.listFiles();
for(File file : listFiles){
System.out.println(file.getName());
}
System.out.println();
System.out.println(listFiles.length);
}
}
2,递归
为了求一个数值,不断的调用本身。。具体内容前面有,这里就不赘述了
例一:递归
package Digui;
public class Demo {
public static void main(String[] args) {
int result = jiecheng(5);
System.out.println(result);
}
public static int jiecheng(int n){
if(n == 1){
return 1;
}
else{
return n*jiecheng(n-1);
}
}
}
再来一个用递归算法思想来完成文件夹的遍历与批量删除
package Digui;
import java.io.File;
public class Demo2 {
public static void main(String[] args) {
// //列出一个文件夹下所有子文件夹以及子文件
// File file = new File("E://Desktop//chapter12//src//com//jp");
// showList(file);
//删除一个目录的过程是如何进行的?
File file = new File("G://a");
remove(file);
}
private static void remove(File file) {
if(file.isDirectory()){
File[] listFiles = file.listFiles();
for( File f : listFiles ){
if(f.isFile()){
f.delete();
}else if(f.isDirectory()){
remove(f);
}
}
}
file.delete();
}
//* isDirectory() 判断文件对象是不是一个文件夹
// isFile() 判断文件对象是不是一个文件
/*private static void showList(File file) {
if(file.isDirectory()){
File[] listFiles = file.listFiles();//以File对象的形式返回当前路径下的所有文件和文件夹
for(File f : listFiles){
if(f.isFile()){
System.err.println("文件: " + f.getName() );
}else if(f.isDirectory()){
//这里是正在循环的f的文件对象
showList(f);//这里用的就是递归
}
}
}
System.out.println("文件夹: " + file.getName());
}*/
}
3.IO流
- IO流用来处理设备之间的数据传输
- java对对数据的操作是通过 流(系统资源)的方式
- java用于操作流的对象都在java.io包中
- 流按操作数据分为两种:字节流,和 字符流
- 流按流向分为:输入流(读),输出流(写)
带Stream后缀的都是字节
带另一种的就是字符流。下面的图为老师上课讲的图,方便看点
4.字符流-创建文件
创建流对象,建立数据存放文件
–FileWriter fw =new FIleWriter(“a.txt”);
调用流对象的写入方法,将数据写入流
–fw.write(“aafsa”);
-关闭流资源,并将流中的数据清空到文件中。
–fw.close();
package Writer;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriterDemo {
public static void main(String[] args) throws IOException {
File file = new File("a.txt");
FileWriter fw = new FileWriter(file);
// fw.write(97);
// fw.flush();//刷新
// fw.close();//关闭流,自带刷新功能
int i = 100;
System.out.println((char)i);
}
}
写入异常的处理
package Writer;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriterDemo2 {
public static void main(String[] args) {
FileWriter fw = null;
try {
File file = new File("xx:/a.txt");
fw = new FileWriter(file,true);
fw.write(97);
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
if(fw != null){
fw.close();
}
} catch (IOException e) {
//保存到日志
throw new RuntimeException("流关闭出门啦!!赶紧来处理");
}
}
}
}
字符流-读取文件
- 建立一个流对象,和指定的文件数据关联
- –FileReader fr = new FileReader(“01.txt”);
- 创建一个临时存放数据的数组。
- –char[] ch = new char[1024];
- 调用流对象的读取方法将流中的数据读入到数组。
- –fr.read(ch);
\r\n代表回车键
读的第一个例子:
package Reader;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderDemo {
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader("a.txt");
// int read1 = fr.read();
// System.out.println(read1);
// int read2 = fr.read();
// System.out.println(read2);
// int read3 = fr.read();
// System.out.println(read3);
int len = 0;
while((len = fr.read()) != -1){
// \r\n代表回车键
System.out.println(len);
}
fr.close();
}
}
自定义缓冲区:
package Reader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderDemo2 {
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader(new File("a.txt"));
//临时缓冲区
char[] c = new char[10];
// int len1 = fr.read(c);//将数据读取到一个字符数组中
// System.out.println("长度:" + len1 + "---读取的内容是:" + new String(c));
// int len2 = fr.read(c);
// System.out.println("长度:" + len2 + "---读取的内容是:" + new String(c));
// int len3 = fr.read(c);
// System.out.println("长度:" + len3 + "---读取的内容是:" + new String(c));
int len = 0;
while((len= fr.read(c)) != -1){
System.out.println(new String(c, 0, len));
}
}
}
字符流练习:比较正规的
package Example;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class CopyDoc1 {
public static void main(String[] args){
FileReader fr = null;
FileWriter fw = null;
try {
//源文件
File sourceFile = new File("F://a.txt");
//目标文件
File targetFile = new File("D://copy.doxc");
//建立读取流的通道
fr = new FileReader(sourceFile);
//建立写入流通道
fw = new FileWriter(targetFile);
//建立临时缓冲区,以提高效率
char[] c = new char[1024];
//记录读取的字符个数
int len = 0;
while((len = fr.read(c)) != -1){
fw.write(c, 0, len);
fw.flush();//刷新
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
if(fr != null){
fr.close();
}
} catch (IOException e) {
throw new RuntimeException("读取流关闭出问题啦");
}
try {
if(fw != null){
fw.close();
}
} catch (IOException e) {
throw new RuntimeException("写入流关闭出问题啦");
}
}
}
}
- 字符流–缓冲区
- 缓冲区提高了对数据的读写效率
- 对应类:
- —BufferedWriter
- —BufferedReader
- 缓冲区要结合流才可以使用。
- 在流的基础上对流的功能进行了增强
package Buffer;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class BufferDemo2 {
public static void main(String[] args) throws IOException {
BufferedReader br = null;
BufferedWriter bw = null;
try {
br = new BufferedReader(new FileReader(new File("F://a.txt")));
bw = new BufferedWriter(new FileWriter(new File("D://nihao.txt")));
String line = null;
while((line = br.readLine()) != null){
bw.write(line);
bw.newLine();//换行
bw.flush();//刷新
}
} catch (IOException e) {
e.printStackTrace();
}finally {
if(br != null){
br.close();
}
if(bw != null){
bw.close();
}
}
}
}
5,装饰者设计模式
- 对原有类进行了功能增强
- 它与继承有什么不同?
- 继承:被增强的对象固定
- 被增强的内容也是固定的
- 装饰者模式;被增强的对象是可以切换的
- 被增强的内容是固定的
- 动态代理(AOP) :被增强的对象可以切换
- 被增强的内容也是可以切换的
6,字节流
FileInputStream
FileOutputStream
复制一个mv到别的盘
package FileInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo {
public static void main(String[] args) throws IOException {
FileInputStream fis =null;
FileOutputStream fos = null;
try {
File sourceFile = new File("D://123.mp4");
File targetFile = new File("G://xcc.mp4");
fis = new FileInputStream(sourceFile);
fos = new FileOutputStream(targetFile);
byte[] b = new byte[1024];
int len = 0;
while((len = fis.read(b)) != -1){
fos.write(b, 0, len);
fos.flush();
}
} catch (IOException e) {
e.printStackTrace();
}finally{
if(fis != null){
try{
fis.close();
}catch(IOException e){
throw new RuntimeException("关闭读取流出问题");
}
}
if(fos != null){
try{
fos.close();
}catch(IOException e){
throw new RuntimeException("关闭写入流出问题");
}
}
}
}
}
字节流—-缓冲区
- BufferedInputStream
- BufferedOutputStream
package Test1;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class BufferedDemo3 {
public static void main(String[] args) throws IOException {
FileInputStream fis = null;
FileOutputStream fos =null;
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
fis = new FileInputStream("E://Desktop//大二 上学期//123.mp4");
fos = new FileOutputStream("d://copy1.mp4");
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos);
byte[] b = new byte[1024];
int len = 0;
while((len = bis.read(b)) != -1) {
bos.write(b, 0, len);
bos.flush();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}catch (IOException e){
e.printStackTrace();
}finally {
try {
if(fis != null){
fis.close();
}
} catch (IOException e) {
throw new RuntimeException("出问题啦");
}
try {
if(fos != null){
fos.close();
}
} catch (IOException e) {
throw new RuntimeException("出问题啦");
}
try {
if(bis != null){
bis.close();
}
} catch (IOException e) {
throw new RuntimeException("出问题啦");
}
try {
if(bos != null){
bos.close();
}
} catch (IOException e) {
throw new RuntimeException("出问题啦");
}
}
}
}
7,转换流
- InputStreamReader , OutputStreamWriter
- 转换流的由来
- –字符流与字节流之间的桥梁
- –方便了字符流与字节流之间的操作
- 转换流的应用
- -字节流中的数据都是字符时,转换字符流的操作更高效
- GBK读中文的码表
package Trans;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class TransDemo {
public static void main(String[] args) throws IOException {
//FileInputStream fis = new FileInputStream("E://xx.txt");
// 需要转换吗?
//InputStreamReader isr = new InputStreamReader(fis, "gbk");
FileReader fr = new FileReader("G://xx.txt");
// 需要提高效率吗?
BufferedReader br = new BufferedReader(fr);
FileOutputStream fos = new FileOutputStream("F://yy.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos, "gbk");
BufferedWriter bw = new BufferedWriter(osw);
String line = null;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.flush();
}
fr.close();
br.close();
fos.close();
osw.close();
bw.close();
}
}
8,标准输入输出流
- System.in 和 System.out分别代表了系统标准的输入和输出设备
- 默认输入设备是键盘,输出设备是显示器
- System.in 的类型是 InputStream
- System.out 的类型是 PrintStream,其实OutoutStream 的子类
- 通过System 类的seth,setOut方法对默认设备进行改变。
- Public static void setln(InputStream in)
- public static void setOut(PrintStream out)
package SYs;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
public class SystemDemo {
public static void main(String[] args) throws IOException {
InputStream in = System.in;
// int read = in.read();
// System.out.println(read);
// int read1 = in.read();
// System.out.println(read1);// 13 \r
// int read2 = in.read();
// System.out.println(read2);// 10\n
// int len = 0;
// while((len = in.read()) != -1){
// System.out.println(len);
// }
InputStreamReader isr = new InputStreamReader(in);
BufferedReader br = new BufferedReader(isr);
PrintStream out = System.out;
OutputStreamWriter osw = new OutputStreamWriter(out);
BufferedWriter bw = new BufferedWriter(osw);
String line = null;
while((line = br.readLine()) != null ){
//System.out.println(line);
if("over".equals(line)){
break;
}
bw.write(line.toUpperCase());//大写
bw.newLine();//换行
bw.flush();//刷新
}
in.close();
isr.close();
br.close();
out.close();
osw.close();
bw.close();
}
}
8、其他流
- 打印流
- —printWriter 与 printStream
- 可以直接操作输入流文件
- 序列流
- —SequenceInputStream
- 对多个流进行合并
- 对象流
- — ObjectInputStream与ObjectOutputStream
- 被操作的对象需要Serializable(标记接口)
打印流
package Pint;
import java.io.IOException;
import java.io.PrintStream;
import org.junit.Test;
public class PrintDemo {
@Test
public void testPrintDemo() throws IOException{
PrintStream ps = new PrintStream("preawer.txt");
ps.print(91);
ps.println();
ps.flush();
ps.close();
}
@Test
public void testPrintWriter(){
//字节流 ctrl + t 查看代码的结构
PrintStream out = System.out;
// PrintWriter pw = new PrintWriter(out);
// pw.print('a');
// pw.flush();
// pw.close();
out.print("aaa");
}
}
对象流
package com.jp.obj;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import org.junit.Test;
public class ObjDemo {
@Test
public void testObjectInputStream() throws IOException, ClassNotFoundException{
ObjectInputStream in = new ObjectInputStream(new FileInputStream("zs.txt"));
//对象的反序列化
Object readObject = in.readObject();
Person p = (Person)readObject;
System.out.println(p.getName());
in.close();
}
@Test
public void testObjectOutputStream() throws IOException{
//对象的写出流,写入到磁盘上
ObjectOutputStream out= new ObjectOutputStream(new FileOutputStream("zs.txt"));
//对象序列化过程
out.writeObject(new Person("zs", 20));
out.flush();
out.close();
}
}
9、常见码表
编码变的由来:
计算机智能识别二进制数据,早期由来是电信号,为了方便应用计算机,让它可以识别各个国家的文字,就将各个国家的文字用数学来表示,并一一对应,形成一张表,这就是编码表
常见的编码表如下
- 编码: 字符串—–字节数组
- 解码:字节数组—字符串
- 转换流的编码应用
- 可以将字符按指定编码格式存储
- 可以对文本数据按指定编码格式来解读
- 指定编码表的动作由构造器来完成
package Example;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class CopyDoc1 {
public static void main(String[] args){
FileReader fr = null;
FileWriter fw = null;
try {
//源文件
File sourceFile = new File("F://a.txt");
//目标文件
File targetFile = new File("D://copy.doxc");
//建立读取流的通道
fr = new FileReader(sourceFile);
//建立写入流通道
fw = new FileWriter(targetFile);
//建立临时缓冲区,以提高效率
char[] c = new char[1024];
//记录读取的字符个数
int len = 0;
while((len = fr.read(c)) != -1){
fw.write(c, 0, len);
fw.flush();//刷新
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
if(fr != null){
fr.close();
}
} catch (IOException e) {
throw new RuntimeException("读取流关闭出问题啦");
}
try {
if(fw != null){
fw.close();
}
} catch (IOException e) {
throw new RuntimeException("写入流关闭出问题啦");
}
}
}
}
发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/114802.html原文链接:https://javaforall.cn
【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛
【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...