IO流及Properties集合

最新推荐文章于 2022-04-13 15:39:04 发布
最新推荐文章于 2022-04-13 15:39:04 发布
阅读量185 收藏
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53264704/article/details/120736739
版权

目录

File类

1.File类概述以及构造方法

  概述

  构造方法

File(String pathname)

File(String parent, String child)

File(File parent, String child)

2.File类创建功能

public boolean createNewFile()

public boolean mkdir()

public boolean mkdirs()

3.File类判断和获取功能

4.File类删除功能

5.递归遍历目录

IO流

1.概述和分类

概述

分类

2.字节流

1.字节流写数据

字节流写数据的两个小问题

2.字节流读数据

3.字节缓冲流

4.字节流和字节缓冲流复制视频

3.字符流

1.为什么会出现字符流

2.编码表

3.字符串中的编码解码问题

4.字符流中的编码解码问题

5.字符流写数据

6.字符流读数据

7.字符缓冲流

8.字符缓冲流特有功能

IO小结图片

 文件与集合相互转换

1.文件到集合

2.集合到文件

3.文件到集合（改）

4.集合到文件（改）

Properties类

1.Properties作为Map集合的使用

2.Properties作为Map集合的特有方法

3.Properties和IO流相结合的方法

File类

1.File类概述以及构造方法

  概述

  • 它是文件和目录路径名的抽象表示

  • 文件和目录是可以通过File封装成对象的

  • 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的

  构造方法

方法名说明
File(String pathname)通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
File(String parent, String child)从父路径名字符串和子路径名字符串创建新的 File实例
File(File parent, String child)从父抽象路径名和子路径名字符串创建新的 File实例

实例

File(String pathname)

File f1 = new File("E:\\itcast\\java.txt");

File(String parent, String child)

File f2 = new File("E:\\itcast","java.txt");

File(File parent, String child)

 File f3 = new File("E:\\itcast");
 File f4 = new File(f3,"java.txt");

2.File类创建功能

方法名说明
public boolean createNewFile()当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件
public boolean mkdir()创建由此抽象路径名命名的目录
public boolean mkdirs()创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录

public boolean createNewFile()

File f1 = new File("E:\\itcast\\java.txt");
f1.createNewFile();

public boolean mkdir()

File f2 = new File("E:\\itcast\\JavaSE");
f2.mkdir();

public boolean mkdirs()

 File f3 = new File("E:\\itcast\\JavaWEB\\HTML");
 System.out.println(f3.mkdirs());

3.File类判断和获取功能

  • 判断功能

    方法名说明
    public boolean isDirectory()测试此抽象路径名表示的File是否为目录
    public boolean isFile()测试此抽象路径名表示的File是否为文件
    public boolean exists()测试此抽象路径名表示的File是否存在

  • 获取功能

    方法名说明
    public String getAbsolutePath()返回此抽象路径名的绝对路径名字符串
    public String getPath()将此抽象路径名转换为路径名字符串
    public String getName()返回由此抽象路径名表示的文件或目录的名称
    public String[] list()返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
    public File[] listFiles()返回此抽象路径名表示的目录中的文件和目录的File对象数组
 File f = new File("myFile\\java.txt");       
 System.out.println(f.isDirectory());
 System.out.println(f.isFile());
 System.out.println(f.exists());
        File f = new File("myFile\\java.txt");
        System.out.println(f.getAbsolutePath());
        System.out.println(f.getPath());
        System.out.println(f.getName());
        System.out.println("--------");
        File f2 = new File("E:\\itcast");

        String[] strArray = f2.list();
        for(String str : strArray) {
            System.out.println(str);
        }
        System.out.println("--------");

        File[] fileArray = f2.listFiles();
        for(File file : fileArray) {
//            System.out.println(file);
//            System.out.println(file.getName());
            if(file.isFile()) {
                System.out.println(file.getName());
            }
        }

4.File类删除功能

方法名说明
public boolean delete()删除由此抽象路径名表示的文件或目录
File f3 = new File("myFile\\itcast");
f3.mkdir();
f3.delete();

5.递归遍历目录

        //根据给定的路径创建一个File对象
//        File srcFile = new File("E:\\itcast");
        File srcFile = new File("E:\\itheima");

        //调用方法
        getAllFilePath(srcFile);
    }

    //定义一个方法，用于获取给定目录下的所有内容，参数为第1步创建的File对象
    public static void getAllFilePath(File srcFile) {
        //获取给定的File目录下所有的文件或者目录的File数组
        File[] fileArray = srcFile.listFiles();
        //遍历该File数组，得到每一个File对象
        if(fileArray != null) {
            for(File file : fileArray) {
                //判断该File对象是否是目录
                if(file.isDirectory()) {
                    //是：递归调用
                    getAllFilePath(file);
                } else {
                    //不是：获取绝对路径输出在控制台
                    System.out.println(file.getAbsolutePath());
                }
            }
        }

IO流

1.概述和分类

概述

  • IO：输入/输出(Input/Output)

  • 流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输

  • IO流就是用来处理设备间数据传输问题的。常见的应用：文件复制；文件上传；文件下载

分类

  • 按照数据的流向

    • 输入流：读数据

    • 输出流：写数据

  • 按照数据类型来分

    • 字节流（如果操作的是图片、视频、音频等二进制文件。优先使用字节流 。 如果不确定文件类型，优先使用字节流。字节流是万能的流  ）

      • 字节输入流

      • 字节输出流

    • 字符流（如果操作的是纯文本文件，优先使用字符流 ）

      • 字符输入流

      • 字符输出流

2.字节流

1.字节流写数据

方法名说明
void write(int b)将指定的字节写入此文件输出流 一次写一个字节数据
void write(byte[] b)将 b.length字节从指定的字节数组写入此文件输出流 一次写一个字节数组数据
void write(byte[] b, int off, int len)将 len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流 一次写一个字节数组的部分数据
FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
fos.write(97); //void write(int b)
byte[] bys = "abcde".getBytes();//        void write(byte[] b)
fos.write(bys);
fos.write(bys,1,3);//void write(byte[] b, int off, int len)
//释放资源
fos.close();

字节流写数据的两个小问题

  • 字节流写数据如何实现换行

    • windows:\r\n

    • linux:\n

    • mac:\r

  • 字节流写数据如何实现追加写入

    • public FileOutputStream(String name,boolean append)

    • 创建文件输出流以指定的名称写入文件。如果第二个参数为true ，则字节将写入文件的末尾而不是开头

//创建字节输出流对象
//        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt",true);

        //写数据
        for (int i = 0; i < 10; i++) {
            fos.write("hello".getBytes());
            fos.write("\r\n".getBytes());
        }

        //释放资源
        fos.close();

2.字节流读数据

FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");
//一次读一个字节
int by;
while ((by=fis.read())!=-1) {
            System.out.print((char)by);
        }
//一次读一个字节数组
byte[] bys = new byte[1024]; //1024及其整数倍
        int len;
        while ((len=fis.read(bys))!=-1) {
            System.out.print(new String(bys,0,len));
        }

        //释放资源
        fis.close();

3.字节缓冲流

方法名说明
BufferedOutputStream(OutputStream out)创建字节缓冲输出流对象
BufferedInputStream(InputStream in)创建字节缓冲输入流对象
//字节缓冲输出流：BufferedOutputStream(OutputStream out)
BufferedOutputStream bos = new BufferedOutputStream(new 				                                       FileOutputStream("myByteStream\\bos.txt"));
bos.write("hello\r\n".getBytes());
        bos.write("world\r\n".getBytes());
        //释放资源
        bos.close();

//字节缓冲输入流：BufferedInputStream(InputStream in)
BufferedInputStream bis = new BufferedInputStream(new                                                          FileInputStream("myByteStream\\bos.txt"));
//一次读取一个字节数据
//        int by;
//        while ((by=bis.read())!=-1) {
//            System.out.print((char)by);
//        }

        //一次读取一个字节数组数据
        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1) {
            System.out.print(new String(bys,0,len));
        }

        //释放资源
        bis.close();

4.字节流和字节缓冲流复制视频

//字节流复制视频
 FileInputStream fis = new FileInputStream("E:\\itcast\\字节流复制图片.avi");
 FileOutputStream fos = new FileOutputStream("myByteStream\\字节流复制图片.avi");
//基本字节流一次读写一个字节
 int by;
        while ((by=fis.read())!=-1) {
            fos.write(by);
        }

        fos.close();
        fis.close();

//基本字节流一次读写一个字节数组
 byte[] bys = new byte[1024];
        int len;
        while ((len=fis.read(bys))!=-1) {
            fos.write(bys,0,len);
        }

        fos.close();
        fis.close();




//字节缓冲流复制视频
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\itcast\\字节流复制图片.avi"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\字节流复制图片.avi"));
//字节缓冲流一次读写一个字节数组
 byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1) {
            bos.write(bys,0,len);
        }

        bos.close();
        bis.close();
//字节缓冲流一次读写一个字节
int by;
        while ((by=bis.read())!=-1) {
            bos.write(by);
        }

        bos.close();
        bis.close();

3.字符流

1.为什么会出现字符流

由于字节流操作中文不是特别的方便，所以Java就提供字符流

字符流 = 字节流 + 编码表

2.编码表

ASCII字符集、GBXXX字符集、UTF-8编码

3.字符串中的编码解码问题

方法名说明
byte[] getBytes()使用平台的默认字符集将该 String编码为一系列字节
byte[] getBytes(String charsetName)使用指定的字符集将该 String编码为一系列字节
String(byte[] bytes)使用平台的默认字符集解码指定的字节数组来创建字符串
String(byte[] bytes, String charsetName)通过指定的字符集解码指定的字节数组来创建字符串
String s = "中国";

byte[] bys = s.getBytes();//byte[] getBytes()

byte[] bys = s.getBytes("UTF-8"); //byte[] getBytes(String charsetName)

String ss = new String(bys);//String(byte[] bytes)

String ss = new String(bys,"UTF-8");//String(byte[] bytes, String charsetName)

4.字符流中的编码解码问题

方法名说明
InputStreamReader(InputStream in)使用默认字符编码创建InputStreamReader对象
InputStreamReader(InputStream in,String chatset)使用指定的字符编码创建InputStreamReader对象
OutputStreamWriter(OutputStream out)使用默认字符编码创建OutputStreamWriter对象
OutputStreamWriter(OutputStream out,String charset)使用指定的字符编码创建OutputStreamWriter对象
//OutputStreamWriter(OutputStream out)使用默认字符编码创建OutputStreamWriter对象
OutputStreamWriter osw = new OutputStreamWriter(new                                             FileOutputStream("myCharStream\\osw.txt"));

//OutputStreamWriter(OutputStream out,String charset)使用指定的字符编码创建OutputStreamWriter对象
OutputStreamWriter osw = new OutputStreamWriter(new                                              FileOutputStream("myCharStream\\osw.txt"),"GBK");
        osw.write("中国");
        osw.close();

//InputStreamReader(InputStream in)使用默认字符编码创建InputStreamReader对象

InputStreamReader isr = new InputStreamReader(new 	                                         FileInputStream("myCharStream\\osw.txt"));
//InputStreamReader(InputStream in,String chatset)使用指定的字符编码创建InputStreamReader对象
InputStreamReader isr = new InputStreamReader(new                                                 FileInputStream("myCharStream\\osw.txt"),"GBK");
        //一次读取一个字符数据
        int ch;
        while ((ch=isr.read())!=-1) {
            System.out.print((char)ch);
        }
        isr.close();

5.字符流写数据

方法名说明
void write(int c)写一个字符
void write(char[] cbuf)写入一个字符数组
void write(char[] cbuf, int off, int len)写入字符数组的一部分
void write(String str)写一个字符串
void write(String str, int off, int len)写一个字符串的一部分
flush()刷新流，之后还可以继续写数据

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"));
//void write(int c)：写一个字符
osw.write(97);

//void writ(char[] cbuf)：写入一个字符数组
char[] chs = {'a', 'b', 'c', 'd', 'e'};
osw.write(chs);

//void write(char[] cbuf, int off, int len)：写入字符数组的一部分
osw.write(chs, 0, chs.length);
osw.write(chs, 1, 3);

//void write(String str)：写一个字符串
osw.write("abcde");

//void write(String str, int off, int len)：写一个字符串的一部分
osw.write("abcde", 1, 3);
//释放资源
osw.close();

6.字符流读数据

方法名说明
int read()一次读一个字符数据
int read(char[] cbuf)一次读一个字符数组数据
InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\ConversionStreamDemo.java"));

//int read()：一次读一个字符数据
int ch;
while ((ch=isr.read())!=-1) {
System.out.print((char)ch);
        }

//int read(char[] cbuf)：一次读一个字符数组数据
char[] chs = new char[1024];
int len;
while ((len = isr.read(chs)) != -1) {
System.out.print(new String(chs, 0, len));
        }

//释放资源
isr.close();

7.字符缓冲流

方法名说明
BufferedWriter(Writer out)创建字符缓冲输出流对象
BufferedReader(Reader in)创建字符缓冲输入流对象
//BufferedWriter(Writer out)
        BufferedWriter bw = new BufferedWriter(new                                                            FileWriter("myCharStream\\bw.txt"));
        bw.write("hello\r\n");
        bw.write("world\r\n");
        bw.close();

//BufferedReader(Reader in)
        BufferedReader br = new BufferedReader(new                                                           FileReader("myCharStream\\bw.txt"));

        //一次读取一个字符数据
//        int ch;
//        while ((ch=br.read())!=-1) {
//            System.out.print((char)ch);
//        }

        //一次读取一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len=br.read(chs))!=-1) {
            System.out.print(new String(chs,0,len));
        }

        br.close();

8.字符缓冲流特有功能

方法介绍

BufferedWriter：

方法名说明
void newLine()写一行行分隔符，行分隔符字符串由系统属性定义

BufferedReader:

方法名说明
String readLine()读一行文字。 结果包含行的内容的字符串，不包括任何行终止字符如果流的结尾已经到达，则为null

//创建字符缓冲输出流
        BufferedWriter bw = new BufferedWriter(new                                                          FileWriter("myCharStream\\bw.txt"));

        //写数据
        for (int i = 0; i < 10; i++) {
            bw.write("hello" + i);
            //bw.write("\r\n");
            bw.newLine();
            bw.flush();
        }

        //释放资源
        bw.close();

        //创建字符缓冲输入流
        BufferedReader br = new BufferedReader(new                                                          FileReader("myCharStream\\bw.txt"));

        String line;
        while ((line=br.readLine())!=null) {
            System.out.println(line);
        }

        br.close();

IO小结图片

 

 文件与集合相互转换

1.文件到集合

//创建ArrayList集合
        ArrayList<String> array = new ArrayList<String>();

        //往集合中存储字符串元素
        array.add("hello");
        array.add("world");
        array.add("java");

        //创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\array.txt"));

        //遍历集合，得到每一个字符串数据
        for(String s : array) {
            //调用字符缓冲输出流对象的方法写数据
            bw.write(s);
            bw.newLine();
            bw.flush();
        }

        //释放资源
        bw.close();

2.集合到文件

//创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\\array.txt"));

        //创建ArrayList集合对象
        ArrayList<String> array = new ArrayList<String>();

        //调用字符缓冲输入流对象的方法读数据
        String line;
        while ((line=br.readLine())!=null) {
            //把读取到的字符串数据存储到集合中
            array.add(line);
        }
        //释放资源
        br.close();
        //遍历集合
        for(String s : array) {
            System.out.println(s);
        }

3.文件到集合（改）

 //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\\students.txt"));

        //创建ArrayList集合对象
        ArrayList<Student> array = new ArrayList<Student>();

        //调用字符缓冲输入流对象的方法读数据
        String line;
        while ((line = br.readLine()) != null) {
            //把读取到的字符串数据用split()进行分割，得到一个字符串数组
            String[] strArray = line.split(",");

            //创建学生对象
            Student s = new Student();
            //把字符串数组中的每一个元素取出来对应的赋值给学生对象的成员变量值
            //itheima001,林青霞,30,西安
            s.setSid(strArray[0]);
            s.setName(strArray[1]);
            s.setAge(Integer.parseInt(strArray[2]));
            s.setAddress(strArray[3]);

            //把学生对象添加到集合
            array.add(s);
        }

        //释放资源
        br.close();

        //遍历集合
        for (Student s : array) {
            System.out.println(s.getSid() + "," + s.getName() + "," + s.getAge() + "," + s.getAddress());
        }

4.集合到文件（改）

//创建ArrayList集合
        ArrayList<Student> array = new ArrayList<Student>();

        //创建学生对象
        Student s1 = new Student("itheima001", "林青霞", 30, "西安");
        Student s2 = new Student("itheima002", "张曼玉", 35, "武汉");
        Student s3 = new Student("itheima003", "王祖贤", 33, "郑州");

        //把学生对象添加到集合中
        array.add(s1);
        array.add(s2);
        array.add(s3);

        //创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\students.txt"));

        //遍历集合，得到每一个学生对象
        for (Student s : array) {
            //把学生对象的数据拼接成指定格式的字符串
            StringBuilder sb = new StringBuilder();
            sb.append(s.getSid()).append(",").append(s.getName()).append(",").append(s.getAge()).append(",").append(s.getAddress());

            //调用字符缓冲输出流对象的方法写数据
            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
        }

        //释放资源
        bw.close();

Properties类

1.Properties作为Map集合的使用

Properties prop = new Properties();

        //存储元素
        prop.put("itheima001", "林青霞");
        prop.put("itheima002", "张曼玉");
        prop.put("itheima003", "王祖贤");

        //遍历集合
        Set<Object> keySet = prop.keySet();
        for (Object key : keySet) {
            Object value = prop.get(key);
            System.out.println(key + "," + value);
        }

2.Properties作为Map集合的特有方法

方法名说明
Object setProperty(String key, String value)设置集合的键和值，都是String类型，底层调用 Hashtable方法 put
String getProperty(String key)使用此属性列表中指定的键搜索属性
Set<String> stringPropertyNames()从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串

//创建集合对象
        Properties prop = new Properties();

        //Object setProperty(String key, String value)：设置集合的键和值，都是String类型，底层调用Hashtable方法put
        prop.setProperty("itheima001", "林青霞");
        /*
            Object setProperty(String key, String value) {
                return put(key, value);
            }

            Object put(Object key, Object value) {
                return map.put(key, value);
            }
         */
        prop.setProperty("itheima002", "张曼玉");
        prop.setProperty("itheima003", "王祖贤");

        //String getProperty(String key)：使用此属性列表中指定的键搜索属性
//        System.out.println(prop.getProperty("itheima001"));
//        System.out.println(prop.getProperty("itheima0011"));

//        System.out.println(prop);

        //Set<String> stringPropertyNames()：从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串
        Set<String> names = prop.stringPropertyNames();
        for (String key : names) {
//            System.out.println(key);
            String value = prop.getProperty(key);
            System.out.println(key + "," + value);
        }

3.Properties和IO流相结合的方法

方法名说明
void load(InputStream inStream)从输入字节流读取属性列表（键和元素对）
void load(Reader reader)从输入字符流读取属性列表（键和元素对）
void store(OutputStream out, String comments)将此属性列表（键和元素对）写入此 Properties表中，以适合于使用 load(InputStream)方法的格式写入输出字节流
void store(Writer writer, String comments)将此属性列表（键和元素对）写入此 Properties表中，以适合使用 load(Reader)方法的格式写入输出字符流

//把集合中的数据保存到文件
//        myStore();

        //把文件中的数据加载到集合
        myLoad();

    }

    private static void myLoad() throws IOException {
        Properties prop = new Properties();

        //void load(Reader reader)：
        FileReader fr = new FileReader("myOtherStream\\fw.txt");
        prop.load(fr);
        fr.close();

        System.out.println(prop);
    }

    private static void myStore() throws IOException {
        Properties prop = new Properties();

        prop.setProperty("itheima001","林青霞");
        prop.setProperty("itheima002","张曼玉");
        prop.setProperty("itheima003","王祖贤");

        //void store(Writer writer, String comments)：
        FileWriter fw = new FileWriter("myOtherStream\\fw.txt");
        prop.store(fw,null);
        fw.close();

Ciiiiiiiiiiiiiiiiii
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
常用IO流以及Properties常用方法
sp1242230746的博客
04-21 137
介绍了IO流的概念、分类、通用操作步骤；主要流的用法；对象序列化和反序列化的方法；Properties常用方法的介绍。
IO流与Properties
zwk19970210的博客
07-25 104
IO流与Properties
Properties和IO流结合
qq_57907966的博客
04-13 136
store(OutputStream out, String comments) 将此 Properties表中的此属性列表（键和元素对）以适合于使用 load(InputStream)方法加载到 Properties表格的格式写入输出流。 private static void mystore() throws IOException{ FileOutputStream fos=new FileOutputStream("E:\\java\\myotherstream2.tx.
Java 读取properties配置文件的方式
Mike的博客
02-18 300
如果你使用的是spring框架那么你就可以继续往下看 因为本方法是基于 spring-core 包中的 PropertiesLoaderUtils 类读取配置 目录结构 配置文件内容 使用 spring-core包下的 PropertiesLoaderUtils 工具类读取配置文件 默认读取 resources目录下的文件 //获取指定配置文件信息 Properties p...
PropertiesLoaderUtils.loadAllProperties()
09-17 2763
spring-core中的方法。可以加载.properties文件。 例如： import java.io.IOException; import java.util.Properties; import org.springframework.core.io.support.PropertiesLoaderUtils; public class Test { public static
day10-IO流&Properties集合1
08-04
在Java编程中，IO流（Input/Output Stream）是用来处理数据输入和输出的重要工具，而Properties集合则是一种用于存储配置信息的关键类。在本案例中，我们探讨的是如何结合使用IO流和Properties集合来实现数据的读写...
Java-IO流/Stream流总结
最新发布
07-12
Java的IO流与Stream流是Java程序中处理输入输出的核心技术。IO流主要分为字节流和字符流，这两种流分别处理二进制数据（如图片、音频等）和文本数据（如ASCII、UTF-8编码的文本）。下面将详细阐述这两个流的分类、...
浅谈java Properties类的使用基础
08-28
* Properties类与IO流结合使用：将properties集合中的属性集写入到文件中实现持久化，或者从.properties配置文件中读取属性集到properties集合中。 四、 Properties类在实际应用中的作用 * 配置文件读写：...
E06_IO复习.pdf
11-02
5. `Properties`集合： `Properties`是Java中的一个类，它继承自`Hashtable`，实现了`Map`接口。`Properties`主要用于存储和加载配置文件，键和值都是字符串类型。它可以与`InputStream`或`Reader`结合使用，用于...
用户管理系统
10-19
在本案例中，系统是用Java编程语言构建的，利用了Java的JDBC（Java Database Connectivity）技术来与数据库进行交互，集合框架来处理数据，以及IO流来实现文件的读写。下面我们将详细探讨这些关键知识点。 1. **...
使用Spring PropertiesLoaderUtils读取properties属性文件
清风专栏
11-12 1030
1.定义属性文件 （resources路径下：server.properties） ##server info server.ip=192.168.59.58 server.port=8080 2.读取 private static String[] getServerInfo(String label){ String[] arr = new String[2]; try { Properties properties = Proper..
Java 读取 .properties 配置文件的几种方式
生命的演绎的博客
03-01 629
Java 开发中，需要将一些易变的配置参数放置再 XML 配置文件或者 properties 配置文件中。然而 XML 配置文件需要通过 DOM 或 SAX 方式解析，而读取 properties 配置文件就比较容易。 介绍几种读取方式： 1、基于ClassLoder读取配置文件 注意：该方式只能读取类路径下的配置文件，有局限但是如果配置文件在类路径下比较方便。 1 Prop...
properties读写
weixin_47520834的博客
10-26 195
第一种方式 Properties properties = new Properties(); try { properties = PropertiesLoaderUtils.loadAllProperties("application.properties"); //遍历取值 Set<Object> objects = properties.keySet(); for (Object object : objects) { //取到参数赋值给
Java基础知识IO流（Properties）
u013951760的博客
05-04 1637
Properties概述Properties类是hashtable的子类，它具备map集合的特点，而且它里面存储的键值对都是字符。Properties 可保存在流中或从流中加载。 Properties是集合和IO技术相结合的集合容器。 Properties 类表示了一个持久的属性集，可以用于键值对形式的配置文件,在加载数据时，需要数据有固定格式：键=值。 比如软件的配置文件：软件的配置信息和数
【IO流】Properties操作配置文件
无心博客
06-04 921
Properties操作配置文件 /** * properties操作配置文件 * * @author xiazhang * @date 2017-6-4 */ public class PropertiesTest { /** * 生成配置文件 */ public static void createIniFile(){ //新建一个propertie
Java基础 -IO流&Properties
上山打卤面的博客
01-19 273
IO流
IO流（七） Properties类
qq_41781316的博客
07-22 353
Properties类介绍 Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。 Properties：Map集合的一种，它是Hashtable集合的子集合,它键与值都是String类型,它是唯一能与IO流结合使用的集合 特点： 1、Hashtable的子类，map集合中的方法都可以用。 2、该集合没有...
Properties和IO流的结合使用
Shaun_Guo的博客
03-22 736
package gxx22;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;import java.io.Reader;import java.io.Writer;import java.util.Properties;//Properties集合的读取与存储：效果是进度的保存和加载/*p...
scala将properties配置文件导入map集合
06-06
你可以使用 Java 标准库中的 Properties 类将配置文件导入到一个可变的 Map 集合中。以下是一个示例： ```scala import java.io.FileReader import java.util.Properties import scala.collection.mutable val ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值