tableau int en chaîne

Question

En C #, j'ai un tableau d'entiers, contenant uniquement des chiffres. Je veux convertir ce tableau en chaîne.

Exemple de tableau:

 int[] arr = {0,1,2,3,0,1};
 

Comment puis-je le convertir en une chaîne au format: "012301" ?

Answer 1

 String.Join("", new List<int>(array).ConvertAll(i => i.ToString()).ToArray());

Answer 2

Vous pouvez simplement utiliser la fonction String.Join et comme séparateur utiliser une chaîne vide C'est en interne en utilisant StringBuilder.

 string result = string.Join(string.Emtpy, new []{0,1,2,3,0,1});
 

Par exemple: si vous utilisez comme point-virgule séparateur, le résultat serait: "0; 1; 2; 3; 0; 1". Il fonctionne en fait avec un séparateur nul et le deuxième paramètre peut être énumérable pour n'importe quel objet, comme:

 string result = string.Join(null, new object[]{0,1,2,3,0,"A",DateTime.Now});
 

Answer 3

Je me rends compte de mon avis, n'est probablement pas le populaire, mais je suppose que j'ai du mal à sauter sur le Linq-y chariot de bande. C'est bien chouette. C'est condensée. Je reçois et je ne suis pas opposé à l'aide là où c'est approprié. Peut-être que c'est juste moi, mais je trouve que les gens ont arrêté de penser à la création de fonctions utilitaires pour accomplir ce qu'ils veulent et préfèrent plutôt de la litière de leur code avec (parfois) trop long des lignes de code Linq pour le bien de la création d'un dense 1-liner.

Je ne dis pas que tout le Linq réponses que les gens ont fournies ici sont mauvais, mais je suppose que je me sens comme il ya la possibilité que ces simples lignes de code peuvent commencer à croître plus longue et la plus obscure, comme vous avez besoin de gérer les différentes situations. Que faire si votre tableau est nulle? Si vous voulez une chaîne délimitée au lieu de simplement purement concaténées? Si certains des entiers dans votre tableau sont à deux chiffres et que vous souhaitez pad chaque valeur de zéros, de sorte que la chaîne de chaque élément est de la même longueur que le reste?

En prenant l'une des réponses comme par exemple:

        result = arr.Aggregate(string.Empty, (s, i) => s + i.ToString());

Si j'ai besoin de vous soucier de la matrice nulle, désormais, c'est ceci:

        result = (arr == null) ? null : arr.Aggregate(string.Empty, (s, i) => s + i.ToString());

Si je veux une chaîne délimitée par des virgules, désormais, c'est ceci:

        result = (arr == null) ? null : arr.Skip(1).Aggregate(arr[0].ToString(), (s, i) => s + "," + i.ToString());

C'est encore pas trop mal, mais je pense que c'est pas évident au regard de ce que cette ligne de code est en train de faire.

Bien sûr, il n'y a rien qui vous empêche de lancer cette ligne de code dans votre propre fonction d'utilité, de sorte que vous n'avez pas que long mess mixte avec la logique de l'application, surtout si vous le faites en plusieurs endroits:

    public static string ToStringLinqy<T>(this T[] array, string delimiter)
    {
        // edit: let's replace this with a "better" version using a StringBuilder
        //return (array == null) ? null : (array.Length == 0) ? string.Empty : array.Skip(1).Aggregate(array[0].ToString(), (s, i) => s + "," + i.ToString());
        return (array == null) ? null : (array.Length == 0) ? string.Empty : array.Skip(1).Aggregate(new StringBuilder(array[0].ToString()), (s, i) => s.Append(delimiter).Append(i), s => s.ToString());
    }

Mais si vous allez la mettre dans une fonction d'utilité de toute façon, avez-vous vraiment besoin d'être condensée en une 1-liner? Dans ce cas, pourquoi ne pas jeter un supplément de quelques lignes pour plus de clarté et de profiter d'un StringBuilder de sorte que vous ne faites pas répété les opérations de concaténation:

    public static string ToStringNonLinqy<T>(this T[] array, string delimiter)
    {
        if (array != null)
        {
            // edit: replaced my previous implementation to use StringBuilder
            if (array.Length > 0)
            {
                StringBuilder builder = new StringBuilder();

                builder.Append(array[0]);
                for (int i = 1; i < array.Length; i++)
                {
                    builder.Append(delimiter);
                    builder.Append(array[i]);
                }

                return builder.ToString()
            }
            else
            {
                return string.Empty;
            }
        }
        else
        {
            return null;
        }
    }

Et si vous êtes vraiment préoccupés par la performance, vous pouvez même le transformer en une fonction hybride qui décide de faire la chaîne.Rejoindre ou à utiliser un StringBuilder en fonction du nombre d'éléments dans le tableau (c'est un micro-optimisation, pas la peine de le faire à mon avis et peut-être plus nuisible que bénéfique, mais je suis de l'utiliser comme un exemple de ce problème):

    public static string ToString<T>(this T[] array, string delimiter)
    {
        if (array != null)
        {
            // determine if the length of the array is greater than the performance threshold for using a stringbuilder
            // 10 is just an arbitrary threshold value I've chosen
            if (array.Length < 10)
            {
                // assumption is that for arrays of less than 10 elements
                // this code would be more efficient than a StringBuilder.
                // Note: this is a crazy/pointless micro-optimization.  Don't do this.
                string[] values = new string[array.Length];

                for (int i = 0; i < values.Length; i++)
                    values[i] = array[i].ToString();

                return string.Join(delimiter, values);
            }
            else
            {
                // for arrays of length 10 or longer, use a StringBuilder
                StringBuilder sb = new StringBuilder();

                sb.Append(array[0]);
                for (int i = 1; i < array.Length; i++)
                {
                    sb.Append(delimiter);
                    sb.Append(array[i]);
                }

                return sb.ToString();
            }
        }
        else
        {
            return null;
        }
    }

Pour cet exemple, l'impact sur les performances est probablement pas la peine de se soucier, mais le point est que si vous êtes dans une situation où vous avez besoin d'être préoccupé par le rendement de vos opérations, quelles qu'elles soient, alors il sera probablement plus facile et plus lisible pour le gérer à l'intérieur d'une fonction d'utilité de l'aide d'un complexe expression Linq.

Que la fonction d'utilité a toujours l'air sorte de maladroit. Maintenant, nous allons abandonner l'hybride de trucs et pour ce faire:

    // convert an enumeration of one type into an enumeration of another type
    public static IEnumerable<TOut> Convert<TIn, TOut>(this IEnumerable<TIn> input, Func<TIn, TOut> conversion)
    {
        foreach (TIn value in input)
        {
            yield return conversion(value);
        }
    }

    // concatenate the strings in an enumeration separated by the specified delimiter
    public static string Delimit<T>(this IEnumerable<T> input, string delimiter)
    {
        IEnumerator<T> enumerator = input.GetEnumerator();

        if (enumerator.MoveNext())
        {
            StringBuilder builder = new StringBuilder();

            // start off with the first element
            builder.Append(enumerator.Current);

            // append the remaining elements separated by the delimiter
            while (enumerator.MoveNext())
            {
                builder.Append(delimiter);
                builder.Append(enumerator.Current);
            }

            return builder.ToString();
        }
        else
        {
            return string.Empty;
        }
    }

    // concatenate all elements
    public static string ToString<T>(this IEnumerable<T> input)
    {
        return ToString(input, string.Empty);
    }

    // concatenate all elements separated by a delimiter
    public static string ToString<T>(this IEnumerable<T> input, string delimiter)
    {
        return input.Delimit(delimiter);
    }

    // concatenate all elements, each one left-padded to a minimum length
    public static string ToString<T>(this IEnumerable<T> input, int minLength, char paddingChar)
    {
        return input.Convert(i => i.ToString().PadLeft(minLength, paddingChar)).Delimit(string.Empty);
    }

Maintenant, nous avons séparé et assez compacte, les fonctions de l'utilitaire, chacun de qui sont soutenables utiles sur leur propre.

En fin de compte, mon point n'est pas que vous ne devriez pas utiliser Linq, mais plutôt juste pour dire de ne pas oublier les avantages de la création de votre propre utilitaire de fonctions, même si elles sont de petite taille et peut-être contenir une seule ligne qui renvoie le résultat à partir d'une ligne de code Linq. Si rien d'autre, vous serez en mesure de garder votre code d'application encore plus condensé que vous pourriez atteindre avec une ligne de code Linq, et si vous l'utilisez, en plusieurs endroits, puis à l'aide d'une fonction d'utilité qui rend plus facile d'ajuster votre sortie dans le cas où vous avez besoin de le changer plus tard.

Pour ce problème, je préfère suffit d'écrire quelque chose comme ceci dans mon code d'application:

        int[] arr = { 0, 1, 2, 3, 0, 1 };

        // 012301
        result = arr.ToString<int>();

        // comma-separated values
        // 0,1,2,3,0,1
        result = arr.ToString(",");

        // left-padded to 2 digits
        // 000102030001
        result = arr.ToString(2, '0');

Answer 4

Pour éviter la création d'un tableau supplémentaire, vous pouvez procéder comme suit.

 var builder = new StringBuilder();
Array.ForEach(arr, x => builder.Append(x));
var res = builder.ToString();
 

Answer 5

 string result = arr.Aggregate("", (s, i) => s + i.ToString());
 

(Avertissement: si vous avez beaucoup de chiffres (des centaines, au moins) et que vous vous souciez des performances, je suggère d'éviter cette méthode et d'utiliser un StringBuilder , comme dans la réponse de JaredPar.)