Java系列（二十）__Java类集

Java系列（二十）__Java类集

1、Collection集合接口

在之前学习链表的时候可以发现，当使用add()方法向链表增加数据的时候，每次保存的都是一个对象的数据，而Collection操作过程之中每次也只能够保存一个对象。在Collection接口之中一共定义了15个方法，那么常用的方法如下：

No.	方法名称	类型	描述
1	public boolean add(E e)	普通	向集合之中保存数据
2	public void clear()	普通	清空集合
3	public boolean contains(Object o)	普通	查询集合之中是否包含有指定对象，需要equals()
4	public boolean remove(Object o)	普通	删除对象，需要equals()
5	public boolean isEmpty()	普通	判断集合是否为空集合
6	public int size()	普通	取得集合的长度
7	public Object[] toArray()	普通	将集合以对象数组的形式返回
8	public Iterator iterator()	普通	为Iterator接口实例化

         在以上所给出的方法之中，99%的情况下是使用add()、iterator()两个方法，其它的方法都很少使用。但是在开发之中不会去直接使用Collection（时代已经结束了），都会使用Collection下的两个子接口：List（允许重复）、Set（不允许重复）。

2、List集合接口

List接口是Collection之中最为常用的子接口，也是大家在开发过程之中主要使用的接口。但是List子接口针对于Collection子接口做了大量的功能扩充，而主要扩充的方法有如下几个：

No.	方法名称	类型	描述
1	public E get(int index)	普通	取得指定索引位置上的对象
2	public E set(int index, E element)	普通	修改指定索引位置上的对象
3	public ListIterator listIterator()	普通	为ListIterator接口实例化

         那么接口完成后如果要想使用接口那么一定需要子类，而常用的两个子类：ArrayList、Vector。

2.1、新的子类：ArrayList（90%）

         ArrayList是在JDK 1.2之后引入的，或者更加明确的讲像Collection、List等都是JDK 1.2之后引入的，也是在List接口使用过程之中最为常见的一个子类。

范例：使用ArrayList

package cn.mldn.demo; import java.util.ArrayList; import java.util.List; public class TestDemo {     public static void main(String[] args)throws Exception {         List all = new ArrayList() ;         all.add("HELLO") ;         all.add("HELLO") ;  // 保存了重复数据         all.add("WORLD") ;         System.out.println(all);     } }

         但是在很多时候可以采用循环的方式输出，因为在List子接口里面扩充了一个get()方法，所以就可以使用for循环。

范例：循环输出List集合

package cn.mldn.demo; import java.util.ArrayList; import java.util.List; public class TestDemo {     public static void main(String[] args)throws Exception {         List all = new ArrayList() ;         all.add("HELLO") ;         all.add("HELLO") ;  // 保存了重复数据         all.add("WORLD") ;         for (int x = 0; x < all.size(); x++) {             System.out.println(all.get(x));         }     } }

范例：验证其它方法

package cn.mldn.demo; import java.util.ArrayList; import java.util.List; public class TestDemo {     public static void main(String[] args)throws Exception {         List all = new ArrayList() ;         System.out.println(all.isEmpty());         all.add("HELLO") ;         all.add("HELLO") ;  // 保存了重复数据         all.add("WORLD") ;         System.out.println(all.isEmpty());         all.set(0, "hello") ;   // 此方法也是List扩充         all.remove("WORLD") ;         System.out.println(all);     } }

         但是以上的程序之中发现操作的数据类型都是String，那么String类是一个比较完善的类，那么下面使用一个自定义的类进行操作。

范例：保存自定义类对象

package cn.mldn.demo; import java.util.ArrayList; import java.util.List; class Person {     private String name ;     private int age ;     public Person(String name,int age) {         this.name = name ;         this.age = age ;     }     @Override     public String toString() {         return "姓名：" +this.name + "，年龄 :" + this.age + "\n" ;     }     @Override     public boolean equals(Object obj) {         if (obj ==null) {            return false ;         }         if (this == obj) {            return true ;         }         if (!(objinstanceof Person)) {            return false ;         }         Person per = (Person) obj ;         if (per.name.equals(this.name) && per.age ==this.age) {            return true ;         }         return false ;     } } public class TestDemo {     public static void main(String[] args)throws Exception {         List all = new ArrayList() ;         all.add(new Person("张三",20)) ;         all.add(new Person("李四",21)) ;         all.add(new Person("王五",19)) ;         all.remove(new Person("王五",19)) ;  // 删除         System.out.println(all.contains(new Person("李四",21)));         System.out.println(all);     } }

         那么在之前使用的链表操作，在List接口上可以方便的使用，使用的规则与之前完全一样，可是List所采用的程序的逻辑更加合理，性能更好，所以不会使用自定义链表，都会使用List接口操作。

2.2、旧的子类：Vector（10%）

         Vector是从JDK 1.0的时候引入的操作类，最早是用于纯粹的保存多个对象，同时在JDK 1.2之后为了让其可以继续使用，于是让Vector类多实现了一个List接口，所以List接口下有两个常用的子类：ArrayList、Vector。

         既然Vector也是List接口的子类，所以在使用上，不管使用ArrayList还是Vector不会有任何的区别。

范例：验证Vector

package cn.mldn.demo; import java.util.List; import java.util.Vector; public class TestDemo {     public static void main(String[] args)throws Exception {         List all = new Vector() ;         all.add("HELLO") ;         all.add("HELLO") ;  // 保存了重复数据         all.add("WORLD") ;         System.out.println(all);     } }

面试题：请解释ArrayList和Vector区别？

No.	区别	ArrayList	Vector
1	推出时间	JDK 1.2时推出	JDK 1.0时推出
2	性能	采用异步处理方式，性能较高	采用同步处理方式，性能较低
3	安全性	数据安全性差	数据安全性高
4	输出	Iterator、ListIterator、foreach	Iterator、ListIterator、foreach、Enumeration

         考虑到日后的开发异步开发居多，所以以ArrayList类为主。

3、Set集合接口

Set之中保存的元素是不能够有重复，但是Set接口并不像List接口那样对Collection进行了方法的扩充，而是完整的继承了Collection接口的所有方法，那么也就意味着，在之前使用的get()方法无法使用了。

         Set子接口之中重要使用两个常用的子类：HashSet、TreeSet。

3.1、散列存放的子类：HashSet（90%）

         Hash是一种散列算法，指的保存数据没有序列。

package cn.mldn.demo; import java.util.HashSet; import java.util.Set; public class TestDemo {     public static void main(String[] args)throws Exception {         Set all = new HashSet() ;         all.add("HELLO") ;         all.add("HELLO") ;  // 保存了重复数据         all.add("WORLD") ;         all.add("小金子") ;         all.add("小谢子") ;         System.out.println(all);     }}

         使用HashSet是不能够保存重复数据的。而且保存的数据没有任何的顺序。

3.2、排序存放的子类：TreeSet（10%）

         如果希望里面的数据排序，则可以使用TreeSet子类。

package cn.mldn.demo; import java.util.Set; import java.util.TreeSet; public class TestDemo {     public static void main(String[] args)throws Exception {         Set all = new TreeSet() ;         all.add("B") ;         all.add("D") ;  // 保存了重复数据         all.add("E") ;         all.add("A") ;         all.add("C") ;         System.out.println(all);     }}

         但是对于排序一般意义不大，所以使用的时候还是以HashSet为主。

3.3、关于数据排序的说明

         使用TreeSet可以实现集合中数据排序的保存，那么在之前使用的是String型数据，下面使用自定义类。但是这个类如果要想正常的使用TreeSet保存，那么一定要在此类上实现java.lang.Comparable接口，以区分大小。

         但是在此时覆写compareTo()方法的时候必须注意到：所有的属性都必须进行比较，否则就会出现部分属性内容相同也会认为是同一对象的情况，造成数据的保存错误。

范例：使用自定义类

package cn.mldn.demo; import java.util.Set; import java.util.TreeSet; class Person implements Comparable {     private String name ;     private int age ;     public Person(String name,int age) {         this.name = name ;         this.age = age ;     }     @Override     public String toString() {         return "姓名：" +this.name + "，年龄 :" + this.age + "\n" ;     }     @Override     public int compareTo(Person o) {         if (this.age > o.age) {            return -1 ;         } else if (this.age < o.age) {            return 1 ;         }         return this.name.compareTo(o.name);     } } public class TestDemo {     public static void main(String[] args)throws Exception {         Set all = new TreeSet() ;         all.add(new Person("张三",20)) ;         all.add(new Person("李四",21)) ;         all.add(new Person("赵六",21)) ; // 年龄重复         all.add(new Person("王五",19)) ;         all.add(new Person("王五",19)) ; // 彻底重复         System.out.println(all);     } }

         通过此时的程序也可以得出一个结论：TreeSet使用过程之中一定要使用到Comparable接口，而且TreeSet集合里面是依靠Comparable接口的compareTo()方法返回的数据来区分是否为重复数据。

3.4、关于重复数据的说明

         Set子接口之中不允许保留重复数据，之前使用的TreeSet子类虽然依靠了Comparable接口进行重复数据判断，但是此判断的方式也只是针对于TreeSet这种排序结构起作用，而真正意义上的排序操作是不依靠接口的，而是依靠Object类之中的两个方法：

                   · 取得对象的hash码：public int hashCode()；

                   · 对象比较：public boolean equals(Object obj)；

         在判断对象是否重复的过程之中，其基本流程如下：

                   · 首先使用要查询对象的hashCode与集合之中的保存对象的每一个hashCode进行比较；

                   · 如果hashCode相同，则再使用equals()方法进行内容的比较。

 

 

范例：重复对象判断

package cn.mldn.demo; import java.util.HashSet; import java.util.Set; class Person {     private String name ;     private int age ;     public Person(String name,int age) {         this.name = name ;         this.age = age ;     }     @Override     public String toString() {         return "姓名：" +this.name + "，年龄 :" + this.age + "\n" ;     }     @Override     public int hashCode() {         final int prime = 31;         int result = 1;         result = prime * result + age;         result = prime * result + ((name ==null) ? 0 : name.hashCode());         return result;     }     @Override     public boolean equals(Object obj) {         if (this == obj)            return true;         if (obj ==null)            return false;         if (getClass() != obj.getClass())            return false;         Person other = (Person) obj;         if (age != other.age)            return false;         if (name ==null) {            if (other.name != null)                return false;         } else if (!name.equals(other.name))            return false;         return true;     } } public class TestDemo {     public static void main(String[] args)throws Exception {         Set all = new HashSet() ;         all.add(new Person("张三",20)) ;         all.add(new Person("李四",21)) ;         all.add(new Person("赵六",21)) ; // 年龄重复         all.add(new Person("王五",19)) ;         all.add(new Person("王五",19)) ; // 彻底重复         System.out.println(all);     } }

         任何情况下如果是对象的重复判断，永恒都使用hashCode()和equals()。

4、集合输出接口

虽然在Collection接口之中提供有将数据变为对象数组的输出形式，但是所有的开发者基本上都不会使用此类访问，因为对于集合的输出有四类主要操作：Iterator、ListIterator、Enumeration、foreach。

4.1、迭代输出：Iterator（核心，95%）

          Iterator是最为常用的一个输出接口，而这个接口的定义如下：

public interface Iterator {     public boolean hasNext() ;  // 判断是否有数据     public E next() ;   // 取数据     public void remove() ;  // 删数据 }

         在之前所学习过的Scanner类就是Iterator接口的子类，但是在Iterator接口里面最常用的只有两个方法：hasNext()、next()，而remove()基本上一次都用不到。

         但是Iterator本身是一个接口，如果要想为此接口实例化对象，则需要使用Collection接口定义的方法：

                   · 取得Iterator接口对象：public Iterator iterator()；

范例：利用Iterator输出数据

package cn.mldn.demo; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class TestDemo {     public static void main(String[] args)throws Exception {         List all = new ArrayList() ;         all.add("HELLO") ;         all.add("HELLO") ;         all.add("WORLD") ;         all.add("你好") ;         Iterator iter = all.iterator() ;         while (iter.hasNext()) {             String str = iter.next() ;             System.out.println(str);         }     } }

         那么此时的操作形式就是在集合输出的标准形式。以后不管是何种开发，只要面对集合的输出操作，不需要做任何思考，永恒使用Iterator输出。

4.2、双向迭代输出：ListIterator（理解，0.01%）

         Iterator只能够完成由前向后的单向输出，而ListIterator可以完成双向的输出，ListIterator定义如下：

public interface ListIterator extends Iterator

         ListIterator是Iterator的子接口，所以在此接口里面重点只观察两个方法：

                   · 判断是否有前一个数据：public boolean hasPrevious()；

                   · 取出前一个数据：public E previous()。

         但是如果要想取得ListIterator接口对象，那么只能够依靠List接口完成。

package cn.mldn.demo; import java.util.ArrayList; import java.util.List; import java.util.ListIterator; public class TestDemo {     public static void main(String[] args)throws Exception {         List all = new ArrayList() ;         all.add("HELLO") ;         all.add("HELLO") ;         all.add("WORLD") ;         all.add("你好") ;         System.out.print("由前向后输出：");         ListIterator iter = all.listIterator() ;         while (iter.hasNext()) {             String str = iter.next() ;             System.out.print(str + "、");         }         System.out.print("\n由后向前输出：");         while (iter.hasPrevious()) {             String str = iter.previous() ;             System.out.print(str + "、");         }     } }

         如果要想进行由后向前的输出一定要首先发生由前向后的输出，实在是罗嗦，没用。

4.3、古老的输出：Enumeration（重点，4.98%）

         Enumeration是在JDK 1.0的时候就提出的一个输出接口，最早是将其称为枚举输出。不过后来随着发展，Enumeration使用的几率越来越少（你们一定会用的），那么Enumeration接口定义如下：

public interface Enumeration {     public boolean hasMoreElements() ;  // 是否有下一个元素     public E nextElement() ;            // 取出元素 }

         但是如果要想取得Enumeration接口实例也是不能够依靠集合接口，只能够依靠Vector类，在Vector子类里面定义了如下方法：public Enumeration elements()。

范例：使用Enumeration输出

package cn.mldn.demo; import java.util.Enumeration; import java.util.Vector; public class TestDemo {     public static void main(String[] args)throws Exception {         Vector all = new Vector() ;         all.add("HELLO") ;         all.add("HELLO") ;         all.add("WORLD") ;         all.add("你好") ;         Enumeration enu = all.elements() ;         while(enu.hasMoreElements()) {             String data = enu.nextElement() ;             System.out.println(data);         }     } }

         如果不到必须使用Enumeration接口的时候能不用还是不用它，都使用Iterator比较好。

4.4、新的输出：foreach（理解，0.01%）

         在之前使用过foreach进行数组的输出，但是对于foreach而言也可以进行集合数据的输出操作，只不过很少有人这样去做。尤其针对于初学者，还是使用标准的Iterator会更好一些。

package cn.mldn.demo; import java.util.ArrayList; import java.util.List; public class TestDemo {     public static void main(String[] args)throws Exception {         List all = new ArrayList() ;         all.add("HELLO") ;         all.add("HELLO") ;         all.add("WORLD") ;         all.add("你好") ;         for (String str : all) {             System.out.println(str);         }     } }

         以上的操作谨慎使用，能不用最好。

5、Map集合接口

Collection每次只能够保存一个对象，而Map每次可以保存一对对象。那么这对对象会按照“key=value”的形式进行存储，随后可以通过key找到对应的value，就好比电话号码本一样，例如，现在存了如下数据：

                   · name = 张三，tel = 110；

                   · name = 李四，tel = 119；

         现在找到了张三（找到了name），就可以找到与之对应的电话（tel），而这样的操作可以通过Map集合表示（public interface Map）。在使用Map接口的时候需要设置两个泛型类型，一个是key的类型，另外一个是value的类型，而在Map接口中定义了如下常用方法。

No.	方法名称	类型	描述
1	public V put(K key, V value)	普通	集合之中保存数据
2	public V get(Object key)	普通	根据key取得对应的value
3	public Set keySet()	普通	取得全部的key，key不能重复
4	public Collection values()	普通	取得全部的value
5	public Set> entrySet()	普通	将Map集合变为Set集合

         而在Map接口下又有两个常见的子类：HashMap、Hashtable。

5.1、新的子类：HashMap（90%）

         HashMap是Map接口中最为常用的一个子类，下面将使用HashMap验证Map的使用操作。

范例：保存数据

package cn.mldn.demo; import java.util.HashMap; import java.util.Map; public class TestDemo {     public static void main(String[] args)throws Exception {         Map map = new HashMap();         map.put(1, "张三");         map.put(1, "李四"); // key重复         map.put(2, "王五");         map.put(3, null);         map.put(null, "赵六");         System.out.println(map);     } }

         在使用Map集合的时候如果发生了key重复的问题，那么会使用新的值替换掉旧的值。但是从实际来讲，设置在Map之中的数据主要是为了查找使用。

         Collection设置数据的目的主要是为了输出，而Map设置数据的目的主要是为了查找。

范例：查找数据

package cn.mldn.demo; import java.util.HashMap; import java.util.Map; public class TestDemo {     public static void main(String[] args)throws Exception {         Map map = new HashMap();         map.put(1, "张三");         map.put(1, "李四"); // key重复         map.put(2, "王五");         map.put(3, null);         map.put(null, "赵六");         System.out.println(map.get(1));         System.out.println(map.get(null));         System.out.println(map.get(200));   // 没有返回null     } }

         整个过程之中都是可以进行null操作的。

5.2、旧的子类：Hashtable（10%）

         Hashtable与Vector、Enumeration一样，都是最早提供的集合操作类，在JDK 1.2之后为了保护其可以继续使用，所以让Hashtable多实现了一个Map接口。

范例：验证Hashtable

package cn.mldn.demo; import java.util.Hashtable; import java.util.Map; public class TestDemo {     public static void main(String[] args)throws Exception {         Map map = new Hashtable();         map.put(1, "张三");         map.put(1, "李四"); // key重复         map.put(2, "王五");         System.out.println(map.get(1));         System.out.println(map.get(200));   // 没有返回null     } }

         在Hashtable的操作之中可以发现，里面是不能够存在有null数据的。

面试题：请解释HashMap和Hashtable区别？

No.	区别	HashMap	Hashtable
1	推出时间	JDK 1.2时推出	JDK 1.0时推出
2	性能	采用异步处理方式，性能较高	采用同步处理方式，性能较低
3	安全性	数据安全性差	数据安全性高
4	处理null	允许保存null	不允许保存null，会出现NullPointerException

         考虑到日后的开发异步开发居多，所以以HashMap类为主。

5.3、关于Map集合的输出说明（核心）

         在Map接口里面存在有一个keySet()的方法，此方法返回的是所有的key的数据，并且是以Set集合的形式返回，于是下面就使用此方法输出数据。

package cn.mldn.demo; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; public class TestDemo {     public static void main(String[] args)throws Exception {         Map map = new HashMap();         map.put(1, "张三");         map.put(2, "李四");         map.put(3, "王五");         Set set = map.keySet() ;   // 取得全部的key         Iterator iter = set.iterator() ;         while (iter.hasNext()) {             Integer key = iter.next() ;             System.out.println(key + " --> " + map.get(key));         }     } }

         就本程序而言，已经实现了Map集合的输出操作，但是这个输出操作存在以下问题：首先取得了全部key，需要进行迭代输出，而且每一个key又要去查询集合中对应的value（循环），所以这样的输出形式是不可取的。

         如果要想输出Map集合，那么一定还是需要使用到Iterator接口，可是Map接口里面并没有定义像Collection接口之中定义的iterator()方法，那么下面就需要分析一下Collection和Map的数据保存区别。

         可以发现在Map接口里面存在有一个static定义的子接口：Map.Entry，而所有的key和value都自动的封装在了此接口对象之中，而在Map.Entry接口里面存在有两个方法：

                   · 取得包装的key：public K getKey()；

                   · 取得包装的value：public V getValue()；

关于Map接口使用Iterator输出的过程：

         1、   首先使用Map集合之中的entrySet()方法将Map集合变为Set集合，而此时Set集合中的每一个元素类型都是Map.Entry接口实例；

         2、   利用Set接口的iterator()方法取得Iterator接口对象，同时Iterator中操作的类型依然是Map.Entry；

         3、   利用Iterator进行迭代输出，取出每一个Map.Entry对象，并且利用getKey()和getValue()方法取出数据。

范例：利用Iterator输出Map集合

package cn.mldn.demo; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; public class TestDemo {     public static void main(String[] args)throws Exception {         Map map = new HashMap();         map.put(1, "张三");         map.put(2, "李四");         map.put(3, "王五");         Set> set = map.entrySet();         Iterator> iter = set.iterator();         while (iter.hasNext()) {             Map.Entry me = iter.next();             System.out.println(me.getKey() + " --> " + me.getValue());         }     } }

         这一程序在工作之中一定会出现，建议下面多写几次，同时一定要记住Map.Entry的作用。

5.4、关于Map集合之中key的说明

         通过之前的代码演示发现一直都是使用Integer作为key的类型，而且Integer本身也是系统类。那么在实际上Map也可以使用自定义类型作为key。但是此时必须有一个要求：由于map集合根据key的查找属于对象的匹配过程，所以作为自定义的key类型，类一定要覆写Object类的hashCode()和equals()两个方法。

package cn.mldn.demo; import java.util.HashMap; import java.util.Map; class Person {     private String name ;     private int age ;     public Person(String name,int age) {         this.name = name ;         this.age = age ;     }     @Override     public String toString() {         return "姓名：" +this.name + "，年龄：" + this.age ;     }     @Override     public int hashCode() {         final int prime = 31;         int result = 1;         result = prime * result + age;         result = prime * result + ((name ==null) ? 0 : name.hashCode());         return result;     }     @Override     public boolean equals(Object obj) {         if (this == obj)            return true;         if (obj ==null)            return false;         if (getClass() != obj.getClass())            return false;         Person other = (Person) obj;         if (age != other.age)            return false;         if (name ==null) {            if (other.name != null)                return false;         } else if (!name.equals(other.name))            return false;         return true;     } } public class TestDemo {     public static void main(String[] args)throws Exception {         Map map = new HashMap();         map.put(new Person("张三", 20),new String("ZS"));         System.out.println(map.get(new Person("张三", 20)));     } }

         以上的代码只是在一次重复强调了hashCode()和equals()的作用，但是从实际的角度来看，作为key的类型99%的情况下都会使用String表示，或者使用Integer等系统类表示。

6、Collections工具类

在java.util包里面有一个Collections类。

package cn.mldn.demo; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class TestDemo {     public static void main(String[] args)throws Exception {         List all = new ArrayList() ;         Collections.addAll(all, "HELLO", "WORLD", "你好");         Collections.reverse(all);         System.out.println(all);     } }

         虽然Collections提供了集合的工具类支持，但是此类的存在意义并不大，也很少去使用，作为知识知道就行了。

面试题：请解释Collection和Collections区别？

         · Collection是集合操作的父接口；

         · Collections是集合操作的工具类，提供了各种集合的操作方法支持。

7、Stack

栈是一种先进后出的数据结构。Stack属于Vector一个子类。但是在进行方法操作的时候需要使用自己扩充方法：

                   · 入栈：public E push(E item)；

                   · 出栈：public E pop()。

范例：观察栈操作

package cn.mldn.demo; import java.util.Stack; public class TestDemo {     public static void main(String[] args)throws Exception {         Stack all = new Stack();         all.push("A");         all.push("B");         all.push("C");         System.out.println(all.pop());         System.out.println(all.pop());         System.out.println(all.pop());         System.out.println(all.pop());  // 没数据了，EmptyStackException     } }

         在Android之中每一个打开的界面都会自动的入栈保存，所以当后退的时候就是一个出栈过程。

8、Properties

Properties是Hashtable的子类，在Hashtable操作的过程之中，key和value都可以保存任意的对象，但是在Properties之中key和value只能够是String型数据，而且操作的方法如下：

                   · 设置属性：public Object setProperty(String key, String value)；

                   · 取得属性：public String getProperty(String key)，没有属性返回null；

                   · 取得属性：public String getProperty(String key, String defaultValue)，没有返回默认值。

范例：验证Properties使用

package cn.mldn.demo; import java.util.Properties; public class TestDemo {     public static void main(String[] args)throws Exception {         Properties pro = new Properties();         pro.setProperty("BJ", "北京");         pro.setProperty("TJ", "天津");         System.out.println(pro.getProperty("BJ"));         System.out.println(pro.getProperty("GZ"));         System.out.println(pro.getProperty("GZ","没有信息"));     } }

         而通过Properties类设置的属性也是可以通过IO操作进行输出的，定义了如下输出方法：

                   ·保存属性：public void store(OutputStream out, String comments) throws IOException；

范例：将属性保存到文件

package cn.mldn.demo; import java.io.File; import java.io.FileOutputStream; import java.util.Properties; public class TestDemo {     public static void main(String[] args)throws Exception {         Properties pro = new Properties();         pro.setProperty("BJ", "北京");         pro.setProperty("TJ", "天津");         pro.store(new FileOutputStream(new File("D:" + File.separator                 + "area.properties")), "Area Info");     } }

         属性文件的后缀一般都是“*.properties”。

         既然可以通过输出流输出文件信息，那么也可以通过输入流读取文件信息，方法如下：

                   ·读取属性：public void load(InputStream inStream) throws IOException；

package cn.mldn.demo; import java.io.File; import java.io.FileInputStream; import java.util.Properties; public class TestDemo {     public static void main(String[] args)throws Exception {         Properties pro = new Properties();         pro.load(new FileInputStream(new File("D:" + File.separator                 + "area.properties")));         System.out.println(pro.getProperty("BJ"));         System.out.println(pro.getProperty("GZ"));     } }

         需要注意的是在*.properties文件之中是不能够直接使用中文的，必须转码，如果要转码可以使用一个指定的转码工具“native2ascii.exe”。日后的开发之中一定会使用到属性文件进行提示数据的保存，所以以上代码非常重要。