专题笔记--Java 类集框架

Java 类集框架

1. Java类集框架产生的原因

在基础的应用中，我们可以通过数组来保存一组对象或者基本数据，但数组的大小是不可更改的，因此出于灵活性的考虑和对空间价值的担忧，我们可以使用链表来实现动态的数组。灵活的代价是操作上的繁琐，在计算机的世界，处理繁琐问题的不二法门就是将其封装，只向外暴露以供调用的方法视图。Java类集框架就是对这一方法的一种官方实现——一套动态对象数组的操作类，它其实就是Java对数据结构的一个大概的封装。

2. 三个核心接口

[java]  view plain copy

 

1. //存放单值的最大父接口——Collection
2. public interface Collection<E> extends Iterable<E>
3. //存放一对数据的最大接口——Map
4. public interface Map<K,V>
5. //通用的输出接口——Iterator
6. public interface Iterator<E>

备注：泛型的说明

在JDK1.5之后，这些接口都增加了泛型的定义，最早的时候这三个接口中的内容都使用Object进行操作。出于安全问题的考虑，以及避免转型之间的繁琐，JDK1.5将整个类集框架都升级为泛型，真是造福大众呀！！！

3. Collection和它的孩子们

按照面向对象的考虑，在使用单值集合时应以接口Collection来作为父类引用，但实践的结果是Collection的两个子接口List和Set获得了更多的青睐。

1. Collection的主要方法视图：

[java]  view plain copy

 

1. //1.添加一个元素
2. public boolean add(E e);
3. //2.清空集合
4. public void clear();
5. //3.是否包含特定元素
6. public boolean contains(E e);
7. //4.实例化Iterator遍历接口
8. public Iterator<E> iterator();
9. //5.从集合中删除特定的元素
10. public boolean remove(Object o);
11. //6.取得集合的大小
12. public int size();
13. //7.将集合转变为一个对象数组输出
14. public Object[] toArray();
15. //8.将集合转变为一个对象数组输出--泛型版本
16. public <T> T[] toArray();

2. List(Collection的一个子接口——允许重复且有序)的新增的主要方法视图：

[java]  view plain copy

 

1. //1.在指定的位置上添加一个元素
2. public void add(int index, E element);
3. //2.取得指定位置上的元素
4. public E get(int index);
5. //3.修改指定位置上的元素，返回原先的元素
6. public E set(int index, E element);
7. //4.为ListIterator接口实例化
8. public ListIterator<E> listIterator();
9. //5.删除指定位置上的元素，返回删除的那个元素的引用
10. public E remove(int index);

备注：ListIterator

它是Iterator接口的一个子接口，可以向前向后遍历List，而Iterator只能向后遍历。

2.1 新的子类：ArrayList

[java]  view plain copy

 

1. public class ArrayList<E> extends AbstractList<E>
2. implements List<E>,RandomAccess,Cloneable,Serializable

2.1.1 范例：设置内容

[java]  view plain copy

 

1. import java.util.ArrayList;
2. import java.util.List;
3. public class ArrayListDemo01 {
4. public static void main(String[] args) {
5. List<String> all = new ArrayList<String>(); // 实例化List接口
6. all.add("hello"); // 向集合中增加内容
7. all.add("world"); // 向集合中增加内容
8. all.add("!!!"); // 向集合中增加内容
9. for (int x = ; x < all.size(); x++) {
10. System.out.println(all.get(x)) ;
11. }
12. }
13. }

说明：本例中使用List接口接收ArrayList实例，在取出数据的时候使用了List接口自己才有的get(int index)方法，如果使用Collection接收，取出数据时要先将其中的数据放到一个数组，然后从数组中取。如下例：

2.1.2 范例：Collection转换成数组输出

[java]  view plain copy

 

1. import java.util.ArrayList;
2. import java.util.Collection;
3. public class ArrayListDemo02 {
4. public static void main(String[] args) {
5. Collection<String> all = new ArrayList<String>(); // 实例化List接口
6. all.add("hello"); // 向集合中增加内容
7. all.add("world"); // 向集合中增加内容
8. all.add("!!!"); // 向集合中增加内容
9. all.remove("!!!"); // 从集合中删除指定对象
10. Object obj[] = all.toArray(); // 将所有的内容变为对象数组
11. for (int x = ; x < obj.length; x++) {
12. String str = (String) obj[x];
13. System.out.print(str + "、");
14. }
15. }
16. }

说明：为了对输出数组的运行时类型进行更精确的控制，可以使用如下的方式来连接数组与集合。

2.1.3 范例：Collection转换成数组输出（精确控制数组类型）

[java]  view plain copy

 

1. import java.util.ArrayList;
2. import java.util.Collection;
3. public class ArrayListDemo02 {
4. public static void main(String[] args) {
5. Collection<String> all = new ArrayList<String>(); // 实例化List接口
6. all.add("hello"); // 向集合中增加内容
7. all.add("world"); // 向集合中增加内容
8. all.add("!!!"); // 向集合中增加内容
9. all.remove("!!!"); // 从集合中删除指定对象
10. Object obj[] = all.toArray(new String[]{}); // 将所有的内容变为对象数组
11. //或者Object obj[] = alll.toArray(new String[0]);
12. for (int x = ; x < obj.length; x++) {
13. String str = (String) obj[x];
14. System.out.print(str + "、");
15. }
16. }
17. }

说明：toArray()能够将集合转换成对象数组，是两种对象管理方式之间的桥梁，也连接了双方的API。

2.2 旧的子类：Vector

        Vector是最早的数据结构的实现类，也称为向量，在JDK1.0时并没有现在的类集框架的概念，它只是一个应需而生的操作类。在JDK1.2之后提出了类集框架，一系列专门设计的接口被推出，为了保留这个类，JDK1.2让它实现了List接口，完成类集的大一统。

范例：Vector的常规应用

[java]  view plain copy

 

1. import java.util.List;
2. import java.util.Vector;
3. public class VectorDemo {
4. public static void main(String[] args) {
5. List<String> all = new Vector<String>(); // 实例化List接口
6. all.add("hello"); // 向集合中增加内容
7. all.add("world"); // 向集合中增加内容
8. all.add("!!!"); // 向集合中增加内容
9. for (int x = ; x < all.size(); x++) {
10. System.out.println(all.get(x)) ;
11. }
12. }
13. }

 2.3 ArrayList和Vector的比较

二者的操作接口基本一致，其区别是在内部的实现上：ArrayList在JDK1.2推出，比Vector晚，它采用异步处理的方式，而非Vector的同步方式，所以速度比较快，这也是它比较受欢迎的原因。相应的，ArrayList非线程安全，Vector则是线程安全的。二者都是List的实现类，都可以依靠size()和get()两个方法完成循环输出，都支持Iterator输出，不过Vector还支持Enumeration的输出方式，在实际运用中这种方式很少用到。

3. 不允许重复的子接口：Set

List接口中的内容是允许重复的，但是如果现在要求集合中的内容不能重复的话，就只能使用Set接口。Set接口不像List那样对Collection进行了大量的扩充，它对外的方法视图与Collection是完全一样的。

3.1 散列存放的子类：HashSet

[java]  view plain copy

 

1. public class HashSet<E>
2. extends AbstractSet<E>
3. implements Set<E>, Cloneable, Serializable

HashSet的定义方式和ArrayList很相似。

范例：添加元素与输出

[java]  view plain copy

 

1. import java.util.HashSet;
2. import java.util.Set;
3. public class HashSetDemo {
4. public static void main(String[] args) {
5. Set<String> all = new HashSet<String>();
6. all.add("hello");
7. all.add("hello"); // 重复设置
8. all.add("world");
9. all.add("!!!");
10. System.out.println(all) ;
11. }
12. }

说明：在Set接口中不允许有重复的元素存在，而且其中的元素是无序的，称为散列存放。

3.2 排序存放的子类：TreeSet

范例：排序存放

[java]  view plain copy

 

1. import java.util.Set;
2. import java.util.TreeSet;
3. public class TreeSetDemo {
4. public static void main(String[] args) {
5. Set<String> all = new TreeSet<String>();
6. all.add("B");
7. all.add("B");
8. all.add("X");
9. all.add("C");
10. all.add("A");
11. System.out.println(all);
12. }
13. }

说明：TreeSet不允许有重复内容，而且添加元素无序，输出时却是有序输出。

3.3 关于排序的补充

TreeSet中的元素对象可以排序要求它们实现Comparable接口，事先指定好排序规则。

范例：排序加入，compareTo()为0的对象元素将不会被再次添加

[java]  view plain copy

 

1. import java.util.Set;
2. import java.util.TreeSet;
3. class Person implements Comparable<Person> {
4. private String name;
5. private int age;
6. public Person(String name, int age) {
7. this.name = name;
8. this.age = age;
9. }
10. public String toString() {
11. return "姓名：" + this.name + "，年龄：" + this.age;
12. }
13. @Override
14. public int compareTo(Person o) {
15. if (this.age < o.age) {
16. return ;
17. } else if (this.age > o.age) {
18. return -;
19. } else {
20. return this.name.compareTo(o.name);
21. }
22. }
23. }
24. public class SortDemo {
25. public static void main(String[] args) {
26. Set<Person> all = new TreeSet<Person>();
27. all.add(new Person("张三", ));
28. all.add(new Person("李四", ));
29. all.add(new Person("李四", ));
30. all.add(new Person("王五", ));
31. System.out.println(all);
32. }
33. }

 3.4 关于重复元素的补充

Comparable可以完成TreeSet类中重复元素的判断，如果这种判断重复的方式通用的话，那么在HashSet中应该也能够使用。但是测试的结果否定了这样的猜测，Set中去掉重复元素的操作不是靠Comparable完成，它们靠两个方法来确定，这两个方法在Object中提供了定义：

[java]  view plain copy

 

1. public boolean equals(Object obj);
2. public int hashCode();

hashCode()可以为对象提供一个标示编号，如果要对对象内容进行验证需要重写equals()方法。hashCode()返回一个数字，它是通过特定的算法得到的，指定算法并不难，指定一个好的使同一个hashCode尽可能少地对应对象就需要花些心思了。

范例：重写hashCode()和equals()

[java]  view plain copy

 

1. import java.util.HashSet;
2. import java.util.Set;
3. class Person{
4. private String name;
5. private int age;
6. public Person(String name, int age) {
7. this.name = name;
8. this.age = age;
9. }
10. @Override
11. public int hashCode() {
12. final int prime = ;
13. int result = ;
14. result = prime * result + age;
15. result = prime * result + ((name == null) ?  : name.hashCode());
16. return result;
17. }
18. @Override
19. public boolean equals(Object obj) {
20. if (this == obj)
21. return true;
22. if (obj == null)
23. return false;
24. if (getClass() != obj.getClass())
25. return false;
26. Person other = (Person) obj;
27. if (age != other.age)
28. return false;
29. if (name == null) {
30. if (other.name != null)
31. return false;
32. } else if (!name.equals(other.name))
33. return false;
34. return true;
35. }
36. public String toString() {
37. return "姓名：" + this.name + "，年龄：" + this.age;
38. }
39. }
40. public class RepeatDemo {
41. public static void main(String[] args) {
42. Set<Person> all = new HashSet<Person>();
43. all.add(new Person("张三", ));
44. all.add(new Person("李四", ));
45. all.add(new Person("李四", ));
46. all.add(new Person("王五", ));
47. System.out.println(all);
48. }
49. }

说明：JVM在管理众多的对象时，其底层实现采用的是一个大的哈希表，这个哈希表可能是用数组来模拟的，数组的下标是hashCode，在哈希表上每个值对应的是一个链表，链表中有哈希值相同的对象的引用。这样进行对象查找时就可以如同查字典一样，先计算对象的hashCode，这时的hashCode如果一个索引；然后迅速定位到索引所对应的对象链表，然后借助equals的内容比较方式进行属性的逐一比对以找到对应的对象。

4. 集合输出

在实际的应用中，只要是集合的输出基本上都不会采用将其变为对象数组的方式。

遍历的方式有如下四种，它们的使用率是不一样的：

Iterator--95%

ListIterator--1%

Enumeration--4%

foreach--0%

4.1 迭代输出：Iterator

Iterator只声明了三个方法：

[java]  view plain copy

 

1. //判断是否有下一个元素
2. public boolean hasNext();
3. //取出当前的元素
4. public E next();
5. //删除当前的内容（不常用）
6. public void remove();

范例：集合输出的标准操作

[java]  view plain copy

 

1. import java.util.ArrayList;
2. import java.util.Iterator;
3. import java.util.List;
4. public class IteratorDemo {
5. public static void main(String[] args) {
6. List<String> all = new ArrayList<String>();
7. all.add("hello");
8. all.add("world");
9. Iterator<String> iter = all.iterator();
10. while (iter.hasNext()) { // 指针向下移动，判断是否有内容
11. String str = iter.next();
12. System.out.print(str + "、");
13. }
14. }
15. }

4.2 双向迭代输出：ListIterator

Iterator接口完成的是从前往后的单向输出，如果要实现双向输出则要借助它的子接口：ListIterator

[java]  view plain copy

 

1. public interface ListIterator<E>
2. extends Iterator<E>
3. //ListIterator新增的方法:
4. //判断是否有前一个元素
5. public boolean hasPrevious();
6. //取出前面的元素
7. public E previous();

要实现ListIterator，只能借助List的listIterator()来获得，Collection并没有提供。

范例：双向遍历

[java]  view plain copy

 

1. import java.util.ArrayList;
2. import java.util.List;
3. import java.util.ListIterator;
4. public class ListIteratorDemo {
5. public static void main(String[] args) {
6. List<String> all = new ArrayList<String>();
7. all.add("hello");
8. all.add("world");
9. ListIterator<String> iter = all.listIterator();
10. System.out.println("=========== 由前向后输出 ============");
11. while (iter.hasNext()) {
12. System.out.print(iter.next() + "、");
13. }
14. System.out.println("/n=========== 由后向前输出 ============");
15. while (iter.hasPrevious()) {
16. System.out.print(iter.previous() + "、");
17. }
18. }
19. }

4.3 几乎废弃的接口：Enumeration

Enumeration接口是Iterator的前辈，发展到现在已经很少使用了。

以下是Enumeration提供的方法（名字起得挺长的）：

[java]  view plain copy

 

1. //判断是否有下一个元素
2. public boolean hasMoreElements();
3. //取出当前的元素
4. public E nextElement();

Enumeration的限制：Collection接口本身并不支持这种输出，只有与之同时期的Vector支持这种输出方式。在Vector类中定义了这样的方法：public Enumeration<E> elements();

范例：使用Enumeration输出

[java]  view plain copy

 

1. import java.util.Enumeration;
2. import java.util.Vector;
3. public class EnumerationDemo {
4. public static void main(String[] args) {
5. Vector<String> all = new Vector<String>();
6. all.add("hello");
7. all.add("world");
8. Enumeration<String> enu = all.elements();
9. while (enu.hasMoreElements()) {
10. String str = enu.nextElement();
11. System.out.print(str + "、");
12. }
13. }
14. }

4.4 新的支持：foreach

JDK1.5为我们提供了一种新的集合输出方式，即增强型的for循环，它的语法比较简洁，但语法简洁的代价是灵活性的缺失，所以很多开发人员并不常用。

范例：foreach输出

[java]  view plain copy

 

1. import java.util.ArrayList;
2. import java.util.List;
3. public class ForEachDemo {
4. public static void main(String[] args) {
5. List<String> all = new ArrayList<String>();
6. all.add("hello");
7. all.add("world");
8. for (String str : all) {
9. System.out.println(str);
10. }
11. }
12. }

5. Map接口

Collection接口操作的时候每次都会向集合中添加一个元素，但是如果要添加的元素是一对的话，就要使用Map接口来完成了，其定义如下：

[java]  view plain copy

 

1. public interface Map<K,V>
2. //K表示键，V表示值

Map的常用方法的视图：

[java]  view plain copy

 

1. //向集合中添加元素，返回与key值以前关联的value，如果之前没有关联则返回null
2. public V put(K key, V value);
3. //根据key获得value
4. public V get(Object key);
5. //取出所有的key
6. public Set<K> keySet();
7. //取出所有的value
8. public Collection<V> values();
9. //删除一个指定的key
10. public V remove(Object key);
11. //将所有的键值对变为Set集合
12. public Set<Map.Entry<K,V>> entrySet();

在Map接口的内部还定义了一个内部接口——Map.Entry，因为采用static interface来定义，所以外部可以通过Map.Entry来访问。

5.1 新的子类：HashMap

如果要使用Map的话，可以使用HashMap对其进行实例化。

范例：添加与查询

[java]  view plain copy

 

1. import java.util.HashMap;
2. import java.util.Map;
3. public class HashMapDemo01 {
4. public static void main(String[] args) {
5. Map<String, String> all = new HashMap<String, String>();
6. all.put("BJ", "BeiJing");
7. all.put("NJ", "NanJing");
8. String value = all.get("BJ"); // 根据key查询出value
9. System.out.println(value);
10. System.out.println(all.get("TJ"));
11. }
12. }

说明：在Map的操作中，会依据key来获得对应的value，如果找不到，则会返回null。

由于现在使用的是HashMap子类，所以里面的key值可以有一个为null。

范例：key值为null

[java]  view plain copy

 

1. import java.util.HashMap;
2. import java.util.Map;
3. public class HashMapDemo02 {
4. public static void main(String[] args) {
5. Map<String, String> all = new HashMap<String, String>();
6. all.put("BJ", "BeiJing");
7. all.put("NJ", "NanJing");
8. all.put(null, "NULL");
9. System.out.println(all.get(null));
10. }
11. }

范例：借助keySet()来获得所有key的集合，然后遍历Map

[java]  view plain copy

 

1. import java.util.HashMap;
2. import java.util.Iterator;
3. import java.util.Map;
4. import java.util.Set;
5. public class HashMapDemo03 {
6. public static void main(String[] args) {
7. Map<String, String> all = new HashMap<String, String>();
8. all.put("BJ", "BeiJing");
9. all.put("NJ", "NanJing");
10. all.put(null, "NULL");
11. Set<String> set = all.keySet();
12. Iterator<String> iter = set.iterator();
13. while (iter.hasNext()) {
14. String key = iter.next() ;
15. System.out.println(key + " --> " + all.get(key)) ;
16. }
17. }
18. }

5.2 Map集合的输出

正统做法：依靠Iterator来输出，但Map本身并不能直接为Iterator实例化，如果非要使用Iterator输出Map集合的话，则要采用如下的步骤：

1. 将所有的Map集合通过entrySet()方法变成Set集合，里面的每一个元素都是Map.Entry的实例；
2. 利用Set接口中提供的iterator()方法来为Iterator接口实例化；
3. 通过迭代，并且利用Map.Entry接口完成key与value的分离。

范例：使用Iterator输出Map

[java]  view plain copy

 

1. import java.util.HashMap;
2. import java.util.Iterator;
3. import java.util.Map;
4. import java.util.Set;
5. public class MapPrint {
6. public static void main(String[] args) {
7. Map<String, String> all = new HashMap<String, String>();
8. all.put("BJ", "BeiJing");
9. all.put("NJ", "NanJing");
10. all.put(null, "NULL");
11. Set<Map.Entry<String, String>> set = all.entrySet();
12. Iterator<Map.Entry<String, String>> iter = set.iterator();
13. while (iter.hasNext()) {
14. Map.Entry<String, String> me = iter.next();
15. System.out.println(me.getKey() + " --> " + me.getValue());
16. }
17. }
18. }

5.3 有序的存放：TreeMap

HashMap子类中的key都属于无序存放的，如果现在希望有序则可以通过TreeMap来实现（按key排序），但是需要注意的是既然按照key来排序，而key又是对象，所以就要求key实现Comparable接口。

范例：TreeMap的简单使用

[java]  view plain copy

 

1. import java.util.Set;
2. import java.util.TreeMap;
3. public class TreeMapDemo {
4. public static void main(String[] args) {
5. Map<String, String> all = new TreeMap<String, String>();
6. all.put("BJ", "BeiJing");
7. all.put("NJ", "NanJing");
8. Set<Map.Entry<String, String>> set = all.entrySet();
9. Iterator<Map.Entry<String, String>> iter = set.iterator();
10. while (iter.hasNext()) {
11. Map.Entry<String, String> me = iter.next();
12. System.out.println(me.getKey() + " --> " + me.getValue());
13. }
14. }
15. }

5.4 旧的子类：Hashtable

Hashtable和Vector都是属于JDK1.0时推出的集合操作类，在JDK1.2之后为了保留让它实现了Map接口。

范例：Hashtable的使用

[java]  view plain copy

 

1. import java.util.Hashtable;
2. import java.util.Iterator;
3. import java.util.Map;
4. import java.util.Set;
5. public class HashtableDemo {
6. public static void main(String[] args) {
7. Map<String, String> all = new Hashtable<String, String>();
8. all.put("BJ", "BeiJing");
9. all.put("NJ", "NanJing");
10. Set<Map.Entry<String, String>> set = all.entrySet();
11. Iterator<Map.Entry<String, String>> iter = set.iterator();
12. while (iter.hasNext()) {
13. Map.Entry<String, String> me = iter.next();
14. System.out.println(me.getKey() + " --> " + me.getValue());
15. }
16. }
17. }

5.5 HashMap和Hashtable的区别

No.               区别点                      HashMap                                         Hashtable

1.                 推出时间                   JDK1.2之后                                       JDK1.0

2.                 线程处理                   异步处理                                            同步处理

3.                 性能                         较快                                                  较慢

4.                 安全性                      非线程安全                                         线程安全

5.                 支持null                    允许key设置为null                             不允许key为null，否则会有NullPointerException

5.6 关于key的说明

在Map中如果一个任意的对象需要作为key保存时，则该对象需要实现Object中的equals()和hashCode()方法。

范例：覆写equals()和hashCode()来保证对象可以做key

[java]  view plain copy

 

1. import java.util.HashMap;
2. import java.util.Map;
3. class Person {
4. private String name;
5. private int age;
6. public Person(String name, int age) {
7. this.name = name;
8. this.age = age;
9. }
10. public String toString() {
11. return "姓名：" + this.name + "，年龄：" + this.age;
12. }
13. @Override
14. public int hashCode() {
15. final int prime = ;
16. int result = ;
17. result = prime * result + age;
18. result = prime * result + ((name == null) ?  : name.hashCode());
19. return result;
20. }
21. @Override
22. public boolean equals(Object obj) {
23. if (this == obj)
24. return true;
25. if (obj == null)
26. return false;
27. if (getClass() != obj.getClass())
28. return false;
29. Person other = (Person) obj;
30. if (age != other.age)
31. return false;
32. if (name == null) {
33. if (other.name != null)
34. return false;
35. } else if (!name.equals(other.name))
36. return false;
37. return true;
38. }
39. }
40. public class MapKeyDemo {
41. public static void main(String[] args) {
42. Map<Person, String> all = new HashMap<Person, String>();
43. all.put(new Person("张三", ), "ZS");
44. System.out.println(all.get(new Person("张三", )));
45. }
46. }

说明：在很多情况下，通常直接使用String作为key，String类本身已经覆写了equals()和hashCode()。

6. Stack类

Stack表示的是栈的操作类，栈是一种典型的先进先出的设计，此类是Vector的子类。

常规操作：

[java]  view plain copy

 

1. //入栈
2. public E push(E item);
3. //出栈
4. public E pop();

范例：入栈与出栈的操作

[java]  view plain copy

 

1. import java.util.Stack;
2. public class StackDemo {
3. public static void main(String[] args) {
4. Stack<String> s = new Stack<String>();
5. s.push("A");
6. s.push("B");
7. s.push("C");
8. System.out.println(s.pop());
9. System.out.println(s.pop());
10. System.out.println(s.pop());
11. System.out.println(s.pop());
12. }
13. }

7. Properties类

Properties类的主要功能是用于操作属性，在各个语言（包括操作系统）都会存在着许多的配置文件。所有的属性文件中的属性都是按照“key=value”的形式保存的，而且保存的内容都是String（字符串），此类定义如下：

public class Properties extends Hashtable<Object,Object>

此类是Hashtable的子类，而且已经默认指定好了泛型是Object，但是所有的属性操作中的类型肯定都是字符串，那么操作的时候主要使用的是Properties类完成。

Properties类中定义的主要操作方法：

No.	方法名称	类型	描述
1	public Object setProperty(String key,String value)	普通	设置属性
2	public String getProperty(String key)	普通	根据属性的名字取得属性的内容，如果没有返回null结果
3	public String getProperty(String key,String defaultValue)	普通	根据属性的名字取得属性内容，如果没有则返回默认值（defaultValue）
4	public void list(PrintStream out)	普通	从一个输出流中显示所有的属性内容
5	public void store(OutputStream out,String comments) throws IOException	普通	向输出流中输出属性
6	public void load(InputStream inStream) throws IOException	普通	从输入流中读取属性内容
7	public void storeToXML(OutputStream os,String comment)  throws IOException	普通	以XML文件格式输出属性内容
8	public void loadFromXML(InputStream in) throws IOException,InvalidPropertiesFormatException	普通	以XML文件格式输入属性内容

7.1、设置和取得属性

import java.util.Properties;

public class PropertiesDemo01 {

public static void main(String[] args) {

Properties pro = new Properties();

pro.setProperty("BJ", "BeiJing");

pro.setProperty("NJ", "NanJing");

System.out.println(pro.getProperty("BJ"));

System.out.println(pro.getProperty("TJ"));

System.out.println(pro.getProperty("TJ", "没有此地区"));

}

}

7.2、保存和读取属性

所有的属性的内容都是可以通过输出和输入流进行保存和读取的，下面先通过代码观察如何保存在普通的文件之中。

import java.io.File;

import java.io.FileOutputStream;

import java.util.Properties;

public class PropertiesDemo02 {

public static void main(String[] args) throws Exception {

Properties pro = new Properties();

pro.setProperty("BJ", "BeiJing");

pro.setProperty("NJ", "NanJing");

pro.store(new FileOutputStream(new File("D:" + File.separator

+ "area.properties")), "AREA INFO");

}

}

此时通过一个普通的文件流将所有的属性保存在了文件之中，而且一定要记住，所有的属性文件一定要使用“*.properties”作为后缀。

import java.io.File;

import java.io.FileInputStream;

import java.util.Properties;

public class PropertiesDemo03 {

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("TJ"));

System.out.println(pro.getProperty("TJ", "没有此地区"));

}

}

以上是将属性保存在了普通文件之中，也可以将其保存在XML文件之中，代码如下：

import java.io.File;

import java.io.FileOutputStream;

import java.util.Properties;

public class PropertiesDemo04 {

public static void main(String[] args) throws Exception {

Properties pro = new Properties();

pro.setProperty("BJ", "BeiJing");

pro.setProperty("NJ", "NanJing");

pro.storeToXML(new FileOutputStream(new File("D:" + File.separator

+ "area.xml")), "AREA INFO");

}

}

以后肯定也只能从XML文件格式中读取属性了。

import java.io.File;

import java.io.FileInputStream;

import java.util.Properties;

public class PropertiesDemo05 {

public static void main(String[] args) throws Exception {

Properties pro = new Properties();

pro.loadFromXML(new FileInputStream(new File("D:" + File.separator

+ "area.xml")));

System.out.println(pro.getProperty("BJ"));

System.out.println(pro.getProperty("TJ"));

System.out.println(pro.getProperty("TJ", "没有此地区"));

}

}

7.3、列出属性

在实际的开发中，如果使用了IO流进行操作的话，有可能由于编码的不同而造成乱码的问题，因为程序的编码和本地环境的编码不统一，所以会造成乱码的显示，那么该如何查询本地编码呢，就需要通过Properties类的list()方法完成。

public class PropertiesDemo06 {

public static void main(String[] args) throws Exception {

System.getProperties().list(System.out) ;

}

}

关于文件的编码，在程序中主要有以下几种：

· GB2312、GBK：表示的是国标编码，2312表示的是简体中文，而GBK包含了简体和繁体中文

· ISO 8859-1：主要用于英文字母的编码方式

· UNICODE：Java中使用十六进制进行编码，能够表示出世界上所有的编码

· UTF编码：中文采用十六进制，而普通的字母依然采用和ISO 8859-1一样的编码

在以后的程序中经常会出现乱码的问题，这种问题造成的根本原因就是在于编码不统一。

import java.io.File;

import java.io.FileOutputStream;

import java.io.OutputStream;

public class EncodingDemo {

public static void main(String[] args) throws Exception {

OutputStream output = new FileOutputStream(new File("D:"

+ File.separator + "hello.txt"));

String info = "你好啊，中国！" ;

output.write(info.getBytes("ISO8859-1")) ;

output.close() ;

}

}

7.4、工厂设计终极版

工厂设计经过发展已经有两种模型：

1、   简单工厂，所有的工厂类随着子类的增加而要修改

2、   反射工厂，只要传递进去完整的包.类，就可以完成实例化操作

但是，第2种实现本身也有问题，因为每次都要传递一个完整的“包.类”实在是太麻烦了。

import java.io.File;

import java.io.FileInputStream;

import java.util.Properties;

interface Area {

public void getInfo();

}

class BeiJing implements Area {

public void getInfo() {

System.out.println("你在北京，欢迎您！");

}

}

class NanJing implements Area {

public void getInfo() {

System.out.println("你在南京，欢迎您！");

}

}

class Factory {

public static Area getInstance(String className) {

Area a = null;

try {

a = (Area) Class.forName(className).newInstance();

} catch (Exception e) {

}

return a;

}

}

public class FactoryDemo {

public static void main(String[] args) throws Exception {

Properties pro = new Properties();

pro.load(new FileInputStream(new File("D:" + File.separator

+ "area.properties")));

Area a = Factory.getInstance(pro.getProperty("area"));

a.getInfo();

}

}

配置文件：area.properties

area=org.lxh.factorydemo.NanJing

现在的程序中可以发现，都是通过配置文件控制的，而且只要配置文件改变了，程序可以立刻发生改变。

达到了配置文件与程序相分离的目的。