Deep Dive into Array Basics Part 1

1
char[] book = {'A','B','C','D'};

1
2
type[] name_of_placeholder;
char[] book;

1
2
name_of_placeholder = new data_type[size_of_array];
book = new char[4];

1
2
3
char[] array = new char[] {'A','B','C','D'};
char[] array = {'A','B','C','D'};
char[] array = new[] {'A','B','C','D'};

1
2
3
4
var array = new char[4]; // creates array of length 4
var array = new char[4] {'A','B','C','D'};
var array = new char[] {'A','B','C','D'};
var array = new[] {'A','B','C','D' };

1
2
3
4
5
6
7
8
9
10
index    Data      Memory addresses
       _____
0     |  A  |     4000  <=  name of the array
      |_____|               pointing to initial address
1     |  B  |     4002
      |_____|
2     |  C  |     4004
      |_____|
3     |  D  |     4006
      |_____|

1
2
3
array_name[numeric_index]
e.g       output
book[2]     C

1
2
3
4
initial address + (index * size of data type)
4000            + (2 * 2)
4000            +    4
=> 4004

1
2
array_name[numeric_index] = new_element
book[0]  =  'P' // Replace A with P

1
['P','B','C','D'];

1
2
3
4
using System.Linq;

int[] intArr = new [] { 11, 2, 0, 14, 112 };
List<int> intList = intArr.OfType<int>().ToList(); // convert array to List

1
2
int[] arr = new int[2];
int[] temp = (int[])arr.Clone();

1
2
3
StructuralComparisons.StructuralEqualityComparer.Equals(new int[]{1,2}, new int[]{2,1}); // False

StructuralComparisons.StructuralEqualityComparer.Equals(new int[]{1,2}, new int[]{1,2}); // True

1
2
3
4
5
StructuralComparisons.StructuralComparer.Compare(new int[]{1,2}, new int[]{2,1}); // -1 first comes before in a second

StructuralComparisons.StructuralComparer.Compare(new int[]{1,2}, new int[]{1,2}); // 0 both are equals

StructuralComparisons.StructuralEqualityComparer.Equals(new int[]{2,1}, new int[]{1,2}); // 1, first comes after second

1
2
3
4
5
Console.WriteLine("["+book[0]+","+book[1]+","+book[2]+","+book[3]+"]"); // direct access
Console.WriteLine("[{0},{1},{2},{3}]",book[0],book[1],book[2],book[3]); // interpolated string
Console.WriteLine("[{0}]", string.Join(",", book)); // get array string and use comma as separator
Output:
[A,B,C,D] // for all 3 statements

1
2
3
for(int i = initial_value ; exit_condtion ; increment/decrement){
  // statement
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Random rand = new Random();
string strA_Z = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
for(int i = 0 ; i < book.Length ; i++){
  // Note : FormattableString string instance is reused to display new values
  Console.Write("book[{0}] = {1}",i,book[i]);
  // random number between 0 - 25
  int randomOndex = rand.Next(strA_Z.Length);
  // replace element with random alphabet
  book[i] = strA_Z[randomOndex];
  Console.WriteLine(" : book[{0}] = {1}",i,book[i]);
}
Output: Its random, so output may differ
book[0] = A : book[0] = H
book[1] = B : book[1] = U
book[2] = C : book[2] = G
book[3] = D : book[3] = O

1
2
3
4
5
6
7
8
9
10
static void Main(string[] args){
  char[] book = new[]{'A','B','C','D'};
  Console.WriteLine("[{0}]",string.Join(",",book)); // [A,B,C,D]
  ChangeReference(book); // no change after this executes
  Console.WriteLine("[{0}]",string.Join(",",book)); // [A,B,C,D]
}
static void ChangeReference(char[] book){
  Console.WriteLine("[{0}]",string.Join(",",book)); // [A,B,C,D]
  book = new[]{'W','X','Y','Z'};
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
static void Main(string[] args){
  char[] book = new[]{'A','B','C','D'};
  Console.WriteLine("[{0}]",string.Join(",",book)); // [A,B,C,D]
  ChangeReference(out book);
  Console.WriteLine("[{0}]",string.Join(",",book)); // [W,X,Y,Z]
  ChangeReference(out null); // compile time error, un-assignable reference
  ChangeReferenceErr(out book);
}
static void ChangeReference(out char[] book){
  book = new[]{'W','X','Y','Z'};
}
static void ChangeReferenceErr(out char[] book){
  Console.WriteLine("[{0}]",string.Join(",",book)); // compilation error, Cannot use before initialization
  book = new[]{'W','X','Y','Z'}; // do this before using book
}

1
2
3
4
5
6
7
8
9
10
11
static void Main(string[] args){
  char[] book = new[]{'A','B','C','D'};
  PrintArrayValues(ref book); // [A,B,C,D]
  char[] bookNull;
  PrintArrayValues(ref bookNull); // compile time error, use of unassigned local variable
  char[] upComingBooks = null;
  PrintArrayValues(ref upComingBooks); // Runtime error, ArgumentNullException, because books is null
}
static void PrintArrayValues(ref char[] book){
  Console.WriteLine("[{0}]",string.Join(",",book));
}

1
2
static void add (ref int a){}
static void add (out int a){} // compilation error, ref and out are not enough to overload a method

1
2
3
4
5
6
7
8
9
10
11
12
static void Main(string[] args){
  TotalAnyLengthArray(1,2,3);          // 6
  TotalAnyLengthArray(1,2,3,3,4,5,5);  // 23
  TotalAnyLengthArray();               // 0
}
static void TotalAnyLengthArray(params int[] ints){
 long sum = 0;
 for(int i = 0 ; i < ints.Length ; i++){
     sum += ints[i];
 }
 Console.WriteLine("Total is {0}",sum);
}

1
2
3
4
5
6
7
8
9
10
11
static void Main(string[] args){
  TotalAnyLengthArrayAndVerify(6,1,2,3);           // True
  TotalAnyLengthArrayAndVerify(20,1,2,3,3,4,5,5);  // False, total is 23 not 20
}
static void TotalAnyLengthArrayAndVerify(int expectedTot, params int[] ints){
 long sum = 0;
 for(int i = 0 ; i < ints.Length ; i++){
     sum += ints[i];
 }
 Console.WriteLine("Match is {0}", sum == expectedTot);
}

1
2
object[] all = new object[]{1,true,""}; // object can store any type
object[] listInt = new int[] {1, 2}; // not possible

1
2
3
char[] nName = new[]{'P', 'A', 'V' };
Console.WriteLine(nName == new char[]{'P','A','V'}); // False
Console.WriteLine(nName.SequenceEqual(new char[]{'P','A','V'})); // True

1
char[] a = new char[]{}; // create empty array

1
2
char[] chars = {'P','A','V','N','E','E','T'};
string name = new string(chars); //PAVNEET