Admin: 1 версия

2010-06-01T05:04:55Z

1 версия

в 17:44, 31 мая 2010

2010-05-31T17:44:27Z

Новая страница

== Adding Another Collection with the addAll() method: public boolean addAll(Collection c) ==

Each element in the collection passed in will be added to the set via the equivalent
of calling the add() method on each element.
If the underlying set changes, true is returned.
If no elements are added, false is returned.



<source lang="java">
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public class MainClass {
public static void main(String[] a) {
String elements[] = { "A", "B", "C", "D", "E" };
Set set = new HashSet(Arrays.asList(elements));
elements = new String[] { "E", "F" };
set.addAll(Arrays.asList(elements));
System.out.println(set);
}
}</source>



<pre class=codeResult>[D, A, F, C, B, E]</pre>

== Adding Single Elements: the add() method ==

To modify an element in a set, you should remove it, modify it, and then re-add it.



<source lang="java">
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public class MainClass {
public static void main(String[] a) {
String elements[] = { "A", "B", "C", "D", "E" };
Set set = new HashSet(Arrays.asList(elements));
set.add("Z");
System.out.println(set);
}
}</source>



<pre class=codeResult>[Z, D, A, C, B, E]</pre>

== An easy way to initialize a set without manually adding each element ==



<source lang="java">
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public class MainClass {
public static void main(String[] a) {
String elements[] = { "A", "B", "C", "D", "E" };
Set set = new HashSet(Arrays.asList(elements));
System.out.println(set);
}
}</source>



<pre class=codeResult>[D, A, C, B, E]</pre>

== Check if a particular element exists in HashSet ==



<source lang="java">
import java.util.HashSet;
public class Main {
public static void main(String[] args) {
HashSet<Integer> hSet = new HashSet<Integer>();
hSet.add(new Integer("1"));
hSet.add(new Integer("2"));
hSet.add(new Integer("3"));
System.out.println(hSet.contains(new Integer("3")));
}
}</source>



== Checking for Existence: the contains() method reports if a specific element is within the set ==



<source lang="java">
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public class MainClass {
public static void main(String[] a) {
String elements[] = { "A", "B", "C", "D", "E" };
Set set = new HashSet(Arrays.asList(elements));
System.out.println(set.contains("A"));
}
}</source>



<pre class=codeResult>true</pre>

== Checking for no elements in the set: use the isEmpty() method instead ==



<source lang="java">
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public class MainClass {
public static void main(String[] a) {
String elements[] = { "A", "B", "C", "D", "E" };
Set set = new HashSet(Arrays.asList(elements));
System.out.println(set.isEmpty());
}
}</source>



<pre class=codeResult>false</pre>

== Convert array to Set ==



<source lang="java">
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
public class Main {
public static void main(String[] args) {
Integer[] numbers = { 7, 7, 8, 9, 10, 8, 8, 9, 6, 5, 4 };
List<Integer> list = Arrays.asList(numbers);
Set<Integer> set = new HashSet<Integer>(list);
for (Iterator iterator = set.iterator(); iterator.hasNext();) {
Object o = iterator.next();
System.out.print(o + ", ");
}
}
}</source>



== Converting elements in a set to Array: public Object[] toArray() ==

The first toArray() method will return an Object array containing all the elements in the collection.



<source lang="java">
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public class MainClass {
public static void main(String[] a) {
String elements[] = { "A", "B", "C", "D", "E" };
Set set = new HashSet(Arrays.asList(elements));
Object[] arrObj = set.toArray();
for (int i = 0; i < arrObj.length; i++) {
System.out.println(arrObj[i]);
}
System.out.println(set);
}
}</source>



<pre class=codeResult>D
A
C
B
E
[D, A, C, B, E]</pre>

== Copy all elements of HashSet to an Object Array ==



<source lang="java">
import java.util.HashSet;
public class Main {
public static void main(String[] args) {
HashSet<Integer> hSet = new HashSet<Integer>();
hSet.add(new Integer("1"));
hSet.add(new Integer("2"));
hSet.add(new Integer("3"));
Object[] objArray = hSet.toArray();
for (Object obj : objArray)
System.out.println(obj);
}
}</source>



== Copying and Cloning Sets: public Object clone() ==

Calling the clone() method of a HashSet creates a shallow copy of that HashSet.
(the elements of the set aren"t duplicated. Both sets will refer to the same elements.



<source lang="java">
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public class MainClass {
public static void main(String[] a) {
String elements[] = { "A", "B", "C", "D", "E" };
Set set = new HashSet(Arrays.asList(elements));
Set set2 = ((Set) ((HashSet) set).clone());
System.out.println(set2);
}
}</source>



<pre class=codeResult>[D, A, C, B, E]</pre>

== Create unique lists of items? ==



<source lang="java">
import java.util.HashSet;
import java.util.Set;
public class MainClass {
public static void main(String args[]) {
String[] name1 = { "Amy", "Jose", "Jeremy", "Alice", "Patrick" };
String[] name2 = { "Alan", "Amy", "Jeremy", "Helen", "Alexi" };
String[] name3 = { "Adel", "Aaron", "Amy", "James", "Alice" };
Set<String> letter = new HashSet<String>();
for (int i = 0; i < name1.length; i++)
letter.add(name1[i]);
for (int j = 0; j < name2.length; j++)
letter.add(name2[j]);
for (int k = 0; k < name3.length; k++)
letter.add(name3[k]);
System.out.println(letter.size() + " letters must be sent to: " + letter);
}
}</source>



<pre class=codeResult>11 letters must be sent to: [Patrick, Amy, Jeremy, Adel, Alexi, Aaron, Jose, Alice, James, Helen, Alan]</pre>

== Creating a HashSet ==

The HashSet class provides four constructors broken into two sets. The first three constructors
create empty sets of varying sizes:



<source lang="java">
public HashSet()
public HashSet(int initialCapacity)
public HashSet(int initialCapacity, int loadFactor)</source>



If the original collection had duplicates, only one of the duplicates will be in the final created set.

== Fetching Elements: to work with all of the elements of the set ==



<source lang="java">
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class MainClass {
public static void main(String[] a) {
String elements[] = { "A", "B", "C", "D", "E" };
Set set = new HashSet(Arrays.asList(elements));
Iterator iter = set.iterator();
while (iter.hasNext()) {
System.out.println(iter.next());
}
}
}</source>



<pre class=codeResult>D
A
C
B
E</pre>

== Find maximum element of HashSet ==



<source lang="java">
import java.util.Collections;
import java.util.HashSet;
public class Main {
public static void main(String[] args) {
HashSet<Long> hashSet = new HashSet<Long>();
hashSet.add(new Long("1111111111"));
hashSet.add(new Long("2222222222"));
hashSet.add(new Long("3333333333"));
hashSet.add(new Long("4444444444"));
hashSet.add(new Long("5555555555"));
Object obj = Collections.max(hashSet);
System.out.println(obj);
}
}</source>



== Find Minimum element of HashSet ==



<source lang="java">
import java.util.Collections;
import java.util.HashSet;
public class Main {
public static void main(String[] args) {
HashSet<Long> hashSet = new HashSet<Long>();
hashSet.add(new Long("9"));
hashSet.add(new Long("4"));
hashSet.add(new Long("2"));
hashSet.add(new Long("2"));
hashSet.add(new Long("3"));
Object obj = Collections.min(hashSet);
System.out.println("Minimum Element of HashSet is : " + obj);
}
}</source>



== Get Enumeration over HashSet ==



<source lang="java">
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashSet;
public class Main {
public static void main(String[] args) {
HashSet<String> hashSet = new HashSet<String>();
hashSet.add("A");
hashSet.add("B");
hashSet.add("D");
hashSet.add("E");
hashSet.add("F");
Enumeration e = Collections.enumeration(hashSet);
while (e.hasMoreElements())
System.out.println(e.nextElement());
}
}</source>



== Get Size of HashSet ==



<source lang="java">
import java.util.HashSet;
public class Main {
public static void main(String[] args) {
HashSet<Integer> hSet = new HashSet<Integer>();
System.out.println("Size of HashSet : " + hSet.size());
hSet.add(new Integer("1"));
hSet.add(new Integer("2"));
hSet.add(new Integer("3"));
System.out.println(hSet.size());
hSet.remove(new Integer("1"));
System.out.println(hSet.size());
}
}
/*
Size of HashSet : 0
3
2
*/</source>



== Get Synchronized Set from HashSet ==



<source lang="java">
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
public class Main {
public static void main(String[] args) {
HashSet hashSet = new HashSet();
Set set = Collections.synchronizedSet(hashSet);
}
}</source>



== HashSet implements the empty Serializable interface ==

If, and only if, all of the elements of a HashSet are Serializable, HashSet can be saved to an
ObjectOutputStream and later read it in to an ObjectInputStream.



<source lang="java">
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public class MainClass {
public static void main(String[] a) throws Exception{
String elements[] = { "A", "B", "C", "D", "E" };
Set set = new HashSet(Arrays.asList(elements));

FileOutputStream fos = new FileOutputStream("set.ser");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(set);
oos.close();

FileInputStream fis = new FileInputStream("set.ser");
ObjectInputStream ois = new ObjectInputStream(fis);
Set anotherSet = (Set) ois.readObject();
ois.close();
System.out.println(anotherSet);
}
}</source>



<pre class=codeResult>[D, A, C, B, E]</pre>

== Integer value set ==



<source lang="java">
import java.util.HashSet;
public class Main {
public static void main(String[] args) {
HashSet<Integer> hSet = new HashSet<Integer>();
hSet.add(new Integer("1"));
hSet.add(new Integer("2"));
hSet.add(new Integer("3"));
System.out.println("HashSet contains.." + hSet);
}
}
//HashSet contains..[1, 2, 3]</source>



== Iterate through elements of HashSet ==



<source lang="java">
import java.util.HashSet;
import java.util.Iterator;
public class Main {
public static void main(String[] args) {
HashSet<Integer> hSet = new HashSet<Integer>();
hSet.add(new Integer("1"));
hSet.add(new Integer("2"));
hSet.add(new Integer("3"));
Iterator itr = hSet.iterator();
while (itr.hasNext())
System.out.println(itr.next());
}
}</source>



== Listing the Elements of a Collection(iterate over the elements of set or list) ==



<source lang="java">
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Main {
public static void main(String[] argv) throws Exception {
Set collection = new HashSet();
// For a set or list
for (Iterator it = collection.iterator(); it.hasNext();) {
Object element = it.next();
}
}
}</source>



== Making a Collection Read-Only ==



<source lang="java">
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Main {
public static void main(String[] argv) throws Exception {
List stuff = Arrays.asList(new String[] { "a", "b" });
List list = new ArrayList(stuff);
list = Collections.unmodifiableList(list);
try {
list.set(0, "new value");
} catch (UnsupportedOperationException e) {

}
Set set = new HashSet(stuff);
set = Collections.unmodifiableSet(set);
Map map = new HashMap();
map = Collections.unmodifiableMap(map);
}
}</source>



== public Object[] toArray(Object[] a) ==

When all elements of a collection are of the same type, it is easier for you to work with an array
of that specific type.



<source lang="java">
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public class MainClass {
public static void main(String[] a) {
String elements[] = { "A", "B", "C", "D", "E" };
Set set = new HashSet(Arrays.asList(elements));
String[] strObj = new String[set.size()];
strObj = (String[]) set.toArray(strObj);
for (int i = 0; i < strObj.length; i++) {
System.out.println(strObj[i]);
}
System.out.println(set);
}
}</source>



<pre class=codeResult>D
A
C
B
E
[D, A, C, B, E]</pre>

== Remove all elements from HashSet ==



<source lang="java">
import java.util.HashSet;
public class Main {
public static void main(String[] args) {
HashSet<Integer> hSet = new HashSet<Integer>();
hSet.add(new Integer("1"));
hSet.add(new Integer("2"));
hSet.add(new Integer("3"));
System.out.println(hSet);
hSet.clear();
System.out.println(hSet);
System.out.println(hSet.isEmpty());
}
}
/*
[1, 2, 3]
[]
true
*/</source>



== Remove specified element from HashSet ==



<source lang="java">
import java.util.HashSet;
public class Main {
public static void main(String[] args) {
HashSet<Integer> hSet = new HashSet<Integer>();
hSet.add(new Integer("1"));
hSet.add(new Integer("2"));
hSet.add(new Integer("3"));
System.out.println(hSet);
boolean blnRemoved = hSet.remove(new Integer("2"));
System.out.println(blnRemoved);
System.out.println(hSet);
}
}
/*
[1, 2, 3]
true
[1, 3]
*/</source>



== Removing All Elements: public void clear() ==

You can still get an UnsupportedOperationException thrown when working with a read-only set.



<source lang="java">
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public class MainClass {
public static void main(String[] a) {
String elements[] = { "A", "B", "C", "D", "E" };
Set set = new HashSet(Arrays.asList(elements));
elements = new String[] { "E", "F" };
set.addAll(Arrays.asList(elements));
System.out.println(set);
set.clear();
System.out.println(set);
}
}</source>



<pre class=codeResult>[D, A, F, C, B, E]
[]</pre>

== Removing Single Elements: public boolean remove(Object element) ==

Determining via the equals() method of the element.
If the element is found, the element is removed and true is returned.
If not found, false is returned.
If removal is not supported, you"ll get an UnsupportedOperationException thrown.



<source lang="java">
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public class MainClass {
public static void main(String[] a) {
String elements[] = { "A", "B", "C", "D", "E" };
Set set = new HashSet(Arrays.asList(elements));
set.remove("A");
System.out.println(set);
}
}</source>



<pre class=codeResult>[D, C, B, E]</pre>

== Set and HashSet ==

<OL><LI>A Set represents a mathematical set.</LI><LI>It is a Collection that, unlike List, does not allow duplicates.</LI><LI>There must not be two elements of a Set, say e1 and e2, such that e1.equals(e2).</LI><LI>The add method of Set returns false if you try to add a duplicate element.</LI></OL>



<source lang="java">
import java.util.HashSet;
import java.util.Set;
public class MainClass {
public static void main(String[] a) {
Set set = new HashSet();
set.add("Hello");
if (set.add("Hello")) {
System.out.println("addition successful");
} else {
System.out.println("addition failed");
}
}
}</source>



<pre class=codeResult>addition failed</pre>
<OL><LI>HashSet allows at most one null element.</LI><LI>HashSet is faster than other implementations of Set, TreeSet and LinkedHashSet.</LI></OL>

== the containsAll() method checks if a set contains another whole collection ==



<source lang="java">
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public class MainClass {
public static void main(String[] a) {
String elements[] = { "A", "B", "C", "D", "E" };
Set set = new HashSet(Arrays.asList(elements));
elements = new String[] { "A", "B", "C" };
Set set2 = new HashSet(Arrays.asList(elements));
System.out.println(set.containsAll(set2));
}
}</source>



<pre class=codeResult>true</pre>

== The HashSet class defines equality through its equals() method: public boolean equals(Object o) ==

A HashSet is equal to another object if the other object implements the Set interface,
has the same size(), and contains all the same elements.



<source lang="java">
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public class MainClass {
public static void main(String[] a) {
String elements[] = { "A", "B", "C", "D", "E" };
Set set = new HashSet(Arrays.asList(elements));
elements = new String[] { "A", "B", "C", "D" };
Set set2 = new HashSet(Arrays.asList(elements));
System.out.println(set.equals(set2));
}
}</source>



<pre class=codeResult>false</pre>

== To find out how many elements are in a set, use the size() method ==



<source lang="java">
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public class MainClass {
public static void main(String[] a) {
String elements[] = { "A", "B", "C", "D", "E" };
Set set = new HashSet(Arrays.asList(elements));
System.out.println(set.size());
}
}</source>



<pre class=codeResult>5</pre>

← Предыдущая	Версия 05:04, 1 июня 2010
(нет различий)

Java Tutorial/Collections/HashSet - История изменений

Admin: 1 версия

в 17:44, 31 мая 2010