jak wyświetlić ciąg sznurkiem liczyć

Question

Mam tablicę ciągów tak:

String[] str = new String[]{"foo","bar","foo","car"} 

muszę wyjście tak:

bar1car1foo2 

Próbowałem tak:

String[] someArray = new String[] { "foo","bar","foo","car"}; 

      for(int i=0;i<someArray.length;i++){ 
       int count=0; 
       for(int j=0;j<someArray.length;j++){ 
        if(someArray[i].equals(someArray[j])){ 

         someArray[i] +=count; 
        } 
       } 
       System.out.println(someArray[i]); 
       } 

a moja produkcja to:

foo0 
bar0 
foo0 
car0 

Answer 1

public static void main(String args[]) { 

     String[] strArray = new String[] { "foo","bar","foo","car"}; 
     countduplicate(strArray); 
     } 


public static void countduplicate(String avalue[]) { 
    String str = ""; 
    Set<String> set = new HashSet<String>(); 
    for (int i = 0; i < avalue.length; i++) { 
     set.add(avalue[i]); 
    } 
    Iterator<String> iterator = set.iterator(); 
    List<String> list = new ArrayList<String>(); 
    while (iterator.hasNext()) { 
     int count=0; 
     str =iterator.next(); 
     for (int i = 0; i < avalue.length; i++) { 
      if(str.equals(avalue[i])){ 
       count++; 
      } 
     } 
      list.add(str+count); 
    } 
    for (int i = 0; i < list.size(); i++) { 
     System.out.print(list.get(i)); 
    } 
} 

Answer 2

Jedną opcją jest użycie Map<String, Integer>, gdzie klawisze oznaczają poszczególne ciągi, a wartość mapy jest licznikiem dla każdego z nich.

Więc można zrobić coś takiego:

Map<String, Integer> stringsWithCount = new TreeMap<>(); 
for (String item : str) { 
    if (stringsWithCount.contains(item)) { 
    stringsWithCount.put(item, stringsWithCount.get(item)+1)); 
    } else { 
    stringsWithCount.put(item, 0); 
    } 
} 

a następnie można iteracyjne mapę po zakończeniu:

for (Entry<String, Integer> entry : stringsWithCount.entrySet()) { 

i budować swój ciąg wynikowy.

To było jak wdrożenie w starej szkole; jeśli chcesz być wyszukane i zaskoczyć swoich nauczycieli, można przejść do rozwiązania Java8/lambda/stream:

Arrays.stream(str) 
    .collect(Collectors 
    .groupingBy(s -> s, TreeMap::new, Collectors.counting())) 
    .entrySet() 
    .stream() 
    .flatMap(e -> Stream.of(e.getKey(), String.valueOf(e.getValue()))) 
    .collect(Collectors.joining()) 

Ale oczywiście, powinny być w stanie wyjaśnić, że kawałek kodu.

Answer 3

import java.util.Set; 
import java.util.TreeSet; 
public class StringCount { 

public static void main(String[] args) { 
    String[] str = new String[]{"foo","bar","foo","car","foo","car","bar","bar"}; 
    Set<String> set= new TreeSet<String>(); 
    for(String a : str){ 
     int c=0; 
     for(int i=0;i<str.length;i++){ 
      if(a.equals(str[i])){ 
       c=c+1; 
      } 
     } 
     set.add(a+c); 
    } 
    System.out.println(set); 
} 

} 


TreeSet is used to get the sorted elements. 
Output: 
[bar3, car2, foo3] 

Answer 4

Oto moje rozwiązanie:

public static void countAndPrint(String[] elements) { 
    Map<String, Integer> map = new TreeMap<String, Integer>(); 
    for (String item: elements) { 
     int occurrences = map.containsKey(item)? map.get(item) + 1: 1; 
     map.put(item, occurrences); 
    } 
    for(String item: map.keySet()) { 
     System.out.print(item); 
     System.out.print(map.get(item)); 
    } 

} 

public static void main(String args[]) { 
    String[] elements = new String[]{"foo","bar","foo","car"}; 
    countAndPrint(elements); 
} 

Answer 5

Można użyć SortedBag z Eclipse Collections, aby rozwiązać ten problem.

String[] str = {"foo","bar","foo","car"}; 
Bag<String> bag = SortedBags.mutable.with(str); 
bag.forEachWithOccurrences(((each, occurrences) -> System.out.print(each + occurrences))); 

Wyjścia: bar1car1foo2

Uwaga: Jestem committer dla Eclipse kolekcjach.