集合框架map

青春属于表白

于 2022-06-09 20:13:15 发布

阅读量281

点赞数

文章标签： java j2ee

本文链接：https://blog.csdn.net/weixin_61523879/article/details/125209990

版权

map集合的特点：

增删改查

HashMap与 Hashtable的区别

map集合的特点：

1、增删改查

2、以键值对形式存在

3、key可以为空

增删改查

Map<String,Integer> map = new HashMap<>();
        //增
        map.put("a", 1);
        map.put("b", 2);
        map.put("c", 3);
        map.put("d", 4);
        System.out.println("增："+map);
        //删
        map.remove("b");
        System.out.println("删："+map);
        //改 也是调put方法
        map.put("b", 23);
        System.out.println("改："+map);
        
        //查询单个  根据键拿到值
        //map.get("这里直接放键，也就是key");
            System.out.println("查单个："+map.get("c"));
        
        //查询全部(这里列举了一种方式，具体请看下方的遍历方式)
        Set keys = map.keySet();
        for (Object key : keys) {
            System.out.println("键："+key+"值："+map.get(key));
        }

看效果图

这里说一个题，面试的时候可能会提到：

HashMap与 Hashtable的区别

这里定义了两个集合，一个是HashMap，一个是Hashtable，分别给两个集合放入一个null键与null值，说出两者之间的会发生什么？

  Map<String,Integer> map = new HashMap<>();
        map.put(null, 1);
        Hashtable<Object, Object> hashtable = new Hashtable<>();
        hashtable.put(null, 1);

咱来看效果图：

HashMap是能打印出来的，并且键是null，值为1

Hashtable是不能打印出来的，且会抛出异常，这其实是跟jdk版本相关，jdk1.8以下Hashtable的key不能存放null

且在编译时不报错，在运行后才会显示错误

这里再多说一点：

在Hashtable这个类中定义的方法是 public synchronized V put(K key, V value)

而HashMap 这个类中定义的方法是 public V put(K key, V value)

synchronized 是同步的意思，所以Hashtable是面向线程安全的

所以在此我给大家的总结是：

1.Hashtable是面向线程安全的

2.jdk1.8以下Hashtable的key不能存放null,在编译时不报错，运行时会报错

HashMap的key则可以存放null，编译与运行时都不报错

遍历方式

entrySet方式

        Set<Entry<String,Integer>> entrySet = map.entrySet();
        System.out.println("entrySet方式");
        for (Entry<String, Integer> entry : entrySet) {
            System.out.println("键："+entry.getKey()+"值："+entry.getValue());
        }

效果图：

keySet方式

        Set keys = map.keySet();
        System.out.println("keySet方式");
        for (Object key : keys) {
            System.out.println("键："+key+"值："+map.get(key));
        }

效果图：

常用实现类HashMap

统计字符串中各字母出现的次数

这里给定一个字符串，计算出该字符串中各个字母出现的次数

大致思路是：

1.做字符串切割，得到一个字符数组

2.接下来遍历，拿到单个字符

3.如果该字符没有出现过，即value值为null，那么该字符为KEY，值初始化为1

4.如已出现过，拿到原来的值+1

        //定义一个字符串
        String s="kjfksafkdvnsnopiefewojewokpkhuhijuhoijkcfdswtyfzxcvbnm";
        //切割字符串
        char[] array = s.toCharArray();
        //定义map集合
        Map<Character,Integer> map = new HashMap<>();
        //遍历切割后的字符集合
        for (char c : array) {
            //定义次数
            Integer value=map.get(c);
            //判断后加入map集合
            if(value==null) {
                map.put(c, 1);
            }
            else {
                map.put(c,value+1);
            }
        }
        //用entrySet方式遍历map集合
        Set<Entry<Character,Integer>> entrySet = map.entrySet();
        for (Entry<Character, Integer> entry : entrySet) {
            System.out.println(entry.getKey()+"："+entry.getValue());
        }

效果图：

泛型

这里只讲作用

例：这里用set集合来做，定义一个set集合

        Set set = new HashSet<>();
        set.add(1);
        set.add(2);
        set.add(3);
        set.add(4);
        set.add(5);
        set.add(6);
        //下面这行代码，由于没规定泛型，因此在编译时不报错，运行后才会报错
        set.add("a");
        for (Object obj : set) {
            if(Integer.valueOf(obj.toString()) % 2==0) {
                System.out.println(obj);
            }
        }

报错效果图：

这里我们加上泛型，在这里做限制

Set<Integer> set = new HashSet<>();

加入泛型后，将异常提到编译时显示

来看加入泛型的前后对比，上面是加入后的效果，下面是加入前的效果

结论：

1.加入泛型之前：不健壮的代码，会在运行时才会把错误暴露出来

2.将潜在的问题暴露出来，避免不必要的错误，将运行期出现的异常转化为编译期的错误

集合框架工具类

集合与数组之间的互转

        String[] arr={"a","b","c","d"};
		//数组转集合	Arrays.asList
		List<String> list = Arrays.asList(arr);	
		//集合转数组  toArray
		Object[] array = list.toArray();

排序

Collections

        //定义一个集合
		List<String> list = new ArrayList<>();
		list.add("b");
		list.add("g");
		list.add("d");
		list.add("s");
		System.out.println("没进行排序的："+list);
		//排序用系统自带的 Collections.sort 
		Collections.sort(list);
		System.out.println("进行排序了的："+list);
		//按字母排序  倒序   这里的x、y值得是集合中的元素
		Collections.sort(list, (x,y)-> y.compareTo(x));
		System.out.println("按字母进行倒序排序了的："+list);

效果图：

实体类的排序:先定义一个实体类

public class Person implements Comparable<Person>{
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Person() {
		// TODO Auto-generated constructor stub
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int compareTo(Person o) {
		return o.getName().compareTo(this.name);
	}
}

然后进行排序

        //定义一个集合
		List<Person> list = new ArrayList<>();
		//给集合添加数据
		list.add(new Person("l", 12));
		list.add(new Person("g", 13));
		list.add(new Person("d", 14));
		list.add(new Person("s", 15));
		//排序前
		System.out.println(list);
		//进行排序
		Collections.sort(list);
		//排序后
		System.out.println(list);

效果图：从name可以看出，是根据字母进行排序的，不过这里是倒序

弄成升序的只需改动以下这行代码即可：

Collections.sort(list, (x,y)->x.getName().compareTo(y.getName()));

效果图：

Arrays

        Integer[] arr= {3,0,3,5,7,9};
		//默认是升序
		Arrays.sort(arr);
		System.out.println("默认排序:"+Arrays.toString(arr));
		//降序
		Arrays.sort(arr, (x,y)->y-x);
		System.out.println("降序排序:"+Arrays.toString(arr));

效果图如下：