Find Usages Diff Raw Download HTML Widget Stack Overflow Q&A
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
1. Examples of GoF Design Patterns
I am learning GoF Java Design Patterns and I want to see some real life examples of them. Can you guys point to some good usage of these Design Patterns.(preferably in Java's core libraries). Thank you
2. Java - How to create new Entry (key ,value)
I'd like to create new item that similarly to Util.Map.Entry i.e. that will already contain the structure key,value The problem is that I can't use Map.Entry itself because apperently it's a read-only object that I can't instanciate new instance of it. Does anyone know how to create new generic key/value object?
3. Map to String in Java
When I do System.out.println(map) in Java, I get a nice output in stdout. How can I obtain this same string representation of a Map in a variable without meddling with standard output? Something like String mapAsString = Collections.toString(map)?
4. How does the intent of an interface differ from an abstract class with abstract methods?
Explanation/preamble In Java, if you declare an abstract class with abstract methods, e.g. public abstract class MyAbstractClass { private String m_id; // default behavior public MyAbstractClass() { setId(null); } public String getId() { return m_id; } public void setId(String id) { m_id = id; } // overridenable method public void doSomething() { /* does nothing by default */ ...
5. Which scope (application, servletContext, httpSession) will EL use for interpreting attributes
when I use <c:out value="${track}"> in a jsp, where should the attribute track be located in (servletContext, httpSession and request)? I tried to have a controller to set the attribute track to the httpSession, but then ${track} doesn't give me anything in the .jsp. On the other hand, if I set it to the servletContext, ${track} give me the value. It doesn't seem right. Can you give a di...
6. Creating a Hashtable from scratch?
I am writing a program that will hash words from a document along with their frequency of use and line numbers. I thought that I had finished it when I was told that you have to create a hash table from scratch. I do not know where to begin. Any suggestions as to where and how to start would be appreciated. 
1
  /*
2
   * Copyright 1997-2007 Sun Microsystems, Inc.  All Rights Reserved.
3
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
   *
5
   * This code is free software; you can redistribute it and/or modify it
6
   * under the terms of the GNU General Public License version 2 only, as
7
   * published by the Free Software Foundation.  Sun designates this
8
   * particular file as subject to the "Classpath" exception as provided
9
   * by Sun in the LICENSE file that accompanied this code.
10
  *
11
  * This code is distributed in the hope that it will be useful, but WITHOUT
12
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14
  * version 2 for more details (a copy is included in the LICENSE file that
15
  * accompanied this code).
16
  *
17
  * You should have received a copy of the GNU General Public License version
18
  * 2 along with this work; if not, write to the Free Software Foundation,
19
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20
  *
21
  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22
  * CA 95054 USA or visit www.sun.com if you need additional information or
23
  * have any questions.
24
  */
25
 
26
 package java.util;
This class provides a skeletal implementation of the Map interface, to minimize the effort required to implement this interface.

To implement an unmodifiable map, the programmer needs only to extend this class and provide an implementation for the entrySet method, which returns a set-view of the map's mappings. Typically, the returned set will, in turn, be implemented atop AbstractSet. This set should not support the add or remove methods, and its iterator should not support the remove method.

To implement a modifiable map, the programmer must additionally override this class's put method (which otherwise throws an UnsupportedOperationException), and the iterator returned by entrySet().iterator() must additionally implement its remove method.

The programmer should generally provide a void (no argument) and map constructor, as per the recommendation in the Map interface specification.

The documentation for each non-abstract method in this class describes its implementation in detail. Each of these methods may be overridden if the map being implemented admits a more efficient implementation.

This class is a member of the Java Collections Framework.

Parameters:
<K> the type of keys maintained by this map
<V> the type of mapped values
Author(s):
Josh Bloch
Neal Gafter
Since:
1.2
See also:
Map
Collection
66
 
67
 
68
 public abstract class AbstractMap<K,V> implements Map<K,V> {
    
Sole constructor. (For invocation by subclass constructors, typically implicit.) 
72
 
73
     protected AbstractMap() {
74
     }
75
 
76
     // Query Operations
77
 
    

This implementation returns entrySet().size(). 

82
 
83
     public int size() {
84
         return entrySet().size();
85
     }

    

This implementation returns size() == 0. 

91
 
92
     public boolean isEmpty() {
93
         return size() == 0;
94
     }

    

This implementation iterates over entrySet() searching for an entry with the specified value. If such an entry is found, true is returned. If the iteration terminates without finding such an entry, false is returned. Note that this implementation requires linear time in the size of the map.

Throws:
java.lang.ClassCastException
java.lang.NullPointerException
108
    public boolean containsValue(Object value) {
109
        Iterator<Entry<K,V>> i = entrySet().iterator();
110
        if (value==null) {
111
            while (i.hasNext()) {
112
                Entry<K,V> e = i.next();
113
                if (e.getValue()==null)
114
                    return true;
115
            }
116
        } else {
117
            while (i.hasNext()) {
118
                Entry<K,V> e = i.next();
119
                if (value.equals(e.getValue()))
120
                    return true;
121
            }
122
        }
123
        return false;
124
    }

    

This implementation iterates over entrySet() searching for an entry with the specified key. If such an entry is found, true is returned. If the iteration terminates without finding such an entry, false is returned. Note that this implementation requires linear time in the size of the map; many implementations will override this method.

Throws:
java.lang.ClassCastException
java.lang.NullPointerException
139
    public boolean containsKey(Object key) {
140
        Iterator<Map.Entry<K,V>> i = entrySet().iterator();
141
        if (key==null) {
142
            while (i.hasNext()) {
143
                Entry<K,V> e = i.next();
144
                if (e.getKey()==null)
145
                    return true;
146
            }
147
        } else {
148
            while (i.hasNext()) {
149
                Entry<K,V> e = i.next();
150
                if (key.equals(e.getKey()))
151
                    return true;
152
            }
153
        }
154
        return false;
155
    }

    

This implementation iterates over entrySet() searching for an entry with the specified key. If such an entry is found, the entry's value is returned. If the iteration terminates without finding such an entry, null is returned. Note that this implementation requires linear time in the size of the map; many implementations will override this method.

Throws:
java.lang.ClassCastException
java.lang.NullPointerException
170
    public V get(Object key) {
171
        Iterator<Entry<K,V>> i = entrySet().iterator();
172
        if (key==null) {
173
            while (i.hasNext()) {
174
                Entry<K,V> e = i.next();
175
                if (e.getKey()==null)
176
                    return e.getValue();
177
            }
178
        } else {
179
            while (i.hasNext()) {
180
                Entry<K,V> e = i.next();
181
                if (key.equals(e.getKey()))
182
                    return e.getValue();
183
            }
184
        }
185
        return null;
186
    }
189
    // Modification Operations
190

    

This implementation always throws an UnsupportedOperationException.

Throws:
java.lang.UnsupportedOperationException
java.lang.ClassCastException
java.lang.NullPointerException
java.lang.IllegalArgumentException
202
    public V put(K key, V value) {
203
        throw new UnsupportedOperationException();
204
    }

    

This implementation iterates over entrySet() searching for an entry with the specified key. If such an entry is found, its value is obtained with its getValue operation, the entry is removed from the collection (and the backing map) with the iterator's remove operation, and the saved value is returned. If the iteration terminates without finding such an entry, null is returned. Note that this implementation requires linear time in the size of the map; many implementations will override this method.

Note that this implementation throws an UnsupportedOperationException if the entrySet iterator does not support the remove method and this map contains a mapping for the specified key.

Throws:
java.lang.UnsupportedOperationException
java.lang.ClassCastException
java.lang.NullPointerException
227
    public V remove(Object key) {
228
        Iterator<Entry<K,V>> i = entrySet().iterator();
229
        Entry<K,V> correctEntry = null;
230
        if (key==null) {
231
            while (correctEntry==null && i.hasNext()) {
232
                Entry<K,V> e = i.next();
233
                if (e.getKey()==null)
234
                    correctEntry = e;
235
            }
236
        } else {
237
            while (correctEntry==null && i.hasNext()) {
238
                Entry<K,V> e = i.next();
239
                if (key.equals(e.getKey()))
240
                    correctEntry = e;
241
            }
242
        }
244
        V oldValue = null;
245
        if (correctEntry !=null) {
246
            oldValue = correctEntry.getValue();
247
            i.remove();
248
        }
249
        return oldValue;
250
    }
253
    // Bulk Operations
254

    

This implementation iterates over the specified map's entrySet() collection, and calls this map's put operation once for each entry returned by the iteration.

Note that this implementation throws an UnsupportedOperationException if this map does not support the put operation and the specified map is nonempty.

Throws:
java.lang.UnsupportedOperationException
java.lang.ClassCastException
java.lang.NullPointerException
java.lang.IllegalArgumentException
271
    public void putAll(Map<? extends K, ? extends V> m) {
272
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
273
            put(e.getKey(), e.getValue());
274
    }

    

This implementation calls entrySet().clear().

Note that this implementation throws an UnsupportedOperationException if the entrySet does not support the clear operation.

Throws:
java.lang.UnsupportedOperationException
287
    public void clear() {
288
        entrySet().clear();
289
    }
292
    // Views
293

    
Each of these fields are initialized to contain an instance of the appropriate view the first time this view is requested. The views are stateless, so there's no reason to create more than one of each. 
299
    transient volatile Set<K>        keySet = null;
300
    transient volatile Collection<V> values = null;

    

This implementation returns a set that subclasses AbstractSet. The subclass's iterator method returns a "wrapper object" over this map's entrySet() iterator. The size method delegates to this map's size method and the contains method delegates to this map's containsKey method.

The set is created the first time this method is called, and returned in response to all subsequent calls. No synchronization is performed, so there is a slight chance that multiple calls to this method will not all return the same set. 

317
    public Set<K> keySet() {
318
        if ( == null) {
319
             = new AbstractSet<K>() {
320
                public Iterator<K> iterator() {
321
                    return new Iterator<K>() {
322
                        private Iterator<Entry<K,V>> i = entrySet().iterator();
324
                        public boolean hasNext() {
325
                            return .hasNext();
326
                        }
328
                        public K next() {
329
                            return .next().getKey();
330
                        }
332
                        public void remove() {
333
                            .remove();
334
                        }
335
                    };
336
                }
338
                public int size() {
339
                    return AbstractMap.this.size();
340
                }
342
                public boolean isEmpty() {
343
                    return AbstractMap.this.isEmpty();
344
                }
346
                public void clear() {
347
                    AbstractMap.this.clear();
348
                }
350
                public boolean contains(Object k) {
351
                    return AbstractMap.this.containsKey(k);
352
                }
353
            };
354
        }
355
        return ;
356
    }

    

This implementation returns a collection that subclasses AbstractCollection. The subclass's iterator method returns a "wrapper object" over this map's entrySet() iterator. The size method delegates to this map's size method and the contains method delegates to this map's containsValue method.

The collection is created the first time this method is called, and returned in response to all subsequent calls. No synchronization is performed, so there is a slight chance that multiple calls to this method will not all return the same collection. 

373
    public Collection<V> values() {
374
        if ( == null) {
375
             = new AbstractCollection<V>() {
376
                public Iterator<V> iterator() {
377
                    return new Iterator<V>() {
378
                        private Iterator<Entry<K,V>> i = entrySet().iterator();
380
                        public boolean hasNext() {
381
                            return .hasNext();
382
                        }
384
                        public V next() {
385
                            return .next().getValue();
386
                        }
388
                        public void remove() {
389
                            .remove();
390
                        }
391
                    };
392
                }
394
                public int size() {
395
                    return AbstractMap.this.size();
396
                }
398
                public boolean isEmpty() {
399
                    return AbstractMap.this.isEmpty();
400
                }
402
                public void clear() {
403
                    AbstractMap.this.clear();
404
                }
406
                public boolean contains(Object v) {
407
                    return AbstractMap.this.containsValue(v);
408
                }
409
            };
410
        }
411
        return ;
412
    }
414
    public abstract Set<Entry<K,V>> entrySet();
417
    // Comparison and hashing
418

    
Compares the specified object with this map for equality. Returns true if the given object is also a map and the two maps represent the same mappings. More formally, two maps m1 and m2 represent the same mappings if m1.entrySet().equals(m2.entrySet()). This ensures that the equals method works properly across different implementations of the Map interface.

This implementation first checks if the specified object is this map; if so it returns true. Then, it checks if the specified object is a map whose size is identical to the size of this map; if not, it returns false. If so, it iterates over this map's entrySet collection, and checks that the specified map contains each mapping that this map contains. If the specified map fails to contain such a mapping, false is returned. If the iteration completes, true is returned.

Parameters:
o object to be compared for equality with this map
Returns:
true if the specified object is equal to this map
440
    public boolean equals(Object o) {
441
        if (o == this)
442
            return true;
444
        if (!(o instanceof Map))
445
            return false;
446
        Map<K,V> m = (Map<K,V>) o;
447
        if (m.size() != size())
448
            return false;
450
        try {
451
            Iterator<Entry<K,V>> i = entrySet().iterator();
452
            while (i.hasNext()) {
453
                Entry<K,V> e = i.next();
454
                K key = e.getKey();
455
                V value = e.getValue();
456
                if (value == null) {
457
                    if (!(m.get(key)==null && m.containsKey(key)))
458
                        return false;
459
                } else {
460
                    if (!value.equals(m.get(key)))
461
                        return false;
462
                }
463
            }
464
        } catch (ClassCastException unused) {
465
            return false;
466
        } catch (NullPointerException unused) {
467
            return false;
468
        }
470
        return true;
471
    }

    
Returns the hash code value for this map. The hash code of a map is defined to be the sum of the hash codes of each entry in the map's entrySet() view. This ensures that m1.equals(m2) implies that m1.hashCode()==m2.hashCode() for any two maps m1 and m2, as required by the general contract of java.lang.Object.hashCode().

This implementation iterates over entrySet(), calling hashCode() on each element (entry) in the set, and adding up the results.

Returns:
the hash code value for this map
See also:
Map.Entry.hashCode()
java.lang.Object.equals(java.lang.Object)
Set.equals(java.lang.Object)
490
    public int hashCode() {
491
        int h = 0;
492
        Iterator<Entry<K,V>> i = entrySet().iterator();
493
        while (i.hasNext())
494
            h += i.next().hashCode();
495
        return h;
496
    }

    
Returns a string representation of this map. The string representation consists of a list of key-value mappings in the order returned by the map's entrySet view's iterator, enclosed in braces ("{}"). Adjacent mappings are separated by the characters ", " (comma and space). Each key-value mapping is rendered as the key followed by an equals sign ("=") followed by the associated value. Keys and values are converted to strings as by java.lang.String.valueOf(java.lang.Object).

Returns:
a string representation of this map
510
    public String toString() {
511
        Iterator<Entry<K,V>> i = entrySet().iterator();
512
        if (! i.hasNext())
513
            return "{}";
515
        StringBuilder sb = new StringBuilder();
516
        sb.append('{');
517
        for (;;) {
518
            Entry<K,V> e = i.next();
519
            K key = e.getKey();
520
            V value = e.getValue();
521
            sb.append(key   == this ? "(this Map)" : key);
522
            sb.append('=');
523
            sb.append(value == this ? "(this Map)" : value);
524
            if (! i.hasNext())
525
                return sb.append('}').toString();
526
            sb.append(", ");
527
        }
528
    }

    
Returns a shallow copy of this AbstractMap instance: the keys and values themselves are not cloned.

Returns:
a shallow copy of this map
536
    protected Object clone() throws CloneNotSupportedException {
537
        AbstractMap<K,V> result = (AbstractMap<K,V>)super.clone();
538
        result.keySet = null;
539
        result.values = null;
540
        return result;
541
    }

    
Utility method for SimpleEntry and SimpleImmutableEntry. Test for equality, checking for nulls. 
547
    private static boolean eq(Object o1, Object o2) {
548
        return o1 == null ? o2 == null : o1.equals(o2);
549
    }
551
    // Implementation Note: SimpleEntry and SimpleImmutableEntry
552
    // are distinct unrelated classes, even though they share
553
    // some code. Since you can't add or subtract final-ness
554
    // of a field in a subclass, they can't share representations,
555
    // and the amount of duplicated code is too small to warrant
556
    // exposing a common abstract class.
557


    
An Entry maintaining a key and a value. The value may be changed using the setValue method. This class facilitates the process of building custom map implementations. For example, it may be convenient to return arrays of SimpleEntry instances in method Map.entrySet().toArray.

Since:
1.6
569
    public static class SimpleEntry<K,V>
570
        implements Entry<K,V>, java.io.Serializable
571
    {
572
        private static final long serialVersionUID = -8499721149061103585L;
574
        private final K key;
575
        private V value;

        
Creates an entry representing a mapping from the specified key to the specified value.

Parameters:
key the key represented by this entry
value the value represented by this entry
584
        public SimpleEntry(K key, V value) {
585
            this.   = key;
586
            this. = value;
587
        }

        
Creates an entry representing the same mapping as the specified entry.

Parameters:
entry the entry to copy
595
        public SimpleEntry(Entry<? extends K, ? extends V> entry) {
596
            this.   = entry.getKey();
597
            this. = entry.getValue();
598
        }

        
Returns the key corresponding to this entry.

Returns:
the key corresponding to this entry
605
        public K getKey() {
606
            return ;
607
        }

        
Returns the value corresponding to this entry.

Returns:
the value corresponding to this entry
614
        public V getValue() {
615
            return ;
616
        }

        
Replaces the value corresponding to this entry with the specified value.

Parameters:
value new value to be stored in this entry
Returns:
the old value corresponding to the entry
625
        public V setValue(V value) {
626
            V oldValue = this.;
627
            this. = value;
628
            return oldValue;
629
        }

        
Compares the specified object with this entry for equality. Returns true if the given object is also a map entry and the two entries represent the same mapping. More formally, two entries e1 and e2 represent the same mapping if
   (e1.getKey()==null ?
    e2.getKey()==null :
    e1.getKey().equals(e2.getKey()))
   &&
   (e1.getValue()==null ?
    e2.getValue()==null :
    e1.getValue().equals(e2.getValue()))
This ensures that the equals method works properly across different implementations of the Map.Entry interface.

Parameters:
o object to be compared for equality with this map entry
Returns:
true if the specified object is equal to this map entry
See also:
hashCode()
652
        public boolean equals(Object o) {
653
            if (!(o instanceof Map.Entry))
654
                return false;
655
            Map.Entry e = (Map.Entry)o;
656
            return eq(, e.getKey()) && eq(, e.getValue());
657
        }

        
Returns the hash code value for this map entry. The hash code of a map entry e is defined to be: 
   (e.getKey()==null   ? 0 : e.getKey().hashCode()) ^
   (e.getValue()==null ? 0 : e.getValue().hashCode())
This ensures that e1.equals(e2) implies that e1.hashCode()==e2.hashCode() for any two Entries e1 and e2, as required by the general contract of java.lang.Object.hashCode().

Returns:
the hash code value for this map entry
See also:
equals(java.lang.Object)
672
        public int hashCode() {
673
            return (   == null ? 0 :   .hashCode()) ^
674
                   ( == null ? 0 : .hashCode());
675
        }

        
Returns a String representation of this map entry. This implementation returns the string representation of this entry's key followed by the equals character ("=") followed by the string representation of this entry's value.

Returns:
a String representation of this map entry
685
        public String toString() {
686
            return  + "=" + ;
687
        }
689
    }

    
An Entry maintaining an immutable key and value. This class does not support method setValue. This class may be convenient in methods that return thread-safe snapshots of key-value mappings.

Since:
1.6
699
    public static class SimpleImmutableEntry<K,V>
700
        implements Entry<K,V>, java.io.Serializable
701
    {
702
        private static final long serialVersionUID = 7138329143949025153L;
704
        private final K key;
705
        private final V value;

        
Creates an entry representing a mapping from the specified key to the specified value.

Parameters:
key the key represented by this entry
value the value represented by this entry
714
        public SimpleImmutableEntry(K key, V value) {
715
            this.   = key;
716
            this. = value;
717
        }

        
Creates an entry representing the same mapping as the specified entry.

Parameters:
entry the entry to copy
725
        public SimpleImmutableEntry(Entry<? extends K, ? extends V> entry) {
726
            this.   = entry.getKey();
727
            this. = entry.getValue();
728
        }

        
Returns the key corresponding to this entry.

Returns:
the key corresponding to this entry
735
        public K getKey() {
736
            return ;
737
        }

        
Returns the value corresponding to this entry.

Returns:
the value corresponding to this entry
744
        public V getValue() {
745
            return ;
746
        }

        
Replaces the value corresponding to this entry with the specified value (optional operation). This implementation simply throws UnsupportedOperationException, as this class implements an immutable map entry.

Parameters:
value new value to be stored in this entry
Returns:
(Does not return)
Throws:
java.lang.UnsupportedOperationException always
758
        public V setValue(V value) {
759
            throw new UnsupportedOperationException();
760
        }

        
Compares the specified object with this entry for equality. Returns true if the given object is also a map entry and the two entries represent the same mapping. More formally, two entries e1 and e2 represent the same mapping if
   (e1.getKey()==null ?
    e2.getKey()==null :
    e1.getKey().equals(e2.getKey()))
   &&
   (e1.getValue()==null ?
    e2.getValue()==null :
    e1.getValue().equals(e2.getValue()))
This ensures that the equals method works properly across different implementations of the Map.Entry interface.

Parameters:
o object to be compared for equality with this map entry
Returns:
true if the specified object is equal to this map entry
See also:
hashCode()
783
        public boolean equals(Object o) {
784
            if (!(o instanceof Map.Entry))
785
                return false;
786
            Map.Entry e = (Map.Entry)o;
787
            return eq(, e.getKey()) && eq(, e.getValue());
788
        }

        
Returns the hash code value for this map entry. The hash code of a map entry e is defined to be: 
   (e.getKey()==null   ? 0 : e.getKey().hashCode()) ^
   (e.getValue()==null ? 0 : e.getValue().hashCode())
This ensures that e1.equals(e2) implies that e1.hashCode()==e2.hashCode() for any two Entries e1 and e2, as required by the general contract of java.lang.Object.hashCode().

Returns:
the hash code value for this map entry
See also:
equals(java.lang.Object)
803
        public int hashCode() {
804
            return (   == null ? 0 :   .hashCode()) ^
805
                   ( == null ? 0 : .hashCode());
806
        }

        
Returns a String representation of this map entry. This implementation returns the string representation of this entry's key followed by the equals character ("=") followed by the string representation of this entry's value.

Returns:
a String representation of this map entry
816
        public String toString() {
817
            return  + "=" + ;
818
        }
820
    }
New to GrepCode? Check out our FAQ X