标签: java-8

如何ArrayList在Java中执行脏检查？

我有一个对象

Animal
{
    String animalName;
    String animalType;
    String animalPlace
}

我有两个清单:

List<Animal> animalList1 = new ArrayList<Animal>();
List<Animal> animalList2 = new ArrayList<Animal>();

在第一个列表中,我有值:

[0][lion,Carnivorous,Africa]
[1][tiger,Carnivorous,Zambia]
[2][Goat,Herbivorous,Zimbabwe]

在第二个列表中,我有以下值:

[0][lion,Carnivorous,Africa]
[1][tiger,Carnivorous,Zambia]
[2][Goat,Herbivorous,Norway]

在第二个清单中,animalPlace索引2的元素已从津巴布韦变为挪威.如何比较两个列表值和已更改的值将该对象放在单独的列表中？

List<Animal> animalList3 = new ArrayList<Animal>();

[0] [Goat,Herbivorous,Norway]

通过使用for循环比较列表,我知道传统的方法:

for (int i = 0; i < list1.size(); i++) 
{
  for (int j = i+1; j < list2.size(); j++) 
  {
    // compare list1 and list2 values
  }
}

有更快更好的方式吗？

我有2种方法，这些方法具有要同时运行的不同返回类型。这是我的代码：

public void method(int id) {
    final CompletableFuture<List<FooA>> fooACF = CompletableFuture.supplyAsync(() -> generateFooA(id));
    final CompletableFuture<List<FooB>> fooBCF = CompletableFuture.supplyAsync(() -> generateFooB(id));
    List<FooA> fooAs = fooACF.get();
    List<FooB> fooBs = fooBCF.get();
    //Do more processesing
}

public List<FooA> generateFooA(int id) {
    //code
}

public List<FooB> generateFooB(int id) {
    //code
}

但是我不知道这两种方法是否都可以与上面的代码并行运行，或者我是否更好地说：

List<FooA> fooAs = generateFooA(id);
List<FooB> fooBs = generateFooB(id);

如何正确使用可完成的期货才能并行运行这两种方法？

我有一个有效负载返回以下内容ArrayList:

[0] true (boolean)
[1] "someStringValue"

我需要String使用lambda表达式提取包含该值的元素的值.

有任何想法吗？

我正在尝试执行一项任务,首先计算目录中的文件数,然后在每个文件中给出一个单词计数.我得到的文件数量还不错,但是我很难转换一些代码,我的教师从一个频率计数到更简单的字数的类中给了我.此外,我似乎无法找到正确的代码来查看每个文件来计算单词(我试图找到"通用"而不是特定的东西,但我试图使用特定的文本文件测试程序) .这是预期的输出:

Count 11 files:
word length: 1 ==> 80
word length: 2 ==> 321
word length: 3 ==> 643

但是,这是输出的内容:

primes.txt
but
are
sometimes
sense
refrigerator
make
haiku
dont
they
funny
word length: 1 ==> {but=1, are=1, sometimes=1, sense=1, refrigerator=1, make=1, haiku=1, dont=1, they=1, funny=1}

.....

Count 11 files:

我正在使用两个类:WordCount和FileCatch8

字数:

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.AbstractMap.SimpleEntry;
import java.util.Arrays;
import java.util.Map;
import static java.util.stream.Collectors.counting;
import static java.util.stream.Collectors.groupingBy;

    /**
     *
     * @author 
     */
    public class WordCount …

import java.util.HashMap;
import java.util.Map;

public class MainTest
{
    static Map<String, Integer> map = new HashMap();

    public static void incr()
    {
        map.merge("counter", 1, Integer::sum);
    }

    public static void decr()
    {
        map.merge("counter", -1, Integer::sum);
    }

    public static void main(String[] args) throws Exception
    {
        map.put("counter", 0);
        for (int i = 0; i < 10000; i++)
        {
            Thread t1 = new Thread(new Runnable()
            {
                @Override
                public void run()
                {
                    incr();
                }
            });
            t1.join();
            t1.start();

            Thread t2 = new Thread(new Runnable()
            {
                @Override
                public void …

我试图为结果返回一个布尔值.

 public boolean status(List<String> myArray) {
      boolean statusOk = false;
      myArray.stream().forEach(item -> {
         helpFunction(item).map ( x -> {
              statusOk = x.status(); // x.status() returns a boolean
              if (x.status()) { 
                  return true;
              } 
              return false;
          });
      });
}

lambda表达式中使用的抱怨变量应该是final或者有效的final.如果我指定statusOk,那么我无法在循环内分配.如何使用stream()和map()返回布尔变量？

我需要包含两个单词的行数.为此,我编写了以下代码:输入文件包含1000 lines和关于4,000 words,大约需要4个小时.是否有一个库Java可以更快地完成它？我可以使用Appache Lucene或实现此代码Stanford Core NLP以减少运行时间吗？

ArrayList<String> reviews = new ArrayList<String>();
ArrayList<String> terms = new ArrayList<String>();
Map<String,Double> pij = new HashMap<String,Double>();

BufferedReader br = null;
FileReader fr = null;
try 
    {
        fr = new FileReader("src/reviews-preprocessing.txt");
            br = new BufferedReader(fr);
            String line;
            while ((line= br.readLine()) != null) 
            {
            for(String term : line.split(" "))
                {
                    if(!terms.contains(term))
                        terms.add(term);
                }
                reviews.add(line);
            }
        } 
        catch (IOException e) { e.printStackTrace();} 
        finally 
        {
            try 
            {
                if (br …

我正在查看Collections类的源代码.我遇到了方法 Collections.synchronizedList(list)

public static <T> List<T> synchronizedList(List<T> list) {
    return (list instanceof RandomAccess ?
            new SynchronizedRandomAccessList<>(list) :
            new SynchronizedList<>(list));
}

我无法理解为什么我们要检查列表是否属于RandomAccess类型.我知道ArrayList实现了这个接口,而LinkedList没有.

此外,SynchronizedRandomAccessList继承SynchronizedList.那检查有什么意义呢？请解释

通过JOOL库JOOQ,Streams上提供了许多功能接口和实用程序类.

我的问题是这个库支持1-16个参数功能接口.这有道理吗？因为我一直在练习中将方法中的参数数量减少到3.虽然可接受的数量根据不同的思想领袖而变化.但没有人说16.

请参阅StackOverflow本身的参考链接:

java方法应具有的标准参数数量是多少？

此外,它提供了一个实用程序类Seq,它看起来仅限于顺序处理.

使用JOOL具有良好过去经验的人可以回答为什么我应该使用JOOL看起来像它包含的很多东西是没用的吗？

我调用一个方法,为a Future中的每个元素返回一次List<Principal>,所以我最终得到一个List<Future<UserRecord>>.

返回的方法Future是库代码,我无法控制代码的运行方式,我只有Future.

我想等待所有的Futures完成(成功或失败),然后再继续.

有没有比这更好的方法:

List<Principal> users = new ArrayList<>();
// Fill users
List<Future<UserRecord>> futures = getAllTheFutures(users);
List<UserRecord> results = new ArrayList<>(futures.size());
boolean[] taskCompleted = new boolean[futures.size()];
for (int j = 0; j < taskCompleted.length; j++) {
    taskCompleted[j] = false;
}
do {
    for (int i = 0; i < futures.size(); i++) {
        if (!taskCompleted[i]) {
            try {
                results.add(i, futures.get(i).get(20, TimeUnit.MILLISECONDS));
                taskCompleted[i] = true;
            } catch (TimeoutException e) { …