精华内容
下载资源
问答
  • Properties:属性集合类,是一个可以和IO流结合使用的集合类 Properties:可保存在流中或从流中加载,属性列表中每个键及其对应值都是一个字符串 是Hashtable的子类,说明是一个Map集合 此集合没有泛型 1.使用...

    Properties:属性集合类,是一个可以和IO流结合使用的集合类
    Properties:可保存在流中或从流中加载,属性列表中每个键及其对应值都是一个字符串
    是Hashtable的子类,说明是一个Map集合
    此集合没有泛型

    1.使用Hashtable的功能玩一下:

    
    public class PropertiesDemo {
        public static void main(String[] args) {
            Properties pr=new Properties();
    
            pr.put("01","hello");
            pr.put("02","world");
    
            System.out.println(pr);
    
            Set<Object> set=pr.keySet();
            for(Object key:set){
                Object value=pr.get(key);
                System.out.println(key+"="+value);
            }
    
        }
    }
    
    

    结果:
    {01=hello,02=world}
    01=hello
    02=world .

    2.特有功能:

    *public Object setProperty​(String key, String value)//添加元素

    • public String getProperty​(String key)//获取元素
    • public Set stringPropertyNames​()//获取所有键的集合

    代码测试:

    
    public class PropertiesDemo2 {
        public static void main(String[] args) {
            Properties pr=new Properties();
    
            pr.setProperty("01","hello");
            pr.setProperty("02","world");
    
            Set<String> keys=pr.stringPropertyNames();
            for(String key:keys){
                String value =pr.getProperty(key);
                System.out.println(key+"="+value);
            }
        }
    }
    
    

    结果:
    01=hello
    02=world

    2.1特有功能:

    • public void load​(Reader reader) //从文件读取数据到集合
    • public void store​(Writer writer, String comments) //把集合中的数据写入文件
    
    public class IoPropertiesDemo {
        public static void main(String[] args) throws IOException {
        	//加载
            load();
    		//写入
            Store();
    
        }
    
        private static void Store() throws IOException{
            Properties pr=new Properties();
            pr.setProperty("01","蝇");
            pr.setProperty("02","蝇");
            pr.setProperty("03","蝇");
    
            Writer w=new FileWriter("t.txt");
            //将集合的元素以键值对形式存储到文件
            pr.store(w,"null");
            w.close();
        }
    
        private static void load() throws IOException { //文件的数据必须是键值对形式
            Reader r = new FileReader("t.txt");
    
            Properties pr = new Properties();
            //加载t.txt文件到集合
            pr.load(r);
            r.close();
    
            System.out.println(pr);
        }
    }
    
    
    展开全文
  • ** 1、Properties简介:** java.util.Properties集合 extends HashTable<k,V> implements Map<k,v> Properties 表示了一个... Properties集合是一个唯一和IO流结合的集合 可以使用Propeertie...

    ** 1、Properties简介:**

    • java.util.Properties集合 extends HashTable<k,V> implements Map<k,v>
    •  Properties 类表示了一个持久的属性集。Properties可保存在流中或从流中加载。
      
    •  Properties集合是一个唯一和IO流相结合的集合
      
    •  可以使用Propeerties集合中的方法store,把集合中的历史数据,持久化到硬盘中,
      
    •  也可以使用Properties集合中的方法load,把硬盘中的文件中的数据(<k,v>)读取到集合中使用
      
    • 属性列表中的每个键及其对应值都是一个字符串。
    • Properties集合是一个双列集合,key和value默认都是字符串

    ** 2、使用Properties存储数据,**

    • Properties集合中特有的处理数据的方法;
    • Object setProperty(String key,String value) : 设置数据,默认键 值都是字符串类型相当于Map集合中的put方法;
    • String getProperty(String key) : 通过key获取集合中的值,键和键对应的值都是字符串类型,相当于Map集合中的get方法
    • Set stringPropertyNames() : 获取集合中的所有键的集,相当于Map集合中的keySet方法

    代码实现:

     //创建Properties结合
            Properties p = new Properties();
            //添加数据
            p.setProperty("刘女士","25岁");
            p.setProperty("张先生","37岁");
            p.setProperty("王小姐","21岁");
            p.setProperty("古先生","20岁");
            p.setProperty("钱大叔","50岁");
    
            //获取集合的键的集
            Set<String> set = p.stringPropertyNames();
    
            //遍历获取键对应的value值
            for ( String s: set) {
                System.out.println(s + " 今年 "+ p.getProperty(s));
            }
    
    • 3、使用字节/字符流对象和Properties集合,持久化数据到磁盘文件中
    • 1、创建一个Properties集合并添加数据;
    • 2、创建一个字节/字符流输出对象,指定输出到的文件;
    • 3、Properties调用store(… , …)方法,将字节流/字符流对象作为参数传进去;
    • 4、释放资源。

    Propertis集合数据持久化存储代码实现:

    //使用store方法将集合中的数据持久化到磁盘文件中
    //FileOutputStream只能写入字节,一般含有中文的不使用此输出流
    //FileOutputStream os = new FileOutputStream("MyBatis01\\Properties.properties");
    FileWriter fw = new FileWriter("MyBatis01\\Properties.properties");
    p.store(fw,"save Properties");
    //释放资源
    fw.close();
    
     * #save Properties
     * 古先生=20岁
     * 张先生=37岁
     * 王小姐=21岁
     * 钱大叔=50岁
     * 刘女士=25岁
    
    • 4、Properties集合读取文件中的键值对数据:
    • 调用的方法:load(InputStream inStream) 字节文件输入流读取
    • load(Reader reader) 字符文件输入流读取
    • 实现步骤:
    • 1、创建Properties对象;
    • 2、创建文件字节/字符输入流对象,并制定读取的目的文件
    • 3、Properties对象调用load(…)方法,将创建的字节/字符输入流对象作为参数传递,读取文件中的数据到Properties集合中;
    • 4、释放资源。
    • 文件读取的注意事项:
    • 1、存储键值对的文件中,键与值之间的链接符号一般是 = ,空格,(也可以使用其他符号);
    • 2、存储键值对的文件中,可以使用# 对数据进行注释,备注的数据在读取时会忽略,不读取;
    • 3、存储键值对的文件中,键和值默认都是字符串类型,不用特别加引号

    数据读取到Properties集合中代码实现:

    //读取properties.properties文件中的数据到Properties集合中
    Properties pp = new Properties();
    FileReader fr = new FileReader("MyBatis01\\Properties.properties");
    pp.load(fr);  //读取文件
    fr.close();  //释放资源
    //遍历读取到集合中的数据
    Set<String> s = pp.stringPropertyNames();
    for (String str: s) {
        System.out.println(str +" 今年 "+pp.getProperty(str));
    }
    
     * 注释古先生的数据之后读取的结果:
     * 
     * 张先生 今年 37岁
     * 王小姐 今年 21岁
     * 钱大叔 今年 50岁
     * 刘女士 今年 25岁
    
    展开全文
  • import java.util.Map.Entry; import java.util.Properties;...是一个可以和IO流结合使用的集合类。 * Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。 *
    package cn.itcast_08;
    
    import java.util.Map.Entry;
    import java.util.Properties;
    import java.util.Set;
    
    /*
     * Properties:属性集合类。是一个可以和IO流相结合使用的集合类。
     * Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。
     * 
     * 是Hashtable的子类,说明是一个Map集合。
     */
    public class PropertiesDemo {
    	public static void main(String[] args) {
    		// 作为Map集合使用
    		// 下面这种做法是错误的,一定要看API,如果没有<>,就说明该类不是一个泛型类,在使用的时候就不能加泛型
    		// Properties<String,String> p = new Properties<String,String>();
    		Properties prop = new Properties();
    
    		// 添加元素
    		prop.put("itcast02", "hello");
    		prop.put("itcast01", "world");
    		prop.put("itcast03", "java");
    
    		// System.out.println("prop:" + prop);
    		// 遍历集合
    		// 丈夫找妻子
    		Set<Object> set = prop.keySet();
    		for (Object key : set) {
    			Object value = prop.get(key);
    			System.out.println(key + "---" + value);
    		}
    
    		// 结婚证找丈夫和妻子
    		// Set<Entry<Object, Object>> set = prop.entrySet();
    		// for (Entry<Object, Object> e : set) {
    		// System.out.println(e.getKey() + "---" + e.getValue());
    		// }
    	}
    }
    

    展开全文
  • Properties-属性集合类(可以结合IO) java.util.Dictionary<K,V> 继承者 java.util.Hashtable<...是一个可以和IO流结合使用的集合类。 Properties 可保存在流中或从流中加载。属性列表中每个键及其对应...
    博客名称
    Java-(中级)

    Properties-属性集合类(可以结合IO)

    java.util.Dictionary<K,V> 继承者 java.util.Hashtable<Object,Object> 继承者 java.util.Properties

    Properties:属性集合类。是一个可以和IO流相结合使用的集合类。
    Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。

    是Hashtable的子类,说明是一个Map集合。

    代码演示

    public class PropertiesDemo {
        public static void main(String[] args) {
            // 作为Map集合的使用
            // 下面这种用法是错误的,一定要看API,如果没有<>,就说明该类不是一个泛型类,在使用的时候就不能加泛型
            // Properties<String, String> prop = new Properties<String, String>();
            Properties prop = new Properties();
    
            //添加元素
            prop.put("001", "挖掘机");
            prop.put("002", "男枪");
            prop.put("003", "盲僧");
    
            //遍历Map集合方式1
            for (Map.Entry<Object, Object> me : prop.entrySet()) {
                System.out.println(me.getKey() + "--" + me.getValue());
            }
            System.out.println("---------------------");
            //遍历方式2
            for (Object o:prop.keySet()) {
                System.out.println(o+"--"+prop.get(o));
    
            }
        }
    }
    

    结果:

    001--挖掘机
    002--男枪
    003--盲僧
    ---------------------
    001--挖掘机
    002--男枪
    003--盲僧
    

    Properties-特殊功能

    public Object setProperty(String key,String value):添加元素
    public String getProperty(String key):获取元素
    public Set stringPropertyNames():获取所有的键的集合

    代码演示

    public class PropertiesDemo02 {
        public static void main(String[] args) {
            //创建集合对象
            Properties prop = new Properties();
    
            //public Object setProperty(String key,String value):添加元素
            //底层使用Map集合的put方法实现的,但是这里传入的参数只能是字符串
            //添加元素
            prop.setProperty("卢锡安", "44");
            prop.setProperty("艾希", "30");
            prop.setProperty("希维尔", "43");
    
            //遍历集合
            //public Set<String> stringPropertyNames():获取所有的键的集合
            Set<String> set = prop.stringPropertyNames();
            for (String s : set) {
                //public String getProperty(String key):获取元素
                System.out.println(s + "--" + prop.get(s));
            }
        }
    }
    /*
     * class Hashtalbe<K,V> { public V put(K key,V value) { ... } }
     * 
     * class Properties extends Hashtable { public V setProperty(String key,String
     * value) { return put(key,value); } }
     */
    

    结果:

    卢锡安--44
    希维尔--43
    艾希--30
    

    Properties-load()和store()功能

    如果只能使用一个集合来读写文件那就是Properties集合

    这里的集合必须是Properties集合:
    public void load(Reader reader):把文件中的数据读取到集合中
    public void store(Writer writer,String comments):把集合中的数据存储到文件

    单机版游戏:
      		进度保存和加载。
      		三国群英传,三国志,仙剑奇侠传...
      
      		吕布=1
      		方天画戟=1
    

    代码演示1
    public void load(Reader reader):把文件中的数据读取到集合中

    public class PropertiesDemo03 {
        public static void main(String[] args) throws IOException {
            //将集合数据存储到文件中
            myStore();
        }
    
        public static void myStore() throws IOException {
            //创建集合对象
            Properties prop = new Properties();
    
            //添加元素
            prop.setProperty("001","亚索");
            prop.setProperty("002","伊芙琳");
            prop.setProperty("003","菲兹");
    
            //创建字符流对象
            FileWriter fw = new FileWriter("prop.txt");
            //public void store(Writer writer,String comments):把集合中的数据存储到文件
            prop.store(fw,"hello");
            //释放资源
            fw.close();
        }
    }
    

    结果:prop.txt文件内容

    #hello
    #Wed Apr 01 14:12:09 CST 2020
    001=亚索
    002=伊芙琳
    003=菲兹
    

    代码演示2
    public void store(Writer writer,String comments):把集合中的数据存储到文件

    public class PropertiesDemo03 {
        public static void main(String[] args) throws IOException {
            //将集合数据存储到文件中
           // myStore();
    
            //读取文件中的键值对数据
            myLoad();
        }
        
        public static void myStore() throws IOException {
            //创建集合对象
            Properties prop = new Properties();
    
            //添加元素
            prop.setProperty("001","亚索");
            prop.setProperty("002","伊芙琳");
            prop.setProperty("003","菲兹");
    
            //创建字输出符流对象
            FileWriter fw = new FileWriter("prop.txt");
            //public void store(Writer writer,String comments):把集合中的数据存储到文件
            prop.store(fw,"hello");
            //释放资源
            fw.close();
    
        }
        public static void myLoad() throws IOException {
            //创建集合对象
            Properties prop = new Properties();
    
            //创建字输入符流对象
            FileReader fr = new FileReader("prop.txt");
            // public void load(Reader reader):把文件中的数据读取到集合中
            //注意:这个文件的数据必须是键值对形式
            prop.load(fr);
            fr.close();
            System.out.println("prop:"+prop);
        }
    }
    

    结果:

    prop:{001=亚索, 002=伊芙琳, 003=菲兹}
    

    我有一个文本文件(prop.txt),我知道数据是键值对形式的,但是不知道内容是什么。

    请写一个程序判断是否有“lisi”这样的键存在,如果有就改变其实为”100”
    prop.txt文件

    lisi=40
    zhangsan=30
    wangwu=50
    
    分析:
            1.创建Properties对象
            2.读取user.txt文件;
            3.在获取到每一个键,在判断改建是否包含lisi
                    是:就把值替换为100
                  不是:不搭理
            4.创建字符缓冲输出流对象,重新写入文件。
    

    代码演示

    public class ProperetiesTest {
        public static void main(String[] args) throws IOException {
            //创建集合对象
            Properties prop = new Properties();
            //创建字符输入流对象
            FileReader fr= new FileReader("prop.txt");
            //读取数据
            prop.load(fr);
            System.out.println(prop);
            //获取键集合
            Set<String> set = prop.stringPropertyNames();
            for (String key:set){
                if(key.equals("lisi")){
                    prop.setProperty(key,"100");
                    break;
                }
            }
    
            //创建字符输出流缓冲对象
            FileWriter fw = new FileWriter("prop.txt");
            prop.store(fw,null);
            //关闭资源
            fw.close();
    
        }
    }
    

    结果:prop.txt文件中内容

    #Wed Apr 01 14:37:21 CST 2020
    lisi=100
    zhangsan=30
    wangwu=50
    

    我有一个猜数字小游戏的程序,请写一个程序实现在测试类中只能用5次,超过5次提示:游戏试玩已结束,请付费。

    分析:
    	1.创建集合对象,创建字符缓冲输入流对象
    	2.调用集合方法读取文件
    	3.根据count键,获取值,在判断改值是否大于5
    								大于5:请付费
    								小于5:键对应的值做++,调动方法从新设置count的值在写到文件中
    

    代码演示

    public class ProperetiesTest2 {
        public static void main(String[] args) throws IOException {
            //创建集合对象
            Properties prop  = new Properties();
            //创建字符缓冲输入流
            FileReader fr= new FileReader("prop.txt");
            //读取数据
            prop.load(fr);
    
            //这个程序是我自己写的,我当然之后文件中存储的是什么
            String strcount = prop.getProperty("count");
            int count = Integer.parseInt(strcount);
            //判断该值是否大于5
            if(count>5){
                System.out.println("你已经免费体验了5次了,需要付费了!");
            }else{
                count++;
                //玩游戏了
                GuessNumber.start();
                FileWriter fw = new FileWriter("prop.txt");
                //从新设置参数值
                prop.setProperty("count",String.valueOf(count));
                //写数据
                prop.store(fw,null);
            }
    
        }
    }
    

    游戏类

    public class GuessNumber {
    	private GuessNumber() {
    	}
    
    	public static void start() {
    		// 产生一个随机数
    		int number = (int) (Math.random() * 100) + 1;
    
    		// 定义一个统计变量
    		int count = 0;
    
    		while (true) {
    			// 键盘录入一个数据
    			Scanner sc = new Scanner(System.in);
    			System.out.println("请输入数据(1-100):");
    			int guessNumber = sc.nextInt();
    
    			count++;
    
    			// 判断
    			if (guessNumber > number) {
    				System.out.println("你猜的数据" + guessNumber + "大了");
    			} else if (guessNumber < number) {
    				System.out.println("你猜的数据" + guessNumber + "小了");
    			} else {
    				System.out.println("恭喜你," + count + "次就猜中了");
    				break;
    			}
    		}
    	}
    }
    

    结果:

    你已经免费体验了5次了,需要付费了!
    

    再连续执行5次代码后prop.txt文件中count已经等于6了,所以要付费了。

    #Wed Apr 01 15:24:28 CST 2020
    count=6
    
    展开全文
  • 1. 第二十二天回顾 File,主要就是方法,但是没有操作文件,读写能力,File必须和流对象配合。构造方法三种重载形式,两个静态常量;\平台无关性。mkdirs,exists,delete,getParent,getName,getParentFile,...
  • 是一个可以和IO流结合使用的集合类。 该类主要用于读取以项目的配置文件(以.properties结尾的文件 和 xml文件)。 Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。 ...
  • map下面实现叫做Hashtable Properties是唯一和IO流结合的 讲解 代码 转载于:https://www.cnblogs.com/wangjunwei/p/11269710.html...
  • 【Properties特点】 /* * 集合对象Properties特点: * 1.... * 2. 该集合无泛型,键值都是字符串 * 3. 键值可以存储到集合中,也可以存储到持久化... 可以和IO对象结合使用,有和技术相结合方法 */ 【Pro...
  • 1.是一个Map体系的集合类 2.Properties可以保存到中或从中加载 Properties作为Map集合的特有方法: 第一个:Object setProperty(String key ,String Value): 设置集合的键值,都是String类型的 底层调用...
  • 概述: java.util.Properties继承于Hashtable 表示一个持久的属性集 它使用键值结构存储数据 每个键及其对应值都是...Properties集合是唯一和IO流结合的集合 可以使用Properties集合中的store()方法 将集合中的临...
  • Java的IO流详解

    2019-03-29 20:39:39
    Java的IO流详解流概念作用IO流的分类IO程序书写流程字节输出流与字节输入流用法字节输出流OutputStream字节输入流InputStream字节输入流与字节输出流的结合使用达到文件复制效果字符流用法字符输出流...
  • 集合对象Properties,继承Hashtable,实现Map接口,可以和IO对象结合使用,实现数据持久存储。 特点: Hashtable子类,map集合方法都可以用。 该集合没有泛型。键值都是字符串。 它是一个可以持久...
  • 唯一和IO流结合的集合 概述: Properties 表示了一个持久的属性集。Properties 可保存在流中或从流中加载。 Properties集合是唯一和IO流结合的集合 可以使用Properties集合中的方法store,把集合中的临时...
  • Java IO流-Properties

    2019-10-06 21:06:19
    2017-11-05 21:37:50 Properties ...Properties:Properties 类表示了一个持久的属性集。... Properties是一个属性集合类,是一个可以和IO流结合使用的集合类。  Properties类 可以保...
  • Properties集合是一个唯一和io流结合的集合 可以使用Properties集合中的方法store,把集合中的临时数据,持久化写入到硬盘中存储 可以使用Properties集合中的load方法,把硬盘中保存的文件(键值对),读取到集合...
  • 目录数据操作简介举例读写内存操作简介字节数组字符数组字符串举例打印简介举例随机访问介绍构造方法举例writeread合并两个文件三个文件序列化定义举例writeread注意属性集合类定义作为Map集合的使用...
  • 的子类,但是是唯一和IO结合的集合 Properties表示了一个持久的属性集。Properties可以保存在中或从中加载。属性列表中每个建及其对应的值都是一个字符串 可以使用Properties集合中的方法store,把集合...
  • * properties:属性集合类,是一个可以在IO流结合使用的集合类 * Properties:可以保存流中或从流中加载,属性列表中的每个键及其对应值都是一个字符串 * * 是Hashtable的子类,说明是一个Map集合 */ public ...
  • * Properties 属性集合类,这个类可以 IO 结合使用。 * Properties 可以保存在中,或者从中加载。属性列表中每一个键其对应值都是一个字符串。 它是 Hashtable 类一个子类,说明是一个 Map 集合。 ...
  • 一、需求引入 1.要求在不使用对象流的前提下实现如下需求 2.需求如下所示: 学生信息系统 (a) 假设有20个Student,每个学生有id(学号...3.代码演示(结合ArrayList集合类+高效字符缓冲+增强for+泛型规范) pac...
  • Properties 集合是一个惟一和IO流结合的集合 可以使用Properties集合中的方法store,把集合中的临时数据,持久化写入到硬盘中存储 可以使用Properties集合中的方法load,把硬盘中保存的文件(键值),读取到集合
  • Properties集合类:是一个双列集合,键值都是String,他是唯一一个可以和IO流直接结合使用的集合类。主要是一些以.propertie结尾的配置文件。 它可以直接从流中读取数据,也可以直接写入数据到流中。 package ji...
  • 目录 1.Properties概述 2.Properties作为集合的使用 ...Properties属于集合类,是一个可以和IO流结合使用的集合类。 Properties是Hashtable的子类,说明是一个Map集合。 2.Properties作为集合的使用 具...
  • 使用Properties集合存储数据,遍历: ...* Properties集合是一个唯一和IO流结合的集合。 * 可以使用Properties集合中的方法store,把集合中的临时数据,持久化写入到硬盘中存储。 * 可以使用Properties
  • Properties概述 ...最后它是一个可以和IO流结合使用的属性集合类。 Properties常用操作方法 Properties基本的存和取 方法 描述 public Object setProperty(String key,String value)...
  • 是一个可以和IO流结合使用的集合类。 * Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。 * * 是Hashtable的子类,说明是一个Map集合。 */ public class PropertiesDemo {...
  • Properties集合是java中比较重要的API,他是一个唯一和IO流结合的集合,他可以将键值对存放在文件中。 1、介绍 java.util.Properties集合 extends Hashtable<k,v> implements Map<k,v> ...
  • *Properties集合是一个唯一和IO流结合的集合 *可以使用Properties集合中的store方法,把集合中的临时数据持久化写入到硬盘中 *可以使用Properties集合中的load方法,把硬盘中的文件(键值对)放到集合中使用 *

空空如也

空空如也

1 2 3 4 5
收藏数 89
精华内容 35
关键字:

和io流结合使用的集合类