Java map list 基本使用方法
- 1.map使用
- Map.putAll()用法
- 2.list使用
- list 删除部分list
- 六种初始化list的方法
- 1.构造 List 后使用 List.add 初始化，最常规的做法，用起来不太方便。
- 2.使用 {{}} 双括号语法
- 3.使用 Arrays.asList
- 4.使用 Stream (JDK8)，单纯初始化 List，使用 Stream 有点大材小用
- 5.使用 Lists （JDK9）,这个和 Arrays.asList 一样简洁清晰。
- 6.Collections
- 将一个List赋值给另一个List的4种方法
- String数组和List的互相转化
- List转String数组
- String数组转List
- 两个不同list对象的复制
- list转map 有重复key,value转为集合
- List groupBy
- 获取list中所有对象的某个属性
- 获取属性且强制转换类型
- 获取List中某个特定属性的对象
- List对象排序
- 3.Map+List
- list map 结合
- List＜Map＜String,Object＞＞转List＜T＞
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);
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
