Map
Map: 映射, 是雙列集合頂層介面
java.util.Map<k,v>
k: key 鍵 唯一
v: value 值 可重復
常用方法和Entry
public V put(K key,V Value)
// 指定的鍵與指定值添加到Map集合中, 添加成功回傳null, 添加失敗回傳之前的值
public V putIfAbsent(K key,V Value)
// jdk1.8后新增 鍵相同值不覆寫回傳原來的值
public V get(Object key)
// 根據指定的鍵, 獲取對應值, 不存在回傳null
public V getOrDefault(Object key, V defaultValue)
// jdk1.8后新增 不存在回傳defaultValue
public boolean containsKey(Object key)
// 判斷集合中是否包含指定的鍵
public V remove(Object key)
// 根據指定的鍵, 洗掉一對元素, 回傳被洗掉的值
public V remove(Object key, Object value)
// 根據指定的鍵和值, 都一致則洗掉, 回傳被洗掉的值
Set<K> keySet()
// 獲取存放所有鍵的Set集合
Collection<V> values()
// 獲取存放所有值的集合
Set<Map.Entry<K, V>> entrySet()
// 獲取鍵值對映射關系物件的Set集合
interface Entry<K,V>
K getKey()
// 獲取映射關系物件中的鍵
V getValue()
// 獲取映射關系物件中的值
LinkedHashMap
底層資料結構: 鏈表 + 哈希表
鏈表保證元素有序 哈希表保證元素唯一
public class Demo {
public static void main(String[] args) {
Map<String, Integer> map = new LinkedHashMap<>();
map.put("1張三",14);
map.put("2李四",17);
// put
// 添加成功回傳 null
System.out.println(map.put("3王五", null));
// 添加失敗回傳之前的值, 并用新值覆寫
System.out.println(map.put("2李四", 19));
// putIfAbsent
// 鍵不存在添加新的鍵值對, 添加成功回傳null
System.out.println(map.putIfAbsent("4劉六", 19));
// 若鍵存在 原有值不改變 并回傳原有值
System.out.println(map.putIfAbsent("1張三", 11));
// get
// 根據鍵找值, 存在則回傳鍵對應的值
System.out.println(map.get("1張三"));
// 不存在則回傳null
System.out.println(map.get("2"));
// getOrDefault
// 鍵存在 回傳對應值
System.out.println(map.getOrDefault("1張三", -1));
// 若不存在 則回傳defaultValue
System.out.println(map.getOrDefault("2", -1));
// 判斷集合中是否包含指定的鍵, 存在回傳true, 不存在回傳false
System.out.println(map.containsKey("2李四"));
// 根據鍵洗掉一對元素 回傳被洗掉的值
// 不存在則回傳null
System.out.println(map.remove("1"));
System.out.println(map.remove("1張三"));
System.out.println(map);
// 遍歷
// 方式1
// 獲取存放所有鍵的集合
Set<String> set = map.keySet();
// 獲取存放所有值的集合
Collection<Integer> values = map.values();
// 迭代器
Iterator<Integer> iterator = values.iterator();
while (iterator.hasNext()) {
System.out.print(iterator.next() + " ");
}
System.out.println();
// 增強for
for (Integer value : values) {
System.out.print(value + " ");
}
System.out.println();
// 迭代器
Iterator<String> it = set.iterator();
while (it.hasNext()) {
String key = it.next();
System.out.print(key + " = " + map.get(key) + "\t");
}
System.out.println();
// 增強for
for (String s : set) {
System.out.print(s + " = " + map.get(s) + "\t");
}
System.out.println();
// 方式2
// Entry是Map的內部類 所以呼叫時需要Map.Entry
Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
// 迭代器
Iterator< Map.Entry<String, Integer>> entries = entrySet.iterator();
while (entries.hasNext()) {
Map.Entry<String, Integer> next = entries.next();
System.out.print(next.getKey() + " = " + next.getValue() + "\t");
}
System.out.println();
// 增強for
for (Map.Entry<String, Integer> entry : entrySet) {
System.out.print(entry.getKey() + " = "+entry.getValue() + "\t");
}
}
}
TreeMap
java.util.TreeMap
底層資料結構是紅黑樹 鍵 排序 具有唯一性 不允許null鍵 允許null值
/*
java.util.TreeMap
底層資料結構是紅黑樹 鍵 排序 具有唯一性 不允許null鍵 允許null值
構造方法:
public TreeMap() 空參構建, 集合中的鍵必須實作自然排序介面 Comparable 的方法 CompareTo
public TreeMap(Comparator<? super K> comparator) 需傳入比較器物件
*/
public class Demo {
public static void main(String[] args) {
TreeMap<Person, String> map = new TreeMap<>();
map.put(new Person("張三",12),"bj");
map.put(new Person("張三",14),"sh");
map.put(new Person("李四",15),null);
map.put(new Person("王五",11),"gz");
map.put(new Person("宮本",19),"jp");
// 不允許null鍵
// map.put(null,"us");
System.out.println(map);
// 獲取第一個鍵
System.out.println(map.firstKey());
// 獲取最后一個鍵
System.out.println(map.lastKey());
// 獲取第一個鍵值對
System.out.println(map.firstEntry());
// 獲取最后一個鍵值對
System.out.println(map.lastEntry());
// 獲取 按排序方法 取索引 >= 指定鍵的最小鍵(>=指定鍵并距離最近)
System.out.println(map.ceilingKey(new Person("李四", 13)));
// 獲取 按排序方法 取索引 >= 指定鍵的最小鍵值對(>=指定鍵并距離最近)
System.out.println(map.ceilingEntry(new Person("李四", 13)));
// 獲取 按排序方法 取索引 <= 指定鍵的最小鍵(<=指定鍵并距離最近)
System.out.println(map.floorKey(new Person("李四", 13)));
// 獲取 按排序方法 取索引 <= 指定鍵的最小鍵值對(<=指定鍵并距離最近)
System.out.println(map.floorEntry(new Person("李四", 13)));
System.out.println("=================");
TreeMap<Person, String> treeMap = new TreeMap<>(new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
if (o1.age == o2.age) {
return o2.name.compareTo(o1.name);
}
return o1.age - o2.age;
}
});
treeMap.put(new Person("張三",12),"bj");
treeMap.put(new Person("張三",14),"sh");
treeMap.put(new Person("李四",15),null);
treeMap.put(new Person("王五",11),"gz");
treeMap.put(new Person("宮本",19),"jp");
System.out.println(treeMap);
}
}
class Person implements Comparable<Person> {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(Person o) {
if (o.age == this.age) {
return o.name.compareTo(this.name);
}
return o.age - this.age;
}
@Override
public String toString() {
return "{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
HashMap
/*
java.util.HashMap
底層資料結構是哈希表 允許null鍵和null值 鍵是無序的 具有唯一性
先比較hashCode
不同 元素不相同
相同 繼續比較equals
相同
不同
因此必須重寫hashCode和equals方法
*/
public class Demo {
public static void main(String[] args) {
Map<Person, String> map = new HashMap<Person, String>();
map.put(new Person("張三",12),"bj");
map.put(new Person("李四",12),"sh");
map.put(new Person("王五",12),"gz");
map.put(new Person("宮本",12),"jp");
map.put(null,"us");
Set<Person> peopleSet = map.keySet();
for (Person person : peopleSet) {
if (person == null) {
System.out.println(person + " " + map.get(person));
continue;
}
System.out.println(person.getName() + " " + person.getAge() + " " + map.get(person));
}
Set<Map.Entry<Person, String>> entries = map.entrySet();
for (Map.Entry<Person, String> entry : entries) {
Person key = entry.getKey();
if (key == null) {
System.out.println(key + " " + entry.getValue());
continue;
}
System.out.println(key.getName() + " "+ key.getAge() + " "+entry.getValue());
}
}
}
class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
if (age != person.age) return false;
return name != null ? name.equals(person.name) : person.name == null;
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
}
可變引數
在JDK1.5之后，如果我們定義一個方法需要接受多個引數，并且多個引數型別一致，我們可以對其簡化.
// 格式
修飾符 回傳值型別 方法名(引數型別... 形參名){ }
/*
可變引數 指引數的個數可變
當引數資料型別確定,且需要較多次多載時, 可以使用可變引數
可變引數必須放在引數串列的最后, 且只能有一個可變引數
格式: 本質上就是陣列
public static int avg(int... nums)
當不傳入引數時, 相當于傳了空陣列
由于本質是陣列, 因此傳入陣列也可以
*/
public class function {
public static void main(String[] args) {
System.out.println(avg(1,2,3,4,5,7,8,9,2));
System.out.println(avg(18,9,2));
System.out.println(avg(1,2));
int[] arr = {1,23,42,45,34,21};
System.out.println(avg(arr));
}
public static int avg(int... nums) {
int sum = 0;
for (int i = 0; i < nums.length; i++) {
sum += nums[i];
}
return sum / nums.length;
}
}
練習
使用Map重寫前天第十一題
使用54張牌打亂順序,三個玩家參與游戲，三人交替摸牌，每人17張牌，最后三張留作底牌.
import java.util.*;
public class PokerDemo {
public static void main(String[] args) {
Map<Integer, String> pokerMap = new HashMap<Integer, String>();
ArrayList<Integer> pokerIndex = new ArrayList<Integer>();
String[] colors = {"?","?","?","?"};
String[] numbers = "2-A-K-Q-J-10-9-8-7-6-5-4-3".split("-");
int index = 2;
pokerMap.put(0, "大王");
pokerMap.put(1, "小王");
for (String number : numbers) {
for (String color : colors) {
pokerMap.put(index, color+number);
index++;
}
}
for (int i = 0; i < 54; i++) {
pokerIndex.add(i);
}
Collections.shuffle(pokerIndex);
ArrayList<Integer> player1 = new ArrayList<Integer>();
ArrayList<Integer> player2 = new ArrayList<Integer>();
ArrayList<Integer> player3 = new ArrayList<Integer>();
ArrayList<Integer> dipai = new ArrayList<Integer>();
for (int i = 0; i < pokerIndex.size(); i++) {
if (i >= 51){
dipai.add(pokerIndex.get(i));
} else if (i % 3 == 0) {
player1.add(pokerIndex.get(i));
} else if (i % 3 == 1) {
player2.add(pokerIndex.get(i));
} else {
player3.add(pokerIndex.get(i));
}
}
System.out.println("玩家1: " + showPoker(player1, pokerMap));
System.out.println("玩家2: " + showPoker(player2, pokerMap));
System.out.println("玩家3: " + showPoker(player3, pokerMap));
System.out.println("底牌: " + showPoker(dipai, pokerMap));
}
public static String showPoker(ArrayList<Integer> player, Map<Integer, String> pokerMap) {
Collections.sort(player);
StringBuilder sb = new StringBuilder("[");
for (int i = 0; i < player.size(); i++) {
sb.append(pokerMap.get(player.get(i)));
if (i == player.size() - 1) {
sb.append("]");
} else {
sb.append(", ");
}
}
return sb.toString();
}
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/549741.html
標籤：其他