Сортировка hashset с заданным пользователем объектом [duplicate]

Вы также можете проверить, что файл $result не работает так, перед выполнением массива выборки

$username = $_POST['username'];
$password = $_POST['password'];
$result = mysql_query('SELECT * FROM Users WHERE UserName LIKE $username');
if(!$result)
{
     echo "error executing query: "+mysql_error(); 
}else{
       while($row = mysql_fetch_array($result))
       {
         echo $row['FirstName'];
       }
}
965
задан james.garriss 27 January 2016 в 18:18
поделиться

24 ответа

Поскольку Date реализует Comparable , он имеет метод compareTo, как String.

Итак, ваш пользовательский Comparator может выглядеть так:

public class CustomComparator implements Comparator<MyObject> {
    @Override
    public int compare(MyObject o1, MyObject o2) {
        return o1.getStartDate().compareTo(o2.getStartDate());
    }
}

Метод compare() должен возвращать int, поэтому вы не можете напрямую вернуть boolean, как вы планировали в любом случае.

Ваш код сортировки будет примерно таким, как вы написали:

Collections.sort(Database.arrayList, new CustomComparator());

Немного более короткий способ написать все это, если вам не нужно повторно использовать ваш компаратор должен записать его как встроенный анонимный класс:

Collections.sort(Database.arrayList, new Comparator<MyObject>() {
    @Override
    public int compare(MyObject o1, MyObject o2) {
        return o1.getStartDate().compareTo(o2.getStartDate());
    }
});

Поскольку

Теперь вы можете написать последнее пример в более короткой форме с использованием лямбда-выражения для Comparator:

Collections.sort(Database.arrayList, 
                        (o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

И List имеет метод sort(Comparator) , поэтому вы можете сократить это еще больше:

Database.arrayList.sort((o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

Это такая распространенная идиома, что встроен метод для генерации Comparator для класса с Comparable:

Database.arrayList.sort(Comparator.comparing(MyObject::getStartDate));

Все это эквивалентные формы.

1316
ответ дан Michael Myers 27 August 2018 в 07:38
поделиться

Да, вы можете. Существует два варианта сравнения элементов: интерфейс Comparable и интерфейс Comparator .

Оба этих интерфейса допускают различное поведение. Comparable позволяет вам заставить объект действовать так, как вы только что описали Strings (на самом деле String реализует Comparable). Второй, Компаратор, позволяет делать то, что вы просите. Вы бы сделали это следующим образом:

Collections.sort(myArrayList, new MyComparator());

Это приведет к тому, что метод Collections.sort будет использовать ваш компаратор для его механизма сортировки. Если объекты в ArrayList реализуются сопоставимыми, вы можете сделать что-то вроде этого:

Collections.sort(myArrayList);

Класс Collections содержит ряд этих полезных общих инструментов.

40
ответ дан aperkins 27 August 2018 в 07:38
поделиться

Для Java 8:

Collections.sort(list, comparing(ClassName::getName));

или

Collections.sort(list, comparing(ClassName::getName).reversed());

Кажется, что работает со строковым типом даты, также как «2015-12-14T21: 55: 51Z»

Другим способом является

Collections.sort(list, comparing(ClassName::getName, Comparator.nullsLast(Comparator.naturalOrder())));
3
ответ дан Arun 27 August 2018 в 07:38
поделиться

С помощью Java 8 вы можете использовать ссылку на метод для вашего компаратора:

import static java.util.Comparator.comparing;

Collections.sort(list, comparing(MyObject::getStartDate));
26
ответ дан assylias 27 August 2018 в 07:38
поделиться

Лучший способ с JAVA 8 для английского алфавитного сорта

Внедрение класса

public class NewspaperClass implements Comparable<NewspaperClass>{
   public String name;

   @Override
   public int compareTo(NewspaperClass another) {
      return name.compareTo(another.name);
   }
}

Сортировка

  Collections.sort(Your List);

Если вы хотите сортировать алфавит, который содержит неанглийские символы, которые вы можете использовать в Locale ... Ниже кода используется турецкая сортировка символов ...

Внедрение класса

public class NewspaperClass implements Comparator<NewspaperClass> {
   public String name;
   public Boolean isUserNewspaper=false;
   private Collator trCollator = Collator.getInstance(new Locale("tr_TR"));



   @Override
   public int compare(NewspaperClass lhs, NewspaperClass rhs) {
      trCollator.setStrength(Collator.PRIMARY);
      return trCollator.compare(lhs.name,rhs.name);
   }
}

Сортировка

Collections.sort(your array list,new NewspaperClass());
7
ответ дан Beyaz 27 August 2018 в 07:38
поделиться

Классы, которые имеют естественный порядок сортировки (например, номер класса), должны реализовать интерфейс Comparable, в то время как классы, которые не имеют естественного порядка сортировки (например, класс-класс), должны быть снабжены компаратором (или анонимный класс компаратора).

Два примера:

public class Number implements Comparable<Number> {
    private int value;

    public Number(int value) { this.value = value; }
    public int compareTo(Number anotherInstance) {
        return this.value - anotherInstance.value;
    }
}

public class Chair {
    private int weight;
    private int height;

    public Chair(int weight, int height) {
        this.weight = weight;
        this.height = height;
    }
    /* Omitting getters and setters */
}
class ChairWeightComparator implements Comparator<Chair> {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getWeight() - chair2.getWeight();
    }
}
class ChairHeightComparator implements Comparator<Chair> {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getHeight() - chair2.getHeight();
    }
}

Использование:

List<Number> numbers = new ArrayList<Number>();
...
Collections.sort(numbers);

List<Chair> chairs = new ArrayList<Chair>();
// Sort by weight:
Collections.sort(chairs, new ChairWeightComparator());
// Sort by height:
Collections.sort(chairs, new ChairHeightComparator());

// You can also create anonymous comparators;
// Sort by color:
Collections.sort(chairs, new Comparator<Chair>() {
    public int compare(Chair chair1, Chair chair2) {
        ...
    }
});
183
ответ дан Björn 27 August 2018 в 07:38
поделиться

Для сортировки ArrayList вы можете использовать следующий фрагмент кода:

Collections.sort(studList, new Comparator<Student>(){
    public int compare(Student s1, Student s2) {
        return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
    }
});
150
ответ дан blackpanther 27 August 2018 в 07:38
поделиться

Вы можете использовать Компаратор бит для сортировки по любому свойству в вашем пользовательском классе.

5
ответ дан camickr 27 August 2018 в 07:38
поделиться
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;

public class test {

public static class Person {
    public String name;
    public int id;
    public Date hireDate;

    public Person(String iname, int iid, Date ihireDate) {
        name = iname;
        id = iid;
        hireDate = ihireDate;
    }

    public String toString() {
        return name + " " + id + " " + hireDate.toString();
    }

    // Comparator
    public static class CompId implements Comparator<Person> {
        @Override
        public int compare(Person arg0, Person arg1) {
            return arg0.id - arg1.id;
        }
    }

    public static class CompDate implements Comparator<Person> {
        private int mod = 1;
        public CompDate(boolean desc) {
            if (desc) mod =-1;
        }
        @Override
        public int compare(Person arg0, Person arg1) {
            return mod*arg0.hireDate.compareTo(arg1.hireDate);
        }
    }
}

public static void main(String[] args) {
    // TODO Auto-generated method stub
    SimpleDateFormat df = new SimpleDateFormat("mm-dd-yyyy");
    ArrayList<Person> people;
    people = new ArrayList<Person>();
    try {
        people.add(new Person("Joe", 92422, df.parse("12-12-2010")));
        people.add(new Person("Joef", 24122, df.parse("1-12-2010")));
        people.add(new Person("Joee", 24922, df.parse("12-2-2010")));
    } catch (ParseException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    Collections.sort(people, new Person.CompId());
    System.out.println("BY ID");
    for (Person p : people) {
        System.out.println(p.toString());
    }

    Collections.sort(people, new Person.CompDate(false));
    System.out.println("BY Date asc");
    for (Person p : people) {
        System.out.println(p.toString());
    }
    Collections.sort(people, new Person.CompDate(true));
    System.out.println("BY Date desc");
    for (Person p : people) {
        System.out.println(p.toString());
    }

}

}
13
ответ дан CharlesW 27 August 2018 в 07:38
поделиться

Да, это возможно, например, в этом ответе Я сортирую по свойству v класса IndexValue

    // Sorting by property v using a custom comparator.
    Arrays.sort( array, new Comparator<IndexValue>(){
        public int compare( IndexValue a, IndexValue b ){
            return a.v - b.v;
        }
    });

Если вы заметили, что я создавая анонимный внутренний класс (который является Java для замыканий) и передавая его непосредственно методу sort класса Arrays

. Ваш объект может также реализовывать Comparable (вот что такое String и большинство основных библиотек в Java), но это будет определять «естественный порядок сортировки» класса, который он сам, и не позволяет вам подключать новые.

4
ответ дан Community 27 August 2018 в 07:38
поделиться

Я предпочитаю этот процесс:

public class SortUtil
{    
    public static <T> List<T> sort(List<T> list, String sortByProperty)
    {
            Collections.sort(list, new BeanComparator(sortByProperty));
            return list;
    }
}

List<T> sortedList = SortUtil<T>.sort(unsortedList, "startDate");

Если список объектов имеет свойство, называемое startDate, вы вызываете его снова и снова. Вы можете даже связать их startDate.time.

Это требует, чтобы ваш объект был Comparable, что означает, что вам нужна реализация compareTo, equals и hashCode.

Да, это может быть быстрее ... Но теперь вам не нужно создавать новый компаратор для каждого типа сортировки. Если вы можете сэкономить время dev и отказаться от времени выполнения, вы можете пойти с этим.

1
ответ дан DDus 27 August 2018 в 07:38
поделиться

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

Вы можете попробовать решить эти задачи с помощью LambdaJ. Вы можете найти его здесь: http://code.google.com/p/lambdaj/

Здесь у вас есть пример:

Сортировка итерации

List<Person> sortedByAgePersons = new ArrayList<Person>(persons);
Collections.sort(sortedByAgePersons, new Comparator<Person>() {
        public int compare(Person p1, Person p2) {
           return Integer.valueOf(p1.getAge()).compareTo(p2.getAge());
        }
});

Сортировка с лямбда

List<Person> sortedByAgePersons = sort(persons, on(Person.class).getAge()); 

Конечно, наличие такой красоты влияет на производительность (в среднем 2 раза), но вы можете найти более читаемый код ?

13
ответ дан Federico Piazza 27 August 2018 в 07:38
поделиться

Вы можете взглянуть на эту презентацию на Java Forum в Штутгарте Германия в 2016 году.

Только несколько слайдов используют немецкий язык, 99% содержимого «Исходный код Java на английском языке»; например

someCollection.sort(
  OurCustomComparator
    .comparing(Person::getName)
    .thenComparing(Person::getId)
);

, где OurCustomComparator использует методы по умолчанию (и другие интересные идеи). Как показано, приводя к очень сжатому коду, чтобы выбрать некоторый метод getter для сортировки; и супер простое соединение (или реверсирование) критериев сортировки.

Если вы находитесь в java8, вы найдете много материала, чтобы вы начали.

3
ответ дан GhostCat 27 August 2018 в 07:38
поделиться

Я нашел больше всего, если не все эти ответы полагаются на базовый класс (Object), чтобы реализовать сопоставимые или иметь вспомогательный сопоставимый интерфейс.

Не с моим решением! Следующий код позволяет сравнить поле объекта, зная его имя строки. Вы можете легко изменить его, чтобы не использовать имя, но тогда вам нужно его выставить или создать один из объектов, которые вы хотите сравнить.

Collections.sort(anArrayListOfSomeObjectPerhapsUsersOrSomething, new ReflectiveComparator(). new ListComparator("name"));

public class ReflectiveComparator {
    public class FieldComparator implements Comparator<Object> {
        private String fieldName;

        public FieldComparator(String fieldName){
            this.fieldName = fieldName;
        }

        @SuppressWarnings({ "unchecked", "rawtypes" })
        @Override
        public int compare(Object object1, Object object2) {
            try {
                Field field = object1.getClass().getDeclaredField(fieldName);
                field.setAccessible(true);

                Comparable object1FieldValue = (Comparable) field.get(object1);
                Comparable object2FieldValue = (Comparable) field.get(object2);

                return object1FieldValue.compareTo(object2FieldValue);
            }catch (Exception e){}

            return 0;
        }
    }

    public class ListComparator implements Comparator<Object> {
        private String fieldName;

        public ListComparator(String fieldName) {
            this.fieldName = fieldName;
        }

        @SuppressWarnings({ "unchecked", "rawtypes" })
        @Override
        public int compare(Object object1, Object object2) {
            try {
                Field field = object1.getClass().getDeclaredField(fieldName);
                field.setAccessible(true);
                Comparable o1FieldValue = (Comparable) field.get(object1);
                Comparable o2FieldValue = (Comparable) field.get(object2);

                if (o1FieldValue == null){ return -1;}
                if (o2FieldValue == null){ return 1;}
                return o1FieldValue.compareTo(o2FieldValue);
            } catch (NoSuchFieldException e) {
                throw new IllegalStateException("Field doesn't exist", e);
            } catch (IllegalAccessException e) {
                throw new IllegalStateException("Field inaccessible", e);
            }
        }
    }
}
3
ответ дан Kevin Parker 27 August 2018 в 07:38
поделиться

Эти фрагменты кода могут быть полезны. Если вы хотите отсортировать объект в моем случае, я хочу сортировать по VolumeName:

public List<Volume> getSortedVolumes() throws SystemException {
    List<Volume> volumes = VolumeLocalServiceUtil.getAllVolumes();
    Collections.sort(volumes, new Comparator<Volume>() {
        public int compare(Volume o1, Volume o2) {
            Volume p1 = (Volume) o1;
            Volume p2 = (Volume) o2;
            return p1.getVolumeName().compareToIgnoreCase(
                    p2.getVolumeName());
        }
    });
    return volumes;
}

Это работает. Я использую его в jsp.

3
ответ дан Laura Liparulo 27 August 2018 в 07:38
поделиться

Из Java 8 и далее нам не нужно напрямую использовать Collections.sort(). Интерфейс List имеет метод по умолчанию sort():

List<User> users = Arrays.asList(user1,user2,user3);
users.sort( (u1, u2) -> { 
return u1.getFirstName.compareTo(u2.getFirstName());}); 

См. http://visvv.blogspot.in/2016/01/sorting-objects-in-java-8. HTML .

5
ответ дан Neil Masson 27 August 2018 в 07:38
поделиться

Новый, поскольку 1.8 - это метод List.sort () вместо использования Collection.sort (), поэтому вы вызываете mylistcontainer.sort ()

. Вот фрагмент кода, который демонстрирует List.sort ():

List<Fruit> fruits = new ArrayList<Fruit>();
fruits.add(new Fruit("Kiwi","green",40));
fruits.add(new Fruit("Banana","yellow",100));
fruits.add(new Fruit("Apple","mixed green,red",120));
fruits.add(new Fruit("Cherry","red",10));

// a) using an existing compareto() method
fruits.sort((Fruit f1,Fruit f2) -> f1.getFruitName().compareTo(f2.getFruitName()));
System.out.println("Using String.compareTo(): " + fruits);
//Using String.compareTo(): [Apple is: mixed green,red, Banana is: yellow, Cherry is: red, Kiwi is: green]

// b) Using a comparable class
fruits.sort((Fruit f1,Fruit f2) -> f1.compareTo(f2));  
System.out.println("Using a Comparable Fruit class (sort by color): " + fruits);
// Using a Comparable Fruit class (sort by color): [Kiwi is green, Apple is: mixed green,red, Cherry is: red, Banana is: yellow]

Класс Fruit:

public class Fruit implements Comparable<Fruit>
{
private String name;
private String color;
private int quantity;

public Fruit(String name,String color,int quantity)
{ this.name = name; this.color = color; this.quantity = quantity;}

public String getFruitName() { return name; }        
public String getColor() { return color; }  
public int getQuantity() { return quantity; }

@Override public final int compareTo(Fruit f) // sorting the color
{
    return this.color.compareTo(f.color);
}     
@Override public String toString()
{   return (name + " is: " + color);
}

} // конец класса Fruit

1
ответ дан Norbert 27 August 2018 в 07:38
поделиться

Java 8 Lambda сокращает сортировку.

Collections.sort(stdList, (o1, o2) -> o1.getName().compareTo(o2.getName()));
4
ответ дан Pshemo 27 August 2018 в 07:38
поделиться

Использование Java 8 может определить Comparator в одной строке, используя Comparator.comparing()

Используйте любой из следующих способов:

Вариант 1:

listToBeSorted.sort(Comparator.comparing(CustomObject::getStartDate));

Вариант 2:

Collections.sort(listToBeSorted, Comparator.comparing(CustomObject::getStartDate));
0
ответ дан Sahil Chhabra 27 August 2018 в 07:38
поделиться

Вы можете сортировать с помощью java 8

yourList.sort(Comparator.comparing(Classname::getName));

or

yourList.stream().forEach(a -> a.getBObjects().sort(Comparator.comparing(Classname::getValue)));
3
ответ дан Seeker 27 August 2018 в 07:38
поделиться

С помощью этой библиотеки здесь вы можете отсортировать список настраиваемых объектов в нескольких столбцах. Библиотека использует возможности версии 8.0. Образец также доступен там. Вот пример, чтобы сделать

SortKeys sortKeys = new SortKeys();
sortKeys.addField("firstName")
            .addField("age", true); // This (true) will sort the age descending

// Other ways to specify a property to the sorter are
//      .addField("lastName", String.class);
//      .addField("dob", Date.class, true);

// Instantiate a ListSorter
ListSorter listSorter = new ListSorter();

// Pass the data to sort (listToSort) and the "by keys" to sort (sortKeys)
List sortedList = (List<Person>) listSorter.sortList(listToSort, sortKeys);
2
ответ дан Shriram M. 27 August 2018 в 07:38
поделиться

JABA 8 лямбда-выражение

Collections.sort(studList, (Student s1, Student s2) ->{
        return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
});

ИЛИ

Comparator<Student> c = (s1, s2) -> s1.firstName.compareTo(s2.firstName);
studList.sort(c)
32
ответ дан Sorter 27 August 2018 в 07:38
поделиться

ваш класс customComparator должен реализовать java.util.Comparator для использования. он также должен переопределять compare () AND equals ()

compare () должен ответить на вопрос: Является ли объект 1 меньше, равным или большим, чем объект 2?

full docs: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Comparator.html

2
ответ дан Vinny 27 August 2018 в 07:38
поделиться

Вы можете попробовать Guava Заказ :

Function<Item, Date> getStartDate = new Function<Item, Date>() {
    public Date apply(Item item) {
        return item.getStartDate();
    }
};

List<Item> orderedItems = Ordering.natural().onResultOf(getStartDate).
                          sortedCopy(items);
5
ответ дан Vitalii Fedorenko 27 August 2018 в 07:38
поделиться
Другие вопросы по тегам:

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