Более быстрый метод для извлечения отдельной строки из Arraylist

Question

У меня есть ArrayList of Dico, и я пытаюсь извлечь четкую строку из Arraylist of 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

Вы не можете сделать что-то подобное?

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 различных значений. Если эффективность является проблемой, вы можете попытаться параллельно запустить конвейер и измерить, если он будет быстрее.

Answer 2

Потоки не будут работать быстрее, но могут сделать его намного проще и понятнее.

Вот простейшая версия. Он будет принимать все индексы списка, сортировать их по расстоянию до середины списка, получать соответствующий термин, отфильтровывать дубликаты и ограничивать до 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()); 
}