常用方法
Map
public V put(K key, V value):
将指定的值与此映射中的指定键关联 ,返回此键之前对应的值,第一次添加此键则返回null
public void clear():
从此映射中移除所有映射关系
public V remove(Object key):
如果存在指定键,则删除此映射,返回此键对应的值,如果不存在指定键,返回null
public boolean containsKey(Object key):
如果此映射包含指定键的映射关系,则返回 true
public boolean containsValue(Object value):
如果此映射将一个或多个键映射到指定值,则返回 true
public boolean isEmpty():
如果此映射未包含键-值映射关系,则返回 true。
public Set<Map.Entry<K,V>> entrySet():
将此映射中包含的映射关系以set类型返回
public V get(Object key):
返回指定键所对应的值,如果不包含该键则返回null
public Set<K> keySet() :
将此映射中包含的键以set类型返回
public Collection<V> values():
将此映射包含的值返回
public int size():
返回此映射中的映射数
Collections
public static <T> void sort(List<T> list) :
将给定列表元素的自然顺序升序排序
public static <T> int binarySearch(List<?> list,T key):
在给定列表中以二分查找获得指定元素的索引
public static <T> T max(Collection<?> coll)
根据元素的自然顺序返回指定集合的最大元素
public static void reverse(List<?> list)
将指定列表中的元素顺序反转
public static void shuffle(List<?> list)
将指定列表的元素顺序随机打乱
public static <T> void sort(List<T> list) :
按给定列表元素的自然顺序进行升序排序
public static <T> void sort(List<T> list, Comparator<T> c)
根据指定比较器产生的顺序对指定列表进行排序
Map简介
键值对,一个映射不能包含重复的键,一个键只能映射到一个值,键相同值覆盖
Map接口和Collection接口的不同
Map是双列的,Collection是单列的
Map的键唯一,Collection的子体系Set是唯一的
Map集合的数据结构针对键有效,跟值无关;Collection集合的数据结构是针对元素有效
HashMap和Hashtable的区别
HashMap:允许null值和null键,线程不安全,效率高,不同步
HashTable:不允许null值和null键,线程安全,效率低,同步
HashMap与LinkedHashMap:
HashMap: 允许null值与null键,元素无序,键唯一
LinkedHashMap:允许null值与null键,元素有序,且键唯一。
map的遍历方式:
HashMap<Student, Integer> students = new HashMap<>();
Student hanli = new Student("hanli", 23);
Student guili = new Student("guili", 22);
Student zhangxiaofan = new Student("zhangxiaofan", 12);
students.put(hanli,1005);
students.put(guili,1006);
students.put(zhangxiaofan,1008);
1.键找值:keySet()方法
Set<Student> keySet = students.keySet();
for(Student s : keySet){
System.out.println(s.getName()+"---"+s.getAge()+"---"+students.get(s));
}
2.键值对对象:entrySet()方法
Set<Map.Entry<Student, Integer>> entries = students.entrySet();
for(Map.Entry<Student,Integer> entry: entries){
System.out.println(entry.getKey().getName()+"---"
+entry.getKey().getAge()+"---"+entry.getValue());
}
TreeMap:
不允许null键,线程不安全,效率高,不同步
键的数据结构是二叉树,可保证键的排序和唯一。
排序同TreeSet,分为自然排序和比较器排序。
集合嵌套:
1.HashMap套HashMap:例
HashMap<String, Integer> jichu = new HashMap<>();
HashMap<String, Integer> jiuye = new HashMap<>();
jichu.put("张三",20);
jichu.put("李四",22);
jiuye.put("王五",21);
jiuye.put("赵六",23);
HashMap<String, HashMap<String, Integer>> westos = new HashMap<>();
westos.put("基础班",jichu);
westos.put("就业班",jiuye);
Set<String> key = westos.keySet();
for(String s : key ){
System.out.println(s);
HashMap<String, Integer> stu = westos.get(s);
Set<Map.Entry<String, Integer>> entries = stu.entrySet();
for(Map.Entry<String, Integer> entry:entries){
System.out.println("\t"+entry.getKey()+"---"+entry.getValue());
}
}
2.HashMap套ArrayList:例
ArrayList<Student> jichu = new ArrayList<>();
ArrayList<Student> jiuye = new ArrayList<>();
jichu.add(new Student("张三",20));
jichu.add(new Student("李四",22));
jiuye.add(new Student("王五",21));
jiuye.add(new Student("赵六",23));
HashMap<String, ArrayList<Student>> westos = new HashMap<>();
westos.put("基础班",jichu);
westos.put("就业班",jiuye);
Set<String> key = westos.keySet();
for(String s :key){
System.out.println(s);
ArrayList<Student> students = westos.get(s);
for(Student stu : students){
System.out.println("\t"+stu.getName()+"---"+stu.getAge());
}
}
集合工具类Collections模拟斗地主洗牌和发牌并对牌进行排序的代码实现:
package homework.day0804;
import org.westos.day0804.MyComparator;
import java.util.*;
public class Doudizhu2 {
public static void main(String[] args) {
//新牌
HashMap<Integer, String> newPoker = getPoker();
//有序号的牌
ArrayList<Map.Entry<Integer, String>> poker = new ArrayList<>();
//玩家和底牌
TreeMap<Integer, String> a = new TreeMap<>(new MyComparator());
TreeMap<Integer, String> b = new TreeMap<>(new MyComparator());
TreeMap<Integer, String> c = new TreeMap<>(new MyComparator());
TreeMap<Integer, String> d = new TreeMap<>(new MyComparator());
Set<Map.Entry<Integer, String>> entries = newPoker.entrySet();
for(Map.Entry<Integer, String> entry : entries){
poker.add(entry);
}
//洗牌
Collections.shuffle(poker);
Collections.shuffle(poker);
Collections.shuffle(poker);
//发牌
for (int i=0;i<poker.size();i++){
Map.Entry<Integer, String> one =poker.get(i);
if(i>=poker.size()-3){
d.put(one.getKey(),one.getValue());
}else if(i%3 == 0){
a.put(one.getKey(),one.getValue());
}else if(i%3 == 1){
b.put(one.getKey(),one.getValue());
}else {
c.put(one.getKey(),one.getValue());
}
}
//看牌
look("a",a);
look("b",b);
look("c",c);
look("d",d);
}
public static void look(String name,Map<Integer,String> map){
System.out.println("玩家"+name);
Set<Integer> key = map.keySet();
for (Integer i : key){
System.out.print(map.get(i)+" ");
}
System.out.println();
}
public static HashMap<Integer,String > getPoker(){
ArrayList<String> pokerList = new ArrayList<>();
String[] hua = {"方块","梅花","红桃","黑桃"};
String[] zi = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
for(int i=0;i<zi.length;i++){
for(int j=0;j<hua.length;j++){
pokerList.add(hua[j].concat(zi[i]));
}
}
HashMap<Integer, String> poker = new HashMap<>();
for(int i=0;i<52;i++){
poker.put(i,pokerList.get(i));
}
poker.put(52,"小王");
poker.put(53,"大王");
return poker;
}
}