Как сортировать ArrayList со строкой в ​​порядке убывания

Question

Я получаю json данных, как это:

[ 
    { 
    "name": "A", 
    "count": "2" 
    }, 
    { 
    "name": "B", 
    "count": "1" 
    }, 
    { 
    "name": "A", 
    "count": "3" 
    }, 
    { 
    "name": "C", 
    "count": "10" 
    }, 
    { 
    "name": "B", 
    "count": "2" 
    } 
] 

Так я итерация данных, используя for петли, нормальные вещи. Но я хотел бы, чтобы в конечном итоге с arraylist, как это:

C -> 7

А -> 5

B -> 3

Обратите внимание, что list является с наивысшего до самого низкого. Что я пытался до сих пор:

//create my arraylists 
    //has both name and count 
    ArrayList<String>namesWithCountList = new ArrayList<>(); 
    //has only names 
    ArrayList<String>namesList = new ArrayList<>(); 

    //get json array.. 
    //iterate using for loop 
    for (int i = 0; i < myJsonArray.length(); i++) { 
     String nameStr = jsonObj.getString("name"); 
     int count = jsonObj.getInt("count"); 

     index = namesList.indexOf(name);//get index of the name 

     if (index < 0) { 
     // name doesnt exist in namesList, so we add it 
     namesList.add(nameStr); 
     namesWithCountList.add(nameStr+"-->"+count); 
     }else{ 
     //name exists so we only add the count to existing list 
     } 

    } 

Я знаю, что я должен использовать Comparator.sort(), но я не знаю, как получить мой list там, потому что я перепутала как имя и сосчитать вместе, как: C-->7

I были подчеркнуты, как должна выглядеть логика, любая помощь в этом?

Answer 1

Позволяет создать класс Entity держать ваши name и count отображения

import java.util.Comparator; 

public class Entity implements Comparable { 
private String name; 
private int count; 

public String getName() { 
    return name; 
} 

public void setName(String name) { 
    this.name = name; 
} 

public int getCount() { 
    return count; 
} 

public void setCount(int count) { 
    this.count = count; 
} 

@Override 
public int hashCode() { 
    final int prime = 31; 
    int result = 1; 
    result = prime * result + count; 
    result = prime * result + ((name == null) ? 0 : name.hashCode()); 
    return result; 
} 

@Override 
public boolean equals(Object obj) { 
    if (this == obj) 
     return true; 
    if (obj == null) 
     return false; 
    if (getClass() != obj.getClass()) 
     return false; 
    Entity other = (Entity) obj; 
    if (count != other.count) 
     return false; 
    if (name == null) { 
     if (other.name != null) 
      return false; 
    } else if (!name.equals(other.name)) 
     return false; 
    return true; 
} 

public static Comparator<Entity> ArraylistComparator = new Comparator<Entity>() { 

    public int compare(Entity e1, Entity e2) { 
     int count1 = e1.getCount(); 
     int count2 = e2.getCount(); 

     // ascending order 
     return e1.compareTo(e2); 

    } 
}; 

@Override 
public int compareTo(Object o) { 
    int compareCount = ((Entity) o).getCount(); 
    /* For Ascending order */ 
    return this.count - compareCount; 

    /* For Descending order do like this */ 
    // return compareCount - this.count; 
} 

@Override 
public String toString() { 
    return "Entity [name=" + name + ", count=" + count + "]"; 
} 

} 

Затем позволяет создать метод в отдельный класс для заполнения arrayList и вызовите comparator

import java.util.ArrayList; 
import java.util.Collections; 

public class ArraySort { 

public static void main(String[] args) { 
    ArrayList<Entity> arrayList = new ArrayList<Entity>(); 

    Entity entity1 = new Entity(); 
    entity1.setCount(2); 
    entity1.setName("D"); 

    Entity entity2 = new Entity(); 
    entity2.setCount(10); 
    entity2.setName("A"); 

    Entity entity3 = new Entity(); 
    entity3.setCount(5); 
    entity3.setName("C"); 

    arrayList.add(entity1); 
    arrayList.add(entity2); 
    arrayList.add(entity3); 

    System.out.println("Entity Count Sorting:"); 
    Collections.sort(arrayList, Entity.ArraylistComparator); 

    for (Entity ent : arrayList) { 
     System.out.println(ent); 
    } 
} 

} 

Выход:

Сущность [name = D, count = 2]

Entity [имя = C, считайте = 5]

Entity [имя = A, считайте = 10]

Надеется, что это помогает!

Answer 2

Вы ошибаетесь в своей «умственной» модели.

Если ваши объекты имеют имя и подсчет, то просто не толкать их в строки, как

"name-->count" 

Вместо: создать свой собственный пользовательский класс, который содержит эти свойства. И тогда вы можете создать (как-то) более простой компаратор для , который класс. Это также упрощает процесс записи данных JSON, если вы намереваетесь сделать это в какой-то момент.

Если вы настаиваете на продолжении своего сломанного подхода, вам нужно создать компаратор, который знает, как сортировать такие строки. Другими словами: ваш компаратор должен разбить такие строки «n -> c»; и вывести из него имя и подсчитать; чтобы затем выполнить свою работу. Но, как сказано; вам лучше отказаться от этой идеи.

Как серьезно: это супер плохой практика. Java - это строго типизированный язык; и код несколько значений в один плоская строка полностью отказаться от «помощи», которую предоставляет вам система типа Java.

Answer 3

Если вы хотите суммировать все «A», все «B» и т. Д., То следующий код может помочь. Он использует Java 8 и Ломбок библиотеку (для генерации кода шаблонный):

@NoArgsConstructor 
@AllArgsConstructor 
@Data 
class Entity { 
    private String name; 
    private int count; 
} 

public class Main { 

    public static void main(String[] args) { 
     List<Entity> list = Arrays.asList(
       new Entity("A", 2), 
       new Entity("B", 1), 
       new Entity("A", 3), 
       new Entity("C", 10), 
       new Entity("B", 2)); 

     Map<String, Integer> grouped = 
       list.stream().collect(Collectors.groupingBy(Entity::getName, Collectors.summingInt(Entity::getCount))); 
     System.out.println(grouped); 
    } 
} 

Результат:

{A=5, B=3, C=10}