* 双列集合： Map
如果实现了Map接口的集合类，具备的特点： 存储的数据都是以键值对的形式存在的，键不可重复，值可以重复；
* HashMap* TreeMap
* Hashtable
添加：
put(K key, V value) 将指定的值与此映射中的指定键关联。
putAll(Map<? extends K,? extends V> m) 从指定映射中将所有映射关系复制到此映射中。
删除：
clear() 从此映射中移除所有映射关系。
remove(Object key) 如果存在一个键的映射关系，则将其从此映射中移除。
获取：
get(Object key) 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
size() 返回此映射中的键-值映射关系数。
判断：
isEmpty() 如果此映射未包含键-值映射关系，则返回 true。
containsKey(Object key) 如果此映射包含指定键的映射关系，则返回 true。
containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true。
equals(Object o) 比较指定的对象与此映射是否相等。
import java.util.HashMap;
import java.util.Map;
public class test_1 {
public static void main(String[] args) {
Map<String, String> aa = new HashMap<String, String>();
// 添加方法
aa.put("付祖贤", "仙女");
aa.put("祖贤", "女侠");
aa.put("贤", "女");
/* // 返回 以前与 key 关联的值，如果没有针对 key 的映射关系，则返回 null。
System.out.println(aa.put("祖贤", "女"));
aa.put("祖", "女");
Map<String, String> bb = new HashMap<String,String>();
bb.put("a", "b");
bb.put("c", "d");
aa.putAll(bb);*/
// 删除
// aa.remove("付祖贤"); // 以前与 key 关联的值；如果没有 key 的映射关系，则返回 null
// 获取
// 只能根据键来获取值，不能根据值来获取键
// System.out.println(aa.get("祖贤"));
// 返回此映射中的键-值映射关系数。
// System.out.println(aa.size());
// 判断
System.out.println(aa.containsKey("贤"));
System.out.println(aa.containsValue("女"));
aa.put(null, null); // 不空 存在映射 null=null
System.out.println(aa.isEmpty());
System.out.println(aa);
}
}
运行结果：
true
true
false
{null=null, 付祖贤=仙女, 祖贤=女侠, 贤=女}
迭代：
Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的 Set 视图。Set<K> keySet() 返回此映射中包含的键的 Set 视图。
Collection<V> values() 返回此映射中包含的值的 Collection 视图
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class test_1 {
public static void main(String[] args) {
Map<String, String> aa = new HashMap<String, String>();
// 添加方法
aa.put("付祖贤", "仙女");
aa.put("祖贤", "女侠");
aa.put("贤", "女");
/* // map 集合遍历方式一 ： 使用 keySet() 方法遍历
// 缺点： 只返回了键，没有返回值
Set<String> keys = aa.keySet(); // 把map集合中的所有键都保存到一个Set类型的集合对象中返回
Iterator<String> it = keys.iterator();
while(it.hasNext()) {
String key = it.next();
System.out.println( key + " " + aa.get(key));
// System.out.println(); // 实际上指针下移2次
} */
/* // map 集合遍历方式二 ： Collection<V> values() 返回此映射中包含的值的 Collection 视图。
// 缺点更大。。。。
Collection<String> c = aa.values();
Iterator<String> it2 = c.iterator();
while(it2.hasNext()) {
System.out.println(it2.next());
}*/
// map 集合遍历方式三：
// Map.Entry 静态内部类
Set<Map.Entry<String, String>> ents = aa.entrySet();
Iterator<Map.Entry<String, String>> it3 = ents.iterator();
while(it3.hasNext()) {
Map.Entry<String, String> entry = it3.next();
System.out.println(entry.getKey() + " " + entry.getValue());
}
System.out.println(aa);
}
}
/////
* 首先会调用键的hashcode方法得到元素的哈希码值，然后经过运算就可以算出该元素在哈希表中的存储位置；
*
* 情况1： 如果算出的位目前没有任何元素存储， 直接存储
* 情况2： 该位置有其他元素， 那么该元素的equals方法与这个位置的元素进行比较，返回false，允许存储，true，不允许存储；
import java.util.HashMap;
import java.util.Map;
class Person{
int id;
String name;
public Person(int id, String name) {
super();
this.id = id;
this.name=name;
}
@Override
public String toString() {
return "{编号： " + this.id + " 姓名: " + this.name + "}";
}
@Override
public boolean equals(Object obj) {
Person p = (Person)obj;
return this.id == p.id;
}
@Override
public int hashCode() {
return this.id;
}
}
public class test_1 {
public static void main(String[] args) {
HashMap<Person, String> aa = new HashMap<Person,String>();
aa.put(new Person(1, "付祖贤"), "仙女");
aa.put(new Person(2, "祖贤"), "女侠");
aa.put(new Person(3, "贤"), "女神经");
// 为什么哈希码值不一样？？？？为什么可以存储？？？？？
// 重写hascode，equals 不能存了，后来的赶走前面的
aa.put(new Person(1, "付祖贤"), "女疯子");
System.out.println(aa);
}
}
运行结果：
{{编号： 1 姓名: 付祖贤}=女疯子, {编号： 2 姓名: 祖贤}=女侠, {编号： 3 姓名: 贤}=女神经}
* TreeMap
* 基于红黑树的 NavigableMap 实现。该映射根据其键的自然顺序进行排序，* 或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。
import java.util.Comparator;
import java.util.TreeMap;
class emp implements Comparable<emp>{
// class emp {
String name;
int salary;
public emp(String name,int salary) {
this.name = name;
this.salary = salary;
}
@Override
public String toString() {
return "{姓名： " + this.name + " 薪水： " + this.salary + "}";
}
@Override
public int compareTo(emp a) {
return this.salary-a.salary;
}
}
class Mycomparator implements Comparator<emp>{
@Override
public int compare(emp a1, emp a2) {
return a1.salary-a2.salary;
}
}
public class test_1 {
public static void main(String[] args) {
/*TreeMap<Character, Integer> aa = new TreeMap<Character,Integer>();
aa.put('f', 10);
aa.put('z', 5);
aa.put('x', 3);*/
Mycomparator c = new Mycomparator();
TreeMap<emp, String> aa = new TreeMap<emp, String>(c);
aa.put(new emp("付祖贤", 1000), "a");
aa.put(new emp("祖贤", 4000), "c");
aa.put(new emp("贤", 2000), "d");
// 根据薪水比较，如果薪水一样，键不变，但是值改变
aa.put(new emp("仙女", 2000), "e");
System.out.println(aa);
}
}
运行结果： 值发生改变。。。。
{{姓名： 付祖贤 薪水： 1000}=a, {姓名： 贤 薪水： 2000}=e, {姓名： 祖贤 薪水： 4000}=c}
* 集合的工具类 （collections）
* collections ： 操作集合对象的一个工具类
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
/*
* 集合的工具类 （collections）
* collections ： 操作集合对象的一个工具类
* Collections：常见方法：
*/
class person {
String name;
int age;
public person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "{姓名： " + this.name + " 年龄： " + this.age + "}";
}
}
class myc implements Comparator<person>{
@Override
public int compare(person a1, person a2) {
return a1.age-a2.age;
}
}
public class test_1 {
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList();
list1.add(6);
list1.add(2);
list1.add(5);
Collections.sort(list1);
System.out.println("二分查找： " + Collections.binarySearch(list1, 2));
System.out.println("找出最大值： " + Collections.max(list1));
Collections.reverse(list1); // 反转不需要比较器
Collections.synchronizedList(list1); // 线程安全
System.out.println(list1);
// 不具备自然顺序，
myc c = new myc();
ArrayList<person> list = new ArrayList<person>();
list.add(new person("fzx",10));
list.add(new person("zx",12));
list.add(new person("x",1));
// 不具备自然顺序，需要传入比较器
Collections.sort(list,c);
System.out.println("查找某对象： " + Collections.binarySearch(list, new person("x",1),new myc()));
System.out.println("找出最大的对象： " + Collections.max(list, new myc()));
}
}
运行结果：
二分查找： 0
找出最大值： 6
[6, 5, 2]
查找某对象： 0
找出最大的对象： {姓名： zx 年龄： 12}