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

2019独角兽企业重金招聘Python工程师标准>>>

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一样，这里就不介绍了

转载于:https://my.oschina.net/u/274829/blog/313405