Java-Äquivalent von PHPs implode(‘,’ , array_filter( array () ))

Lesezeit: 1 Minute

Benutzer-Avatar
max4ever

Ich verwende dieses Stück Code oft in PHP

$ordine['address'] = implode(', ', array_filter(array($cliente['cap'], $cliente['citta'], $cliente['provincia'])));

Es löscht leere Zeichenfolgen und verbindet sie mit einem “,”. Wenn nur eins übrig bleibt, wird kein zusätzliches unnötiges Komma hinzugefügt. Es fügt kein Komma am Ende hinzu. Wenn keine übrig bleibt, wird eine leere Zeichenfolge zurückgegeben.

So kann ich eines der folgenden Ergebnisse erhalten

""
"Street abc 14"
"Street abc 14, 00168"
"Street abc 14, 00168, Rome"

Was ist die beste Java-Implementierung (weniger Code) in Java ohne externe Bibliotheken hinzufügen zu müssen (Design für Android)?

  • stackoverflow.com/questions/794248/…

    – dfreeman

    28. Juni 2012 um 15:41 Uhr

  • FYI für dieses Beispiel benötigen Sie eine externe Bibliothek (import org.apache.commons.lang.StringUtils;), aber ich würde trotzdem empfehlen, diese Methode zu verwenden

    – ow gerig

    28. Juni 2012 um 15:42 Uhr

  • dfreeman tut nicht, was ich brauche, kein Komma hinzufügen, wo nötig

    – max4ever

    28. Juni 2012 um 15:44 Uhr

  • Ich kann nicht glauben, dass Java das noch nicht eingebaut hat. jede andere Sprache tut es.

    – OneSolitaryNoob

    13. Mai 2013 um 22:54 Uhr

  • Können Sie bitte die Akzeptanzmarkierung ändern? stackoverflow.com/a/11248692/871050 Diese Antwort ist hier die richtigste.

    – Madaras Geist

    7. Juli 2015 um 9:08 Uhr

Benutzer-Avatar
Pshemo

Aktualisierte Version mit Java 8 (Original am Ende des Beitrags)

Wenn Sie keine Elemente filtern müssen, können Sie verwenden


Seit Java 8 können wir verwenden StringJoiner (statt ursprünglich verwendet StringBulder) und vereinfachen unseren Code.
Auch um eine Neukompilierung zu vermeiden " *" Regex in jedem Aufruf von matches(" *") Wir können ein separates Muster erstellen, das seine kompilierte Version in einem bestimmten Feld enthält und es bei Bedarf verwendet.

private static final Pattern SPACES_OR_EMPTY = Pattern.compile(" *");
public static String implode(String separator, String... data) {
    StringJoiner sb = new StringJoiner(separator);
    for (String token : data) {
        if (!SPACES_OR_EMPTY.matcher(token).matches()) {
            sb.add(token);
        }
    }
    return sb.toString();
}   

Mit Streams kann unser Code aussehen.

private static final Predicate<String> IS_NOT_SPACES_ONLY = 
        Pattern.compile("^\\s*$").asPredicate().negate();

public static String implode(String delimiter, String... data) {
    return Arrays.stream(data)
            .filter(IS_NOT_SPACES_ONLY)
            .collect(Collectors.joining(delimiter));
}

Wenn wir Streams verwenden, können wir das filter Elemente, die Predicate. In diesem Fall möchten wir, dass das Prädikat Zeichenfolgen akzeptiert, die nicht nur Leerzeichen sind – mit anderen Worten, die Zeichenfolge muss Nicht-Leerzeichen enthalten.

Wir können ein solches Prädikat aus Muster erstellen. Das auf diese Weise erstellte Prädikat akzeptiert alle Zeichenfolgen, die Teilzeichenfolgen enthalten, die mit Regex abgeglichen werden könnten (wenn also Regex nach sucht "\\S" Prädikat akzeptiert Zeichenfolgen wie "foo ", " foo bar ", "whatever"wird aber nicht akzeptiert " " Noch " ").

Also können wir verwenden

Pattern.compile("\\S").asPredicate();

oder möglicherweise etwas aussagekräftiger, Negation von Zeichenfolgen, die nur Leerzeichen oder leer sind

Pattern.compile("^\\s*$").asPredicate().negate();

Als nächstes entfernt der Filter alle leeren oder nur Leerzeichen enthaltenden Strings, die wir können collect Rest der Elemente. Dank an Collectors.joining wir können entscheiden, welches Trennzeichen verwendet werden soll.


Ursprüngliche Antwort (vor Java 8)

public static String implode(String separator, String... data) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < data.length - 1; i++) {
    //data.length - 1 => to not add separator at the end
        if (!data[i].matches(" *")) {//empty string are ""; " "; "  "; and so on
            sb.append(data[i]);
            sb.append(separator);
        }
    }
    sb.append(data[data.length - 1].trim());
    return sb.toString();
}

Sie können es gerne verwenden

System.out.println(implode(", ", "ab", " ", "abs"));

oder

System.out.println(implode(", ", new String[] { "ab", " ", "abs" }));

Ausgabe ab, abs

  • Ja, es ist bequemer zu verwenden, da Sie kein Array erstellen müssen, und mir war nicht bewusst, dass Sie String , String … verwenden können.

    – max4ever

    28. Juni 2012 um 16:17 Uhr

  • Es funktioniert nicht gut, wenn Daten die Länge 1 xD haben. Ich verwende dieses sb.append (data[0]); for (int i = 1; i < (data.length); i++) { //data.length - 1 => kein Trennzeichen am Ende hinzufügen if ((data.length[i] != null) && !daten[i].matches(” *”)) {//leere Zeichenfolge sind “”; ” “; ” “; und so weiter sb.append(separator); sb.append(data[i]); } }

    – max4ever

    28. Juni 2012 um 16:35 Uhr


  • @max4ever könntest du ein Beispiel zeigen? Ich habe in on getestet System.out.println(implode(", ", "X")) und es scheint gut zu funktionieren.

    – Pschemo

    28. Juni 2012 um 16:38 Uhr

Wieso so ernst? Versuchen StringUtils.join(new String[] {"Hello", "World", "!"}, ", ") !

  • StringUtils ist eine externe Bibliothek

    – max4ever

    29. Januar 2013 um 15:39 Uhr

  • es wird von Apache gemacht, jeder benutzt es… Ich mache es auf Bogdans Art, ihr macht, was ihr wollt

    – anton1980

    11. Juli 2013 um 14:48 Uhr

  • Es ist in Ordnung, dass Sie “es auf Ihre Weise tun”, wenn die Bibliothek bereits verfügbar ist. Wenn dies nicht der Fall ist, a) müssen Sie wissen, dass es sich um ein externes handelt, b) wo/wie Sie es erhalten können und c) ob Sie dies tun dürfen. Das Spielen von Nicht-Unternehmens-Cowboy entlastet Sie nur von c)

    – Zefiro

    23. Mai 2014 um 17:03 Uhr

  • Die externe Bibliothek finden Sie hier: commons.apache.org/proper/commons-lang

    – Alan B. Dee

    1. August 2014 um 16:01 Uhr

Benutzer-Avatar
dloomb

Hier ist eine Android-spezifische Antwort, die für einige hilfreich sein kann:

String combined = TextUtils.join(",", new String[]{"Red", "Green", "Blue"});

// Result => Red,Green,Blue

Stellen Sie sicher, dass Sie die TextUtils-Klasse importieren:

import android.text.TextUtils;

Benutzer-Avatar
nickb

Sie müssten Ihre Zeichenfolgen zu einer ArrayList hinzufügen, leere entfernen und entsprechend formatieren:

public static String createAddressString( String street, String zip_code, String country) {
    List<String> list = new ArrayList<String>();
    list.add( street);
    list.add( zip_code);
    list.add( country);

    // Remove all empty values
    list.removeAll(Arrays.asList("", null));

    // If this list is empty, it only contained blank values
    if( list.isEmpty()) {
        return "";
    }

    // Format the ArrayList as a string, similar to implode
    StringBuilder builder = new StringBuilder();
    builder.append( list.remove(0));

    for( String s : list) {
        builder.append( ", ");
        builder.append( s);
    }

    return builder.toString();
}

Zusätzlich, wenn Sie hatten String[]ein Array von Strings, können Sie sie einfach zu einer ArrayList hinzufügen:

String[] s;
List<String> list = new ArrayList<String>( Arrays.asList( s));

Benutzer-Avatar
Amann J

Verwenden von Streams (z Java 8 und später) wäre eine alternative mögliche Lösung dafür.

Sie müssen importieren

java.util.stream.Collectors;

um den Join-Prozess zu verwenden

Sie können Folgendes verwenden:

Arrays.asList("foo","bar").stream().collect(Collectors.joining(","));

um das gewünschte Ergebnis zu erzielen.

Ein einfaches Implodieren

public static String implode(String glue, String[] strArray)
{
    String ret = "";
    for(int i=0;i<strArray.length;i++)
    {
        ret += (i == strArray.length - 1) ? strArray[i] : strArray[i] + glue;
    }
    return ret;
}

Sie können dafür Überladungen erstellen.

Das obige Äquivalent von php implode.
Hier ist, was Sie wollen:

import java.lang.*
public static String customImplode(String glue, String[] strArray)
{
    String ret = "";
    for(int i=0;i<strArray.length;i++)
    {
        if (strArray[i].trim() != "")
            ret += (i == strArray.length - 1) ? strArray[i] : strArray[i] + glue;
    }
    return ret;
}

Benutzer-Avatar
Ben Barkay

Hier ist meine Implode-Implementierung:

/**
 * Implodes the specified items, gluing them using the specified glue replacing nulls with the specified
 * null placeholder.
 * @param glue              The text to use between the specified items.
 * @param nullPlaceholder   The placeholder to use for items that are <code>null</code> value.
 * @param items             The items to implode.
 * @return  A <code>String</code> containing the items in their order, separated by the specified glue.
 */
public static final String implode(String glue, String nullPlaceholder, String ... items) {
    StringBuilder sb = new StringBuilder();
    for (String item : items) {
        if (item != null) {
            sb.append(item);
        } else {
            sb.append(nullPlaceholder);
        }
        sb.append(glue);
    }
    return sb.delete(sb.length() - glue.length(), sb.length()).toString();
}

1226000cookie-checkJava-Äquivalent von PHPs implode(‘,’ , array_filter( array () ))

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy