Array Operations in. net

1. /* ------------------- C # Learning arrays ------------------*/
2. // =============================== One-dimensional array
3. // The new operator is used to create an array and initialize the array elements as their default values. In this example, all array elements are initialized to zero.
4. Int [] intarr1 = new int [5];
5. Int [] intarr2 = new int [] {1, 2, 3, 4, 5 };
6. Int [] intarr3 = {1, 2, 3, 4, 5, 6 };
7. Int [] intarr4;
8. // Arraylist Dynamic Array
9. Arraylist al1 = new arraylist ();
11. // Assign values directly to Arrays
12. Intarr4 = new int [] {4, 7, 8, 43, 2 };
13. For (INT I = 0; I <5; I ++)
14. {
15. // Assign values to Arrays
16. Intarr1 [I] = I * 2;
17. Al1.add (I );
18. }
19. // Output the value of the Dynamic Array
20. Foreach (int I in al1)
21. {
22. Common. writeln (I );
23. }
24. Foreach (int I in intarr4)
25. {
26. Common. writeln (I );
27. }
28. // =================== Implicit type array [do not consider the array type]
29. VaR A = new [] {1, 10,100,100 0}; // int []
30. VaR B = new [] {"hello", null, "world"}; // string []
31. // Output as follows
32. Foreach (var I in)
33. {// Here, A can be changed to B
34. Common. writeln (I );
35. }
37. // C and D are also called staggered arrays.
38. VaR c = new []
39. {
40. New [] {1, 2, 4 },
41. New [] {5, 6, 7, 8}
42. };
44. VaR d = new []
45. {
46. New [] {"Luca", "Mads", "Luke", "Dinesh "},
47. New [] {"Karen", "Suma", "Frances "}
48. };
50. Foreach (var I in D)
51. {// Here, D can be changed to C
52. Foreach (var j in I)
53. {
54. Common. writeln (j );
55. }
56. }
57. // ============================= Two-dimensional array and multi-dimensional array
58. // Statement
59. Int [,] Two = new int [4, 2];
60. Int [,] Three = new int [4, 2, 3];
61. // Declare and initialize
62. Int [,] array2d = new int [,] {1, 2}, {3, 4}, {5, 6}, {7, 8 }};
63. Int [,] array3d = new int [,] {1, 2}, {4, 3 },{ 5, 6}, {7, 8 }}};
64. // Outputs two-dimensional arrays, which are similar to 3D arrays.
65. For (INT I = array2d. getlowerbound (0); I <= array2d. getupperbound (0); I ++)
66. {
67. For (Int J = array2d. getlowerbound (1); j <= array2d. getupperbound (1); j ++)
68. {
69. // Note the array syntax
70. Common. writeln (array2d [I, j]);
71. }
72. }
73. // Output a 3D Array
74. For (INT I = array3d. getlowerbound (0); I <= array3d. getupperbound (0); I ++)
75. For (Int J = array3d. getlowerbound (1); j <= array3d. getupperbound (1); j ++)
76. For (int K = array3d. getlowerbound (2); k <= array3d. getupperbound (2); k ++)
77. // Note the array syntax
78. Common. writeln (array3d [I, j, k]);
79. // Initialize the array but do not specify the level:
80. Int [,] array1 = {1, 2}, {3, 4}, {5, 6}, {7, 8 }};
81. // Declare first and then initialize
82. Int [,] array2;
83. // It must be written as new int [,]
84. Array2 = new int [,] {1, 2}, {3, 4}, {5, 6}, {7, 8 }};
85. // ==================================== Jagged array [staggered array]
86. // The above are all the positive arrays of offsets, and the following is the array of sertices.
87. // Staggered array: elements are arrays. The dimensions and sizes of elements in the staggered array can be different. An interleaved array is sometimes called an "array" and its elements are of reference type.
88. // Declare an array with two elements
89. Int [] [] myarray = new int [3] [];
91. // Fill Element
92. Myarray [0] = new int [5] {1, 3, 5, 7, 9 };
93. Myarray [1] = new int [3] {2, 4, 6 };
94. Myarray [2] = new int [2] {0, 2 };
96. For (INT I = 0; I <myarray. length; I ++)
97. {
98. Common. writeln ("the" + I + "element is :");
99. // Note that only the jagged array can be written as myarray [I]. length.
100. For (Int J = 0; j <myarray [I]. length; j ++)
101. {
102. Common. writeln (myarray [I] [J]);
103. }
104. }
105. // Initialize the statement.
106. Int [] [] array3 = new int [] []
107. {
108. New int [] {1, 2, 3, 4, 5 },
109. New int [] {3, 4, 5 },
110. New int [] {0}
111. };
112. // Stenographer
113. Int [] [] array4 =
114. {
115. New int [] {1, 2, 3}
116. };