Java Map List

jincheng_

已于 2023-03-08 11:38:05 修改

阅读量2.8k

点赞数

分类专栏： Java学习文章标签： java

于 2021-06-11 14:37:54 首次发布

本文链接：https://blog.csdn.net/jincheng_/article/details/117816612

版权

Java学习专栏收录该内容

10 篇文章 0 订阅

订阅专栏

Java map list 基本使用方法

1.map使用

package basic;
import java.util.HashMap;
import java.util.Map;
//map使用方法
public class MapDemo {

    public static void main(String[] args) {
        // map实例化
        Map<String, Integer> maps = new HashMap<>();

        // 添加元素
        maps.put("A", 10);
        maps.put("B", 20);
        maps.put("C", 30);
        maps.put("D", 40);
        maps.put("E", 50);
        maps.put("F", 60);

        // 修改元素
        maps.replace("F", 65);

        // 删除元素
        maps.remove("E");

        // 遍历map-原始方法
        for (Map.Entry<String, Integer> entry : maps.entrySet()) {
            System.out.println("key:" + entry.getKey() + ";value:" + entry.getValue());
        }

        // 遍历map-forEach方法（Java8新特性）
        maps.forEach((k,v)->
            System.out.println("key : " + k + "; value : " + v)
            );

        // 查询元素
        int f = maps.get("F");
        System.out.println("F的值为:" +  f);
		
		//获取Map中的所有key
        Set<String> keySet = maps.keySet();
		//使用迭代器遍历存放所有key的Set集合
        Iterator<String> it =keySet.iterator();  
        while(it.hasNext()){                         
            //得到每一个key
            String key = it.next();
            //通过key获取对应的value
            Integer value = maps.get(key);
            System.out.println(key+"="+value);
        }
		
		//map初始化
		Map<Integer,Object> chargeType = new HashMap<Integer,Object>(){
	        {
	            put(1,"季节");
	            put(2,"永久");
	        }
    	};

    }
}

Map.putAll()用法

putAll可以合并两个MAP，只不过如果有相同的key那么用后面的覆盖前面的

//合并两个map到map1
Map<String,Object> map1 = new HashMap<>();
Map<String,Object> map2 = new HashMap<>();
map1.putAll(map2);

2.list使用

import java.io.*;
import java.util.*;
class test  
{
	public static void main (String[] args) throws java.lang.Exception
	{
		System.out.println("hello");
		List<String> list = new ArrayList<String>();
        
        //添加元素.
        list.add("Tom");
        list.add("Jam");
        list.add("Alix");
        list.add("Tom");
        list.add("Tom");
        list.add("Tom");

        //获取元素.
        String str = list.get(0);
    //    System.out.println(str);
    
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        
        //删除元素.
        list.remove(1);
        list.remove("Alix");

        //判断某一个元素是否在list中.
        String name = "Tom";
        if (list.contains(name)) {
            System.out.println("Tom in list.");
        } else {
            System.out.println("Tom not in list");
        }
        
        //根据索引改变list中某一个值.
        list.set(0, "Tony");
        System.out.println();
        //遍历元素.
        for (String s: list) {
            System.out.println(s);
        }

        //根据值查找索引
        //返回元素值等于Tom的索引.（第一个）
        System.out.println(list.indexOf("Tom"));
        //返回元素值等于Tom的最后的索引.
        System.out.println(list.lastIndexOf("Tom"));
        
        list = list.subList(1,3); //截取集合：[1,3)
        for (String s: list) {
            System.out.println(s);
        }
		
		//判断是否为空
		if (list.isEmpty()) {
            System.out.println("空的.");
        } 
		
		//转化成iterator对象遍历.
        Iterator it = list.iterator();
        while(it.hasNext()) {
            Object obj = it.next();
            System.out.println(obj);
        }
		
		//将集合转化为String
		str = list.toString();
		System.out.println(str);

		//list排序
		//普通list
		Collections.sort(list); // 升序排列
		Collections.reverse(list); // 倒序排列
		//对象list
      	list.sort(Comparator.comparing(People::getDeptId));//正序
		list.sort(Comparator.comparing(People::getDeptId).reversed());//倒序
		 
	}
}

list 删除部分list

List<a> aList = ...;
List<a> bList = ...;
//aList 包含bList 
aList.removeAll(bList);

六种初始化list的方法

1.构造 List 后使用 List.add 初始化，最常规的做法，用起来不太方便。

    List<String> stringList = new ArrayList<>();
	stringList.add("a");
	stringList.add("b");
	stringList.add("c");

2.使用 {{}} 双括号语法

List<String> stringList = new LinkedList<String>(){{
    add("a");
    add("b");
    add("c");
}};

这种方式相对方便了一些。
外层的 {} 定义了一个 LinkedList 的匿名内部类。内层的 {} 的定义了一个实例初始化代码块。这个代码块在初始化内部类时执行。所以这里相当于定义了一个匿名内部类，并使用 add 添加元素来初始化。
这种方式有几个缺点：
使用匿名内部类，会有效率上的损失。当然在大多数情况下，这点效率都是可接受的。
静态内部类持有所在外部类的引用。如果需要将 List 返回给到其他地方使用，可能造成内存泄漏。

3.使用 Arrays.asList

List<String> stringList = Arrays.asList("a", "b", "c");

这种方式使用了 java.util.Arrays 的静态方法。写法上比之前的两种都更简洁，也没有构造匿名内部类的效率问题。

但也有几点需要注意：

Arrays.asList 返回的是 Arrays 的静态内部类（静态内部类不持有所在外部类的引用）。
这个内部类继承自 AbstractList，实现了 RandomAccess，内部使用了一个数组来存储元素。但是不支持增删元素。这点需要注意。如果只是使用 Arrays.asList 来初始化常量，那么这点就不算什么问题了。

Arrays.asList 的参数如果是基本类型的数组时，需要留意返回值可能和你预期的不同。

int[] intArray = new int[]{1, 2, 3};
Integer[] integerArray = new Integer[]{1, 2, 3};
 
List<int[] > intArrayList = Arrays.asList(intArray);
List<Integer> integerList = Arrays.asList(integerArray);
List<Integer> integerList2 = Arrays.asList(1, 2, 3);

这里 Arrays.asList(intArray) 的返回值是 List<int[]> 而不是 List。这一点也算不上问题，只是使用时需要留意。如果能在 Java 中做到尽量使用 List 和 Integer，尽量避免使用 int 等基本类型和 [] 这种较为底层的数据结构即可避免。

虽然本文是在讲初始化 List，但这里的 {{}} 双括号语法同样可用于初始化 Map 等其他众多类型。相对而言，Arrays.asList 就只能用于初始化 List 类型了。

4.使用 Stream (JDK8)，单纯初始化 List，使用 Stream 有点大材小用

List<String> list = Stream.of("a", "b", "c").collect(Collectors.toList());

5.使用 Lists （JDK9）,这个和 Arrays.asList 一样简洁清晰。

List<String> list = Lists.newArrayList("a", "b", "c");

6.Collections

String customerNumber = "xxx";
Collections.singletonList(customerNumber))

将一个List赋值给另一个List的4种方法

1.直接 =
注：此时B对象相当与A对象的引用，而并不是将A对象的值单纯的传递给B对象。即：B对象的操作将直接改变A对象。如B.add(“3”);结果A中也包含了“3”；

ArrayList<String> A= new ArrayList<String>();  
A.add("1");  
A.add("2");  
ArrayList<String> B;  
B = A;

2.单纯赋值 new一个对象初始化

ArrayList B　＝ new ArrayList<> (A);

3.clone()方法

ArrayList B　＝ A.clone();

4.addAll()方法

ArrayList B　＝ new ArrayList<String>();  
B.addAll(A);

5.foreach循环赋值法

for(String s: A)  
 B.add(s);

String数组和List的互相转化

List转String数组

//List转String数组 方法一
String[] strs1 = testList.toArray(new String[testList.size()]);
//List转String数组 方法二
String[] strs2 = new String[testList.size()];
for(int i=0;i<testList.size();i++){
   strs2[i]=testList.get(i);
}

String数组转List

//准备一个String数组
String[] strs = {"aa","bb","cc"};
//String数组转List 方法一
List<String> strsToList1= Arrays.asList(strs);
//String数组转List 方法二
List<String> strsToList2=new ArrayList<>();
Collections.addAll(strsToList2,strs);
//String数组转List 方法三
List<String> strsToList3=new ArrayList<>();
for(String s:strs){
    strsToList3.add(s);
}

两个不同list对象的复制

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;

List<A> aList = JSON.parseArray(JSON.toJSONString(bList), A.class);

list转map 有重复key,value转为集合

list.stream().collect(Collectors.toMap(CardOrg::getBankId, 
	p -> {
       List<String> getValueList = new ArrayList<>();
       getValueList.add(p.getBankName());
       return getValueList;
	},
    (List<String> value1, List<String> value2) -> {
         value1.addAll(value2);
         return value1;
     }
));

List groupBy

 Map<String, Long> collect = addHouseDtoList.stream().collect(Collectors.groupingBy(BusHouseDto::getPathName, Collectors.counting()));
 for (Map.Entry<String, Long> entry : collect.entrySet()) {
            if (entry.getValue() > 1) {
                ...
            }
        }

获取list中所有对象的某个属性

List<String> courseIds=  users.stream().map(UserEntity::getUserName).collect(Collectors.toList());

获取属性且强制转换类型

List<String> ids = new ArrayList<>();
		ids.add("1");
		ids.add("2");
		ids.add("3");
		ids.add("4");
		List<Long> longs = ids.stream().map(s -> Long.parseLong(s.trim())).collect(Collectors.toList());

//结合使用
List<Long> courseIds = list.stream().map(UserEntity::getUserName).collect(Collectors.toList())
                .stream().map(s -> Long.parseLong(s.trim())).collect(Collectors.toList());

//Integer转Long
List<Long> ids = busBillInfoList.stream().map(BusBillInfo::getBuildType).collect(Collectors.toList())
                .stream().map(Integer::longValue).collect(Collectors.toList());

获取List中某个特定属性的对象

案例：假设对象是Cart购物车，里面有product_id，product_name，count等。需要从集合中查找商品id是1的商品对象。

Optional<Cart> cartOptional = cartlist.stream().filter(item -> item.getProductId().equals(1L)).findFirst();
if (cartOptional.isPresent()) {
    // 存在
    Cart cart =  cartOptional.get();
} else {
    // 不存在
}
//或者是：
Cart cart = cartlist.stream().filter(item -> item.getProductId().equals(1L)).findFirst().get();

List对象排序

List<BusCommunityTree> treeList = new ArrayList<>();
//正序
treeList.sort(Comparator.comparing(BusCommunityTree::getName));
//倒序
treeList.sort(Comparator.comparing(BusCommunityTree::getName).reversed());
// 按照拼音首字母排序
Comparator comparator = Collator.getInstance(Locale.CHINA);
        Collections.sort(treeList, (p1, p2) -> comparator.compare(PinYinUtil.converterToFirstSpell(p1.getName().substring(0,1)).toLowerCase(),
                PinYinUtil.converterToFirstSpell(p2.getName().substring(0,1)).toLowerCase()));

PinYinUtil

package me.zhengjie.utils;

import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;

/**
 * @author JC
 * date 2020-09-01
 */
public class PinYinUtil {
    /**
     * 获取字符串拼音的第一个字母
     * @param chinese
     * @return
     */
    public static String toFirstChar(String chinese) throws Exception{
        String pinyinStr = "";
        if(Tools.isNull(chinese)){
            return pinyinStr;
        }
        chinese = chinese.replace("(","").replace(")","");
        chinese = chinese.replace("（","").replace("）","");
        char[] newChar = chinese.toCharArray();  //转为单个字符
        HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
        defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);
        defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
        for (int i = 0; i < newChar.length; i++) {
            if (newChar[i] > 128) {
                try {
                    pinyinStr += PinyinHelper.toHanyuPinyinStringArray(newChar[i], defaultFormat)[0].charAt(0);
                } catch (BadHanyuPinyinOutputFormatCombination e) {
                    // e.printStackTrace();
                }
            }else{
                pinyinStr += newChar[i];
            }
        }
        return pinyinStr;
    }

    /**
     * 汉字转为拼音
     * @param chinese
     * @return
     */
    public static String toPinyin(String chinese){
        String pinyinStr = "";
        char[] newChar = chinese.toCharArray();
        HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
        defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);
        defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
        for (int i = 0; i < newChar.length; i++) {
            if (newChar[i] > 128) {
                try {
                    pinyinStr += PinyinHelper.toHanyuPinyinStringArray(newChar[i], defaultFormat)[0];
                } catch (BadHanyuPinyinOutputFormatCombination e) {
                    e.printStackTrace();
                }
            }else{
                pinyinStr += newChar[i];
            }
        }
        return pinyinStr;
    }

    /**
     * 汉字转换位汉语拼音首字母，英文字符不变
     *
     * @param chines 汉字
     * @return 拼音
     */
    public static String converterToFirstSpell(String chines) {
        String pinyinName = "";
        char[] nameChar = chines.toCharArray();
        HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
        defaultFormat.setCaseType(HanyuPinyinCaseType.UPPERCASE);
        defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
        for (int i = 0; i < nameChar.length; i++) {
            if (nameChar[i] > 128) {
                try {
                    pinyinName += PinyinHelper.toHanyuPinyinStringArray(
                            nameChar[i], defaultFormat)[0].charAt(0);
                } catch (BadHanyuPinyinOutputFormatCombination e) {
                    e.printStackTrace();
                }
            } else {
                pinyinName += nameChar[i];
            }
        }
        return pinyinName;
    }

}

pom.xml

		<dependency>
            <groupId>com.belerweb</groupId>
            <artifactId>pinyin4j</artifactId>
            <version>2.5.0</version>
        </dependency>

3.Map+List

list map 结合

//list里有多条数据 detailList为list里的每一条数据（每条数据下有多个属性）
list.forEach(
	detailList->{
		detailMap.put(detailList.getValue(), detailList.getLabel());
	}
);

List＜Map＜String,Object＞＞转List＜T＞

		import com.alibaba.fastjson.JSONArray;

		JSONArray jsonArray = new JSONArray();
        jsonArray.addAll(listMap);
        List<User> list = jsonArray.toJavaList(User.class);

jincheng_

关注

0
点赞
踩
7

收藏

觉得还不错? 一键收藏
2
评论
Java Map List

Java map list 基本使用方法1.map使用2.list使用3.Map+List1.map使用package basic;import java.util.HashMap;import java.util.Map;//map使用方法public class MapDemo { public static void main(String[] args) { // map实例化 Map<String, Integer> maps =
复制链接

扫一扫