Set
特点：无序，无重复2
两大实现类：HashSet和TreeSet
HashSet，根据对象的哈希值来确定对象在元素中的储存位置，因此具有良好的存取和查找性能
TreeSet，以二叉树的方式来储存元素，可以实现对集合中的元素进行排序
public class Example01:
public void static main(String[] args){
HashSet set = new HashSet();
set.add("peter");
set.add("morton");
set.add("mary");
set.add("mary);
Iterator it = set.iterator();
while(it.hashNext()){
Object o = it.next();
}
}
}
对象存入HashSet类，要先调用对象的hashCode()方法来获取对象的哈希值，然后再
调用equals()来比较对象是否相等
如果自定义的对象没有重写hashCode()和equals()方法，有时候会出错：
class Person{
String id;
String name;
person(String id , String name){
this.id = id;
this.name = name;
}
//重写toString方法
public String toString(){
return id + ":" + name;s
}
}
class Example02 {
public void static main(String[] args){
HashSet set = new HashSet();
set.add(new Person("21","peter");
set.add(new Person("22","mary");
set.add(new Person("22","mary");
}
}
这样的话，会出现重复
正确的写法：
Person {
String id;
String name;
Person(String id , String name){
this.id = id;
this.name = name;
}
//重写toString()
public String toString(){
return id + ":" + name;
}
//重写hashCode()
public int hash(){
retrun id.hashCode();
}
//重写equals()方法
public boolean equals(Object o){
if(this == o)
return false;
if(!(o instanceof Person))
return false;
Person p = (Person) o ;
return p.id.equals(this.id);
}
//equals()是所有类的一个共有方法，其重写规则为：直接比较---类型比较---强转类型比较属性
public class Example03{
public void static main(String[] args){
HashSet set = new HashSet();
set.add(new Person("22","Mike");
set.add(new Person("22","Mike");
}
}
这样的话，就避免了重复添加两个相同对象
TreeSet：
二叉树就是每个节点最多有两个子节点的有序树
TreeSet内部使用的是自平衡的排序二叉树，其特点是储存的元素会按照大小排序以及能避免重复
HashedSet是不能重复（重写hashCode()和equals()方法），而TreeSet是比较大小(重写
compareTo(Object to)方法，或者重写比较器implements Comparator)
不重写compareTo()方法时，会自动按照常见的方式来排序（如首字母顺序）
class Example04{
public void static main(String[] args){
TreeSet ts = new TreeSet();
ts.add("aaaaaaaa");
ts.add("ccccccc");
ts.add("bbbbbbbb");
Iterator iterator = ts.iterator();
while(iterator.hasNext()){
System.out.println(ts.next());
}
}
}
这样出来的是aaaaaa,bbbbb,ccccccccc
class Person {
String id;
String name;
//构造函数
Person(String id , String name){
this.id = id;
this.name = name;
}
//重写toString()方法
public String toString(){
return id + ":" + name;
}
//重写compareTo()
public int compareTo(Object o){
Person p = (Person) o;
x = Integer.parseInt(this.id);
y = Integer.parseInt(p.id);
if((x - y ) > 0){
return 1;
}
if(x == y ){
return p.name.compareTo(this.name);
}
return -1;
}
}
class Example05{
public void static main(Stringp[] args){
TreeSet set = new TreeSet();
set.add(new Person("33","sldf");
...
set.add(new Person("34","sfgg");
}
}
还可以自己实现comparator写个自定义的比较器
class MyComparator implements comparator{
//重写compare()方法
public int compare(Object o1, Object o2){
//强转为String
String s1 = (String) o1;
String s2 = (String) o2;
return (s1.length - s2.length);
}
}
public class Example06{
public void static main(String[] args){
//实例化TreeMap,并且传入自定义的比较器
TreeMap tm = new TreeMap(new MyComparator);
tm.add("sssssssssssss");
tm.add("adfsdfa");
tm.add("trwtwrt");
//添加迭代器
Iterator it = tm.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
学完collection，再看Map接口
7个常用的方法：
2boolean：
boolean containsKey(Object key)
boolean containsKey(Object value)
void put(Object key,Object value)
Object get(Object key)
//以下三个方法比较重要
Set keySet()---返回此映射包含的键的视图
Collection<v> values()---返回此映射包含的值的Collection视图
Set<Map.Entry<K,V>> entrySet()---返回此映射包含的所有键值对
注意返回值格式：
Set<Map.Entry<K,V>>
Map.Entry是Map的一个接口内部类，entry是条目的意思
和Set一样，Map接口主要有HashMap和TreeMap两个实现类
HashMap类：
public class Example15{
public void static main(String[] args){
Map map = new HashMap(); //创建hashmap
map.put("1","aaa"); //储存键值对，注意Collection是add(),Map是Put()
map.put("2","bbb");
map.put("3","ccc");
map.put("4","ddd");
System.out.println("1"+map.get("1"));
System.out.println("2"+map.get("2"));
}
}
利用entrySet()和keySet()方法可以实现Map的遍历
public class Example16{
public void static main(String[] args){
Map map = new Map();
map.put("1","aaa"); //储存键值对，注意Collection是add(),Map是Put()
map.put("2","bbb");
map.put("3","ccc");
map.put("4","ddd");
Set key = map.keySet();
Iterator it = key.iterator();
while(it.hasNext()){
String s = it.next();
String ss = map.get(s);
}
}
}
第二种遍历方法：
public class Example17{
public void static main(String[] args){
Map map = new Map();
map.put("1","aaa"); //储存键值对，注意Collection是add(),Map是Put()
map.put("2","bbb");
map.put("3","ccc");
map.put("4","ddd");
Set set = map.entrySet();
Iterator it = set.Iterator();
while(it.hasNext()){
Map.Entry me = it.next();
Object key = me.getKey();
Object value = me.getValue();
}
}
}
HashMap里还有最后一个东西：LinkedHashMap
与LinkedList一样都是使用双向链表来维护内部元素的关系，使得Map元素的迭代的顺序与存入的顺序一致。。所以它的特点就是：迭代出来的元素顺序和存入的顺序一致
public class Example18 {
public void static main(String[] args){
Map map = new LinkedHashMap();
map.put("1","qqq");
map.put("2","www");
map.put("3","eee");
//获取全部键的集合
Set keys = map.keySet();
//获取迭代器
Iterator it = keys.iterator();
while(it.hasNext()){
Object key = it.next();
Object value = map.get(key);
System.out.println(value);
}
}
}
TreeMap:通过二叉树的原理来保证键的唯一性，与TreeSet集合存储的原理一样，因此TreeMap中所有的键都是按照某种顺序排列的,其中最关键的还是比较器
一般根据String类型来排序，String类实现了Comparable接口，因此会默认按照自然顺序进行排序，当然也可以自定义选择器。
一般情况：
class Example19{
public void static main(String[] args){
Map map = new TreeMap(); //new一个TreeMap
map.put("1","feriosa"); //向Map中放入键值对
map.put("2","max");
map.put("3","nux");
Set keys = map.keySet(); //得到全部键的集合
Iterator it = keys.iterator(); //得到迭代器
while(it.hasNext()){ //开始迭代
Object key = it.next();
Object value = map.get(key) //得到键所对应的值
}
}
}
如前所述，会按照String类型来排序(默认为从小到大)
自定义选择器的情况：(从大到小)
class Example20{
public void static main(String[] args){
Map map = new TreeMap(new MyComparator()) //传入自定义选择器的实例
map.put("1","feriosa");
map.put("2","max");
map.put("3","nux");
Set keys = map.keySet(); //得到键的Set集合
Iterator it = keys.iterator(); //得到迭代器
while(it.hasNext()){ //开始迭代
Object key = keys.next();
Object value = map.get(key);
System.out.println(value);
}
}
class MyComparator implements Comparator { //自定义选择器
public int compare(Object o1, Object o2){
String s1 = (String) o1;
String s2 = (String) o2; //强转为String类型
return s1.compareTo(s2); //返回较大值
}
}
|
|
收藏
淘帖
踩
