J2EE(集合框架之Map)

雨沐笙

已于 2022-06-09 21:56:22 修改

阅读量72

点赞数

文章标签： python 开发语言 j2ee

于 2022-06-09 21:55:16 首次发布

本文链接：https://blog.csdn.net/m0_62604616/article/details/125210044

版权

补充点：HashMap与hashtale的区别

前言

前两天给大家分享了list、set这两种集合，今天我又给各位带来另外一种集合，也就是map集合，希望对大家有帮助

提示：以下是本篇文章正文内容，下面案例可供参考

一、Map有什么特点？

1、增删改查

package com.mgy.map;

import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class Demo1 {
	public static void main(String[] args) {		
		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);
		
		System.out.println("===========删除===========");
		Object remove = map.remove("b");
		System.out.println(remove);
		System.out.println(map);
		
		System.out.println("===========修改===========");
		map.put("c", 32);
		System.out.println(map);
		
//		查询
        System.out.println("===========查询===========");
		System.out.println(map.get("c"));
		
	}
}

效果图:

注意：修改也是调用put方法

2、Map是以什么形式存在

Map集合是以键值对形式存在，列如：map.put("a", 1); a就是键，1就是值。根据一个键值获得对应的一个值

3、key可以为空

Map<String,Integer> map=new HashMap<>();
		//增加
		map.put(null, null);

补充点：HashMap与hashtale的区别

public class Demo1 {
	public static void main(String[] args) {
		Hashtable<Object, Object> table = new Hashtable<>();
		table.put(null, null);
//		publie synchronized V put(k key,V value)
		
		
		Map<String,Integer> map=new HashMap<>();
		//增加
		map.put(null, null);
//		V put(K key,V value);
    }
}

注释的那段代码就是他们两个的区别，hastable的put方法用了synchronized，这使得hashtable更加安全，而HashMap并没有加上。jdk1.8以下hashtable的key不能存放null。

二、遍历方式

1、entrySet

package com.mgy.map;

import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;


public class Demo1 {
	public static void main(String[] args) {
		Map<String,Integer> map=new HashMap<>();
		//增加
		map.put("a", 1);
		map.put("b", 2);
		map.put("c", 3);
		map.put("d", 4);

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

效果：

2、keySet

package com.mgy.map;

import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;


public class Demo1 {
	public static void main(String[] args) {
		Map<String,Integer> map=new HashMap<>();
		//增加
		map.put("a", 1);
		map.put("b", 2);
		map.put("c", 3);
		map.put("d", 4);

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

效果：

注意：这两个遍历方式的效果固然相同，但是entrySet是拿到映射关系，而keySet是先拿到map集合中的所有key，在拿值。

三、常用实现类HashMap

案例：根据字符串中出现的次数进行排序

思路：

做字符串切割，得到一个字符数组
遍历，拿到单个字符
如果该字符没有出现过，即value值为null，那么该字符为key，值初始为1
接下来可以通过F6一步步调试当前程序对应的每一个变量值
通过ArrayList构造函数把map.entrySet()转换成list
通过比较器实现比较排序

代码：

package com.mgy.map;


import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;

public class Demo2 {
	public static void main(String[] args) {
		String s="sdaasdhaigangibagfiohoihazczchjakdanvbayd";
		/*
		 *实现思路：
		 * 1.做字符串切割，得到一个字符数组
		 * 2.遍历，拿到单个字符
		 * 3.如果该字符没有出现过，即value值为null，那么该字符为key，值初始为1
		 * 4.如果已经出现过，拿到原来的值+1 
         * 5.通过ArrayList构造函数把map.entrySet()转换成list
         * 6.通过比较器实现比较排序 
		 */
		//1.做字符串切割，得到一个字符数组
		char[] arr = s.toCharArray();
		Map<Character, Integer>map=new TreeMap<>();
//		2.遍历，拿到单个字符
		for (char c : arr) {
			Integer value=map.get(c);
//			判断该字符value值为空
			if(value==null) {
//				如果value值为null，即该字符没有出现过，那么该字符为key，值初始为1
				map.put(c, 1);
			}
			else {
//				如果已经出现过，拿到原来的值+1 
				map.put(c, value+1);
			}
//			System.out.println(value);
		}
		
		//通过ArrayList构造函数把map.entrySet()转换成list
		List<Entry<Character, Integer>> list=new ArrayList<Map.Entry<Character,Integer>>(map.entrySet());
		//通过比较器实现比较排序 
		Collections.sort(list,new Comparator<Map.Entry<Character, Integer>>() {
			@Override
			public int compare(Entry<Character, Integer> o1, Entry<Character, Integer> o2) {
				// TODO Auto-generated method stub
				return o1.getValue().compareTo(o2.getValue());
			}

		});
		
		for (Entry<Character, Integer> entry : list) {
			System.out.println("键:"+entry.getKey()+"  值:"+entry.getValue());
		}
		
		
	}
}

效果：

四、泛型

1、作用

泛型的作用就是把类型参数化，也就是我们常说的类型参数平时我们接触的普通方法的参数，比如public void fun (String s)；参数的类型是String，是固定的。泛型中使用多个类型参数，您只需要在尖括号中传递指定另一个类型参数，并用逗号分隔即可。将潜在存在的问题暴露出来，早预防早治疗，将运行期的出现异常转换为编译期的错误

2、泛型类

使用泛型，我们可以在不知道代码操作对象的类型的情况下编写代码。它允许我们创建泛型类，构造函数和方法。

泛型类是使用形式类型参数定义的。

形式类型参数是一个逗号分隔的变量名列表，位于类声明中类名后面的尖括号<>中。

语法：

public class Wrapper<T>  {

}

该参数已命名为T.

T是一个类型变量，它可以是Java中的任何引用类型，例如String，Integer，Double等。

当使用Wrapper类时，指定形式类型参数值。

例子：

public class Main {
  public static void main(String[] args) {
    Wrapper<String> w1 = new Wrapper<>("Hello");
    String s1 = w1.get();
    System.out.println("s1=" + s1);

    w1.set("Testing generics");
    String s2 = w1.get();
    System.out.println("s2=" + s2);

    w1.set(null);
    String s3 = w1.get();
    System.out.println("s3=" + s3);
  }
}

class Wrapper<T> {
  private T obj;

  public Wrapper(T obj) {
    this.obj = obj;
  }

  public T get() {
    return obj;
  }

  public void set(T obj) {
    this.obj = obj;
  }
}

3、泛型方法

3.1定义

泛型方法 是在调用方法的时候指明泛型的具体类型。
【泛型方法能够使方法独立于类的处理指定的类型。】

3.2 语法

修饰符 <T,E,…> 返回值类型方法名（形参列表）{
。。。。。。
}

3.3使用

package com.mgy.map;

import java.util.HashSet;
import java.util.Set;

public class Demo3 {
    public static  <T> T show(T t) {
        System.out.println(t);
        return t;
    }

    public static void main(String[] args) {
        // 返回值不用强转，传进去是什么，返回就是什么
        String s = show("一个优秀的小朋友");
        int num1 = show(666);
        double num2 = show(666.666);
        System.out.println("------------------------");
        System.out.println(s);
        System.out.println(num1);
        System.out.println(num2);
    }
}

五、集合框架工具类

1、Collections

1.1排序

为排序之前：

package com.mgy.map;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;

/**
 * 对于工具类其他方法的应用
 * sort
 * tostring
 * @author Administrator
 *
 */
public class Demo5 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		list.add("b");
		list.add("c");
		list.add("a");
		System.out.println(list);
	}
}

效果：

排序为[a,b,c]：我们是在原本的就有顺序的基础上进行排序，所以我们要用Collections.sort(你要排序的集合);来进行排序

package com.mgy.map;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;

/**
 * 对于工具类其他方法的应用
 * sort
 * tostring
 * @author Administrator
 *
 */
public class Demo5 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		list.add("b");
		list.add("c");
		list.add("a");
		Collections.sort(list);
		System.out.println(list);

	}
}

效果：

倒序输出相当于改变排序接口，所以要比较器接口来进行

package com.mgy.map;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;

/**
 * 对于工具类其他方法的应用
 * sort
 * tostring
 * @author Administrator
 *
 */
public class Demo5 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		list.add("b");
		list.add("c");
		list.add("a");
        //		这里面x，y指的是集合中的元素
		Collections.sort(list, (x,y)-> y.compareTo(x));
		System.out.println(list);

	}
}

效果：

进行对象排序：

package com.mgy.map;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;

public class Demo5 {
	public static void main(String[] args) {				
		ArrayList<Person> list = new ArrayList<>();
		list.add(new Person("b", 16));
		list.add(new Person("c", 18));
		list.add(new Person("a", 19));
		System.out.println(list);
//		Collections.sort(list);
		Collections.sort(list, (x,y)-> x.getName().compareTo(y.getName()));
		System.out.println(list);
		
		Integer[] arr= {3,6,9,2,5,8};
		Arrays.sort(arr, (x,y)->y-x);
		System.out.println(Arrays.toString(arr));
	}
}
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) {
		// TODO Auto-generated method stub
		return o.getName().compareTo(this.getName());
	}
	
}

注意：进行对象排序的时候一定要实现 Comparable

效果：

2、Arrays

有三个方法 1.toString 2.asList 3.sort

package com.mgy.map;

import java.util.Arrays;
import java.util.List;


public class Demo4 {
	public static void main(String[] args) {
		String []arr= {"a","b","c","d"};
        //数组转为集合
		List<String> list = Arrays.asList(arr);
        //集合转为数组
//		Object[] array = list.toArray();
		list.add("e");
//		java.lang.UnsupportedOperationException
		System.out.println(list.size());
	}
}

效果：