• Day10配置文件&日志&多线程

    配置文件

    在企业开发过程中，我们习惯把一些需要灵活配置的数据放在一些文本文件中，而不是在Java代码写死 我们把这种存放程序配置信息的文件，统称为配置文件

    properties 

    是一个Map集合（键值对集合），但是我们一般不会当集合使用。

    核心作用：Properties是用来代表属性文件的，通过Properties可以读写属性文件里的内容 

     

     使用Properties读取属性文件里的键值对数据 

     

    使用Properties把键值对数据写出到属性文件里去 

     

    1. public class Demo1 {
    2.     public static void main(String[] args)throws IOException {
    3.         //1. 创建一个配置文件对象
    4.  
    5.         Properties properties = new Properties();
    6.         properties.setProperty("name","卷王");
    7.         properties.setProperty("age","18");
    8.  
    9.         properties.store(new FileWriter("E:\\Code191Day\\day10\\a-1.properties"),"卷王个人介绍");
    10.         //2. 读取
    11.  
    12.         properties.load(new FileReader("E:\\Code191Day\\day10\\a-1.properties"));
    13.  
    14.         System.out.println(properties.getProperty("name"));
    15.         System.out.println(properties.getProperty("age"));
    16.  
    17.         Set set = properties.stringPropertyNames();
    18.         for (String s : set) {
    19.             System.out.println(s + properties.getProperty(s));
    20.         }
    21.         
    22.     }
    23. }

     Properties的作用？具体如何使用？

    可以加载属性文件中的数据到Properties对象中来

    void load​(Reader reader)

    public String getProperty(String key)     根据键获取值 

    可以存储Properties属性集的键值对数据到属性文件中去

    void store​(Writer writer, String comments)

    public Object setProperty(String key, String value)    设置键值

    XML

              本质是一种数据的格式，可以用来存储复杂的数据结构，和数据关系。 

     

    XML的特点

    1.XML中的“<标签名>” 称为一个标签或一个元素，一般是成对出现的。

    2.XML中的标签名可以自己定义（可扩展），但必须要正确的嵌套。

    3.XML中只能有一个根标签。

    4.XML中的标签可以有属性。

    5.如果一个文件中放置的是XML格式的数据，这个文件就是XML文件，后缀一般要写成.xml 

     XML的语法规则

    1.XML文件的后缀名为：xml，文档声明必须是第一行

     

    version：XML默认的版本号码、该属性是必须存在的

    encoding：本XML文件的编码

    2.XML中可以定义注释信息：，快捷键是Ctrl+shift+/

    3.XML中书写”<”、“&”等，可能会出现冲突，导致报错，此时可以用如下特殊字符替代。

        <    <  小于

        >    >  大于

       &   &  和号

       '  '  单引号

       "  "  引号

    4.XML中可以写一个叫CDATA的数据区: ，里面的内容可以随便写。

    XML的作用和应用场景 

    本质是一种数据格式，可以存储复杂的数据结构，和数据关系。

    应用场景：经常用来做为系统的配置文件；或者作为一种特殊的数据结构，在网络中进行传输。 

     

     XML的作用

    XML的是一种可扩展的标记语言。

    作用：1）作为软件的配置文件   2）用于进行存储数据和传输数据 

    解析XML文件

    Dom4j解析XML-得到Document对象 

     

    DOM4J解析XML文件的思想：文档对象模型 
    1. "1.0" encoding="UTF-8" ?>
    3.     "1">
    4.         张无忌
    5.         minmin
    6.         
      光明顶
    7.         男
    8.     
    9.     "2">
    10.         敏敏
    11.         wuji
    12.         
      光明顶
    13.         女
    14.     
    1. public class Demo2 {
    2.     public static void main(String[] args) throws DocumentException {
    3.  
    4.         List list = new ArrayList<>();
    5.  
    6.         //1.使用SAXReader读取XML,封装成Document
    7.         SAXReader saxReader = new SAXReader();
    8.         Document read = saxReader.read("E:\\Code191Day\\day10\\b-2.xml");
    9.  
    10.         //获取跟节点
    11.         Element rootElement = read.getRootElement();
    12.  
    13.         //获取根元素下的子元素
    14.         List elements = rootElement.elements();
    15.  
    16.         //遍历集合获取每个元素
    17.         for (Element element : elements) {
    18.             String id = element.attributeValue("id");
    19.             String name = element.element("name").getText();
    20.             String password = element.element("password").getText();
    21.             String address = element.element("address").getText();
    22.             String gender = element.element("gender").getText();
    23.  
    24.             User user = new User(Integer.valueOf(id),name,password,address,gender);
    25.             list.add(user);
    26.         }
    27.  
    28.         list.stream().forEach(System.out::println);
    29.     }
    30. }
    Element提供的方法 

     

    约束文档 

    门用来限制xml书写格式的文档，比如：限制标签、属性应该怎么写。 

    约束文档的分类 

    1.DTD文档

    2.Schema文档 

    日志技术 

              程序中的日志，通常就是一个文件，里面记录的是程序运行过程中的各种信息。 

    1.可以将系统执行的信息，方便的记录到指定的位置（控制台、文件中、数据库中）。

    2.可以随时以开关的形式控制日志的启停，无需侵入到源代码中去进行修改。 

    Logback日志框架 

    想使用Logback日志框架，至少需要在项目中整合如下三个模块： 

    1.slf4j-api：日志接口

    2.logback-core

    3.logback-classic 

    实现步骤 

     

     

    1. public class Demo1 {
    2.  
    3.     public static final Logger LOGGER = LoggerFactory.getLogger("Demo1");
    4.  
    5.     public static void main(String[] args) {
    6.  
    7.         LOGGER.debug("哈哈哈");
    8.         LOGGER.error("除法报错");
    9.      try {
    10.          LOGGER.warn("除数为0");
    11.          sum(10, 2);
    12.      }catch (Exception e){
    13.          LOGGER.error("除法报错");
    14.      }
    15.  
    16.     }
    17.  
    18.     public static int sum(int a,int b){
    19.  
    20.         LOGGER.info("输入的参数:a={},b={}",a,b);
    21.         int c = a / b;
    22.         return c;
    23.     }
    24.  
    25. }

     日志级别

     

    多线程 

    1.单线程：在计算机中同一时间只能做一件事

    2.多线程：在计算机中同一时间可以做多件事 

    1. public class Demo1 {
    2.     public static final Logger logger = LoggerFactory.getLogger("Demo1");
    3.     public static void main(String[] args) {
    4.         //需求：创建两个线程，分别用于打印10个A和10个B，最后观察下输出顺序
    5.  
    6.           new Thread(){
    7.             @Override
    8.             public void run() {
    9.                 Thread.currentThread().setName("卷王线程");
    10.  
    11.                 for (int i = 0; i < 10; i++) {
    12.                     logger.info(Thread.currentThread().getName() + i);
    13.                 }
    14.             }
    15.         }.start();
    16.  
    17.         new Thread(){
    18.             @Override
    19.             public void run() {
    20.                 Thread.currentThread().setName("阿giao线程");
    21.                 for (int i = 0; i < 10; i++) {
    22.                     logger.info( Thread.currentThread().getName() + i);
    23.                 }
    24.             }
    25.         }.start();
    26.  
    27.     }
    28. }

     线程的创建方式

    方式一继承Thread类 

    1.定义一个子类继承线程类java.lang.Thread，

    2.重写run()方法 创建子类的对象

    3.调用子类对象的start()方法启动线程（底层会自动去执行run方法） 

    1. public class Demo1 {
    2.     public static final Logger logger = LoggerFactory.getLogger("Demo1");
    3.     public static void main(String[] args) {
    4.         //需求：创建两个线程，分别用于打印10个A和10个B，最后观察下输出顺序
    5.  
    6.           new Thread(){
    7.             @Override
    8.             public void run() {
    9.                 Thread.currentThread().setName("卷王线程");
    10.  
    11.                 for (int i = 0; i < 10; i++) {
    12.                     logger.info(Thread.currentThread().getName() + i);
    13.                 }
    14.             }
    15.         }.start();
    16.  
    17.         new Thread(){
    18.             @Override
    19.             public void run() {
    20.                 Thread.currentThread().setName("阿giao线程");
    21.                 for (int i = 0; i < 10; i++) {
    22.                     logger.info( Thread.currentThread().getName() + i);
    23.                 }
    24.             }
    25.         }.start();
    26.  
    27.     }
    28. }

     多线程的创建方式二：实现Runnable接口

     

    1. public class Demo1 {
    2.     public static final Logger logger  = LoggerFactory.getLogger("Demo1");
    3.     public static void main(String[] args) {
    4.         //需求：创建两个线程，分别用于打印10个A和10个B，最后观察下输出顺序
    5.  
    6.         new Thread(() -> {
    7.             for (int i = 0; i < 10; i++) {
    8.                 logger.info("Agiao = {}", i);
    9.             }
    10.         },"Agiao"){
    11.         }.start();
    12.  
    13.         new Thread(()  -> {
    14.                 for (int i = 0; i < 10; i++) {
    15.                 logger.info("展丫鹏 = {}" , i);
    16.             }
    17.  
    18.         },"展丫鹏"){
    19.         }.start();
    20.     }
    21. }

    多线程的第三种创建方式：利用Callable接口、FutureTask类来实现

     

    1. public class Demo1 {
    2.  
    3.     public static final Logger logger  = LoggerFactory.getLogger("Demo1");
    4.     public static void main(String[] args) throws ExecutionException, InterruptedException {
    5.         //需求：启动两个子线程，分别计算100之内的奇数的和和偶数的和，然后在主线程中再做个汇总，得到总和
    6.  
    7.         //2.创建任务类对象
    8.         OddCallable oddCallable = new OddCallable();
    9.         EvenCallable evenCallable = new EvenCallable();
    10.  
    11.         //3.创建未来任务的对象,可以获取线程执行的结果
    12.         FutureTask integerFutureTask1 = new FutureTask<>(oddCallable);
    13.         FutureTask integerFutureTask2 = new FutureTask<>(evenCallable);
    14.  
    15.         //4.创建线程类
    16.         Thread thread1 = new Thread(integerFutureTask1,"计算奇数");
    17.         Thread thread2 = new Thread(integerFutureTask2,"计算偶数");
    18.  
    19.         //5.启动线程
    20.         thread1.start();
    21.         thread2.start();
    22.  
    23.         //6.从FutureTask对象中获取线程执行结果
    24.         //假设结果还没有算出来,线程会在此等待
    25.         Integer oddSum = integerFutureTask1.get();
    26.         Integer evenSum = integerFutureTask2.get();
    27.  
    28.         logger.info("{}",oddSum + evenSum);
    29.     }
    30.  
    31. }
    32.  
    33. class OddCallable implements Callable{
    34.  
    35.     @Override
    36.     public Integer call() throws Exception {
    37.  
    38.         int sum = 0;
    39.         for (int i = 1; i <= 100; i+=2) {
    40.  
    41.             sum += i;
    42.         }
    43.  
    44.         return sum;
    45.     }
    46. }
    47.  
    48. class EvenCallable implements Callable{
    49.  
    50.     @Override
    51.     public Integer call() throws Exception {
    52.  
    53.         int sum = 0;
    54.         for (int i = 0; i <= 100; i+=2) {
    55.  
    56.             sum += i;
    57.         }
    58.  
    59.         return sum;
    60.     }
    61. }

    请对对比说一下三种线程的创建方式，和不同点？ 

     

     

  • 相关阅读:
    Python Selenium Headless：以 Headless 模式打开 Chrome 浏览器
    R语言kaggle 游戏数据探索与可视化
    字符串压缩（三）之短字符串压缩
    vue 02
    一款云渗透工具 - Sea Moon
    【LeetCode热题100】【图论】岛屿数量
    php获取客户端ip地址及ip所在国家、省份、城市、县区
    go 这样做就是python
    C++:C++11 和 设计模式
    【学习笔记】倍增 + 二分
  • 原文地址：https://blog.csdn.net/m0_60388241/article/details/134042222