集合框架2

Map<K,V>:

是另外一个顶级接口，用来保存键值对。Map 和 Collection 的区别就是，Map 存的是一对一对的数据，Collection

存的是一个一个的数据。Map 中保存的是键值对 Map<key,Value> ，Key 值不允许重复。(如果 key 已经存在，则被

覆盖，返回被覆盖后的 value。如果 key 不存在，则返回 null。)

常用方法：put(K key,V value); 该方法可以将 key 和 value 存到 Map 对象

get(Object key); 该方法可以根据 key 值返回对应的 value。

size(); 返回 Map 对象中键值对的数量。

常用实现类：HashMap

key 值的 hashCode 和 equals 保证元素唯一性。

TreeMap

不仅可以保证 key 不重复，还可以对 value 数据进行排序。

HashTable

jdk1.0中定义的类，实现同步。

Map集合：Map 集合是以键值对存放的，Map 接口中提供了将 key 与 value 分别转变成 Collection 对象的方法，然后就

可以使用 Iterator 分别遍历 Map 的 key 以及 value。

public class UserInfo {

private String name;
private int age;

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public static void main(String[] args) {
UserInfo user1=new UserInfo();
user1.setName("王华");
user1.setAge(12);
UserInfo user2=new UserInfo();
user2.setName("小华");
user2.setAge(8);
UserInfo user3=new UserInfo();
user3.setName("张华");
user3.setAge(12);
//TreeMap 中想要存放有序的对象，Key 类需要继承 Comparable 类
//Set<UserInfo> userSet=new TreeSet<UserInfo>();
Set<UserInfo> userSet=new HashSet<UserInfo>();
userSet.add(user1);
userSet.add(user2);
userSet.add(user3);
//构造迭代器
Iterator<UserInfo> it=userSet.iterator();
while(it.hasNext()){
UserInfo info=it.next();
System.out.println(info.getName()+info.getAge());
}
}
}

Set<E>

Set 接口主要有两个实现类，HashSet、TreeSet，常用的是 HashSet

Set 接口继承了 Collection 接口。

Set 中所存储的元素是不重复的,但是是无序的,也就是说 Set 中的元素是没有索引的

TreeSet 是可排序的

Set<E> 接口的实现类

HashSet<E>

HashSet<E> 类按照哈希算法来存取对象，当向集合中加入一个新对象时，会调用对象的 hashCode() 方法

得到对象的哈希码，然后根据这个码计算出对象在集合中存储的位置。

TreeSet<E>

可以给 Set 集合中的元素进行指定方式的排序。存储的对象必须实现 Comparable 接口。

HashSet<E> 的常用方法

add(E e); 将指定的元素添加到 set。（如果此 set 中尚未包含指定元素，则添加指定元素。）

TreeSet<E> 的常用方法

add(E e); 将指定的元素添加到 set（如果尚未存在于该set中）。

first(); 返回已排序 set 中当前的第一个（最低）元素。

last(); 返回已排序 set 中当前的最后一个（最高）元素。

例如：HashSet 的使用和 ArrayList 是相同的。

import java.util.Set;
import java.util.TreeSet;

public class TreeSetExemple {
public static void main(String[] args) {
User user1=new User("张华");
User user2=new User("张星");
Set userSet=new TreeSet();
userSet.add(user1);
userSet.add(user2);
Set<User> userSet1=new TreeSet<User>();
userSet1.add(user1);
userSet1.add(user2);
}
}

例如：TreeSet 中存放的对象需要实现 Comparable

public class UserInfo implements Comparable<UserInfo> {
private String name;
private int age;

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

@Override
public int compareTo(UserInfo o) {
if(o.getName().equals(name)){
return 0;
}else
return 1;
}
}
public class TreeSetExemple {
public static void main(String[] args) {
UserInfo user1=new UserInfo();
user.setName("张华");
UserInfo user2=new UserInfo();
user2.setName("王华");
Set<UserInfo> userSet =new TreeSet<UserInfo>();
userSet.add(user1);
userSet.add(user2);
}
}

两种遍历方式。（HashSet 和 TreeSet 的遍历）

增强for循环/迭代器遍历

public class SetExemple {
public static void main(String[] args) {
User user1=new User(“王辉");
User user2=new User("qw");
Set<User> userSet=newHashSet<User>();
Set<User> userSet=new TreeSet<User>();
userSet.add(user1);
userSet.add(user2);
//增强for循环遍历
for(User user:userSet ){
System.out.println(user.getUserName());
}
}
}

Properties

是 Map 的另一个实现类，是比较早的类，主要用来处理属性及属性文件。学习IO后，看 Properties

处理属性文件的例子更容易

是 Hashtable 类的子类，所以也间接地实现了 Map 接口。在实际应用中，常使用 Properties 类对

属性文件进行处理。

常用方法：

load(); 加载文件。

getProperty(key); 通过 key 值获得对应的 value 值

setProperty(String key,String value); 给 properties 文件中写值。

public static void main(String[] args) {
Properties props=new Properties();

try {
props.load(new FileInputStream(new File("test.properties")));
props.setProperty("age", "13");

} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}

System.out.println(props.getProperty("name"));
System.out.println(props.getProperty("password"));
}

Collections 类

与接口 Collection 非常类似的名字，但是它是一个类，这个类是集合的工具类，定义了大量静态的

处理集合的方法，与数组的工具方法 Arrays 类非常类似同步集合对象的方法对 List 排序的方法

Collections 方法的介绍

Set<T> synchronizedSet(Set<T> s) 返回由指定 set 支持的同步（线程安全）的 set。

Map<K,V> synchronizedMap(Map<K,V> m) 返回由指定 map 支持的同步（线程安全）的 map。

对List 排序的方法

sort(List<T> list> 根据元素的自然顺序 对指定列表按升序进行排序。(泛型对象需要实现 Comparator)

Collections 类对 ArrayList 的排序使用

public class User implements Comparable<User>{
private int userAge;

public User(int age) {
super();
this.userAge = age;
}

public int getUserAge() {
return userAge;
}

public void setUserAge(int userAge) {
this.userAge = userAge;
}

@Override
public int compareTo(User o) {
return this.userAge<o.getUserAge()?1:this.userAge==o.getUserAge()?0:-1;
}
}
//对List集合排序
public class GenericsList {
public static void main(String[] args) {
User user4= new User(11); // 创建用户对象
User user1 = new User(14);
User user2 = new User(13);
User user3 = new User(9);
List<User> userList = new ArrayList<User>(); // 创建集合对象，存放用户对象
userList.add(user4);
userList.add(user1);
userList.add(user2);
userList.add(user3);
for(User u:userList){
System.out.println(u.getUserAge());
}
Collections.sort(userList);//调用排序方法
for(User u:userList){
System.out.println(u.getUserAge());
}
}
}