//通过指定的路径创建 相对的 文件实例对象 方法一
File file = new File("D:\\javafile\\java\\你好\\你好.txt");
System.out.println(file);
File file1 = new File("D:\\javafile","java.txt");
System.out.println(file1); boolean newFile = file.createNewFile();//这个会报一个io流异常 导入 可以创建文件 注意 这个 不能创建多级文件 在上级目录没有的情况下 是无法创建成功的file.delete();//这个删除 根目录不删除System.out.println(file.getAbsolutePath());//返回的是文件对象的路径 但是他是 String 类型的 System.out.println(file.getName());//返回的是 文件或目录的名称System.out.println(file.getParentFile());//获取的是 文件的最外的根目录的文件名System.out.println(file.getAbsoluteFile());//返回的是所有文件的路径 但是 他返回的是一个 file文件对象 它可以进行 file文件的方法的使用 System.out.println(file.exists());//测试这个文件路径是否存在
File file2 = new File("D:\\javafile");//使用 list() filelist() 方法时需要有文件的名字
File[] list = file2.listFiles();//返回的是 文件类型的数组 返回输出的是 文件/文件的样式 以路径的样式输出的
String[] list1 = file2.list();//返回的是字符串的数组输出的是 文件夹下的 所有文件的名字
// System.out.println(list);
for(String item:list1){
System.out.println(item);
}
for(File item:list){
System.out.println(item);
}
//file.isFile();//判断是不是文件
file.mkdirs();//创建多级目录 不加 s就是单个目录file.renameTo(file3);//重命名的 方法 让文件重新命名递归 不死神兔
时间 兔子总数 新增
初始 1对 0
一个月后 1对 0
两个月后 2对 1
三个月后 3对 1
四个月后 5对 2
五个月后 8对 3
六个月后 13对 5
从二个月后每次增加的兔子数量均为前一个月的前一个月的兔子数量如：
二月后=一月后（本次增加时原有的兔子量）+初始（本次增加时可以生小兔子的兔子量）
三月后=二月后（本次增加时原有的兔子量）+一月后（本次增加时可以生小兔子的兔子量）
以此类推可以知道n月后= n-1月后的兔子数量+n-2月后的兔子数量；
便可以递归实现得到兔子数量
阶乘
package File文件使用;
public class 递归阶乘 {
public static void main(String[] args) {
//5的阶乘 = 5*4*3*2*1
//4的阶乘 = 4*3*2*1
//3的阶乘 = 3*2*1
//2的阶乘 = 2*1
//1的阶乘 = 1
// n的阶乘 = n*(n-1)的阶乘
System.out.println(jiecheng(5));
}
public static int jiecheng(int n){
if (n==1){
return 1;
}else{
return n*jiecheng(n-1);
}
}
}
文件查找递归使用
package File文件使用;
import java.io.File;
public class 递归获取文件所有的文件 {
public static void main(String[] args) {
findFile(new File("D:\\javafile"));
}
public static void findFile(File filename){
File[] files = filename.listFiles();
for(File item:files){
if(item.isDirectory()){
findFile(item);
}else {
System.out.println(item.getName());
}
}
}
}
Io流
io流分为 字节流 字符流 字节流专门写 看不见的 读不懂的 字符 流 写 记事本能读懂的
如果不知道用啥好 那就使用字节流 他是万能的
注意 字节流的写入流 创建对象使用的是 子类实现类 创建的对象
OutputStream fileOutputStream = new FileOutputStream("D:\\javafile\\do.txt",true);//创建 字节输出流对象 在创建对象 构造函数位置加一个参数 true 就是向后追加文字内容
//fileOutputStream.write(97);//写入 字节输出流
//字符串 有获取字节码的 方法
byte[] bytes = "你好啊".getBytes();
fileOutputStream.write(bytes);
//向后追加 方法
fileOutputStream.close();//关闭字节输出流
字节流在创建的时候 加一个参数 就是默认向后追加 而不是覆盖
字符串 有方法 可以获得 该字符串的 字节流 方法
// 不同的系统 有不同的换行 操作
\r \n 换行 windows
\n linux
\r mac 系统
不同的操作系统 标识符不一样
字节流的复制粘贴
package Io流;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class 字节流写入 {
public static void main(String[] args) {
//文件 输出流
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream=null;
try {
fileInputStream = new FileInputStream("D:\\javafile\\do.txt");
fileOutputStream =new FileOutputStream("D:\\javafile\\java\\do.txt");
// System.out.println(fileInputStream.read());
int by;
while ((by=fileInputStream.read())!=-1){
fileOutputStream.write(by);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fileInputStream.close();
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
注意点 一 需要 把读取的字节 转换成 字节码 ===>就是 int类型的 必须要加int
注意 二 看好 while循环里面的赋值操作 咋做的
注意点 三 读取字节流 读不到 就是 -1 标识符
字节流的缓冲区
字节流缓冲区 与字节流底层的耗时区别
package Io流;
import java.io.*;
public class 字节流与缓冲流的区别 {
public static void main(String[] args) throws IOException {
long strat = System.currentTimeMillis();
FileInputStream fileInputStream = new FileInputStream("D:\\javafile\\钢铁侠.MP4");
FileOutputStream fileOutputStream = new FileOutputStream("D:\\javafile\\java\\钢铁.MP4");
int len;
// while ((len =fileInputStream.read())!=-1){ //底层的字节流 一个字节读取 9万多毫秒
// fileOutputStream.write(len);
// }
// byte[] bytes = new byte[8192];
// while ((len = fileInputStream.read(bytes)) != -1) { //底层 字节数组 8192 22毫秒
// fileOutputStream.write(len);
// }
BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
// while ((len =bufferedInputStream.read())!=-1){ //buff字节缓冲流读取的字节流 一个字节读取 519毫秒
// bufferedOutputStream.write(len);
// }
byte[] bytes = new byte[8192];// 字节缓冲流 读取 数组类型的 读取
while ((len = bufferedInputStream.read(bytes)) != -1) { //底层 字节数组 8192 16毫秒
bufferedOutputStream.write(len);
}
fileInputStream.close();//关闭流释放资源
fileOutputStream.close();
long end = System.currentTimeMillis();
System.out.println("公耗时" + (end - strat) + "毫秒");
}
}
字符流
字符流就是为了 读取 汉字的字符
中文转换成编码的时候 都是 负数 就知道 他是中文了 ,然后再根据 编码的字符集 是 GBK 还是
utf-8字符集
字符流 跟字节流 几乎一样 字符流也需要 io流的底层支持 对象
读取的时候 默认是 utf-8 编码 常用的还有 GBK
字符的编码 解码
字符 编码 是 get byte方法 解码 对应的 byte() 方法 用什么方式解码 就要用什么方式 编码
字符串 可以直接获取 字符的方法
"字符串".getByte()====>字符 得到的是 -负号开头的数组
无非 就是两种字符集 一种是 GBK 一种是 UTF-8 字符集
字符流 写法 new outStremread 或者 write 写入 这两种
记得 写入 的时候 传入的是 单个的字节 或者字符 或者单个的 字符 或字符数组
文件流 复制java文件字符流
package Io流;
import java.io.*;
public class 复制java案例 {
public static void main(String[] args) throws IOException {
InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("..\\java_base\\copy.java"));
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("..\\java_base\\copys.java"));
char[] chars = new char[1024];
int len;
while ((len=inputStreamReader.read(chars))!=-1){
outputStreamWriter.write(chars,0,len);
}
outputStreamWriter.close();
inputStreamReader.close();
}
}文件 file write file read 流 读取字符
package Io流;
import java.io.*;
public class 字符流的进阶版 {
public static void main(String[] args) throws IOException {
FileReader fileReader = new FileReader("..\\java_base\\copy.java");
FileWriter fileWriter = new FileWriter("..\\java_base\\copys.java");
int len;
char[] chars = new char[1024];
while ((len=fileReader.read(chars))!=-1){
fileWriter.write(chars,0,len);// 字符流 必须按着这个样式 写入 才能正确写入
}
fileReader.close();
fileWriter.close();// 字符流 必须要 关闭流 释放资源 这个关闭流里面 有一个刷新流 在里面 不刷新 不会出来东西
}
}
注意 !!!字符流 必须 是 write(chars,0,len) 字符数组 ,偏移量,长度读取的
字符缓冲流
bufferedReader
bufferedWriter
package Io流;
import java.io.*;
public class 字符缓冲流 {
public static void main(String[] args) throws IOException {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream("..\\java_base\\copy.java")));
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("..\\java_base\\copys.java")));
int len;
char[] chars = new char[8192];
while ((len=bufferedReader.read(chars))!=-1){
bufferedWriter.write(chars,0,len);
}
bufferedReader.close();
bufferedWriter.close();
}
}
字符缓冲流 特有的功能
bufferedWriter.newLine(); 开启新的一行换行符 使用任何系统 bufferedReader.readLine(); 读取一行的数据 如果没有了 新的一行 读出来的就是 null 但是她不会读取换行的符号
最好的是 写数据 换行 符号 刷新流最常用的!!!!!!!!!!!
io流小节
1412
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
