Difference between Array and Map
Last Updated :
18 Sep, 2023
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 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 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# 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 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]);
}
}
OutputElement 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 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 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# 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 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__
OutputThe 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 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
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# 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
// 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);
}
OutputContribute 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;
}
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());
}
}
}
# 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# 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 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__
OutputThe 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;
}
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);
}
}
}
}
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)
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 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.
Outputapple 1
apple 10
apple 1
ball 2
cat 6
cat 7
dog 9
Difference between Array and Map
|
| 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 multidimensional | Maps can be multimap, Unordered Multimap, Unordered map, etc |
| Array’s size must be specified during the array declaration. | The map’s size is dynamic. |
Similar Reads
Difference between Stack and Array
Stack: A stack is a linear data structure in which elements can be inserted and deleted only from one side of the list, called the top. A stack follows the LIFO (Last In First Out) principle, i.e., the element inserted at the last is the first element to come out. The insertion of an element into a
3 min read
Difference between Arrays and Pointers
The array and pointers are derived data types that have lots of differences and similarities. In some cases, we can even use pointers in place of an array, and arrays automatically get converted to pointers when passed to a function. So, it is necessary to know about the differences between arrays a
7 min read
Difference between Array, Queue and Stack
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
3 min read
Difference between an array and a tree
Array:An array is a collection of homogeneous(same type) data items stored in contiguous memory locations. For example, if an array is of type “intâ€, it can only store integer elements and cannot allow the elements of other types such as double, float, char, etc. The array is a linear data structure
3 min read
Difference between Array and Union in C
1. Array in C : An array is collection of similar data items accessed by a common name stored at continuous memory locations. The elements of an array can be accessed using indices. They can be used to store primitive data types such as int, float, double, char, etc. but all elements have to be of t
2 min read
Swift - Difference Between Sets and Arrays
An array is a linear data structure which has contiguous memory in a single variable that can store N number of elements. For example, if we want to take 10 inputs from the user we can’t initialise 10 variables. In this case you can make use of arrays. It can store N number of elements into a single
3 min read
Difference between Array and String in Java
An array is a collection of similar type of elements that are stored in a contiguous memory location. Arrays can contain primitives(int, char, etc) as well as object(non-primitives) references of a class depending upon the definition of the array. In the case of primitive data type, the actual value
5 min read
Difference between List and Array in Python
In Python, lists and arrays are the data structures that are used to store multiple items. They both support the indexing of elements to access them, slicing, and iterating over the elements. In this article, we will see the difference between the two. Operations Difference in Lists and ArraysAccess
6 min read
Difference Between JavaScript Arrays and Objects
Below are the main differences between a JavaScript Array and Object. FeatureJavaScript ArraysJavaScript ObjectsIndex TypeNumeric indexes (0, 1, 2, ...)Named keys (strings or symbols)OrderOrdered collectionUnordered collectionUse CaseStoring lists, sequences, ordered dataStoring data with key-value
1 min read
Difference between List and ArrayList in Java
A Collection is a group of individual objects represented as a single unit. Java provides a Collection Framework which defines several classes and interfaces to represent a group of objects as a single unit This framework consists of the List Interface as well as the ArrayList class. In this article
4 min read