Map
- 是一个双列集合接口
- 以键值对来进行存储,key,value键值对是一一对应的
- Map的键是不能重复的,值是可以重复
- Map具体的子类
HashMap,也是hash表来进行存储
TreeMap
Hashtable - map实例化
public class Test{
public static void main(String[] args){
Map<Integer,String> map = new HashMap<>();
//Intege,表示键的泛型,String表示值的泛型
}
}
Collection和Map
Collection:
- 数据结构是针对于对具体值
- 存的都是单个的元素
- 只有set集合的数据保证不重复
Map:
- 数据结构值针对于键
- 存的是一组数据,通过键值对来进行存储
- 键不能够重复
Map 常规的方法
1.增加
V put(K key, V value):返回值是null
2.删除
V remove(Object key):key表示键名,是根据键来删除值
void clear():清空集合中所有的数据
3.判断性
boolean containsKey(Object key):key是否存在
boolean containsValue(Object value):判断值是否存在
boolean isEmpty():判断是否为null
4.得到性
V get(Object key):根据键来获取具体的值
Set keySet():获取map集合中所有的键,返回的是一个key的set集合
Collection values():获取到所有的值,返回的是一个Collection集合
int size():返回的是集合的长度
Set<Map.Entry<K,V>> entrySet():获取包含所以键值对的集合
5.修改的方法
V put(K key, V value):返回值是修改前的值,如果这个数据存在,才会执行修改的方法
Map如何来进行遍历
1.第一种方式:是先获取所有的键,再通过键来获取其值
public class Test {
public static void main(String[] args) {
Map<String,String> map = new HashMap<>();
map.put("a","A");
map.put("b","B");
map.put("c","C");
Set<String> set = map.keySet();
Iterator<String> iter = set.iterator(); //使用keySet()方法和迭代器,遍历map
while(iter.hasNext()){
String temp = iter.next();
System.out.println(temp+":"+map.get(temp));
}
System.out.println("-----");
for(String temp:set){ //使用keySet()方法和增强for循环,遍历map
System.out.println(temp+":"+map.get(temp));
}
}
}
2.把map中的每一组元素当成一个对象Map.Entry<K,V>调用 getKey() getValue();
public class Test {
public static void main(String[] args) {
Map<String,String> map = new HashMap<>();
map.put("a","A");
map.put("b","B");
map.put("c","C");
Set<Map.Entry<String,String>> set = map.entrySet();
Iterator<Map.Entry<String,String>> iter = set.iterator(); //使用entrySet()方法和迭代器,遍历map
while(iter.hasNext()){
Map.Entry<String,String> temp = iter.next();
System.out.println(temp.getKey()+":"+temp.getValue());
}
System.out.println("-----");
for(Map.Entry<String,String> temp:set){ //使用entrySet()方法和增强for循环,遍历map
System.out.println(temp.getKey()+":"+temp.getValue());
}
}
}
Map子类
HashMap
- 属于Map的子类,没有顺序
- 允许null的值和null的键
- 使用hash表结构来进行存储的
- HashSet底层存数据也是使用的HashMap来进行储存的
- 常规的方法与map的方法是一样
LinkedHashMap
- 是HashMap的子类
- 以双重链表来保证数据是有序
Hashtable和HashMap
- 版本不一样,Hashtable版本是1.0,HashMap版本是1.2
- Hashtable:多线程同步,安全性高.HashMap不是线程同步的,安全性低,但是效率高
- Hashtable类名中的table首字母是小写,所以命名是不规范的,HashMap 命名是规范的
- Hashtable键值不能存null,HashMap可以存null
Collections工具类
- 导包:java.util.Collections
- 没有构造方法,提供了一些静态的方法
常规的静态的方法
public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key)
根据二分法进行查找, list是查询的集合(按升序排列),key表示查询的数据 返回值是:所在的索引public static <T> void copy(List<? super T> dest, List<? extends T> src)
dest:目的地列表(会发生改变的),把src所有的数据全部赋值给destpublic static <T> void fill(List<? super T> list,T obj)
把obj都填充到list集合里public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
根据其元素的自然顺序返回给定集合的最大元素public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
根据其元素的自然顺序返回给定集合的最小元素public static <T> boolean replaceAll(List<T> list,T oldVal,T newVal)
oldVal需要替换的值,newVal替换成什么值public static void reverse(List<?> list)
倒序public static void shuffle(List<?> list)
表示随机置换,也就是元素与元素随机交换位置public static <T extends Comparable<? super T>> void sort(List<T> list)
升序排序public static void swap(List<?> list,int i,int j)
表示元素之间交互数据,list:交换元素的列表,i:要交换的一个元素的索引, j: 要交换的其他元素的索引.
public class Test {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(3);
list.add(2);
list.add(1);
list.add(4);
list.add(5);
list.add(6);
Collections.sort(list); //排序
System.out.println(list);
System.out.println(Collections.binarySearch(list,3)); //二分搜索
Collections.shuffle(list); //随机替换
System.out.println(list);
ArrayList<Integer> ilist = new ArrayList<>(Collections.nCopies(6,0));
System.out.println(ilist);
Collections.fill(ilist,1); //填充
System.out.println(ilist);
}
}
//扑克牌随机对三人发牌
public class Test {
public static void main(String[] args) {
//创建牌堆
String[] nums = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
String[] color = {"♤","♥","♦","♣"};
List<String> cards = new ArrayList<>();
for(int i=0;i<nums.length;i++){
for(int j=0;j<color.length;j++){
cards.add(color[j]+nums[i]);
}
}
cards.add("大王");
cards.add("小王");
//创建牌堆索引
List<Integer> index = new ArrayList<>();
for(int i=0;i<cards.size();i++){
index.add(i);
}
//打乱索引
Collections.shuffle(index);
//创建玩家
List<Integer> temp01 = new ArrayList<>();
List<Integer> temp02 = new ArrayList<>();
List<Integer> temp03 = new ArrayList<>();
List<Integer> temp04 = new ArrayList<>();
//发牌
for(int i=0;i<index.size();i++){
if(i>=cards.size()-3){
temp04.add(index.get(i));
}else if(i%3==0){
temp01.add(index.get(i));
}else if(i%3==1){
temp02.add(index.get(i));
}else if(i%3==2){
temp03.add(index.get(i));
}
}
//牌组排序
Collections.sort(temp01);
Collections.sort(temp02);
Collections.sort(temp03);
Collections.sort(temp04);
//牌组输出
System.out.print("玩家1:");
for (int i:temp01){
System.out.print(cards.get(i)+" ");
}
System.out.println();
System.out.print("玩家2:");
for (int i:temp02){
System.out.print(cards.get(i)+" ");
}
System.out.println();
System.out.print("玩家3:");
for (int i:temp03){
System.out.print(cards.get(i)+" ");
}
System.out.println();
System.out.print("底牌:");
for (int i:temp04){
System.out.print(cards.get(i)+" ");
}
System.out.println();
}
}
扫一扫
1827
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
