Java学习第九章(二)

已于 2022-04-13 22:14:02 修改
阅读量613 收藏
点赞数
分类专栏： JAVA学习(进阶班) 文章标签： java 学习 开发语言
于 2022-03-28 10:37:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49883619/article/details/123687516
版权

视频链接：https://www.bilibili.com/video/BV1Rx411876f?p=1

视频范围P743 - P756

目录描述

1.File类的理解和常用方法

  1. File类和四大家族没有关系，所以File类不能完成文件的读和写
  2. File对象代表文件和目录路径名的抽象表示形式
  3. 需要掌握File类中常用的方法

代码实例一：
exists()，createNewFile()，mkdir()，mkdirs()，getParent()，getParentFile()，getAbsolutePath()

package IO;

import java.io.File;

public class FileTest01 {
    public static void main(String[] args) throws Exception{
        //创建一个File对象
        File f1 = new File("D:\\file");

        //判断是否存在！
        System.out.println(f1.exists());//输出为：false

        //如果D:\file不存在，则以文件的形式创建出来
        if (!f1.exists()){
            //以文件形式新建
            f1.createNewFile();
        }

        //如果D:\file不存在，则以目录的形式创建出来
        if (!f1.exists()){
            //以目录形式新建
            f1.mkdir();
        }

        //创建多重目录
        File f2 = new File("D:/a/b/c/d");
        if (!f2.exists()){
            //多重目录的形式新建
            f2.mkdirs();
        }

        File f3 = new File("D:\\百度云盘\\BaiduNetdisk");
        //获取文件的父路径
        String parentPath = f3.getParent();
        System.out.println(parentPath);
        File parentFile = f3.getParentFile();
        System.out.println("获取绝对路径：" + parentFile.getAbsolutePath());
    }
}

代码实例二：
getName()，isDirectory()，isFile()，lastModified()，length()

 package IO;

import javax.xml.crypto.Data;
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;

public class FileTest02 {
    public static void main(String[] args) {
        File f1 = new File("D:\\百度云盘\\BaiduNetdisk");
        //获取文件名
        System.out.println("文件名：" + f1.getName());

        //判断是否是一个目录
        System.out.println(f1.isDirectory());

        //判断是否是一个文件
        System.out.println(f1.isFile());

        //获取文件最后一次修改时间
        long haoMiao = f1.lastModified();//这个毫秒是从1970年到现在的总毫秒数
        //将总毫秒数转换成日期
        Date time = new Date(haoMiao);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        String strTime = sdf.format(time);
        System.out.println(strTime);

        //获取文件大小
        System.out.println(f1.length());

    }
}

代码实例三：
listFiles()方法

package IO;

import java.io.File;

public class FileTest03 {
    public static void main(String[] args) {
        //获取当前目录下所有的子文件
        File f1 = new File("D:\\百度云盘\\BaiduNetdisk");
        File[] files = f1.listFiles();
        //foreach
        for(File file : files){
            System.out.println(file.getAbsoluteFile());
            System.out.println(file.getName());
        }
    }
}

2.目录拷贝

将一个文件夹及其中的文档或子文件拷贝从D盘拷到C盘

package IO;

import java.io.*;

public class CopyAll {
    public static void main(String[] args) {
        //拷贝源
        File srcFile = new File("D:\\目录复制演示文件");
        //拷贝目标
        File destFile = new File("C:\\");
        //调用方法拷贝
        copyDir(srcFile,destFile);
    }

    /**
     * 拷贝目录
     * @param srcFile 拷贝源
     * @param destFile 拷贝目标
     */
    private static void copyDir(File srcFile, File destFile) {
        if(srcFile.isFile()){
            //srcFile如果是一个文件的话，递归结束
            //是文件的时候需要拷贝
            //...一边读一边写
            FileInputStream in = null;
            FileOutputStream out = null;
            try {
                //读这个文件
                //D:\目录复制演示文件
                in = new FileInputStream(srcFile);
                //写到这个文件中
                //C:\目录复制演示文件
                String path = (destFile.getAbsolutePath().endsWith("\\")?destFile.getAbsolutePath():destFile.getAbsolutePath() + "\\") + srcFile.getAbsolutePath().substring(3);
                out = new FileOutputStream(path);
                //一边读一边写
                byte[] bytes = new byte[1024*1024];//一次复制1MB
                int readCount = 0;
                while ((readCount = in.read(bytes))!= -1){
                    out.write(bytes,0,readCount);
                }
                out.flush();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (out != null) {
                    try {
                        out.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }

                if (in != null) {
                    try {
                        in.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }

            }
            return;
        }

        //获取源下面的子目录
        File[] files = srcFile.listFiles();
        for (File file : files){
            //获取所有文件的(包括目录和文件)绝对路径
            //System.out.println(file.getAbsolutePath());
            if (file.isDirectory()){
                //新建对于的目录
                //System.out.println(file.getAbsolutePath());
                //D:\目录复制演示文件  源目录
                //C:\目录复制演示文件  目标目录
                String srcDir = file.getAbsolutePath();
                String destDir = (destFile.getAbsolutePath().endsWith("\\")?destFile.getAbsolutePath():destFile.getAbsolutePath() + "\\") + srcDir.substring(3);
                File newFile = new File(destDir);
                if (!newFile.exists()){
                    newFile.mkdirs();
                }
            }
            //递归调用
            copyDir(file,destFile);
        }
    }
}

3.序列化和反序列化

3.1 概念

序列化：Serialize java对象存储到文件中，将java对象的状态保存下来的过程【objectInputStream】
反序列化：DeSerialize 将硬盘上的数据重新恢复到内存当中，恢复成java对象【objectOutputStream】
在这里插入图片描述

3.2 Serializable接口

  1. 参与序列化和反序列化的对象，必须实现Serializable接口
  2. 通过源代码发现，Serializable接口只是一个标志接口，这个接口当中什么代码都没有：
public interface Serializable {
}
  1. Serializable作用：起到标识的作用，标志的作用，java虚拟机看到这个类实现了这个接口，可能会对这个类进行特殊待遇，Serializable这个标志接口是给java虚拟机参考的，java虚拟机看到这个接口之后，会为该类自动生成一个序列化版本号
  2. 序列化作用：为了保存在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以把保存的对象状态再读出来

3.2.1 序列化

学生类：

package bean;

import java.io.Serializable;

public class Student implements Serializable {
    //Java虚拟机看到Serializable接口之后，会自动生成一个序列化版本号
    //这里没有手动写出来，java虚拟机会默认提供这个序列化版本号
    private int no;
    private String name;

    public Student() {
    }

    public Student(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
}

测试类：

package IO;

import bean.Student;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

/**
 * java.io.NotSerializableException student对象不支持序列化！！！
 */
public class ObjectOutputStreamTest01 {
    public static void main(String[] args) throws Exception {
        //创建java对象
        Student s = new Student(1111,"zhangsan");
        //序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("student"));

        //序列化对象
        oos.writeObject(s);

        //刷新
        oos.flush();

        //关闭
        oos.close();
    }
}

运行结果：
生成一个student文件

在这里插入图片描述

3.2.2 反序列化

package IO;

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class ObjectInputStreamTest01 {
    public static void main(String[] args) throws Exception{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("student"));
        //开始反序列化，读
        Object obj = ois.readObject();
        //反序列化回来是一个学生对象，所以会调用学生对象的toString方式
        System.out.println(obj);
        ois.close();
    }
}

运行结果：

在这里插入图片描述

3.2.3 序列化多个对象

  1. 将对象放到序列化集合中
  2. 参与序列化的ArrayList集合以及集合厚葬的元素User都需要实现java.io.Serializable接口

用户类：

package bean;

import java.io.Serializable;

public class User implements Serializable {
    private int no;
    private String name;

    public User() {
    }

    public User(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
}

序列化：

package IO;

import bean.User;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

public class ObjectOutputStreamTest02 {
    public static void main(String[] args) throws Exception{
        List<User> userList = new ArrayList<>();
        userList.add(new User(1,"zhangsan"));
        userList.add(new User(2,"lisi"));
        userList.add(new User(3,"wangwu"));
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("users"));

        //序列化一个集合，这个集合对象中放了很多其它对象
        oos.writeObject(userList);

        oos.flush();
        oos.close();
    }
}

运行结果：

生成一个users文件在这里插入图片描述

反序列化：

package IO;

import bean.User;

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.List;

public class ObjectInputStreamTest02 {
    public static void main(String[] args) throws Exception{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("users"));

        List<User> userList = (List<User>) ois.readObject();
        for(User user : userList){
            System.out.println(user);
        }
        ois.close();
    }
}

运行结果：

在这里插入图片描述

3.3 transient关键字

表示游离的，不参与序列化

package bean;

import java.io.Serializable;

public class User implements Serializable {
    private int no;
    //transient关键字表示游离，不参与序列化
    private transient String name;//name不参与序列化操作！

    public User() {
    }

    public User(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
}

运行结果：
重新序列化和反序列化后的
在这里插入图片描述

3.4 序列化版本号

  1. 过了很久，Student这个类源代码改动后，需要重新编译，编译之后生成了全新的字节码文件，并且class文件再次运行的时候，java虚拟机生成的序列化版本号也会发生相应的改变
  2. Java虚拟机看到Serializable接口之后，会自动生成一个序列化版本号，这里没有手动写出来，java虚拟机会默认提供这个序列化版本号
  3. java语言中区分类：
    第一：首先通过类名进行比对，如果类名不一样，肯定不是同一个类
    第二：如果类名一样，再靠序列化版本号进行区分
  4. 举例
小鹏编写了一个类: com.bjpowernode.java.bean.Student implements Serializable
胡浪编写了一个类: com. bjpowernode.java.bean.Student implements Serializable
不同的人编写了同一个类，但"这两个类确实不是同一个类"”。这个时候序列化版本就起上作用了。
对于java虚拟机来说，java虚拟机是可以区分开这两个类的，因为这两个类都实现了Serializable接口，都有默认的序列化版本号，他们的序列化版本号不一样。所以区分开了。(这是自动生成序列化版本号的好处)
  1. 自动生成序列化版本号缺点：一旦代码确定之后，不能进行后续的修改，因为只要修改，必然会重新编译，此时会生成全新的序列化版本号，这个时候java虚拟机会认为这是一个全新的类【这样就不好了】
  2. 注意：凡是一个类实现了Serializable接口，建议将序列化版本号手动的写出来，不建议自动生成；这样，以后这个类即使代码修改了，但是版本号不变，java虚拟机会认为是同一个类
//java虚拟机识别一个类的时候先通过类，如果类名一致，再通过序列化版本号
private static final long serialVersionUID = 1L;
  1. IDEA自动生成序列化版本号

在这里插入图片描述
然后在类名上 Alt+回车键
在这里插入图片描述
最终效果：
在这里插入图片描述

4.IO和Properties联合使用

IO流：文件的读和写
Properties：是一个Map集合，key和value都是String类型
需求：想将userinfo文件【.txt文件】中的数据加载到Properties对象当中

userinfo文件：

##########在属性配置文件中井号十注释############
#属性配置文件的key重复的话，value会自动覆盖！
#不要有空格！
username=admin
password=123

测试类：

package IO;

import java.io.FileReader;
import java.util.Properties;

public class IoPropertiesTest01 {
    public static void main(String[] args) throws Exception{
        //新建一个输入流对象
        FileReader reader = new FileReader("IO/userinfo");

        //新建一个Map集合
        Properties pro = new Properties();

        //调用Properties对象的load方法将文件中的数据加载到Map集合中
        pro.load(reader);//文件中的数据顺着管道加载到Map集合中，其中等号=左边做key，右边做value

        //通过key来获取value
        String username = pro.getProperty("username");
        System.out.println(username);//输出为：admin
    }
}

总结：

  1. 一个非常好的设计理念：以后经常改变的数据，可以单独写到一个文件中，使用程序动态读取，将来只需要修改这个文件的的内容，java代码不需要改动，不需要重新编译，服务器也不需要重启，就可以拿到动态的信息
  2. 当类似userinfo文件这种文件被称为配置文件，并且当配置文件中的内容格式是如下，把这种配置文件叫做属性配置文件：
key1 = value
key2 = value
  1. java规范中要求：属性配置文件建议以.properties结尾，但这不是必须的
  2. 以.properties结尾的文件在java中被称为：属性配置文件
  3. 其中properties是专门存放属性配置文件内容的一个类
计算机量子狗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java类文件通过$获取properties文件的属性值
09-07
java类文件通过$获取properties文件的属性值
Java程序设计与数据结构第九章习题答案
12-11
为学习Java程序设计的基础同学提供习题代码的参考，便于他们掌握多种方法，得到解决问题的思路和想法，Java程序设计与数据结构第九章习题答案！！！
java.io.File类中mkdir()与mkdirs()区别
kyi_persisting的博客
01-07 7258
在Java中对文件进行操作时常常用到java.io.File.mkdir()和java.io.File.mkdirs()两个方法来创建一个目录(文件夹)，这两个方法非常相似，都是无参数且返回值都为boolean类型的方法，都是用于创建指定路径名称对应的目录，但二者主要区别如下： java.io.File.mkdir()：只能创建一级目录，且父目录必须存在，否则无法成功创建一个目录。 j
关于java读取和写入properties配置文件的内容
weixin_30617561的博客
08-07 485
一般通过使用流的方式进行读取 代码示例如下： package com.zznode.transmit.util; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.InputStream; import java.io.OutputStream; import jav...
mkdir()与 mkdirs()的区别
Htht_Smile的专栏
11-12 1206
1、mkdir()与 mkdirs()的返回值都是boolean，成功创建目录放回true，未成功放回false。 2、mkdirs()可以建立多级文件夹， mkdir()只会建立一级的文件夹， 如下：     File f = new File("d:\\test/one/two\\three"); f.mkdirs();     f.mkdir(); mkdirs()执行后，
Java File的mkdir()和mkdirs()使用区别
l912943297的博客
08-10 3702
import java.io.*; public class TestFile { public static void main(String[] args) throws Exception { File f1 = new File("E://aaa//bbb"); if(!f1.exists()){ f1.mkdirs(); }
Java程序设计与数据结构第八章习题答案
12-11
为学习Java程序设计的基础同学提供习题代码的参考，便于他们掌握多种方法，得到解决问题的思路和想法，Java程序设计与数据结构第八章习题答案！！！
java学习课件第二章
12-21
这是第2章内容 这是关于学习java基础的课件 第一章、java语言基础 第二章、java语法基础 第三章、面向对象特征 第四章、applet及其应用 ...第五章、图形用户界面设计 ...第九章、文件输入输出 第十章、网络编程
java学习课件 第四章
12-21
这是关于学习java基础的课件 第一章、java语言基础 第二章、java语法基础 第三章、面向对象特征 第四章、applet及其应用 第五章、图形用户界面设计 ...第九章、文件输入输出 第十章、网络编程
java学习课件第三章
12-21
这是关于学习java基础的课件 第一章、java语言基础 第二章、java语法基础 第三章、面向对象特征 第四章、applet及其应用 第五章、图形用户界面设计 ...第九章、文件输入输出 第十章、网络编程
Java中Properties类
qq_39038793的博客
03-09 150
一、Java Properties类 Java中有个比较重要的类Properties（Java.util.Properties），主要用于读取Java的配置文件，各种语言都有自己所支持的配置文件，配置文件中很多变量是经常改变的，这样做也是为了方便用户，让用户能够脱离程序本身去修改相关的变量设置。在Java中，其配置文件常为.properties文件，格式为文本文件，文件的内容的格式是“键...
利用java反射机制 读取配置文件 实现动态类加载以及动态类型转换
热门推荐
leixingbang的专栏
10-16 1万+
Spring实现的一个重要的机制是通过反射（java.lang.reflect）读取配置文件，通过配置文件来动态生成配置文件中的类对象。Java动态加载类主要是为了不改变主程序代码，通过修改配置文件就可以操作不同的对象执行不同的功能。 由于java是强类型语言，本文根据一篇老外的博客，给出了一种可以实现动态类型转换的可行性方法和思路。 本文主要帮助你完成一下学习目标： （1） java反射机制最基础的学习。 （2） 通过最基础的java正则表达式读取配置文件，获取需要的信息。 （3） 模拟spring的IO
java配置properties文件_关于Java配置文件properties的学习
weixin_29191669的博客
02-20 223
在Java早期的开发中，常用*.properties文件存储一些配置信息。其文件中的信息主要是以key=value的方式进行存储，在早期受到广泛的应用。而后随着xml使用的广泛，其位置渐渐被取代，不过，目前仍有一些框架如log4J在使用它。最近在弄自己的小玩意儿的时候也用到了它，顺便加深了一下了解，在此分享。Java在对*.properties文件进行操作的时候，实际上是通过IO对文档进行逐行的扫...
properties java读取_Java读取properties的几种实现方式
weixin_39950552的博客
02-12 221
1.通过java.util.Properties.Properties类读取配置信息Properties类继承自Hashtable类并且实现了Map接口，也是使用一种键值对的形式来保存属性集。不过Properties有特殊的地方，就是它的键和值都是字符串类型。加载属性文件，它提供了两个方法：load和loadFromXMLload有两个方法的重载：load(InputStream inStream...
java bean配置_[Java教程]Spring中Bean的配置
weixin_34439450的博客
02-20 638
[Java教程]Spring中Bean的配置0 2016-09-10 16:00:15原创作品，可以转载，但是请标注出处地址http://www.cnblogs.com/V1haoge/p/5859556.html1、Bean的配置一般都在文件中进行配置2、Bean相关包为：org.springframework.beans和org.springframework.context3、...
java环境部署
JiuMeilove的博客
06-04 399
如果你电脑已经下载了 jdk ，那你可以跳过这一步了我这里下载的是java21 你们可以选择自己需要下载的游览进去的页面是这样子的（相比以前这个页面发生很大变化了），可以看见目前 jdk 已经发行到 17 了，jdk 它又分了三个个操作系统，一个是 Linux、一个是 macOS、以及 windows，如果你是在 windows 操作系统上，那当然就下载 windows 对应的 jdk，其次的话就是还会区分你操作系统的处理器是 32 位的还是 64 位的，可以点击 我的电脑 - 属性 查看。
finereport 9.0 Tomcat 集群-来自帆软
最新发布
chenmingfa110的博客
06-07 586
APACHE_HOME ％为你的安装目录。对于每个新来的session，Apache按照节点配置中的lbfactor比重选择访问节点，如果某节点node1不能访问，则寻找下一可访问节点，并且将此node1就在该访问session的访问黑名单中，以后该session的访问直接不考虑node1，即使node1又可以访问了。注：由于这里三个tomcat全在一台机器上，所以需要修改三种类型的端口号，如果是在不同的机器上，则只需要修改AJP13的connector的port，其他端口号不需要修改。
java语言程序设计第九章思维导图
01-15
如果您想了解Java语言程序设计的第九章内容，我建议您参考相关的教材或学习资料。您可以查阅Java语言程序设计的教材或参考书籍，或者在网上搜索相关的学习资源和教程。这些资源通常会提供详细的章节内容和示例代码，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值