Open In App

Difference between Array and Map

Last Updated : 18 Sep, 2023
Summarize
Comments
Improve
Suggest changes
Share
Like Article
Like
Report

Array:

An array is a collection of items stored at contiguous memory locations. The idea is to store multiple items of the same type together. This makes it easier to calculate the position of each element by simply adding an offset to a base value, i.e., the memory location of the first element of the array (generally denoted by the name of the array).
The diagrammatic representation of the Array is given below:
 

Program 1:
Below is an illustration of a 1D array:


Output: 


6 10 5 0


 

Program 2:
Below is an illustration of a 2D array:

C++ 
// C++ program to illustrate 1D array
#include <bits/stdc++.h>
using namespace std;

// Driver Code
int main()
{
    // A 2D array with 3 rows and
    // 2 columns
    int x[3][2] = { { 0, 1 }, { 2, 3 }, { 4, 5 } };

    // Print each array element value
    // Traverse row
    for (int i = 0; i < 3; i++) {

        // Traverse column
        for (int j = 0; j < 2; j++) {

            // Print element
            cout << "Element at x[" << i
                 << "][" << j
                 << "]: ";
            cout << x[i][j] << endl;
        }
    }
    return 0;
}
Java 
// Java program to illustrate 1D array
import java.util.*;
class GFG{

// Driver Code
public static void main(String[] args)
{
    // A 2D array with 3 rows and
    // 2 columns
    int x[][] = { { 0, 1 }, { 2, 3 }, { 4, 5 } };

    // Print each array element value
    // Traverse row
    for (int i = 0; i < 3; i++)
    {

        // Traverse column
        for (int j = 0; j < 2; j++) 
        {

            // Print element
            System.out.print("Element at x[" +  i + 
                             "][" +  j + "]: ");
            System.out.print(x[i][j] + "\n");
        }
    }
}
}

// This code is contributed by Princi Singh
Python3 
# Python3 program to illustrate 1D array

# Driver Code
if __name__ == '__main__':
  
    # A 2D array with 3 rows and
    # 2 columns
    x = [[0, 1], [2, 3], [4, 5]];

    # Print each array element value
    # Traverse row
    for i in range(3):

        # Traverse column
        for j in range(2):
            # Print element
            print("Element at x[" , i , 
                  "][" , j , "]: ", end = "");
            print(x[i][j]);

# This code is contributed by sapnasingh4991
C# 
// C# program to illustrate 1D array
using System;
class GFG{

// Driver Code
public static void Main(String[] args)
{
    // A 2D array with 3 rows and
    // 2 columns
    int [,]x = { { 0, 1 }, { 2, 3 }, { 4, 5 } };

    // Print each array element value
    // Traverse row
    for (int i = 0; i < 3; i++)
    {

        // Traverse column
        for (int j = 0; j < 2; j++) 
        {

            // Print element
            Console.Write("Element at x[" +  i + 
                              "," +  j + "]: ");
            Console.Write(x[i,j] + "\n");
        }
    }
}
}

// This code is contributed by Princi Singh
JavaScript 
    // JavaScript program to illustrate 1D array
    
    // A 2D array with 3 rows and
    // 2 columns
    let x = [ [ 0, 1 ], [ 2, 3 ], [ 4, 5 ] ];
 
    // Print each array element value
    // Traverse row
    for (let i = 0; i < 3; i++)
    {
 
        // Traverse column
        for (let j = 0; j < 2; j++)
        {
 
            // Print element
            process.stdout.write("Element at x[" +  i +
                             "][" +  j + "]: ");
            console.log(x[i][j]);
        }
    }

Output
Element at x[0][0]: 0
Element at x[0][1]: 1
Element at x[1][0]: 2
Element at x[1][1]: 3
Element at x[2][0]: 4
Element at x[2][1]: 5

Map:

A map is an associative container that stores elements in a mapped fashion. Each element has a key value and a mapped value. No two mapped values can have equal key values.

The diagrammatic representation of Map is given below:


 Program 1:
Below is an illustration of a map: 

C++ 
// C++ program to illustrate Map
#include <bits/stdc++.h>
using namespace std;

// Driver Code
int main()
{
    // Empty map container
    map<int, int> gquiz1;

    // Insert elements in Map
    gquiz1.insert(pair<int, int>(1, 40));
    gquiz1.insert(pair<int, int>(2, 30));
    gquiz1.insert(pair<int, int>(3, 60));

    // Iterator to iterate Map
    map<int, int>::iterator itr;

    cout << "\nThe map gquiz1 is : \n";
    cout << "\tKEY\tELEMENT\n";

    // Print map gquiz1
    for (itr = gquiz1.begin();
         itr != gquiz1.end(); ++itr) {
        cout << '\t' << itr->first
             << '\t' << itr->second
             << '\n';
    }
    return 0;
}
Java 
// Java program to illustrate Map
import java.util.*;
class GFG{

// Driver Code
public static void main(String[] args)
{
    // Empty map container
    HashMap<Integer,
            Integer> gquiz1 = new HashMap<Integer,
                                          Integer>();

    // Insert elements in Map
    gquiz1.put(1, 40);
    gquiz1.put(2, 30);
    gquiz1.put(3, 60);

    // Iterator to iterate Map
    Iterator<Map.Entry<Integer, 
                       Integer>> itr = gquiz1.entrySet().
                                              iterator();

    System.out.print("\nThe map gquiz1 is : \n");
    System.out.print("KEY\tELEMENT\n");

    // Print map gquiz1
    while(itr.hasNext()) 
    {
        Map.Entry<Integer, 
                  Integer> entry = itr.next();
        System.out.print('\t' + entry.getKey()
                         + "\t" + entry.getValue()+ "\n");
    }
}
}

// This code is contributed by shikhasingrajput
Python3 
# Python3 program to illustrate Map

# Driver Code
if __name__ == '__main__':
    
    # Empty map container
    gquiz1 = dict()

    # Insert elements in Map
    gquiz1[1] = 40
    gquiz1[2] = 30
    gquiz1[3] = 60

    print("\nThe map gquiz1 is : ")
    print("KEY\tELEMENT")

    for x, y in gquiz1.items():
        print(x, "\t", y)

# This code is contributed by Rajput-Ji
C# 
// C# program to illustrate Map
using System;
using System.Collections.Generic;

class GFG{

// Driver Code
public static void Main(String[] args)
{
    
    // Empty map container
    Dictionary<int,
               int> gquiz1 = new Dictionary<int,
                                            int>();
                                            
    // Insert elements in Map
    gquiz1.Add(1, 40);
    gquiz1.Add(2, 30);
    gquiz1.Add(3, 60);
    
    Console.Write("\nThe map gquiz1 is : \n");
    Console.Write("\tKEY\tELEMENT\n");
    
    // Print map gquiz1
    foreach(KeyValuePair<int, 
                         int> entry in gquiz1)
    {
        Console.Write("\t" + entry.Key + 
                      "\t" + entry.Value + "\n");
    }
}
}

// This code is contributed by Amit Katiyar
JavaScript 
// JavaScript program to illustrate Map
let gquiz1 = new Map();

// Insert elements in Map
gquiz1.set(1, 40);
gquiz1.set(2, 30);
gquiz1.set(3, 60);

// Iterator to iterate Map
let itr;

console.log("\nThe map gquiz1 is : \n");
console.log("\tKEY\tELEMENT\n");

// Print map gquiz1
for (itr of gquiz1.entries()) {
    console.log(`\t${itr[0]}\t${itr[1]}\n`);
}

// This code is contributed by akashish__

Output
The map gquiz1 is : 
    KEY    ELEMENT
    1    40
    2    30
    3    60

Program 2:
Below is an illustration of an unordered map:

C++ 
// C++ program to illustrate Map
#include <bits/stdc++.h>
using namespace std;

// Driver Code
int main()
{
    // Declaring umap of <string, int>
    // type key will be of string and
    // mapped value will be of double
    unordered_map<string, int> umap;

    // Insert values by using [] operator
    umap["GeeksforGeeks"] = 10;
    umap["Practice"] = 20;
    umap["Contribute"] = 30;

    // Traversing an unordered map
    // and print the key-value pairs
    for (auto x : umap)
        cout << x.first << " "
             << x.second << endl;
    return 0;
}
Java 
// Java program to illustrate Map
import java.util.*;

class GFG{

// Driver Code
public static void main(String[] args)
{
    
    // Declaring umap of <String, int>
    // type key will be of String and
    // mapped value will be of double
    HashMap<String, 
            Integer> umap = new HashMap<>();

    // Insert values by using [] operator
    umap.put("GeeksforGeeks", 10);
    umap.put("Practice", 20);
    umap.put("Contribute", 30);

    // Traversing an unordered map
    // and print the key-value pairs
    for(Map.Entry<String,
                  Integer> x : umap.entrySet())
        System.out.print(x.getKey() + " " +
                         x.getValue() + "\n");
}
}

// This code is contributed by amal kumar choubey
Python3 
class GFG :
  
    # Driver Code
    @staticmethod
    def main( args) :
      
        # Declaring umap of <String, int>
        # type key will be of String and
        # mapped value will be of double
        umap =  dict()
        
        # Insert values by using [] operator
        umap["GeeksforGeeks"] = 10
        umap["Practice"] = 20
        umap["Contribute"] = 30
        
        # Traversing an unordered map
        # and print the key-value pairs
        for key,value in umap.items() :
            print(key + " " + str(umap.get(key)) + "\n", end ="")
    
if __name__=="__main__":
    GFG.main([])
    
    # This code is contributed by aadityaburujwale.
C# 
// C# program to illustrate Map
using System;
using System.Collections.Generic;
class GFG{

    // Driver Code
    public static void Main(String[] args)
    {

        // Declaring umap of <String, int>
        // type key will be of String and
        // mapped value will be of double
        Dictionary<String, int> umap = new Dictionary<String, 
                                                      int>();

        // Insert values by using [] operator
          umap.Add("Contribute", 30);
        umap.Add("GeeksforGeeks", 10);
        umap.Add("Practice", 20);        

        // Traversing an unordered map
        // and print the key-value pairs
        foreach(KeyValuePair<String, int> x in umap)
            Console.Write(x.Key + " " + x.Value + "\n");
    }
}

// This code is contributed by Rajput-Ji
JavaScript 
// Declaring a Map with string keys and integer values
let umap = new Map();

// Inserting key-value pairs
umap.set("GeeksforGeeks", 10);
umap.set("Practice", 20);
umap.set("Contribute", 30);

// Traversing the Map and printing key-value pairs
for (let [key, value] of umap) {
  console.log(key + " " + value);
}

Output
Contribute 30
GeeksforGeeks 10
Practice 20

Program 3:
Below is an illustration of a multimap:

C++ 
// C++ program to illustrate Multimap
#include <bits/stdc++.h>
using namespace std;

// Driver Code
int main()
{
    // Empty multimap container
    multimap<int, int> gquiz1;

    // Insert elements
    gquiz1.insert(pair<int, int>(1, 40));
    gquiz1.insert(pair<int, int>(2, 30));

    // Iterator
    multimap<int, int>::iterator itr;

    cout << "\nThe multimap gquiz1 is : \n";
    cout << "\tKEY\tELEMENT\n";

    // Print multimap gquiz1
    for (itr = gquiz1.begin();
         itr != gquiz1.end(); ++itr) {

        cout << '\t' << itr->first
             << '\t' << itr->second
             << '\n';
    }
    return 0;
}
Java 
import java.util.*;

public class Main {
    public static void main(String[] args) {
        // Empty multimap container
        Map<Integer, Integer> gquiz1 = new TreeMap<>();

        // Insert elements
        gquiz1.put(1, 40);
        gquiz1.put(2, 30);

        // Iterator
        Iterator<Map.Entry<Integer, Integer>> itr = gquiz1.entrySet().iterator();

        System.out.println("The multimap gquiz1 is : ");
        System.out.println("\tKEY\tELEMENT");

        // Print multimap gquiz1
        while (itr.hasNext()) {
            Map.Entry<Integer, Integer> entry = itr.next();
            System.out.println("\t" + entry.getKey() + "\t" + entry.getValue());
        }
    }
}
Python3 
# Python Program to illustrate Multimap

# Empty multimap container
gquiz1 = {}

# Insert elements
gquiz1[1] = 40
gquiz1[2] = 30

# Iterator
itr = gquiz1.items()

print("\nThe multimap gquiz1 is : ")
print("\tKEY\tELEMENT")

# Print multimap gquiz1
for (key, value) in itr:
    print('\t', key, '\t', value)
    
# This code is contributed by akashish__
C# 
// C# program to illustrate Multimap
using System;
using System.Collections.Generic;

public class GFG 
{

  // Driver Code
  public static void Main()
  {

    // Empty multimap container
    SortedDictionary<int, int> gquiz1
      = new SortedDictionary<int, int>();

    // Insert elements
    gquiz1.Add(1, 40);
    gquiz1.Add(2, 30);

    // Iterator
    SortedDictionary<int, int>.Enumerator itr;

    Console.WriteLine("\nThe multimap gquiz1 is : ");
    Console.WriteLine("\tKEY\tELEMENT");

    // Print multimap gquiz1
    for (itr = gquiz1.GetEnumerator();
         itr.MoveNext();) {

      Console.WriteLine("\t{0}\t{1}", itr.Current.Key,
                        itr.Current.Value);
    }
  }
}
JavaScript 
// JavaScript Program to illustrate Multimap

// Empty multimap container
let gquiz1 = {};

// Insert elements
gquiz1[1] = 40;
gquiz1[2] = 30;

// Iterator
let itr = Object.entries(gquiz1);

console.log("\nThe multimap gquiz1 is : ");
console.log("\tKEY\tELEMENT");

// Print multimap gquiz1
for (let [key, value] of itr) {
    console.log('\t', key, '\t', value);
}

// This code is contributed by akashish__

Output
The multimap gquiz1 is : 
    KEY    ELEMENT
    1    40
    2    30

Program 4:
Below is an illustration of an unordered multimap:

C++ 
// C++ program to illustrate
// unordered multimap
#include <bits/stdc++.h>
using namespace std;

// Driver Code
int main()
{
    // Empty initialization
    unordered_multimap<string, int> umm1;

    // Initialization by initializer list
    unordered_multimap<string, int> umm2(
        { { "apple", 1 },
          { "ball", 2 },
          { "apple", 10 },
          { "cat", 7 },
          { "dog", 9 },
          { "cat", 6 },
          { "apple", 1 } });

    // Traversing an unordered_multimap
    // and print the elements stored
    for (auto x : umm2) {
        cout << x.first << " "
             << x.second << endl;
    }
    return 0;
}
Java 
import java.util.*;

public class Main {
    public static void main(String[] args)
    {
        // Initialization by initializer list
        HashMap<String, ArrayList<Integer> >
            umm2 = new HashMap<>() {
                {
                    put("apple",
                        new ArrayList<>(
                            Arrays.asList(1, 10, 1)));
                    put("ball",
                        new ArrayList<>(
                            Collections.singletonList(2)));
                    put("cat", new ArrayList<>(
                                   Arrays.asList(7, 6)));
                    put("dog",
                        new ArrayList<>(
                            Collections.singletonList(9)));
                }
            };

        // Traversing the hashmap and print the elements
        // stored
        for (Map.Entry<String, ArrayList<Integer> > entry :
             umm2.entrySet()) {
            String key = entry.getKey();
            ArrayList<Integer> values = entry.getValue();
            for (int value : values) {
                System.out.println(key + " " + value);
            }
        }
    }
}
Python3 
from collections import defaultdict

# Initializing a defaultdict with 
# lists as default values
GFG = defaultdict(list)

# Adding key-value pairs to the defaultdict
GFG["apple"] = [1, 10, 1]
GFG["ball"] = [2]
GFG["cat"] = [7, 6]
GFG["dog"] = [9]

# Traversing the defaultdict and 
# printing the elements stored
for key, values in GFG.items():
    for value in values:
        print(key, value)
C# 
using System;
using System.Collections.Generic;

class Program {
    static void Main(string[] args)
    {
        // Initialization by initializer list
        var umm2
            = new SortedDictionary<string, List<int> >() {
                  { "apple", new List<int>(){ 1, 10, 1 } },
                      { "ball", new List<int>(){ 2 } },
                      { "cat", new List<int>(){ 7, 6 } },
                  {
                      "dog", new List<int>() { 9 }
                  }
              };

        // Traversing the sorted dictionary and print the
        // elements stored
        foreach(
            KeyValuePair<string, List<int> > entry in umm2)
        {
            string key = entry.Key;
            List<int> values = entry.Value;
            foreach(int value in values)
            {
                Console.WriteLine(key + " " + value);
            }
        }
    }
}
// This code is contributed by sarojmcy2e
JavaScript 
// Javascript code addition 

// Initialization of the HashMap
const umm2 = new Map([
  ["apple", [1, 10, 1]],
  ["ball", [2]],
  ["cat", [7, 6]],
  ["dog", [9]]
]);

// Traversing the hashmap and print the elements stored
for (let [key, values] of umm2) {
  values.forEach(value => {
    console.log(key + " " + value);
  });
}

// The code is contributed by Nidhi goel.

Output
apple 1
apple 10
apple 1
ball 2
cat 6
cat 7
dog 9

Difference between Array and Map

ArrayMap
An Array is a collection of elements of the same data type.The map is a hashed structure of key and value pairs.
The indices of the list are integers starting from 0.The keys of the Map can be of any data type.
The elements are accessed via indices.The elements are accessed via key-values.
The order of the elements entered is maintained.There is no guarantee for maintaining order.
The array can be 1D, 2D or multidimensionalMaps can be multimap, Unordered Multimap, Unordered map, etc
Array’s size must be specified during the array declaration.The map’s size is dynamic.

Next Article
Is there any difference between int[] a and int a[] in Java?

S
spp____
Improve
Article Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox