126

我试图在调用一些改变它的方法后打印出数组的内容，在Java中我使用：

System.out.print(Arrays.toString(alg.id));

我如何在 C# 中做到这一点？

4

13 回答 13

232

你可以试试这个：

foreach(var item in yourArray)
{
    Console.WriteLine(item.ToString());
}

此外，您可能想尝试这样的事情：

yourArray.ToList().ForEach(i => Console.WriteLine(i.ToString()));

编辑：在一行中获得输出[根据您的评论]：

 Console.WriteLine("[{0}]", string.Join(", ", yourArray));
 //output style:  [8, 1, 8, 8, 4, 8, 6, 8, 8, 8]

编辑（2019）：正如其他答案中提到的，最好使用Array.ForEach<T>方法，并且不需要执行该ToList步骤。

Array.ForEach(yourArray, Console.WriteLine);
于 2013-04-28T16:53:13.017 回答
74

有很多方法可以做到这一点，其他答案都很好，这里有一个替代方案：

Console.WriteLine(string.Join("\n", myArrayOfObjects));
于 2013-04-28T16:55:17.093 回答
22

最简单的一个，例如，如果你有一个这样声明的字符串数组 string[] myStringArray = new string[];

Console.WriteLine("Array : ");
Console.WriteLine("[{0}]", string.Join(", ", myStringArray));
于 2015-04-10T09:46:18.607 回答
22

我决定测试这里发布的不同方法的速度：

这是我使用的四种方法。

static void Print1(string[] toPrint)
{
    foreach(string s in toPrint)
    {
        Console.Write(s);
    }
}

static void Print2(string[] toPrint)
{
    toPrint.ToList().ForEach(Console.Write);
}

static void Print3(string[] toPrint)
{
    Console.WriteLine(string.Join("", toPrint));
}

static void Print4(string[] toPrint)
{
    Array.ForEach(toPrint, Console.Write);
}

结果如下：

 Strings per trial: 10000
 Number of Trials: 100
 Total Time Taken to complete: 00:01:20.5004836
 Print1 Average: 484.37ms
 Print2 Average: 246.29ms
 Print3 Average: 70.57ms
 Print4 Average: 233.81ms

所以 Print3 是最快的，因为它只有一次调用，Console.WriteLine这似乎是打印出数组速度的主要瓶颈。Print4 比 Print2 稍快，而 Print1 是最慢的。

我认为 Print4 可能是我测试的 4 个中最通用的，尽管 Print3 更快。

如果我犯了任何错误，请随时让我知道/自行修复它们！

编辑：我在下面添加生成的 IL

g__Print10_0://Print1
IL_0000:  ldarg.0     
IL_0001:  stloc.0     
IL_0002:  ldc.i4.0    
IL_0003:  stloc.1     
IL_0004:  br.s        IL_0012
IL_0006:  ldloc.0     
IL_0007:  ldloc.1     
IL_0008:  ldelem.ref  
IL_0009:  call        System.Console.Write
IL_000E:  ldloc.1     
IL_000F:  ldc.i4.1    
IL_0010:  add         
IL_0011:  stloc.1     
IL_0012:  ldloc.1     
IL_0013:  ldloc.0     
IL_0014:  ldlen       
IL_0015:  conv.i4     
IL_0016:  blt.s       IL_0006
IL_0018:  ret         

g__Print20_1://Print2
IL_0000:  ldarg.0     
IL_0001:  call        System.Linq.Enumerable.ToList<String>
IL_0006:  ldnull      
IL_0007:  ldftn       System.Console.Write
IL_000D:  newobj      System.Action<System.String>..ctor
IL_0012:  callvirt    System.Collections.Generic.List<System.String>.ForEach
IL_0017:  ret         

g__Print30_2://Print3
IL_0000:  ldstr       ""
IL_0005:  ldarg.0     
IL_0006:  call        System.String.Join
IL_000B:  call        System.Console.WriteLine
IL_0010:  ret         

g__Print40_3://Print4
IL_0000:  ldarg.0     
IL_0001:  ldnull      
IL_0002:  ldftn       System.Console.Write
IL_0008:  newobj      System.Action<System.String>..ctor
IL_000D:  call        System.Array.ForEach<String>
IL_0012:  ret
于 2018-05-16T13:39:47.677 回答
9

类的Array.ForEach<T> Method (T[], Action<T>)方法的另一种方法Array

Array.ForEach(myArray, Console.WriteLine);

与需要两次迭代相比，只需要一次迭代并在内部为（双迭代运行时和双内存消耗）array.ToList().ForEach(Console.WriteLine)创建第二个数组List

于 2018-05-16T13:23:23.140 回答
2

在 C# 中，您可以循环打印每个元素的数组。请注意，System.Object 定义了一个 ToString() 方法。从 System.Object() 派生的任何给定类型都可以覆盖它。

返回表示当前对象的字符串。

http://msdn.microsoft.com/en-us/library/system.object.tostring.aspx

默认情况下，将打印对象的完整类型名称，尽管许多内置类型会覆盖该默认值以打印更有意义的结果。您可以在自己的对象中覆盖 ToString() 以提供有意义的输出。

foreach (var item in myArray)
{
    Console.WriteLine(item.ToString()); // Assumes a console application
}

如果您有自己的 Foo 类，则可以像这样覆盖 ToString()：

public class Foo
{
    public override string ToString()
    {
        return "This is a formatted specific for the class Foo.";
    }
}
于 2013-04-28T16:53:52.867 回答
2

从C# 6.0开始，当引入$ - 字符串插值时，还有另一种方法：

var array = new[] { "A", "B", "C" };
Console.WriteLine($"{string.Join(", ", array)}");

//output
A, B, C

System.Linq可以使用、 转换string[]为char[]并打印为来归档串联string：

var array = new[] { "A", "B", "C" };
Console.WriteLine($"{new String(array.SelectMany(_ => _).ToArray())}");

//output
ABC
于 2019-01-25T14:40:29.647 回答
0

如果你想变得可爱，你可以编写一个扩展方法，将IEnumerable<object>序列写入控制台。这将适用于任何类型的枚举，因为IEnumerable<T>在 T 上是协变的：

using System;
using System.Collections.Generic;

namespace Demo
{
    internal static class Program
    {
        private static void Main(string[] args)
        {
            string[] array  = new []{"One", "Two", "Three", "Four"};
            array.Print();

            Console.WriteLine();

            object[] objArray = new object[] {"One", 2, 3.3, TimeSpan.FromDays(4), '5', 6.6f, 7.7m};
            objArray.Print();
        }
    }

    public static class MyEnumerableExt
    {
        public static void Print(this IEnumerable<object> @this)
        {
            foreach (var obj in @this)
                Console.WriteLine(obj);
        }
    }
}

（我认为您不会在测试代码中使用它。）

于 2013-04-28T18:13:54.717 回答
0

你可以使用 for 循环

    int[] random_numbers = {10, 30, 44, 21, 51, 21, 61, 24, 14}
    int array_length = random_numbers.Length;
    for (int i = 0; i < array_length; i++){
        if(i == array_length - 1){
              Console.Write($"{random_numbers[i]}\n");
        } else{
              Console.Write($"{random_numbers[i]}, ");
         }
     }
于 2020-10-31T18:14:17.173 回答
0

如果它是一个字符串数组，您可以使用Aggregate

var array = new string[] { "A", "B", "C", "D"};
Console.WriteLine(array.Aggregate((result, next) => $"{result}, {next}")); // A, B, C, D

这样，您可以通过更改参数的顺序来反转顺序，如下所示 

Console.WriteLine(array.Aggregate((result, next) => $"{next}, {result}")); // D, C, B, A
于 2020-02-03T21:08:38.210 回答
0

这是您可以使用数组打印字符串的最简单方法！！！

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace arraypracticeforstring
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] arr = new string[3] { "Snehal", "Janki", "Thakkar" };

            foreach (string item in arr)
            {
                Console.WriteLine(item.ToString());
            }
            Console.ReadLine();
        }
    }
}
于 2016-02-21T03:42:08.147 回答
0

我赞成 Matthew Watson 的扩展方法答案，但是如果您从 Python 迁移/访问，您可能会发现这样的方法很有用：

class Utils
{
    static void dump<T>(IEnumerable<T> list, string glue="\n")
    {
        Console.WriteLine(string.Join(glue, list.Select(x => x.ToString())));
    }
}

-> 这将使用提供的分隔符打印任何集合。它非常有限（嵌套集合？）。

对于脚本（即仅包含 Program.cs 的 C# 控制台应用程序，并且大多数事情发生在 中Program.Main）- 这可能很好。

于 2016-01-26T16:42:05.817 回答
-2

如果不想使用 Array 函数。

public class GArray
{
    int[] mainArray;
    int index;
    int i = 0;

    public GArray()
    {
        index = 0;
        mainArray = new int[4];
    }
    public void add(int addValue)
    {

        if (index == mainArray.Length)
        {
            int newSize = index * 2;
            int[] temp = new int[newSize];
            for (int i = 0; i < mainArray.Length; i++)
            {
                temp[i] = mainArray[i];
            }
            mainArray = temp;
        }
        mainArray[index] = addValue;
        index++;

    }
    public void print()
    {
        for (int i = 0; i < index; i++)
        {
            Console.WriteLine(mainArray[i]);
        }
    }
 }
 class Program
{
    static void Main(string[] args)
    {
        GArray myArray = new GArray();
        myArray.add(1);
        myArray.add(2);
        myArray.add(3);
        myArray.add(4);
        myArray.add(5);
        myArray.add(6);
        myArray.print();
        Console.ReadKey();
    }
}
于 2019-05-20T19:35:00.560 回答