Comment faire un tri itératif dans une liste de chaînes?

Question

J'ai un ArrayList avec des éléments de chaîne ci-dessous ->

['STM-1000-H', 'STM-2000-E', 'STM-4000-H', 'STM-200-H', 'SFP-1000-A', 
'SFP-300-H', 'SAFPX-1000-H', 'SAFPX-2000-A', 'STM-1000-H-L1', 'STM-1000-H-L1+VA+GH', 'STM-1000-H-L2'] 

Je veux un arraylist avec le regroupement comme ...

affichage STM- 400, 500, 600, 100, 2000, 4000 (in that order), followed by SPX- 1000, 2000, 4000 (dans cet ordre, puis suivi par le 1000. SAFPX- également , je dois énumérer chacun par le L, L1, L2, M, M1, M2, M3, H, H! and VH (dans cet ordre).

Pouvez-vous s'il vous plaît aider à cela, la liste est Array éléments de chaîne seulement.

Answer 1

vous devez crea te un comparateur personnalisé et ensuite l'utiliser pour trier l'arraylist.

Par exemple (ceci fait une partie du tri que vous avez demandé mais n'est pas vérifié pour les cas-bords, c'est à vous de corriger). Remarque: Java 8 est utilisé

public static void main(String[] args) { 
    ArrayList<String> list = new ArrayList<>(); 
    list.add("STM-1000-H"); 
    list.add("STM-2000-E"); 
    list.add("SAFPX-1000-H-L2"); 
    list.add("SAFPX-1000-H-L1"); 
    list.add("STM-1000-H-L1"); 
    list.add("SFP-1000-B"); 
    list.add("SFP-1000-A"); 

    HashMap hm = new HashMap(); 
    hm.put("STM", 1); 
    hm.put("SFP", 2); 
    hm.put("SAFPX", 3); 

    list = sort(list, hm); 

    for (String s : list) { 
     System.out.println(s); 
    } 
} 

public static ArrayList<String> sort(ArrayList<String> list, HashMap<String, Integer> hashmap) { 
    Comparator<String> comparator = (string1, string2) -> 
    { 
     String[] tokens1 = string1.split("-"); 
     String[] tokens2 = string2.split("-"); 

     if (hashmap.get(tokens1[0]) > hashmap.get(tokens2[0])) 
      return 1; 
     else if (hashmap.get(tokens1[0]) < hashmap.get(tokens2[0])) 
      return -1; 

     if (Integer.parseInt(tokens1[1]) > Integer.parseInt(tokens2[1])) 
      return 1; 
     else if (Integer.parseInt(tokens1[1]) < Integer.parseInt(tokens2[1])) 
      return -1; 

     if (tokens1.length > 2 && tokens2.length > 2) { 
      int res = tokens1[2].compareTo(tokens2[2]); 
      if(res != 0) 
      return res; 
     } 

     if (tokens1.length > 3 && tokens2.length > 3) { 
      int res = tokens1[3].compareTo(tokens2[3]); 
      if(res != 0) 
       return res; 
     } 

     return 0; 
    }; 

    Collections.sort(list, comparator); 
    return list; 
} 

Sorties:

STM-1000-H

STM-1000-H-L1

STM-2000-E

SFP- 1000-A

SFP-1000-B

SAFPX-1000-H-L1

SAFPX-1000-H-L2

Answer 2

Stream.of("STM-1000-H", 
      "STM-2000-E", 
      "STM-4000-H", 
      "STM-200-H", 
      "SFP-1000-A", 
      "SFP-300-H", 
      "SAFPX-1000-H", 
      "SAFPX-2000-A", 
      "STM-1000-H-L1", 
      "STM-1000-H-L1+VA+GH", 
      "STM-1000-H-L2") 
      .collect(Collectors.groupingBy(s -> s.substring(0, s.indexOf('-')))) 
      .entrySet() 
      .stream() 
      .sorted((e1, e2) -> -e1.getKey().compareTo(e2.getKey())) 
      .forEach(e -> { 
       System.out.println(e.getKey() + ":"); 
       e.getValue().stream().sorted().forEach(System.out::println); 
      }); 

-

STM: 
STM-1000-H 
STM-1000-H-L1 
STM-1000-H-L1+VA+GH 
STM-1000-H-L2 
STM-200-H 
STM-2000-E 
STM-4000-H 
SFP: 
SFP-1000-A 
SFP-300-H 
SAFPX: 
SAFPX-1000-H 
SAFPX-2000-A 

Answer 3

package com.skadakov.examples.devrev; 

import java.util.ArrayList; 
import java.util.Comparator; 
import java.util.List; 
import java.util.Map; 
import java.util.Objects; 
import java.util.TreeMap; 

/** 
* 
* @author s.kadakov 
*/ 
public class DevRev { 

    private final String series; 
    private final int model; 
    private final String version; 
    private final String revision; 

    public DevRev(String firmware) { 
     String[] ss = firmware.split("-"); 
     if (ss.length < 3) { 
      throw new IllegalArgumentException(firmware); 
     } 

     this.series = ss[0]; 
     this.model = Integer.parseInt(ss[1]); 
     this.version = ss[2]; 
     this.revision = ss.length == 3 ? null : ss[3]; 
    } 

    public String getSeries() { 
     return series; 
    } 

    public int getModel() { 
     return model; 
    } 

    public String getVersion() { 
     return version; 
    } 

    public String getRevision() { 
     return revision; 
    } 

    @Override 
    public int hashCode() { 
     int hash = 7; 
     hash = 97 * hash + Objects.hashCode(this.series); 
     hash = 97 * hash + this.model; 
     hash = 97 * hash + Objects.hashCode(this.version); 
     hash = 97 * hash + Objects.hashCode(this.revision); 
     return hash; 
    } 

    @Override 
    public boolean equals(Object obj) { 
     if (this == obj) { 
      return true; 
     } 
     if (obj == null) { 
      return false; 
     } 
     if (getClass() != obj.getClass()) { 
      return false; 
     } 
     final DevRev other = (DevRev) obj; 
     if (this.model != other.model) { 
      return false; 
     } 
     if (!Objects.equals(this.series, other.series)) { 
      return false; 
     } 
     if (!Objects.equals(this.version, other.version)) { 
      return false; 
     } 
     return Objects.equals(this.revision, other.revision); 
    } 

    @Override 
    public String toString() { 
     return series + "-" + model + "-" + version + (revision != null ? "-" + revision : ""); 
    } 

    public static void main(String[] args) { 
     String[] firmare = { 
      "STM-1000-H", 
      "STM-2000-E", 
      "STM-4000-H", 
      "STM-200-H", 
      "SFP-1000-A", 
      "SFP-300-H", 
      "SAFPX-1000-H", 
      "SAFPX-2000-A", 
      "STM-1000-H-L1", 
      "STM-1000-H-L1+VA+GH", 
      "STM-1000-H-L2"}; 

     Map<String, List<DevRev>> revs = new TreeMap<>(); 
     for (String f : firmare) { 
      DevRev dr = new DevRev(f); 
      List<DevRev> sdevs = revs.get(dr.getSeries()); 
      if (sdevs == null) { 
       sdevs = new ArrayList<>(); 
       revs.put(dr.getSeries(), sdevs); 
      } 

      sdevs.add(dr); 
     } 

     for (Map.Entry<String, List<DevRev>> entry : revs.entrySet()) { 
      String series = entry.getKey(); 
      List<DevRev> devices = entry.getValue(); 
      System.out.println(series); 
      devices.sort(new Comparator<DevRev>() { 
       @Override 
       public int compare(DevRev o1, DevRev o2) { 
        return new Integer(o1.getModel()).compareTo(o2.getModel()); 
       } 
      }); 

      for (DevRev dr : devices) { 
       System.out.println("-> " + dr); 
      } 
     } 
    } 
}