Represents a collection of unique elements with no duplicate
values.

The Set methods work on a set, that
is, an unordered collection of elements that was initialized using
the `set` keyword. Set elements
can be of any data type—primitive types, collections, sObjects,
user-defined types, and built-in Apex types. Set methods are all instance methods, that is, they
all operate on a particular instance of a Set. The following are the
instance methods for sets.

For more information on sets, see Sets.

The following are constructors for `Set`.

Creates a new instance of the `Set` class. A set can hold elements of any data type T.

`public Set<T>()`

// Create a set of strings Set<String> s1 = new Set<String>(); // Add two strings to it s1.add('item1'); s1.add('item2');

Creates a new instance of the `Set` class by copying the elements of the specified set.
T is the data type of the elements in both sets and can be any data
type.

`public Set<T>(Set<T> setToCopy)`

`setToCopy`- Type: Set<T>
- The set to initialize this set with.

Set<String> s1 = new Set<String>(); s1.add('item1'); s1.add('item2'); Set<String> s2 = new Set<String>(s1); // The set elements in s2 are copied from s1 System.debug(s2);

Creates a new instance of the `Set` class by coping the list elements. T is the data type
of the elements in the set and list and can be any data type.

`public Set<T>(List<T> listToCopy)`

`listToCopy`- Type: Integer
- The list to copy the elements of into this set.

List<Integer> ls = new List<Integer>(); ls.add(1); ls.add(2); // Create a set based on a list Set<Integer> s1 = new Set<Integer>(ls); // Elements are copied from the list to this set System.debug(s1);// DEBUG|{1, 2}

The following are methods for `Set`. All are instance methods.

Adds an element to the set if it is not already present.

`public Boolean add(Object setElement)`

`setElement`- Type: Object

Type: Boolean

This method returns true
if the original set changed as a result of the call. For example:

set<string> myString = new Set<String>{'a', 'b', 'c'}; Boolean result; result = myString.add('d'); system.assertEquals(result, true);

Adds all of the elements in the specified list to the set
if they are not already present.

`public Boolean addAll(List<Object> fromList)`

`fromList`- Type: List

This method results in the *union* of the list and the set. The list must be of the same type
as the set that calls the method.

Adds all of the elements in the specified set to the set
that calls the method if they are not already present.

`public Boolean addAll(Set<Object> fromSet)`

`fromSet`- Type: Set<Object>

Type: Boolean

This method returns `true` if the original set changed as a result of the call.

This method results in the *union* of the two sets. The specified set must be of the same
type as the original set that calls the method.

set<string> myString = new Set<String>{'a', 'b'}; set<string> sString = new Set<String>{'c'}; Boolean result1; result1 = myString.addAll(sString); system.assertEquals(result1, true);

Removes all of the elements from the set.

`public Void clear()`

Type: Void

Makes a duplicate copy of the set.

`public Set<Object> clone()`

Type: Set (of same type)

Returns `true` if
the set contains the specified element.

`public Boolean contains(Object setElement)`

`setElement`- Type: Object

Type: Boolean

set<string> myString = new Set<String>{'a', 'b'}; Boolean result; result = myString.contains('z'); system.assertEquals(result, false);

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.

`public Boolean containsAll(Set<Object> setToCompare)`

`setToCompare`- Type: Set<Object>

Type: Boolean

set<string> myString = new Set<String>{'a', 'b'}; set<string> sString = new Set<String>{'c'}; set<string> rString = new Set<String>{'a', 'b', 'c'}; Boolean result1, result2; result1 = myString.addAll(sString); system.assertEquals(result1, true); result2 = myString.containsAll(rString); system.assertEquals(result2, true);

Compares this set with the specified set and returns `true` if both sets are equal; otherwise,
returns `false`.

`public Boolean equals(Set<Object> set2)`

`set2`- Type: Set<Object>
- The
`set2`argument is the set to compare this set with.

Type: Boolean

Two sets are equal if their
elements are equal, regardless of their order. The `==` operator is used to compare the
elements of the sets.

The `==` operator is equivalent to calling the `equals` method, so you can call `set1.equals(set2);` instead of `set1 == set2;`.

Returns the hashcode corresponding to this set and its
contents.

`public Integer hashCode()`

Type: Integer

Returns `true` if
the set has zero elements.

`public Boolean isEmpty()`

Type: Boolean

Set<integer> mySet = new Set<integer>(); Boolean result; result = mySet.isEmpty(); system.assertEquals(result, true);

Removes the specified element from the set if it is present.

`public Boolean remove(Object setElement)`

`setElement`- Type: Object

Removes the elements in the specified list from the set
if they are present.

`public Boolean removeAll(List<Object> listOfElementsToRemove)`

`listOfElementsToRemove`- Type: List<Object>

This method results in the relative complement of the two sets. The list must be of the same type as the set that calls the method.

Set<integer> mySet = new Set<integer>{1, 2, 3}; List<integer> myList = new List<integer>{1, 3}; Boolean result = mySet.removeAll(myList); System.assertEquals(result, true); Integer result2 = mySet.size(); System.assertEquals(result2, 1);

Removes the elements in the specified set from the original
set if they are present.

`public Boolean removeAll(Set<Object> setOfElementsToRemove)`

`setOfElementsToRemove`- Type: Set<Object>

Type: Boolean

This method returns `true` if the original set changed as a result of the call.

This method results in the relative complement of the two sets. The specified set must be of the same type as the original set that calls the method.

Retains only the elements in this set that are contained
in the specified list.

`public Boolean retainAll(List<Object> listOfElementsToRetain)`

`listOfElementsToRetain`- Type: List<Object>

Type: Boolean

This method returns `true` if the original set changed as a result of the call.

This method results in the *intersection* of the list and the set. The list must be of the
same type as the set that calls the method.

Set<integer> mySet = new Set<integer>{1, 2, 3}; List<integer> myList = new List<integer>{1, 3}; Boolean result = mySet.retainAll(myList); System.assertEquals(result, true);

Retains only the elements in the original set that are
contained in the specified set.

`public Boolean retainAll(Set setOfElementsToRetain)`

`setOfElementsToRetain`- Type: Set

This method results in the *intersection* of the two sets. The specified set must be of the
same type as the original set that calls the method.

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

`public Integer size()`

Type: Integer

Set<integer> mySet = new Set<integer>{1, 2, 3}; List<integer> myList = new List<integer>{1, 3}; Boolean result = mySet.retainAll(myList); System.assertEquals(result, true); Integer result2 = mySet.size(); System.assertEquals(result2, 2);