What is Collections and What are the different collections in Apex?

Collections in Salesforce:

What are the different types of collections in Apex? What are maps in Apex?

Collections are the type of variables which can be used to store multiple number of records (data).

It is useful because Governor Limits restrict the number of records you can retrieve per transaction. Hence, collections can be used to store multiple records in a single variable defined as type collection and by retrieving data in the form of collections, Governor Limits will be in check. Collections are similar to how arrays work.

There are 3 collection types in Salesforce:

• Lists
• Maps
• Sets

Maps are used to store data in the form of key-value pairs, where each unique key maps to a single value. 
Syntax: Map<String, String> country_city = new Map<String, String>();

List:

• List is a collection of elements, Such as primitive data types (String, Integer, Date, etc), user defined objects, sObjects, Apex objects or other collections (can be multidimensional up to 5 levels).
• List allows duplicate values.
• List index position starts from zero.

Set:

• Set is a collection of unique, unordered elements.
• It can contain primitive data types (String, Integer, Date, etc) or sObjects.
• Set allows unique values.

Map:

• Map is a collection of key-value pair.
• Keys can be any primitive data types (String, Integer, Date, etc) while values can include primitives, Apex objects, sObjects and other collections.
• Map allows duplicate values, but each key must be unique.

COLLECTIONS IN APEX: LIST, MAPS AND SETS

This post explains the differences between the different collections that are available in Salesforce Apex.

LIST:

A list is an ordered collection. A ordered collection is one where each element in the collection is stored in a specific position, and you could access the element using its position.

List<Integer> MyList = new List<Integer>();
MyList.add(10);
MyList.add(80);
MyList.add(50);
MyList.add(30);
MyList.add(10); //Duplicate entry

• List can have duplicate entries. The integer 10 is added twice to the list.
• List is a ordered collection, meaning that each element is stored in a specific position. An element can be accessed using its location (also called as Index). The index always starts with 0.

List can also contain SObject records, here is a sample code. Note that removing/adding a record to the list does not add it to the database. You should explicitly use the DML commands insert/upsert/delete.

List<Account> listsample = [Select Id,Name from Account limit 5];
system.debug('The Account Name at index 0 is'+listsample[0].Name);
system.debug('The size of the list is'+listsample.size());
//Adding a element to the list
listsample.add(new Account(Name='testlistsample'));
system.debug('The size of the list now is'+listsample.size());
//Remove a element from the list
listsample.remove(5);
system.debug('The size of the list now is'+listsample.size());

SET:

A set is an unordered collection. Elements in a set are not stored in a specific order and you cannot access an element using an index.

Here is a sample code:

Set<String> Accountids = new Set<String>();
for (Account a: [Select Id from Account limit 5])
    Accountids.add(a.Id);
system.debug('The size of the set is'+accountids.size());
for (Account a: [Select Id from Account limit 5])
    Accountids.add(a.Id);
system.debug('The size of the set is'+accountids.size());

MAPS:

A Map is a collection of Key Value pairs. Each key corresponds to an element. Below is a diagram which illustrates this.

A major difference between a Map and a List is traversal. In a List you will have to loop through each element to find out a specific element, whereas in a map you could fetch it directly using the key. This greatly reduces processing time.

Map<Id,Account> testmap = new Map<Id,Account>([Select Id,Name from Account limit 5]);
system.debug('The size of the map is'+testmap.size());
system.debug('The keys are'+testmap.keySet());
system.debug('The values are'+testmap.values());

What all data types can a set store?

Sets can have any of the following data types:

• Primitive types
• Collections
• sObjects
• User-defined types
• Built-in Apex types

What is Collections and What are the different collections in Apex?

The Apex supports arrays to store data. Arrays are of a fixed size which is defined during initialization of the array.

Developer typically require a data structure which is flexible in size, so that they can add and remove items from this data structure on request. To avoid that every developer has to implement his custom data structure the Apex library provide several default implementations for this via the collection.

Apex  collections are dynamic in size, e.g. a collection can contain a flexible number of objects.

More theoretical said, collection is a data structure which contains and processes a set of data. The data stored in the collection is encapsulated and the access to the data is only possible via predefined methods.

For example if your application saves data in an object of type People, you can store several People objects in a collection.

Arrays and collections are a family of data types that contain a sequence of values . It includes Lists , Arrays, Sets, and Maps.

Each collection type is different, but there are four methods you can invoke on all of them:

1. clear: Removes all elements from the collection.

2. clone: Returns a copy of the collection.

3. isEmpty: Returns false if the collection has elements, true if empty.

4. size: Returns the number of elements in the collection as an Integer.

Array

array, which stores a fixed-size sequential collection of elements of the same type. An array is used to store a collection of data, but it is often more useful to think of an array as a collection of variables of the same type.

Instead of declaring individual variables, such as number0, number1, ..., and number99, you declare one array variable such as numbers and use numbers[0], numbers[1], and ..., numbers[99] to represent individual variables.

Declaring Array Variables:

To use an array in a program, you must declare a variable to reference the array, and you must specify the type of array the variable can reference. Here is the syntax for declaring an array variable:

dataType[] arrayRefVar;   // preferred way.

EX:-

Account[] accs = new Account[]{};

Account a = new Account();

a.name = 'xxx';

accs.add(a);

System.debug(accs[0].name);

a.clear();

System.debug(accs[0].name);

List

A list is an ordered collection of typed primitives, sObjects, user-defined objects, Apex objects or collections that are distinguished by their indices.

To declare a list, use the List keyword followed by the primitive data, sObject, nested list, map, or set type within <> characters.

for reference

http://www.salesforce.com/us/developer/docs/dbcom_apex250/Content/apex_methods_system_list.htm

EX: -

// Create an empty list of String

List<String> my_list = new List<String>();

// Create a list of account records from a SOQL query

List<Account> accs = [SELECT Id, Name FROM Account LIMIT 1000];

The following are instance methods for List.

 add(Object) : Adds an element to the end of the list.

 add(Integer, Object) :Inserts an element into the list at the specified index position.

 addAll(List) : Adds all of the elements in the specified list to the list that calls the method. Both lists must be of the same type.

addAll(Set) :Add all of the elements in specified set to the list that calls the method. The set and the list must be of the same type.

clear() :Removes all elements from a list, consequently setting the list's length to zero.

clone() : Makes a duplicate copy of a list.

deepClone(Boolean, Boolean, Boolean) : Makes a duplicate copy of a list of sObject records, including the sObject records themselves.

 equals(List) : Compares this list with the specified list and returns true if both lists are equal; otherwise, returns false.

  get(Integer) : Returns the list element stored at the specified index.

 getSObjectType() : Returns the token of the sObject type that makes up a list of sObjects.

hashCode() : Returns the hashcode corresponding to this list and its contents.

isEmpty() : Returns true if the list has zero elements.

 iterator() : Returns an instance of an iterator for this list.

remove(Integer) : Removes the list element stored at the specified index, returning the element that was removed.

set(Integer, Object) : Sets the specified value for the element at the given index.

size() : Returns the number of elements in the list.

 sort() : Sorts the items in the list in ascending order.

public class arrayListTest {

       

       //creating List

      List<String> nameList = new List<String>();

       public void addElementsList(){

       //Adding string objects to List

       nameList.add('Jwalant');

       nameList.add('Hiren');

       nameList.add('Piyush');

       nameList.add('Yogesh');

       nameList.add('Dharmendra');

       nameList.add('Piyush');

     

system.debug(‘List size is-->’+ nameList.size());

       //iterating over list

       for(String name : nameList){

           System.debug('List Elements is-->'+name);

       }

   }

   

}

addAll method Example

public class arrayListAddAllTest {

    public static void addAlltest() {

       

       //creating List

       List<String> firstList = new List<String>();

       

       //Adding string objects to first List

       firstList.add('Jwalant');

       firstList.add('Hiren');

       firstList.add('Piyush');

     

system.debug(‘ First List size is-->’+ firstList.size());

       //creating ArrayList

       List<String> secondList = new List<String>();

       

       //Adding string objects to second List

       secondList.add('Yogesh');

       secondList.add('Dharmendra');

       secondList.add('Piyush');

       

       //add all objects of first list to second list.

       secondList.addAll(firstList);

       

       //iterating over second arraylist

       for(String name : secondList){

           System.debug('Second List Details is-->'+name);

       }

    }

    public static void removeTest() {

       

       //creating List

       List<String> firstList = new List<String>();

       

       //Adding string objects to first List

       firstList.add('Jwalant');

       firstList.add('Hiren');

       firstList.add('Piyush');

       

       firstList.remove(2); //remove 2nd position value.

       

       //iterating over second list

       for(String name : firstList){

           System.debug(name);

       }

    }

       

}

Set

A set is an unordered collection of elements that do not contain any duplicates. Set elements can be of any data type—primitive types, collections, sObjects, user-defined types and built-in Apex types.

 To declare a set, use the Set keyword followed by the primitive data type name within <> characters. For example:

new Set<String>()

The following are ways to declare and populate a set:

for reference

http://www.salesforce.com/us/developer/docs/dbcom_apex250/Content/apex_methods_system_set.htm

Set<String> s1 = new Set<String>{'a', 'b + c'}; // Defines a new set with two elements

Set<String> s2 = new Set<String>(s1); // Defines a new set that contains the

// elements of the set   created in the previous step

The following are instance methods for Set.

  add(Object) : Adds an element to the set if it is not already present.

addAll(List<Object>) : Adds all of the elements in the specified list to the set if they are not already present.

addAll(Set<Object>) : Adds all of the elements in the specified set to the set that calls the method if they are not already present.

 clear() : Removes all of the elements from the set

 clone() : Makes a duplicate copy of the set.

 contains(Object) : Returns true if the set contains the specified element.

containsAll(List<Object>) : Returns true if the set contains all of the elements in the specified list. The list must be of the same type as the set that calls the method.

containsAll(Set<Object>) : Returns true if the set contains all of the elements in the specified set. The specified set must be of the same type as the original set that calls the method.

equals(Set<Object>) : Compares this set with the specified set and returns true if both sets are equal; otherwise, returns false.

  hashCode() : Returns the hashcode corresponding to this set and its contents.

 isEmpty() : Returns true if the set has zero elements.

 remove(Object) : Removes the specified element from the set if it is present.

removeAll(List<Object>) : Removes the elements in the specified list from the set if they are present.

removeAll(Set<Object>) : Removes the elements in the specified set from the original set if they are present.

retainAll(List<Object>) : Retains only the elements in this set that are contained in the specified list.

retainAll(Set) : Retains only the elements in the original set that are contained in the specified set.

 size() : Returns the number of elements in the set (its cardinality).

public class SetExample {

 public static void setAdd() {

       

       Set<String> countries = new Set<String>();

       

       boolean result = false;

       result = countries.add('USA');

       System.debug('USA Added '+result);

       

       result = countries.add('CANADA');

       System.debug('CANADA Added '+result);

       

       result = countries.add('U.K.');

       System.debug('U.K. Added '+result);

       

       result = countries.add('INDIA');

       System.debug('INDIA Added '+result);

       

       result = countries.add('CANADA');

       System.debug('CANADA Added '+result);

       

       System.debug('Size of set '+countries.size());

       for(String country : countries) {

           System.debug('Country: '+country);

       }

 }

}

Map

A map is a collection of key-value pairs where each unique key maps to a single value. Keys and values can be any data type—primitive types, collections, sObjects, user-defined types, and built-in Apex types.

 To declare a map, use the Map keyword followed by the data types of the key and the value within <> characters.

Map<String, String> country_currencies = new Map<String, String>();

Map<ID, Set<String>> m = new Map<ID, Set<String>>();

clear() : Removes all of the key-value mappings from the map.

clone() : Makes a duplicate copy of the map.

containsKey(Object) : Returns true if the map contains a mapping for the specified key.

deepClone() : Makes a duplicate copy of a map, including sObject records if this is a map with sObject record values.

equals(Map) : Compares this map with the specified map and returns true if both maps are equal; otherwise, returns false.

get(Object) : Returns the value to which the specified key is mapped, or null if the map contains no value for this key.

getSObjectType() : Returns the token of the sObject type that makes up the map values.

hashCode() : Returns the hashcode corresponding to this map.

isEmpty() : Returns true if the map has zero key-value pairs.

 keySet() : Returns a set that contains all of the keys in the map.

put(Object, Object) : Associates the specified value with the specified key in the map.

putAll(Map) : Copies all of the mappings from the specified map to the original map.

putAll(sObject[]) : Adds the list of sObject records to a map declared as Map<ID, sObject> or Map<String, sObject>.

remove(Key) : Removes the mapping for the specified key from the map, if present, and returns the corresponding value.

size() : Returns the number of key-value pairs in the map.

values() : Returns a list that contains all of the values in the map in arbitrary order.

 public class MapExample {

public static void mapPut(){

       

    Map<String,String> currencyMap = new Map<String,String>();

    currencyMap.put('USA', 'USD');

    currencyMap.put('CANADA', 'CAD');

    currencyMap.put('Uniter Kingdom', 'GBP');

       

    for(String key : currencyMap.keySet()) {

    System.debug('Country: '+key+' Currency: '+currencyMap.get(key));

    }

 }

 public static void getMapElements() {

       

    Map<String,String> currencyMap = new Map<String,String>();

    currencyMap.put('USA', 'USD');

    currencyMap.put('CANADA', 'CAD');

    currencyMap.put('Uniter Kingdom', 'GBP');

       

    for(String key : currencyMap.keySet()) {

    System.debug('Country: '+key+' Currency: '+currencyMap.get(key));

    }

 }

    public static void containsKeyTest() {

       

    Map<String,String> currencyMap = new Map<String,String>();

    currencyMap.put('USA', 'USD');

    currencyMap.put('CANADA', 'CAD');

    currencyMap.put('Uniter Kingdom', 'GBP');

       

    System.debug('Contains USA? : '+currencyMap.containsKey('USA'));     

    System.debug('Contains America?: '+currencyMap.containsKey('America'));

 }

 public static void keysetTest() {

       

    Map<String,String> currencyMap = new Map<String,String>();

    currencyMap.put('USA', 'USD');

    currencyMap.put('CANADA', 'CAD');

    currencyMap.put('Uniter Kingdom', 'GBP');

       

    for(String key : currencyMap.keySet()) {

       System.debug('Country : '+key+' has currency : '+currencyMap.get(key));

    }

 }

  

}