сортировать по: от высокого к низкому - PullRequest
Новая
       27

сортировать по: от высокого к низкому

0 голосов
/ 27 апреля 2020

Как это сделать Как сделать Когда я положу максимум на минимум или низко на максимум, он все устроит? 

String [][]Data={{"Eugine","8"},{"Ben","9"},{"John","19"},{"Jairus","5"},{"Sofia","13"}};

ВЫХОД сортировать по: сверху вниз Джон ", 19 София, 13 Бен", 9 Юджин , 8 Иаира, 5 сортировка по: от низкого до высокого Иаира, 5 Юджина, 8 Бен, 9 София, 13 Иоанна, 19 

//This is just my noob code// //please help//
 String [][] Data={{"Eugine","8"},{"Ben","9"},{"John","19"},{"Jairus","5"},{"Sofia","13"}};
            Arrays.sort(people);
            for(Person p : people)
                System.out.println(p.name + ", " + p.age);
        }
    }

    class Person implements Comparable<Person>{
        public final String name;
        public final int age;[enter image description here][1]
        public Person(String name, int age){
            this.name = name;
            this.age = age;
        }
        @Override
        public int compareTo(Person person) {
            return age - person.age;
        }

Ответы [ 2 ]

2 голосов
/ 27 апреля 2020

Поскольку вы пытаетесь сортировать по-разному, вам нужно использовать Comparator .

Некоторые из способов, которыми вы можете сделать это, следующие:

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

import java.util.Arrays;
import java.util.Comparator;

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return name + " age " + age;
    }
}

class LowToHighComparator implements Comparator<Person> {

    @Override
    public int compare(Person p1, Person p2) {
        return Integer.compare(p1.getAge(), p2.getAge());
    }
}

class HighToLowComparator implements Comparator<Person> {

    @Override
    public int compare(Person p1, Person p2) {
        return Integer.compare(p2.getAge(), p1.getAge());
    }
}

public class Main {
    public static void main(String[] args) {
        Person[] people = { new Person("Eugine", 8), new Person("Ben", 9), new Person("John", 19),
                new Person("Jairus", 5), new Person("Sofia", 13) };

        Person[] lowToHigh = people.clone();
        Person[] highToLow = people.clone();

        Arrays.sort(lowToHigh, new LowToHighComparator());
        Arrays.sort(highToLow, new HighToLowComparator());

        System.out.println("Unsorted: ");
        Arrays.stream(people).forEach(System.out::println);
        System.out.println();

        System.out.println("Low to high: ");
        Arrays.stream(lowToHigh).forEach(System.out::println);
        System.out.println();

        System.out.println("High to low: ");
        Arrays.stream(highToLow).forEach(System.out::println);
    }
}

Вывод: 

Unsorted: 
Eugine age 8
Ben age 9
John age 19
Jairus age 5
Sofia age 13

Low to high: 
Jairus age 5
Eugine age 8
Ben age 9
Sofia age 13
John age 19

High to low: 
John age 19
Sofia age 13
Ben age 9
Eugine age 8
Jairus age 5

[Используя Comparator.comparing ] 

import java.util.Arrays;
import java.util.Comparator;

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return name + " age " + age;
    }
}

public class Main {
    public static void main(String[] args) {
        Person[] people = { new Person("Eugine", 8), new Person("Ben", 9), new Person("John", 19),
                new Person("Jairus", 5), new Person("Sofia", 13) };

        Person[] lowToHigh = people.clone();
        Person[] highToLow = people.clone();

        Arrays.sort(lowToHigh, Comparator.comparing(Person::getAge));
        Arrays.sort(highToLow, Comparator.comparing(Person::getAge).reversed());

        System.out.println("Unsorted: ");
        Arrays.stream(people).forEach(System.out::println);
        System.out.println();

        System.out.println("Low to high: ");
        Arrays.stream(lowToHigh).forEach(System.out::println);
        System.out.println();

        System.out.println("High to low: ");
        Arrays.stream(highToLow).forEach(System.out::println);
    }
}

Вывод: 

Unsorted: 
Eugine age 8
Ben age 9
John age 19
Jairus age 5
Sofia age 13

Low to high: 
Jairus age 5
Eugine age 8
Ben age 9
Sofia age 13
John age 19

High to low: 
John age 19
Sofia age 13
Ben age 9
Eugine age 8
Jairus age 5
1 голос
/ 27 апреля 2020

Я не мог по-настоящему понять, как вы хотели, чтобы ваш код работал, но если у вас возникают проблемы с простой сортировкой этих значений, тогда, я думаю, вы меня охватили. Вместо хранения в массиве String используйте TreeMaps.

Я сохранил числа в виде ключей и их соответствующие имена в качестве значений и сохранил их в TreeMap, который хранит их в отсортированном порядке (от низкого до высокого). Вы также можете отобразить их в обратном порядке, используя Collections.reverseOrder (). 

import java.util.*;

class Main {
  public static void main(String[] args) {

    TreeMap<Integer, String> map = new TreeMap<>();

    map.put(8, "Eugene");
    map.put(9, "Ben");
    map.put(19, "John");
    map.put(5, "Jairus");
    map.put(13, "Sofia");

    System.out.println("From low to high");

    for(Integer i : map.keySet()){
      System.out.println(map.get(i) + ", " + i);
    }

    TreeMap<Integer, String> revMap = 
      new TreeMap<Integer, String>(Collections.reverseOrder());

    revMap.putAll(map);

    System.out.println("\nFrom high to low");
    for(Integer i : revMap.keySet()){
      System.out.println(revMap.get(i) + ", " + i);
    }
  }
}
...