Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
  /*
2
   * Copyright 2002-2007 the original author or authors.
3
   *
4
   * Licensed under the Apache License, Version 2.0 (the "License");
5
   * you may not use this file except in compliance with the License.
6
   * You may obtain a copy of the License at
7
   *
8
   *      http://www.apache.org/licenses/LICENSE-2.0
9
   *
10
  * Unless required by applicable law or agreed to in writing, software
11
  * distributed under the License is distributed on an "AS IS" BASIS,
12
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
  * See the License for the specific language governing permissions and
14
  * limitations under the License.
15
  */
16
 
17
 package org.springframework.util;
18
 
Miscellaneous object utility methods. Mainly for internal use within the framework; consider Jakarta's Commons Lang for a more comprehensive suite of object utilities.

Author(s):
Juergen Hoeller
Keith Donald
Rod Johnson
Rob Harrop
Alex Ruiz
Since:
19.03.2004
See also:
org.apache.commons.lang.ObjectUtils
34
 
35
 public abstract class ObjectUtils {
36
 
37
 	private static final int INITIAL_HASH = 7;
38
 	private static final int MULTIPLIER = 31;
39
 
40
 	private static final String EMPTY_STRING = "";
41
 	private static final String NULL_STRING = "null";
42
 	private static final String ARRAY_START = "{";
43
 	private static final String ARRAY_END = "}";
44
 	private static final String EMPTY_ARRAY =  + ;
45
 	private static final String ARRAY_ELEMENT_SEPARATOR = ", ";
Return whether the given throwable is a checked exception: that is, neither a RuntimeException nor an Error.

Parameters:
ex the throwable to check
Returns:
whether the throwable is a checked exception
See also:
java.lang.Exception
java.lang.RuntimeException
java.lang.Error
56
 
57
 	public static boolean isCheckedException(Throwable ex) {
58
 		return !(ex instanceof RuntimeException || ex instanceof Error);
59
 	}
Check whether the given exception is compatible with the exceptions declared in a throws clause.

Parameters:
ex the exception to checked
declaredExceptions the exceptions declared in the throws clause
Returns:
whether the given exception is compatible
67
 
68
 	public static boolean isCompatibleWithThrowsClause(Throwable ex, Class[] declaredExceptions) {
69
 		if (!isCheckedException(ex)) {
70
 			return true;
71
 		}
72
 		if (declaredExceptions != null) {
73
 			for (int i = 0; i < declaredExceptions.length; i++) {
74
 				if (declaredExceptions[i].isAssignableFrom(ex.getClass())) {
75
 					return true;
76
 				}
77
 			}
78
 		}
79
 		return false;
80
 	}
Return whether the given array is empty: that is, null or of zero length.

Parameters:
array the array to check
Returns:
whether the given array is empty
87
 
88
 	public static boolean isEmpty(Object[] array) {
89
 		return (array == null || array.length == 0);
90
 	}
Check whether the given array contains the given element.

Parameters:
array the array to check (may be null, in which case the return value will always be false)
element the element to check for
Returns:
whether the element has been found in the given array
98
 
99
 	public static boolean containsElement(Object[] array, Object element) {
100
		if (array == null) {
101
			return false;
102
		}
103
		for (int i = 0; i < array.length; i++) {
104
			if (nullSafeEquals(array[i], element)) {
105
				return true;
106
			}
107
		}
108
		return false;
109
	}
Append the given Object to the given array, returning a new array consisting of the input array contents plus the given Object.

Parameters:
array the array to append to (can be null)
obj the Object to append
Returns:
the new array (of the same component type; never null)
118
	public static Object[] addObjectToArray(Object[] array, Object obj) {
119
		Class compType = Object.class;
120
		if (array != null) {
121
			compType = array.getClass().getComponentType();
122
		}
123
		else if (obj != null) {
124
			compType = obj.getClass();
125
		}
126
		int newArrLength = (array != null ? array.length + 1 : 1);
127
		Object[] newArr = (Object[]) Array.newInstance(compType, newArrLength);
128
		if (array != null) {
129
			System.arraycopy(array, 0, newArr, 0, array.length);
130
		}
131
		newArr[newArr.length - 1] = obj;
132
		return newArr;
133
	}
Convert the given array (which may be a primitive array) to an object array (if necessary of primitive wrapper objects).

A null source value will be converted to an empty Object array.

Parameters:
source the (potentially primitive) array
Returns:
the corresponding object array (never null)
Throws:
java.lang.IllegalArgumentException if the parameter is not an array
144
	public static Object[] toObjectArray(Object source) {
145
		if (source instanceof Object[]) {
146
			return (Object[]) source;
147
		}
148
		if (source == null) {
149
			return new Object[0];
150
		}
151
		if (!source.getClass().isArray()) {
152
			throw new IllegalArgumentException("Source is not an array: " + source);
153
		}
154
		int length = Array.getLength(source);
155
		if (length == 0) {
156
			return new Object[0];
157
		}
158
		Class wrapperType = Array.get(source, 0).getClass();
159
		Object[] newArray = (Object[]) Array.newInstance(wrapperType, length);
160
		for (int i = 0; i < length; i++) {
161
			newArray[i] = Array.get(source, i);
162
		}
163
		return newArray;
164
	}
167
	//---------------------------------------------------------------------
168
	// Convenience methods for content-based equality/hash-code handling
169
	//---------------------------------------------------------------------
Determine if the given objects are equal, returning true if both are null or false if only one is null.

Compares arrays with Arrays.equals, performing an equality check based on the array elements rather than the array reference.

Parameters:
o1 first Object to compare
o2 second Object to compare
Returns:
whether the given objects are equal
See also:
java.lang.Object.equals(java.lang.Object)
182
	public static boolean nullSafeEquals(Object o1, Object o2) {
183
		if (o1 == o2) {
184
			return true;
185
		}
186
		if (o1 == null || o2 == null) {
187
			return false;
188
		}
189
		if (o1.equals(o2)) {
190
			return true;
191
		}
192
		if (o1.getClass().isArray() && o2.getClass().isArray()) {
193
			if (o1 instanceof Object[] && o2 instanceof Object[]) {
194
				return Arrays.equals((Object[]) o1, (Object[]) o2);
195
			}
196
			if (o1 instanceof boolean[] && o2 instanceof boolean[]) {
197
				return Arrays.equals((boolean[]) o1, (boolean[]) o2);
198
			}
199
			if (o1 instanceof byte[] && o2 instanceof byte[]) {
200
				return Arrays.equals((byte[]) o1, (byte[]) o2);
201
			}
202
			if (o1 instanceof char[] && o2 instanceof char[]) {
203
				return Arrays.equals((char[]) o1, (char[]) o2);
204
			}
205
			if (o1 instanceof double[] && o2 instanceof double[]) {
206
				return Arrays.equals((double[]) o1, (double[]) o2);
207
			}
208
			if (o1 instanceof float[] && o2 instanceof float[]) {
209
				return Arrays.equals((float[]) o1, (float[]) o2);
210
			}
211
			if (o1 instanceof int[] && o2 instanceof int[]) {
212
				return Arrays.equals((int[]) o1, (int[]) o2);
213
			}
214
			if (o1 instanceof long[] && o2 instanceof long[]) {
215
				return Arrays.equals((long[]) o1, (long[]) o2);
216
			}
217
			if (o1 instanceof short[] && o2 instanceof short[]) {
218
				return Arrays.equals((short[]) o1, (short[]) o2);
219
			}
220
		}
221
		return false;
222
	}
Return as hash code for the given object; typically the value of java.lang.Object.hashCode(). If the object is an array, this method will delegate to any of the nullSafeHashCode methods for arrays in this class. If the object is null, this method returns 0.

See also:
nullSafeHashCode(java.lang.Object[])
nullSafeHashCode(boolean[])
nullSafeHashCode(byte[])
nullSafeHashCode(char[])
nullSafeHashCode(double[])
nullSafeHashCode(float[])
nullSafeHashCode(int[])
nullSafeHashCode(long[])
nullSafeHashCode(short[])
240
	public static int nullSafeHashCode(Object obj) {
241
		if (obj == null) {
242
			return 0;
243
		}
244
		if (obj.getClass().isArray()) {
245
			if (obj instanceof Object[]) {
246
				return nullSafeHashCode((Object[]) obj);
247
			}
248
			if (obj instanceof boolean[]) {
249
				return nullSafeHashCode((boolean[]) obj);
250
			}
251
			if (obj instanceof byte[]) {
252
				return nullSafeHashCode((byte[]) obj);
253
			}
254
			if (obj instanceof char[]) {
255
				return nullSafeHashCode((char[]) obj);
256
			}
257
			if (obj instanceof double[]) {
258
				return nullSafeHashCode((double[]) obj);
259
			}
260
			if (obj instanceof float[]) {
261
				return nullSafeHashCode((float[]) obj);
262
			}
263
			if (obj instanceof int[]) {
264
				return nullSafeHashCode((int[]) obj);
265
			}
266
			if (obj instanceof long[]) {
267
				return nullSafeHashCode((long[]) obj);
268
			}
269
			if (obj instanceof short[]) {
270
				return nullSafeHashCode((short[]) obj);
271
			}
272
		}
273
		return obj.hashCode();
274
	}
Return a hash code based on the contents of the specified array. If array is null, this method returns 0. 
280
	public static int nullSafeHashCode(Object[] array) {
281
		if (array == null) {
282
			return 0;
283
		}
284
		int hash = ;
285
		int arraySize = array.length;
286
		for (int i = 0; i < arraySize; i++) {
287
			hash =  * hash + nullSafeHashCode(array[i]);
288
		}
289
		return hash;
290
	}
Return a hash code based on the contents of the specified array. If array is null, this method returns 0. 
296
	public static int nullSafeHashCode(boolean[] array) {
297
		if (array == null) {
298
			return 0;
299
		}
300
		int hash = ;
301
		int arraySize = array.length;
302
		for (int i = 0; i < arraySize; i++) {
303
			hash =  * hash + hashCode(array[i]);
304
		}
305
		return hash;
306
	}
Return a hash code based on the contents of the specified array. If array is null, this method returns 0. 
312
	public static int nullSafeHashCode(byte[] array) {
313
		if (array == null) {
314
			return 0;
315
		}
316
		int hash = ;
317
		int arraySize = array.length;
318
		for (int i = 0; i < arraySize; i++) {
319
			hash =  * hash + array[i];
320
		}
321
		return hash;
322
	}
Return a hash code based on the contents of the specified array. If array is null, this method returns 0. 
328
	public static int nullSafeHashCode(char[] array) {
329
		if (array == null) {
330
			return 0;
331
		}
332
		int hash = ;
333
		int arraySize = array.length;
334
		for (int i = 0; i < arraySize; i++) {
335
			hash =  * hash + array[i];
336
		}
337
		return hash;
338
	}
Return a hash code based on the contents of the specified array. If array is null, this method returns 0. 
344
	public static int nullSafeHashCode(double[] array) {
345
		if (array == null) {
346
			return 0;
347
		}
348
		int hash = ;
349
		int arraySize = array.length;
350
		for (int i = 0; i < arraySize; i++) {
351
			hash =  * hash + hashCode(array[i]);
352
		}
353
		return hash;
354
	}
Return a hash code based on the contents of the specified array. If array is null, this method returns 0. 
360
	public static int nullSafeHashCode(float[] array) {
361
		if (array == null) {
362
			return 0;
363
		}
364
		int hash = ;
365
		int arraySize = array.length;
366
		for (int i = 0; i < arraySize; i++) {
367
			hash =  * hash + hashCode(array[i]);
368
		}
369
		return hash;
370
	}
Return a hash code based on the contents of the specified array. If array is null, this method returns 0. 
376
	public static int nullSafeHashCode(int[] array) {
377
		if (array == null) {
378
			return 0;
379
		}
380
		int hash = ;
381
		int arraySize = array.length;
382
		for (int i = 0; i < arraySize; i++) {
383
			hash =  * hash + array[i];
384
		}
385
		return hash;
386
	}
Return a hash code based on the contents of the specified array. If array is null, this method returns 0. 
392
	public static int nullSafeHashCode(long[] array) {
393
		if (array == null) {
394
			return 0;
395
		}
396
		int hash = ;
397
		int arraySize = array.length;
398
		for (int i = 0; i < arraySize; i++) {
399
			hash =  * hash + hashCode(array[i]);
400
		}
401
		return hash;
402
	}
Return a hash code based on the contents of the specified array. If array is null, this method returns 0. 
408
	public static int nullSafeHashCode(short[] array) {
409
		if (array == null) {
410
			return 0;
411
		}
412
		int hash = ;
413
		int arraySize = array.length;
414
		for (int i = 0; i < arraySize; i++) {
415
			hash =  * hash + array[i];
416
		}
417
		return hash;
418
	}
Return the same value as java.lang.Boolean.hashCode().

See also:
java.lang.Boolean.hashCode()
424
	public static int hashCode(boolean bool) {
425
		return bool ? 1231 : 1237;
426
	}
Return the same value as java.lang.Double.hashCode().

See also:
java.lang.Double.hashCode()
432
	public static int hashCode(double dbl) {
433
		long bits = Double.doubleToLongBits(dbl);
434
		return hashCode(bits);
435
	}
Return the same value as java.lang.Float.hashCode().

See also:
java.lang.Float.hashCode()
441
	public static int hashCode(float flt) {
442
		return Float.floatToIntBits(flt);
443
	}
Return the same value as java.lang.Long.hashCode().

See also:
java.lang.Long.hashCode()
449
	public static int hashCode(long lng) {
450
		return (int) (lng ^ (lng >>> 32));
451
	}
454
	//---------------------------------------------------------------------
455
	// Convenience methods for toString output
456
	//---------------------------------------------------------------------
Return a String representation of an object's overall identity.

Parameters:
obj the object (may be null)
Returns:
the object's identity as String representation, or an empty String if the object was null
464
	public static String identityToString(Object obj) {
465
		if (obj == null) {
466
			return ;
467
		}
468
		return obj.getClass().getName() + "@" + getIdentityHexString(obj);
469
	}
Return a hex String form of an object's identity hash code.

Parameters:
obj the object
Returns:
the object's identity code in hex notation
476
	public static String getIdentityHexString(Object obj) {
477
		return Integer.toHexString(System.identityHashCode(obj));
478
	}
Return a content-based String representation if obj is not null; otherwise returns an empty String.

Differs from nullSafeToString(java.lang.Object) in that it returns an empty String rather than "null" for a null value.

Parameters:
obj the object to build a display String for
Returns:
a display String representation of obj
See also:
nullSafeToString(java.lang.Object)
489
	public static String getDisplayString(Object obj) {
490
		if (obj == null) {
491
			return ;
492
		}
493
		return nullSafeToString(obj);
494
	}
Determine the class name for the given object.

Returns "null" if obj is null.

Parameters:
obj the object to introspect (may be null)
Returns:
the corresponding class name
502
	public static String nullSafeClassName(Object obj) {
503
		return (obj != null ? obj.getClass().getName() : );
504
	}
Return a String representation of the specified Object.

Builds a String representation of the contents in case of an array. Returns "null" if obj is null.

Parameters:
obj the object to build a String representation for
Returns:
a String representation of obj
513
	public static String nullSafeToString(Object obj) {
514
		if (obj == null) {
515
			return ;
516
		}
517
		if (obj instanceof String) {
518
			return (String) obj;
519
		}
520
		if (obj instanceof Object[]) {
521
			return nullSafeToString((Object[]) obj);
522
		}
523
		if (obj instanceof boolean[]) {
524
			return nullSafeToString((boolean[]) obj);
525
		}
526
		if (obj instanceof byte[]) {
527
			return nullSafeToString((byte[]) obj);
528
		}
529
		if (obj instanceof char[]) {
530
			return nullSafeToString((char[]) obj);
531
		}
532
		if (obj instanceof double[]) {
533
			return nullSafeToString((double[]) obj);
534
		}
535
		if (obj instanceof float[]) {
536
			return nullSafeToString((float[]) obj);
537
		}
538
		if (obj instanceof int[]) {
539
			return nullSafeToString((int[]) obj);
540
		}
541
		if (obj instanceof long[]) {
542
			return nullSafeToString((long[]) obj);
543
		}
544
		if (obj instanceof short[]) {
545
			return nullSafeToString((short[]) obj);
546
		}
547
		String str = obj.toString();
548
		return (str != null ? str : );
549
	}
Return a String representation of the contents of the specified array.

The String representation consists of a list of the array's elements, enclosed in curly braces ("{}"). Adjacent elements are separated by the characters ", " (a comma followed by a space). Returns "null" if array is null.

Parameters:
array the array to build a String representation for
Returns:
a String representation of array
560
	public static String nullSafeToString(Object[] array) {
561
		if (array == null) {
562
			return ;
563
		}
564
		int length = array.length;
565
		if (length == 0) {
566
			return ;
567
		}
568
		StringBuffer buffer = new StringBuffer();
569
		for (int i = 0; i < length; i++) {
570
			if (i == 0) {
572
			}
573
			else {
575
			}
576
			buffer.append(String.valueOf(array[i]));
577
		}
579
		return buffer.toString();
580
	}
Return a String representation of the contents of the specified array.

The String representation consists of a list of the array's elements, enclosed in curly braces ("{}"). Adjacent elements are separated by the characters ", " (a comma followed by a space). Returns "null" if array is null.

Parameters:
array the array to build a String representation for
Returns:
a String representation of array
591
	public static String nullSafeToString(boolean[] array) {
592
		if (array == null) {
593
			return ;
594
		}
595
		int length = array.length;
596
		if (length == 0) {
597
			return ;
598
		}
599
		StringBuffer buffer = new StringBuffer();
600
		for (int i = 0; i < length; i++) {
601
			if (i == 0) {
603
			}
604
			else {
606
			}
608
			buffer.append(array[i]);
609
		}
611
		return buffer.toString();
612
	}
Return a String representation of the contents of the specified array.

The String representation consists of a list of the array's elements, enclosed in curly braces ("{}"). Adjacent elements are separated by the characters ", " (a comma followed by a space). Returns "null" if array is null.

Parameters:
array the array to build a String representation for
Returns:
a String representation of array
623
	public static String nullSafeToString(byte[] array) {
624
		if (array == null) {
625
			return ;
626
		}
627
		int length = array.length;
628
		if (length == 0) {
629
			return ;
630
		}
631
		StringBuffer buffer = new StringBuffer();
632
		for (int i = 0; i < length; i++) {
633
			if (i == 0) {
635
			}
636
			else {
638
			}
639
			buffer.append(array[i]);
640
		}
642
		return buffer.toString();
643
	}
Return a String representation of the contents of the specified array.

The String representation consists of a list of the array's elements, enclosed in curly braces ("{}"). Adjacent elements are separated by the characters ", " (a comma followed by a space). Returns "null" if array is null.

Parameters:
array the array to build a String representation for
Returns:
a String representation of array
654
	public static String nullSafeToString(char[] array) {
655
		if (array == null) {
656
			return ;
657
		}
658
		int length = array.length;
659
		if (length == 0) {
660
			return ;
661
		}
662
		StringBuffer buffer = new StringBuffer();
663
		for (int i = 0; i < length; i++) {
664
			if (i == 0) {
666
			}
667
			else {
669
			}
670
			buffer.append("'").append(array[i]).append("'");
671
		}
673
		return buffer.toString();
674
	}
Return a String representation of the contents of the specified array.

The String representation consists of a list of the array's elements, enclosed in curly braces ("{}"). Adjacent elements are separated by the characters ", " (a comma followed by a space). Returns "null" if array is null.

Parameters:
array the array to build a String representation for
Returns:
a String representation of array
685
	public static String nullSafeToString(double[] array) {
686
		if (array == null) {
687
			return ;
688
		}
689
		int length = array.length;
690
		if (length == 0) {
691
			return ;
692
		}
693
		StringBuffer buffer = new StringBuffer();
694
		for (int i = 0; i < length; i++) {
695
			if (i == 0) {
697
			}
698
			else {
700
			}
702
			buffer.append(array[i]);
703
		}
705
		return buffer.toString();
706
	}
Return a String representation of the contents of the specified array.

The String representation consists of a list of the array's elements, enclosed in curly braces ("{}"). Adjacent elements are separated by the characters ", " (a comma followed by a space). Returns "null" if array is null.

Parameters:
array the array to build a String representation for
Returns:
a String representation of array
717
	public static String nullSafeToString(float[] array) {
718
		if (array == null) {
719
			return ;
720
		}
721
		int length = array.length;
722
		if (length == 0) {
723
			return ;
724
		}
725
		StringBuffer buffer = new StringBuffer();
726
		for (int i = 0; i < length; i++) {
727
			if (i == 0) {
729
			}
730
			else {
732
			}
734
			buffer.append(array[i]);
735
		}
737
		return buffer.toString();
738
	}
Return a String representation of the contents of the specified array.

The String representation consists of a list of the array's elements, enclosed in curly braces ("{}"). Adjacent elements are separated by the characters ", " (a comma followed by a space). Returns "null" if array is null.

Parameters:
array the array to build a String representation for
Returns:
a String representation of array
749
	public static String nullSafeToString(int[] array) {
750
		if (array == null) {
751
			return ;
752
		}
753
		int length = array.length;
754
		if (length == 0) {
755
			return ;
756
		}
757
		StringBuffer buffer = new StringBuffer();
758
		for (int i = 0; i < length; i++) {
759
			if (i == 0) {
761
			}
762
			else {
764
			}
765
			buffer.append(array[i]);
766
		}
768
		return buffer.toString();
769
	}
Return a String representation of the contents of the specified array.

The String representation consists of a list of the array's elements, enclosed in curly braces ("{}"). Adjacent elements are separated by the characters ", " (a comma followed by a space). Returns "null" if array is null.

Parameters:
array the array to build a String representation for
Returns:
a String representation of array
780
	public static String nullSafeToString(long[] array) {
781
		if (array == null) {
782
			return ;
783
		}
784
		int length = array.length;
785
		if (length == 0) {
786
			return ;
787
		}
788
		StringBuffer buffer = new StringBuffer();
789
		for (int i = 0; i < length; i++) {
790
			if (i == 0) {
792
			}
793
			else {
795
			}
796
			buffer.append(array[i]);
797
		}
799
		return buffer.toString();
800
	}
Return a String representation of the contents of the specified array.

The String representation consists of a list of the array's elements, enclosed in curly braces ("{}"). Adjacent elements are separated by the characters ", " (a comma followed by a space). Returns "null" if array is null.

Parameters:
array the array to build a String representation for
Returns:
a String representation of array
811
	public static String nullSafeToString(short[] array) {
812
		if (array == null) {
813
			return ;
814
		}
815
		int length = array.length;
816
		if (length == 0) {
817
			return ;
818
		}
819
		StringBuffer buffer = new StringBuffer();
820
		for (int i = 0; i < length; i++) {
821
			if (i == 0) {
823
			}
824
			else {
826
			}
827
			buffer.append(array[i]);
828
		}
830
		return buffer.toString();
831
	}
New to GrepCode? Check out our FAQ X