小蓝xlanll

这个屌丝很懒，什么也没留下！

热门标签

11.18笔记_lgd.remove()

作者：小蓝xlanll | 2024-03-25 03:29:16

踩

lgd.remove()

MAP集合

比如 key-------------value

Abcd-------------1234

像这种键值对应关系的数据,Java给我们提供了一种容器,就是Map集合

Map一个根接口学习几个实现类: HashMapHashtable TreeMap,用多态的方式来创建对象

Map<String, String> hm = newHashMap<String, String>();

Map是双列集合,主要用来存储有键值对应关系的数据 Map是一个接口

HashMapHashtable区别 HashMap非同步的,效率高,数据不安全 Hashtable同步的,效率第,数据安全

HashMap底层数据结构是哈希表特点:元素无序且唯一元素唯一是靠元素重写 equlse方法和hashCode方法

//LinkedHashMap 底层数据结构是链表和哈希表链表保证元素有序,哈希表保证元素唯一

//TreeMap 底层数据结构是二叉树它能够对元素进行排序排序对元素有要求要求元素实现 Comparable<T>接口

//重写 compareTo 方法元素放置的顺序就是根据这个方法的返回值正负 0来确定

//常见方法

HashMap<Object,Object> hm = new HashMap<>();

//hm.put(key, value); 添加数据第一次添加返回值是null 再添加就会上一次的值键相同值覆盖

//hm.size() 获取集合长度

//hm.isEmpty()//判断集合是否为空

//hm.containsKey(key) 判断集合有没有这个键

//hm.containsValue(value) 判断集合有没有这个值

//hm.get(key) 根据键获取对应值

//hm.keySet() 获取所有的键的set集合

//hm.entrySet();// 获取所有的键值对对象集合 Entry<Object, Object> 有两个方法 getKey 和

//getValue

//hm.values(); 获取所有值的集合

//hm.clear(); 清除所有的元素

//hm.remove(key) 根据键移除一对

1 存储数据用put 方法,放置数据

第一次采用put 放置数据的时候返回的是null

第二次放置键相同的数据会返回上一次的值


import java.util.HashMap;
import java.util.Map;
public class MapDemo {
	public static void main(String[] args) {
		String str = hm.put("EDG", "666");
		String str2 = hm.put("RNG1", "233");
		hm.put("LGD", "886");
		hm.put("JDG", "663");
		System.out.println(str);
		System.out.println(str2);
		System.out.println(hm);//打印地址值,或者其它

2 删除功能

voidclear():移除所有的键值对元素

Vremove(Object key)：根据键删除键值对元素，并把值返回

hm.clear();

Stringvalue = hm.remove("LGD");//根据键名从集合中移除这个组键值,返回这个键所对应的值

System.out.println(value);

System.out.println(hm);

3 判断功能

boolean containsKey(Object key)：判断集合是否包含指定的键

boolean containsValue(Object value):判断集合是否包含指定的值

boolean isEmpty()：判断集合是否为空

boolean b = hm.containsKey(5);

b = hm.containsValue("电子竞技");

hm.clear();

b = hm.isEmpty();

4 获取功能

Set<Map.Entry<K,V>> entrySet(): 返回一个键值对的Set集合

V get(Object key):根据键获取值

Set<K> keySet():获取集合中所有键的集合

Collection<V> values():获取集合中所有值的集合

遍历Map集合

Set<K> keySet():获取集合中所有键的集合

Set<Integer>keySet = hm.keySet();//获取键的集合

for (Integer key : keySet) {

hm.get(key)通过键找值

System.out.println(key+ "=====" + hm.get(key));

}

Map集合的数据结构只跟键有关跟值没关系

第二种遍历Map 集合的方式

Set<Map.Entry<K,V>> entrySet(): 返回一个键值对的Set集合

Entry<K,V>键值对对象 ,把键和值封装起来看做一个对象

Entry<K,V>

getKey()

返回与此项对应的键。

VgetValue()

返回与此项对应的值。

entrySet();获取所有的键值对对象Entry<Integer, String>

Set<Entry<Integer,String>> entrySet = hm.entrySet();

for(Entry<Integer, String> en : entrySet) {

Entry键值对对象里面提过了两个方法 getKey获取键 getValue 获取值

System.out.println(en.getKey()+ "----" + en.getValue());

}

获取map 集合中所有的值

Collection<String>values = hm.values();

for(String v : values) {

System.out.println(v);

}

举例


import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
public class MapDemo {
	public static void main(String[] args) {
		// A:案例演示: HashMap集合键是String值是Student的案例
		HashMap<String, Student> hm = new HashMap<String, Student>();
		hm.put("01", new Student("熊大", 81));
		hm.put("02", new Student("熊二", 82));
		hm.put("03", new Student("熊三", 83));
		hm.put("04", new Student("熊四", 84));
		hm.put("05", new Student("熊无", 85));
		System.out.println(hm);
		// 方式1
		Set<String> keySet = hm.keySet();
		for (String key : keySet) {
			System.out.println(key + "====" + hm.get(key).getName() + "--" + hm.get(key).getAge());
		}
		// 方式2 遍历
		System.out.println("-------------------------------------------------------------------");
		Set<Entry<String, Student>> entrySet = hm.entrySet();
		for (Entry<String, Student> en : entrySet) {
			String key = en.getKey();
			Student stu = en.getValue();
			System.out.println(key + "==" + stu.getName() + "--" + stu.getAge());
		}
	}
}

LinkedHashMap的概述: Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序

LinkedHashMap的特点：底层的数据结构是链表和哈希表元素有序并且唯一

元素的有序性由链表数据结构保证唯一性由哈希表数据结构保证

Map集合的数据结构只和键有关

LinkedHashMap<Integer, String> map =new LinkedHashMap<Integer, String>();

有序:指的是存的顺序跟取的顺序一致


public static voiimport java.util.LinkedHashMap;
import java.util.Map.Entry;
import java.util.Set;
public class Test3 {
public static void main(String[] args) {		
		map.put(1, "狗大);
		map.put(0, "狗二");
		map.put(3, "狗三");
		map.put(4, "狗大");
		map.put(2, "狗小");
		map.put(1, "狗五");
		// 遍历
		Set<Entry<Integer, String>> entrySet = hm.entrySet();
		for (Entry<Integer, String> en : entrySet) {
			Integer key = en.getKey();
			String value = en.getValue();
			System.out.println(key + "===" + value);
		}
	}
}


import java.util.Collection;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
public class MapTest {
         publicstatic void main(String[] args) {
                   HashMap<Integer,String> hm = new HashMap<Integer, String>();
                   hm.put(1,"斗鱼");
                   hm.put(2,"虎牙");
                   hm.put(3,"熊猫");
                   hm.put(4,"天才);
                   hm.put(5,"战旗");
                   判断功能
                   booleancontainsKey(Object key)：判断集合是否包含指定的键
                   booleancontainsValue(Object value):判断集合是否包含指定的值
                   booleanisEmpty()：判断集合是否为空
                   booleanb = hm.containsKey(5);
                   b= hm.containsValue("斗鱼");
                   hm.clear();
                   b= hm.isEmpty();
                   System.out.println(b);
 
                   获取功能
                   Set<Map.Entry<K,V>>entrySet(): 返回一个键值对的Set集合
                    V get(Object key):根据键获取值
                   Set<K>keySet():获取集合中所有键的集合
                   Collection<V>values():获取集合中所有值的集合
 
                    Set<K> keySet():获取集合中所有键的集合
                   Vget(Object key):根据键获取值
                   System.out.println("------------------------------------------------");
                   Set<Integer>keySet = hm.keySet();//获取键的集合
                   for(Integer key : keySet) {
                            hm.get(key)通过键 找值
                            System.out.println(key+ "=====" + hm.get(key));
                   }

TreeMap

TreeMap:数据结构是红黑树特点:元素唯一,而且还能对元素进行排序 :自然排序和比较器排序TreeMap 不允许插入null键


TreeMap<Student, String> map = new TreeMap<Student, String>();
		// new TreeMap(new Comparator<Student>() {
		//
		// @Override
		// public int compare(T o1, T o2) {
		// // TODO Auto-generated method stub
		// return 0;
		// }
		// });
	public static void main(String[] args) {
		TreeMap<String, String> treeMap = new TreeMap<String, String>();
		// treeMap.put(null, "abc");
		// treeMap.put(null, null);
		treeMap.put("ddd", null);
		System.out.println(treeMap);
		// 获取map集合的长度 size()
		System.out.println(treeMap.size());
	}
 
}

用TreeMap 存储键是Integer 值是 String 类型的数据

TreeMap 底层数据结构是红黑树它能够保证元素唯一,能够对元素进行排序,排序要有条件排序的元素必须实现Comparable接口重写 CmcompareTo(T)

元素实现了Comparable<Integer> 接口重写了里面的CmcompareTo(To) 比较此对象与指定对象的顺序。


import java.util.Set;
importjava.util.TreeMap;
public class TreeDemo2 {
    public static void main(String[]args) {
    TreeMap<Integer,String>map= new TreeMap<Integer,String>();
    map.put(0, "RNG");
    map.put(1, "EDG");
    map.put(3, "LGD");
    map.put(2, "QG");
    Set<Integer>keySet=map.keySet();
    for(Integer mp :keySet){
       System.out.println(mp+map.get(mp));
    }
   
    }
}

二 Collection


importjava.io.LineNumberInputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.ListIterator;
 
public class ListUtils {
    publicstatic void main(String[] args) {
// 集合工具类 Collections 针对的是 Collection集合
 
// Collections类概述: 针对集合操作 的工具类
// Collections成员方法
// public static <T> voidsort(List<T> list): 排序,默认按照自然顺序
// public static <T> intbinarySearch(List<?> list,T key): 二分查找
// public static <T> Tmax(Collection<?> coll): 获取最大值
// public static voidreverse(List<?> list): 反转
// public static voidshuffle(List<?> list): 随机置换
 
       ArrayList<Integer>list = new ArrayList<Integer>();
        list.add(20);
       list.add(30);
       list.add(1);
       list.add(0);
       list.add(10);
       //采用集合工具类进行排序
       Collections.sort(list);
 
       //Object[] a = list.toArray();//先把集合转成数组
       //Arrays.sort(a);//排列数组里面的元素
       //获取迭代器
       //ListIterator<T> i = list.listIterator();
       //遍历集合中的元素
       //for (int j=0; j<a.length; j++) {
       //i.next();//获取每一个元素
       //i.set((T)a[j]);//替换了集合中的元素
       //}
 
       //public static <T> int binarySearch(List<?> list,T key);
//  二分查找,前提是元素必须有序
       intindex = Collections.binarySearch(list, 20);
       System.out.println(index);
       Integermax = Collections.max(list);
       Integermin = Collections.min(list);
       System.out.println(max+ "==" + min);
       //随机打乱集合中元素的顺序
       //Collections.shuffle(list);
       Collections.reverse(list);
       System.out.println(list);
    }
 
}

课堂练习:1案例演示:需求：用户随便输入一段字符串统计字符串中每个字符出现的次数


importjava.util.HashMap;
importjava.util.Scanner;
import java.util.Set;
 
public class Test1 {
public static void main(String[] args) {
HashMap<Character, Integer> map = new HashMap<Character, Integer>();
Scanner sc = new Scanner(System.in);
System.out.println("请输入一段字符");
String str = sc.nextLine();
char [] chs =str.toCharArray();
for (char key: chs){
    Integer value =map.get(key);
    if(value == null){
       map.put(key,1);
    }else{
       value++;
       map.put(key,value); 
      
    }
}
Set<Character> keySet= map.keySet();
StringBuilder sb = new StringBuilder();
for (Character ch : keySet) {
    sb.append(ch).append("(").append(map.get(ch)).append(")");
 
}
System.out.println(sb.toString());
}
}

2嵌套排序


import java.util.HashMap;
import java.util.Set;
 
public class Test2 {
public static void main(String[] args) {
	HashMap <String,Integer> map1 = new HashMap<String,Integer>();
	map1.put("RNG",666);
	map1.put("edg",622);
	HashMap<String, Integer> map2 = new HashMap<String,Integer>();
	map2.put("LGD", 233);
	map2.put("QG", 2233);
	HashMap<String, HashMap<String, Integer>> map = new HashMap<String,HashMap<String,Integer>>();
	map.put("LPL", map1);
	map.put("lspl",map2);
	Set<String>keySet=map.keySet();
	for(String key:keySet){
		System.out.println(key);
	HashMap<String, Integer> map3 = map.get(key);
	Set<String> keySet2 = map3.keySet();
	for(String key2:keySet2){
		System.out.println(key2+map3.get(key2));
	}
System.out.println();
	}
}
}

2HashMap和Hashtable的区别:

HashMap: 线程不安全,效率高.允许null值和null键

Hashtable: 线程安全 , 效率低.不允许null值和null键

4 斗地主小游戏


import java.util.ArrayList;
import java.util.Collections;
 
public class Game2 {
public static void main(String[] args) throws Exception{
	ArrayList<String> Paibox = new ArrayList<String>();
	String[] colors ={ "♥", "♠", "♦", "♣" };
	String[] nums =  { "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K" };
	for (String color : colors){
		for (String num: nums){
			Paibox.add(color+num);
			
		}
	}
	Paibox.add("☼");
	Paibox.add("☽");
	Collections.shuffle(Paibox);
	Collections.shuffle(Paibox);
	ArrayList<String> RNG = new ArrayList<String>();
	ArrayList<String> EDG = new ArrayList<String>();
	ArrayList<String> LGD = new ArrayList<String>();
	ArrayList<String> 底牌 = new ArrayList<String>();
	for (int i =0;i<Paibox.size();i++){
		if(i>=Paibox.size()-3){
			底牌.add(Paibox.get(i));
		}else if (i%3==0){
			RNG.add(Paibox.get(i));
			
		}else if (i%3==1){
			EDG.add(Paibox.get(i));
			
		}else if (i%3==0){
			LGD.add(Paibox.get(i));
		}
	}
			lookPai("RNG", RNG);
			lookPai("EDG", EDG);
			lookPai("LGD", LGD);
			lookPai("底牌", 底牌);
			
		}
	
	
	
 
 
private static void lookPai(String string, ArrayList<String> list) {
	System.out.println(string);
	for (String pai:list){
		System.out.println(pai+" ");
	}
	System.out.println();
	
}
}

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/306682