Сортируемый просмотр таблицы в android

Question

Я не могу понять код компаратора , упомянутый в следующей библиотеке GitHub.

Может кто-нибудь объяснить код компаратора лучше?

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

Если вам нужно сделать ваши данные сортируемыми, вы должны использовать SortableTableView вместо обычного TableView . Чтобы сделать таблицу сортируемой по столбцу, все, что вам нужно сделать, - это внедрить Comparator и установить для него столбец speci c.

Код компаратора:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    // ...
    sortableTableView.setColumnComparator(0, new CarProducerComparator());
}

private static class CarProducerComparator implements Comparator<Car> {
    @Override
    public int compare(Car car1, Car car2) {
        return car1.getProducer().getName().compareTo(car2.getProducer().getName());
    }
}

При этом SortableTableView автоматически отображает сортируемый индикатор рядом с заголовком таблицы столбца с индексом 0. При щелчке по этому заголовку таблицы таблица сортируется по возрастанию с помощью данного компаратора. Если щелкнуть заголовок таблицы еще раз, он будет отсортирован в порядке убывания.

Ссылка на GitHub: https://github.com/ISchwarz23/SortableTableView

Answer 1

это оригинальный исходный код java.util.Comparator, который используется в этой библиотеке, вы можете видеть, что происходит, и я думаю, что car1 и car2 представляют строку и следующую строку для сравнения. просто удерживайте ctrl и нажмите на любой метод, который вы не можете понять, который приведет вас к исходному коду.

<code>    /*
 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package java.util;

import java.io.Serializable;
import java.util.function.Function;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import java.util.function.ToDoubleFunction;
import java.util.Comparators;

/**
 * A comparison function, which imposes a <i>total ordering</i> on some
 * collection of objects.  Comparators can be passed to a sort method (such
 * as {@link Collections#sort(List,Comparator) Collections.sort} or {@link
 * Arrays#sort(Object[],Comparator) Arrays.sort}) to allow precise control
 * over the sort order.  Comparators can also be used to control the order of
 * certain data structures (such as {@link SortedSet sorted sets} or {@link
 * SortedMap sorted maps}), or to provide an ordering for collections of
 * objects that don't have a {@link Comparable natural ordering}.<p>
 *
 * The ordering imposed by a comparator <tt>c</tt> on a set of elements
 * <tt>S</tt> is said to be <i>consistent with equals</i> if and only if
 * <tt>c.compare(e1, e2)==0</tt> has the same boolean value as
 * <tt>e1.equals(e2)</tt> for every <tt>e1</tt> and <tt>e2</tt> in
 * <tt>S</tt>.<p>
 *
 * Caution should be exercised when using a comparator capable of imposing an
 * ordering inconsistent with equals to order a sorted set (or sorted map).
 * Suppose a sorted set (or sorted map) with an explicit comparator <tt>c</tt>
 * is used with elements (or keys) drawn from a set <tt>S</tt>.  If the
 * ordering imposed by <tt>c</tt> on <tt>S</tt> is inconsistent with equals,
 * the sorted set (or sorted map) will behave "strangely."  In particular the
 * sorted set (or sorted map) will violate the general contract for set (or
 * map), which is defined in terms of <tt>equals</tt>.<p>
 *
 * For example, suppose one adds two elements {@code a} and {@code b} such that
 * {@code (a.equals(b) && c.compare(a, b) != 0)}
 * to an empty {@code TreeSet} with comparator {@code c}.
 * The second {@code add} operation will return
 * true (and the size of the tree set will increase) because {@code a} and
 * {@code b} are not equivalent from the tree set's perspective, even though
 * this is contrary to the specification of the
 * {@link Set#add Set.add} method.<p>
 *
 * Note: It is generally a good idea for comparators to also implement
 * <tt>java.io.Serializable</tt>, as they may be used as ordering methods in
 * serializable data structures (like {@link TreeSet}, {@link TreeMap}).  In
 * order for the data structure to serialize successfully, the comparator (if
 * provided) must implement <tt>Serializable</tt>.<p>
 *
 * For the mathematically inclined, the <i>relation</i> that defines the
 * <i>imposed ordering</i> that a given comparator <tt>c</tt> imposes on a
 * given set of objects <tt>S</tt> is:<pre>
 *       {(x, y) such that c.compare(x, y) &lt;= 0}.
 * 

Коэффициент для этого общего заказа:

 *       {(x, y) such that c.compare(x, y) == 0}.
 * 

* * It Из контракта на немедленно следует * сравнить , что * частное является отношением эквивалентности для S , и что * навязанный порядок представляет собой общий заказ на S . Когда мы говорим, что * порядок, наложенный c на S , соответствует * равен , мы имеем в виду, что частное для этого порядка эквивалентно * отношение, определенное методом (-ами) объектов {@link Object # equals (Object) * equals (Object)}:

 *     {(x, y) such that x.equals(y)}. 

* *

В отличие от {@code Comparable}, компаратор может по выбору разрешить * сравнение нуля аргументы, сохраняя при этом требования для * отношения эквивалентности. * *

Этот интерфейс является членом * * Java Collections Framework . * * @param тип объектов, которые могут сравниваться этим компаратором * * @author Jo sh Bloch * @author Neal Gafter * @see Comparable * @see java .io.Serializable * @since 1.2 * / @FunctionalInterface publi c интерфейс Comparator {/ ** * Сравнивает два аргумента для порядка. Возвращает отрицательное целое число, * ноль или положительное целое число, так как первый аргумент меньше, равен * или больше второго.

* * В вышеприведенном описании запись * sgn (* 1033) * выражение ) обозначает математическую функцию * signum , которая определена как возвращающая одну из -1 , * 0 или 1 в зависимости от того, является ли значение * выражение отрицательным, нулевым или положительным. * * Разработчик должен убедиться, что sgn (сравнить (x , y)) == * -sgn (сравнить (y, x)) для всех x и y . (Это * означает, что сравнить (х, у) должно выдать исключение, если и только * если сравнить (у, х) выдает исключение.) * * Разработчик Также необходимо убедиться, что отношение является транзитивным: * ((сравнить (x, y)> 0) && (сравнить (y, z)> 0)) подразумевает * сравнить (x, z) > 0 . * * Наконец, разработчик должен убедиться, что сравнение (x, y) == 0 * подразумевает, что sgn (сравнение (x, z)) == sgn (сравнить (y, z)) для всех * z . * * Это обычно так, но не строго требуется, чтобы * ( сравнить (x, y) == 0) == (x.equals (y)) . Вообще говоря, * любой компаратор, который нарушает это условие, должен четко указывать * на этот факт. Рекомендуемый язык: «Примечание: этот компаратор * устанавливает порядок, не совместимый с равным». * * @param o1 первый объект для сравнения. * @param o2 второй объект для сравнения. * @ возвращают отрицательное целое число, ноль или положительное целое число, поскольку * первый аргумент меньше, равен или больше * второго аргумента. * @throws NullPointerException, если аргумент является нулевым, и этот * компаратор не допускает нулевые аргументы * @throws ClassCastException, если типы аргументов препятствуют * их сравнению этим компаратором. * / int сравнить (T o1, T o2); / ** * Указывает, равен ли какой-либо другой объект этому * компаратору. Этот метод должен подчиняться общему контракту * {@link Object # equals (Object)}. Кроме того, этот метод может возвращать * true только , если указанный объект также является компаратором *, и он налагает тот же порядок, что и этот компаратор. Таким образом, * comp1.equals(comp2) означает, что sgn (comp1.compare (o1, * o2)) == sgn (comp2.compare (o1, o2)) для каждой ссылки на объект * o1 и o2 . * * Обратите внимание, что всегда безопасно не для переопределения * Object.equals (Object) . Однако переопределение этого метода может * в некоторых случаях повысить производительность, позволяя программам определять *, что два разных компаратора устанавливают один и тот же порядок. * * @param obj эталонный объект для сравнения. * @return true только если указанный объект также * является компаратором и на него накладывается тот же порядок, что и у этого * компаратора. * @see Object # equals (Object) * @see Object # hashCode () * / логическое equals (Object obj); / ** * Возвращает компаратор, который устанавливает обратный порядок этого * компаратора. * * @ возврат компаратора, который навязывает обратный порядок этого * компаратора. * @since 1.8 * / по умолчанию Comparator reversed () {return Collections.reverseOrder (this); } / ** * Возвращает лексикографический c -компаратор порядка с другим компаратором. * Если этот {@code Comparator} считает два элемента равными, т. Е. * {@Code compare (a, b) == 0}, {@code other} используется для определения порядка. * * Возвращенный компаратор сериализуем, если указанный компаратор * также сериализуем. * * @apiNote * Например, чтобы отсортировать коллекцию {@code String} на основе длины * и затем без учета регистра естественное упорядочение, компаратор может быть * составлен с использованием следующего кода * * {@code * Comparator<String> cmp = Comparator.comparingInt(String::length) * .thenComparing(String.CASE_INSENSITIVE_ORDER); * } * * @param другой - другой компаратор, который будет использоваться, когда этот компаратор * сравнивает два равных объекта. * @return a lexicographi c - компаратор заказа, составленный из этого, а затем * другого компаратора * @throws NullPointerException, если аргумент равен нулю. * @since 1.8 * / по умолчанию Comparator thenComparing (Comparator другое) {Objects.requireNonNull (другое); return (Comparator & Serializable) (c1, c2) -> {int res = сравнивать (c1, c2); вернуть (res! = 0)? res: other.compare (c1, c2); }; } / ** * Возвращает лексикографический c -приряд сравнения с функцией, * извлекающей ключ для сравнения с заданным {@code Comparator}. * * @ implSpe c Эта реализация по умолчанию ведет себя так, как будто {@code * thenComparing (сравнение (keyExtractor, cmp))}. * * @param тип ключа сортировки * @param keyExtractor функция, используемая для извлечения ключа сортировки * @param keyComparator {@code Comparator}, используемый для сравнения ключа сортировки * @return a lexicographi c - компаратор порядка, составленный из этого компаратора *, а затем сравнивающий ключ, извлеченный функцией keyExtractor * @throws NullPointerException, если любой из аргументов равен нулю. * @see #comparing (Функция, Компаратор) * @see #thenComparing (Компаратор) * @since 1.8 * / default Компаратор thenComparing (Функция keyExtractor, Компаратор keyComparator) {return thenComparing (сравнение (keyExtractor, keyComparator)); } / ** * Возвращает лексикографический c -компаратор порядка с функцией, которая * извлекает {@code Comparable} ключ сортировки. * * @ implSpe c Эта реализация по умолчанию ведет себя так, как будто {@code * thenComparing (сравнение (keyExtractor))}}. * * @param тип {@link * Comparable} ключа сортировки * @param keyExtractor - функция, используемая для извлечения {@link * Comparable} ключа сортировки * @return лексикографического c порядка сравнения, составленного из этого а затем ключ сортировки * {@link Comparable}. * @throws NullPointerException, если аргумент равен нулю. * @see #comparing (Функция) * @see #thenComparing (Компаратор) * @since 1.8 * / default > Компаратор thenComparing (Функция keyExtractor) {return thenComparing (сравнение (keyExtractor)); } / ** * Возвращает лексикографический c -порядок сравнения с функцией, которая * извлекает {@code int} ключ сортировки. * * @ implSpe c Эта реализация по умолчанию ведет себя так, как будто {@code * thenComparing (comparingInt (keyExtractor))}}. * * @param keyExtractor - функция, используемая для извлечения целочисленного ключа сортировки. * @return лексикографический c -компаратор порядка, составленный из этого, а затем ключ сортировки * {@code int} * @throws NullPointerException, если аргумент равен нулю. * @see #comparingInt (ToIntFunction) * @see #thenComparing (Comparator) * @since 1.8 * / компаратор по умолчанию thenComparingInt (ToIntFunction keyExtractor) {return thenComparing (comparingInt (keyExtractor)); } / ** * Возвращает лексикографический c -приряд сравнения с функцией, которая * извлекает {@code long} ключ сортировки. * * @ implSpe c Эта реализация по умолчанию ведет себя так, как будто {@code * thenComparing (comparingLong (keyExtractor))}}. * * @param keyExtractor - функция, используемая для извлечения длинного ключа сортировки. * @return a lexicographi c - компаратор порядка, составленный из этого, а затем ключ сортировки * {@code long} * @throws NullPointerException, если аргумент равен нулю. * @see #comparingLong (ToLongFunction) * @see #thenComparing (Comparator) * @since 1.8 * / компаратор по умолчанию thenComparingLong (ToLongFunction keyExtractor) {return thenComparing (comparingLong (keyExtractor)); } / ** * Возвращает лексикографический c -приряд сравнения с функцией, которая * извлекает {@code double} ключ сортировки. * * @ implSpe c Эта реализация по умолчанию ведет себя так, как будто {@code * thenComparing (comparingDouble (keyExtractor))}}. * * @param keyExtractor - функция, используемая для извлечения ключа двойной сортировки * @return a lexicographi c -компаратор порядка, составленный из этого, а затем ключ сортировки * {@code double} * @throws NullPointerException, если аргумент равен нулю. * @see #comparingDouble (ToDoubleFunction) * @see #thenComparing (Comparator) * @since 1.8 * / компаратор по умолчанию thenComparingDouble (ToDoubleFunction keyExtractor) {return thenComparing (comparingDouble (keyExtractor)); } / ** * Возвращает компаратор, который налагает обратное натуральное * упорядочение . * * Возвращенный компаратор является сериализуемым и выдает {@link * NullPointerException} при сравнении {@code null}. * * @param тип {@link Comparable} элемента для сравнения * @ возвращает компаратор, который налагает обратное естественное * упорядочение на {@code Comparable} объектах. * @see Comparable * @ since 1.8 * / publi c stati c > Компаратор reverseOrder () {return Collections.reverseOrder (); } / ** * Возвращает компаратор, который сравнивает {@link Comparable} объекты в естественном * порядке. * * Возвращенный компаратор является сериализуемым и выдает {@link * NullPointerException} при сравнении {@code null}. * * @param тип {@link Comparable} элемента для сравнения * @ возвращает компаратор, который налагает естественное упорядочение на {@code * Comparable} объекты. * @see Comparable * @since 1.8 * / @SuppressWarnings ("не проверено") publi c stati c > Comparator naturalOrder () {return (Comparator ) Comparators.NaturalOrderComparator.INSTANCE; } / ** * Возвращает дружественный к нулю компаратор, который считает, что {@code null} * меньше ненулевого. Когда оба {@code null}, они считаются * равными. Если оба значения не равны NULL, указанный {@code Comparator} используется * для определения порядка. Если указанный компаратор равен {@code null}, *, то возвращенный компаратор считает все ненулевые значения равными. * * Возвращенный компаратор сериализуем, если указанный компаратор * сериализуем. * * @param тип сравниваемых элементов * @param компаратор a {@code Comparator} для сравнения ненулевых значений * @return компаратор, который считает {@code null} меньше * не- null и сравнивает ненулевые объекты с предоставленным * {@code Comparator}. * @since 1.8 * / publi c stati c Comparator nullsFirst (Comparator компаратор) {вернуть новые Comparators.NullComparator <> (true, компаратор); } / ** * Возвращает дружественный к нулю компаратор, который считает {@code null} * большим, чем ненулевое. Когда оба {@code null}, они считаются * равными. Если оба значения не равны NULL, указанный {@code Comparator} используется * для определения порядка. Если указанный компаратор равен {@code null}, *, то возвращенный компаратор считает все ненулевые значения равными. * * Возвращенный компаратор сериализуем, если указанный компаратор * сериализуем. * * @param тип сравниваемых элементов * @param компаратор a {@code Comparator} для сравнения ненулевых значений * @turnurn компаратор, который считает {@code null} большим, чем * non- null и сравнивает ненулевые объекты с предоставленным * {@code Comparator}. * @since 1.8 * / publi c stati c Comparator nullsLast (Comparator компаратор) {вернуть новые Comparators.NullComparator <> (false, компаратор); } / ** * Принимает функцию, которая извлекает ключ сортировки из типа {@code T} и * возвращает {@code Comparator }, который сравнивает по этому ключу сортировки, используя * указанный {@link Comparator}. * * Возвращенный компаратор сериализуем, если указанная функция * и компаратор оба сериализуемы. * * @apiNote * Например, чтобы получить {@code Comparator}, который сравнивает {@code * Person} объектов по их фамилии, игнорируя различия регистра, * * {@code * Comparator<Person> cmp = Comparator.comparing( * Person::getLastName, * String.CASE_INSENSITIVE_ORDER); * } * * @param тип элемента для сравнивать * @param тип ключа сортировки * @param keyExtractor функция, используемая для извлечения ключа сортировки * @param keyComparator {@code Comparator}, используемый для сравнения ключа сортировки * @вернуть компаратор, который сравнивает по извлеченный ключ с использованием * указанного {@code Comparator} * @throws NullPointerException, если любой из аргументов равен нулю * @since 1.8 * / publi c stati c Компаратор сравнения (функция keyExtractor, Компаратор keyComparator) {Objects.requireNonNull (keyExtractor); Objects.requireNonNull (keyComparator); return (Comparator & Serializable) (c1, c2) -> keyComparator.compare (keyExtractor.apply (c1), keyExtractor.apply (c2)); } / ** * Принимает функцию, которая извлекает {@link java .lang.Comparable * Comparable} ключ сортировки из типа {@code T} и возвращает {@code * Comparator }, который сравнивается с помощью ключ такого рода. * * Возвращенный компаратор сериализуем, если указана функция * также сериализуем. * * @apiNote * Например, чтобы получить {@code Comparator}, который сравнивает {@code * Person} объекты по их фамилии, * * {@code * Comparator<Person> byLastName = Comparator.comparing(Person::getLastName); * } * * @param тип элемента для сравнения * @param тип {@code Comparable} ключа сортировки * @param keyExtractor функция, используемая для извлечения {@link * Comparable} ключа сортировки * @trevert компаратор, который сравнивает извлеченный ключ * @throws NullPointerException, если аргумент равен нулю * @ since 1.8 * / publi c stati c > Компаратор Сравнение (Функция keyExtractor) {Objects.requireNonNull (keyExtractor); return (Компаратор & Сериализуемый) (c1, c2) -> keyExtractor.apply (c1) .compareTo (keyExtractor.apply (c2)); } / ** * Принимает функцию, которая извлекает ключ сортировки {@code int} из типа * {@code T} и возвращает {@code Comparator }, который сравнивается этим ключом сортировки *. * * Возвращенный компаратор сериализуем, если указанная функция * также сериализуема. * * @param тип элемента для сравнения * @param keyExtractor функция, используемая для извлечения целочисленного ключа сортировки * @turnurn-компаратор, который сравнивает извлеченный ключ * @see #comparing (Function) * @throws NullPointerException если аргумент равен нулю * @since 1.8 * / publi c stati c Comparator comparingInt (ToIntFunction keyExtractor) {Objects.requireNonNull (keyExtractor); return (Comparator & Serializable) (c1, c2) -> Integer.compare (keyExtractor.applyAsInt (c1), keyExtractor.applyAsInt (c2)); } / ** * Принимает функцию, которая извлекает {@code long} ключ сортировки из типа * {@code T} и возвращает {@code Comparator }, который сравнивается этим * ключом сортировки. * * Возвращенный компаратор сериализуем, если указанная функция * также сериализуема. * * @param тип элемента для сравнения * @param keyExtractor функция, используемая для извлечения длинного ключа сортировки * @trevert компаратор, который сравнивает по извлеченному ключу * @see #comparing (Function) * @throws NullPointerException если аргумент равен нулю * @since 1.8 * / publi c stati c Comparator comparingLong (ToLongFunction keyExtractor) {Objects.requireNonNull (keyExtractor); return (Comparator & Serializable) (c1, c2) -> Long.compare (keyExtractor.applyAsLong (c1), keyExtractor.applyAsLong (c2)); } / ** * Принимает функцию, которая извлекает {@code double} ключ сортировки из типа * {@code T} и возвращает {@code Comparator }, который сравнивается этим * ключом сортировки. * * Возвращенный компаратор сериализуем, если указанная функция * также сериализуема. * * @param тип элемента для сравнения * @param keyExtractor функция, используемая для извлечения ключа двойной сортировки * @turnurn компаратор, который сравнивает по извлеченному ключу * @see #comparing (Function) * @throws NullPointerException если аргумент равен нулю * @since 1.8 * / publi c stati c Comparator comparingDouble (ToDoubleFunction keyExtractor) {Objects.requireNonNull (keyExtractor); return (Comparator & Serializable) (c1, c2) -> Double.compare (keyExtractor.applyAsDouble (c1), keyExtractor.applyAsDouble (c2)); }}