小编Stu*_*rks的帖子

我创建了两个Stream

Stream<String> first= ...
Stream<String> second= ...

他们俩都有数字.假设第一个文件有1到1000而第二个文件有25到35.我想检查第一个文件是否包含秒数的数字.

first.filter(s-> !s.contains(second.toString())
     .collect(Collectors.toList());

如果我second.toString()用"10" 替换它然后它可以工作,但我如何检查整个流而不仅仅是字符串或字符串？

我们可以像这样从字符串List创建流

    List<String> list = Arrays.asList("somestring");
    Stream<String> stream = list.stream();

但是如何直接从字符串创建流.

String x = "somestring";

String[] stringArray = streamString.toArray(size -> new String[size]);

如何自动将大小视为流的大小？

如何使用流解析Generic到Object []？我有过

private static <T> List<Object[]> selectData(List<T> a,
    Predicate<T> predicate) {
    ArrayList<Object[]> tmp = new ArrayList<Object[]>();
    for (T x : a) {
      if (predicate.test(x)) {
        tmp.add(new Object[] { x });
      }
    }   
return tmp;
}

但我想做的事情如下:

...//    
return a.stream().filter(predicate).collect(Collectors.toList());

但我不知道如何将每个元素转换为Object []

使用流API; 一旦相关数据被过滤,我想编辑正在收集的数据.这是迄今为止的代码:

  String wordUp = word.substring(0,1).toUpperCase() + word.substring(1);
  String wordDown = word.toLowerCase();

  ArrayList<String> text = Files.lines(path)
        .parallel() // Perform filtering in parallel
        .filter(s -> s.contains(wordUp) || s.contains(wordDown) &&  Arrays.asList(s.split(" ")).contains(word))
        .sequential()
        .collect(Collectors.toCollection(ArrayList::new));

编辑下面的代码很糟糕,我试图避免它.(它也没有完全奏效.它是在凌晨4点完成的,请原谅.)

    for (int i = 0; i < text.size(); i++) {
        String set = "";
        List temp = Arrays.asList(text.get(i).split(" "));
        int wordPos = temp.indexOf(word);

        List<String> com1 = (wordPos >= limit) ? temp.subList(wordPos - limit, wordPos) : new ArrayList<String>();
        List<String> com2 = (wordPos + limit < text.get(i).length() -1) …

我是大学新手Java程序员.我今天发现了一些关于Java语法如何工作的概念.

public class testClass {

ArrayList <String> persons = new ArrayList <String> ();

public void run(){
    Stream <String> personstream = persons.stream();
}}

stream()在ArrayList类中找不到该方法,但它可能看起来好像在那里.当我将鼠标移到stream()Eclipse中的-method上时,它表示它是Collections的一部分,但我stream()在其在线文档中找不到任何方法.

stream()如果它不是我从中调用它的类的一部分,为什么调用该方法呢？

我已经阅读了一本关于Java 8的书,该书说使用并行流来获取数字的范围IntStream.range(0,someNumber)可能比连续的慢...为什么？

我目前正在JDK 1.8上学习lambda表达式.我遇到了一些我发现我不理解的代码.

这是代码:

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.lang.Comparable;

/**
 * Hello world!
 *
 */
public class App
{
    public static void main( String[] args ) throws Exception
    {

        List<String> list = Arrays.asList("a", "b", "c");
        sort(list, Comparable::<String>compareTo);

    }

    interface MyComparable {
        public <T extends Comparable<T>> int compare(T obj1, T obj2 );
    }

    public static <T extends Comparable<T>> void sort(List<T> list, MyComparable comp) {

        int n = comp.compare("5","2");
        System.out.println(n);
    }

}

comp.compare("5", "3")最终执行"5".compareTo("2").我的理解是编译器需要找到一个具有相同签名的静态方法

public <T extends …

虽然我使用下面的比较器来对我正在获得的对象进行排序比较方法违反了比较器中的一般合同问题.

final Set<Span> set = new TreeSet<Span>(new Comparator<Span>() {

        public int compare(final Span firstSpan, final Span secSpan) {
            BigInteger s1X0 = firstSpan.getCoordinates().getX0();
            BigInteger s1X1 = firstSpan.getCoordinates().getX1();
            BigInteger s2X0 = secSpan.getCoordinates().getX0();
            BigInteger s2X1 = secSpan.getCoordinates().getX1();

            BigInteger s1Y0 = firstSpan.getCoordinates().getY0();
            final BigInteger s2Y0 = secSpan.getCoordinates().getY0();

            if(s1X0.intValue() == s2X0.intValue() && s1X1.intValue() == s2X1.intValue() && s1Y0.intValue() == s2Y0.intValue()){
                return 0;
            }
            if ((s1Y0.intValue() - s2Y0.intValue() <= 5) && (s1Y0.intValue() - s2Y0.intValue() >= -5)) {
                return (s1X0.intValue()>s2X0.intValue()) ? 1 : -1;
            } else {
                if …