1.File类:File类只能操作文件本身,但是不能操作文件的内容,就像你可以把别人的笔记本放到任何地方,但是你不能看他到底写了什么内容。
//获取f盘下a文件夹下abc文件夹下的tt.txt文件
public class Demo1 {
public static void main(String[] args) {
//这时候对象f就是tt.txt文件
File f = new File("F:\\a\\abc\\tt.txt");
//注意:\在文件中是路径的分隔符,但是在java编程中一个\的意思是转义符,在java中\\或者/才是文件的分隔符
File f2 = new File("F:/a/abc/tt.txt");
//也可以用File.separator作为文件分隔符
File f3 = new File("F:"+File.separator+"a/abc/tt.txt");
File f1 = new File("F:\\a\\abc","tt.txt");//同上,这种方式使用较少
File f4 = new File("F:\\test\\abc");//这是个目录
//获取文件名
System.out.println(f.getName());
//获取当前的目录(文件夹)名
System.out.println(f4.getName());
//获取文件或者文件夹当前路径,就是new file时候写的路径
System.out.println(f.getPath());
File f5 = new File("/src/main/java/xiangdui/xiangduilujing.java");//使用相对路径创建file对象
//获取文件或者文件夹当前路径,就是new file时候写的路径
System.out.println(f5.getPath());
//获取当前文件的绝对路径
System.out.println(f5.getAbsolutePath());
//就是new file时候写的路径
System.out.println(f5);
//返回一个用当前文件的绝对路径构建的file对象
System.out.println(f5.getAbsoluteFile());
//返回当前文件或者文件夹的父级路径
System.out.println(f5.getParent());
//给文件或文件夹重命名
f.renameTo(new File("F:\\a\\abc\\tt1.txt"));
//判断文件或者文件夹是否存在
File f6 = new File("F:\\a\\abc\\tt1.txt");
System.out.println(f6.exists());//true
File f7 = new File("F:\\a\\abc\\tt2.txt");
System.out.println(f7.exists());//false
//判断文件是否可读/写
System.out.println(f6.canRead());//true
System.out.println(f6.canWrite());//true
//判断当前的file对象是不是文件
System.out.println(f6.isFile());//true
//判断当前的file对象是不是一个文件夹(目录)
System.out.println(f6.isDirectory());//false
//获取文件的最后修改时间,返回的是一个毫秒数
System.out.println(f6.lastModified());
//返回文件的长度,单位是字节数
System.out.println(f6.length());
//创建一个新文件
File f8 = new File("F:\\a\\abc\\tt2.txt");
if (!f8.exists()){//tt2.txt文件不存在
try{
f8.createNewFile();
}catch(Exception e){
System.out.println(e.getMessage());
}
}
//删除一个文件
if (f8.exists()){
f8.delete();
}
//创建单层目录,如果使用这种方式创建多层目录,只能一层一层的执行mkdir
//File f9 = new File("F:\\a\\abc\\cc");
File f9 = new File("F:\\a\\abc\\cc\\dd");
f9.mkdir();
//创建多级目录
File f10 = new File("F:\\a\\abc\\dd\\ee");
f10.mkdirs();
//返回当前文件夹的子集的名称,包括目录和文件
File f11 = new File("F://a");
String[] list = f11.list();
for (String s:list) {
System.out.println(s);
}
//返回的是当前文件夹的子集的file对象,包括目录和文件
File[] lists = f11.listFiles();
for (File s:lists) {
System.out.println(s);
}
}
}
2.练习
//遍历f盘下a文件夹,并将其所有目录和文件打印出来
public class Demo1lianxi {
public static void test(File file){
if (file.isFile()){
System.out.println(file.getAbsolutePath()+"是文件");
}else{
System.out.println(file.getAbsolutePath()+"是一个文件夹");
//如果是文件夹,这个文件夹里就可能有子文件夹或者文件
File[] fs = file.listFiles();//这是获取当前文件夹下的子文件夹或者文件的file对象
if (fs!=null&&fs.length>0){//有东西
for (File ff:fs) {
/*if (ff.isFile()){
System.out.println(file.getAbsolutePath()+"是文件");
}else{
System.out.println(file.getAbsolutePath()+"是一个文件夹");
}*/
test(ff);
}
}
}
}
public static void main(String[] args) {
File file = new File("F:\\a");
test(file);
}
}
3.无论是输入还是输出,都指的是计算机
3.1文件字节流
/*
注意:文件字节流非常通用,可以用来操作字符的文档,还可以操作任何的其他
类型文件(如图片,压缩包等等),因为字节流直接使用的是二进制
*/
public class Demo1 {
public static void main(String[] args) throws Exception {
//testFileInputStream();
// testFileOutputStream();
//copyFile("F:\\a\\abc\\tt2.txt","F:\\a\\abc\\cc\\tt2.txt");
copyFile("F:\\a\\abc\\img.png","F:\\a\\abc\\cc\\img.png");//复制图片
}
//文件字节输入流
public static void testFileInputStream() throws Exception{
FileInputStream in = new FileInputStream("F:/a/abc/tt1.txt");
byte[] b = new byte[100];//设置一个byte数组接收读取的文件的内容
//in.read(b);//将读出来的东西存入b,返回读取的长度,如果读取到最后一个数据,还会向后读一个,
//也就意味着当in.read()的返回值是-1的时候整个文件就读取完毕了,也就是你文件中如果有多条
//数据,只能读取到第一条
int len = 0;//接收它读取的长度
while((len = in.read(b))!=-1){
System.out.println(new String(b,0,len));
//new String(b,0,len);参数1是缓冲数据的数组,参数2是从数组的哪个位置开始转化字符串,参数3是总共转化几个字节
}
//System.out.println(new String(b));
in.close();//注意:流在使用完毕之后一定要关闭
}
//文件字节输出流
public static void testFileOutputStream() throws Exception {
FileOutputStream out = new FileOutputStream("F:/a/abc/tt2.txt");//指定向tt4.txt输出数据,没有此文件的话它会自动创建
String str = "666666";
out.write(str.getBytes());//把数据写到内存中
out.flush();//把内存中的数据刷写到硬盘上
out.close();
}
//练习:将tt1.txt文件复制到cc文件夹下
public static void copyFile(String inPath,String outPath){
try{
FileInputStream in = new FileInputStream(inPath);//读取的源文件
FileOutputStream out = new FileOutputStream(outPath);//复制到哪
byte[] b = new byte[100];
int len = 0;
while ((len = in.read(b))!=-1){
out.write(b,0,len);//参数1是写的缓冲数组,参数2是从数组的哪个位置开始,参数3是写的总长度
}
out.flush();
out.close();
in.close();
}catch(Exception e){
System.out.println(e.getMessage());
}
}
}
3.2文件字符流
/*
注意:定义文件路径时,可以使用"/"或者"\\"
在写入一个文件时,如果目录下有同名文件将被覆盖//字节流和字符流都有这种情况
在读取文件时,必须保证该文件已经存在,否则出异常
*/
public class Demo2 {
public static void main(String[] args) throws Exception {
//testFileReader("F:/a/abc/tt1.txt");
testFileWriter("F:/a/abc/tt2.txt");
}
//文件字符输入流
public static void testFileReader(String inPath) throws Exception {
FileReader fr = new FileReader(inPath);//创建文件字符输入流对象
char[] c = new char[100];//创建临时存放数据的字符数组
int len = 0;//定义一个输入流的读取长度
while((len = fr.read(c))!=-1){
System.out.println(new String(c,0,len));
}
fr.close();//关闭流
}
//文件字符输出流
public static void testFileWriter(String outPath) throws Exception {
FileWriter fw = new FileWriter(outPath);
String str = "777";
fw.write(str);//写入
fw.write("6666");
fw.write("\r\n");
fw.append(str);//拼接到后面
fw.flush();//把内存的数据刷到硬盘
fw.close();
}
}
3.3处理流:缓冲流:为了提高数据读写的速度,而上面两种都是计算机与硬盘之间发生的IO操作,而硬盘的读写速度是比较慢的,所以也就有了缓冲流。缓冲流是套接在相应的节点流之上的,对读写的数据提供了缓冲的功能,提高了读写的效率,对于输出的缓冲流,写出的数据会先在内存中缓存,使用flush()方法将内存中的数据立刻写出。即与内存IO,然后在全部给硬盘。
public class Demo3 {
public static void main(String[] args) throws Exception {
//testBufferedInputStream();
//testBufferedOutputStream();
//testBufferedReader();
testBufferedWriter();
}
//缓冲字节输入流
public static void testBufferedInputStream() throws Exception{
//文件字节输入流对象
FileInputStream in = new FileInputStream("F:/a/abc/tt1.txt");
//缓冲字节输入流对象,将文件字节输入流对象放入到缓冲字节输入流中
BufferedInputStream br = new BufferedInputStream(in);
byte[] b = new byte[100];
int len = 0;
while((len=br.read(b))!= -1){
System.out.println(new String(b,0,len));
}
//关闭流的时候,后开的先关,依次关掉
br.close();
in.close();
}
//缓冲字节输出流
public static void testBufferedOutputStream() throws Exception{
//文件字节输出流对象
FileOutputStream out = new FileOutputStream("F:/a/abc/tt2.txt");
//缓冲字节输出流对象,将文件字节输出流对象放入到缓冲字节输出流中
BufferedOutputStream bo = new BufferedOutputStream(out);
String str = "hello world";
bo.write(str.getBytes());//写到内存中
bo.flush();//刷新到硬盘上
//关闭流的时候,后开的先关,依次关掉
bo.close();
out.close();
}
//缓冲字符输入流
public static void testBufferedReader() throws Exception {
FileReader r = new FileReader("F:/a/abc/tt1.txt");
BufferedReader br = new BufferedReader(r);
char[] c = new char[100];
int len = 0;
while ((len=br.read(c))!=-1){//读到文件的最后一个字符的下一位,返回值就是-1
System.out.println(new String(c,0,len));
}
br.close();
r.close();
}
//缓冲字符输出流
public static void testBufferedWriter() throws Exception {
FileWriter r = new FileWriter("F:/a/abc/tt1.txt");
BufferedWriter br = new BufferedWriter(r);
String s = "666666";
br.write(s);
br.flush();
br.close();
r.close();
}
}
3.4处理流:转换流
public class Demo4 {
public static void main(String[] args) throws Exception {
//所有文件都是有编码格式
//对于我们来说,txt和java文件一般来讲有三种编码
//ISO8859-1,西欧编码,是纯粹的英文编码,不适合中文
//GBK和UTF-8,这两种是适用于中文和英文的
//一般使用UTF-8编码
//testInputStreamReader();
testOutputStreamWriter();
}
//转换字节输入流为字符输入流
//注意:在转换字符流的时候,设置的字符集编码要与读取的文件的数据的编码一致,否则就会出现乱码
public static void testInputStreamReader() throws Exception {
FileInputStream fs = new FileInputStream("src\\main\\java\\tt5.txt");
//把字节流转换为字符流,参数1是字节流,参数2是编码
InputStreamReader in = new InputStreamReader(fs,"UTF-8");
char[] c = new char[100];
int len = 0;
while((len=in.read(c))!=-1){
System.out.println(new String(c,0,len));
}
in.close();
fs.close();
}
//转换字节输出流为字符输出流
public static void testOutputStreamWriter() throws Exception{
FileOutputStream out = new FileOutputStream("src\\main\\java\\tt6.txt");
//注意:在转换字符流的时候,设置的字符集编码要与读取的文件的数据的编码一致,否则就会出现乱码
OutputStreamWriter os = new OutputStreamWriter(out,"UTF-8");
os.write("你好!");
os.flush();
os.close();
out.close();
}
}
3.5处理流:标准输入输出流
System.in和System.out分别代表了系统标准的输入和输出设备,默认输入设备设键盘,输出设备是显示器
System.in的类型是InputStream
System.out的类型是PrintStream,其是OutputStream的子类FilterOutputStream的子类
3.5.1System.in
public class Demo5{
public static void main(String[] args) throws IOException {
//testSystemIn();
writeToTxt();
}
//标准输入流
public static void testSystemIn() throws IOException {
//创建一个接受键盘输入数据的输入流
InputStreamReader is = new InputStreamReader(System.in);
//把输入流放到缓冲流中
BufferedReader br = new BufferedReader(is);
String str = "";//定义一个临时接收数据的字符串
while((str=br.readLine())!= null){
System.out.println(str);
}
br.close();
is.close();
}
//练习:把控制台输入的内容写到指定的txt文件中,但接收到over就结束
public static void writeToTxt() throws IOException {
//创建一个接受键盘输入数据的输入流
InputStreamReader is = new InputStreamReader(System.in);
//创建一个输入缓冲流
BufferedReader br = new BufferedReader(is);
BufferedWriter out = new BufferedWriter(new FileWriter("src\\main\\java\\tt5.txt"));
String line="";
while((line=br.readLine())!=null){
if (line.equals("over")){
break;
}
//读取每一行并写到指定的txt文件
out.write(line);
out.newLine();//换行
}
out.flush();
out.close();
br.close();
is.close();
}
}
3.5.2System.out
PrintStream(字节打印流)和PrintWriter(字符打印流)提供了一系列重载的print和println方法,用于多种数据类型的输出,他们两个流的输出都不会抛出异常并且都有自动flush功能,System.out返回的是PrintStream的实例
3.6处理流:数据流:专门用来方便操作基本数据类型的数据
DataInputStream和DataOutputStream 分别套接在InputStream和OutputStream节点流上
public class Demo6 {
public static void main(String[] args) throws Exception {
//testDataOutputStream();
testDataInputStream();
}
//数据输出流
/*
用数据输出流写到文件中的基本数据类型的数据,是乱码的,不能直接辨认出来,需要数据输入流读取出来
*/
public static void testDataOutputStream() throws Exception {
//创建一个数据输出流对象
DataOutputStream out = new DataOutputStream(new FileOutputStream("src\\main\\java\\tt6.txt"));
//out.writeBoolean(true);
//out.writeDouble(1.35d);
out.writeInt(100);
out.flush();
out.close();
}
/*
数据输入流
用数据输出流写到文件中的基本数据类型的数据,是乱码的,不能直接辨认出来,需要数据输入流读取出来
用数据输入流读取数据输出流写到文件中的数据时,要保证使用和当时写的数据类型一致,否则得不到想要的数据
*/
public static void testDataInputStream() throws Exception{
DataInputStream in = new DataInputStream(new FileInputStream("src\\main\\java\\tt6.txt"));
System.out.println(in.readInt());
in.close();
}
}
3.7处理流:对象流
ObjectInputStream和ObjectOutputStream:用于存储和读取对象的处理流。它的强大之处就是可以把java中的对象写入到数据源中,也能把对象从数据源中还原回来。
正是因为保存对象到硬盘(对象的持久化)和对象的网络传输,需要做这两件事,就产生了输入与输出流。
序列化(Serialize):用ObjectOutputStream类将一个java对象写入IO流中
反序列化(Deserialize):用ObjectInputStream类从IO流中恢复该java对象
序列化与反序列化针对的是对象的各种属性,不包括类的属性。
ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
Person.java
/*
可以序列化与反序列化的对象
*/
public class Person implements Serializable {
/*
一个表示序列化版本标识符的静态变量
用来表明类的不同版本间的兼容性
*/
private static final long serialVersionUID = 1L;
String name;
int age;
}
test.java
/*
序列化与反序列化
注意:对象的序列化与反序列化使用的类要严格一致,包名,类名,类结构等等都要一致
*/
public class test {
public static void main(String[] args) throws Exception {
//testSerialize();//序列化
testDeserialize();//反序列化
}
/*
对象序列化
*/
public static void testSerialize() throws Exception{
//定义对象的输出流,把对象序列化之后的流放到指定的文件中
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("src\\main\\java\\tt6.txt"));
Person p = new Person();
p.age = 18;
p.name ="HAHA";
out.writeObject(p);
out.flush();
out.close();
}
/*
对象的反序列化
*/
public static void testDeserialize() throws Exception{
//创建对象输入流对象,从指定的文件中把对象的序列化后的值读取出来
ObjectInputStream in = new ObjectInputStream(new FileInputStream("src\\main\\java\\tt6.txt"));
Object obj = in.readObject();
Person p = (Person)obj;
System.out.println(p.name);
System.out.println(p.age);
in.close();
}
}
3.8RandomAccessFile类
RandomAccessFile类支持“随机访问”的方式,程序可以直接跳转到文件的任意地方来读,写文件
支持只访问文件的部分内容
可以向已存在的文件后追加内容
RandomAccessFile对象包含一个记录指针,用以标示当前读写处的位置
RandomAccessFile对象可以自由移动记录指针
long getFilePointer():获取文件记录指针的当前位置
void seek(long pos):将文件记录指针定位到pos位置
/*
文件的随机读写:程序可以直接跳到文件的任意地方来读、写文件
*/
public class test {
public static void main(String[] args) throws Exception {
//testRandomAccessFileRead();
testRandomAccessFileWrite();
}
/*
随机读文件
*/
public static void testRandomAccessFileRead() throws Exception{
//RandomAccessFile的构造有两个参数,参数1是读写的文件的路径
//参数2是指定RandomAccessFile的访问模式
//r:以只读方式打开
//rw:打开以便读取和写入
//rwd:打开以便读取和写入;同步文件内容的更新
//rws:打开以便读取和写入;同步文件内容和元数据的更新
RandomAccessFile ra = new RandomAccessFile("src\\main\\java\\tt5.txt","r");
//ra.seek(0);//设置读取文件内容的起始点,以字符为单位
ra.seek(8);
byte[] b = new byte[1024];
int len = 0;
while((len=ra.read(b))!=-1){
System.out.println(new String(b,0,len));
}
ra.close();
}
/*
随机写文件
*/
public static void testRandomAccessFileWrite() throws Exception{
RandomAccessFile ra = new RandomAccessFile("src\\main\\java\\tt5.txt","rw");
//ra.seek(6);//设置写的起始点,0代表从开头写
//注意:如果是在文件开头或者中间的某个位置开始写的话,就会用写的内容覆盖掉等长度的原内容
ra.seek(ra.length());//设置写的起始点,ra.length()代表从文件的最后结尾写,也就是文件的追加
ra.write("你好".getBytes());
ra.close();
}
}