Come posso sostituire più spazi con un singolo spazio in C #?

Come posso sostituire più spazi in una stringa con un solo spazio in C #?

Esempio:

1 2 3  4    5

sarebbe:

1 2 3 4 5

string sentence = "This is a sentence with multiple    spaces";
RegexOptions options = RegexOptions.None;
Regex regex = new Regex("[ ]{2,}", options);     
sentence = regex.Replace(sentence, " ");

Mi piace usare:

myString = Regex.Replace(myString, @"\s+", " ");

Dal momento che catturerà corse di qualsiasi tipo di spazio bianco (ad esempio schede, nuove righe, ecc.) E le sostituirà con un singolo spazio.

string xyz = "1   2   3   4   5";
xyz = string.Join( " ", xyz.Split( new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries ));

Penso che la risposta di Matt sia la migliore, ma non credo sia del tutto giusta. Se si desidera sostituire le nuove righe, è necessario utilizzare:

myString = Regex.Replace(myString, @"\s+", " ", RegexOptions.Multiline);

Un altro approccio che utilizza LINQ:

 var list = str.Split(' ').Where(s => !string.IsNullOrWhiteSpace(s));
 str = string.Join(" ", list);

È molto più semplice di tutto ciò:

while(str.Contains("  ")) str = str.Replace("  ", " ");

Regex può essere piuttosto lento anche con compiti semplici. Questo crea un metodo di estensione che può essere utilizzato al di fuori di qualsiasi string.

    public static class StringExtension
    {
        public static String ReduceWhitespace(this String value)
        {
            var newString = new StringBuilder();
            bool previousIsWhitespace = false;
            for (int i = 0; i < value.Length; i++)
            {
                if (Char.IsWhiteSpace(value[i]))
                {
                    if (previousIsWhitespace)
                    {
                        continue;
                    }

                    previousIsWhitespace = true;
                }
                else
                {
                    previousIsWhitespace = false;
                }

                newString.Append(value[i]);
            }

            return newString.ToString();
        }
    }

Sarebbe usato come tale:

string testValue = "This contains     too          much  whitespace."
testValue = testValue.ReduceWhitespace();
// testValue = "This contains too much whitespace."

myString = Regex.Replace(myString, " {2,}", " ");

Per coloro a cui non piace Regex, ecco un metodo che utilizza StringBuilder:

    public static string FilterWhiteSpaces(string input)
    {
        if (input == null)
            return string.Empty;

        StringBuilder stringBuilder = new StringBuilder(input.Length);
        for (int i = 0; i < input.Length; i++)
        {
            char c = input[i];
            if (i == 0 || c != ' ' || (c == ' ' && input[i - 1] != ' '))
                stringBuilder.Append(c);
        }
        return stringBuilder.ToString();
    }

Nei miei test, questo metodo era in media 16 volte più veloce con un set molto ampio di stringhe di dimensioni medio-piccole, rispetto a un Regex compilato statico. Rispetto a un Regex non compilato o non statico, questo dovrebbe essere ancora più veloce.

Tieni presente che non rimuove gli spazi iniziali o finali, ma solo più occorrenze di tali.

Puoi semplicemente farlo in un'unica soluzione!

string s = "welcome to  london";
s.Replace(" ", "()").Replace(")(", "").Replace("()", " ");

Puoi scegliere altre parentesi (o anche altri caratteri), se lo desideri.

Questa è una versione più breve, che dovrebbe essere utilizzata solo se lo fai solo una volta, poiché crea una nuova istanza della Regexclasse ogni volta che viene chiamata.

temp = new Regex(" {2,}").Replace(temp, " "); 

Se non conosci troppo le espressioni regolari, ecco una breve spiegazione:

La {2,}rende la ricerca regex per il carattere che lo precede, e trova sottostringhe tra 2 e numero illimitato di volte.
Il .Replace(temp, " ")sostituisce tutte le partite della temperatura stringa con uno spazio.

Se vuoi usarlo più volte, ecco un'opzione migliore, in quanto crea il regex IL al momento della compilazione:

Regex singleSpacify = new Regex(" {2,}", RegexOptions.Compiled);
temp = singleSpacify.Replace(temp, " ");

no Regex, no Linq ... rimuove gli spazi iniziali e finali e riduce qualsiasi segmento di spazio multiplo incorporato in uno spazio

string myString = "   0 1 2  3   4               5  ";
myString = string.Join(" ", myString.Split(new char[] { ' ' }, 
StringSplitOptions.RemoveEmptyEntries));

risultato: "0 1 2 3 4 5"

Consolodando altre risposte, secondo Joel, e si spera che migliorino leggermente mentre vado:

Puoi farlo con Regex.Replace():

string s = Regex.Replace (
    "   1  2    4 5", 
    @"[ ]{2,}", 
    " "
    );

O con String.Split():

static class StringExtensions
{
    public static string Join(this IList<string> value, string separator)
    {
        return string.Join(separator, value.ToArray());
    }
}

//...

string s = "     1  2    4 5".Split (
    " ".ToCharArray(), 
    StringSplitOptions.RemoveEmptyEntries
    ).Join (" ");

Ho appena scritto un nuovo Joinche mi piace, quindi ho pensato di rispondere di nuovo, con esso:

public static string Join<T>(this IEnumerable<T> source, string separator)
{
    return string.Join(separator, source.Select(e => e.ToString()).ToArray());
}

Una delle cose interessanti di questo è che funziona con raccolte che non sono stringhe, chiamando ToString () sugli elementi. L'utilizzo è sempre lo stesso:

//...

string s = "     1  2    4 5".Split (
    " ".ToCharArray(), 
    StringSplitOptions.RemoveEmptyEntries
    ).Join (" ");

      // Mysample string
            string str ="hi you           are          a demo";

            //Split the words based on white sapce
            var demo= str .Split(' ').Where(s => !string.IsNullOrWhiteSpace(s));

            //Join the values back and add a single space in between
                    str = string.Join(" ", demo);

//output: string str ="hi you are a demo";

So che è piuttosto vecchio, ma mi sono imbattuto in questo mentre cercavo di ottenere quasi la stessa cosa. Ho trovato questa soluzione in RegEx Buddy. Questo modello sostituirà tutti i doppi spazi con spazi singoli e taglierà anche gli spazi iniziali e finali.

pattern: (?m:^ +| +$|( ){2,})
replacement: $1

È un po 'difficile da leggere poiché abbiamo a che fare con uno spazio vuoto, quindi eccolo di nuovo con gli "spazi" sostituiti da uno "_".

pattern: (?m:^_+|_+$|(_){2,})  <-- don't use this, just for illustration.

Il costrutto "(? M:" abilita l'opzione "multi-linea". In genere mi piace includere tutte le opzioni che posso all'interno del modello stesso, in modo che sia più autonomo.

Molte risposte stanno fornendo il giusto risultato ma per coloro che sono alla ricerca delle migliori prestazioni, ho migliorato la risposta di Nolanar (che era la migliore risposta per le prestazioni) di circa il 10%.

public static string MergeSpaces(this string str)
{

    if (str == null)
    {
        return null;
    }
    else
    {
        StringBuilder stringBuilder = new StringBuilder(str.Length);

        int i = 0;
        foreach (char c in str)
        {
            if (c != ' ' || i == 0 || str[i - 1] != ' ')
                stringBuilder.Append(c);
            i++;
        }
        return stringBuilder.ToString();
    }

}

Posso rimuovere gli spazi bianchi con questo

while word.contains("  ")  //double space
   word = word.Replace("  "," "); //replace double space by single space.
word = word.trim(); //to remove single whitespces from start & end.

Usa il modello regex

    [ ]+    #only space

   var text = Regex.Replace(inputString, @"[ ]+", " ");

prova questo metodo

private string removeNestedWhitespaces(char[] st)
{
    StringBuilder sb = new StringBuilder();
    int indx = 0, length = st.Length;
    while (indx < length)
    {
        sb.Append(st[indx]);
        indx++;
        while (indx < length && st[indx] == ' ')
            indx++;
        if(sb.Length > 1  && sb[0] != ' ')
            sb.Append(' ');
    }
    return sb.ToString();
}

usalo così:

string test = removeNestedWhitespaces("1 2 3  4    5".toCharArray());

Ecco una leggera modifica sulla risposta originale di Nolonar .

Verifica se il personaggio non è solo uno spazio, ma uno spazio bianco, usa questo:

Sostituirà qualsiasi carattere a più spazi bianchi con un singolo spazio.

public static string FilterWhiteSpaces(string input)
{
    if (input == null)
        return string.Empty;

    var stringBuilder = new StringBuilder(input.Length);
    for (int i = 0; i < input.Length; i++)
    {
        char c = input[i];
        if (i == 0 || !char.IsWhiteSpace(c) || (char.IsWhiteSpace(c) && 
            !char.IsWhiteSpace(strValue[i - 1])))
            stringBuilder.Append(c);
    }
    return stringBuilder.ToString();
}

Vecchia scuola:

string oldText = "   1 2  3   4    5     ";
string newText = oldText
                    .Replace("  ", " " + (char)22 )
                    .Replace( (char)22 + " ", "" )
                    .Replace( (char)22 + "", "" );

Assert.That( newText, Is.EqualTo( " 1 2 3 4 5 " ) );

Senza usare espressioni regolari:

while (myString.IndexOf("  ", StringComparison.CurrentCulture) != -1)
{
    myString = myString.Replace("  ", " ");
}

OK da usare su stringhe brevi, ma funzionerà male su stringhe lunghe con molti spazi.

Mix di StringBuilder e Enumerable.Aggregate () come metodo di estensione per le stringhe:

using System;
using System.Linq;
using System.Text;

public static class StringExtension
{
    public static string StripSpaces(this string s)
    {
        return s.Aggregate(new StringBuilder(), (acc, c) =>
        {
            if (c != ' ' || acc.Length > 0 && acc[acc.Length-1] != ' ')
                acc.Append(c);

            return acc;
        }).ToString();
    }

    public static void Main()
    {
        Console.WriteLine("\"" + StringExtension.StripSpaces("1   Hello       World  2   ") + "\"");
    }
}

Ingresso:

"1   Hello       World  2   "

Produzione:

"1 Hello World 2 "