小编Rav*_*ala的帖子

Map<Integer, String> map = new HashMap<>();
map.put(1, "f");
map.put(2, "i");
map.put(3, "a");
map.put(4, "c");....etc

现在我有一个列表：

List<Integer> picks = {1,3}

我想取回一个字符串列表，即映射中与“ pick”列表中找到的键值匹配的值。因此，我希望取回{“ f”，“ a”}作为结果。有没有一种方法可以使用Java流api优雅地做到这一点？

当有一个值时，我就是这样：

map.entrySet().stream()
            .filter(entry -> "a".equals(entry.getValue()))
            .map(entry -> entry.getValue())
            .collect(Collectors.toList())

但是，当要过滤的键/小贴士列表变得越来越困难时。

我有以下结构：

Map<String,Map<String,Map<String,Integer>>>

现在，我想忽略“第一级地图”，并根据“第二级地图”的键来分组（并总结）“第三级地图”。要澄清一些示例条目：

Entry 1: ["1"["A"[[a,1];[b,2]];"B"[[a,3];[c,1]]]]
Entry 2: ["2"["A"[[b,2];[c,1]];"B"[[a,5];[b,0]]]]

所需的输出：

Entry 1: ["A"[[a,1];[b,4];[c,1]]]
Entry 4: ["B"[[a,8];[b,0];[c,1]]]

因此，为此，我首先根据我的2级密钥（“ A”，“ B”）对我的Entry-stream进行分组，如果没有其他操作，则最终得到如下结构：

Map<String,List<Entry<String,Map<String,Integer>>>>

这就是我被困住的地方。我该如何Map<String,Integer>从我的条目列表中获取我的信息（对于每个外部地图，具体而言）？

我假设可以保证需要使用以下简单代码：

        initialMap.values().stream()
                            .flatMap(m -> m.entrySet().stream())
                            .collect(Collectors.groupingBy(Map.Entry::getKey));

摘要：

如何变换Map<String,Map<String,Map<String,Integer>>>到Map<String<Map<String,Integer>>不顾最外层Map，分组我最里面Maps按照我的第二个，图层- Keys和总结我Integer的-值key最里面的-值Map。此外，最外面的每个第二级Maps都有一个，因此每个都会有相同的第二级。在3 -级别- s时，可以无法在其他3-级别-发现Key-Value-PairMapKeysKeysetKeysMaps

我有 2 个列表。要求是根据条件过滤掉list1中不在list2中的元素。

  Class Fighter
  {
    String name;
    String address;
  }     
  List<Fighter> pairs1 = new ArrayList();
    pairs1.add(new Fighter("a", "a"));
    pairs1.add(new Fighter("b", "a"));

    List<Fighter> pairs2 = new ArrayList();
    pairs2.add(new Fighter("a", "c"));
    pairs2.add(new Fighter("a", "d"));
    Set<Fighter> finalValues = new HashSet<>();


    finalValues = pairs1.stream().filter(firstList -> 
   pairs2.stream().noneMatch(secondList -> 
   firstList.getName().equals(secondList.getName())
            && firstList.getName().equals(secondList.getName()))).collect(Collectors.toSet());

    System.out.println(finalValues);

预期输出：a=a, b=a

说明：list1 中的元素不在 list2 中

上面的代码没有给出预期的输出。请让我知道如何更正上述流代码以获得输出

我有以下封面.我需要为被许可人添加值,日期并在框中填写另一个给定的文本.如何使用iText完成此操作.任何帮助表示赞赏.

我有一个这样的用例。我在我的 Mongo DB 中有问题并且有一个 CRUD 微服务。在那里，我公开了一种 API 方法，可以通过查询参数给出的 ID 列表来获取问题。让我们说为了简单起见，用户给出/api/questions?id=2, id=7, id=4, id = 5

然后我需要以完全相同的顺序返回问题列表，就像这样

questions: [
    {
       id: 2,
       prompt: "prompt one",
       ...
    },
    {
        id: 7,
        prompt: "prompt two",
        ...
    },
    {
        id: 4,
        ...
    },
    {
        id: 5
        ...
    }
]

但请注意，这既不是 ASC 也不是 DESC，而是可以是任意顺序，例如 /api/questions?id=2, id=7, id=4, id=5

我正在使用org.springframework.data.mongodb.repository.MongoRepository我的DAO班级。目前，我正在通过基于 spring-data 的存储库获取数据后在我的服务层内进行排序。该解决方案有效。但我更愿意在 DAO 存储库级别本身完成此排序，因为它成本更低，并且不会在服务层为我的业务逻辑增加不必要的复杂性。相反，我可以仅将责任委托给数据库，假设它更有能力通过更多优化来完成这些事情。

Mongo 文档结构如下所示。

我可以使用弹簧数据实现这一点吗？如果是这样，如何完成那件事？

以下是我的课

public final class Test {
enum Animal {DOG,CAT};
enum COLOR {RED,YELLOW};

class Meaningless {
    String animal,color;
}
public void filter(List<Meaningless> meaninglesses){
    meaninglesses.stream()
            .filter(meaningless -> {
                try {
                    Animal.valueOf(meaningless.animal);
                    return true;
                }catch(Exception e){
                    return false;
                }
            })
            .filter(meaningless -> {
                try {
                    COLOR.valueOf(meaningless.color);
                    return true;
                }catch(Exception e){
                    return false;
                }
            })
            .collect(Collectors.toList());
}

}

filter方法的2次迭代实质上过滤掉了无效的枚举类型。如何从中删除重复的代码？该检查应该足够通用，以便isValidEnum在enum引入新的检查时不必更改。

理想情况下，我想做类似的事情

 meaninglesses.stream()
            .filter(meaningless -> isValidEnum(meaningless.animal,Animal.class))
            .filter(meaningless -> isValidEnum(meaningless.color,COLOR.class))

我想转换以下xml，

<pets>
    <Pet>
        <category>
            <id>4</id>
            <name>Lions</name>
        </category>
        <id>9</id>
        <name>Lion 3</name>
        <photoUrls>
            <photoUrl>url1</photoUrl>
            <photoUrl>url2</photoUrl>
        </photoUrls>
        <status>available</status>
        <tags>
            <tag>
                <id>1</id>
                <name>tag3</name>
            </tag>
            <tag>
                <id>2</id>
                <name>tag4</name>
            </tag>
        </tags>
    </Pet>
</pets>

转换成这种 xml 格式。

<pets>
    <Pet>
        <category>
            <id>4</id>
            <name>Lions</name>
        </category>
        <id>9</id>
        <name>Lion 3</name>
        <photoUrl>url1</photoUrl>
        <photoUrl>url2</photoUrl>
        <status>available</status>
        <tag>
            <id>1</id>
            <name>tag3</name>
        </tag>
        <tag>
            <id>2</id>
            <name>tag4</name>
        </tag>
    </Pet>
</pets>

我尝试按如下方式编写模板，但它删除了父元素及其子元素。

<xsl:template match="photoUrls"/>

这如何在 xslt 中完成。任何帮助表示赞赏。

大家好，使用streams时，有一个问题。我有一个工作表，我想按其中出现字符的频率进行排序：

List<String> frequency = new ArrayList<>();
        Collections.addAll(frequency, "gg", "ss", "gg", "boy", "girls", "girls", "gg", "boy", "aa", "aa");

我写了这个方法：

return words.stream().limit(limit).map(String::toLowerCase)
.collect(Collectors.groupingBy(Function.identity(),Collectors.counting()))
                    .entrySet().stream()
                    .map(entry -> new Pair<>(entry.getKey(), entry.getValue()))
                    .collect(Collectors.toList());

但是已经显示的答案是不正确的，字符串a完全丢失，字符串gg是一个元素，而boy是一个元素

ss=1
gg=2
girls=2
boy=1

而且我不知道如何按发生频率对它们进行排序。结果应该是这样的：

gg=3
aa=2
boy=2
girls=2
ss=1

如何改善呢？

我在Java 11中有此代码

Object a = getObjectOrNullIfNotAvailable();
String value = a==null ? null : a.toString();

我想使用Optional编写此代码，我能想到的最好的方法是。我没有尝试运行它，但我怀疑它会起作用

Optional<Object> oa = Optional.ofNullable(getObjectOrNullIfNotAvailable());
Optional<String> oas = oa.map(a -> a.toString());
String value = oas.orElse(null);

除了在可选组件上运行map之外，我还有什么想法可以实现此目的。我希望有类似下面的代码，但这行不通

Optional<Object> oa = Optional.ofNullable(getObjectOrNullIfNotAvailable());
String value = oa.ifPresentOrElse(a -> a.toString(), a -> null);

我正在使用放心为我的微服务编写集成测试。我有一个像这样的 Json 有效负载，它是从它返回的。

{
   "sessionQuestions":[
      {
         "id":1272,
         "sessionId":1146,
         "questionId":"1002",
      },
      {
         "id":1273,
         "sessionId":1146,
         "questionId":"1004",
      }
   ]
}

我需要根据 QuestionId 值查找会话问题的 id。然后我需要在我的断言中比较它们。给定 QuestionId 值，我很难从 sessionQuestion 中获取 id。我正在使用 JsonPath 来完成这件事。这是我的 Json 路径表达式。

new JsonPath(response).get("$.sessionQuestions[?(@.questionId=='1002')].id");

这会引发错误。

java.lang.IllegalArgumentException: Invalid JSON expression:
Script1.groovy: 1: expecting EOF, found '[' @ line 1, column 45.
   nRootObject.$.sessionQuestions[?(@.quest
                                 ^

1 error

   at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)

我在此在线评估器中尝试了相同的 Json 路径表达式，效果很好。我在用json-path-2.9.0.jar

我在这里做错了什么？非常感谢任何帮助。

我有以下问题。有两个大小相等的整数列表a和b。现在，我想比较两个列表值在相同的索引处。我的函数返回带有2个值的列表。第一个值是列表a中更大的值计数。第二个值是列表b中更大的值计数。如果两者的值相同，则计数不增加。

我可以一些想法如何使用流/过滤器/谓词在java8中实现

我已经在较旧的Java版本中重新运行了该方法。

    static List<Integer> compareTriplets(List<Integer> a, List<Integer> b) {
        List<Integer> list = new ArrayList<Integer>();
        int asize = 0;
        int bsize = 0;
        for (int i = 0; i <b.size();i++) {
            if(a.get(i) > b.get(i)) {
                asize++;
            }else if(a.get(i) < b.get(i)) {
                bsize++;
            }
        }
        list.add(asize);
        list.add(bsize);
        return list;
    }

例1。输入：a = 5 6 7 b = 3 6 10输出：1 1例如2.输入：a = 17 28 30 b = 99 16 8输出：2 1

我正在尝试根据条件过滤列表。是否有其他替代方法可以中断Java 8流以停止过滤？

举个例子：假设我有以下列表。

List<String> list = Arrays.asList("Foo","Food" ,"Fine","Far","Bar","Ford","Flower","Fire");

list.stream()
        .filter(str -> str.startsWith("F")) //break when str doesn't start with F
        .collect(Collectors.toList());

我希望从头开始以“ F”开头的所有字符串，一旦找到不以“ F”开头的字符串，我想停止过滤。没有流，我将执行以下操作：

List<String> result = new ArrayList<>();
for(String s : list){
    if(s.startsWith("F")){
        result.add(s);
    }
    else{
        break;
    }
}

如何在信息流中使用“中断”？

我有两个清单。我想创建一个映射里面会有真正的匹配部件及虚假的唯一一个在Java 8
EG。
输入 -

列表1 = [A，B，C，D]
列表2 = [B，C，Y，Z]

输出 -

地图：

A，假

B，真

C真

D，假

我的代码：

Map<String,Boolean> map = new HashMap<>();
            for(String var1 : list1) {
                boolean value;
                if (CollectionUtils.isNotEmpty(list2)) {
                    Optional<String> valueOptional = list2.stream()
                            .filter(e1 -> e1.equalsIgnoreCase(var1))
                            .findAny();
                    value = valueOptional.isPresent();
                    map.put(var1, value);
                }
            }