Вопрос по list, java, collections, sorting – Сортировка списка LIst по значению подсписка

2
private List<String> subList;
private List<List<String>> records = new ArrayList<List<String>>();

for(....){

    subList = new ArrayList<String>();
    ...populate..
    records.add(subList);
}

Например, в subList есть три строки - a, b и c. Я хочу отсортировать записи по значению b в subList.

records at 0 has a list of "10", "20", "30"
records at 1 has a list of "10", "05", "30"
records at 2 has a list of "10", "35", "30"

После сортировки порядок записей должен быть -

records at 0 = records at 1 above
records at 1 = records at 0 above
records at 2 = records at 2 above

Что может быть хорошим алгоритмом для этого?

Вопрос и контрольный пример неоднозначны. Вы хотите отсортировать по второму элементу каждого подсписка, независимо от значения первого элемента? Как сортировать {01,20,30}, {02,05,30} и {03,35,30}? erickson

Ваш Ответ

4   ответа
0

Колонка компаратор позволяет сортировать по любому столбцу в списке. Сортировка выполняется с использованием естественного порядка сортировки данных в столбце.

1
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;


public class MyList 
{

    private List<List<Long>> myList;

    public MyList()
    {
        myList = new ArrayList<List<Long>>();
        ArrayList arrayList = null;

        for(int i=0;i<3;i++)
        {           
            arrayList = new ArrayList<Long>();
            for(int x=0;x<3;x++)
            {           
                arrayList.add((Long)Math.round(Math.random()*10));
            }
            myList.add(arrayList);
        }       
    }

    public static void main(String[] args)
    {
        MyList newList = new MyList();
        newList.printList();
        Collections.sort(newList.getMyList(),new Comparator<List<Long>>(){

            public int compare(List<Long> o1, List<Long> o2) {
                if(o1 != null && o2 !=null)
                {
                    Long var1 = o1.get(0);
                    Long var2 = o2.get(0);

                    return var1.compareTo(var2);                    
                }
                return 0;
            }   
        });
        newList.printList();
    }

    private void printList() {
        for(List<Long> subString : myList)
        {
            System.out.println("List");
            for(Long elements : subString)
            {
                System.out.println(elements);
            }
        }

    }

    public List<List<Long>> getMyList() {
        return myList;
    }

    public void setMyList(List<List<Long>> myList) {
        this.myList = myList;
    }

}
5

с учетом двух строк начните с начала и сравните каждый символ; если есть различие, строка с более низким значением идет первой, в противном случае просматривают следующие символы из каждой строки. Если строки имеют разную длину, обрабатывайте более короткую строку, как если бы она имела суффикс нулей.

В этом случае «символы» целочисленные значения, полученные путем вызоваInteger.parseInt(), Кроме того, реализацияComparator дляList<String> было бы полезно здесь. ТогдаCollections.sort() метод может быть использован.

Компаратор может выглядеть примерно так:

final class MyComparator implements Comparator<List<String>> {

  public int compare(List<String> a, List<String> b) {
    /* Assume all strings are parseable to values 
     * in range [0,Integer.MAX_VALUE] */
    int len = Math.min(a.size(), b.size());
    for (int idx = 0; idx < len; ++idx) {
      int va = Integer.parseInt(a.get(idx)), vb = Integer.parseInt(b.get(idx));
      if (va != vb)
        return va - vb;
    }
    return va.size() - vb.size();
  }

  @Override
  public boolean equals(Object o) {
    return o instanceof MyComparator;
  }

  @Override
  public int hashCode() {
    return MyComparator.class.hashCode();
  }

}
Да, например, инкапсулирующий класс может помешать добавлению любых строк, которые можно анализировать как целые числа в допустимом диапазоне.
В зависимости от контекста, возможно, стоит заменитьList<String> с инкапсулирующим классом.
5

Что-то вроде:

Collections.sort(records, new Comparator<List<String>>()
{
  public int compare(List<String> o1, List<String> o2)
  {
    //Simple string comparison here, add more sophisticated logic if needed.
    return o1.get(1).compareTo(o2.get(1));
  }
})

Хотя я нахожу жесткое кодирование позиций на практике несколько сомнительным, ваше мнение может отличаться.

Я прочитал вопрос как «отсортировать по второму элементу в каждом подсписке», другими словами, по индексу 1.
1 является индексом "b"?

Похожие вопросы