从 Arraylist 中提取不同字符串的更快方法

Question

我有一个 Dico 的 ArrayList，我尝试从 Dico 的 Arraylist 中提取一个不同的字符串。

这是 Dico 类。

public class Dico implements Comparable {
private final String m_term;
private double m_weight;
private final int m_Id_doc;

public Dico(int Id_Doc, String Term, double tf_ief) {
    this.m_Id_doc = Id_Doc;
    this.m_term = Term;
    this.m_weight = tf_ief;
}

public String getTerm() {
    return this.m_term;
}

public double getWeight() {
    return this.m_weight;
}

public void setWeight(double weight) {
    this.m_weight = weight;
}

public int getDocId() {
    return this.m_Id_doc;
}
}

我使用这个函数从这个数组的中间提取 1000 个不同的值： 我从中间开始，我只在左右两个方向上取不同的值

public static List <String> get_sinificativ_term(List<Dico> dico)
 {
   List <String> term =  new ArrayList();
   int  pos_median= ( dico.size() / 2 );
   int count=0;
   int i=0;
   int j=0;   
  String temp_d = dico.get(pos_median).getTerm();
  String temp_g =temp_d;
  term.add(temp_d);

 while(count < 999) // count of element 
  {   
   if(!temp_d.equals(dico.get( ( pos_median + i) ).getTerm()))

 {    
     temp_d = dico.get(( pos_median + i)).getTerm(); // save current term in temp
     //  System.out.println(temp_d);
       term.add(temp_d);  // add term to list                            
       i++;     // go to the next value-->right
       count++;
     //  System.out.println(temp_d);
   }

  else
       i++; // go to the next value-->right

  if(!temp_g.equals(dico.get( ( pos_median+j ) ).getTerm()))

 {    
       temp_g = dico.get(( pos_median+j )).getTerm();

      term.add(temp_g );// add term to array
     //  System.out.println(temp_g);
      j--; //  go to the next value-->left

      count++;
   }
  else 
         j--;//  go to the next value-->left

}      
    return term;
 }

我想让我的解决方案比这个函数更快，如果可能的话，我可以用 Java SE 8 Streams 做这个吗？

Answer 1

Streams 不会让它更快，但可以让它更简单、更清晰。

这是最简单的版本。它将获取所有列表索引，按到列表中间的距离对它们进行排序，获取相应的术语，过滤掉重复项并限制为 1000 个元素。它肯定会比你的迭代代码慢，但更容易理解，因为代码巧妙地反映了它的英文描述：

public static List<String> get_sinificativ_term(List<Dico> dicolist) {
    int size = dicolist.size();

    return IntStream.range(0, size)
            .boxed()
            .sorted(comparing(i -> Math.abs(size / 2 - i)))
            .map(dicolist::get)
            .map(Dico::getTerm)
            .distinct()
            .limit(1000)
            .collect(toList());
}

如果您的列表非常庞大并且您想避免对其进行排序，则可以牺牲一些简单性来换取性能。这个版本做了一些数学运算，从中心向右-左-右-左：

public static List<String> get_sinificativ_term(List<Dico> dicolist) {
    int size = dicolist.size();

    return IntStream.range(0, size)
            .map(i -> i % 2 == 0 ? (size + i) / 2 : (size - i - 1) / 2)
            .mapToObj(i -> dicolist.get(i).getTerm())
            .distinct()
            .limit(1000)
            .collect(toList());
}

Answer 2

你不能这样做吗？

public static List <String> get_sinificativ_term(List<Dico> dico) {
    List<String> list = dico.stream()
                            .map(Dico::getTerm)
                            .distinct()
                            .limit(1000)
                            .collect(Collectors.toList());
    if(list.size() != 1000) {
         throw new IllegalStateException("Need at least 1000 distinct values");
    }
    return list;
}

您需要检查大小，因为您可以拥有少于 1000 个不同的值。如果效率是一个问题，您可以尝试并行运行管道并测量它是否更快。