小编zak*_*zak的帖子

我需要一个Java流操作来测试两个集合是否至少具有3个公共元素。

这是我的Java 7代码，可以正常工作：

@Test
public void testContainement(){
    Set<Integer> setOne = IntStream.of(0,1,4,3)
                                   .boxed()
                                   .collect(Collectors.toCollection(HashSet::new));

    Set<Integer> setTwo = IntStream.of(0,1,4,5)
            .boxed()
            .collect(Collectors.toCollection(HashSet::new));

    Assertions.assertEquals(true,testSets(setOne,setTwo));

}

private boolean testSets( Set<Integer> setOne, Set<Integer> setTwo ) {
    int counter=0;
    for (int x: setOne){
        if (setTwo.contains(x))
            counter++;
    }
    return counter > 2;
}

我们如何使用Java流操作来做到这一点？

我正在尝试逐行读取一个长文件,并尝试同时从该行中提取一些信息.

这是我正在做的一个例子:

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.stream.Stream;

public class ReadFile_Files_Lines {

    public static void main(String[] pArgs) throws IOException {
        String fileName = "c:\\temp\\sample-1GB.txt";
        File file = new File(fileName);

        try (Stream<String> linesStream = Files.lines(file.toPath())) {
            linesStream.forEach(line -> {
                System.out.println(line);
            });
        }
    }
}

我文件中的一行分为三部分:

10 1010101 15

我希望每次都阅读这三个信息.喜欢 :

String str1 = line[0];
String str2 = line[1];
String str3 = line[2];

如果我不将流转换为集合,我正在寻找的解决方案会更好.我将使用这3个String来创建图形数据结构,如:

createGraphe(str1,str2,str3);`

我知道我可以发送完整的字符串,但是因为我正在学习Stream我很想知道如何提取这些信息.

谢谢.

我有一些对象.我需要从Set中获取两个min对象.

我的例子如下:

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Example {
     public static void main( String[] args ) {
         SomeObject obj1 = new SomeObject(1);
         SomeObject obj2 = new SomeObject(2);
         SomeObject obj3 = new SomeObject(3);
         Set<SomeObject> set = Stream.of(obj1,obj2,obj3)
                                     .collect(Collectors.toSet());

         SomeObject minObject= set.stream()
                                  .min(Comparator.comparingInt(object->object.getValue()))
                                  .get();
         System.out.println(minObject);
     }
}


class SomeObject{
    private int value;
    SomeObject(int value){
            this.value=value;
    }

    public int getValue() {
        return value;
    }

    @Override
    public String toString() {
        return this.value+"";
    }
}

在我的例子中,我可以根据value属性从这个Set中获取min对象.

所以,我需要使用java流操作获取两个最小值.

awnser应该很快,因为在我的真实程序中,我多次调用此方法,我的集合非常大.

我有一个列表列表,我想使用java Stream返回具有最小大小的列表.

这是我试过的:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Example {
   public static void main( String[] args )  {
         ArrayList<Integer> list1 = new ArrayList<>();
         list1.add(0);list1.add(2);list1.add(3);

         ArrayList<Integer> list2 = new ArrayList<>();
         list2.add(0);list2.add(2);list2.add(3);list2.add(4);

         System.out.println( getTheMinList(list1,list2).size());    
   }

   public static ArrayList<Integer> getTheMinList(ArrayList<Integer>... lists) {
         return Arrays.stream(lists)
                      .map(list->list.size())
                      /*here i stoped*/
                ;
   }
}

程序应该打印,3因为第一个列表具有最小大小.

请注意,我无法更改getTheMinList()的签名.有人可以给我一个提示吗？

我有一个HashMap<Integer, Integer>,我愿意得到一个特定价值的关键.

例如我的HashMap:

Key|Vlaue
2--->3
1--->0
5--->1

我正在寻找一个java流操作来获取具有最大值的密钥.在我们的示例中,密钥2具有最大值.

所以2应该是结果.

使用for循环它是可能的,但我正在寻找一种java流方式.

import java.util.*;

public class Example {
     public static void main( String[] args ) {
         HashMap <Integer,Integer> map = new HashMap<>();
         map.put(2,3);
         map.put(1,0);
         map.put(5,1);
         /////////

     }
}

我有一个包含重复ArrayList的List.

我正在寻找解决方案来删除它们.

这是一个例子:

listOne = [[1, 0], [0, 1], [3, 2], [2, 3]]

该集包含重复的List.通常我想得到:

theListAfterTransformation  = [[1, 0],[3, 2]]

这是我的小例子,我试图使用Set但它不能很好地工作.

public class Example {
    public static void main( String[] args ) {
        ArrayList<ArrayList<Integer>> lists = new ArrayList<>();

        ArrayList<Integer> list1 = new ArrayList<>(); list1.add(1); list1.add(0);
        ArrayList<Integer> list2 = new ArrayList<>(); list2.add(0); list2.add(1);
        ArrayList<Integer> list3 = new ArrayList<>(); list3.add(3); list3.add(2);
        ArrayList<Integer> list4 = new ArrayList<>(); list4.add(2); list4.add(3);

        lists.add(list1);lists.add(list2);lists.add(list3);lists.add(list4);

        System.out.println(getUnduplicateList(lists));


    }
    public static ArrayList<ArrayList<Integer>> getUnduplicateList( ArrayList<ArrayList<Integer>> lists) {
        Iterator iterator = lists.iterator();
        Set<ArrayList<Integer>> …

我有一个 HashMap<Integer, Set<Integer>>.

我想将Collection地图中的集合转换为列表列表.

例如:

import java.util.*;
import java.util.stream.*;
public class Example {

         public static void main( String[] args ) {
             Map<Integer,Set<Integer>> map = new HashMap<>();
             Set<Integer> set1 = Stream.of(1,2,3).collect(Collectors.toSet());
             Set<Integer> set2 = Stream.of(1,2).collect(Collectors.toSet());
             map.put(1,set1);
             map.put(2,set2);

             //I tried to get the collection as a first step
             Collection<Set<Integer>> collectionOfSets = map.values();

             // I neeed  List<List<Integer>> list = ...... 

             //so the list should contains[[1,2,3],[1,2]]
         }
    }

我有一个整数列表列表,如list1 =(1,2,3)和list2 =(0,1).

我的列表列表包含list1和list2.它可以包含更多但是对于示例我只采用了两个列表.

问题是使用java流获取最小大小的列表索引.

这是我的程序,它只使用for循环方法.

import java.util.ArrayList;

public class Example {

     public static void main( String[] args ) {


         ArrayList<Integer> list1 = new ArrayList<>();
         list1.add(1);list1.add(2);list1.add(3);

         ArrayList<Integer> list2 = new ArrayList<>();
         list2.add(0);list2.add(1);

         ArrayList<ArrayList<Integer>> listOLists = new ArrayList<>();
         listOLists.add(list1);
         listOLists.add(list2);
         printTheIndexOfTheListWithTheMinSize(listOLists);
     }

    private static void printTheIndexOfTheListWithTheMinSize( ArrayList<ArrayList<Integer>> listOLists ) {
        int minSize  = listOLists.get(0).size();
        int minIndex = 0;
        int i=0;
        for ( ArrayList<Integer> list:  listOLists ) {

            if (list.size()<minSize)
            {
                minSize = list.size();
                minIndex=i;
            }
            i++;

        }
        System.out.println(minIndex);
    }
}

能否请您使用Java流API向我提示如何做到这一点. …

我的问题是关于内部方法调用的 AOP Spring 行为。

@Service
class Service {
    @Transactional
    public void method1() {
        method1();
    }

    @Transactional
    public void method2() {}
}

如果我们从外部调用method1()，method1()会以事务模式执行，但由于内部调用method2()，method2()内部的代码不会以事务模式执行。

同时，对于 Configuration 类，通常我们应该有相同的行为：

@Configuration
class MyConfiguration{
    @Bean
    public Object1 bean1() {
        return new Object1();
    }

    @Bean
    public Object1 bean2() { 
        Object1 b1 = bean1();
        return new Object2(b1);
    }
}

通常，如果我理解得很好，从 bean2() 调用 bean1() 方法不应该被代理对象拦截，因此，如果我们多次调用 bean1()，我们每次都应该得到不同的对象。

首先，您能否从技术上解释为什么代理对象没有拦截内部调用，其次检查我对第二个示例的理解是否正确。

我正在寻找将字符添加到字符串中特定位置的有效方法。

我的例子：

package test;

public class Test {

/**
 * @param args the command line arguments
 */
public static void main(String[] args) {

      //Creating A String Object that Hold "Hello"  
      String  seq = new String("Hello");
      System.out.println(seq);/*printing Hello*/

      /*putting tha char _ in the 3 Position :  He_llo */
      seq = seq.substring(0, 2)+ "_" + seq.substring(2, seq.length());
      System.out.println(seq);/*it prints He_llo*/

  }

这只是一个简单的函数，但在我的真实程序中，我正在处理：

• 1- 长度为 400-600 个字符的字符串。
• 2- 我会多次调用以在字符串中间添加 _ 字符。

在我看来，使用 String Object 或 StringBuilder Object 并不是最好的 Object，因为seq = seq.substring(0, …