Как заменить несколько пробелов одним пробелом в C#?

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

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

Объединяя другие ответы, за Джоэла, и, надеюсь, немного улучшаюсь по мере того, как я иду:

Вы можете сделать это с помощью Regex.Replace():

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

Или с 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 (" ");

Все намного проще:

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

Мне нравится использовать:

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

Поскольку он будет ловить пробелы любого вида (например, табуляции, новые строки и т. д.) И заменять их одним пробелом.

Я только что написал новый Join, который мне нравится, поэтому подумал, что отвечу еще раз:

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

Одна из замечательных особенностей этого метода заключается в том, что он работает с коллекциями, которые не являются строками, путем вызова ToString () для элементов. Использование осталось прежним:

//...

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

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

Я думаю, что ответ Мэтта лучший, но я не считаю его правильным. Если вы хотите заменить символы новой строки, вы должны использовать:

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

Другой подход, использующий LINQ:

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

Старая школа:

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

Для тех, кому не нравится Regex, вот метод, который использует 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();
    }

В моих тестах этот метод был в среднем в 16 раз быстрее с очень большим набором строк от малого до среднего размера по сравнению со статическим скомпилированным Regex. По сравнению с нескомпилированным или нестатическим регулярным выражением это должно быть еще быстрее.

Имейте в виду, что нет удаляет начальные или конечные пробелы, только несколько таких случаев.

Я знаю, что это довольно давно, но наткнулся на это, пытаясь достичь почти того же самого. Нашел это решение в RegEx Buddy. Этот шаблон заменит все двойные пробелы одинарными, а также обрежет начальные и конечные пробелы.

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

Его немного сложно читать, так как мы имеем дело с пустым пространством, поэтому здесь снова «пробелы» заменены на «_».

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

Конструкция «(? M:» включает параметр «многострочный». Обычно мне нравится включать все возможные варианты в сам шаблон, чтобы он был более самодостаточным.

Вы можете просто сделать это в однострочном решении!

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

Вы можете выбрать другие скобки (или даже другие символы), если хотите.

Это более короткая версия, которую следует использовать только в том случае, если вы делаете это только один раз, поскольку она создает новый экземпляр класса Regex при каждом его вызове.

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

Если вы не слишком знакомы с регулярными выражениями, вот краткое объяснение:

{2,} выполняет поиск в регулярном выражении предшествующего ему символа и находит подстроки от 2 до неограниченного числа раз. .Replace(temp, " ") заменяет все совпадения в строке temp пробелом.

Если вы хотите использовать это несколько раз, вот лучший вариант, поскольку он создает IL регулярного выражения во время компиляции:

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

Regex может работать довольно медленно даже с простыми задачами. Это создает метод расширения, который можно использовать вне любого 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();
        }
    }

Он будет использоваться как таковой:

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

попробуйте этот метод

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

используйте это так:

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

Я могу удалить пробелы с помощью этого

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

Без использования регулярных выражений:

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

Можно использовать с короткими строками, но плохо работает с длинными строками с большим количеством пробелов.

no Regex, no Linq ... удаляет начальные и конечные пробелы, а также сокращает любые встроенные несколько сегментов пробела до одного пробела

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

результат: "0 1 2 3 4 5"

Многие ответы дают правильный результат, но для тех, кто ищет лучшую производительность, я улучшил Ответ ноланара (что было лучшим ответом на производительность) примерно на 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();
    }

}

Используйте шаблон регулярного выражения

    [ ]+    #only space

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

Сочетание StringBuilder и Enumerable.Aggregate () в качестве метода расширения для строк:

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   ") + "\"");
    }
}

Вход:

"1   Hello       World  2   "

Выход:

"1 Hello World 2 "

// 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";

Вот небольшая модификация на Нолонар оригинальный ответ.

Проверяя, является ли символ не просто пробелом, а любым пробелом, используйте это:

Он заменит любой многократный пробельный символ одним пробелом.

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

Я просмотрел предложенные решения и не смог найти того, который обрабатывал бы сочетание символов пробела, приемлемого для моего случая, например:

• Regex.Replace(input, @"\s+", " ") - съест ваши разрывы строк, если они смешаны с пробелами, например последовательность \n \n будет заменена на
• Regex.Replace(source, @"(\s)\s+", "$1") - это будет зависеть от первого символа пробела, что означает, что он снова может съесть ваши разрывы строк
• Regex.Replace(source, @"[ ]{2,}", " ") - он не будет работать правильно, если есть сочетание пробельных символов - например, "\t \t "

Наверное, не идеально, но быстрое решение для меня было:

Regex.Replace(input, @"\s+", 
(match) => match.Value.IndexOf('\n') > -1 ? "\n" : " ", RegexOptions.Multiline)

Идея в том, что разрыв строки побеждает пробелы и табуляции.

Это не будет правильно обрабатывать разрывы строк в окнах, но было бы легко настроить работу с этим тоже, не знаю регулярное выражение так хорошо - может быть, можно вписаться в один шаблон.