第31天学习打卡（File类。字符流读写文件）
File类
概念
文件，文件夹，一个file对象代表磁盘上的某个文件或者文件夹
构造方法
File(String pathname)
File(String parent,String child)
File(File parent, String child)
成员方法
creatNewFile():创建文件
mkdir()和mkdirs():创建目录（即创建文件夹）
isDirectory():判断File对象是否为目录
isFile():判断File对象是否为文件
exicts()：判断File对象是否存在
package cn.itcast.demo20;
/*
File类：
概述：
文件，文件夹，一个File对象代表磁盘上的某个文件夹。也就是用来操作文件（夹）路径的。
构造方法：
File(String pathname) 根据给定的字符串路径创建其对应的File对象
File(String parent, String child)根据给定的字符串形式的父目录和子文件（夹）名创建File对象
File(File parent, String child)根据给定的父母目录对象和子文件（夹）名创建File对象
成员方法：
创建功能：如果不存在就创建，返回true,否则就不存在，返回false
createNewFile():创建文件夹
mkdir(): 创建单级目录
mkdirs():创建目录
判断功能：
isDirectory():判断File对象是否为目录
isFile():判断File对象是否为文件
exists():判断File对象是否存在
*/
import java.io.File;
import java.io.IOException;
public class Test {
public static void main(String[] args) throws IOException {
//需求: 将 D:\abc\1.txt 封装成File对象.
//方式一: 根据字符串形式的路径获取File对象.
//File file1 = new File("D:\\abc\\1.txt");
File file1 = new File("D:/abc/1.txt");
System.out.println("file1: " + file1);
//方式二: 根据字符串形式的父目录以及子目录创建File对象.
File file2 = new File("D:/abc/", "1.txt");
System.out.println("file2: " + file2);
//方式三: 根据父目录对象, 以及字符串形式的子目录来获取File对象.
File file3 = new File("D:/abc/");
File file4 = new File(file3, "1.txt");
System.out.println("file4: " + file4);
System.out.println("-----------------------------");
System.out.println("创建功能");
//需求: 在f:盘下创建 b.txt文件(我的在D盘里面创建不了b.txt 文件，会报错， 所有要换一个文件的路径改为f盘或者其他盘。不区分盘的大小写)
File file5 = new File("f:/b.txt");
boolean flag1 = file5.createNewFile();
System.out.println("flag1: " + flag1);
//需求: 在D:盘下创建 a文件夹
File file6 = new File("D:/a");
boolean flag2 = file6.mkdir();//make directory:创建单级目录
System.out.println("flag2:" + flag2);
//需求：在D盘创建a/b/c文件夹：即文件夹a下包含文件夹b，文件夹b下包含文件夹c.即创建多级路径
File file7 = new File("D:/a/b/c");
boolean flag3 = file7.mkdirs();//mkdirs可以创建多级目录也可以创建单级目录
System.out.println("flag3:" + flag3);
System.out.println("==============");
System.out.println("测试判断功能");
File file8 = new File("D:/a/b");
/* boolean flag4 = file8.isDirectory();
System.out.println("测试file8是否是文件夹:" + flag4);*/
//上面注释的是标准的写法
System.out.println("测试file8是否是文件夹:" + file8.isDirectory());
System.out.println("测试file8是否是文件:" +file8.isFile());
System.out.println("测试file8是否是存在:" + file8.exists());
}
}
成员方法
getAbsolutePath():获取绝对路径
绝对路径：以盘符开头的路径
例如：D:/1.txt
getPath():获取文件的相对路径
相对路径：一般是相对于当前项目路径来讲的。
例如：1.txt
getName():获取文件名
list():获取指定目录下所有文件（夹）名称数组
listFiles():获取指定目录下所有文件（夹）File数组
package cn.itcast.demo21;
/*
File类的获取功能:
getAbsolutePath():获取绝对路径
getPath():获取文件的相对路径
getName():获取指定目录下所有文件（夹）名称数组
list():获取指定目录下所有文件(夹)File数组
listFile():获取指定目录下所有文件（夹）File数组
Java中路径的划分：
绝对路径：
以盘符开头的路径，固定的，写“死”的路径
相对路径：
意思是相对某个路径而言，Java中的相对路径是指：相对于当前项目的路径来讲的
*/
import java.io.File;
public class Test {
public static void main(String[] args) {
File file1 = new File("lib/1.txt");
//获取file1的绝对路径
String path1 = file1.getAbsolutePath();
System.out.println("绝对路径: " + path1);
//获取file1的相对路径
String path2 = file1.getPath();
System.out.println("相对路径:" + path2);
//获取文件名
String fileName = file1.getName();
System.out.println("文件名:" + fileName);
//获取lib文件夹下所有的文件（夹）的：名称数组String[]
File file2 = new File("lib");
String[] names = file2.list();
for (String name : names){
System.out.println(name);
}
System.out.println("==================");
//获取lib文件夹下所有的文件（夹）的：File对象数组File[]
File[] files= file2.listFiles();
for(File file:files){
System.out.println(file);
}
}
}
输出结果：
绝对路径: C:\Users\HP\Desktop\besttj\lib\1.txt 相对路径:lib\1.txt 文件名:1.txt 1.txt a
abc
lib\1.txt lib\a lib\abc
Process finished with exit code 0
字符流读写文件
字符流读数据-按单个字符读取
创建字符流读文件对象：
Reader reader = new FileReader("readme.txt");
调用方法读取数据：
int data = reader.read();
读取一个字符，返回该字符代表的整数，若到达流的末尾，返回-1
异常处理：
throws IOException
关闭资源：
reader.close();
package cn.itcast.demo22;
/*
字符流读数据：
Reader 类中的方法：
int read(): 读一个字符，返回该字符对应的ASCII码值，读不到返回-1
FileReader类的构造方法：
public FileReader(String pathname):根据传入的字符串形式的路径，获取字符输入流对象
*/
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class ReaderDemo01 {
public static void main(String[] args) throws FileNotFoundException, IOException {
//需求：通过字符流读取数据
//1.创建字符输入流对象
Reader reader = new FileReader("lib/1.txt");
//2.读取数据
int ch1 = reader.read();
System.out.println(ch1);//输出了lib/1.txt文件中abc 中a的ascii值97
int ch2 = reader.read();
System.out.println(ch2);//输出了lib/1.txt文件中abc 中b的ascii值98
int ch3 = reader.read();
System.out.println(ch3);//输出了lib/1.txt文件中abc 中c的ascii值99
int ch4 = reader.read();
System.out.println(ch4);//输出-1,因为已经到字符串末尾了
//3.释放资源
reader.close();
}
}
package cn.itcast.demo22;
/*
字符流读数据：
Reader 类中的方法：
int read(): 读一个字符，返回该字符对应的ASCII码值，读不到返回-1
FileReader类的构造方法：
public FileReader(String pathname):根据传入的字符串形式的路径，获取字符输入流对象
*/
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class ReaderDemo01 {
public static void main(String[] args) throws FileNotFoundException, IOException {
//需求：通过字符流读取数据
//1.创建字符输入流对象
Reader reader = new FileReader("lib/1.txt");
//2.读取数据
/*int ch1 = reader.read();
System.out.println(ch1);//输出了lib/1.txt文件中abc 中a的ascii值97
int ch2 = reader.read();
System.out.println(ch2);//输出了lib/1.txt文件中abc 中b的ascii值98
int ch3 = reader.read();
System.out.println(ch3);//输出了lib/1.txt文件中abc 中c的ascii值99
int ch4 = reader.read();
System.out.println(ch4);//输出-1,因为已经到字符串末尾了*/
/*
优化上述的读法，用循环改进
又因为不知道循环的次数，所有用while循环
*/
//定义变量，用来接收读取到的字符
int ch;
/*
(ch=reader.read())!= -1 这句代码做了三件事
1.执行reader.read() 去文件中读取一个字符
2.执行ch=reader.read()将读取到的字符赋值变量
3.（ch=reader.read()）！= -1，用读取到的字符（内容）和-1进行比较
*/
while((ch=reader.read())!= -1){
//ch = reader.read();
System.out.println(ch);
}
//3.释放资源
reader.close();
}
}
创建字符流读数据-按字符数组读取
创建字符流读文件对象：
Reader reader = new FileReader("readme.txt");
调用方法读取数据：
char[] chs = new char[2048];
int len = r.read(chs);
读取字符到数组中，返回读取的字符数，若到达流的末尾，返回-1
异常处理
throws IOException
关闭资源：
reader.close();
package cn.itcast.demo22;
/*
字符流读数据：
Reader类中的方法：
int read(char[] chs): 一次读一个字符数组，将读取到的内容存入到数组中
并返回读取到的有效字符流，读不到返回-1
FileReader类的构造方法:
Public FileReader(String pathname):根据传入的字符串形式的路径，获取字符输入流对象
*/
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class ReaderDemo02 {
public static void main(String[] args) throws IOException {
//需求：通过字符流读取数据，一次读取一个字符数据
//1.创建字符输入流对象 2.txt里面只有abcdefg这个字符串
Reader reader = new FileReader("lib/2.txt");
//2.读取数据
char[] chs = new char[3];//字符数组初始长度为3
int len1 = reader.read(chs);
System.out.println(chs);//a,b,c
System.out.println(len1);//返回值为3
int len2 = reader.read(chs);
System.out.println(chs);//d,e,f
System.out.println(len2);//返回值为3
int len3 = reader.read(chs);
System.out.println(chs);//g,e,f 最后只剩g所以返回值为1，但是要返回三个，那么前面的def只有d被g覆盖了，其余的不变，因为没有字母进行e和f的覆盖
System.out.println(len3);//返回值为1
int len4 = reader.read(chs);
System.out.println(chs);//g,e,f
System.out.println(len4);//返回值为-1
//3.释放资源
reader.close();
}
}
package cn.itcast.demo22;
/*
字符流读数据：
Reader类中的方法：
int read(char[] chs): 一次读一个字符数组，将读取到的内容存入到数组中
并返回读取到的有效字符流，读不到返回-1
FileReader类的构造方法:
Public FileReader(String pathname):根据传入的字符串形式的路径，获取字符输入流对象
*/
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class ReaderDemo02 {
public static void main(String[] args) throws IOException {
//需求：通过字符流读取数据，一次读取一个字符数据
//1.创建字符输入流对象
Reader reader = new FileReader("lib/2.txt");
//2.读取数据
/*char[] chs = new char[3];//字符数组初始长度为3
int len1 = reader.read(chs);
System.out.println(chs);//a,b,c
System.out.println(len1);//返回值为3
int len2 = reader.read(chs);
System.out.println(chs);//d,e,f
System.out.println(len2);//返回值为3
int len3 = reader.read(chs);
System.out.println(chs);//g,e,f
System.out.println(len3);//返回值为1
int len4 = reader.read(chs);
System.out.println(chs);//g,e,f
System.out.println(len4);//返回值为-1*/
/*
优化上述的代码，while循环
*/
//定义字符数组
char[] chs = new char[3];
//定义一个变量，记录读取到的有效字符数
int len;
while((len = reader.read(chs))!=-1){
//将读取到的内容，转换成字符串，然后打印
/*
chs :表示要操作的数组
0:表示起始索引
len:表示要操作的字符个数
*/
String s = new String(chs,0,len);//传字符数组、起始索引、长度
System.out.println(s);
}
//3.释放资源
reader.close();
}
}
字符流写数据-按单个字符写入
创建字符流写文件对象：
Writer writer = new FileWriter("dest.txt");
调用方法写入数据
int x = '中';
writer.write(x);
写一个字符
异常处理
throws IOException
关闭资源
writer.close();
package cn.itcast.demo23;
/*
字符流写数据：
Writer类中的方法：
void write(int ch): 一次写一个字符
void write(char[] chs,int index,int len):一次写一个指定的字符数组
void write(String str):一次写一个字符串
FileWriter 类的构造方法:
public FileWriter(String pathname):根据传入的字符串形式的路径，获取字符输出流对象
*/
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class WriterDemo01 {
public static void main(String[] args) throws IOException {
//需求：通过字符流写数据
//1.创建字符输出流对象
Writer writer = new FileWriter("lib/1.txt");
//2.写数据
//一次写一个字符
writer.write('好');//把原来1.txt文件里面的abc给覆盖了 abc被覆盖为好
//3.释放资源
writer.close();
}
}
字符流写数据-按字符数组写入
创建字符流写文件对象：
Writer writer = new FileWriter("dest.txt");
调用方法写数据：
char[] chs = {'橙','心','橙','意'};
writer.write(chs);
写一个字符数组
异常处理：
throws IOException
关闭资源：
writer.close();
package cn.itcast.demo23;
/*
字符流写数据：
Writer类中的方法：
void write(int ch): 一次写一个字符
void write(char[] chs,int index,int len):一次写一个指定的字符数组
void write(String str):一次写一个字符串
FileWriter 类的构造方法:
public FileWriter(String pathname):根据传入的字符串形式的路径，获取字符输出流对象
*/
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class WriterDemo01 {
public static void main(String[] args) throws IOException {
//需求：通过字符流写数据
//1.创建字符输出流对象
Writer writer = new FileWriter("lib/1.txt");
//2.写数据
//一次写一个字符
// writer.write('好');//把原来1.txt文件里面的abc给覆盖了 abc被覆盖为好
//一次写一个指定的字符数组
char[] chs = {'黑','马','程','序','员'};
writer.write(chs,2,3);
//3.释放资源
writer.close();
}
}
字符流写数据-按字符串写入
创建字符流写文件对象：
Writer writer = new FileWriter("dest.txt");
调用方法写入数据：
writer.write("小黑爱学习");
写入一个字符串
异常处理：
throws IOException
关闭资源：
writer.close();
package cn.itcast.demo23;
/*
字符流写数据：
Writer类中的方法：
void write(int ch): 一次写一个字符
void write(char[] chs,int index,int len):一次写一个指定的字符数组
void write(String str):一次写一个字符串
FileWriter 类的构造方法:
public FileWriter(String pathname):根据传入的字符串形式的路径，获取字符输出流对象
*/
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class WriterDemo01 {
public static void main(String[] args) throws IOException {
//需求：通过字符流写数据
//1.创建字符输出流对象
Writer writer = new FileWriter("lib/1.txt");
//2.写数据
//一次写一个字符
// writer.write('好');//把原来1.txt文件里面的abc给覆盖了 abc被覆盖为好
//一次写一个指定的字符数组
/* char[] chs = {'黑','马','程','序','员'};
writer.write(chs,2,3);*/
//一次写一个字符串
writer.write("好好学习，知识改变命运");
//3.释放资源
writer.close();
}
}
字符流读写数据
字符流拷贝文件-按单个字符读写
创建字符流读文件对象：
Reader reader = new FileReader("readme.txt");
创建字符流写文件对象
Writer writer = new FileWriter("dest.txt");
调用方法读取数据
int data = reader.read();
调用方法写入数据
writer.write(data);
异常处理
throws IOException
关闭资源
reader.close();
writer.close();
package cn.itcast.demo24;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class CopyFile1 {
public static void main(String[] args) throws IOException {
//需求：通过字符流拷贝文件，一次读写一个字符
//例如。将1.txt文件中的内容复制到2.txt文件中
/*
IO流拷贝文件核心六步：
1.创建字符输入流对象，关联数据源文件
2.创建字符输出流对象，关联目的地文件
3.定义变量，记录读取的内容
4.循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量
5.将读取到的数据写入到目的地文件中
6.释放资源
*/
//1.创建字符输入流对象，关联数据源文件
//Reader reader = new FileReader("lib/1.txt");下面是这个代码的优化写法
FileReader fr = new FileReader("lib/1.txt");
//2.创建字符输出流对象，关联目的地文件
FileWriter fw = new FileWriter("lib/3.txt");//细节：如果目的地文件不存在，程序会自动创建
//3.定义变量，记录读取的内容
int len;
//4.循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量
while ((len = fr.read())!=-1){
//5.将读取到的数据写入到目的地文件中
fw.write(len);
}
//6.释放资源
fr.close();
fw.close();
}
}
字符流拷贝文件-按字符数组读写
创建字符流读文件对象：
Reader reader = new FileReader("reader.txt");
创建字符流写文件对象：
Writer writer = new FileWriter("dest.txt");
调用方法读取数据：
char[] chs = new char[2048];//字符数组的长度最好定义为1024的整数倍， 计算机底层的换算单位是1024的整数倍
int len = reader.read(chs);
调用方法写数据：
writer.write(chs,0,len);
异常处理：
throws IOException
关闭资源
reader.close();
writer.close();
package cn.itcast.demo24;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class CopyFile2 {
public static void main(String[] args) throws IOException {
//需求：通过字符流拷贝文件，一次读写一个字符数组
//例如：将1.txt文件中的内容复制到2.txt文件中
/*
IO流核心六步：
1.创建字符流输入流对象，关联数据源文件
2.创建字符输出流对象，关联目的地文件
3.创建变量，用来记录读取到的有效字符数
4.通过循环进行读取，只要条件满足就一直读，并将读取到的有效数赋值给变量
5.将读取到的数据写入到目的地文件中
6.释放资源
*/
//1.创建字符流输入流对象，关联数据源文件
FileReader fr = new FileReader("lib/1.txt");
//2.创建字符输出流对象，关联目的地文件
FileWriter fw = new FileWriter("lib/2.txt");
//3.创建变量，用来记录读取到的有效字符数
char[] chs = new char[1024];
//用来记录读取到的有效字符数
int len;
//4.通过循环进行读取，只要条件满足就一直读，并将读取到的有效数赋值给变量
while ((len = fr.read(chs))!= -1){
//5.将读取到的数据写入到目的地文件中
fw.write(chs,0,len);
}
//6.释放资源
fr.close();
fw.close();
}
}
第31天学习打卡（File类。字符流读写文件）的更多相关文章
- java io 学习笔记（三） 字符流读写
1.字符流读取 字符流读取的所有类都是从Reader这个超类继承的,都是用于读取字符的,这些类分别是InputSteamReader(从字符流读取).FileReader(继承与InputStream ...
- IO学习一（File类）
File类 1.凡是与输入.输出相关的类.接口都定义在java.io包下 2.File有构造器来创建对象,此对象对应着一个文件或文件目录 支持文件类型:.txt .avi .doc .jpg .ppt ...
- 6.1（java学习笔记）File类
1.路径分隔符,文件分隔符. 路径分隔符(“:”) 文件名称分隔符(“\”windows,“/”Linux等). 不同平台使用的文件分隔符是不一样的,所以File类中提供了分隔符常量,它会根据平台的不 ...
- 吴裕雄--天生自然JAVAIO操作学习笔记：File类
import java.io.File ; import java.io.IOException ; public class FileDemo01{ public static void main( ...
- File类遍历目录及文件
1. 构造函数 File(String args0)//使用一个表示文件或目录的路径的字符串创建一个File对象 File(URL args0)//使用一个URL对象创建File对象 File(Fil ...
- java中File类应用：遍历文件夹下所有文件
练习: 要求指定文件夹下的所有文件,包括子文件夹下的文件 代码: package 遍历文件夹所有文件; import java.io.File; public class Test { public ...
- 吴裕雄--天生自然JAVAIO操作学习笔记：字节流与字符流操作
import java.io.* ; public class Copy{ public static void main(String args[]){ if(args.length!=2){ // ...
- Python 学习 第十三篇：数据的读写-文件、DataFrame、json
Python的文件是一个重要的对象,使用open()函数来打开文件,创建文件对象,进行文件的读写操作.当数据用于交换信息时,通常需要把数据保存为有格式的文本数据,可以保存为有特定的行分隔符和列分隔符的 ...
- Java学习笔记29（IO字符流，转换流）
字符流:只能操作文本文件,与字节流的区别是,字节流是按照字节来读取文件,而字符流是按照字符来读取,因此字符流的局限性为文本文件 字符输出流:Write类,使用时通过子类 每一次写入都要刷新 pac ...
随机推荐
- Manacher(马拉车)算法详解
给定一个字符串,求出其最长回文子串 eg: abcba 第一步: 在字符串首尾,及各字符间各插入一个字符(前提这个字符未出现在串里). 如 原来ma /* a b a b c ...
- Educational Codeforces Round 41
Educational Codeforces Round 41 D. Pair Of Lines 考虑先把凸包找出来,如果凸包上的点数大于\(4\)显然不存在解,小于等于\(2\)必然存在解 否则枚 ...
- 【uva 12174】Shuffle（算法效率--滑动窗口）
题意:假设一种音乐播放器有一个乱序的功能,设定每播放S首歌为一个周期,随机播放编号为1~S的歌曲.现在给一个长度为N的部分播放记录,请统计下次随机排序所发生的时间的可能性种数.(1≤S,N≤10000 ...
- Codeforces Round #579 (Div. 3) E. Boxers (贪心)
题意:给你一组数,每个数都可以进行一次加一减一,问最后最多能有多少不同的数. 题解:我们可以用桶存每个数的次数,然后枚举\([1,150001]\)来求对答案的贡献,然后贪心,这里我们不用担心其他乱七 ...
- Codeforces Round #670 (Div. 2) A. Subset Mex (贪心)
题意:给你一长度为\(n\)的序列,将其分为两个集合,求两个集合中未出现的最小元素的最大值, 题解:用桶存一下每个元素的个数,两次枚举\([1,100]\),找出两个最小值即可. 代码: int t; ...
- Zabbix 配置监控 & 触发器
Zabbix 自定义监控 zabbix-agent 获取数据,然后定义,交给 zabbix-server 端 Zabbix 配置监控项 监控的内容 # 监控服务器登录用户的数量 [root@web01 ...
- WSL (Windows Subsystem for Linux) 的 VSLAM (Visual Simultaneous Localization and Mapping) 道路
WSL 的 VSLAM 道路 以 Windows Subsystem for Linux 闯入 Visual Simultaneous Localization and Mapping 世界的艰难道路 ...
- Redis 主从复制（Replication）
为了保证服务的可用性,现代数据库都提供了复制功能,同时在多个进程中维护一致的数据状态. Redis 支持一主多从的复制架构,该功能被简化成了一条 SLAVEOF 命令,下面通过条命令来解析 Redis ...
- hdu 5874
On an isolated island, lived some dwarves. A king (not a dwarf) ruled the island and the seas nearby ...
- 用python写的一个自动卸载python包的脚本
import osplist=os.popen("pip list") # 执行windows cmd命令,获取所有包package列表,并获取返回结果到plist#跳过第1,2行 ...