一,TreeSet
TreeSet是一种可以指定顺序的Set集合,指定顺序的方式有两种,自然顺序(Comparable,比较器(Comparator);
1,Comparable : 在要放入TreeSet集合的类上实现Comparable接口,重写compareTo方法,对象存入TreeSet的时候就会按照compareTo()方法排序;
2,Comparator : 如果两个TreeSet存储同一类型对象,需要使用不同顺序,那么Comparable接口就无法满足这样的需求了,compareTo()方法只有一个,无法定义两种比较方法;,
如果不希望TreeSet按照Comparable的顺序排序,可以再创建TreeSet的时候,在构造杉树中传入一个比较器,
创建TreeSet对象时,构造函数可以接收一个Comparator类型的对象;
我们可以自定义一个Comparator类的子类,重写Compare()方法;
一旦构造函数中传入了Comparator,TreeSet将不再按照Comparable中的顺序排序,add()方法执行时自动按照Comparator的顺序排序;
二,集合分类:
Collection:单列集合,一次存一个对象,
List: 可重复,有索引
LinkedList:链表结构,查找慢,增删快
ArrayList :数组结构,查找快,增删慢;
Vector: 原理和ArrayList相同,线程安全,效率低,被ArrayList取代,java1.0出现的
特有方法:枚举;
Stack: 栈,先存的对象最后才能被取出;
Set: 不重复,无索引
*HashSet: 使用哈希算法,除去重复,速度快
*TreeSet: 使用二叉树算法,按照指定顺序排序,指定顺序的方式有:自然排序,比较器
LinkedHashSet: HashSet的子类,也是使用哈希算法,但可以保留原存储顺序;
Map: 双列集合;键值对,一次存两个对象,键唯一,可以根据键查找值
*HashMap: 使用哈希算法对键对象除去重复;
*TreeMap : 使用二叉树算法对键对象排序;
LinkedHashMap: HashMap的子类,除去重复的同时保留存储顺序
Hashtable: : 和HashMap原理相同,都是使用哈希算法除去重复,线程安全,效率较低,不允许键和值为null,被HashMap取代;
Properties: : 键和值都是String,用来存储一些配置项;
三:Map集合:
Map集合用来存储键值对,每次存储2个对象,一个键一个值,形成映射关系,可以根据键查找值,键必须唯一;
*Map集合常用方法:
V put(K key,V value)
存储一个键值对,如果键在集合中存在,值将会覆盖原有值,且返回原有值;如果不存在,直接存,返回null;
V get(Object key)
根据键获取值,如果不存在,返回null
V remove(Object key)
根据键删除值,并将值返回,如果不存在,返回null
Boolean containsKey(Object key)
判断指定的键对象是否存在;
举例:
package cn.itcast;
import java.util.HashMap;
import java.util.Map;
publicclass Test {
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
//put();
//contains();
//putAll();
//remove();
Map<String,Integer>map = new HashMap<String,Integer>();
map.put("秦琼", 89);
map.put("程咬金",90);
map.put("隋炀帝", 50);
System.out.println(map.put("秦琼", 9));
System.out.println(map.put("袁绍", 34));
}
publicstaticvoid remove() {
Map<String,Integer>map = new HashMap<String,Integer>();
map.put("秦琼", 89);
map.put("程咬金",90);
map.put("隋炀帝", 50);
System.out.println(map.remove("秦琼"));
System.out.println(map.remove(78));
}
publicstaticvoid putAll() {
Map<String,Integer> map1 = new HashMap<String,Integer>();
map1.put("秦琼", 89);
map1.put("程咬金",90);
map1.put("隋炀帝", 50);
Map<String,Integer>map2 = new HashMap<String,Integer>();
map2.put("秦琼", 999);
map2.put("程咬金",9);
map2.put("宇文画戟", 50);
//putAll:将map2集合中所有元素装入map1中;
map1.putAll(map2);
System.out.println(map1);
}
publicstaticvoid contains() {
Map<String,Integer>map = new HashMap<String,Integer>();
map.put("秦琼", 89);
map.put("程咬金",90);
map.put("隋炀帝", 50);
System.out.println(map.containsKey(90));
//boolean类型,判断集合是否包含指定键,
System.out.println(map.containsKey("秦琼"));
//boolean类型,判断集合是否包含指定值;
System.out.println(map.containsValue(90));
System.out.println(map.containsValue("秦琼"));
}
publicstaticvoid put() {
Map<String,Integer>map = new HashMap<String,Integer>();
//使用put,指定键与值之间发生映射关系;
map.put("曹操",90);
map.put("孙权",null);
map.put("赵云", 90);
System.out.println(map);
//打印集合长度;
System.out.println(map.size());
//清空map集合;
map.clear();
//判断集合是否为空,空则返回true;
System.out.println(map.isEmpty());
System.out.println(map.size());
//结果是Boolean型,如果包含指定键,返回true;
System.out.println(map.containsKey("庞统"));
System.out.println(map.containsValue(90));
}
}
*Map集合遍历的两种方式:
**keySet:
Map集合的keySet()方法可以得到一个所有键对象组成的Set集合;
遍历这个Set集合可以得到每一个键对象;
再根据键对象即可获取所映射的值;
**entrySet :
Map集合的entrySet()方法可以得到一个Map.Entry对象(键值对)组成的set集合
遍历这个Set集合可以得到每一个Map.Entry对象
再使用Map.Entry的getKey ()方法和getValue方法获取键和值;
例:
package Map;
importjava.util.HashMap;
publicclass MapIteratorDemo {
/**取出map集合中的键值对,有2中方式;keySet和entrySet
* @param args
*/
publicstaticvoid main(String[] args) {
//TODOAuto-generated method stub
//keySet();
entrySet();
}
publicstaticvoid entrySet() {
Map<String,Integer> hs = new HashMap<String,Integer>();
hs.put("aaa", 1);
hs.put("xxx", 4);
hs.put("abc", 3);
//map集合的entrySet方法可以得到一个所有entry(键值对映射关系)组成的set集合
Set<Map.Entry<String,Integer>> s = hs.entrySet();
//遍历set集合可以得到每一个entry对象;
Iterator<Map.Entry<String,Integer>> it = s.iterator();
while(it.hasNext()) {
Map.Entry<String,Integer> e =it.next();
//在使用entry的getkey和getvalue获取键和值
if(e.getKey().equals("aaa"))
e.setValue(100);
System.out.println(e.getKey() +"..."+ e.getValue());
}
/*
//使用增强for循环.
Set<Entry<String, Integer>> s= hs.entrySet();
for(Entry<String,Integer> e: s) {
System.out.println(e.getKey()+">>"+e.getValue());
}
*/
}
publicstaticvoid keySet() {
Map<String,Integer> hs = new HashMap<String,Integer>();
hs.put("aaa", 1);
hs.put("xxx", 4);
hs.put("abc", 3);
Set<String> s = hs.keySet();
//使用迭代器的方法取出map集合中键值对;
Iterator<String> it = s.iterator();
while(it.hasNext()) {
String key = it.next();
Integer value = hs.get(key);
System.out.println(key +"="+value);
}
/*
//Map集合的keySet方法可以得到每一个键对象所组成的Set集合
Set<String> s = hs.keySet();
//使用增强for循环取出键对象;
for(String str : s)
//根据键获取值;
System.out.println(str+"="+hs.get(str));
*/
}
}
Map常用类:
|--HashMap:底层是哈希表数据结构,允许使用 null值和 null 键,该集合是不同步的。将hashtable替代,jdk1.2.效率高。
|--TreeMap:底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。
Map集合扩展:一键对多值;map集合被使用是因为具备映射关系;
例:
package Map;
importjava.util.*;
publicclass MapDemo3 {
/**
* map集合扩展:一键对多值;并打印处键和值;
* 例:基础班,学号,姓名;
*"base","01","张三";
*"base","02","李四";
就业班,学号,名字;
*"work","01","王五";
*"work","02","赵六";
*
* @param args
*/
publicstaticvoid main(String[] args) {
//将学号和姓名形成映射关系,装入一个班级Map集合中;再将班级名称和班级集合形成映射关系,装进另一个Map集合中;
demo1();
//创建一个学生类,将学号和姓名封装进学生类中,将学生类装入一个List集合中,再将班级名称和List集合形成映射关系,装进一个Map集合中;这种方式比较常见,如.一个公司,有不同部门,部门中有不同的员工;这就是一键对多值关系;
demo2();
}
publicstaticvoid demo2() {
//将学生的信息封装在Studen里,
List<Studen> base = new ArrayList<Studen>();
//向集合中添加对象;
base.add(new Studen("01","张三"));
base.add(new Studen("02","李四"));
List<Studen> work = new ArrayList<Studen>();
work.add(new Studen("01","王五"));
work.add(new Studen("02","赵六"));
HashMap<String,List<Studen>>hs =newHashMap<String,List<Studen>>();
//向hs集合中添加键值对;
hs.put("base", base);
hs.put("work", work);
//将集合中的key组成set集合;
Set<String> set = hs.keySet();
//使用增强for循环,取出hs集合中的key组成的set集合元素;
for(String str :set) {
//打印hs集合中的键值;
System.out.println(str);
//将遍历到的键所映射的值再次遍历;因为是List集合,不是map集合,所以不用keyset和entrySet方法转换,直接遍历
for(Studen s: hs.get(str))
//打印num和name;
System.out.println(s);
}
}
publicstaticvoid demo1() {
//基础班的集合对象;
HashMap<String, String> base =new HashMap<String, String>();
//向集合中添加学号和名字;
base.put("01","张三");
base.put("02","李四");
//就业班的集合对象;
HashMap<String, String> work =new HashMap<String, String>();
work.put("01","王五");
work.put("02","赵六");
//学校的集合对象;包括班级名字和班级内的学员;
HashMap<String, HashMap<String,String>> hs =newHashMap<String, HashMap<String, String>>();
//向集合中添加班级名字和班级的集合对象;
hs.put("base", base);
hs.put("work", work);
//使用迭代器方法取出学校中所有的班级和学员;采用循环嵌套循环的形式;
//使用hs集合的entrySet方法调用Map.Entry类,得到hs集合的所有映射关系;再使用迭代器遍历每一个映射关系;
Iterator<Entry<String,HashMap<String,String>>>it = hs.entrySet().iterator();
while(it.hasNext()) {
//定义变量记住键值对;
Entry<String,HashMap<String,String>>e = it.next();
//打印班级名称;
System.out.println(e.getKey()+"----");
//使用迭代器取出班级中的键值对;
//使用遍历到的班级名称所对应的班级,调用keySet方法,使用迭代器获取班级中的键所组成的集合的对象;
Iterator<String> iter =e.getValue().keySet().iterator();
while(iter.hasNext()) {
//定义变量记住遍历到的键;
String s = iter.next();
//打印键和值;
System.out.println(s +":::"+e.getValue().get(s));
}
}
}
}
class Studen {
private Stringname;
private Stringnum;
Studen(String num,String name) {
this.num = num;
this.name = name;
}
public String toString() {
returnnum +"->"+name;
}
}