Java 数据类型转换、方法调用相关笔记

迷途码界

已于 2022-08-11 09:57:09 修改

阅读量541

点赞数

分类专栏： Java 文章标签： java 开发语言

于 2022-06-13 13:51:37 首次发布

本文链接：https://blog.csdn.net/zx711166/article/details/125258539

版权

Java 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

Java 数据类型转换、方法调用相关笔记

Stream 使用异常
- java.lang.IllegalStateException: Duplicate key
Java 流(Steam)
- List< Entity > 转 Map < String, Entity >
- List＜Object＞转换为 List＜String＞
Json 字符串转 Map＜String, Object＞
Map 转对象
Map 初始化的四种方式
Java 数组转Set
getMethod()方法使用
枚举类型转为Map

Stream 使用异常

java.lang.IllegalStateException: Duplicate key

问题：List 转 Map 中 key 相同，就会导致报错

Map<String, String> userMap = userList.stream()
		.collect(Collectors.toMap(User::getId, User::getName));

解决：使用的是两个key 相同时，保留先存进去的那个元素。相比第一个方法，主要就是我们要去实现一个策略，来决定key相同时，元素如何保留。

Map<String, String> userMap = userList.stream()
		.collect(Collectors.toMap(User::getId, User::getName, (item1,item2) ->item1));

Java 流(Steam)

List< Entity > 转 Map < String, Entity >

key 和 value 都是对象中的某个属性值：

Map<String, String> userMap = userList.stream()
	.collect(Collectors.toMap(User::getId, User::getName));

key 是对象中的某个属性值，value 是对象本身（使用返回本身的lambda表达式）：

Map<String, User> userMap = userList.stream()
	.collect(Collectors.toMap(User::getId, User -> User));

key 是对象中的某个属性值，value 是对象本身（使用Function.identity()的简洁写法）：

Map<String, User> userMap = userList.stream()
	.collect(Collectors.toMap(User::getId, Function.identity()));

key 是对象中的某个属性值，value 是对象本身，当 key 冲突时选择第二个 key 值覆盖第一个 key 值：

Map<String, User> userMap = userList.stream()
	.collect(Collectors.toMap(User::getId, Function.identity(), (oldValue, newValue) -> newValue));

List＜Object＞转换为 List＜String＞

Stream 的 map() 方法，实现将对象 List 转为单属性 List。

List<String> collect = dataItemList.stream()
            .map(item -> {
                return item.getMobile();
            })
            .collect(Collectors.toList());

简化写法：

List<String> collect = dataItemList.stream()
            .map(item -> item.getMobile())
            .collect(Collectors.toList());

通过return，可转换为各种类型的。
如写成return new AAA(){…} 这样来控制类型

dataItemList.stream()
            .map(item -> {
                return new TempModel(...);
            })
            .collect(Collectors.toList());

Json 字符串转 Map＜String, Object＞

JSONObject formOptions = jsonObject.getJSONObject(“formOptions”);
Map<String, Object> formOptionsMap = JSON.parseObject(formOptions.toString());

Map 转对象

依赖 alibaba 的 fast-json


<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>x.x.x</version>
</dependency>

Map转对象

//将map 转换为 lpPersonInfoImg对象
PersonInfo PersonInfo = JSONObject.parseObject(JSONObject.toJSONString(map), PersonInfo.class);

Map 初始化的四种方式

新建Map对象（最常见）

public class MapDemo{  
    private static final Map<String, String> map = new HashMap<String, String>();  
    static{
    	map.put("key1", "value1");  
    	map.put("key2", "value2"); 
    }  
}

Java8 新特性（双括号初始化）

HashMap<String, String > map  = new HashMap<String, String>(){{  
		put("key1", "value1");  
    	put("key2", "value2");       
}};

Java9新特性（最简便、不可变集合）

Map.of("key1", "value1", "key2", "value2"); // 不可变集合

Google Guava（第三方依赖库、不可变集合）

引入maven依赖

<dependency>
	<groupId>com.google.guava</groupId>
	<artifactId>guava</artifactId>
	<version>19.0</version>
</dependency>

Map<String, String> map = ImmutableMap.of("key1", "value1", "key2", "value2", "key3", "value3"); // 不可变集合

注：不可变集合优点

在多线程操作下，是线程安全的。
所有不可变集合会比可变集合更有效的利用资源。
中途不可改变。
当对象被不可信的库调用时，不可变形式是安全的。
不可变集合不需要考虑变化，因此可以节省时间和空间。
不可变对象因为有固定不变，可以作为常量来安全使用。

在这里插入图片描述

Java 数组转Set

Java 流(Steam)实现（List,Map适用）

import java.util.Arrays;
import java.util.Set;
import java.util.stream.Collectors;

public class Main {

	public static void main(String[] args) {
		Integer[] arr = {1,2,3,3};
		
		Set<Integer> set = Arrays.stream(arr).collect(Collectors.toSet());//适用于JDK>=1.8
		
		for (Integer integer : set) {
			System.out.println(integer);//【输出：1,2，3】
		}

	}

}

"Collections.addAll()"方法

String[] num = new String[] { "One", "Two", "Three", "One", "Six" };

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

Collections.addAll(set,num);

System.out.println(set);//输出【[Six, One, Two, Three]】

"Arrays.asList()"方法(array⇒list⇒set)

String[] num = new String[] { "One", "Two", "Three", "One", "Six" };

Set<String> set = new HashSet<>(Arrays.asList(num)); //不推荐，大小固定不能增删

System.out.println(set);

getMethod()方法使用

getMethod方法要注意的地方：

第一个参数是mName “方法名称”；
第二个参数是 “方法参数的类对象”。

// 类对象.getMethod(mName, HttpServletRequest.class, HttpServletResponse.class);
Class.getMethod(mName, HttpServletRequest.class, HttpServletResponse.class);

示例：抽取出的通用的servlet（页面请求经过的第一个servlet，所有页面请求必须经过的一个servlet, baseservlet）

protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
	try {
		//1.获取方法名称
		String mName = request.getParameter("method");
           
		//2.获取方法对象
 		Method method = this.getClass().getMethod(mName,HttpServletRequest.class,HttpServletResponse.class);
            
		//3.让方法执行，接受返回值
		String path = (String) method.invoke(this, request,response);
            
		//4.判断返回值是否为空，若不为空，统一处理请求转发
		if(null != path) {
			request.getRequestDispatcher(path).forward(request, response);
		}
	} catch (Exception e) {
		e.printStackTrace();
		throw new RuntimeException();
	}
}

这是一个具体执行某类操作的servlet（这里是执行用户注册的servlet，页面请求经过的第二个servlet，userservlet）

public String registUI(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
	return "/jsp/register.jsp";
}

枚举类型转为Map

枚举基类

public interface IBaseEnum {

	String getCode();
	
	String getMessage();
}

自定义枚举类

public enum GlobalExceptionEnum implements IBaseEnum {

    EXCEPTION_ENUM("EC_0001", "未知异常，请联系项目管理员！"),
    RUNTIME_EXCEPTION_ENUM("EC_0002", "运行期间发生异常，请联系项目管理员！");

    private String code;
    private String message;

    GlobalExceptionEnum(String code, String message) {
        this.code = code;
        this.message = message;
    }

    @Override
    public String getCode() {
        return this.code;
    }

    @Override
    public String getMessage() {
        return this.message;
    }
}

枚举转换工具

public class EnumUtils {

    /**
     * @Description 将枚举转换成Map对象方便取值 - 固定类型- 仅为了提供思路 
     * @return
     */
    public static Map<String, String> convertToMap() {
        Map<String, String> mapResult = new HashMap<>();

        Arrays.stream(GlobalExceptionEnum.values()).forEach(globalExceptionEnum -> {
            mapResult.put(globalExceptionEnum.getCode(), globalExceptionEnum.getMessage());
        });

        return mapResult;
    }

    /**
     * @Description 真正的工具类 - 将枚举转为Map使用，只要参数 clazz 继承了IbaseEnum
     * @return
     */
    public static Map<String, String> generateConvertToMap(Class<? extends IBaseEnum> clazz) {
        Map<String, String> mapResult = new HashMap<>();

        if(!clazz.isEnum()) {
            throw new UnsupportedOperationException("参数不合法：非枚举类，不支持转换，请检查程序是否有误！");
        }

        // 通过class.getEnumConstants();获取所有的枚举字段和值
        IBaseEnum[] iBaseEnums = clazz.getEnumConstants();
        for (IBaseEnum iBaseEnum : iBaseEnums) {
            mapResult.put(iBaseEnum.getCode(), iBaseEnum.getMessage());
        }
        return mapResult;

    }

    // 测试使用
    public static void main(String[] args) throws InstantiationException,
            IllegalAccessException, InvocationTargetException {
        Map<String, String> mapResult1 = EnumUtils.convertToMap();
        System.out.println(mapResult1);
        // 这里是真正工具调用的地方
        Map<String, String> mapResult2 = EnumUtils.generateConvertToMap(GlobalExceptionEnum.class);
        System.out.println(mapResult2);
    }
}