сортировка 2D массива строк в Java

Question

Я знаю, что этот вопрос, возможно, задавался раньше, но я не смог найти подходящий ответ.Скажем, у меня есть этот массив:

String [][] theArray = {{"james", "30.0"},{"joyce", "35.0"},{"frank", "3.0"}, {"zach", "34.0"}}

Есть ли способ отсортировать этот массив по убыванию по второму элементу каждого подэлемента.Так что я бы получил что-то вроде этого.

theArray = {{"joyce", "35.0"},{"zach", "34.0"},{"james", "30.0"}, {"frank", "3.0"}}

Спасибо, ребята

Answer 1

Использование Arrays.sort(arr, comparator) с пользовательским компаратором:

Arrays.sort(theArray, new Comparator<String[]>(){

    @Override
    public int compare(final String[] first, final String[] second){
        // here you should usually check that first and second
        // a) are not null and b) have at least two items
        // updated after comments: comparing Double, not Strings
        // makes more sense, thanks Bart Kiers
        return Double.valueOf(second[1]).compareTo(
            Double.valueOf(first[1])
        );
    }
});
System.out.println(Arrays.deepToString(theArray));

Выход:

[[joyce, 35.0], [zach, 34.0], [james, 30.0], [frank, 23.0]]

---

Внимание:

вы будете сортировать массив, который вы передали, Arrays.sort() не вернет новый массив (фактически он возвращает void). Если вы хотите отсортированную копию, сделайте это:

String[][] theCopy = Arrays.copyOf(theArray, theArray.length);

И выполнить сортировку по theCopy, а не theArray.

Answer 2

Вы должны использовать метод Arrays.sort () .Этот метод принимает Comparator в качестве аргумента.Метод sort делегирует компаратору, чтобы определить, должен ли один элемент массива считаться больше, меньше или равен другому элементу.Поскольку каждый элемент внешнего массива является массивом, компаратору придется сравнивать массивы (строк).

Массивы должны сравниваться на основе значения их второго элемента.Этот второй элемент является строкой, которая фактически представляет собой двойное число.Поэтому вам придется преобразовывать строки в числа, иначе порядок будет лексикографическим (20 предшествует 3), а не числовым.

Компаратор может выглядеть следующим образом:

public class StrinArrayComparator implements Comparator<String[]> {
    @Override
    public int compare(String[] array1, String[] array2) {
        // get the second element of each array, andtransform it into a Double
        Double d1 = Double.valueOf(array1.[1]);
        Double d2 = Double.valueOf(array2.[1]);
        // since you want a descending order, you need to negate the 
        // comparison of the double
        return -d1.compareTo(d2);
        // or : return d2.compareTo(d1);
    }
}

Answer 3

Если вы хотите отойти от массивов, вот вариант, который использует List<Record> и RecordComparator, которые implements Comparator<Record>.

Консоль

joyce 35.0
zach 34.0
james 30.0
frank 23.0

Код:

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

/** @see http://stackoverflow.com/questions/5064027 */
public class ComparatorTest {
    public static void main(String[] args) {
        List<Record> list = new ArrayList<Record>(Arrays.asList(
            new Record("james", "30.0"),
            new Record("joyce", "35.0"),
            new Record("frank", "23.0"),
            new Record("zach",  "34.0")));
        print(list, Sort.DESCENDING, Field.D);
    }

    private static void print(List<Record> list, Sort s, Field f) {
        RecordComparator rc = new RecordComparator(s, f);
        Collections.sort(list, rc);
        for (Record r : list) {
            System.out.println(r);
        }
    }
}

class Record {

    private String s;
    private Double d;

    public Record(String name, String number) {
        this.s = name;
        this.d = Double.valueOf(number);
    }

    @Override
    public String toString() {
        return s + " " + d;
    }

    public int compareTo(Field field, Record record) {
        switch (field) {
            case S: return this.s.compareTo(record.s);
            case D: return this.d.compareTo(record.d);
            default: throw new IllegalArgumentException(
                "Unable to sort Records by " + field.getType());
        }
    }
}

enum Sort { ASCENDING, DESCENDING; }

enum Field {

    S(String.class), D(Double.class);

    private Class type;

    Field(Class<? extends Comparable> type) {
        this.type = type;
    }

    public Class getType() {
        return type;
    }
}

class RecordComparator implements Comparator<Record> {

    private Field field;
    private Sort sort;

    public RecordComparator(Sort sort, Field field) {
        this.sort = sort;
        this.field = field;
    }

    @Override
    public final int compare(Record a, Record b) {
        int result = a.compareTo(field, b);
        if (sort == Sort.ASCENDING) return result;
        else return -result;
    }
}

Answer 4

Вы, кажется, живете в отрицании объекта .Эти внутренние массивы очень похожи на информацию о Person (с именем и некоторым значением, может быть, счетом).

Что вы хотели бы сделать, это написать собственный класс для хранения этой информации:

public class Person {
  private final String name;
  private final double score;

  public Person(final String name, final double score) {
    this.name=name;
    this.score=score;
  }

  public String getName() {
    return name;
  }

  public double getScore() {
    return score;
  }
}

Затем, когда вы хотите отсортировать их, вы просто реализуете Comparator<Person>, который указывает, как вы хотите их отсортировать:

public PersonScoreComparator implements Comparator<Person> {
  public int compare(Person p1, Person p2) {
    return Double.compare(p1.getScore(), p2.getScore());
  }
}

В качестве альтернативы, вы можетечтобы сам класс Person реализовал Comparable<Person>, добавив этот метод:

public int compareTo(Person other) {
  return Double.compare(getScore(), other.getScore());
}

Answer 5

/**
     *
     * @param array - 2D array required to be arranged by certain column
     * @param columnIndex - starts from 0; this will be the main comparator
     * @param hasHeaders - true/false; true - ignore the first row. False -
     * first row it's also compared and arranged
     * @return - the new arranged array
     */
    private String[][] arrangeArray(String[][] array, int columnIndex, boolean hasHeaders) {
        int headersExists = 0;
        if (hasHeaders) {
            headersExists = 1;
        }
        for (int i = headersExists; i < array.length; i++) {
            for (int j = headersExists; j < array.length; j++) {
            if (array[i][columnIndex].compareTo(array[j][columnIndex]) < 0){
                String[] temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
    }
    return array;
}

Answer 6

public static void main (аргументы String []) {

String Name[][]={{"prakash","kumar"},{"raj","kappor"},{"vinod","bhart"}};

String str[]=new String[2];


for(int j=0; j<Name.length;j++)
 {
     for (int i=0 ; i<2; i++)
     {
         str[i]=Name[j][i];
     }
 for(int i=0;i<str.length;i++)
 {
     for(int k=i+1;k<str.length;k++)
     {
         if(str[i].compareTo(str[k])>0)
         {
             String temp= str[i];
             str[i]=str[k];
             str[k]=temp;
         }

         }
     System.out.print(str[i]+ " ");
  }
 System.out.println();
 }



 }
}

Answer 7

может быть, эта ссылка помогает Как отсортировать строки, содержащие числа в Java

Answer 8

В java.util.Arrays есть несколько методов сортировки.Два из них принимают обычай Comparator с.Просто предоставьте компаратор, сравнивающий второй элемент внутренних массивов.

Answer 9

-Создание списка из этого массива с помощью Arrays.toList () - Разработайте компаратор, используя java.lang.comparator и напишите логику для сортировки всех четных элементов