java基础知识回顾之java集合类-Properties集合

/**
 java.lang.Object
   |--java.util.Dictionary<K,V>
      |--java.util.Hashtable<Object,Object>
          |--java.util.Properties

* @author Administrator
 *Properties集合:
         * 特点:
         * 1,该集合中的键和值都是字符串类型。
         * 2,集合中的数据可以保存到流中,或者从流加载
         * 3,表示一个持久的属性集,可以把内存里面的数据保存到硬盘上的文件当中。
         * 4,此类是线程安全的,可以用在多线程当中
         * 通常该集合用于操作以键值对形式存在的配置文件。
         *
         *  存数据:public Object setProperty(String key,String value) 此方法是线程同步的,调用HashTable的put方法
             取数据:public String getProperty(String key):返回属性列表里面建对应的值
             遍历:  public Set<String> stringPropertyNames():返回属性列表中的键key集
                        public Enumeration<?> propertyNames():返回属性列表中所有键的枚举

与IO输入输出流相关的操作:
                    1.public void list(PrintStream out):用于调试
  
                   2.将属性集合中的键值信息写入字节输出流
                   public void store(OutputStream out,String comments)throws IOException
                   将属性集合中的键值信息写入字符输出流
                   public void store(Writer writer,String comments) throws IOException
                 
                   3.从输入”字节流“中读属性列表(键-值)。从文件当中读取信息到输入流中,然后从输入流中读取到集合中
                   public void load(InputStream inStream) throws IOException 从
                   从输入"字符流"中读取属性列表
                   public void load(Reader reader) throws IOException
                   
 */

测试代码如下:

public class PropertiesDemo {

    public static void main(String[]args) throws IOException{
        method_5();

    }
    /**
     *
     * Properties结合的存和取元素,遍历
     */
    public static void method_1(){
        Properties pr = new Properties();
        pr.setProperty("张三", "20");
        pr.setProperty("李四", "23");
        pr.setProperty("王五", "34");
        pr.setProperty("赵六", "45");
        /*//遍历返回一个String<Set>集合遍历,java 1.6后出来的新方法
         //遍历方法1
        Set<String>keys = pr.stringPropertyNames();

        for(String key : keys ){
            String value = pr.getProperty(key);//返回键对应的value值
            System.out.println(key+"="+value);
        }*/

        //遍历2,之前使用的老方法
        Enumeration enumer = pr.propertyNames();
        while(enumer.hasMoreElements()){
            String key = (String) enumer.nextElement();
            String value = pr.getProperty(key);
            System.out.println(key+"="+value);
        }
    }
    /**
     * 返回当前系统属性集合,包括java虚拟机的信息,运行时环境,操作系统信息
     *
     */
    public static void method_2(){
        Properties pro = System.getProperties();//返回值 Properties
        pro.list(System.out);
    }
    /**
     * 将集合中的键-值信息存储到文件当中,使用OutputStream字节流,使用store方法
     *
     */
    public static void method_3(){
        Properties pr = new Properties();
        pr.setProperty("zhangshan", "20");
        pr.setProperty("lisi", "23");
        pr.setProperty("wangwu", "34");
        pr.setProperty("zhaoliu", "45");
        OutputStream os = null;
        try {
             os = new FileOutputStream("info.txt");//持久化到文件当中
             pr.store(os, "info");//将集合中的键-值信息写入到输出流中

        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(os != null){
                try {
                    os.close();//保存到文件当中
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    /**
     * 将资源文件信息读入到读入到输入流中,从输入流中读取属性列表
     * 1.集合中数据来自于一个文件
     * 2.文件中的数据是键值对
     * 3.使用load方法从输入流中读取数据
     *
     * * 读取.properties文件
     * Properties pro = new Properties();
     * 打开classpath下面的指定的配置文件,读取properties配置文件
     * InputStream in = getClass()
     *                             .getClassLoader()
     *                             .getResourceAsStream("log4j.properties");
     * pro.load(in);
     * 然后对Properties集合进行遍历
     */
    public static void method_4(){
        Properties pro = new Properties();
        InputStream in = null;
        try {
            //关联已有的属性文件
            in = new FileInputStream("info.txt");
            pro.load(in);//load到集合中
            pro.list(System.out);//使用调试方法遍历集合,打印到控制台
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                if(in != null){
                    in.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
    /**
     * 如果不存在创建文件,文件存在,读取文件并对已有问价进行修改
     * @throws IOException
     *
     * info.txt文件中:
     * #update zhaoliu
       #Fri Aug 01 11:13:46 CST 2014
       zhangshan=20
       lisi=23
       zhaoliu=30
       wangwu=34
            说明:看store源码知道:
                 注释内容都用#号开头
                 写入当前时间
         key-value对

     */
    public static void method_5() throws IOException{
        File file = new File("info.txt");
        if(!file.exists()){
            file.createNewFile();
        }
        //通过字符输入流对文件进行读取
        Reader fr = new FileReader(file);
        Properties pro = new Properties();
        //从字符输入流中读取文件列表
        pro.load(fr);
        //修改配置文件信息
        pro.setProperty("zhaoliu", "30");

        //写入到字符输出流中,持久化修改后的文件
        Writer fw = new FileWriter(file);
        pro.store(fw, "update zhaoliu");

        //遍历修改后的文件
        Set<String> keys = pro.stringPropertyNames();
        for(String key:keys){
            String value = pro.getProperty(key);
            System.out.println(key+"="+value);
        }
        fr.close();
        fw.close();
    }
}

java基础知识回顾之java集合类-Properties集合

时间: 2024-10-13 10:24:22

java基础知识回顾之java集合类-Properties集合的相关文章

java基础知识回顾之java Thread类学习(八)--java多线程通信等待唤醒机制经典应用(生产者消费者)

 *java多线程--等待唤醒机制:经典的体现"生产者和消费者模型 *对于此模型,应该明确以下几点: *1.生产者仅仅在仓库未满的时候生产,仓库满了则停止生产. *2.消费者仅仅在有产品的时候才能消费,仓空则等待. *3.当消费者发现仓储没有产品可消费的时候,会唤醒等待生产者生产. *4.生产者在生产出可以消费的产品的时候,应该通知等待的消费者去消费. 下面先介绍个简单的生产者消费者例子:本例只适用于两个线程,一个线程生产,一个线程负责消费. 生产一个资源,就得消费一个资源. 代码如下: pub

java基础知识回顾之java Thread类学习(七)--java多线程通信等待唤醒机制(wait和notify,notifyAll)

1.wait和notify,notifyAll: wait和notify,notifyAll是Object类方法,因为等待和唤醒必须是同一个锁,不可以对不同锁中的线程进行唤醒,而锁可以是任意对象,所以可以被任意对象调用的方法,定义在Object基类中. wait()方法:对此对象调用wait方法导致本线程放弃对象锁,让线程处于冻结状态,进入等待线程的线程池当中.wait是指已经进入同步锁的线程,让自己暂时让出同步锁,以便使其他正在等待此锁的线程可以进入同步锁并运行,只有其它线程调用notify方

java基础知识回顾之java Thread类学习(六)--java多线程同步函数用的锁

1.验证同步函数使用的锁----普通方法使用的锁 思路:创建两个线程,同时操作同一个资源,还是用卖票的例子来验证.创建好两个线程t1,t2,t1线程走同步代码块操作tickets,t2,线程走同步函数封装的代码操作tickets,同步代码块中的锁我们可以指定.假设我们事先不知道同步函数用的是什么锁:如果在同步代码块中指定的某个锁(测试)和同步函数用的锁相同,就不会出现线程安全问题,如果锁不相同,就会发生线程安全问题. 看下面的代码:t1线程用的同步锁是obj,t2线程在操作同步函数的资源,假设不

java基础知识回顾之java Thread类学习(五)--java多线程安全问题(锁)同步的前提

这里举个例子讲解,同步synchronized在什么地方加,以及同步的前提: * 1.必须要有两个以上的线程,才需要同步. * 2.必须是多个线程使用同一个锁. * 3.必须保证同步中只能有一个线程在运行,锁加在哪一块代码 那么我们要思考的地方有:1.知道我们写的哪些是多线程代码 2.明确共享数据 3.明确多线程运行的代码中哪些语句是操作共享数据的.. 4.要确保使用同一个锁. 下面的代码:需求:两个存户分别往银行存钱,每次村100块,分三次存完. class bank{ private int

java基础知识回顾之---java String final类之intern方法

public class StringObjectDemo { /** * @param args */ public static void main(String[] args) { String hello = "Hello", lo = "lo"; System.out.print((hello == "Hello") + " ");//true System.out.print((Other.hello == hel

java基础知识回顾之---java String final类普通方法的应用之“按照字节截取字符串”

/*需求:在java中,字符串“abcd”与字符串“ab你好”的长度是一样,都是四个字符.但对应的字节数不同,一个汉字占两个字节.定义一个方法,按照最大的字节数来取子串.如:对于“ab你好”,如果取三个字节,那么子串就是ab与“你”字的半个,那么半个就要舍弃.如果去四个字节就是“ab你”,取五个字节还是“ab你”.*/ 代码:其实是一个解码和编码的问题,要明白UTF-8码表和GBK码表的区别,UTF-8中用三个字节代表一个汉字,GBK使用2个字节代表一个汉字. 且在码表中都是用数字存放这些汉字.

java基础知识回顾之---java String final类 容易混淆的java String常量池内存分析

/** *   栈(Stack) :存放基本类型的变量数据和对象的引用,但对象本身不存放在栈中,而是存放在堆(new 出来的对象)或者常量池中(字符串常量对象存放  在常量池中). 堆(heap):存放所有new出来的对象. *   静态存储:存放静态成员(static定义的). 常量池(constant pool):在堆中分配出来的一块存储区域,存放储显式的String常量和基本类型常量(float.int等).另外,可以存储不经常改变的东西 *                       p

java基础知识回顾之java Thread类学习(四)--java多线程安全问题(锁)

上一节售票系统中我们发现,打印出了错票,0,-1,出现了多线程安全问题.我们分析为什么会发生多线程安全问题? 看下面线程的主要代码: @Override public void run() { // TODO Auto-generated method stub while(true){ if(ticket > 0){//当线程0被调起的时候,当执行到这条判断语句的时候,线程1被调起抢了CPU资源,线程0进入冻结状态. try { Thread.sleep(100);//中断当前活跃的线程,或者

java基础知识回顾之java Thread类学习(把)--java.util.concurrent.locks(JDK1.5)与synchronized异同讲解

看API文档介绍几个方法:  JDK1.5中提供了多线程的升级解决方案: 特点: 1.将同步synchronized显示的替换成Lock                    2.接口Condition:Condition替代了Object监视器方法(wait.notify.notifyAll),分别替换成了await(),signal() (唤醒一个等待线               程),signalAll() 唤醒多个线程.一个锁可以绑定多个condition对象,可以对应好几组wait,