Arraylist、HashSet去重复 treeSet排列实现方法 HashMap遍历取值

摘要: java Arraylist去除重复元素、Hashset去重复 treeSet排列实现方法 HashMap遍历取值两种方式

java提供的Arraylist本身不能对添加的元素进行去重，需要在添加后进行比较，如果相同就不添加

public static ArrayList single(ArrayList al) {

ArrayList temp = new ArrayList();

Iterator it = al.iterator();

while(it.hasNext()){
Object obj = it.next();

if(!temp.contains(obj)){  //如果元素已经存在就不添加 确保不重复
temp.add(obj);
}
}

return temp;
}

java里Hashset默认可以自动对字符型等简单对象进行去重复，如

public static void main(String[] args) {

HashSet hs = new HashSet();

hs.add("hehe");
hs.add("xixii");
hs.add("hehe");

Iterator it = hs.iterator();

while(it.hasNext()){
System.out.println(it.next());
}
}

HashSet判断是否重复时，先判断HashCode是否一样，两个对象hashcode不相等，他们一定不equals。两个对象hashcode相等，他们不一定equals，还需要进一步判断。再重写equals方法，步骤

1. 判断传入的对象是否为空，如果为空，没有比较的必要 返回false

2. 判断当前对象是否和传入对象是同一个对象，如果是一个对象，没有必要比较，返回true

3. 判断当前对象是否和传入的对象类型相同，如果不同，没有比较的意义 返回false

4. 如果当前对象和传入对象类型相同（传入对象可以是相同或者子类），将传入的对象强制转换为当前对象类型

5. 逐个的来比较对象中的每一个属性值（对象的比较用equals()方法，基本类型用==，double,float 有精度损失的，可以将其转换成对应的Double,Float后在调用equals()进行比较）

public class Person {

private String name;
private int age;

public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}

@Override
public int hashCode() {
return name.hashCode()+age*27;  //不同对象产生不同的hashcode 不会调用equals提高效率
}

@Override
public boolean equals(Object obj) {

if(this == obj)   //判断是否为同一个对象 是返回 true 证明已经存在
return true;
if(!(obj instanceof Person))  //不是同一对象 判断是否 隶属于 person类对象
throw new ClassCastException("类型错误"); //不是抛出异常

Person p = (Person)obj;  //转换为 Person类型

return this.name.equals(p.name) && this.age == p.age; //返回 是否存在
}
}

排序有两种实现方式：comparable和Comparator

第一种 comparable 排序

TreeSet排序 实现comparable接口 只有TreeSet可以排序 HashSet不可以，所有的set都可以去重复

public class Person implements Comparable<Person> {

........
........

public int compareTo(Person p){

int temp = this.age - p.age;  //按年龄排序
return temp==0?this.name.compareTo(p.name):temp;   //年龄相同按姓名排序
}

}

例子

public static void main(String[] args) {

TreeSet ts = new TreeSet();  //TreeSet对象

ts.add(new Person("zhangsan",28));
ts.add(new Person("lisi",21));
ts.add(new Person("wangu",24));
ts.add(new Person("zangu",24));

Iterator it = ts.iterator();
while(it.hasNext()){
Person p = (Person)it.next();

System.out.println(p.getName()+":"+p.getAge());
}

}
先按年龄 相同年龄 再按姓名。
结果：lisi 21
wanggu 24
zangu  24
zhangsan 28

第2种 comparator排序

public class ComparatorByName implements Comparator {

@Override
public int compare(Object o1, Object o2) {

Person p1 = (Person)o1;
Person p2 = (Person)o2;

int temp = p1.getName().compareTo(p2.getName());  //先按姓名
return temp==0?p1.getAge()-p2.getAge(): temp;     //再按年龄排
}
}

public static void main(String[] args) {

TreeSet ts = new TreeSet(new ComparatorByName());

ts.add(new Person("zhangsan",28));
ts.add(new Person("lisi",21));
ts.add(new Person("zangu",24));
ts.add(new Person("zangu",26));

Iterator it = ts.iterator();

while(it.hasNext()){
Person p = (Person)it.next();
System.out.println(p.getName()+":"+p.getAge());
}
}
结果：lisi 21
zangu 24
zangu 26
zhangsan 28

map键值对 遍历值的获取

entrySet可以直接获取 key和value keySet() 先获得key 然后通过get(key)获得value值

public static void method(Map<Integer,String> map){

Map<Integer,String> map = new HashMap<Integer,String>();
map.put(8,"zhaoliu");
map.put(2,"zhaoliu");
map.put(7,"xiaoqiang");
map.put(6,"wangcai");

Collection<String> values = map.values();  //获得value值

Iterator<String> it2 = values.iterator();
while(it2.hasNext()){
System.out.println(it2.next());
}

Set<Map.Entry<Integer, String>> entrySet = map.entrySet();  //

Iterator<Map.Entry<Integer, String>> it = entrySet.iterator();

while(it.hasNext()){
Map.Entry<Integer, String> me = it.next();
Integer key = me.getKey();        //获得key
String value = me.getValue();     //获得value
System.out.println(key+"::::"+value);
}

Set<Integer> keySet = map.keySet();
Iterator<Integer> it = keySet.iterator();

while(it.hasNext()){
Integer key = it.next();
String value = map.get(key);
System.out.println(key+":"+value);
}
}

HashMap 每个key 只有一个value 最后一次key的value会重新以前的value。

keySet实现HashMap遍历

public static void main(String[] args) {

HashMap<Student,String> hm = new HashMap<Student,String>();

hm.put(new Student("lisi",38),"北京");
hm.put(new Student("zhaoliu",24),"上海");
hm.put(new Student("zhaoliu",24),"铁岭");

Iterator<Student> it = hm.keySet().iterator();

while(it.hasNext()){
Student key = it.next();      //先得到key
String value = hm.get(key);   //根据key获得value
System.out.println(key.getName()+":"+key.getAge()+"---"+value);
}
}

输出结果 lisi 38 北京

zhaoliu 24 铁岭 //替换了前面的 上海的那个

TreeMap也可以实现排列 Comparator，方式与TreeSet一样，这里就不介绍了