技術標籤：javahashmap

每新增一個物件，都會呼叫hashcode方法
1.TreeSet
排好序的, 並且 不允許重複
set 無序並且不允許重複
tree底層利用的是紅黑樹
排序：
自定義的類
Integer
String
return 0 代表即將要新增的元素和現有的元素重複 則不新增
升序：this>o return 1
this<o return -1
降序 this>o return -1;
this<o return 1;
TreeSet 可以排序的, 泛型是自定義類的話 必須實現排序介面
Comparable 自然排序
2.自然排序

1. 在泛型中的自定義類中實現Comparable<自定義類名>
2. 重寫compareTo方法
3. 建立TreeSet集合,向集合中新增元素
   一個元素比較排序

public class Student implements Comparable<Student>{
	int age;
	public Student(int age) {
		super();
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [age=" + age + "]";
	}
	@Override
	public int compareTo
 
(Student o) {		System.out.println("===compareTo===");
		if(this.age>o.age) {
			return -1;
		}else if (this.age<o.age) {
			return 1;
		}		
		return 0;
	}
}
public class Test {
	public static void main(String[] args) {
		TreeSet<Student> set = new TreeSet<>();
		set.add(new
 
 Student(5));
		set.add(new Student(33));
		set.add(new Student(1));
		set.add(new Student(6));
		set.add(new Student(6));
		System.out.println(se);		
	}
}

兩個元素比較排序

public class Animal implements Comparable<Animal>{
	String name;
	int age;	
	public Animal(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public int compareTo(Animal o) {
		//第一條件 age  降序
		if(this.age>o.age) {
			return -1;
		}else if (this.age<o.age) {
			return 1;
		}else {
			//第二條件 姓名升序
			int num = this.name.compareTo(o.name);
			return num;
		}		
	}
	@Override
	public String toString() {
		return "Animal [name=" + name + ", age=" + age + "]";
	}
}
public class Test {
	public static void main(String[] args) {
		TreeSet<Animal> set = new TreeSet<>();
		set.add(new Animal("zhangsan", 4));
		set.add(new Animal("zhangsan", 4));
		set.add(new Animal("zhangsan", 14));
		set.add(new Animal("lisi", 14));
		set.add(new Animal("wangwu", 14));		
		for (Animal animal : set) {
			System.out.println(animal);
		}
}

3.定製排序
1.編寫自定義類
2.單獨定義比較器類,實現Comparator<自定義類>
3. 重寫compare方法
4.建立TreeSet集合,new TreeSet<>(new 比較器物件)
定製排序比自然排序耦合性低

public class Student {
	String name;
	int age;
	public Student() {
		super();		
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
}
import java.util.Comparator;
public class StudentComparator implements Comparator<Student>{
	//compare和CompareTo方法一樣
	@Override
	public int compare(Student o1, Student o2) {
		//年齡降序排序
		if(o1.age>o2.age) {
			return -1;
		}else if (o1.age<o2.age) {
			return 1;
		}
		return 0;
	}
}
import java.util.TreeSet;
public class Test {
	public static void main(String[] args) {
		TreeSet<Student> set = new TreeSet<>(new StudentComparator());
		set.add(new Student("a",1));
		set.add(new Student("a",5));
		set.add(new Student("a",4));
		set.add(new Student("a",2));
		set.add(new Student("a",11));
		for (Student student : set) {
			System.out.println(student);
		}
	}
}

4.Map的三種遍歷方法
不能通過增強for迴圈直接遍歷集合
1.Set<Map.Entry<K,V>> entrySet()
2.Set keySet()
3.Collection values()
通過一些方式進行轉換, 轉換成 set,Collection這種集合進行遍歷
Set keySet()

import java.util.Collection;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
public class Test {
	public static void main(String[] args) {
		HashMap<String, Integer> map = new HashMap<>();
		// 新增元素
		map.put("a", 1);
		map.put("b", 2);
		map.put("c", 3);
		// 如果鍵有相同,鍵只能儲存一份，但是新的值覆蓋舊的值
		map.put("a", 5);
		System.out.println(map);
		// 判斷是否包含指定的鍵
		boolean b = map.containsValue("a");
		System.out.println(b);
		// 判斷是否包含指定的值
		boolean containValue = map.containsValue(13);
		System.out.println(containValue);
		// 判斷是否為空（集合中沒有元素） 沒有元素結果為true 有元素結果為false
		boolean empty = map.isEmpty();
		System.out.println(empty);
		// 根據鍵 得到值
		Integer value = map.get("a");
		System.out.println(value);
		// 1. 將集合中所有的鍵全部拿到
		Set<String> keys = map.keySet();
		for (String key : keys) {
			Integer value2 = map.get(key);
			System.out.println(key + "=" + value2);
		}
		// 2. Collection<V> values() 只能拿到所有的值
		// 只能通過鍵找值,不能通過值找鍵
		Collection<Integer> values = map.values();
		for (Integer integer : values) {
			System.out.println(integer);
		}
		// 3. Set<Map.Entry<K,V>> entrySet()
		Set<Entry<String, Integer>> set = map.entrySet();
		for (Entry<String, Integer> entry : set) {
			String key = entry.getKey();
			Integer value2 = entry.getValue();
			System.out.println(key + "=" + value2);
		}
	}
}