如何在字符串arraylist中進行迭代排序？

Question

我有以下字符串元素的ArrayList - >

['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'] 

我想和分組等的ArrayList ...

顯示STM- 400, 500, 600, 100, 2000, 4000 (in that order), followed by SPX- 1000, 2000, 4000（以該順序，再其次是SAFPX- 1000還，我必須列出由L, L1, L2, M, M1, M2, M3, H, H! and VH每個（按順序）。

能否請您協助執行，Array列表只是字符串元素。

Answer 1

你應該CREA定製一個比較器，然後用它來排列數組列表。

例如（這是做一些你要求的排序，但不檢查邊緣情況，這是由你來修復）。注意：爪哇8用於

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; 
} 

輸出：

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); 
      } 
     } 
    } 
}