1. Toy模板网首页
  2. > Toy博客

List＜Entity＞与Map＜String, Entity＞互转

5月前 作者：代码改变世界888 分类：Toy博客 阅读(23) 违法举报

这篇具有很好参考价值的文章主要介绍了List＜Entity＞与Map＜String, Entity＞互转。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

List 转为 Map<String, Entity>

要将 List<Entity> 转换为 Map<String, Entity>，你需要指定一个属性作为 Map 的键，然后将 List 中的每个实体对象的该属性值作为键，实体对象本身作为值放入 Map 中。以下是一个示例代码：

假设你有一个名为 Entity 的实体类，其中有一个属性名为 id，你想将 List<Entity> 根据 id 属性转换为 Map<String, Entity>：

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Entity> entityList = ...; // 获取入参 List

        // 将 List 转换为 Map
        Map<String, Entity> entityMap = entityList.stream()
                .collect(Collectors.toMap(Entity::getId, entity -> entity));

        // 现在你可以使用 entityMap 了
    }

    static class Entity {
        private String id;
        // 其他属性和方法，包括 getter 和 setter

        public String getId() {
            return id;
        }

        public void setId(String id) {
            this.id = id;
        }
    }
}

在上面的示例中，我们使用了 Java 8 的 Stream API，通过 Collectors.toMap() 方法将 List<Entity> 转换为 Map<String, Entity>。在 toMap() 方法中，第一个参数 Entity::getId 指定了将实体对象的 id 属性作为 Map 的键，第二个参数 entity -> entity 指定了将实体对象本身作为 Map 的值。

Map<String, Entity>转为List

要将 Map<String, Entity> 转换为 List<Entity>，你可以使用 Map 的 values() 方法获取所有的实体对象，然后将它们放入一个 List 中。以下是一个示例代码：

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        Map<String, Entity> entityMap = ...; // 获取入参 Map

        // 将 Map 转换为 List
        List<Entity> entityList = entityMap.values().stream()
                .collect(Collectors.toList());

        // 现在你可以使用 entityList 了
    }

    static class Entity {
        // 实体类的属性和方法
    }
}

在上面的示例中，我们使用了 Java 8 的 Stream API，通过 Collectors.toList() 方法将 Map 的值集合转换为 List。 entityMap.values().stream() 获取 Map 的值集合的 Stream 流，然后通过 collect(Collectors.toList()) 将 Stream 流转换为 List。

将List按多个指定的属性进行排序

方式1

如果要按多个指定的属性对 List<Entity> 进行排序，你可以使用 Java 的 Comparator 接口来自定义排序规则。以下是一个示例代码，演示了如何按多个指定的属性对 List<Entity> 进行排序：

假设你的实体类 Entity 包含了多个属性，比如 property1 和 property2，你希望先按 property1 排序，然后在 property1 相同的情况下再按 property2 排序：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<Entity> entityList = ...; // 获取入参 List

        // 使用 Comparator 自定义排序规则
        Comparator<Entity> comparator = Comparator
                .comparing(Entity::getProperty1)
                .thenComparing(Entity::getProperty2);

        // 对 List 进行排序
        Collections.sort(entityList, comparator);

        // 现在 entityList 已按指定属性排序
    }

    static class Entity {
        private int property1;
        private String property2;
        // 其他属性和方法，包括 getter 和 setter

        public int getProperty1() {
            return property1;
        }

        public void setProperty1(int property1) {
            this.property1 = property1;
        }

        public String getProperty2() {
            return property2;
        }

        public void setProperty2(String property2) {
            this.property2 = property2;
        }
    }
}

在上面的示例中，我们使用了 Java 8 的 Comparator 接口的 comparing() 方法来按照 property1 进行排序，然后使用 thenComparing() 方法来在 property1 相同的情况下按照 property2 进行排序。最后，我们使用 Collections.sort() 方法将 List 按照自定义的排序规则进行排序。

方式2

当然可以使用实现接口的方式来实现多属性排序。你可以编写一个实现 Comparator 接口的类，并在其中定义自定义的排序逻辑。以下是一个示例代码：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<Entity> entityList = ...; // 获取入参 List

        // 使用自定义的排序类进行排序
        Comparator<Entity> comparator = new MultiPropertyComparator();
        Collections.sort(entityList, comparator);

        // 现在 entityList 已按指定属性排序
    }

    static class Entity {
        private int property1;
        private String property2;
        // 其他属性和方法，包括 getter 和 setter

        public int getProperty1() {
            return property1;
        }

        public void setProperty1(int property1) {
            this.property1 = property1;
        }

        public String getProperty2() {
            return property2;
        }

        public void setProperty2(String property2) {
            this.property2 = property2;
        }
    }

    static class MultiPropertyComparator implements Comparator<Entity> {
        @Override
        public int compare(Entity entity1, Entity entity2) {
            // 先按 property1 排序
            int result = Integer.compare(entity1.getProperty1(), entity2.getProperty1());
            if (result != 0) {
                return result;
            }
            // 如果 property1 相同，则按 property2 排序
            return entity1.getProperty2().compareTo(entity2.getProperty2());
        }
    }
}

在上面的示例中，我们创建了一个名为 MultiPropertyComparator 的实现了 Comparator 接口的内部类，实现了 compare() 方法来定义多属性排序逻辑。然后我们使用这个自定义的排序类进行排序。

方式3

是的，你可以通过让实体类实现 Comparable 接口来定义排序规则。这样，你就可以直接使用 Collections.sort() 方法对实体对象的 List 进行排序，而无需显式地传递 Comparator。

以下是一个示例代码，演示了如何让实体类实现 Comparable 接口来完成排序功能：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<Entity> entityList = ...; // 获取入参 List

        // 对 List 进行排序
        Collections.sort(entityList);

        // 现在 entityList 已按指定属性排序
    }

    static class Entity implements Comparable<Entity> {
        private int property1;
        private String property2;
        // 其他属性和方法，包括 getter 和 setter

        // 实现 compareTo 方法，定义排序规则
        @Override
        public int compareTo(Entity other) {
            // 先按 property1 排序
            int result = Integer.compare(this.property1, other.property1);
            if (result != 0) {
                return result;
            }
            // 如果 property1 相同，则按 property2 排序
            return this.property2.compareTo(other.property2);
        }

        // 其他属性的 getter 和 setter 方法
    }
}

在上面的示例中，我们让实体类 Entity 实现了 Comparable 接口，并重写了 compareTo 方法来定义排序规则。然后我们可以直接使用 Collections.sort() 方法对实体对象的 List 进行排序，因为实体类已经定义了排序规则。

List 根据id排序

方式1

要根据实体类中的 id 属性对 List<Entity> 进行排序，你可以按照以下步骤操作：

  1. 让实体类实现 Comparable 接口，并在其中重写 compareTo 方法，根据 id 属性进行比较。
  2. 调用 Collections.sort() 方法对 List 进行排序。

下面是一个示例代码：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<Entity> entityList = ...; // 获取入参 List

        // 对 List 进行排序
        Collections.sort(entityList);

        // 现在 entityList 已按 id 排序
    }

    static class Entity implements Comparable<Entity> {
        private Long id;
        // 其他属性和方法，包括 getter 和 setter

        // 实现 compareTo 方法，定义排序规则
        @Override
        public int compareTo(Entity other) {
            return this.id.compareTo(other.id);
        }

        // id 的 getter 和 setter 方法
        public Long getId() {
            return id;
        }

        public void setId(Long id) {
            this.id = id;
        }
    }
}

在上面的示例中，我们让实体类 Entity 实现了 Comparable 接口，并重写了 compareTo 方法来根据 id 属性进行比较。然后我们可以直接使用 Collections.sort() 方法对实体对象的 List 进行排序，因为实体类已经定义了排序规则。

方式2 不使用实现接口的方式

如果不想使用实现接口的方式，你可以使用 Comparator 来定义排序规则，并将其作为参数传递给 Collections.sort() 方法。以下是一个示例代码：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<Entity> entityList = ...; // 获取入参 List

        // 使用 Comparator 定义排序规则
        Comparator<Entity> comparator = Comparator.comparingLong(Entity::getId);

        // 对 List 进行排序
        Collections.sort(entityList, comparator);

        // 现在 entityList 已按 id 排序
    }

    static class Entity {
        private Long id;
        // 其他属性和方法，包括 getter 和 setter

        // id 的 getter 和 setter 方法
        public Long getId() {
            return id;
        }

        public void setId(Long id) {
            this.id = id;
        }
    }
}

在上面的示例中，我们使用 Comparator.comparingLong() 方法创建了一个按照 id 属性进行比较的 Comparator，并将其传递给 Collections.sort() 方法来对 List 进行排序。

List指定多个属性判断是否存在重复的数据

如果在实体类的多个属性中存在 null 值，并且你想要判断是否存在重复的数据，可以使用 Map 来记录已经出现过的属性组合，然后进行遍历判断。以下是一个示例代码，演示了如何判断 List<Entity> 中是否存在重复的数据，其中 name 和 age 属性中可能存在 null 值：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<Entity> entityList = ...; // 获取入参 List

        // 使用 Map 记录已经出现过的属性组合
        Map<String, Set<Integer>> attributeMap = new HashMap<>();

        boolean hasDuplicate = false;
        for (Entity entity : entityList) {
            // 根据实体对象的属性值构建属性组合的字符串表示
            String attributeKey = entity.getName() + "-" + entity.getAge();

            // 如果属性组合已经存在，则说明存在重复数据
            if (attributeMap.containsKey(attributeKey)) {
                hasDuplicate = true;
                break;
            }

            // 将属性组合放入 Map 中
            Set<Integer> ids = attributeMap.computeIfAbsent(attributeKey, k -> new HashSet<>());
            ids.add(entity.getId());
        }

        if (hasDuplicate) {
            System.out.println("存在重复数据");
        } else {
            System.out.println("不存在重复数据");
        }
    }

    static class Entity {
        private Integer id;
        private String name;
        private Integer age;
        // 其他属性和方法，包括 getter 和 setter

        // id、name 和 age 的 getter 和 setter 方法
        public Integer getId() {
            return id;
        }

        public void setId(Integer id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public Integer getAge() {
            return age;
        }

        public void setAge(Integer age) {
            this.age = age;
        }
    }
}

在上面的示例中，我们使用了一个 HashMap 来记录已经出现过的属性组合，其中键是由 name 和 age 组成的字符串，值是出现过该属性组合的实体对象的 ID 集合。然后我们遍历 List，对每个实体对象构建属性组合的字符串表示，检查该字符串是否已经在 Map 中存在，如果存在则说明存在重复数据。文章来源地址https://www.toymoban.com/news/detail-855527.html

实战

package com.exer;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        Entity entity1 = new Entity(1L,"qq", "10");
        Entity entity2 = new Entity(3L,null, "12");
        Entity entity3 = new Entity(2L,"ww", "11");
        List<Entity> entityList1 = Arrays.asList(entity1, entity2, entity3);

        // 将 List 转换为 Map
        Map<Long, Entity> entityMap = entityList1.stream().collect(Collectors.toMap(Entity::getId, entity -> entity));
        System.out.println("entityMap = " + entityMap);

        System.out.println("entityList1 = " + entityList1);
        entityList1.sort(Comparator.comparingLong(Entity::getId));
        System.out.println("entityList1 = " + entityList1);

        // 添加不重复的Map id
        Entity entity6 = new Entity(null,"aa", "13");
        Entity entity7 = new Entity(null,"null", "12");
        Entity entity8 = new Entity(2L,"dd", "15");
        List<Entity> entityList2 = Arrays.asList(entity6, entity7, entity8);
        for (int i = 0; i < entityList2.size(); i++) {
            if (entityList2.get(i).getId() != null) {
                entityMap.put(entityList2.get(i).getId(),entityList2.get(i));
            } else {
                entityMap.put((entityList1.get(entityList1.size() - 1).getId() + i + 1), entityList2.get(i));
            }
        }
        System.out.println("entityMap = " + entityMap);

        // 将 Map 转换为 List
        List<Entity> entities = new ArrayList<>(entityMap.values());
        System.out.println("entities = " + entities);

        // List<Entity> 判断是否有重复
        Set<String> keySet = new HashSet<>();
        for(Entity entity : entities) {
            if(!keySet.add(entity.getKey())){
                System.out.println("存在重复数据");
            }
        }
    }
}


package com.exer;

public class Entity {
    private Long id;

    private String name;

    private String age;

    public String getKey(){
        return name + age;
    }

    public Entity() {
    }

    public Entity(Long id, String name, String age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Entity{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age='" + age + '\'' +
                '}';
    }

}

到了这里，关于List＜Entity＞与Map＜String, Entity＞互转的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包