day16【字节流、字符流、Properties】

最新推荐文章于 2022-05-03 19:13:30 发布
最新推荐文章于 2022-05-03 19:13:30 发布
阅读量310 收藏 2
点赞数
文章标签： java 字符串 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46690280/article/details/106001191
版权

【字节流、字符流、Properties】

第一章 字符流

当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。

1.1字符输入流【Reader】

字符输入流Reader类的概述

java.io.Reader抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。

字符输入流Reader类的常用方法

  • public void close() ：关闭此流并释放与此流相关联的任何系统资源。
  • public int read()： 从输入流读取一个字符。
  • public int read(char[] cbuf)： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。

1.2FileReader类

FileReader类的概述

java.io.FileReader类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

FileReader类的构造方法

  • FileReader(File file)： 创建一个新的 FileReader ，给定要读取的File对象。
  • FileReader(String fileName)： 创建一个新的 FileReader ，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径。类似于FileInputStream 。

  • 构造举例，代码如下：
public class FileReaderConstructor throws IOException{
    public static void main(String[] args) {
   	 	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileReader fr = new FileReader(file);
      
        // 使用文件名称创建流对象
        FileReader fr = new FileReader("b.txt");
    }
}

FileReader类读取数据

  1. 读取字符：read方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回-1，循环读取，代码使用演示：
public class FRRead {
    public static void main(String[] args) throws IOException {
      	// 使用文件名称创建流对象
       	FileReader fr = new FileReader("read.txt");
      	// 定义变量，保存数据
        int b ；
        // 循环读取
        while ((b = fr.read())!=-1) {
            System.out.println((char)b);
        }
		// 关闭资源
        fr.close();
    }
}
输出结果：
黑
马
程
序
员

小贴士：虽然读取了一个字符，但是会自动提升为int类型。

  1. 使用字符数组读取：read(char[] cbuf)，每次读取多个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回-1 ，代码使用演示：
public class FRRead {
    public static void main(String[] args) throws IOException {
      	// 使用文件名称创建流对象
       	FileReader fr = new FileReader("read.txt");
      	// 定义变量，保存有效字符个数
        int len ；
        // 定义字符数组，作为装字符数据的容器
         char[] cbuf = new char[2];
        // 循环读取
        while ((len = fr.read(cbuf))!=-1) {
            System.out.println(new String(cbuf));
        }
		// 关闭资源
        fr.close();
    }
}
输出结果：
黑马
程序
员序

获取有效的字符改进，代码使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException {
      	// 使用文件名称创建流对象
       	FileReader fr = new FileReader("read.txt");
      	// 定义变量，保存有效字符个数
        int len ；
        // 定义字符数组，作为装字符数据的容器
        char[] cbuf = new char[2];
        // 循环读取
        while ((len = fr.read(cbuf))!=-1) {
            System.out.println(new String(cbuf,0,len));
        }
    	// 关闭资源
        fr.close();
    }
}

输出结果：
黑马
程序
员

1.3字符输出流【Writer】

字符输出流Writer类的概述

java.io.Writer抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。

字符输出流Writer类的常用方法

  • public abstract void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
  • public abstract void flush() ：刷新此输出流并强制任何缓冲的输出字符被写出。
  • public void write(int c) ：写出一个字符。
  • public void write(char[] cbuf)：将 b.length字符从指定的字符数组写出此输出流。
  • public abstract void write(char[] b, int off, int len) ：从指定的字符数组写出 len字符，从偏移量 off开始输出到此输出流。
  • public void write(String str) ：写出一个字符串。
  • public void write(String str,int off,int len) ：写出一个字符串的一部分。

1.4FileWriter类

FileWriter类的概述

java.io.FileWriter类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

FileWriter类的构造方法

  • FileWriter(File file)： 创建一个新的 FileWriter，给定要读取的File对象。
  • FileWriter(String fileName)： 创建一个新的 FileWriter，给定要读取的文件的名称。
  • FileWriter(File file,boolean append)： 创建一个新的 FileWriter，给定要读取的File对象。
  • FileWriter(String fileName,boolean append)： 创建一个新的 FileWriter，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径，类似于FileOutputStream。

  • 构造举例，代码如下：
public class FileWriterConstructor {
    public static void main(String[] args) throws IOException {
   	 	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileWriter fw = new FileWriter(file);
      
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("b.txt");
    }
}

FileWriter类写出数据

写出字符：write(int b) 方法，每次可以写出一个字符数据，代码使用演示：

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");     
      	// 写出数据
      	fw.write(97); // 写出第1个字符
      	fw.write('b'); // 写出第2个字符
      	fw.write('C'); // 写出第3个字符
      	fw.write(30000); // 写出第4个字符，中文编码表中30000对应一个汉字。
      
      	/*
        【注意】关闭资源时,与FileOutputStream不同。
      	 如果不关闭,数据只是保存到缓冲区，并未保存到文件。
        */
        // fw.close();
    }
}
输出结果：
abC田

小贴士：

  1. 虽然参数为int类型四个字节，但是只会保留一个字符的信息写出。
  2. 未调用close方法，数据只是保存到了缓冲区，并未写出到文件中。
  1. 写出字符数组 ：write(char[] cbuf) 和 write(char[] cbuf, int off, int len) ，每次可以写出字符数组中的数据，用法类似FileOutputStream，代码使用演示：
public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");     
      	// 字符串转换为字节数组
      	char[] chars = "黑马程序员".toCharArray();
      
      	// 写出字符数组
      	fw.write(chars); // 黑马程序员
        
		// 写出从索引2开始，2个字节。索引2是'程'，两个字节，也就是'程序'。
        fw.write(b,2,2); // 程序
      
      	// 关闭资源
        fos.close();
    }
}
  1. 写出字符串：write(String str) 和 write(String str, int off, int len) ，每次可以写出字符串中的数据，更为方便，代码使用演示：
public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");     
      	// 字符串
      	String msg = "黑马程序员";
      
      	// 写出字符数组
      	fw.write(msg); //黑马程序员
      
		// 写出从索引2开始，2个字节。索引2是'程'，两个字节，也就是'程序'。
        fw.write(msg,2,2);	// 程序
      	
        // 关闭资源
        fos.close();
    }
}
  1. 续写和换行：操作类似于FileOutputStream。
public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象，可以续写数据
        FileWriter fw = new FileWriter("fw.txt"，true);     
      	// 写出字符串
        fw.write("黑马");
      	// 写出换行
      	fw.write("\r\n");
      	// 写出字符串
  		fw.write("程序员");
      	// 关闭资源
        fw.close();
    }
}
输出结果:
黑马
程序员

小贴士：字符流，只能操作文本文件，不能操作图片，视频等非文本文件。

当我们单纯读或者写文本文件时 使用字符流 其他情况使用字节流

关闭和刷新

因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要flush 方法了。

  • flush ：刷新缓冲区，流对象可以继续使用。
  • close ：关闭流，释放系统资源。关闭前会刷新缓冲区。

代码使用演示：

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");
        // 写出数据，通过flush
        fw.write('刷'); // 写出第1个字符
        fw.flush();
        fw.write('新'); // 继续写出第2个字符，写出成功
        fw.flush();
      
      	// 写出数据，通过close
        fw.write('关'); // 写出第1个字符
        fw.close();
        fw.write('闭'); // 继续写出第2个字符,【报错】java.io.IOException: Stream closed
        fw.close();
    }
}

小贴士：即便是flush方法写出了数据，操作的最后还是要调用close方法，释放系统资源。

第二章 IO资源的处理

2.1JDK7前处理

之前的入门练习，我们一直把异常抛出，而实际开发中并不能这样处理，建议使用try...catch...finally 代码块，处理异常部分，代码使用演示：

public class HandleException1 {
    public static void main(String[] args) {
      	// 声明变量
        FileWriter fw = null;
        try {
            //创建流对象
            fw = new FileWriter("fw.txt");
            // 写出数据
            fw.write("黑马程序员"); //黑马程序员
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fw != null) {
                    fw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2.2 JDK7的处理

还可以使用JDK7优化后的try-with-resource 语句，该语句确保了每个资源在语句结束时关闭。所谓的资源（resource）是指在程序完成后，必须关闭的对象。

格式：

try (创建流对象语句，如果多个,使用';'隔开) {
	// 读写数据
} catch (IOException e) {
	e.printStackTrace();
}

代码使用演示：

public class HandleException2 {
    public static void main(String[] args) {
      	// 创建流对象
        try ( FileWriter fw = new FileWriter("fw.txt"); ) {
            // 写出数据
            fw.write("黑马程序员"); //黑马程序员
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

第三章 属性集

3.1 Properties类

Properties类的概述

java.util.Properties 继承于Hashtable ，来表示一个持久的属性集。它使用键值结构存储数据，每个键及其对应值都是一个字符串。该类也被许多Java类使用，比如获取系统属性时，System.getProperties 方法就是返回一个Properties对象。

Properties类的构造方法

  • public Properties() :创建一个空的属性列表。

Properties类存储方法

  • public Object setProperty(String key, String value) ： 保存一对属性。
  • public String getProperty(String key) ：使用此属性列表中指定的键搜索属性值。
  • public Set<String> stringPropertyNames() ：所有键的名称的集合。
public class ProDemo {
    public static void main(String[] args) throws FileNotFoundException {
        // 创建属性集对象
        Properties properties = new Properties();
        // 添加键值对元素
        properties.setProperty("filename", "a.txt");
        properties.setProperty("length", "209385038");
        properties.setProperty("location", "D:\\a.txt");
        // 打印属性集对象
        System.out.println(properties);
        // 通过键,获取属性值
        System.out.println(properties.getProperty("filename"));
        System.out.println(properties.getProperty("length"));
        System.out.println(properties.getProperty("location"));

        // 遍历属性集,获取所有键的集合
        Set<String> strings = properties.stringPropertyNames();
        // 打印键值对
        for (String key : strings ) {
          	System.out.println(key+" -- "+properties.getProperty(key));
        }
    }
}
输出结果：
{filename=a.txt, length=209385038, location=D:\a.txt}
a.txt
209385038
D:\a.txt
filename -- a.txt
length -- 209385038
location -- D:\a.txt

Properties类与流相关的方法

  • public void load(InputStream inStream)： 从字节输入流中读取键值对。

参数中使用了字节输入流，通过流对象，可以关联到某文件上，这样就能够加载文本中的数据了。文本数据格式:

filename=a.txt
length=209385038
location=D:\a.txt

加载代码演示：

public class ProDemo2 {
    public static void main(String[] args) throws FileNotFoundException {
        // 创建属性集对象
        Properties pro = new Properties();
        // 加载文本中信息到属性集
        pro.load(new FileInputStream("read.txt"));
        // 遍历集合并打印
        Set<String> strings = pro.stringPropertyNames();
        for (String key : strings ) {
          	System.out.println(key+" -- "+pro.getProperty(key));
        }
     }
}
输出结果：
filename -- a.txt
length -- 209385038
location -- D:\a.txt

小贴士：文本中的数据，必须是键值对形式，可以使用空格、等号、冒号等符号分隔。

第四章 ResourceBundle工具类

ResourceBundle类的介绍

前面我们学习了Properties工具类，它能够读取资源文件，当资源文件是以.properties结尾的文件时，我们可以使用JDK提供的另外一个工具类ResourceBundle来对文件进行读取，使得操作更加简单。

java.util.ResourceBundle它是一个抽象类，我们可以使用它的子类PropertyResourceBundle来读取以.properties结尾的配置文件。

ResourceBundle类对象的创建

在ResourceBundle类中提供了一个静态方法，用于获得它的子类对象(抽象类不能创建对象！)。

// 使用指定的基本名称，默认语言环境和调用者的类加载器获取资源包。  
static ResourceBundle getBundle(String baseName);

注意：

​ ①properties配置文件需要放置在类的根路径src下面

​ ②给定参数只需要配置文件的名称，不要扩展名。

在这里插入图片描述

public class TestResourceBundle {
    public static void main(String[] args) {
        // 获得ResourceBundle类的对象(properties文件要放置在src目录下，给定参数只要文件名称，不要扩展名！)
        ResourceBundle bundle = ResourceBundle.getBundle("data");// 父类引用指向子类对象(多态)
        System.out.println(bundle);
    }
}

在这里插入图片描述
ResourceBundle读取配置文件操作

ResourceBundle类提供了一个getString(String key)方法用于读取配置文件中指定key的值。

String getString(String key) 从此资源束或其父项之一获取给定密钥的字符串。

代码演示(数据在上图中)：

public class TestResourceBundle {
    public static void main(String[] args) {
        // 获得ResourceBundle类的对象(properties文件要放置在src目录下，给定参数只要文件名称，不要扩展名)
        ResourceBundle bundle = ResourceBundle.getBundle("data");
        System.out.println(bundle);

        // 读取指定key(username)的值
        String username = bundle.getString("username");
        System.out.println(username); // 张三

        // 读取指定key(password)的值
        String password = bundle.getString("password");
        System.out.println(password); // itheima
    }
}

运行结果：
在这里插入图片描述

第五章 练习模块

题目一

​ 1. 请定义一个Student类，属性：姓名、性别、年龄、分数

​ 无参、全参构造方法

​ get/set方法

​ 2. 定义测试类，编写main()方法：

​ //1.定义一个集合

​ List stuList = new ArrayList<>();

​ stuList.add(new Student(“张三”,”男”,20,88);

​ stuList.add(new Student(“李四”,”女”,19,99);

​ 3. 遍历这个集合，将每个Student对象中的数据按以下格式写到项目根目录下

​ 的student.txt中：

​ 张三,男,20,88

​ 李四,女,19,99

package com.day16;

import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

public class Task1_3 {
    public static void main(String[] args) throws IOException {
        ArrayList<Student> studentArrayList = new ArrayList<>();
        studentArrayList.add(new Student("张三","男",20,88));
        studentArrayList.add(new Student("李四","女",19,99));
        FileWriter fw  = new FileWriter("Task1_3.txt");
        String stu1 = studentArrayList.get(0).getName()+","+studentArrayList.get(0).getGender()+","+studentArrayList.get(0).getAge()+","+studentArrayList.get(0).getScore();
        String stu2 = studentArrayList.get(1).getName()+","+studentArrayList.get(1).getGender()+","+studentArrayList.get(1).getAge()+","+studentArrayList.get(1).getScore();
        fw.write(stu1);
        fw.write(System.getProperty("line.separator"));//为了程序能在不同操作系统运行
        fw.write(stu2);
        fw.write(System.getProperty("line.separator"));//为了程序能在不同操作系统运行
        fw.flush();//刷新缓存

        fw.close();



    }
}
class Student {
    private String name;
    private String gender;
    private int age;
    private int score;

    public Student() {
    }

    public Student(String name, String gender, int age, int score) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.score = score;
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }
}

题目二

​ 请编写程序，定义一个Properties对象，存储以下内容：

​ Properties pro = new Properties();

​ pro.setProperty(“品名”,”Iphone11 Pro Max”);

​ pro.setProperty(“颜色”,”暗夜绿”);

​ pro.setProperty(“存储容量”,”256G”);

​ pro.setProperty(“价格”,”10899”);

​ //请将上述内容写入到文件：”test2_1.txt”中

package com.day16;

import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

public class Task3_1 {
    public static void main(String[] args) {
        Properties pro = new Properties();
        pro.setProperty("品名","Iphone11 Pro Max");
        pro.setProperty("颜色","暗夜绿");
        pro.setProperty("存储容量","256G");
        pro.setProperty("价格","10899");

        try (FileWriter fw = new FileWriter("Task3_1.txt")) {
            Set<String> stringSet = pro.stringPropertyNames();
            for (String key : stringSet) {
                String str = key+"=" + pro.getProperty(key);
                fw.write(str);
                fw.write(System.lineSeparator());
                fw.flush();
            }

        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

题目三

请编写程序，定义一个Properties对象，将文件”test2_1.txt”的内容读取到Properties对象中，遍历，并打印每个键值对。

package com.day16;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

public class Task3_2 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("Task3_1.txt"));
        Properties pro = new Properties();
        String line;
        while ((line = br.readLine())!=null){
            String[] str = line.split("=");
            pro.setProperty(str[0],str[1]);
        }
        Set<String> keySet = pro.stringPropertyNames();
        for (String key : keySet) {
            System.out.println(key+"="+pro.getProperty(key));
        }
        br.close();
    }
}
Ybb_studyRecord
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Properties 容器类 io 流 字节流 文件拷贝 字符流 对象流 四大内置核心函数式接口 方法引用
Heiko_O的博客
01-17 141
Properties Properties 容器类 Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。 public static void main(String[] args) throws IOException { Properties pro=new Properties(); pro.put("123", "haha"); pro....
day14作业io流下
qq_25534101的博客
09-19 691
一、基础案例 1．训练案例1 1.1．训练描述：【InputStreamReader OutputStreamWriter】 一、需求说明：以UTF-8编码的格式写出 “你好”到文件中, 并将数据正确的读取出来打印在控制台 1.2．操作步骤描述 1．创建OutputStreamWriter关联文件, 并在构造方法中指定编码表 2．调用writer方法写出字符串 3．创建InputStreamReader关联文件, 并在构造方法中指定码表进行读取 4. 调用read方法读取数据, 打印在控制台 public
properties和字符流（还有字节流）
weixin_41908066的博客
05-03 245
字节流与字符流与Properties结合
weixin_49392733的博客
03-04 241
import java.io.*; import java.util.Properties; public class PropertiesDemo { public static void main(String[] args)throws IOException { //myStore(); // myLoad(); //myStoreTwo(); myLoadTwo(); } private static voi.
2021-03-31
weixin_56180591的博客
03-31 163
【字符流】 ## 定义集合，添加对象信息，遍历集合将每个对象中的数据按以下格式写到项目根目录下的student.txt中： 属性：姓名、性别、年龄、分数 张三,男,20,88 李四,女,19,99 定义一个Student类，定义属性，无参、有参、get、set构造方法 package zuoye.Five; //创建Student类 public class Student { //私有化属性 private String name; private String sex;
day20_字节流、字符流、属性集.pdf
11-02
day20_字节流、字符流、属性集.pdf
day09_字节流、字符流2
08-08
day09_字节流、字符流2
day09-字节缓冲流&字符流
06-10
day09-字节缓冲流&字符流
day09_字节流、字符流-答案1
08-08
利用字节输出流对象往C盘下c.txt文件输出5句：”i love java”答案操作步骤:利用两个参数的构造方法创建字节输出流对象，参数一指定文件路径，参数二指
day09-字节缓冲流&字符流1
08-04
1.1字节缓冲流构造方法【应用】 1.2字节流复制视频【应用】 2.1为什么会出现字符流【理解】 2.2编码表【理解】 2.3字符串中的编码解码问题【应用】 2
Java 字节流&字符流&Properties集合习题答案
kai46385076的专栏
07-13 5057
基础题 练习一:字节输出流写出字节数据 描述:利用字节输出流一次写一个字节的方式，向D盘的a.txt文件输出字符‘a’。 答案 操作步骤: 1.创建字节输出流FileOutputStream对象并指定文件路径。 2.调用字节输出流的write(int byte)方法写出数据 代码: public class Test01_01 { public static void main(String[] ...
读Properties文件和往Properties文件里面写内容
小灰的博客
06-07 7681
1.读取配置文件是一个很常用的操作；   读取很简单： public static String getProperty(String key) { String value = ""; //第一步是取得一个Properties对象 Properties props = new Properties(); //第二步是取得配置文件的输入流 InputStream is = Prop
Java集合（十一）综合练习
qq_39033580的博客
05-11 502
练习1：键盘录入三个学生信息（学号，姓名，年龄，居住地）存入集合，然后遍历集合把每一个学生信息存入文本文件（每一个学生信息为一行数据，自己定义分割标记） 分析1、定义学生类 2.创建集合对象 3.写方法实现键盘录入学生信息，并把学生对象作为元素添加到集合 4.创建输出缓冲流对象 5，遍历集合得到每一个学生信息，并把学生信息按一定的格式写入文本文件 例 ：xuexi001,李四，30，北京 6.释放资源 ArrayList<Student> arr=new ArrayList<Student
List集合存储学生对象并遍历
LeoZuosj的博客
05-19 4564
List集合的特有遍历功能 A：案例演示 通过size()和get()方法结合使用遍历。 List list = new ArrayList(); list.add(new Student("张三", 18)); list.add(new Student("李四", 18)); list.add(new Student("王五", 18)); list.add(new S...
Spring加载properties文件的两种方式
热门推荐
武哥聊编程
05-10 18万+
我的个人博客站点：http://www.itcodai.com         在项目中如果有些参数经常需要修改，或者后期可能需要修改，那我们最好把这些参数放到properties文件中，源代码中读取properties里面的配置，这样后期只需要改动properties文件即可，不需要修改源代码，这样更加方便。在Spring中也可以这么做，而且Spring有两种加载properties文件的方式...
Properties对象
qq_45072449的博客
03-28 869
property复数形式，属性的意思。属性名 = 属性值 key=value。 位于java.util包 理解： 1.属性集合对象 2.属于Map中的一员，继承Hashtable，可以直接使用map的方法 3.key和value都只能是字符串。 4.可以读取流中数据也可以将数据保存到流中 5.持久化的属性集对象 构造方法： Properties()：空列表 Properties(Properties prop)：带有指定内容的列表 按照map中的方式操作： 以上方式不建议使用，因为属性集对象要求key
将properties内容存到java 中的map对象中
weixin_44446774的博客
06-09 665
/* * 将properties中的内容转换成map * 可以将filepath抽取成参数 * */ public class ProExec { private static final Logger logger = LoggerFactory.getLogger(ProExec.class); public static void main(String[] args) { String filepath = "/config.properties";
黑马程序员-第二十一天（Properties类）
darkleo的专栏
03-14 540
---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------            一，  Properties对象 Properties是Hashtable的子类，也就是说它具备集合的特点，而且它里面存储的键值对者是字符串，不需要泛型。是集合中和IO技术相结合的集合容器。 该对象的特点：可
空中交通流流量预测代码
最新发布
06-11
空中交通流流量预测是一项复杂的任务，需要考虑多个因素，比如天气、航班计划、航空器性能等。下面是一个简单的空中交通流流量预测代码示例，用于预测未来一段时间内的航班流量： ```python import numpy as np ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值