001 /* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.commons.lang3; 018 019 import java.lang.reflect.Array; 020 import java.util.HashMap; 021 import java.util.Map; 022 023 import org.apache.commons.lang3.builder.EqualsBuilder; 024 import org.apache.commons.lang3.builder.ToStringBuilder; 025 import org.apache.commons.lang3.builder.ToStringStyle; 026 027 /** 028 * <p>Operations on arrays, primitive arrays (like <code>int[]</code>) and 029 * primitive wrapper arrays (like <code>Integer[]</code>).</p> 030 * 031 * <p>This class tries to handle <code>null</code> input gracefully. 032 * An exception will not be thrown for a <code>null</code> 033 * array input. However, an Object array that contains a <code>null</code> 034 * element may throw an exception. Each method documents its behaviour.</p> 035 * 036 * <p>#ThreadSafe#</p> 037 * @author Apache Software Foundation 038 * @author Moritz Petersen 039 * @author <a href="mailto:fredrik@westermarck.com">Fredrik Westermarck</a> 040 * @author Nikolay Metchev 041 * @author Matthew Hawthorne 042 * @author Tim O'Brien 043 * @author Pete Gieser 044 * @author Gary Gregory 045 * @author <a href="mailto:equinus100@hotmail.com">Ashwin S</a> 046 * @author Maarten Coene 047 * @author <a href="mailto:levon@lk.otherinbox.com">Levon Karayan</a> 048 * @since 2.0 049 * @version $Id: ArrayUtils.java 918868 2010-03-04 06:22:16Z bayard $ 050 */ 051 public class ArrayUtils { 052 053 /** 054 * An empty immutable <code>Object</code> array. 055 */ 056 public static final Object[] EMPTY_OBJECT_ARRAY = new Object[0]; 057 /** 058 * An empty immutable <code>Class</code> array. 059 */ 060 public static final Class<?>[] EMPTY_CLASS_ARRAY = new Class[0]; 061 /** 062 * An empty immutable <code>String</code> array. 063 */ 064 public static final String[] EMPTY_STRING_ARRAY = new String[0]; 065 /** 066 * An empty immutable <code>long</code> array. 067 */ 068 public static final long[] EMPTY_LONG_ARRAY = new long[0]; 069 /** 070 * An empty immutable <code>Long</code> array. 071 */ 072 public static final Long[] EMPTY_LONG_OBJECT_ARRAY = new Long[0]; 073 /** 074 * An empty immutable <code>int</code> array. 075 */ 076 public static final int[] EMPTY_INT_ARRAY = new int[0]; 077 /** 078 * An empty immutable <code>Integer</code> array. 079 */ 080 public static final Integer[] EMPTY_INTEGER_OBJECT_ARRAY = new Integer[0]; 081 /** 082 * An empty immutable <code>short</code> array. 083 */ 084 public static final short[] EMPTY_SHORT_ARRAY = new short[0]; 085 /** 086 * An empty immutable <code>Short</code> array. 087 */ 088 public static final Short[] EMPTY_SHORT_OBJECT_ARRAY = new Short[0]; 089 /** 090 * An empty immutable <code>byte</code> array. 091 */ 092 public static final byte[] EMPTY_BYTE_ARRAY = new byte[0]; 093 /** 094 * An empty immutable <code>Byte</code> array. 095 */ 096 public static final Byte[] EMPTY_BYTE_OBJECT_ARRAY = new Byte[0]; 097 /** 098 * An empty immutable <code>double</code> array. 099 */ 100 public static final double[] EMPTY_DOUBLE_ARRAY = new double[0]; 101 /** 102 * An empty immutable <code>Double</code> array. 103 */ 104 public static final Double[] EMPTY_DOUBLE_OBJECT_ARRAY = new Double[0]; 105 /** 106 * An empty immutable <code>float</code> array. 107 */ 108 public static final float[] EMPTY_FLOAT_ARRAY = new float[0]; 109 /** 110 * An empty immutable <code>Float</code> array. 111 */ 112 public static final Float[] EMPTY_FLOAT_OBJECT_ARRAY = new Float[0]; 113 /** 114 * An empty immutable <code>boolean</code> array. 115 */ 116 public static final boolean[] EMPTY_BOOLEAN_ARRAY = new boolean[0]; 117 /** 118 * An empty immutable <code>Boolean</code> array. 119 */ 120 public static final Boolean[] EMPTY_BOOLEAN_OBJECT_ARRAY = new Boolean[0]; 121 /** 122 * An empty immutable <code>char</code> array. 123 */ 124 public static final char[] EMPTY_CHAR_ARRAY = new char[0]; 125 /** 126 * An empty immutable <code>Character</code> array. 127 */ 128 public static final Character[] EMPTY_CHARACTER_OBJECT_ARRAY = new Character[0]; 129 130 /** 131 * The index value when an element is not found in a list or array: <code>-1</code>. 132 * This value is returned by methods in this class and can also be used in comparisons with values returned by 133 * various method from {@link java.util.List}. 134 */ 135 public static final int INDEX_NOT_FOUND = -1; 136 137 /** 138 * <p>ArrayUtils instances should NOT be constructed in standard programming. 139 * Instead, the class should be used as <code>ArrayUtils.clone(new int[] {2})</code>.</p> 140 * 141 * <p>This constructor is public to permit tools that require a JavaBean instance 142 * to operate.</p> 143 */ 144 public ArrayUtils() { 145 super(); 146 } 147 148 // Basic methods handling multi-dimensional arrays 149 //----------------------------------------------------------------------- 150 /** 151 * <p>Outputs an array as a String, treating <code>null</code> as an empty array.</p> 152 * 153 * <p>Multi-dimensional arrays are handled correctly, including 154 * multi-dimensional primitive arrays.</p> 155 * 156 * <p>The format is that of Java source code, for example <code>{a,b}</code>.</p> 157 * 158 * @param array the array to get a toString for, may be <code>null</code> 159 * @return a String representation of the array, '{}' if null array input 160 */ 161 public static String toString(Object array) { 162 return toString(array, "{}"); 163 } 164 165 /** 166 * <p>Outputs an array as a String handling <code>null</code>s.</p> 167 * 168 * <p>Multi-dimensional arrays are handled correctly, including 169 * multi-dimensional primitive arrays.</p> 170 * 171 * <p>The format is that of Java source code, for example <code>{a,b}</code>.</p> 172 * 173 * @param array the array to get a toString for, may be <code>null</code> 174 * @param stringIfNull the String to return if the array is <code>null</code> 175 * @return a String representation of the array 176 */ 177 public static String toString(Object array, String stringIfNull) { 178 if (array == null) { 179 return stringIfNull; 180 } 181 return new ToStringBuilder(array, ToStringStyle.SIMPLE_STYLE).append(array).toString(); 182 } 183 184 /** 185 * <p>Compares two arrays, using equals(), handling multi-dimensional arrays 186 * correctly.</p> 187 * 188 * <p>Multi-dimensional primitive arrays are also handled correctly by this method.</p> 189 * 190 * @param array1 the left hand array to compare, may be <code>null</code> 191 * @param array2 the right hand array to compare, may be <code>null</code> 192 * @return <code>true</code> if the arrays are equal 193 */ 194 public static boolean isEquals(Object array1, Object array2) { 195 return new EqualsBuilder().append(array1, array2).isEquals(); 196 } 197 198 // To map 199 //----------------------------------------------------------------------- 200 /** 201 * <p>Converts the given array into a {@link java.util.Map}. Each element of the array 202 * must be either a {@link java.util.Map.Entry} or an Array, containing at least two 203 * elements, where the first element is used as key and the second as 204 * value.</p> 205 * 206 * <p>This method can be used to initialize:</p> 207 * <pre> 208 * // Create a Map mapping colors. 209 * Map colorMap = MapUtils.toMap(new String[][] {{ 210 * {"RED", "#FF0000"}, 211 * {"GREEN", "#00FF00"}, 212 * {"BLUE", "#0000FF"}}); 213 * </pre> 214 * 215 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 216 * 217 * @param array an array whose elements are either a {@link java.util.Map.Entry} or 218 * an Array containing at least two elements, may be <code>null</code> 219 * @return a <code>Map</code> that was created from the array 220 * @throws IllegalArgumentException if one element of this Array is 221 * itself an Array containing less then two elements 222 * @throws IllegalArgumentException if the array contains elements other 223 * than {@link java.util.Map.Entry} and an Array 224 */ 225 public static Map<Object, Object> toMap(Object[] array) { 226 if (array == null) { 227 return null; 228 } 229 final Map<Object, Object> map = new HashMap<Object, Object>((int) (array.length * 1.5)); 230 for (int i = 0; i < array.length; i++) { 231 Object object = array[i]; 232 if (object instanceof Map.Entry<?, ?>) { 233 Map.Entry<?,?> entry = (Map.Entry<?,?>) object; 234 map.put(entry.getKey(), entry.getValue()); 235 } else if (object instanceof Object[]) { 236 Object[] entry = (Object[]) object; 237 if (entry.length < 2) { 238 throw new IllegalArgumentException("Array element " + i + ", '" 239 + object 240 + "', has a length less than 2"); 241 } 242 map.put(entry[0], entry[1]); 243 } else { 244 throw new IllegalArgumentException("Array element " + i + ", '" 245 + object 246 + "', is neither of type Map.Entry nor an Array"); 247 } 248 } 249 return map; 250 } 251 252 // Generic array 253 //----------------------------------------------------------------------- 254 /** 255 * Create a type-safe generic array. 256 * 257 * <p>Arrays are covariant i.e. they cannot be created from a generic type:</p> 258 * 259 * <pre> 260 public static <T> T[] createAnArray(int size) 261 { 262 return T[size]; // compiler error here 263 } 264 public static <T> T[] createAnArray(int size) 265 { 266 return (T[])Object[size]; // ClassCastException at runtime 267 } 268 * </pre> 269 * 270 * <p>Therefore new arrays of generic types can be created with this method, e.g. an arrays 271 * of Strings:</p> 272 * 273 * <pre> 274 String[] array = ArrayUtils.toArray("1", "2"); 275 String[] emptyArray = ArrayUtils.<String>toArray(); 276 * </pre> 277 * 278 * The method is typically used in scenarios, where the caller itself uses generic types 279 * that have to be combined into an array. 280 * 281 * Note, this method makes only sense to provide arguments of the same type so that the 282 * compiler can deduce the type of the array itself. While it is possible to select the 283 * type explicitly like in <code>Number[] array = ArrayUtils.<Number>toArray(new 284 * Integer(42), new Double(Math.PI))</code>, there is no real advantage to <code>new 285 * Number[] {new Integer(42), new Double(Math.PI)}</code> anymore. 286 * 287 * @param <T> the array's element type 288 * @param items the items of the array 289 * @return the array 290 * @since 3.0 291 */ 292 public static <T> T[] toArray(final T... items) 293 { 294 return items; 295 } 296 297 // Clone 298 //----------------------------------------------------------------------- 299 /** 300 * <p>Shallow clones an array returning a typecast result and handling 301 * <code>null</code>.</p> 302 * 303 * <p>The objects in the array are not cloned, thus there is no special 304 * handling for multi-dimensional arrays.</p> 305 * 306 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 307 * 308 * @param array the array to shallow clone, may be <code>null</code> 309 * @return the cloned array, <code>null</code> if <code>null</code> input 310 */ 311 public static <T> T[] clone(T[] array) { 312 if (array == null) { 313 return null; 314 } 315 return array.clone(); 316 } 317 318 /** 319 * <p>Clones an array returning a typecast result and handling 320 * <code>null</code>.</p> 321 * 322 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 323 * 324 * @param array the array to clone, may be <code>null</code> 325 * @return the cloned array, <code>null</code> if <code>null</code> input 326 */ 327 public static long[] clone(long[] array) { 328 if (array == null) { 329 return null; 330 } 331 return array.clone(); 332 } 333 334 /** 335 * <p>Clones an array returning a typecast result and handling 336 * <code>null</code>.</p> 337 * 338 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 339 * 340 * @param array the array to clone, may be <code>null</code> 341 * @return the cloned array, <code>null</code> if <code>null</code> input 342 */ 343 public static int[] clone(int[] array) { 344 if (array == null) { 345 return null; 346 } 347 return array.clone(); 348 } 349 350 /** 351 * <p>Clones an array returning a typecast result and handling 352 * <code>null</code>.</p> 353 * 354 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 355 * 356 * @param array the array to clone, may be <code>null</code> 357 * @return the cloned array, <code>null</code> if <code>null</code> input 358 */ 359 public static short[] clone(short[] array) { 360 if (array == null) { 361 return null; 362 } 363 return array.clone(); 364 } 365 366 /** 367 * <p>Clones an array returning a typecast result and handling 368 * <code>null</code>.</p> 369 * 370 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 371 * 372 * @param array the array to clone, may be <code>null</code> 373 * @return the cloned array, <code>null</code> if <code>null</code> input 374 */ 375 public static char[] clone(char[] array) { 376 if (array == null) { 377 return null; 378 } 379 return array.clone(); 380 } 381 382 /** 383 * <p>Clones an array returning a typecast result and handling 384 * <code>null</code>.</p> 385 * 386 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 387 * 388 * @param array the array to clone, may be <code>null</code> 389 * @return the cloned array, <code>null</code> if <code>null</code> input 390 */ 391 public static byte[] clone(byte[] array) { 392 if (array == null) { 393 return null; 394 } 395 return array.clone(); 396 } 397 398 /** 399 * <p>Clones an array returning a typecast result and handling 400 * <code>null</code>.</p> 401 * 402 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 403 * 404 * @param array the array to clone, may be <code>null</code> 405 * @return the cloned array, <code>null</code> if <code>null</code> input 406 */ 407 public static double[] clone(double[] array) { 408 if (array == null) { 409 return null; 410 } 411 return array.clone(); 412 } 413 414 /** 415 * <p>Clones an array returning a typecast result and handling 416 * <code>null</code>.</p> 417 * 418 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 419 * 420 * @param array the array to clone, may be <code>null</code> 421 * @return the cloned array, <code>null</code> if <code>null</code> input 422 */ 423 public static float[] clone(float[] array) { 424 if (array == null) { 425 return null; 426 } 427 return array.clone(); 428 } 429 430 /** 431 * <p>Clones an array returning a typecast result and handling 432 * <code>null</code>.</p> 433 * 434 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 435 * 436 * @param array the array to clone, may be <code>null</code> 437 * @return the cloned array, <code>null</code> if <code>null</code> input 438 */ 439 public static boolean[] clone(boolean[] array) { 440 if (array == null) { 441 return null; 442 } 443 return array.clone(); 444 } 445 446 // nullToEmpty 447 //----------------------------------------------------------------------- 448 /** 449 * <p>Defensive programming technique to change a <code>null</code> 450 * reference to an empty one.</p> 451 * 452 * <p>This method returns an empty array for a <code>null</code> input array.</p> 453 * 454 * <p>As a memory optimizing technique an empty array passed in will be overridden with 455 * the empty <code>public static</code> references in this class.</p> 456 * 457 * @param array the array to check for <code>null</code> or empty 458 * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input 459 * @since 2.5 460 */ 461 public static Object[] nullToEmpty(Object[] array) { 462 if (array == null || array.length == 0) { 463 return EMPTY_OBJECT_ARRAY; 464 } 465 return array; 466 } 467 468 /** 469 * <p>Defensive programming technique to change a <code>null</code> 470 * reference to an empty one.</p> 471 * 472 * <p>This method returns an empty array for a <code>null</code> input array.</p> 473 * 474 * <p>As a memory optimizing technique an empty array passed in will be overridden with 475 * the empty <code>public static</code> references in this class.</p> 476 * 477 * @param array the array to check for <code>null</code> or empty 478 * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input 479 * @since 2.5 480 */ 481 public static String[] nullToEmpty(String[] array) { 482 if (array == null || array.length == 0) { 483 return EMPTY_STRING_ARRAY; 484 } 485 return array; 486 } 487 488 /** 489 * <p>Defensive programming technique to change a <code>null</code> 490 * reference to an empty one.</p> 491 * 492 * <p>This method returns an empty array for a <code>null</code> input array.</p> 493 * 494 * <p>As a memory optimizing technique an empty array passed in will be overridden with 495 * the empty <code>public static</code> references in this class.</p> 496 * 497 * @param array the array to check for <code>null</code> or empty 498 * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input 499 * @since 2.5 500 */ 501 public static long[] nullToEmpty(long[] array) { 502 if (array == null || array.length == 0) { 503 return EMPTY_LONG_ARRAY; 504 } 505 return array; 506 } 507 508 /** 509 * <p>Defensive programming technique to change a <code>null</code> 510 * reference to an empty one.</p> 511 * 512 * <p>This method returns an empty array for a <code>null</code> input array.</p> 513 * 514 * <p>As a memory optimizing technique an empty array passed in will be overridden with 515 * the empty <code>public static</code> references in this class.</p> 516 * 517 * @param array the array to check for <code>null</code> or empty 518 * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input 519 * @since 2.5 520 */ 521 public static int[] nullToEmpty(int[] array) { 522 if (array == null || array.length == 0) { 523 return EMPTY_INT_ARRAY; 524 } 525 return array; 526 } 527 528 /** 529 * <p>Defensive programming technique to change a <code>null</code> 530 * reference to an empty one.</p> 531 * 532 * <p>This method returns an empty array for a <code>null</code> input array.</p> 533 * 534 * <p>As a memory optimizing technique an empty array passed in will be overridden with 535 * the empty <code>public static</code> references in this class.</p> 536 * 537 * @param array the array to check for <code>null</code> or empty 538 * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input 539 * @since 2.5 540 */ 541 public static short[] nullToEmpty(short[] array) { 542 if (array == null || array.length == 0) { 543 return EMPTY_SHORT_ARRAY; 544 } 545 return array; 546 } 547 548 /** 549 * <p>Defensive programming technique to change a <code>null</code> 550 * reference to an empty one.</p> 551 * 552 * <p>This method returns an empty array for a <code>null</code> input array.</p> 553 * 554 * <p>As a memory optimizing technique an empty array passed in will be overridden with 555 * the empty <code>public static</code> references in this class.</p> 556 * 557 * @param array the array to check for <code>null</code> or empty 558 * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input 559 * @since 2.5 560 */ 561 public static char[] nullToEmpty(char[] array) { 562 if (array == null || array.length == 0) { 563 return EMPTY_CHAR_ARRAY; 564 } 565 return array; 566 } 567 568 /** 569 * <p>Defensive programming technique to change a <code>null</code> 570 * reference to an empty one.</p> 571 * 572 * <p>This method returns an empty array for a <code>null</code> input array.</p> 573 * 574 * <p>As a memory optimizing technique an empty array passed in will be overridden with 575 * the empty <code>public static</code> references in this class.</p> 576 * 577 * @param array the array to check for <code>null</code> or empty 578 * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input 579 * @since 2.5 580 */ 581 public static byte[] nullToEmpty(byte[] array) { 582 if (array == null || array.length == 0) { 583 return EMPTY_BYTE_ARRAY; 584 } 585 return array; 586 } 587 588 /** 589 * <p>Defensive programming technique to change a <code>null</code> 590 * reference to an empty one.</p> 591 * 592 * <p>This method returns an empty array for a <code>null</code> input array.</p> 593 * 594 * <p>As a memory optimizing technique an empty array passed in will be overridden with 595 * the empty <code>public static</code> references in this class.</p> 596 * 597 * @param array the array to check for <code>null</code> or empty 598 * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input 599 * @since 2.5 600 */ 601 public static double[] nullToEmpty(double[] array) { 602 if (array == null || array.length == 0) { 603 return EMPTY_DOUBLE_ARRAY; 604 } 605 return array; 606 } 607 608 /** 609 * <p>Defensive programming technique to change a <code>null</code> 610 * reference to an empty one.</p> 611 * 612 * <p>This method returns an empty array for a <code>null</code> input array.</p> 613 * 614 * <p>As a memory optimizing technique an empty array passed in will be overridden with 615 * the empty <code>public static</code> references in this class.</p> 616 * 617 * @param array the array to check for <code>null</code> or empty 618 * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input 619 * @since 2.5 620 */ 621 public static float[] nullToEmpty(float[] array) { 622 if (array == null || array.length == 0) { 623 return EMPTY_FLOAT_ARRAY; 624 } 625 return array; 626 } 627 628 /** 629 * <p>Defensive programming technique to change a <code>null</code> 630 * reference to an empty one.</p> 631 * 632 * <p>This method returns an empty array for a <code>null</code> input array.</p> 633 * 634 * <p>As a memory optimizing technique an empty array passed in will be overridden with 635 * the empty <code>public static</code> references in this class.</p> 636 * 637 * @param array the array to check for <code>null</code> or empty 638 * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input 639 * @since 2.5 640 */ 641 public static boolean[] nullToEmpty(boolean[] array) { 642 if (array == null || array.length == 0) { 643 return EMPTY_BOOLEAN_ARRAY; 644 } 645 return array; 646 } 647 648 /** 649 * <p>Defensive programming technique to change a <code>null</code> 650 * reference to an empty one.</p> 651 * 652 * <p>This method returns an empty array for a <code>null</code> input array.</p> 653 * 654 * <p>As a memory optimizing technique an empty array passed in will be overridden with 655 * the empty <code>public static</code> references in this class.</p> 656 * 657 * @param array the array to check for <code>null</code> or empty 658 * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input 659 * @since 2.5 660 */ 661 public static Long[] nullToEmpty(Long[] array) { 662 if (array == null || array.length == 0) { 663 return EMPTY_LONG_OBJECT_ARRAY; 664 } 665 return array; 666 } 667 668 /** 669 * <p>Defensive programming technique to change a <code>null</code> 670 * reference to an empty one.</p> 671 * 672 * <p>This method returns an empty array for a <code>null</code> input array.</p> 673 * 674 * <p>As a memory optimizing technique an empty array passed in will be overridden with 675 * the empty <code>public static</code> references in this class.</p> 676 * 677 * @param array the array to check for <code>null</code> or empty 678 * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input 679 * @since 2.5 680 */ 681 public static Integer[] nullToEmpty(Integer[] array) { 682 if (array == null || array.length == 0) { 683 return EMPTY_INTEGER_OBJECT_ARRAY; 684 } 685 return array; 686 } 687 688 /** 689 * <p>Defensive programming technique to change a <code>null</code> 690 * reference to an empty one.</p> 691 * 692 * <p>This method returns an empty array for a <code>null</code> input array.</p> 693 * 694 * <p>As a memory optimizing technique an empty array passed in will be overridden with 695 * the empty <code>public static</code> references in this class.</p> 696 * 697 * @param array the array to check for <code>null</code> or empty 698 * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input 699 * @since 2.5 700 */ 701 public static Short[] nullToEmpty(Short[] array) { 702 if (array == null || array.length == 0) { 703 return EMPTY_SHORT_OBJECT_ARRAY; 704 } 705 return array; 706 } 707 708 /** 709 * <p>Defensive programming technique to change a <code>null</code> 710 * reference to an empty one.</p> 711 * 712 * <p>This method returns an empty array for a <code>null</code> input array.</p> 713 * 714 * <p>As a memory optimizing technique an empty array passed in will be overridden with 715 * the empty <code>public static</code> references in this class.</p> 716 * 717 * @param array the array to check for <code>null</code> or empty 718 * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input 719 * @since 2.5 720 */ 721 public static Character[] nullToEmpty(Character[] array) { 722 if (array == null || array.length == 0) { 723 return EMPTY_CHARACTER_OBJECT_ARRAY; 724 } 725 return array; 726 } 727 728 /** 729 * <p>Defensive programming technique to change a <code>null</code> 730 * reference to an empty one.</p> 731 * 732 * <p>This method returns an empty array for a <code>null</code> input array.</p> 733 * 734 * <p>As a memory optimizing technique an empty array passed in will be overridden with 735 * the empty <code>public static</code> references in this class.</p> 736 * 737 * @param array the array to check for <code>null</code> or empty 738 * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input 739 * @since 2.5 740 */ 741 public static Byte[] nullToEmpty(Byte[] array) { 742 if (array == null || array.length == 0) { 743 return EMPTY_BYTE_OBJECT_ARRAY; 744 } 745 return array; 746 } 747 748 /** 749 * <p>Defensive programming technique to change a <code>null</code> 750 * reference to an empty one.</p> 751 * 752 * <p>This method returns an empty array for a <code>null</code> input array.</p> 753 * 754 * <p>As a memory optimizing technique an empty array passed in will be overridden with 755 * the empty <code>public static</code> references in this class.</p> 756 * 757 * @param array the array to check for <code>null</code> or empty 758 * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input 759 * @since 2.5 760 */ 761 public static Double[] nullToEmpty(Double[] array) { 762 if (array == null || array.length == 0) { 763 return EMPTY_DOUBLE_OBJECT_ARRAY; 764 } 765 return array; 766 } 767 768 /** 769 * <p>Defensive programming technique to change a <code>null</code> 770 * reference to an empty one.</p> 771 * 772 * <p>This method returns an empty array for a <code>null</code> input array.</p> 773 * 774 * <p>As a memory optimizing technique an empty array passed in will be overridden with 775 * the empty <code>public static</code> references in this class.</p> 776 * 777 * @param array the array to check for <code>null</code> or empty 778 * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input 779 * @since 2.5 780 */ 781 public static Float[] nullToEmpty(Float[] array) { 782 if (array == null || array.length == 0) { 783 return EMPTY_FLOAT_OBJECT_ARRAY; 784 } 785 return array; 786 } 787 788 /** 789 * <p>Defensive programming technique to change a <code>null</code> 790 * reference to an empty one.</p> 791 * 792 * <p>This method returns an empty array for a <code>null</code> input array.</p> 793 * 794 * <p>As a memory optimizing technique an empty array passed in will be overridden with 795 * the empty <code>public static</code> references in this class.</p> 796 * 797 * @param array the array to check for <code>null</code> or empty 798 * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input 799 * @since 2.5 800 */ 801 public static Boolean[] nullToEmpty(Boolean[] array) { 802 if (array == null || array.length == 0) { 803 return EMPTY_BOOLEAN_OBJECT_ARRAY; 804 } 805 return array; 806 } 807 808 // Subarrays 809 //----------------------------------------------------------------------- 810 /** 811 * <p>Produces a new array containing the elements between 812 * the start and end indices.</p> 813 * 814 * <p>The start index is inclusive, the end index exclusive. 815 * Null array input produces null output.</p> 816 * 817 * <p>The component type of the subarray is always the same as 818 * that of the input array. Thus, if the input is an array of type 819 * <code>Date</code>, the following usage is envisaged:</p> 820 * 821 * <pre> 822 * Date[] someDates = (Date[])ArrayUtils.subarray(allDates, 2, 5); 823 * </pre> 824 * 825 * @param array the array 826 * @param startIndexInclusive the starting index. Undervalue (<0) 827 * is promoted to 0, overvalue (>array.length) results 828 * in an empty array. 829 * @param endIndexExclusive elements up to endIndex-1 are present in the 830 * returned subarray. Undervalue (< startIndex) produces 831 * empty array, overvalue (>array.length) is demoted to 832 * array length. 833 * @return a new array containing the elements between 834 * the start and end indices. 835 * @since 2.1 836 */ 837 public static <T> T[] subarray(T[] array, int startIndexInclusive, int endIndexExclusive) { 838 if (array == null) { 839 return null; 840 } 841 if (startIndexInclusive < 0) { 842 startIndexInclusive = 0; 843 } 844 if (endIndexExclusive > array.length) { 845 endIndexExclusive = array.length; 846 } 847 int newSize = endIndexExclusive - startIndexInclusive; 848 Class<?> type = array.getClass().getComponentType(); 849 if (newSize <= 0) { 850 @SuppressWarnings("unchecked") // OK, because array is of type T 851 final T[] emptyArray = (T[]) Array.newInstance(type, 0); 852 return emptyArray; 853 } 854 @SuppressWarnings("unchecked") // OK, because array is of type T 855 T[] subarray = (T[]) Array.newInstance(type, newSize); 856 System.arraycopy(array, startIndexInclusive, subarray, 0, newSize); 857 return subarray; 858 } 859 860 /** 861 * <p>Produces a new <code>long</code> array containing the elements 862 * between the start and end indices.</p> 863 * 864 * <p>The start index is inclusive, the end index exclusive. 865 * Null array input produces null output.</p> 866 * 867 * @param array the array 868 * @param startIndexInclusive the starting index. Undervalue (<0) 869 * is promoted to 0, overvalue (>array.length) results 870 * in an empty array. 871 * @param endIndexExclusive elements up to endIndex-1 are present in the 872 * returned subarray. Undervalue (< startIndex) produces 873 * empty array, overvalue (>array.length) is demoted to 874 * array length. 875 * @return a new array containing the elements between 876 * the start and end indices. 877 * @since 2.1 878 */ 879 public static long[] subarray(long[] array, int startIndexInclusive, int endIndexExclusive) { 880 if (array == null) { 881 return null; 882 } 883 if (startIndexInclusive < 0) { 884 startIndexInclusive = 0; 885 } 886 if (endIndexExclusive > array.length) { 887 endIndexExclusive = array.length; 888 } 889 int newSize = endIndexExclusive - startIndexInclusive; 890 if (newSize <= 0) { 891 return EMPTY_LONG_ARRAY; 892 } 893 894 long[] subarray = new long[newSize]; 895 System.arraycopy(array, startIndexInclusive, subarray, 0, newSize); 896 return subarray; 897 } 898 899 /** 900 * <p>Produces a new <code>int</code> array containing the elements 901 * between the start and end indices.</p> 902 * 903 * <p>The start index is inclusive, the end index exclusive. 904 * Null array input produces null output.</p> 905 * 906 * @param array the array 907 * @param startIndexInclusive the starting index. Undervalue (<0) 908 * is promoted to 0, overvalue (>array.length) results 909 * in an empty array. 910 * @param endIndexExclusive elements up to endIndex-1 are present in the 911 * returned subarray. Undervalue (< startIndex) produces 912 * empty array, overvalue (>array.length) is demoted to 913 * array length. 914 * @return a new array containing the elements between 915 * the start and end indices. 916 * @since 2.1 917 */ 918 public static int[] subarray(int[] array, int startIndexInclusive, int endIndexExclusive) { 919 if (array == null) { 920 return null; 921 } 922 if (startIndexInclusive < 0) { 923 startIndexInclusive = 0; 924 } 925 if (endIndexExclusive > array.length) { 926 endIndexExclusive = array.length; 927 } 928 int newSize = endIndexExclusive - startIndexInclusive; 929 if (newSize <= 0) { 930 return EMPTY_INT_ARRAY; 931 } 932 933 int[] subarray = new int[newSize]; 934 System.arraycopy(array, startIndexInclusive, subarray, 0, newSize); 935 return subarray; 936 } 937 938 /** 939 * <p>Produces a new <code>short</code> array containing the elements 940 * between the start and end indices.</p> 941 * 942 * <p>The start index is inclusive, the end index exclusive. 943 * Null array input produces null output.</p> 944 * 945 * @param array the array 946 * @param startIndexInclusive the starting index. Undervalue (<0) 947 * is promoted to 0, overvalue (>array.length) results 948 * in an empty array. 949 * @param endIndexExclusive elements up to endIndex-1 are present in the 950 * returned subarray. Undervalue (< startIndex) produces 951 * empty array, overvalue (>array.length) is demoted to 952 * array length. 953 * @return a new array containing the elements between 954 * the start and end indices. 955 * @since 2.1 956 */ 957 public static short[] subarray(short[] array, int startIndexInclusive, int endIndexExclusive) { 958 if (array == null) { 959 return null; 960 } 961 if (startIndexInclusive < 0) { 962 startIndexInclusive = 0; 963 } 964 if (endIndexExclusive > array.length) { 965 endIndexExclusive = array.length; 966 } 967 int newSize = endIndexExclusive - startIndexInclusive; 968 if (newSize <= 0) { 969 return EMPTY_SHORT_ARRAY; 970 } 971 972 short[] subarray = new short[newSize]; 973 System.arraycopy(array, startIndexInclusive, subarray, 0, newSize); 974 return subarray; 975 } 976 977 /** 978 * <p>Produces a new <code>char</code> array containing the elements 979 * between the start and end indices.</p> 980 * 981 * <p>The start index is inclusive, the end index exclusive. 982 * Null array input produces null output.</p> 983 * 984 * @param array the array 985 * @param startIndexInclusive the starting index. Undervalue (<0) 986 * is promoted to 0, overvalue (>array.length) results 987 * in an empty array. 988 * @param endIndexExclusive elements up to endIndex-1 are present in the 989 * returned subarray. Undervalue (< startIndex) produces 990 * empty array, overvalue (>array.length) is demoted to 991 * array length. 992 * @return a new array containing the elements between 993 * the start and end indices. 994 * @since 2.1 995 */ 996 public static char[] subarray(char[] array, int startIndexInclusive, int endIndexExclusive) { 997 if (array == null) { 998 return null; 999 } 1000 if (startIndexInclusive < 0) { 1001 startIndexInclusive = 0; 1002 } 1003 if (endIndexExclusive > array.length) { 1004 endIndexExclusive = array.length; 1005 } 1006 int newSize = endIndexExclusive - startIndexInclusive; 1007 if (newSize <= 0) { 1008 return EMPTY_CHAR_ARRAY; 1009 } 1010 1011 char[] subarray = new char[newSize]; 1012 System.arraycopy(array, startIndexInclusive, subarray, 0, newSize); 1013 return subarray; 1014 } 1015 1016 /** 1017 * <p>Produces a new <code>byte</code> array containing the elements 1018 * between the start and end indices.</p> 1019 * 1020 * <p>The start index is inclusive, the end index exclusive. 1021 * Null array input produces null output.</p> 1022 * 1023 * @param array the array 1024 * @param startIndexInclusive the starting index. Undervalue (<0) 1025 * is promoted to 0, overvalue (>array.length) results 1026 * in an empty array. 1027 * @param endIndexExclusive elements up to endIndex-1 are present in the 1028 * returned subarray. Undervalue (< startIndex) produces 1029 * empty array, overvalue (>array.length) is demoted to 1030 * array length. 1031 * @return a new array containing the elements between 1032 * the start and end indices. 1033 * @since 2.1 1034 */ 1035 public static byte[] subarray(byte[] array, int startIndexInclusive, int endIndexExclusive) { 1036 if (array == null) { 1037 return null; 1038 } 1039 if (startIndexInclusive < 0) { 1040 startIndexInclusive = 0; 1041 } 1042 if (endIndexExclusive > array.length) { 1043 endIndexExclusive = array.length; 1044 } 1045 int newSize = endIndexExclusive - startIndexInclusive; 1046 if (newSize <= 0) { 1047 return EMPTY_BYTE_ARRAY; 1048 } 1049 1050 byte[] subarray = new byte[newSize]; 1051 System.arraycopy(array, startIndexInclusive, subarray, 0, newSize); 1052 return subarray; 1053 } 1054 1055 /** 1056 * <p>Produces a new <code>double</code> array containing the elements 1057 * between the start and end indices.</p> 1058 * 1059 * <p>The start index is inclusive, the end index exclusive. 1060 * Null array input produces null output.</p> 1061 * 1062 * @param array the array 1063 * @param startIndexInclusive the starting index. Undervalue (<0) 1064 * is promoted to 0, overvalue (>array.length) results 1065 * in an empty array. 1066 * @param endIndexExclusive elements up to endIndex-1 are present in the 1067 * returned subarray. Undervalue (< startIndex) produces 1068 * empty array, overvalue (>array.length) is demoted to 1069 * array length. 1070 * @return a new array containing the elements between 1071 * the start and end indices. 1072 * @since 2.1 1073 */ 1074 public static double[] subarray(double[] array, int startIndexInclusive, int endIndexExclusive) { 1075 if (array == null) { 1076 return null; 1077 } 1078 if (startIndexInclusive < 0) { 1079 startIndexInclusive = 0; 1080 } 1081 if (endIndexExclusive > array.length) { 1082 endIndexExclusive = array.length; 1083 } 1084 int newSize = endIndexExclusive - startIndexInclusive; 1085 if (newSize <= 0) { 1086 return EMPTY_DOUBLE_ARRAY; 1087 } 1088 1089 double[] subarray = new double[newSize]; 1090 System.arraycopy(array, startIndexInclusive, subarray, 0, newSize); 1091 return subarray; 1092 } 1093 1094 /** 1095 * <p>Produces a new <code>float</code> array containing the elements 1096 * between the start and end indices.</p> 1097 * 1098 * <p>The start index is inclusive, the end index exclusive. 1099 * Null array input produces null output.</p> 1100 * 1101 * @param array the array 1102 * @param startIndexInclusive the starting index. Undervalue (<0) 1103 * is promoted to 0, overvalue (>array.length) results 1104 * in an empty array. 1105 * @param endIndexExclusive elements up to endIndex-1 are present in the 1106 * returned subarray. Undervalue (< startIndex) produces 1107 * empty array, overvalue (>array.length) is demoted to 1108 * array length. 1109 * @return a new array containing the elements between 1110 * the start and end indices. 1111 * @since 2.1 1112 */ 1113 public static float[] subarray(float[] array, int startIndexInclusive, int endIndexExclusive) { 1114 if (array == null) { 1115 return null; 1116 } 1117 if (startIndexInclusive < 0) { 1118 startIndexInclusive = 0; 1119 } 1120 if (endIndexExclusive > array.length) { 1121 endIndexExclusive = array.length; 1122 } 1123 int newSize = endIndexExclusive - startIndexInclusive; 1124 if (newSize <= 0) { 1125 return EMPTY_FLOAT_ARRAY; 1126 } 1127 1128 float[] subarray = new float[newSize]; 1129 System.arraycopy(array, startIndexInclusive, subarray, 0, newSize); 1130 return subarray; 1131 } 1132 1133 /** 1134 * <p>Produces a new <code>boolean</code> array containing the elements 1135 * between the start and end indices.</p> 1136 * 1137 * <p>The start index is inclusive, the end index exclusive. 1138 * Null array input produces null output.</p> 1139 * 1140 * @param array the array 1141 * @param startIndexInclusive the starting index. Undervalue (<0) 1142 * is promoted to 0, overvalue (>array.length) results 1143 * in an empty array. 1144 * @param endIndexExclusive elements up to endIndex-1 are present in the 1145 * returned subarray. Undervalue (< startIndex) produces 1146 * empty array, overvalue (>array.length) is demoted to 1147 * array length. 1148 * @return a new array containing the elements between 1149 * the start and end indices. 1150 * @since 2.1 1151 */ 1152 public static boolean[] subarray(boolean[] array, int startIndexInclusive, int endIndexExclusive) { 1153 if (array == null) { 1154 return null; 1155 } 1156 if (startIndexInclusive < 0) { 1157 startIndexInclusive = 0; 1158 } 1159 if (endIndexExclusive > array.length) { 1160 endIndexExclusive = array.length; 1161 } 1162 int newSize = endIndexExclusive - startIndexInclusive; 1163 if (newSize <= 0) { 1164 return EMPTY_BOOLEAN_ARRAY; 1165 } 1166 1167 boolean[] subarray = new boolean[newSize]; 1168 System.arraycopy(array, startIndexInclusive, subarray, 0, newSize); 1169 return subarray; 1170 } 1171 1172 // Is same length 1173 //----------------------------------------------------------------------- 1174 /** 1175 * <p>Checks whether two arrays are the same length, treating 1176 * <code>null</code> arrays as length <code>0</code>. 1177 * 1178 * <p>Any multi-dimensional aspects of the arrays are ignored.</p> 1179 * 1180 * @param array1 the first array, may be <code>null</code> 1181 * @param array2 the second array, may be <code>null</code> 1182 * @return <code>true</code> if length of arrays matches, treating 1183 * <code>null</code> as an empty array 1184 */ 1185 public static boolean isSameLength(Object[] array1, Object[] array2) { 1186 if ((array1 == null && array2 != null && array2.length > 0) || 1187 (array2 == null && array1 != null && array1.length > 0) || 1188 (array1 != null && array2 != null && array1.length != array2.length)) { 1189 return false; 1190 } 1191 return true; 1192 } 1193 1194 /** 1195 * <p>Checks whether two arrays are the same length, treating 1196 * <code>null</code> arrays as length <code>0</code>.</p> 1197 * 1198 * @param array1 the first array, may be <code>null</code> 1199 * @param array2 the second array, may be <code>null</code> 1200 * @return <code>true</code> if length of arrays matches, treating 1201 * <code>null</code> as an empty array 1202 */ 1203 public static boolean isSameLength(long[] array1, long[] array2) { 1204 if ((array1 == null && array2 != null && array2.length > 0) || 1205 (array2 == null && array1 != null && array1.length > 0) || 1206 (array1 != null && array2 != null && array1.length != array2.length)) { 1207 return false; 1208 } 1209 return true; 1210 } 1211 1212 /** 1213 * <p>Checks whether two arrays are the same length, treating 1214 * <code>null</code> arrays as length <code>0</code>.</p> 1215 * 1216 * @param array1 the first array, may be <code>null</code> 1217 * @param array2 the second array, may be <code>null</code> 1218 * @return <code>true</code> if length of arrays matches, treating 1219 * <code>null</code> as an empty array 1220 */ 1221 public static boolean isSameLength(int[] array1, int[] array2) { 1222 if ((array1 == null && array2 != null && array2.length > 0) || 1223 (array2 == null && array1 != null && array1.length > 0) || 1224 (array1 != null && array2 != null && array1.length != array2.length)) { 1225 return false; 1226 } 1227 return true; 1228 } 1229 1230 /** 1231 * <p>Checks whether two arrays are the same length, treating 1232 * <code>null</code> arrays as length <code>0</code>.</p> 1233 * 1234 * @param array1 the first array, may be <code>null</code> 1235 * @param array2 the second array, may be <code>null</code> 1236 * @return <code>true</code> if length of arrays matches, treating 1237 * <code>null</code> as an empty array 1238 */ 1239 public static boolean isSameLength(short[] array1, short[] array2) { 1240 if ((array1 == null && array2 != null && array2.length > 0) || 1241 (array2 == null && array1 != null && array1.length > 0) || 1242 (array1 != null && array2 != null && array1.length != array2.length)) { 1243 return false; 1244 } 1245 return true; 1246 } 1247 1248 /** 1249 * <p>Checks whether two arrays are the same length, treating 1250 * <code>null</code> arrays as length <code>0</code>.</p> 1251 * 1252 * @param array1 the first array, may be <code>null</code> 1253 * @param array2 the second array, may be <code>null</code> 1254 * @return <code>true</code> if length of arrays matches, treating 1255 * <code>null</code> as an empty array 1256 */ 1257 public static boolean isSameLength(char[] array1, char[] array2) { 1258 if ((array1 == null && array2 != null && array2.length > 0) || 1259 (array2 == null && array1 != null && array1.length > 0) || 1260 (array1 != null && array2 != null && array1.length != array2.length)) { 1261 return false; 1262 } 1263 return true; 1264 } 1265 1266 /** 1267 * <p>Checks whether two arrays are the same length, treating 1268 * <code>null</code> arrays as length <code>0</code>.</p> 1269 * 1270 * @param array1 the first array, may be <code>null</code> 1271 * @param array2 the second array, may be <code>null</code> 1272 * @return <code>true</code> if length of arrays matches, treating 1273 * <code>null</code> as an empty array 1274 */ 1275 public static boolean isSameLength(byte[] array1, byte[] array2) { 1276 if ((array1 == null && array2 != null && array2.length > 0) || 1277 (array2 == null && array1 != null && array1.length > 0) || 1278 (array1 != null && array2 != null && array1.length != array2.length)) { 1279 return false; 1280 } 1281 return true; 1282 } 1283 1284 /** 1285 * <p>Checks whether two arrays are the same length, treating 1286 * <code>null</code> arrays as length <code>0</code>.</p> 1287 * 1288 * @param array1 the first array, may be <code>null</code> 1289 * @param array2 the second array, may be <code>null</code> 1290 * @return <code>true</code> if length of arrays matches, treating 1291 * <code>null</code> as an empty array 1292 */ 1293 public static boolean isSameLength(double[] array1, double[] array2) { 1294 if ((array1 == null && array2 != null && array2.length > 0) || 1295 (array2 == null && array1 != null && array1.length > 0) || 1296 (array1 != null && array2 != null && array1.length != array2.length)) { 1297 return false; 1298 } 1299 return true; 1300 } 1301 1302 /** 1303 * <p>Checks whether two arrays are the same length, treating 1304 * <code>null</code> arrays as length <code>0</code>.</p> 1305 * 1306 * @param array1 the first array, may be <code>null</code> 1307 * @param array2 the second array, may be <code>null</code> 1308 * @return <code>true</code> if length of arrays matches, treating 1309 * <code>null</code> as an empty array 1310 */ 1311 public static boolean isSameLength(float[] array1, float[] array2) { 1312 if ((array1 == null && array2 != null && array2.length > 0) || 1313 (array2 == null && array1 != null && array1.length > 0) || 1314 (array1 != null && array2 != null && array1.length != array2.length)) { 1315 return false; 1316 } 1317 return true; 1318 } 1319 1320 /** 1321 * <p>Checks whether two arrays are the same length, treating 1322 * <code>null</code> arrays as length <code>0</code>.</p> 1323 * 1324 * @param array1 the first array, may be <code>null</code> 1325 * @param array2 the second array, may be <code>null</code> 1326 * @return <code>true</code> if length of arrays matches, treating 1327 * <code>null</code> as an empty array 1328 */ 1329 public static boolean isSameLength(boolean[] array1, boolean[] array2) { 1330 if ((array1 == null && array2 != null && array2.length > 0) || 1331 (array2 == null && array1 != null && array1.length > 0) || 1332 (array1 != null && array2 != null && array1.length != array2.length)) { 1333 return false; 1334 } 1335 return true; 1336 } 1337 1338 //----------------------------------------------------------------------- 1339 /** 1340 * <p>Returns the length of the specified array. 1341 * This method can deal with <code>Object</code> arrays and with primitive arrays.</p> 1342 * 1343 * <p>If the input array is <code>null</code>, <code>0</code> is returned.</p> 1344 * 1345 * <pre> 1346 * ArrayUtils.getLength(null) = 0 1347 * ArrayUtils.getLength([]) = 0 1348 * ArrayUtils.getLength([null]) = 1 1349 * ArrayUtils.getLength([true, false]) = 2 1350 * ArrayUtils.getLength([1, 2, 3]) = 3 1351 * ArrayUtils.getLength(["a", "b", "c"]) = 3 1352 * </pre> 1353 * 1354 * @param array the array to retrieve the length from, may be null 1355 * @return The length of the array, or <code>0</code> if the array is <code>null</code> 1356 * @throws IllegalArgumentException if the object arguement is not an array. 1357 * @since 2.1 1358 */ 1359 public static int getLength(Object array) { 1360 if (array == null) { 1361 return 0; 1362 } 1363 return Array.getLength(array); 1364 } 1365 1366 /** 1367 * <p>Checks whether two arrays are the same type taking into account 1368 * multi-dimensional arrays.</p> 1369 * 1370 * @param array1 the first array, must not be <code>null</code> 1371 * @param array2 the second array, must not be <code>null</code> 1372 * @return <code>true</code> if type of arrays matches 1373 * @throws IllegalArgumentException if either array is <code>null</code> 1374 */ 1375 public static boolean isSameType(Object array1, Object array2) { 1376 if (array1 == null || array2 == null) { 1377 throw new IllegalArgumentException("The Array must not be null"); 1378 } 1379 return array1.getClass().getName().equals(array2.getClass().getName()); 1380 } 1381 1382 // Reverse 1383 //----------------------------------------------------------------------- 1384 /** 1385 * <p>Reverses the order of the given array.</p> 1386 * 1387 * <p>There is no special handling for multi-dimensional arrays.</p> 1388 * 1389 * <p>This method does nothing for a <code>null</code> input array.</p> 1390 * 1391 * @param array the array to reverse, may be <code>null</code> 1392 */ 1393 public static void reverse(Object[] array) { 1394 if (array == null) { 1395 return; 1396 } 1397 int i = 0; 1398 int j = array.length - 1; 1399 Object tmp; 1400 while (j > i) { 1401 tmp = array[j]; 1402 array[j] = array[i]; 1403 array[i] = tmp; 1404 j--; 1405 i++; 1406 } 1407 } 1408 1409 /** 1410 * <p>Reverses the order of the given array.</p> 1411 * 1412 * <p>This method does nothing for a <code>null</code> input array.</p> 1413 * 1414 * @param array the array to reverse, may be <code>null</code> 1415 */ 1416 public static void reverse(long[] array) { 1417 if (array == null) { 1418 return; 1419 } 1420 int i = 0; 1421 int j = array.length - 1; 1422 long tmp; 1423 while (j > i) { 1424 tmp = array[j]; 1425 array[j] = array[i]; 1426 array[i] = tmp; 1427 j--; 1428 i++; 1429 } 1430 } 1431 1432 /** 1433 * <p>Reverses the order of the given array.</p> 1434 * 1435 * <p>This method does nothing for a <code>null</code> input array.</p> 1436 * 1437 * @param array the array to reverse, may be <code>null</code> 1438 */ 1439 public static void reverse(int[] array) { 1440 if (array == null) { 1441 return; 1442 } 1443 int i = 0; 1444 int j = array.length - 1; 1445 int tmp; 1446 while (j > i) { 1447 tmp = array[j]; 1448 array[j] = array[i]; 1449 array[i] = tmp; 1450 j--; 1451 i++; 1452 } 1453 } 1454 1455 /** 1456 * <p>Reverses the order of the given array.</p> 1457 * 1458 * <p>This method does nothing for a <code>null</code> input array.</p> 1459 * 1460 * @param array the array to reverse, may be <code>null</code> 1461 */ 1462 public static void reverse(short[] array) { 1463 if (array == null) { 1464 return; 1465 } 1466 int i = 0; 1467 int j = array.length - 1; 1468 short tmp; 1469 while (j > i) { 1470 tmp = array[j]; 1471 array[j] = array[i]; 1472 array[i] = tmp; 1473 j--; 1474 i++; 1475 } 1476 } 1477 1478 /** 1479 * <p>Reverses the order of the given array.</p> 1480 * 1481 * <p>This method does nothing for a <code>null</code> input array.</p> 1482 * 1483 * @param array the array to reverse, may be <code>null</code> 1484 */ 1485 public static void reverse(char[] array) { 1486 if (array == null) { 1487 return; 1488 } 1489 int i = 0; 1490 int j = array.length - 1; 1491 char tmp; 1492 while (j > i) { 1493 tmp = array[j]; 1494 array[j] = array[i]; 1495 array[i] = tmp; 1496 j--; 1497 i++; 1498 } 1499 } 1500 1501 /** 1502 * <p>Reverses the order of the given array.</p> 1503 * 1504 * <p>This method does nothing for a <code>null</code> input array.</p> 1505 * 1506 * @param array the array to reverse, may be <code>null</code> 1507 */ 1508 public static void reverse(byte[] array) { 1509 if (array == null) { 1510 return; 1511 } 1512 int i = 0; 1513 int j = array.length - 1; 1514 byte tmp; 1515 while (j > i) { 1516 tmp = array[j]; 1517 array[j] = array[i]; 1518 array[i] = tmp; 1519 j--; 1520 i++; 1521 } 1522 } 1523 1524 /** 1525 * <p>Reverses the order of the given array.</p> 1526 * 1527 * <p>This method does nothing for a <code>null</code> input array.</p> 1528 * 1529 * @param array the array to reverse, may be <code>null</code> 1530 */ 1531 public static void reverse(double[] array) { 1532 if (array == null) { 1533 return; 1534 } 1535 int i = 0; 1536 int j = array.length - 1; 1537 double tmp; 1538 while (j > i) { 1539 tmp = array[j]; 1540 array[j] = array[i]; 1541 array[i] = tmp; 1542 j--; 1543 i++; 1544 } 1545 } 1546 1547 /** 1548 * <p>Reverses the order of the given array.</p> 1549 * 1550 * <p>This method does nothing for a <code>null</code> input array.</p> 1551 * 1552 * @param array the array to reverse, may be <code>null</code> 1553 */ 1554 public static void reverse(float[] array) { 1555 if (array == null) { 1556 return; 1557 } 1558 int i = 0; 1559 int j = array.length - 1; 1560 float tmp; 1561 while (j > i) { 1562 tmp = array[j]; 1563 array[j] = array[i]; 1564 array[i] = tmp; 1565 j--; 1566 i++; 1567 } 1568 } 1569 1570 /** 1571 * <p>Reverses the order of the given array.</p> 1572 * 1573 * <p>This method does nothing for a <code>null</code> input array.</p> 1574 * 1575 * @param array the array to reverse, may be <code>null</code> 1576 */ 1577 public static void reverse(boolean[] array) { 1578 if (array == null) { 1579 return; 1580 } 1581 int i = 0; 1582 int j = array.length - 1; 1583 boolean tmp; 1584 while (j > i) { 1585 tmp = array[j]; 1586 array[j] = array[i]; 1587 array[i] = tmp; 1588 j--; 1589 i++; 1590 } 1591 } 1592 1593 // IndexOf search 1594 // ---------------------------------------------------------------------- 1595 1596 // Object IndexOf 1597 //----------------------------------------------------------------------- 1598 /** 1599 * <p>Finds the index of the given object in the array.</p> 1600 * 1601 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 1602 * 1603 * @param array the array to search through for the object, may be <code>null</code> 1604 * @param objectToFind the object to find, may be <code>null</code> 1605 * @return the index of the object within the array, 1606 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 1607 */ 1608 public static int indexOf(Object[] array, Object objectToFind) { 1609 return indexOf(array, objectToFind, 0); 1610 } 1611 1612 /** 1613 * <p>Finds the index of the given object in the array starting at the given index.</p> 1614 * 1615 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 1616 * 1617 * <p>A negative startIndex is treated as zero. A startIndex larger than the array 1618 * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p> 1619 * 1620 * @param array the array to search through for the object, may be <code>null</code> 1621 * @param objectToFind the object to find, may be <code>null</code> 1622 * @param startIndex the index to start searching at 1623 * @return the index of the object within the array starting at the index, 1624 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 1625 */ 1626 public static int indexOf(Object[] array, Object objectToFind, int startIndex) { 1627 if (array == null) { 1628 return INDEX_NOT_FOUND; 1629 } 1630 if (startIndex < 0) { 1631 startIndex = 0; 1632 } 1633 if (objectToFind == null) { 1634 for (int i = startIndex; i < array.length; i++) { 1635 if (array[i] == null) { 1636 return i; 1637 } 1638 } 1639 } else if (array.getClass().getComponentType().isInstance(objectToFind)) { 1640 for (int i = startIndex; i < array.length; i++) { 1641 if (objectToFind.equals(array[i])) { 1642 return i; 1643 } 1644 } 1645 } 1646 return INDEX_NOT_FOUND; 1647 } 1648 1649 /** 1650 * <p>Finds the last index of the given object within the array.</p> 1651 * 1652 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 1653 * 1654 * @param array the array to travers backwords looking for the object, may be <code>null</code> 1655 * @param objectToFind the object to find, may be <code>null</code> 1656 * @return the last index of the object within the array, 1657 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 1658 */ 1659 public static int lastIndexOf(Object[] array, Object objectToFind) { 1660 return lastIndexOf(array, objectToFind, Integer.MAX_VALUE); 1661 } 1662 1663 /** 1664 * <p>Finds the last index of the given object in the array starting at the given index.</p> 1665 * 1666 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 1667 * 1668 * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than 1669 * the array length will search from the end of the array.</p> 1670 * 1671 * @param array the array to traverse for looking for the object, may be <code>null</code> 1672 * @param objectToFind the object to find, may be <code>null</code> 1673 * @param startIndex the start index to travers backwards from 1674 * @return the last index of the object within the array, 1675 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 1676 */ 1677 public static int lastIndexOf(Object[] array, Object objectToFind, int startIndex) { 1678 if (array == null) { 1679 return INDEX_NOT_FOUND; 1680 } 1681 if (startIndex < 0) { 1682 return INDEX_NOT_FOUND; 1683 } else if (startIndex >= array.length) { 1684 startIndex = array.length - 1; 1685 } 1686 if (objectToFind == null) { 1687 for (int i = startIndex; i >= 0; i--) { 1688 if (array[i] == null) { 1689 return i; 1690 } 1691 } 1692 } else if (array.getClass().getComponentType().isInstance(objectToFind)) { 1693 for (int i = startIndex; i >= 0; i--) { 1694 if (objectToFind.equals(array[i])) { 1695 return i; 1696 } 1697 } 1698 } 1699 return INDEX_NOT_FOUND; 1700 } 1701 1702 /** 1703 * <p>Checks if the object is in the given array.</p> 1704 * 1705 * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p> 1706 * 1707 * @param array the array to search through 1708 * @param objectToFind the object to find 1709 * @return <code>true</code> if the array contains the object 1710 */ 1711 public static boolean contains(Object[] array, Object objectToFind) { 1712 return indexOf(array, objectToFind) != INDEX_NOT_FOUND; 1713 } 1714 1715 // long IndexOf 1716 //----------------------------------------------------------------------- 1717 /** 1718 * <p>Finds the index of the given value in the array.</p> 1719 * 1720 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 1721 * 1722 * @param array the array to search through for the object, may be <code>null</code> 1723 * @param valueToFind the value to find 1724 * @return the index of the value within the array, 1725 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 1726 */ 1727 public static int indexOf(long[] array, long valueToFind) { 1728 return indexOf(array, valueToFind, 0); 1729 } 1730 1731 /** 1732 * <p>Finds the index of the given value in the array starting at the given index.</p> 1733 * 1734 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 1735 * 1736 * <p>A negative startIndex is treated as zero. A startIndex larger than the array 1737 * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p> 1738 * 1739 * @param array the array to search through for the object, may be <code>null</code> 1740 * @param valueToFind the value to find 1741 * @param startIndex the index to start searching at 1742 * @return the index of the value within the array, 1743 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 1744 */ 1745 public static int indexOf(long[] array, long valueToFind, int startIndex) { 1746 if (array == null) { 1747 return INDEX_NOT_FOUND; 1748 } 1749 if (startIndex < 0) { 1750 startIndex = 0; 1751 } 1752 for (int i = startIndex; i < array.length; i++) { 1753 if (valueToFind == array[i]) { 1754 return i; 1755 } 1756 } 1757 return INDEX_NOT_FOUND; 1758 } 1759 1760 /** 1761 * <p>Finds the last index of the given value within the array.</p> 1762 * 1763 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 1764 * 1765 * @param array the array to travers backwords looking for the object, may be <code>null</code> 1766 * @param valueToFind the object to find 1767 * @return the last index of the value within the array, 1768 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 1769 */ 1770 public static int lastIndexOf(long[] array, long valueToFind) { 1771 return lastIndexOf(array, valueToFind, Integer.MAX_VALUE); 1772 } 1773 1774 /** 1775 * <p>Finds the last index of the given value in the array starting at the given index.</p> 1776 * 1777 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 1778 * 1779 * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than the 1780 * array length will search from the end of the array.</p> 1781 * 1782 * @param array the array to traverse for looking for the object, may be <code>null</code> 1783 * @param valueToFind the value to find 1784 * @param startIndex the start index to travers backwards from 1785 * @return the last index of the value within the array, 1786 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 1787 */ 1788 public static int lastIndexOf(long[] array, long valueToFind, int startIndex) { 1789 if (array == null) { 1790 return INDEX_NOT_FOUND; 1791 } 1792 if (startIndex < 0) { 1793 return INDEX_NOT_FOUND; 1794 } else if (startIndex >= array.length) { 1795 startIndex = array.length - 1; 1796 } 1797 for (int i = startIndex; i >= 0; i--) { 1798 if (valueToFind == array[i]) { 1799 return i; 1800 } 1801 } 1802 return INDEX_NOT_FOUND; 1803 } 1804 1805 /** 1806 * <p>Checks if the value is in the given array.</p> 1807 * 1808 * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p> 1809 * 1810 * @param array the array to search through 1811 * @param valueToFind the value to find 1812 * @return <code>true</code> if the array contains the object 1813 */ 1814 public static boolean contains(long[] array, long valueToFind) { 1815 return indexOf(array, valueToFind) != INDEX_NOT_FOUND; 1816 } 1817 1818 // int IndexOf 1819 //----------------------------------------------------------------------- 1820 /** 1821 * <p>Finds the index of the given value in the array.</p> 1822 * 1823 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 1824 * 1825 * @param array the array to search through for the object, may be <code>null</code> 1826 * @param valueToFind the value to find 1827 * @return the index of the value within the array, 1828 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 1829 */ 1830 public static int indexOf(int[] array, int valueToFind) { 1831 return indexOf(array, valueToFind, 0); 1832 } 1833 1834 /** 1835 * <p>Finds the index of the given value in the array starting at the given index.</p> 1836 * 1837 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 1838 * 1839 * <p>A negative startIndex is treated as zero. A startIndex larger than the array 1840 * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p> 1841 * 1842 * @param array the array to search through for the object, may be <code>null</code> 1843 * @param valueToFind the value to find 1844 * @param startIndex the index to start searching at 1845 * @return the index of the value within the array, 1846 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 1847 */ 1848 public static int indexOf(int[] array, int valueToFind, int startIndex) { 1849 if (array == null) { 1850 return INDEX_NOT_FOUND; 1851 } 1852 if (startIndex < 0) { 1853 startIndex = 0; 1854 } 1855 for (int i = startIndex; i < array.length; i++) { 1856 if (valueToFind == array[i]) { 1857 return i; 1858 } 1859 } 1860 return INDEX_NOT_FOUND; 1861 } 1862 1863 /** 1864 * <p>Finds the last index of the given value within the array.</p> 1865 * 1866 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 1867 * 1868 * @param array the array to travers backwords looking for the object, may be <code>null</code> 1869 * @param valueToFind the object to find 1870 * @return the last index of the value within the array, 1871 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 1872 */ 1873 public static int lastIndexOf(int[] array, int valueToFind) { 1874 return lastIndexOf(array, valueToFind, Integer.MAX_VALUE); 1875 } 1876 1877 /** 1878 * <p>Finds the last index of the given value in the array starting at the given index.</p> 1879 * 1880 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 1881 * 1882 * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than the 1883 * array length will search from the end of the array.</p> 1884 * 1885 * @param array the array to traverse for looking for the object, may be <code>null</code> 1886 * @param valueToFind the value to find 1887 * @param startIndex the start index to travers backwards from 1888 * @return the last index of the value within the array, 1889 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 1890 */ 1891 public static int lastIndexOf(int[] array, int valueToFind, int startIndex) { 1892 if (array == null) { 1893 return INDEX_NOT_FOUND; 1894 } 1895 if (startIndex < 0) { 1896 return INDEX_NOT_FOUND; 1897 } else if (startIndex >= array.length) { 1898 startIndex = array.length - 1; 1899 } 1900 for (int i = startIndex; i >= 0; i--) { 1901 if (valueToFind == array[i]) { 1902 return i; 1903 } 1904 } 1905 return INDEX_NOT_FOUND; 1906 } 1907 1908 /** 1909 * <p>Checks if the value is in the given array.</p> 1910 * 1911 * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p> 1912 * 1913 * @param array the array to search through 1914 * @param valueToFind the value to find 1915 * @return <code>true</code> if the array contains the object 1916 */ 1917 public static boolean contains(int[] array, int valueToFind) { 1918 return indexOf(array, valueToFind) != INDEX_NOT_FOUND; 1919 } 1920 1921 // short IndexOf 1922 //----------------------------------------------------------------------- 1923 /** 1924 * <p>Finds the index of the given value in the array.</p> 1925 * 1926 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 1927 * 1928 * @param array the array to search through for the object, may be <code>null</code> 1929 * @param valueToFind the value to find 1930 * @return the index of the value within the array, 1931 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 1932 */ 1933 public static int indexOf(short[] array, short valueToFind) { 1934 return indexOf(array, valueToFind, 0); 1935 } 1936 1937 /** 1938 * <p>Finds the index of the given value in the array starting at the given index.</p> 1939 * 1940 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 1941 * 1942 * <p>A negative startIndex is treated as zero. A startIndex larger than the array 1943 * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p> 1944 * 1945 * @param array the array to search through for the object, may be <code>null</code> 1946 * @param valueToFind the value to find 1947 * @param startIndex the index to start searching at 1948 * @return the index of the value within the array, 1949 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 1950 */ 1951 public static int indexOf(short[] array, short valueToFind, int startIndex) { 1952 if (array == null) { 1953 return INDEX_NOT_FOUND; 1954 } 1955 if (startIndex < 0) { 1956 startIndex = 0; 1957 } 1958 for (int i = startIndex; i < array.length; i++) { 1959 if (valueToFind == array[i]) { 1960 return i; 1961 } 1962 } 1963 return INDEX_NOT_FOUND; 1964 } 1965 1966 /** 1967 * <p>Finds the last index of the given value within the array.</p> 1968 * 1969 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 1970 * 1971 * @param array the array to travers backwords looking for the object, may be <code>null</code> 1972 * @param valueToFind the object to find 1973 * @return the last index of the value within the array, 1974 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 1975 */ 1976 public static int lastIndexOf(short[] array, short valueToFind) { 1977 return lastIndexOf(array, valueToFind, Integer.MAX_VALUE); 1978 } 1979 1980 /** 1981 * <p>Finds the last index of the given value in the array starting at the given index.</p> 1982 * 1983 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 1984 * 1985 * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than the 1986 * array length will search from the end of the array.</p> 1987 * 1988 * @param array the array to traverse for looking for the object, may be <code>null</code> 1989 * @param valueToFind the value to find 1990 * @param startIndex the start index to travers backwards from 1991 * @return the last index of the value within the array, 1992 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 1993 */ 1994 public static int lastIndexOf(short[] array, short valueToFind, int startIndex) { 1995 if (array == null) { 1996 return INDEX_NOT_FOUND; 1997 } 1998 if (startIndex < 0) { 1999 return INDEX_NOT_FOUND; 2000 } else if (startIndex >= array.length) { 2001 startIndex = array.length - 1; 2002 } 2003 for (int i = startIndex; i >= 0; i--) { 2004 if (valueToFind == array[i]) { 2005 return i; 2006 } 2007 } 2008 return INDEX_NOT_FOUND; 2009 } 2010 2011 /** 2012 * <p>Checks if the value is in the given array.</p> 2013 * 2014 * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p> 2015 * 2016 * @param array the array to search through 2017 * @param valueToFind the value to find 2018 * @return <code>true</code> if the array contains the object 2019 */ 2020 public static boolean contains(short[] array, short valueToFind) { 2021 return indexOf(array, valueToFind) != INDEX_NOT_FOUND; 2022 } 2023 2024 // char IndexOf 2025 //----------------------------------------------------------------------- 2026 /** 2027 * <p>Finds the index of the given value in the array.</p> 2028 * 2029 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2030 * 2031 * @param array the array to search through for the object, may be <code>null</code> 2032 * @param valueToFind the value to find 2033 * @return the index of the value within the array, 2034 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2035 * @since 2.1 2036 */ 2037 public static int indexOf(char[] array, char valueToFind) { 2038 return indexOf(array, valueToFind, 0); 2039 } 2040 2041 /** 2042 * <p>Finds the index of the given value in the array starting at the given index.</p> 2043 * 2044 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2045 * 2046 * <p>A negative startIndex is treated as zero. A startIndex larger than the array 2047 * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p> 2048 * 2049 * @param array the array to search through for the object, may be <code>null</code> 2050 * @param valueToFind the value to find 2051 * @param startIndex the index to start searching at 2052 * @return the index of the value within the array, 2053 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2054 * @since 2.1 2055 */ 2056 public static int indexOf(char[] array, char valueToFind, int startIndex) { 2057 if (array == null) { 2058 return INDEX_NOT_FOUND; 2059 } 2060 if (startIndex < 0) { 2061 startIndex = 0; 2062 } 2063 for (int i = startIndex; i < array.length; i++) { 2064 if (valueToFind == array[i]) { 2065 return i; 2066 } 2067 } 2068 return INDEX_NOT_FOUND; 2069 } 2070 2071 /** 2072 * <p>Finds the last index of the given value within the array.</p> 2073 * 2074 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2075 * 2076 * @param array the array to travers backwords looking for the object, may be <code>null</code> 2077 * @param valueToFind the object to find 2078 * @return the last index of the value within the array, 2079 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2080 * @since 2.1 2081 */ 2082 public static int lastIndexOf(char[] array, char valueToFind) { 2083 return lastIndexOf(array, valueToFind, Integer.MAX_VALUE); 2084 } 2085 2086 /** 2087 * <p>Finds the last index of the given value in the array starting at the given index.</p> 2088 * 2089 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2090 * 2091 * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than the 2092 * array length will search from the end of the array.</p> 2093 * 2094 * @param array the array to traverse for looking for the object, may be <code>null</code> 2095 * @param valueToFind the value to find 2096 * @param startIndex the start index to travers backwards from 2097 * @return the last index of the value within the array, 2098 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2099 * @since 2.1 2100 */ 2101 public static int lastIndexOf(char[] array, char valueToFind, int startIndex) { 2102 if (array == null) { 2103 return INDEX_NOT_FOUND; 2104 } 2105 if (startIndex < 0) { 2106 return INDEX_NOT_FOUND; 2107 } else if (startIndex >= array.length) { 2108 startIndex = array.length - 1; 2109 } 2110 for (int i = startIndex; i >= 0; i--) { 2111 if (valueToFind == array[i]) { 2112 return i; 2113 } 2114 } 2115 return INDEX_NOT_FOUND; 2116 } 2117 2118 /** 2119 * <p>Checks if the value is in the given array.</p> 2120 * 2121 * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p> 2122 * 2123 * @param array the array to search through 2124 * @param valueToFind the value to find 2125 * @return <code>true</code> if the array contains the object 2126 * @since 2.1 2127 */ 2128 public static boolean contains(char[] array, char valueToFind) { 2129 return indexOf(array, valueToFind) != INDEX_NOT_FOUND; 2130 } 2131 2132 // byte IndexOf 2133 //----------------------------------------------------------------------- 2134 /** 2135 * <p>Finds the index of the given value in the array.</p> 2136 * 2137 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2138 * 2139 * @param array the array to search through for the object, may be <code>null</code> 2140 * @param valueToFind the value to find 2141 * @return the index of the value within the array, 2142 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2143 */ 2144 public static int indexOf(byte[] array, byte valueToFind) { 2145 return indexOf(array, valueToFind, 0); 2146 } 2147 2148 /** 2149 * <p>Finds the index of the given value in the array starting at the given index.</p> 2150 * 2151 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2152 * 2153 * <p>A negative startIndex is treated as zero. A startIndex larger than the array 2154 * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p> 2155 * 2156 * @param array the array to search through for the object, may be <code>null</code> 2157 * @param valueToFind the value to find 2158 * @param startIndex the index to start searching at 2159 * @return the index of the value within the array, 2160 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2161 */ 2162 public static int indexOf(byte[] array, byte valueToFind, int startIndex) { 2163 if (array == null) { 2164 return INDEX_NOT_FOUND; 2165 } 2166 if (startIndex < 0) { 2167 startIndex = 0; 2168 } 2169 for (int i = startIndex; i < array.length; i++) { 2170 if (valueToFind == array[i]) { 2171 return i; 2172 } 2173 } 2174 return INDEX_NOT_FOUND; 2175 } 2176 2177 /** 2178 * <p>Finds the last index of the given value within the array.</p> 2179 * 2180 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2181 * 2182 * @param array the array to travers backwords looking for the object, may be <code>null</code> 2183 * @param valueToFind the object to find 2184 * @return the last index of the value within the array, 2185 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2186 */ 2187 public static int lastIndexOf(byte[] array, byte valueToFind) { 2188 return lastIndexOf(array, valueToFind, Integer.MAX_VALUE); 2189 } 2190 2191 /** 2192 * <p>Finds the last index of the given value in the array starting at the given index.</p> 2193 * 2194 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2195 * 2196 * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than the 2197 * array length will search from the end of the array.</p> 2198 * 2199 * @param array the array to traverse for looking for the object, may be <code>null</code> 2200 * @param valueToFind the value to find 2201 * @param startIndex the start index to travers backwards from 2202 * @return the last index of the value within the array, 2203 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2204 */ 2205 public static int lastIndexOf(byte[] array, byte valueToFind, int startIndex) { 2206 if (array == null) { 2207 return INDEX_NOT_FOUND; 2208 } 2209 if (startIndex < 0) { 2210 return INDEX_NOT_FOUND; 2211 } else if (startIndex >= array.length) { 2212 startIndex = array.length - 1; 2213 } 2214 for (int i = startIndex; i >= 0; i--) { 2215 if (valueToFind == array[i]) { 2216 return i; 2217 } 2218 } 2219 return INDEX_NOT_FOUND; 2220 } 2221 2222 /** 2223 * <p>Checks if the value is in the given array.</p> 2224 * 2225 * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p> 2226 * 2227 * @param array the array to search through 2228 * @param valueToFind the value to find 2229 * @return <code>true</code> if the array contains the object 2230 */ 2231 public static boolean contains(byte[] array, byte valueToFind) { 2232 return indexOf(array, valueToFind) != INDEX_NOT_FOUND; 2233 } 2234 2235 // double IndexOf 2236 //----------------------------------------------------------------------- 2237 /** 2238 * <p>Finds the index of the given value in the array.</p> 2239 * 2240 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2241 * 2242 * @param array the array to search through for the object, may be <code>null</code> 2243 * @param valueToFind the value to find 2244 * @return the index of the value within the array, 2245 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2246 */ 2247 public static int indexOf(double[] array, double valueToFind) { 2248 return indexOf(array, valueToFind, 0); 2249 } 2250 2251 /** 2252 * <p>Finds the index of the given value within a given tolerance in the array. 2253 * This method will return the index of the first value which falls between the region 2254 * defined by valueToFind - tolerance and valueToFind + tolerance.</p> 2255 * 2256 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2257 * 2258 * @param array the array to search through for the object, may be <code>null</code> 2259 * @param valueToFind the value to find 2260 * @param tolerance tolerance of the search 2261 * @return the index of the value within the array, 2262 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2263 */ 2264 public static int indexOf(double[] array, double valueToFind, double tolerance) { 2265 return indexOf(array, valueToFind, 0, tolerance); 2266 } 2267 2268 /** 2269 * <p>Finds the index of the given value in the array starting at the given index.</p> 2270 * 2271 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2272 * 2273 * <p>A negative startIndex is treated as zero. A startIndex larger than the array 2274 * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p> 2275 * 2276 * @param array the array to search through for the object, may be <code>null</code> 2277 * @param valueToFind the value to find 2278 * @param startIndex the index to start searching at 2279 * @return the index of the value within the array, 2280 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2281 */ 2282 public static int indexOf(double[] array, double valueToFind, int startIndex) { 2283 if (ArrayUtils.isEmpty(array)) { 2284 return INDEX_NOT_FOUND; 2285 } 2286 if (startIndex < 0) { 2287 startIndex = 0; 2288 } 2289 for (int i = startIndex; i < array.length; i++) { 2290 if (valueToFind == array[i]) { 2291 return i; 2292 } 2293 } 2294 return INDEX_NOT_FOUND; 2295 } 2296 2297 /** 2298 * <p>Finds the index of the given value in the array starting at the given index. 2299 * This method will return the index of the first value which falls between the region 2300 * defined by valueToFind - tolerance and valueToFind + tolerance.</p> 2301 * 2302 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2303 * 2304 * <p>A negative startIndex is treated as zero. A startIndex larger than the array 2305 * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p> 2306 * 2307 * @param array the array to search through for the object, may be <code>null</code> 2308 * @param valueToFind the value to find 2309 * @param startIndex the index to start searching at 2310 * @param tolerance tolerance of the search 2311 * @return the index of the value within the array, 2312 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2313 */ 2314 public static int indexOf(double[] array, double valueToFind, int startIndex, double tolerance) { 2315 if (ArrayUtils.isEmpty(array)) { 2316 return INDEX_NOT_FOUND; 2317 } 2318 if (startIndex < 0) { 2319 startIndex = 0; 2320 } 2321 double min = valueToFind - tolerance; 2322 double max = valueToFind + tolerance; 2323 for (int i = startIndex; i < array.length; i++) { 2324 if (array[i] >= min && array[i] <= max) { 2325 return i; 2326 } 2327 } 2328 return INDEX_NOT_FOUND; 2329 } 2330 2331 /** 2332 * <p>Finds the last index of the given value within the array.</p> 2333 * 2334 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2335 * 2336 * @param array the array to travers backwords looking for the object, may be <code>null</code> 2337 * @param valueToFind the object to find 2338 * @return the last index of the value within the array, 2339 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2340 */ 2341 public static int lastIndexOf(double[] array, double valueToFind) { 2342 return lastIndexOf(array, valueToFind, Integer.MAX_VALUE); 2343 } 2344 2345 /** 2346 * <p>Finds the last index of the given value within a given tolerance in the array. 2347 * This method will return the index of the last value which falls between the region 2348 * defined by valueToFind - tolerance and valueToFind + tolerance.</p> 2349 * 2350 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2351 * 2352 * @param array the array to search through for the object, may be <code>null</code> 2353 * @param valueToFind the value to find 2354 * @param tolerance tolerance of the search 2355 * @return the index of the value within the array, 2356 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2357 */ 2358 public static int lastIndexOf(double[] array, double valueToFind, double tolerance) { 2359 return lastIndexOf(array, valueToFind, Integer.MAX_VALUE, tolerance); 2360 } 2361 2362 /** 2363 * <p>Finds the last index of the given value in the array starting at the given index.</p> 2364 * 2365 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2366 * 2367 * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than the 2368 * array length will search from the end of the array.</p> 2369 * 2370 * @param array the array to traverse for looking for the object, may be <code>null</code> 2371 * @param valueToFind the value to find 2372 * @param startIndex the start index to travers backwards from 2373 * @return the last index of the value within the array, 2374 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2375 */ 2376 public static int lastIndexOf(double[] array, double valueToFind, int startIndex) { 2377 if (ArrayUtils.isEmpty(array)) { 2378 return INDEX_NOT_FOUND; 2379 } 2380 if (startIndex < 0) { 2381 return INDEX_NOT_FOUND; 2382 } else if (startIndex >= array.length) { 2383 startIndex = array.length - 1; 2384 } 2385 for (int i = startIndex; i >= 0; i--) { 2386 if (valueToFind == array[i]) { 2387 return i; 2388 } 2389 } 2390 return INDEX_NOT_FOUND; 2391 } 2392 2393 /** 2394 * <p>Finds the last index of the given value in the array starting at the given index. 2395 * This method will return the index of the last value which falls between the region 2396 * defined by valueToFind - tolerance and valueToFind + tolerance.</p> 2397 * 2398 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2399 * 2400 * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than the 2401 * array length will search from the end of the array.</p> 2402 * 2403 * @param array the array to traverse for looking for the object, may be <code>null</code> 2404 * @param valueToFind the value to find 2405 * @param startIndex the start index to travers backwards from 2406 * @param tolerance search for value within plus/minus this amount 2407 * @return the last index of the value within the array, 2408 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2409 */ 2410 public static int lastIndexOf(double[] array, double valueToFind, int startIndex, double tolerance) { 2411 if (ArrayUtils.isEmpty(array)) { 2412 return INDEX_NOT_FOUND; 2413 } 2414 if (startIndex < 0) { 2415 return INDEX_NOT_FOUND; 2416 } else if (startIndex >= array.length) { 2417 startIndex = array.length - 1; 2418 } 2419 double min = valueToFind - tolerance; 2420 double max = valueToFind + tolerance; 2421 for (int i = startIndex; i >= 0; i--) { 2422 if (array[i] >= min && array[i] <= max) { 2423 return i; 2424 } 2425 } 2426 return INDEX_NOT_FOUND; 2427 } 2428 2429 /** 2430 * <p>Checks if the value is in the given array.</p> 2431 * 2432 * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p> 2433 * 2434 * @param array the array to search through 2435 * @param valueToFind the value to find 2436 * @return <code>true</code> if the array contains the object 2437 */ 2438 public static boolean contains(double[] array, double valueToFind) { 2439 return indexOf(array, valueToFind) != INDEX_NOT_FOUND; 2440 } 2441 2442 /** 2443 * <p>Checks if a value falling within the given tolerance is in the 2444 * given array. If the array contains a value within the inclusive range 2445 * defined by (value - tolerance) to (value + tolerance).</p> 2446 * 2447 * <p>The method returns <code>false</code> if a <code>null</code> array 2448 * is passed in.</p> 2449 * 2450 * @param array the array to search 2451 * @param valueToFind the value to find 2452 * @param tolerance the array contains the tolerance of the search 2453 * @return true if value falling within tolerance is in array 2454 */ 2455 public static boolean contains(double[] array, double valueToFind, double tolerance) { 2456 return indexOf(array, valueToFind, 0, tolerance) != INDEX_NOT_FOUND; 2457 } 2458 2459 // float IndexOf 2460 //----------------------------------------------------------------------- 2461 /** 2462 * <p>Finds the index of the given value in the array.</p> 2463 * 2464 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2465 * 2466 * @param array the array to search through for the object, may be <code>null</code> 2467 * @param valueToFind the value to find 2468 * @return the index of the value within the array, 2469 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2470 */ 2471 public static int indexOf(float[] array, float valueToFind) { 2472 return indexOf(array, valueToFind, 0); 2473 } 2474 2475 /** 2476 * <p>Finds the index of the given value in the array starting at the given index.</p> 2477 * 2478 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2479 * 2480 * <p>A negative startIndex is treated as zero. A startIndex larger than the array 2481 * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p> 2482 * 2483 * @param array the array to search through for the object, may be <code>null</code> 2484 * @param valueToFind the value to find 2485 * @param startIndex the index to start searching at 2486 * @return the index of the value within the array, 2487 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2488 */ 2489 public static int indexOf(float[] array, float valueToFind, int startIndex) { 2490 if (ArrayUtils.isEmpty(array)) { 2491 return INDEX_NOT_FOUND; 2492 } 2493 if (startIndex < 0) { 2494 startIndex = 0; 2495 } 2496 for (int i = startIndex; i < array.length; i++) { 2497 if (valueToFind == array[i]) { 2498 return i; 2499 } 2500 } 2501 return INDEX_NOT_FOUND; 2502 } 2503 2504 /** 2505 * <p>Finds the last index of the given value within the array.</p> 2506 * 2507 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2508 * 2509 * @param array the array to travers backwords looking for the object, may be <code>null</code> 2510 * @param valueToFind the object to find 2511 * @return the last index of the value within the array, 2512 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2513 */ 2514 public static int lastIndexOf(float[] array, float valueToFind) { 2515 return lastIndexOf(array, valueToFind, Integer.MAX_VALUE); 2516 } 2517 2518 /** 2519 * <p>Finds the last index of the given value in the array starting at the given index.</p> 2520 * 2521 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2522 * 2523 * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than the 2524 * array length will search from the end of the array.</p> 2525 * 2526 * @param array the array to traverse for looking for the object, may be <code>null</code> 2527 * @param valueToFind the value to find 2528 * @param startIndex the start index to travers backwards from 2529 * @return the last index of the value within the array, 2530 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2531 */ 2532 public static int lastIndexOf(float[] array, float valueToFind, int startIndex) { 2533 if (ArrayUtils.isEmpty(array)) { 2534 return INDEX_NOT_FOUND; 2535 } 2536 if (startIndex < 0) { 2537 return INDEX_NOT_FOUND; 2538 } else if (startIndex >= array.length) { 2539 startIndex = array.length - 1; 2540 } 2541 for (int i = startIndex; i >= 0; i--) { 2542 if (valueToFind == array[i]) { 2543 return i; 2544 } 2545 } 2546 return INDEX_NOT_FOUND; 2547 } 2548 2549 /** 2550 * <p>Checks if the value is in the given array.</p> 2551 * 2552 * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p> 2553 * 2554 * @param array the array to search through 2555 * @param valueToFind the value to find 2556 * @return <code>true</code> if the array contains the object 2557 */ 2558 public static boolean contains(float[] array, float valueToFind) { 2559 return indexOf(array, valueToFind) != INDEX_NOT_FOUND; 2560 } 2561 2562 // boolean IndexOf 2563 //----------------------------------------------------------------------- 2564 /** 2565 * <p>Finds the index of the given value in the array.</p> 2566 * 2567 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2568 * 2569 * @param array the array to search through for the object, may be <code>null</code> 2570 * @param valueToFind the value to find 2571 * @return the index of the value within the array, 2572 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2573 */ 2574 public static int indexOf(boolean[] array, boolean valueToFind) { 2575 return indexOf(array, valueToFind, 0); 2576 } 2577 2578 /** 2579 * <p>Finds the index of the given value in the array starting at the given index.</p> 2580 * 2581 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2582 * 2583 * <p>A negative startIndex is treated as zero. A startIndex larger than the array 2584 * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p> 2585 * 2586 * @param array the array to search through for the object, may be <code>null</code> 2587 * @param valueToFind the value to find 2588 * @param startIndex the index to start searching at 2589 * @return the index of the value within the array, 2590 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> 2591 * array input 2592 */ 2593 public static int indexOf(boolean[] array, boolean valueToFind, int startIndex) { 2594 if (ArrayUtils.isEmpty(array)) { 2595 return INDEX_NOT_FOUND; 2596 } 2597 if (startIndex < 0) { 2598 startIndex = 0; 2599 } 2600 for (int i = startIndex; i < array.length; i++) { 2601 if (valueToFind == array[i]) { 2602 return i; 2603 } 2604 } 2605 return INDEX_NOT_FOUND; 2606 } 2607 2608 /** 2609 * <p>Finds the last index of the given value within the array.</p> 2610 * 2611 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) if 2612 * <code>null</code> array input.</p> 2613 * 2614 * @param array the array to travers backwords looking for the object, may be <code>null</code> 2615 * @param valueToFind the object to find 2616 * @return the last index of the value within the array, 2617 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2618 */ 2619 public static int lastIndexOf(boolean[] array, boolean valueToFind) { 2620 return lastIndexOf(array, valueToFind, Integer.MAX_VALUE); 2621 } 2622 2623 /** 2624 * <p>Finds the last index of the given value in the array starting at the given index.</p> 2625 * 2626 * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p> 2627 * 2628 * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than 2629 * the array length will search from the end of the array.</p> 2630 * 2631 * @param array the array to traverse for looking for the object, may be <code>null</code> 2632 * @param valueToFind the value to find 2633 * @param startIndex the start index to travers backwards from 2634 * @return the last index of the value within the array, 2635 * {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input 2636 */ 2637 public static int lastIndexOf(boolean[] array, boolean valueToFind, int startIndex) { 2638 if (ArrayUtils.isEmpty(array)) { 2639 return INDEX_NOT_FOUND; 2640 } 2641 if (startIndex < 0) { 2642 return INDEX_NOT_FOUND; 2643 } else if (startIndex >= array.length) { 2644 startIndex = array.length - 1; 2645 } 2646 for (int i = startIndex; i >= 0; i--) { 2647 if (valueToFind == array[i]) { 2648 return i; 2649 } 2650 } 2651 return INDEX_NOT_FOUND; 2652 } 2653 2654 /** 2655 * <p>Checks if the value is in the given array.</p> 2656 * 2657 * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p> 2658 * 2659 * @param array the array to search through 2660 * @param valueToFind the value to find 2661 * @return <code>true</code> if the array contains the object 2662 */ 2663 public static boolean contains(boolean[] array, boolean valueToFind) { 2664 return indexOf(array, valueToFind) != INDEX_NOT_FOUND; 2665 } 2666 2667 // Primitive/Object array converters 2668 // ---------------------------------------------------------------------- 2669 2670 // Character array converters 2671 // ---------------------------------------------------------------------- 2672 /** 2673 * <p>Converts an array of object Characters to primitives.</p> 2674 * 2675 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 2676 * 2677 * @param array a <code>Character</code> array, may be <code>null</code> 2678 * @return a <code>char</code> array, <code>null</code> if null array input 2679 * @throws NullPointerException if array content is <code>null</code> 2680 */ 2681 public static char[] toPrimitive(Character[] array) { 2682 if (array == null) { 2683 return null; 2684 } else if (array.length == 0) { 2685 return EMPTY_CHAR_ARRAY; 2686 } 2687 final char[] result = new char[array.length]; 2688 for (int i = 0; i < array.length; i++) { 2689 result[i] = array[i].charValue(); 2690 } 2691 return result; 2692 } 2693 2694 /** 2695 * <p>Converts an array of object Character to primitives handling <code>null</code>.</p> 2696 * 2697 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 2698 * 2699 * @param array a <code>Character</code> array, may be <code>null</code> 2700 * @param valueForNull the value to insert if <code>null</code> found 2701 * @return a <code>char</code> array, <code>null</code> if null array input 2702 */ 2703 public static char[] toPrimitive(Character[] array, char valueForNull) { 2704 if (array == null) { 2705 return null; 2706 } else if (array.length == 0) { 2707 return EMPTY_CHAR_ARRAY; 2708 } 2709 final char[] result = new char[array.length]; 2710 for (int i = 0; i < array.length; i++) { 2711 Character b = array[i]; 2712 result[i] = (b == null ? valueForNull : b.charValue()); 2713 } 2714 return result; 2715 } 2716 2717 /** 2718 * <p>Converts an array of primitive chars to objects.</p> 2719 * 2720 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 2721 * 2722 * @param array a <code>char</code> array 2723 * @return a <code>Character</code> array, <code>null</code> if null array input 2724 */ 2725 public static Character[] toObject(char[] array) { 2726 if (array == null) { 2727 return null; 2728 } else if (array.length == 0) { 2729 return EMPTY_CHARACTER_OBJECT_ARRAY; 2730 } 2731 final Character[] result = new Character[array.length]; 2732 for (int i = 0; i < array.length; i++) { 2733 result[i] = Character.valueOf(array[i]); 2734 } 2735 return result; 2736 } 2737 2738 // Long array converters 2739 // ---------------------------------------------------------------------- 2740 /** 2741 * <p>Converts an array of object Longs to primitives.</p> 2742 * 2743 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 2744 * 2745 * @param array a <code>Long</code> array, may be <code>null</code> 2746 * @return a <code>long</code> array, <code>null</code> if null array input 2747 * @throws NullPointerException if array content is <code>null</code> 2748 */ 2749 public static long[] toPrimitive(Long[] array) { 2750 if (array == null) { 2751 return null; 2752 } else if (array.length == 0) { 2753 return EMPTY_LONG_ARRAY; 2754 } 2755 final long[] result = new long[array.length]; 2756 for (int i = 0; i < array.length; i++) { 2757 result[i] = array[i].longValue(); 2758 } 2759 return result; 2760 } 2761 2762 /** 2763 * <p>Converts an array of object Long to primitives handling <code>null</code>.</p> 2764 * 2765 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 2766 * 2767 * @param array a <code>Long</code> array, may be <code>null</code> 2768 * @param valueForNull the value to insert if <code>null</code> found 2769 * @return a <code>long</code> array, <code>null</code> if null array input 2770 */ 2771 public static long[] toPrimitive(Long[] array, long valueForNull) { 2772 if (array == null) { 2773 return null; 2774 } else if (array.length == 0) { 2775 return EMPTY_LONG_ARRAY; 2776 } 2777 final long[] result = new long[array.length]; 2778 for (int i = 0; i < array.length; i++) { 2779 Long b = array[i]; 2780 result[i] = (b == null ? valueForNull : b.longValue()); 2781 } 2782 return result; 2783 } 2784 2785 /** 2786 * <p>Converts an array of primitive longs to objects.</p> 2787 * 2788 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 2789 * 2790 * @param array a <code>long</code> array 2791 * @return a <code>Long</code> array, <code>null</code> if null array input 2792 */ 2793 public static Long[] toObject(long[] array) { 2794 if (array == null) { 2795 return null; 2796 } else if (array.length == 0) { 2797 return EMPTY_LONG_OBJECT_ARRAY; 2798 } 2799 final Long[] result = new Long[array.length]; 2800 for (int i = 0; i < array.length; i++) { 2801 result[i] = Long.valueOf(array[i]); 2802 } 2803 return result; 2804 } 2805 2806 // Int array converters 2807 // ---------------------------------------------------------------------- 2808 /** 2809 * <p>Converts an array of object Integers to primitives.</p> 2810 * 2811 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 2812 * 2813 * @param array a <code>Integer</code> array, may be <code>null</code> 2814 * @return an <code>int</code> array, <code>null</code> if null array input 2815 * @throws NullPointerException if array content is <code>null</code> 2816 */ 2817 public static int[] toPrimitive(Integer[] array) { 2818 if (array == null) { 2819 return null; 2820 } else if (array.length == 0) { 2821 return EMPTY_INT_ARRAY; 2822 } 2823 final int[] result = new int[array.length]; 2824 for (int i = 0; i < array.length; i++) { 2825 result[i] = array[i].intValue(); 2826 } 2827 return result; 2828 } 2829 2830 /** 2831 * <p>Converts an array of object Integer to primitives handling <code>null</code>.</p> 2832 * 2833 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 2834 * 2835 * @param array a <code>Integer</code> array, may be <code>null</code> 2836 * @param valueForNull the value to insert if <code>null</code> found 2837 * @return an <code>int</code> array, <code>null</code> if null array input 2838 */ 2839 public static int[] toPrimitive(Integer[] array, int valueForNull) { 2840 if (array == null) { 2841 return null; 2842 } else if (array.length == 0) { 2843 return EMPTY_INT_ARRAY; 2844 } 2845 final int[] result = new int[array.length]; 2846 for (int i = 0; i < array.length; i++) { 2847 Integer b = array[i]; 2848 result[i] = (b == null ? valueForNull : b.intValue()); 2849 } 2850 return result; 2851 } 2852 2853 /** 2854 * <p>Converts an array of primitive ints to objects.</p> 2855 * 2856 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 2857 * 2858 * @param array an <code>int</code> array 2859 * @return an <code>Integer</code> array, <code>null</code> if null array input 2860 */ 2861 public static Integer[] toObject(int[] array) { 2862 if (array == null) { 2863 return null; 2864 } else if (array.length == 0) { 2865 return EMPTY_INTEGER_OBJECT_ARRAY; 2866 } 2867 final Integer[] result = new Integer[array.length]; 2868 for (int i = 0; i < array.length; i++) { 2869 result[i] = Integer.valueOf(array[i]); 2870 } 2871 return result; 2872 } 2873 2874 // Short array converters 2875 // ---------------------------------------------------------------------- 2876 /** 2877 * <p>Converts an array of object Shorts to primitives.</p> 2878 * 2879 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 2880 * 2881 * @param array a <code>Short</code> array, may be <code>null</code> 2882 * @return a <code>byte</code> array, <code>null</code> if null array input 2883 * @throws NullPointerException if array content is <code>null</code> 2884 */ 2885 public static short[] toPrimitive(Short[] array) { 2886 if (array == null) { 2887 return null; 2888 } else if (array.length == 0) { 2889 return EMPTY_SHORT_ARRAY; 2890 } 2891 final short[] result = new short[array.length]; 2892 for (int i = 0; i < array.length; i++) { 2893 result[i] = array[i].shortValue(); 2894 } 2895 return result; 2896 } 2897 2898 /** 2899 * <p>Converts an array of object Short to primitives handling <code>null</code>.</p> 2900 * 2901 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 2902 * 2903 * @param array a <code>Short</code> array, may be <code>null</code> 2904 * @param valueForNull the value to insert if <code>null</code> found 2905 * @return a <code>byte</code> array, <code>null</code> if null array input 2906 */ 2907 public static short[] toPrimitive(Short[] array, short valueForNull) { 2908 if (array == null) { 2909 return null; 2910 } else if (array.length == 0) { 2911 return EMPTY_SHORT_ARRAY; 2912 } 2913 final short[] result = new short[array.length]; 2914 for (int i = 0; i < array.length; i++) { 2915 Short b = array[i]; 2916 result[i] = (b == null ? valueForNull : b.shortValue()); 2917 } 2918 return result; 2919 } 2920 2921 /** 2922 * <p>Converts an array of primitive shorts to objects.</p> 2923 * 2924 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 2925 * 2926 * @param array a <code>short</code> array 2927 * @return a <code>Short</code> array, <code>null</code> if null array input 2928 */ 2929 public static Short[] toObject(short[] array) { 2930 if (array == null) { 2931 return null; 2932 } else if (array.length == 0) { 2933 return EMPTY_SHORT_OBJECT_ARRAY; 2934 } 2935 final Short[] result = new Short[array.length]; 2936 for (int i = 0; i < array.length; i++) { 2937 result[i] = Short.valueOf(array[i]); 2938 } 2939 return result; 2940 } 2941 2942 // Byte array converters 2943 // ---------------------------------------------------------------------- 2944 /** 2945 * <p>Converts an array of object Bytes to primitives.</p> 2946 * 2947 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 2948 * 2949 * @param array a <code>Byte</code> array, may be <code>null</code> 2950 * @return a <code>byte</code> array, <code>null</code> if null array input 2951 * @throws NullPointerException if array content is <code>null</code> 2952 */ 2953 public static byte[] toPrimitive(Byte[] array) { 2954 if (array == null) { 2955 return null; 2956 } else if (array.length == 0) { 2957 return EMPTY_BYTE_ARRAY; 2958 } 2959 final byte[] result = new byte[array.length]; 2960 for (int i = 0; i < array.length; i++) { 2961 result[i] = array[i].byteValue(); 2962 } 2963 return result; 2964 } 2965 2966 /** 2967 * <p>Converts an array of object Bytes to primitives handling <code>null</code>.</p> 2968 * 2969 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 2970 * 2971 * @param array a <code>Byte</code> array, may be <code>null</code> 2972 * @param valueForNull the value to insert if <code>null</code> found 2973 * @return a <code>byte</code> array, <code>null</code> if null array input 2974 */ 2975 public static byte[] toPrimitive(Byte[] array, byte valueForNull) { 2976 if (array == null) { 2977 return null; 2978 } else if (array.length == 0) { 2979 return EMPTY_BYTE_ARRAY; 2980 } 2981 final byte[] result = new byte[array.length]; 2982 for (int i = 0; i < array.length; i++) { 2983 Byte b = array[i]; 2984 result[i] = (b == null ? valueForNull : b.byteValue()); 2985 } 2986 return result; 2987 } 2988 2989 /** 2990 * <p>Converts an array of primitive bytes to objects.</p> 2991 * 2992 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 2993 * 2994 * @param array a <code>byte</code> array 2995 * @return a <code>Byte</code> array, <code>null</code> if null array input 2996 */ 2997 public static Byte[] toObject(byte[] array) { 2998 if (array == null) { 2999 return null; 3000 } else if (array.length == 0) { 3001 return EMPTY_BYTE_OBJECT_ARRAY; 3002 } 3003 final Byte[] result = new Byte[array.length]; 3004 for (int i = 0; i < array.length; i++) { 3005 result[i] = Byte.valueOf(array[i]); 3006 } 3007 return result; 3008 } 3009 3010 // Double array converters 3011 // ---------------------------------------------------------------------- 3012 /** 3013 * <p>Converts an array of object Doubles to primitives.</p> 3014 * 3015 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 3016 * 3017 * @param array a <code>Double</code> array, may be <code>null</code> 3018 * @return a <code>double</code> array, <code>null</code> if null array input 3019 * @throws NullPointerException if array content is <code>null</code> 3020 */ 3021 public static double[] toPrimitive(Double[] array) { 3022 if (array == null) { 3023 return null; 3024 } else if (array.length == 0) { 3025 return EMPTY_DOUBLE_ARRAY; 3026 } 3027 final double[] result = new double[array.length]; 3028 for (int i = 0; i < array.length; i++) { 3029 result[i] = array[i].doubleValue(); 3030 } 3031 return result; 3032 } 3033 3034 /** 3035 * <p>Converts an array of object Doubles to primitives handling <code>null</code>.</p> 3036 * 3037 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 3038 * 3039 * @param array a <code>Double</code> array, may be <code>null</code> 3040 * @param valueForNull the value to insert if <code>null</code> found 3041 * @return a <code>double</code> array, <code>null</code> if null array input 3042 */ 3043 public static double[] toPrimitive(Double[] array, double valueForNull) { 3044 if (array == null) { 3045 return null; 3046 } else if (array.length == 0) { 3047 return EMPTY_DOUBLE_ARRAY; 3048 } 3049 final double[] result = new double[array.length]; 3050 for (int i = 0; i < array.length; i++) { 3051 Double b = array[i]; 3052 result[i] = (b == null ? valueForNull : b.doubleValue()); 3053 } 3054 return result; 3055 } 3056 3057 /** 3058 * <p>Converts an array of primitive doubles to objects.</p> 3059 * 3060 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 3061 * 3062 * @param array a <code>double</code> array 3063 * @return a <code>Double</code> array, <code>null</code> if null array input 3064 */ 3065 public static Double[] toObject(double[] array) { 3066 if (array == null) { 3067 return null; 3068 } else if (array.length == 0) { 3069 return EMPTY_DOUBLE_OBJECT_ARRAY; 3070 } 3071 final Double[] result = new Double[array.length]; 3072 for (int i = 0; i < array.length; i++) { 3073 result[i] = Double.valueOf(array[i]); 3074 } 3075 return result; 3076 } 3077 3078 // Float array converters 3079 // ---------------------------------------------------------------------- 3080 /** 3081 * <p>Converts an array of object Floats to primitives.</p> 3082 * 3083 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 3084 * 3085 * @param array a <code>Float</code> array, may be <code>null</code> 3086 * @return a <code>float</code> array, <code>null</code> if null array input 3087 * @throws NullPointerException if array content is <code>null</code> 3088 */ 3089 public static float[] toPrimitive(Float[] array) { 3090 if (array == null) { 3091 return null; 3092 } else if (array.length == 0) { 3093 return EMPTY_FLOAT_ARRAY; 3094 } 3095 final float[] result = new float[array.length]; 3096 for (int i = 0; i < array.length; i++) { 3097 result[i] = array[i].floatValue(); 3098 } 3099 return result; 3100 } 3101 3102 /** 3103 * <p>Converts an array of object Floats to primitives handling <code>null</code>.</p> 3104 * 3105 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 3106 * 3107 * @param array a <code>Float</code> array, may be <code>null</code> 3108 * @param valueForNull the value to insert if <code>null</code> found 3109 * @return a <code>float</code> array, <code>null</code> if null array input 3110 */ 3111 public static float[] toPrimitive(Float[] array, float valueForNull) { 3112 if (array == null) { 3113 return null; 3114 } else if (array.length == 0) { 3115 return EMPTY_FLOAT_ARRAY; 3116 } 3117 final float[] result = new float[array.length]; 3118 for (int i = 0; i < array.length; i++) { 3119 Float b = array[i]; 3120 result[i] = (b == null ? valueForNull : b.floatValue()); 3121 } 3122 return result; 3123 } 3124 3125 /** 3126 * <p>Converts an array of primitive floats to objects.</p> 3127 * 3128 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 3129 * 3130 * @param array a <code>float</code> array 3131 * @return a <code>Float</code> array, <code>null</code> if null array input 3132 */ 3133 public static Float[] toObject(float[] array) { 3134 if (array == null) { 3135 return null; 3136 } else if (array.length == 0) { 3137 return EMPTY_FLOAT_OBJECT_ARRAY; 3138 } 3139 final Float[] result = new Float[array.length]; 3140 for (int i = 0; i < array.length; i++) { 3141 result[i] = Float.valueOf(array[i]); 3142 } 3143 return result; 3144 } 3145 3146 // Boolean array converters 3147 // ---------------------------------------------------------------------- 3148 /** 3149 * <p>Converts an array of object Booleans to primitives.</p> 3150 * 3151 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 3152 * 3153 * @param array a <code>Boolean</code> array, may be <code>null</code> 3154 * @return a <code>boolean</code> array, <code>null</code> if null array input 3155 * @throws NullPointerException if array content is <code>null</code> 3156 */ 3157 public static boolean[] toPrimitive(Boolean[] array) { 3158 if (array == null) { 3159 return null; 3160 } else if (array.length == 0) { 3161 return EMPTY_BOOLEAN_ARRAY; 3162 } 3163 final boolean[] result = new boolean[array.length]; 3164 for (int i = 0; i < array.length; i++) { 3165 result[i] = array[i].booleanValue(); 3166 } 3167 return result; 3168 } 3169 3170 /** 3171 * <p>Converts an array of object Booleans to primitives handling <code>null</code>.</p> 3172 * 3173 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 3174 * 3175 * @param array a <code>Boolean</code> array, may be <code>null</code> 3176 * @param valueForNull the value to insert if <code>null</code> found 3177 * @return a <code>boolean</code> array, <code>null</code> if null array input 3178 */ 3179 public static boolean[] toPrimitive(Boolean[] array, boolean valueForNull) { 3180 if (array == null) { 3181 return null; 3182 } else if (array.length == 0) { 3183 return EMPTY_BOOLEAN_ARRAY; 3184 } 3185 final boolean[] result = new boolean[array.length]; 3186 for (int i = 0; i < array.length; i++) { 3187 Boolean b = array[i]; 3188 result[i] = (b == null ? valueForNull : b.booleanValue()); 3189 } 3190 return result; 3191 } 3192 3193 /** 3194 * <p>Converts an array of primitive booleans to objects.</p> 3195 * 3196 * <p>This method returns <code>null</code> for a <code>null</code> input array.</p> 3197 * 3198 * @param array a <code>boolean</code> array 3199 * @return a <code>Boolean</code> array, <code>null</code> if null array input 3200 */ 3201 public static Boolean[] toObject(boolean[] array) { 3202 if (array == null) { 3203 return null; 3204 } else if (array.length == 0) { 3205 return EMPTY_BOOLEAN_OBJECT_ARRAY; 3206 } 3207 final Boolean[] result = new Boolean[array.length]; 3208 for (int i = 0; i < array.length; i++) { 3209 result[i] = (array[i] ? Boolean.TRUE : Boolean.FALSE); 3210 } 3211 return result; 3212 } 3213 3214 // ---------------------------------------------------------------------- 3215 /** 3216 * <p>Checks if an array of Objects is empty or <code>null</code>.</p> 3217 * 3218 * @param array the array to test 3219 * @return <code>true</code> if the array is empty or <code>null</code> 3220 * @since 2.1 3221 */ 3222 public static <T> boolean isEmpty(T[] array) { 3223 if (array == null || array.length == 0) { 3224 return true; 3225 } 3226 return false; 3227 } 3228 3229 /** 3230 * <p>Checks if an array of primitive longs is empty or <code>null</code>.</p> 3231 * 3232 * @param array the array to test 3233 * @return <code>true</code> if the array is empty or <code>null</code> 3234 * @since 2.1 3235 */ 3236 public static boolean isEmpty(long[] array) { 3237 if (array == null || array.length == 0) { 3238 return true; 3239 } 3240 return false; 3241 } 3242 3243 /** 3244 * <p>Checks if an array of primitive ints is empty or <code>null</code>.</p> 3245 * 3246 * @param array the array to test 3247 * @return <code>true</code> if the array is empty or <code>null</code> 3248 * @since 2.1 3249 */ 3250 public static boolean isEmpty(int[] array) { 3251 if (array == null || array.length == 0) { 3252 return true; 3253 } 3254 return false; 3255 } 3256 3257 /** 3258 * <p>Checks if an array of primitive shorts is empty or <code>null</code>.</p> 3259 * 3260 * @param array the array to test 3261 * @return <code>true</code> if the array is empty or <code>null</code> 3262 * @since 2.1 3263 */ 3264 public static boolean isEmpty(short[] array) { 3265 if (array == null || array.length == 0) { 3266 return true; 3267 } 3268 return false; 3269 } 3270 3271 /** 3272 * <p>Checks if an array of primitive chars is empty or <code>null</code>.</p> 3273 * 3274 * @param array the array to test 3275 * @return <code>true</code> if the array is empty or <code>null</code> 3276 * @since 2.1 3277 */ 3278 public static boolean isEmpty(char[] array) { 3279 if (array == null || array.length == 0) { 3280 return true; 3281 } 3282 return false; 3283 } 3284 3285 /** 3286 * <p>Checks if an array of primitive bytes is empty or <code>null</code>.</p> 3287 * 3288 * @param array the array to test 3289 * @return <code>true</code> if the array is empty or <code>null</code> 3290 * @since 2.1 3291 */ 3292 public static boolean isEmpty(byte[] array) { 3293 if (array == null || array.length == 0) { 3294 return true; 3295 } 3296 return false; 3297 } 3298 3299 /** 3300 * <p>Checks if an array of primitive doubles is empty or <code>null</code>.</p> 3301 * 3302 * @param array the array to test 3303 * @return <code>true</code> if the array is empty or <code>null</code> 3304 * @since 2.1 3305 */ 3306 public static boolean isEmpty(double[] array) { 3307 if (array == null || array.length == 0) { 3308 return true; 3309 } 3310 return false; 3311 } 3312 3313 /** 3314 * <p>Checks if an array of primitive floats is empty or <code>null</code>.</p> 3315 * 3316 * @param array the array to test 3317 * @return <code>true</code> if the array is empty or <code>null</code> 3318 * @since 2.1 3319 */ 3320 public static boolean isEmpty(float[] array) { 3321 if (array == null || array.length == 0) { 3322 return true; 3323 } 3324 return false; 3325 } 3326 3327 /** 3328 * <p>Checks if an array of primitive booleans is empty or <code>null</code>.</p> 3329 * 3330 * @param array the array to test 3331 * @return <code>true</code> if the array is empty or <code>null</code> 3332 * @since 2.1 3333 */ 3334 public static boolean isEmpty(boolean[] array) { 3335 if (array == null || array.length == 0) { 3336 return true; 3337 } 3338 return false; 3339 } 3340 3341 // ---------------------------------------------------------------------- 3342 /** 3343 * <p>Checks if an array of Objects is not empty or not <code>null</code>.</p> 3344 * 3345 * @param array the array to test 3346 * @return <code>true</code> if the array is not empty or not <code>null</code> 3347 * @since 2.5 3348 */ 3349 public static <T> boolean isNotEmpty(T[] array) { 3350 return (array != null && array.length != 0); 3351 } 3352 3353 /** 3354 * <p>Checks if an array of primitive longs is not empty or not <code>null</code>.</p> 3355 * 3356 * @param array the array to test 3357 * @return <code>true</code> if the array is not empty or not <code>null</code> 3358 * @since 2.5 3359 */ 3360 public static boolean isNotEmpty(long[] array) { 3361 return (array != null && array.length != 0); 3362 } 3363 3364 /** 3365 * <p>Checks if an array of primitive ints is not empty or not <code>null</code>.</p> 3366 * 3367 * @param array the array to test 3368 * @return <code>true</code> if the array is not empty or not <code>null</code> 3369 * @since 2.5 3370 */ 3371 public static boolean isNotEmpty(int[] array) { 3372 return (array != null && array.length != 0); 3373 } 3374 3375 /** 3376 * <p>Checks if an array of primitive shorts is not empty or not <code>null</code>.</p> 3377 * 3378 * @param array the array to test 3379 * @return <code>true</code> if the array is not empty or not <code>null</code> 3380 * @since 2.5 3381 */ 3382 public static boolean isNotEmpty(short[] array) { 3383 return (array != null && array.length != 0); 3384 } 3385 3386 /** 3387 * <p>Checks if an array of primitive chars is not empty or not <code>null</code>.</p> 3388 * 3389 * @param array the array to test 3390 * @return <code>true</code> if the array is not empty or not <code>null</code> 3391 * @since 2.5 3392 */ 3393 public static boolean isNotEmpty(char[] array) { 3394 return (array != null && array.length != 0); 3395 } 3396 3397 /** 3398 * <p>Checks if an array of primitive bytes is not empty or not <code>null</code>.</p> 3399 * 3400 * @param array the array to test 3401 * @return <code>true</code> if the array is not empty or not <code>null</code> 3402 * @since 2.5 3403 */ 3404 public static boolean isNotEmpty(byte[] array) { 3405 return (array != null && array.length != 0); 3406 } 3407 3408 /** 3409 * <p>Checks if an array of primitive doubles is not empty or not <code>null</code>.</p> 3410 * 3411 * @param array the array to test 3412 * @return <code>true</code> if the array is not empty or not <code>null</code> 3413 * @since 2.5 3414 */ 3415 public static boolean isNotEmpty(double[] array) { 3416 return (array != null && array.length != 0); 3417 } 3418 3419 /** 3420 * <p>Checks if an array of primitive floats is not empty or not <code>null</code>.</p> 3421 * 3422 * @param array the array to test 3423 * @return <code>true</code> if the array is not empty or not <code>null</code> 3424 * @since 2.5 3425 */ 3426 public static boolean isNotEmpty(float[] array) { 3427 return (array != null && array.length != 0); 3428 } 3429 3430 /** 3431 * <p>Checks if an array of primitive booleans is not empty or not <code>null</code>.</p> 3432 * 3433 * @param array the array to test 3434 * @return <code>true</code> if the array is not empty or not <code>null</code> 3435 * @since 2.5 3436 */ 3437 public static boolean isNotEmpty(boolean[] array) { 3438 return (array != null && array.length != 0); 3439 } 3440 3441 /** 3442 * <p>Adds all the elements of the given arrays into a new array.</p> 3443 * <p>The new array contains all of the element of <code>array1</code> followed 3444 * by all of the elements <code>array2</code>. When an array is returned, it is always 3445 * a new array.</p> 3446 * 3447 * <pre> 3448 * ArrayUtils.addAll(null, null) = null 3449 * ArrayUtils.addAll(array1, null) = cloned copy of array1 3450 * ArrayUtils.addAll(null, array2) = cloned copy of array2 3451 * ArrayUtils.addAll([], []) = [] 3452 * ArrayUtils.addAll([null], [null]) = [null, null] 3453 * ArrayUtils.addAll(["a", "b", "c"], ["1", "2", "3"]) = ["a", "b", "c", "1", "2", "3"] 3454 * </pre> 3455 * 3456 * @param array1 the first array whose elements are added to the new array, may be <code>null</code> 3457 * @param array2 the second array whose elements are added to the new array, may be <code>null</code> 3458 * @return The new array, <code>null</code> if both arrays are <code>null</code>. 3459 * The type of the new array is the type of the first array, 3460 * unless the first array is null, in which case the type is the same as the second array. 3461 * @since 2.1 3462 * @throws IllegalArgumentException if the array types are incompatible 3463 */ 3464 public static <T> T[] addAll(T[] array1, T... array2) { 3465 if (array1 == null) { 3466 return clone(array2); 3467 } else if (array2 == null) { 3468 return clone(array1); 3469 } 3470 final Class<?> type1 = array1.getClass().getComponentType(); 3471 @SuppressWarnings("unchecked") // OK, because array is of type T 3472 T[] joinedArray = (T[]) Array.newInstance(type1, array1.length + array2.length); 3473 System.arraycopy(array1, 0, joinedArray, 0, array1.length); 3474 try { 3475 System.arraycopy(array2, 0, joinedArray, array1.length, array2.length); 3476 } catch (ArrayStoreException ase) { 3477 // Check if problem was due to incompatible types 3478 /* 3479 * We do this here, rather than before the copy because: 3480 * - it would be a wasted check most of the time 3481 * - safer, in case check turns out to be too strict 3482 */ 3483 final Class<?> type2 = array2.getClass().getComponentType(); 3484 if (!type1.isAssignableFrom(type2)){ 3485 throw new IllegalArgumentException("Cannot store "+type2.getName()+" in an array of "+type1.getName(), ase); 3486 } 3487 throw ase; // No, so rethrow original 3488 } 3489 return joinedArray; 3490 } 3491 3492 /** 3493 * <p>Adds all the elements of the given arrays into a new array.</p> 3494 * <p>The new array contains all of the element of <code>array1</code> followed 3495 * by all of the elements <code>array2</code>. When an array is returned, it is always 3496 * a new array.</p> 3497 * 3498 * <pre> 3499 * ArrayUtils.addAll(array1, null) = cloned copy of array1 3500 * ArrayUtils.addAll(null, array2) = cloned copy of array2 3501 * ArrayUtils.addAll([], []) = [] 3502 * </pre> 3503 * 3504 * @param array1 the first array whose elements are added to the new array. 3505 * @param array2 the second array whose elements are added to the new array. 3506 * @return The new boolean[] array. 3507 * @since 2.1 3508 */ 3509 public static boolean[] addAll(boolean[] array1, boolean... array2) { 3510 if (array1 == null) { 3511 return clone(array2); 3512 } else if (array2 == null) { 3513 return clone(array1); 3514 } 3515 boolean[] joinedArray = new boolean[array1.length + array2.length]; 3516 System.arraycopy(array1, 0, joinedArray, 0, array1.length); 3517 System.arraycopy(array2, 0, joinedArray, array1.length, array2.length); 3518 return joinedArray; 3519 } 3520 3521 /** 3522 * <p>Adds all the elements of the given arrays into a new array.</p> 3523 * <p>The new array contains all of the element of <code>array1</code> followed 3524 * by all of the elements <code>array2</code>. When an array is returned, it is always 3525 * a new array.</p> 3526 * 3527 * <pre> 3528 * ArrayUtils.addAll(array1, null) = cloned copy of array1 3529 * ArrayUtils.addAll(null, array2) = cloned copy of array2 3530 * ArrayUtils.addAll([], []) = [] 3531 * </pre> 3532 * 3533 * @param array1 the first array whose elements are added to the new array. 3534 * @param array2 the second array whose elements are added to the new array. 3535 * @return The new char[] array. 3536 * @since 2.1 3537 */ 3538 public static char[] addAll(char[] array1, char... array2) { 3539 if (array1 == null) { 3540 return clone(array2); 3541 } else if (array2 == null) { 3542 return clone(array1); 3543 } 3544 char[] joinedArray = new char[array1.length + array2.length]; 3545 System.arraycopy(array1, 0, joinedArray, 0, array1.length); 3546 System.arraycopy(array2, 0, joinedArray, array1.length, array2.length); 3547 return joinedArray; 3548 } 3549 3550 /** 3551 * <p>Adds all the elements of the given arrays into a new array.</p> 3552 * <p>The new array contains all of the element of <code>array1</code> followed 3553 * by all of the elements <code>array2</code>. When an array is returned, it is always 3554 * a new array.</p> 3555 * 3556 * <pre> 3557 * ArrayUtils.addAll(array1, null) = cloned copy of array1 3558 * ArrayUtils.addAll(null, array2) = cloned copy of array2 3559 * ArrayUtils.addAll([], []) = [] 3560 * </pre> 3561 * 3562 * @param array1 the first array whose elements are added to the new array. 3563 * @param array2 the second array whose elements are added to the new array. 3564 * @return The new byte[] array. 3565 * @since 2.1 3566 */ 3567 public static byte[] addAll(byte[] array1, byte... array2) { 3568 if (array1 == null) { 3569 return clone(array2); 3570 } else if (array2 == null) { 3571 return clone(array1); 3572 } 3573 byte[] joinedArray = new byte[array1.length + array2.length]; 3574 System.arraycopy(array1, 0, joinedArray, 0, array1.length); 3575 System.arraycopy(array2, 0, joinedArray, array1.length, array2.length); 3576 return joinedArray; 3577 } 3578 3579 /** 3580 * <p>Adds all the elements of the given arrays into a new array.</p> 3581 * <p>The new array contains all of the element of <code>array1</code> followed 3582 * by all of the elements <code>array2</code>. When an array is returned, it is always 3583 * a new array.</p> 3584 * 3585 * <pre> 3586 * ArrayUtils.addAll(array1, null) = cloned copy of array1 3587 * ArrayUtils.addAll(null, array2) = cloned copy of array2 3588 * ArrayUtils.addAll([], []) = [] 3589 * </pre> 3590 * 3591 * @param array1 the first array whose elements are added to the new array. 3592 * @param array2 the second array whose elements are added to the new array. 3593 * @return The new short[] array. 3594 * @since 2.1 3595 */ 3596 public static short[] addAll(short[] array1, short... array2) { 3597 if (array1 == null) { 3598 return clone(array2); 3599 } else if (array2 == null) { 3600 return clone(array1); 3601 } 3602 short[] joinedArray = new short[array1.length + array2.length]; 3603 System.arraycopy(array1, 0, joinedArray, 0, array1.length); 3604 System.arraycopy(array2, 0, joinedArray, array1.length, array2.length); 3605 return joinedArray; 3606 } 3607 3608 /** 3609 * <p>Adds all the elements of the given arrays into a new array.</p> 3610 * <p>The new array contains all of the element of <code>array1</code> followed 3611 * by all of the elements <code>array2</code>. When an array is returned, it is always 3612 * a new array.</p> 3613 * 3614 * <pre> 3615 * ArrayUtils.addAll(array1, null) = cloned copy of array1 3616 * ArrayUtils.addAll(null, array2) = cloned copy of array2 3617 * ArrayUtils.addAll([], []) = [] 3618 * </pre> 3619 * 3620 * @param array1 the first array whose elements are added to the new array. 3621 * @param array2 the second array whose elements are added to the new array. 3622 * @return The new int[] array. 3623 * @since 2.1 3624 */ 3625 public static int[] addAll(int[] array1, int... array2) { 3626 if (array1 == null) { 3627 return clone(array2); 3628 } else if (array2 == null) { 3629 return clone(array1); 3630 } 3631 int[] joinedArray = new int[array1.length + array2.length]; 3632 System.arraycopy(array1, 0, joinedArray, 0, array1.length); 3633 System.arraycopy(array2, 0, joinedArray, array1.length, array2.length); 3634 return joinedArray; 3635 } 3636 3637 /** 3638 * <p>Adds all the elements of the given arrays into a new array.</p> 3639 * <p>The new array contains all of the element of <code>array1</code> followed 3640 * by all of the elements <code>array2</code>. When an array is returned, it is always 3641 * a new array.</p> 3642 * 3643 * <pre> 3644 * ArrayUtils.addAll(array1, null) = cloned copy of array1 3645 * ArrayUtils.addAll(null, array2) = cloned copy of array2 3646 * ArrayUtils.addAll([], []) = [] 3647 * </pre> 3648 * 3649 * @param array1 the first array whose elements are added to the new array. 3650 * @param array2 the second array whose elements are added to the new array. 3651 * @return The new long[] array. 3652 * @since 2.1 3653 */ 3654 public static long[] addAll(long[] array1, long... array2) { 3655 if (array1 == null) { 3656 return clone(array2); 3657 } else if (array2 == null) { 3658 return clone(array1); 3659 } 3660 long[] joinedArray = new long[array1.length + array2.length]; 3661 System.arraycopy(array1, 0, joinedArray, 0, array1.length); 3662 System.arraycopy(array2, 0, joinedArray, array1.length, array2.length); 3663 return joinedArray; 3664 } 3665 3666 /** 3667 * <p>Adds all the elements of the given arrays into a new array.</p> 3668 * <p>The new array contains all of the element of <code>array1</code> followed 3669 * by all of the elements <code>array2</code>. When an array is returned, it is always 3670 * a new array.</p> 3671 * 3672 * <pre> 3673 * ArrayUtils.addAll(array1, null) = cloned copy of array1 3674 * ArrayUtils.addAll(null, array2) = cloned copy of array2 3675 * ArrayUtils.addAll([], []) = [] 3676 * </pre> 3677 * 3678 * @param array1 the first array whose elements are added to the new array. 3679 * @param array2 the second array whose elements are added to the new array. 3680 * @return The new float[] array. 3681 * @since 2.1 3682 */ 3683 public static float[] addAll(float[] array1, float... array2) { 3684 if (array1 == null) { 3685 return clone(array2); 3686 } else if (array2 == null) { 3687 return clone(array1); 3688 } 3689 float[] joinedArray = new float[array1.length + array2.length]; 3690 System.arraycopy(array1, 0, joinedArray, 0, array1.length); 3691 System.arraycopy(array2, 0, joinedArray, array1.length, array2.length); 3692 return joinedArray; 3693 } 3694 3695 /** 3696 * <p>Adds all the elements of the given arrays into a new array.</p> 3697 * <p>The new array contains all of the element of <code>array1</code> followed 3698 * by all of the elements <code>array2</code>. When an array is returned, it is always 3699 * a new array.</p> 3700 * 3701 * <pre> 3702 * ArrayUtils.addAll(array1, null) = cloned copy of array1 3703 * ArrayUtils.addAll(null, array2) = cloned copy of array2 3704 * ArrayUtils.addAll([], []) = [] 3705 * </pre> 3706 * 3707 * @param array1 the first array whose elements are added to the new array. 3708 * @param array2 the second array whose elements are added to the new array. 3709 * @return The new double[] array. 3710 * @since 2.1 3711 */ 3712 public static double[] addAll(double[] array1, double... array2) { 3713 if (array1 == null) { 3714 return clone(array2); 3715 } else if (array2 == null) { 3716 return clone(array1); 3717 } 3718 double[] joinedArray = new double[array1.length + array2.length]; 3719 System.arraycopy(array1, 0, joinedArray, 0, array1.length); 3720 System.arraycopy(array2, 0, joinedArray, array1.length, array2.length); 3721 return joinedArray; 3722 } 3723 3724 /** 3725 * <p>Copies the given array and adds the given element at the end of the new array.</p> 3726 * 3727 * <p>The new array contains the same elements of the input 3728 * array plus the given element in the last position. The component type of 3729 * the new array is the same as that of the input array.</p> 3730 * 3731 * <p>If the input array is <code>null</code>, a new one element array is returned 3732 * whose component type is the same as the element, unless the element itself is null, 3733 * in which case the return type is Object[]</p> 3734 * 3735 * <pre> 3736 * ArrayUtils.add(null, null) = [null] 3737 * ArrayUtils.add(null, "a") = ["a"] 3738 * ArrayUtils.add(["a"], null) = ["a", null] 3739 * ArrayUtils.add(["a"], "b") = ["a", "b"] 3740 * ArrayUtils.add(["a", "b"], "c") = ["a", "b", "c"] 3741 * </pre> 3742 * 3743 * @param array the array to "add" the element to, may be <code>null</code> 3744 * @param element the object to add, may be <code>null</code> 3745 * @return A new array containing the existing elements plus the new element 3746 * The returned array type will be that of the input array (unless null), 3747 * in which case it will have the same type as the element. 3748 * If both are null, an IllegalArgumentException is thrown 3749 * @since 2.1 3750 * @throws IllegalArgumentException if both arguments are null 3751 */ 3752 public static <T> T[] add(T[] array, T element) { 3753 Class<?> type; 3754 if (array != null){ 3755 type = array.getClass(); 3756 } else if (element != null) { 3757 type = element.getClass(); 3758 } else { 3759 throw new IllegalArgumentException("Arguments cannot both be null"); 3760 } 3761 @SuppressWarnings("unchecked") // type must be T 3762 T[] newArray = (T[]) copyArrayGrow1(array, type); 3763 newArray[newArray.length - 1] = element; 3764 return newArray; 3765 } 3766 3767 /** 3768 * <p>Copies the given array and adds the given element at the end of the new array.</p> 3769 * 3770 * <p>The new array contains the same elements of the input 3771 * array plus the given element in the last position. The component type of 3772 * the new array is the same as that of the input array.</p> 3773 * 3774 * <p>If the input array is <code>null</code>, a new one element array is returned 3775 * whose component type is the same as the element.</p> 3776 * 3777 * <pre> 3778 * ArrayUtils.add(null, true) = [true] 3779 * ArrayUtils.add([true], false) = [true, false] 3780 * ArrayUtils.add([true, false], true) = [true, false, true] 3781 * </pre> 3782 * 3783 * @param array the array to copy and add the element to, may be <code>null</code> 3784 * @param element the object to add at the last index of the new array 3785 * @return A new array containing the existing elements plus the new element 3786 * @since 2.1 3787 */ 3788 public static boolean[] add(boolean[] array, boolean element) { 3789 boolean[] newArray = (boolean[])copyArrayGrow1(array, Boolean.TYPE); 3790 newArray[newArray.length - 1] = element; 3791 return newArray; 3792 } 3793 3794 /** 3795 * <p>Copies the given array and adds the given element at the end of the new array.</p> 3796 * 3797 * <p>The new array contains the same elements of the input 3798 * array plus the given element in the last position. The component type of 3799 * the new array is the same as that of the input array.</p> 3800 * 3801 * <p>If the input array is <code>null</code>, a new one element array is returned 3802 * whose component type is the same as the element.</p> 3803 * 3804 * <pre> 3805 * ArrayUtils.add(null, 0) = [0] 3806 * ArrayUtils.add([1], 0) = [1, 0] 3807 * ArrayUtils.add([1, 0], 1) = [1, 0, 1] 3808 * </pre> 3809 * 3810 * @param array the array to copy and add the element to, may be <code>null</code> 3811 * @param element the object to add at the last index of the new array 3812 * @return A new array containing the existing elements plus the new element 3813 * @since 2.1 3814 */ 3815 public static byte[] add(byte[] array, byte element) { 3816 byte[] newArray = (byte[])copyArrayGrow1(array, Byte.TYPE); 3817 newArray[newArray.length - 1] = element; 3818 return newArray; 3819 } 3820 3821 /** 3822 * <p>Copies the given array and adds the given element at the end of the new array.</p> 3823 * 3824 * <p>The new array contains the same elements of the input 3825 * array plus the given element in the last position. The component type of 3826 * the new array is the same as that of the input array.</p> 3827 * 3828 * <p>If the input array is <code>null</code>, a new one element array is returned 3829 * whose component type is the same as the element.</p> 3830 * 3831 * <pre> 3832 * ArrayUtils.add(null, '0') = ['0'] 3833 * ArrayUtils.add(['1'], '0') = ['1', '0'] 3834 * ArrayUtils.add(['1', '0'], '1') = ['1', '0', '1'] 3835 * </pre> 3836 * 3837 * @param array the array to copy and add the element to, may be <code>null</code> 3838 * @param element the object to add at the last index of the new array 3839 * @return A new array containing the existing elements plus the new element 3840 * @since 2.1 3841 */ 3842 public static char[] add(char[] array, char element) { 3843 char[] newArray = (char[])copyArrayGrow1(array, Character.TYPE); 3844 newArray[newArray.length - 1] = element; 3845 return newArray; 3846 } 3847 3848 /** 3849 * <p>Copies the given array and adds the given element at the end of the new array.</p> 3850 * 3851 * <p>The new array contains the same elements of the input 3852 * array plus the given element in the last position. The component type of 3853 * the new array is the same as that of the input array.</p> 3854 * 3855 * <p>If the input array is <code>null</code>, a new one element array is returned 3856 * whose component type is the same as the element.</p> 3857 * 3858 * <pre> 3859 * ArrayUtils.add(null, 0) = [0] 3860 * ArrayUtils.add([1], 0) = [1, 0] 3861 * ArrayUtils.add([1, 0], 1) = [1, 0, 1] 3862 * </pre> 3863 * 3864 * @param array the array to copy and add the element to, may be <code>null</code> 3865 * @param element the object to add at the last index of the new array 3866 * @return A new array containing the existing elements plus the new element 3867 * @since 2.1 3868 */ 3869 public static double[] add(double[] array, double element) { 3870 double[] newArray = (double[])copyArrayGrow1(array, Double.TYPE); 3871 newArray[newArray.length - 1] = element; 3872 return newArray; 3873 } 3874 3875 /** 3876 * <p>Copies the given array and adds the given element at the end of the new array.</p> 3877 * 3878 * <p>The new array contains the same elements of the input 3879 * array plus the given element in the last position. The component type of 3880 * the new array is the same as that of the input array.</p> 3881 * 3882 * <p>If the input array is <code>null</code>, a new one element array is returned 3883 * whose component type is the same as the element.</p> 3884 * 3885 * <pre> 3886 * ArrayUtils.add(null, 0) = [0] 3887 * ArrayUtils.add([1], 0) = [1, 0] 3888 * ArrayUtils.add([1, 0], 1) = [1, 0, 1] 3889 * </pre> 3890 * 3891 * @param array the array to copy and add the element to, may be <code>null</code> 3892 * @param element the object to add at the last index of the new array 3893 * @return A new array containing the existing elements plus the new element 3894 * @since 2.1 3895 */ 3896 public static float[] add(float[] array, float element) { 3897 float[] newArray = (float[])copyArrayGrow1(array, Float.TYPE); 3898 newArray[newArray.length - 1] = element; 3899 return newArray; 3900 } 3901 3902 /** 3903 * <p>Copies the given array and adds the given element at the end of the new array.</p> 3904 * 3905 * <p>The new array contains the same elements of the input 3906 * array plus the given element in the last position. The component type of 3907 * the new array is the same as that of the input array.</p> 3908 * 3909 * <p>If the input array is <code>null</code>, a new one element array is returned 3910 * whose component type is the same as the element.</p> 3911 * 3912 * <pre> 3913 * ArrayUtils.add(null, 0) = [0] 3914 * ArrayUtils.add([1], 0) = [1, 0] 3915 * ArrayUtils.add([1, 0], 1) = [1, 0, 1] 3916 * </pre> 3917 * 3918 * @param array the array to copy and add the element to, may be <code>null</code> 3919 * @param element the object to add at the last index of the new array 3920 * @return A new array containing the existing elements plus the new element 3921 * @since 2.1 3922 */ 3923 public static int[] add(int[] array, int element) { 3924 int[] newArray = (int[])copyArrayGrow1(array, Integer.TYPE); 3925 newArray[newArray.length - 1] = element; 3926 return newArray; 3927 } 3928 3929 /** 3930 * <p>Copies the given array and adds the given element at the end of the new array.</p> 3931 * 3932 * <p>The new array contains the same elements of the input 3933 * array plus the given element in the last position. The component type of 3934 * the new array is the same as that of the input array.</p> 3935 * 3936 * <p>If the input array is <code>null</code>, a new one element array is returned 3937 * whose component type is the same as the element.</p> 3938 * 3939 * <pre> 3940 * ArrayUtils.add(null, 0) = [0] 3941 * ArrayUtils.add([1], 0) = [1, 0] 3942 * ArrayUtils.add([1, 0], 1) = [1, 0, 1] 3943 * </pre> 3944 * 3945 * @param array the array to copy and add the element to, may be <code>null</code> 3946 * @param element the object to add at the last index of the new array 3947 * @return A new array containing the existing elements plus the new element 3948 * @since 2.1 3949 */ 3950 public static long[] add(long[] array, long element) { 3951 long[] newArray = (long[])copyArrayGrow1(array, Long.TYPE); 3952 newArray[newArray.length - 1] = element; 3953 return newArray; 3954 } 3955 3956 /** 3957 * <p>Copies the given array and adds the given element at the end of the new array.</p> 3958 * 3959 * <p>The new array contains the same elements of the input 3960 * array plus the given element in the last position. The component type of 3961 * the new array is the same as that of the input array.</p> 3962 * 3963 * <p>If the input array is <code>null</code>, a new one element array is returned 3964 * whose component type is the same as the element.</p> 3965 * 3966 * <pre> 3967 * ArrayUtils.add(null, 0) = [0] 3968 * ArrayUtils.add([1], 0) = [1, 0] 3969 * ArrayUtils.add([1, 0], 1) = [1, 0, 1] 3970 * </pre> 3971 * 3972 * @param array the array to copy and add the element to, may be <code>null</code> 3973 * @param element the object to add at the last index of the new array 3974 * @return A new array containing the existing elements plus the new element 3975 * @since 2.1 3976 */ 3977 public static short[] add(short[] array, short element) { 3978 short[] newArray = (short[])copyArrayGrow1(array, Short.TYPE); 3979 newArray[newArray.length - 1] = element; 3980 return newArray; 3981 } 3982 3983 /** 3984 * Returns a copy of the given array of size 1 greater than the argument. 3985 * The last value of the array is left to the default value. 3986 * 3987 * @param array The array to copy, must not be <code>null</code>. 3988 * @param newArrayComponentType If <code>array</code> is <code>null</code>, create a 3989 * size 1 array of this type. 3990 * @return A new copy of the array of size 1 greater than the input. 3991 */ 3992 private static Object copyArrayGrow1(Object array, Class<?> newArrayComponentType) { 3993 if (array != null) { 3994 int arrayLength = Array.getLength(array); 3995 Object newArray = Array.newInstance(array.getClass().getComponentType(), arrayLength + 1); 3996 System.arraycopy(array, 0, newArray, 0, arrayLength); 3997 return newArray; 3998 } 3999 return Array.newInstance(newArrayComponentType, 1); 4000 } 4001 4002 /** 4003 * <p>Inserts the specified element at the specified position in the array. 4004 * Shifts the element currently at that position (if any) and any subsequent 4005 * elements to the right (adds one to their indices).</p> 4006 * 4007 * <p>This method returns a new array with the same elements of the input 4008 * array plus the given element on the specified position. The component 4009 * type of the returned array is always the same as that of the input 4010 * array.</p> 4011 * 4012 * <p>If the input array is <code>null</code>, a new one element array is returned 4013 * whose component type is the same as the element.</p> 4014 * 4015 * <pre> 4016 * ArrayUtils.add(null, 0, null) = [null] 4017 * ArrayUtils.add(null, 0, "a") = ["a"] 4018 * ArrayUtils.add(["a"], 1, null) = ["a", null] 4019 * ArrayUtils.add(["a"], 1, "b") = ["a", "b"] 4020 * ArrayUtils.add(["a", "b"], 3, "c") = ["a", "b", "c"] 4021 * </pre> 4022 * 4023 * @param array the array to add the element to, may be <code>null</code> 4024 * @param index the position of the new object 4025 * @param element the object to add 4026 * @return A new array containing the existing elements and the new element 4027 * @throws IndexOutOfBoundsException if the index is out of range 4028 * (index < 0 || index > array.length). 4029 * @throws IllegalArgumentException if both array and element are null 4030 */ 4031 public static <T> T[] add(T[] array, int index, T element) { 4032 Class<?> clss = null; 4033 if (array != null) { 4034 clss = array.getClass().getComponentType(); 4035 } else if (element != null) { 4036 clss = element.getClass(); 4037 } else { 4038 throw new IllegalArgumentException("Array and element cannot both be null"); 4039 } 4040 @SuppressWarnings("unchecked") // the add method creates an array of type clss, which is type T 4041 final T[] newArray = (T[]) add(array, index, element, clss); 4042 return newArray; 4043 } 4044 4045 /** 4046 * <p>Inserts the specified element at the specified position in the array. 4047 * Shifts the element currently at that position (if any) and any subsequent 4048 * elements to the right (adds one to their indices).</p> 4049 * 4050 * <p>This method returns a new array with the same elements of the input 4051 * array plus the given element on the specified position. The component 4052 * type of the returned array is always the same as that of the input 4053 * array.</p> 4054 * 4055 * <p>If the input array is <code>null</code>, a new one element array is returned 4056 * whose component type is the same as the element.</p> 4057 * 4058 * <pre> 4059 * ArrayUtils.add(null, 0, true) = [true] 4060 * ArrayUtils.add([true], 0, false) = [false, true] 4061 * ArrayUtils.add([false], 1, true) = [false, true] 4062 * ArrayUtils.add([true, false], 1, true) = [true, true, false] 4063 * </pre> 4064 * 4065 * @param array the array to add the element to, may be <code>null</code> 4066 * @param index the position of the new object 4067 * @param element the object to add 4068 * @return A new array containing the existing elements and the new element 4069 * @throws IndexOutOfBoundsException if the index is out of range 4070 * (index < 0 || index > array.length). 4071 */ 4072 public static boolean[] add(boolean[] array, int index, boolean element) { 4073 return (boolean[]) add(array, index, Boolean.valueOf(element), Boolean.TYPE); 4074 } 4075 4076 /** 4077 * <p>Inserts the specified element at the specified position in the array. 4078 * Shifts the element currently at that position (if any) and any subsequent 4079 * elements to the right (adds one to their indices).</p> 4080 * 4081 * <p>This method returns a new array with the same elements of the input 4082 * array plus the given element on the specified position. The component 4083 * type of the returned array is always the same as that of the input 4084 * array.</p> 4085 * 4086 * <p>If the input array is <code>null</code>, a new one element array is returned 4087 * whose component type is the same as the element.</p> 4088 * 4089 * <pre> 4090 * ArrayUtils.add(null, 0, 'a') = ['a'] 4091 * ArrayUtils.add(['a'], 0, 'b') = ['b', 'a'] 4092 * ArrayUtils.add(['a', 'b'], 0, 'c') = ['c', 'a', 'b'] 4093 * ArrayUtils.add(['a', 'b'], 1, 'k') = ['a', 'k', 'b'] 4094 * ArrayUtils.add(['a', 'b', 'c'], 1, 't') = ['a', 't', 'b', 'c'] 4095 * </pre> 4096 * 4097 * @param array the array to add the element to, may be <code>null</code> 4098 * @param index the position of the new object 4099 * @param element the object to add 4100 * @return A new array containing the existing elements and the new element 4101 * @throws IndexOutOfBoundsException if the index is out of range 4102 * (index < 0 || index > array.length). 4103 */ 4104 public static char[] add(char[] array, int index, char element) { 4105 return (char[]) add(array, index, Character.valueOf(element), Character.TYPE); 4106 } 4107 4108 /** 4109 * <p>Inserts the specified element at the specified position in the array. 4110 * Shifts the element currently at that position (if any) and any subsequent 4111 * elements to the right (adds one to their indices).</p> 4112 * 4113 * <p>This method returns a new array with the same elements of the input 4114 * array plus the given element on the specified position. The component 4115 * type of the returned array is always the same as that of the input 4116 * array.</p> 4117 * 4118 * <p>If the input array is <code>null</code>, a new one element array is returned 4119 * whose component type is the same as the element.</p> 4120 * 4121 * <pre> 4122 * ArrayUtils.add([1], 0, 2) = [2, 1] 4123 * ArrayUtils.add([2, 6], 2, 3) = [2, 6, 3] 4124 * ArrayUtils.add([2, 6], 0, 1) = [1, 2, 6] 4125 * ArrayUtils.add([2, 6, 3], 2, 1) = [2, 6, 1, 3] 4126 * </pre> 4127 * 4128 * @param array the array to add the element to, may be <code>null</code> 4129 * @param index the position of the new object 4130 * @param element the object to add 4131 * @return A new array containing the existing elements and the new element 4132 * @throws IndexOutOfBoundsException if the index is out of range 4133 * (index < 0 || index > array.length). 4134 */ 4135 public static byte[] add(byte[] array, int index, byte element) { 4136 return (byte[]) add(array, index, Byte.valueOf(element), Byte.TYPE); 4137 } 4138 4139 /** 4140 * <p>Inserts the specified element at the specified position in the array. 4141 * Shifts the element currently at that position (if any) and any subsequent 4142 * elements to the right (adds one to their indices).</p> 4143 * 4144 * <p>This method returns a new array with the same elements of the input 4145 * array plus the given element on the specified position. The component 4146 * type of the returned array is always the same as that of the input 4147 * array.</p> 4148 * 4149 * <p>If the input array is <code>null</code>, a new one element array is returned 4150 * whose component type is the same as the element.</p> 4151 * 4152 * <pre> 4153 * ArrayUtils.add([1], 0, 2) = [2, 1] 4154 * ArrayUtils.add([2, 6], 2, 10) = [2, 6, 10] 4155 * ArrayUtils.add([2, 6], 0, -4) = [-4, 2, 6] 4156 * ArrayUtils.add([2, 6, 3], 2, 1) = [2, 6, 1, 3] 4157 * </pre> 4158 * 4159 * @param array the array to add the element to, may be <code>null</code> 4160 * @param index the position of the new object 4161 * @param element the object to add 4162 * @return A new array containing the existing elements and the new element 4163 * @throws IndexOutOfBoundsException if the index is out of range 4164 * (index < 0 || index > array.length). 4165 */ 4166 public static short[] add(short[] array, int index, short element) { 4167 return (short[]) add(array, index, Short.valueOf(element), Short.TYPE); 4168 } 4169 4170 /** 4171 * <p>Inserts the specified element at the specified position in the array. 4172 * Shifts the element currently at that position (if any) and any subsequent 4173 * elements to the right (adds one to their indices).</p> 4174 * 4175 * <p>This method returns a new array with the same elements of the input 4176 * array plus the given element on the specified position. The component 4177 * type of the returned array is always the same as that of the input 4178 * array.</p> 4179 * 4180 * <p>If the input array is <code>null</code>, a new one element array is returned 4181 * whose component type is the same as the element.</p> 4182 * 4183 * <pre> 4184 * ArrayUtils.add([1], 0, 2) = [2, 1] 4185 * ArrayUtils.add([2, 6], 2, 10) = [2, 6, 10] 4186 * ArrayUtils.add([2, 6], 0, -4) = [-4, 2, 6] 4187 * ArrayUtils.add([2, 6, 3], 2, 1) = [2, 6, 1, 3] 4188 * </pre> 4189 * 4190 * @param array the array to add the element to, may be <code>null</code> 4191 * @param index the position of the new object 4192 * @param element the object to add 4193 * @return A new array containing the existing elements and the new element 4194 * @throws IndexOutOfBoundsException if the index is out of range 4195 * (index < 0 || index > array.length). 4196 */ 4197 public static int[] add(int[] array, int index, int element) { 4198 return (int[]) add(array, index, Integer.valueOf(element), Integer.TYPE); 4199 } 4200 4201 /** 4202 * <p>Inserts the specified element at the specified position in the array. 4203 * Shifts the element currently at that position (if any) and any subsequent 4204 * elements to the right (adds one to their indices).</p> 4205 * 4206 * <p>This method returns a new array with the same elements of the input 4207 * array plus the given element on the specified position. The component 4208 * type of the returned array is always the same as that of the input 4209 * array.</p> 4210 * 4211 * <p>If the input array is <code>null</code>, a new one element array is returned 4212 * whose component type is the same as the element.</p> 4213 * 4214 * <pre> 4215 * ArrayUtils.add([1L], 0, 2L) = [2L, 1L] 4216 * ArrayUtils.add([2L, 6L], 2, 10L) = [2L, 6L, 10L] 4217 * ArrayUtils.add([2L, 6L], 0, -4L) = [-4L, 2L, 6L] 4218 * ArrayUtils.add([2L, 6L, 3L], 2, 1L) = [2L, 6L, 1L, 3L] 4219 * </pre> 4220 * 4221 * @param array the array to add the element to, may be <code>null</code> 4222 * @param index the position of the new object 4223 * @param element the object to add 4224 * @return A new array containing the existing elements and the new element 4225 * @throws IndexOutOfBoundsException if the index is out of range 4226 * (index < 0 || index > array.length). 4227 */ 4228 public static long[] add(long[] array, int index, long element) { 4229 return (long[]) add(array, index, Long.valueOf(element), Long.TYPE); 4230 } 4231 4232 /** 4233 * <p>Inserts the specified element at the specified position in the array. 4234 * Shifts the element currently at that position (if any) and any subsequent 4235 * elements to the right (adds one to their indices).</p> 4236 * 4237 * <p>This method returns a new array with the same elements of the input 4238 * array plus the given element on the specified position. The component 4239 * type of the returned array is always the same as that of the input 4240 * array.</p> 4241 * 4242 * <p>If the input array is <code>null</code>, a new one element array is returned 4243 * whose component type is the same as the element.</p> 4244 * 4245 * <pre> 4246 * ArrayUtils.add([1.1f], 0, 2.2f) = [2.2f, 1.1f] 4247 * ArrayUtils.add([2.3f, 6.4f], 2, 10.5f) = [2.3f, 6.4f, 10.5f] 4248 * ArrayUtils.add([2.6f, 6.7f], 0, -4.8f) = [-4.8f, 2.6f, 6.7f] 4249 * ArrayUtils.add([2.9f, 6.0f, 0.3f], 2, 1.0f) = [2.9f, 6.0f, 1.0f, 0.3f] 4250 * </pre> 4251 * 4252 * @param array the array to add the element to, may be <code>null</code> 4253 * @param index the position of the new object 4254 * @param element the object to add 4255 * @return A new array containing the existing elements and the new element 4256 * @throws IndexOutOfBoundsException if the index is out of range 4257 * (index < 0 || index > array.length). 4258 */ 4259 public static float[] add(float[] array, int index, float element) { 4260 return (float[]) add(array, index, Float.valueOf(element), Float.TYPE); 4261 } 4262 4263 /** 4264 * <p>Inserts the specified element at the specified position in the array. 4265 * Shifts the element currently at that position (if any) and any subsequent 4266 * elements to the right (adds one to their indices).</p> 4267 * 4268 * <p>This method returns a new array with the same elements of the input 4269 * array plus the given element on the specified position. The component 4270 * type of the returned array is always the same as that of the input 4271 * array.</p> 4272 * 4273 * <p>If the input array is <code>null</code>, a new one element array is returned 4274 * whose component type is the same as the element.</p> 4275 * 4276 * <pre> 4277 * ArrayUtils.add([1.1], 0, 2.2) = [2.2, 1.1] 4278 * ArrayUtils.add([2.3, 6.4], 2, 10.5) = [2.3, 6.4, 10.5] 4279 * ArrayUtils.add([2.6, 6.7], 0, -4.8) = [-4.8, 2.6, 6.7] 4280 * ArrayUtils.add([2.9, 6.0, 0.3], 2, 1.0) = [2.9, 6.0, 1.0, 0.3] 4281 * </pre> 4282 * 4283 * @param array the array to add the element to, may be <code>null</code> 4284 * @param index the position of the new object 4285 * @param element the object to add 4286 * @return A new array containing the existing elements and the new element 4287 * @throws IndexOutOfBoundsException if the index is out of range 4288 * (index < 0 || index > array.length). 4289 */ 4290 public static double[] add(double[] array, int index, double element) { 4291 return (double[]) add(array, index, Double.valueOf(element), Double.TYPE); 4292 } 4293 4294 /** 4295 * Underlying implementation of add(array, index, element) methods. 4296 * The last parameter is the class, which may not equal element.getClass 4297 * for primitives. 4298 * 4299 * @param array the array to add the element to, may be <code>null</code> 4300 * @param index the position of the new object 4301 * @param element the object to add 4302 * @param clss the type of the element being added 4303 * @return A new array containing the existing elements and the new element 4304 */ 4305 private static Object add(Object array, int index, Object element, Class<?> clss) { 4306 if (array == null) { 4307 if (index != 0) { 4308 throw new IndexOutOfBoundsException("Index: " + index + ", Length: 0"); 4309 } 4310 Object joinedArray = Array.newInstance(clss, 1); 4311 Array.set(joinedArray, 0, element); 4312 return joinedArray; 4313 } 4314 int length = Array.getLength(array); 4315 if (index > length || index < 0) { 4316 throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length); 4317 } 4318 Object result = Array.newInstance(clss, length + 1); 4319 System.arraycopy(array, 0, result, 0, index); 4320 Array.set(result, index, element); 4321 if (index < length) { 4322 System.arraycopy(array, index, result, index + 1, length - index); 4323 } 4324 return result; 4325 } 4326 4327 /** 4328 * <p>Removes the element at the specified position from the specified array. 4329 * All subsequent elements are shifted to the left (substracts one from 4330 * their indices).</p> 4331 * 4332 * <p>This method returns a new array with the same elements of the input 4333 * array except the element on the specified position. The component 4334 * type of the returned array is always the same as that of the input 4335 * array.</p> 4336 * 4337 * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException 4338 * will be thrown, because in that case no valid index can be specified.</p> 4339 * 4340 * <pre> 4341 * ArrayUtils.remove(["a"], 0) = [] 4342 * ArrayUtils.remove(["a", "b"], 0) = ["b"] 4343 * ArrayUtils.remove(["a", "b"], 1) = ["a"] 4344 * ArrayUtils.remove(["a", "b", "c"], 1) = ["a", "c"] 4345 * </pre> 4346 * 4347 * @param array the array to remove the element from, may not be <code>null</code> 4348 * @param index the position of the element to be removed 4349 * @return A new array containing the existing elements except the element 4350 * at the specified position. 4351 * @throws IndexOutOfBoundsException if the index is out of range 4352 * (index < 0 || index >= array.length), or if the array is <code>null</code>. 4353 * @since 2.1 4354 */ 4355 @SuppressWarnings("unchecked") // remove() always creates an array of the same type as its input 4356 public static <T> T[] remove(T[] array, int index) { 4357 return (T[]) remove((Object) array, index); 4358 } 4359 4360 /** 4361 * <p>Removes the first occurrence of the specified element from the 4362 * specified array. All subsequent elements are shifted to the left 4363 * (substracts one from their indices). If the array doesn't contains 4364 * such an element, no elements are removed from the array.</p> 4365 * 4366 * <p>This method returns a new array with the same elements of the input 4367 * array except the first occurrence of the specified element. The component 4368 * type of the returned array is always the same as that of the input 4369 * array.</p> 4370 * 4371 * <pre> 4372 * ArrayUtils.removeElement(null, "a") = null 4373 * ArrayUtils.removeElement([], "a") = [] 4374 * ArrayUtils.removeElement(["a"], "b") = ["a"] 4375 * ArrayUtils.removeElement(["a", "b"], "a") = ["b"] 4376 * ArrayUtils.removeElement(["a", "b", "a"], "a") = ["b", "a"] 4377 * </pre> 4378 * 4379 * @param array the array to remove the element from, may be <code>null</code> 4380 * @param element the element to be removed 4381 * @return A new array containing the existing elements except the first 4382 * occurrence of the specified element. 4383 * @since 2.1 4384 */ 4385 public static <T> T[] removeElement(T[] array, Object element) { 4386 int index = indexOf(array, element); 4387 if (index == INDEX_NOT_FOUND) { 4388 return clone(array); 4389 } 4390 return remove(array, index); 4391 } 4392 4393 /** 4394 * <p>Removes the element at the specified position from the specified array. 4395 * All subsequent elements are shifted to the left (substracts one from 4396 * their indices).</p> 4397 * 4398 * <p>This method returns a new array with the same elements of the input 4399 * array except the element on the specified position. The component 4400 * type of the returned array is always the same as that of the input 4401 * array.</p> 4402 * 4403 * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException 4404 * will be thrown, because in that case no valid index can be specified.</p> 4405 * 4406 * <pre> 4407 * ArrayUtils.remove([true], 0) = [] 4408 * ArrayUtils.remove([true, false], 0) = [false] 4409 * ArrayUtils.remove([true, false], 1) = [true] 4410 * ArrayUtils.remove([true, true, false], 1) = [true, false] 4411 * </pre> 4412 * 4413 * @param array the array to remove the element from, may not be <code>null</code> 4414 * @param index the position of the element to be removed 4415 * @return A new array containing the existing elements except the element 4416 * at the specified position. 4417 * @throws IndexOutOfBoundsException if the index is out of range 4418 * (index < 0 || index >= array.length), or if the array is <code>null</code>. 4419 * @since 2.1 4420 */ 4421 public static boolean[] remove(boolean[] array, int index) { 4422 return (boolean[]) remove((Object) array, index); 4423 } 4424 4425 /** 4426 * <p>Removes the first occurrence of the specified element from the 4427 * specified array. All subsequent elements are shifted to the left 4428 * (substracts one from their indices). If the array doesn't contains 4429 * such an element, no elements are removed from the array.</p> 4430 * 4431 * <p>This method returns a new array with the same elements of the input 4432 * array except the first occurrence of the specified element. The component 4433 * type of the returned array is always the same as that of the input 4434 * array.</p> 4435 * 4436 * <pre> 4437 * ArrayUtils.removeElement(null, true) = null 4438 * ArrayUtils.removeElement([], true) = [] 4439 * ArrayUtils.removeElement([true], false) = [true] 4440 * ArrayUtils.removeElement([true, false], false) = [true] 4441 * ArrayUtils.removeElement([true, false, true], true) = [false, true] 4442 * </pre> 4443 * 4444 * @param array the array to remove the element from, may be <code>null</code> 4445 * @param element the element to be removed 4446 * @return A new array containing the existing elements except the first 4447 * occurrence of the specified element. 4448 * @since 2.1 4449 */ 4450 public static boolean[] removeElement(boolean[] array, boolean element) { 4451 int index = indexOf(array, element); 4452 if (index == INDEX_NOT_FOUND) { 4453 return clone(array); 4454 } 4455 return remove(array, index); 4456 } 4457 4458 /** 4459 * <p>Removes the element at the specified position from the specified array. 4460 * All subsequent elements are shifted to the left (substracts one from 4461 * their indices).</p> 4462 * 4463 * <p>This method returns a new array with the same elements of the input 4464 * array except the element on the specified position. The component 4465 * type of the returned array is always the same as that of the input 4466 * array.</p> 4467 * 4468 * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException 4469 * will be thrown, because in that case no valid index can be specified.</p> 4470 * 4471 * <pre> 4472 * ArrayUtils.remove([1], 0) = [] 4473 * ArrayUtils.remove([1, 0], 0) = [0] 4474 * ArrayUtils.remove([1, 0], 1) = [1] 4475 * ArrayUtils.remove([1, 0, 1], 1) = [1, 1] 4476 * </pre> 4477 * 4478 * @param array the array to remove the element from, may not be <code>null</code> 4479 * @param index the position of the element to be removed 4480 * @return A new array containing the existing elements except the element 4481 * at the specified position. 4482 * @throws IndexOutOfBoundsException if the index is out of range 4483 * (index < 0 || index >= array.length), or if the array is <code>null</code>. 4484 * @since 2.1 4485 */ 4486 public static byte[] remove(byte[] array, int index) { 4487 return (byte[]) remove((Object) array, index); 4488 } 4489 4490 /** 4491 * <p>Removes the first occurrence of the specified element from the 4492 * specified array. All subsequent elements are shifted to the left 4493 * (substracts one from their indices). If the array doesn't contains 4494 * such an element, no elements are removed from the array.</p> 4495 * 4496 * <p>This method returns a new array with the same elements of the input 4497 * array except the first occurrence of the specified element. The component 4498 * type of the returned array is always the same as that of the input 4499 * array.</p> 4500 * 4501 * <pre> 4502 * ArrayUtils.removeElement(null, 1) = null 4503 * ArrayUtils.removeElement([], 1) = [] 4504 * ArrayUtils.removeElement([1], 0) = [1] 4505 * ArrayUtils.removeElement([1, 0], 0) = [1] 4506 * ArrayUtils.removeElement([1, 0, 1], 1) = [0, 1] 4507 * </pre> 4508 * 4509 * @param array the array to remove the element from, may be <code>null</code> 4510 * @param element the element to be removed 4511 * @return A new array containing the existing elements except the first 4512 * occurrence of the specified element. 4513 * @since 2.1 4514 */ 4515 public static byte[] removeElement(byte[] array, byte element) { 4516 int index = indexOf(array, element); 4517 if (index == INDEX_NOT_FOUND) { 4518 return clone(array); 4519 } 4520 return remove(array, index); 4521 } 4522 4523 /** 4524 * <p>Removes the element at the specified position from the specified array. 4525 * All subsequent elements are shifted to the left (substracts one from 4526 * their indices).</p> 4527 * 4528 * <p>This method returns a new array with the same elements of the input 4529 * array except the element on the specified position. The component 4530 * type of the returned array is always the same as that of the input 4531 * array.</p> 4532 * 4533 * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException 4534 * will be thrown, because in that case no valid index can be specified.</p> 4535 * 4536 * <pre> 4537 * ArrayUtils.remove(['a'], 0) = [] 4538 * ArrayUtils.remove(['a', 'b'], 0) = ['b'] 4539 * ArrayUtils.remove(['a', 'b'], 1) = ['a'] 4540 * ArrayUtils.remove(['a', 'b', 'c'], 1) = ['a', 'c'] 4541 * </pre> 4542 * 4543 * @param array the array to remove the element from, may not be <code>null</code> 4544 * @param index the position of the element to be removed 4545 * @return A new array containing the existing elements except the element 4546 * at the specified position. 4547 * @throws IndexOutOfBoundsException if the index is out of range 4548 * (index < 0 || index >= array.length), or if the array is <code>null</code>. 4549 * @since 2.1 4550 */ 4551 public static char[] remove(char[] array, int index) { 4552 return (char[]) remove((Object) array, index); 4553 } 4554 4555 /** 4556 * <p>Removes the first occurrence of the specified element from the 4557 * specified array. All subsequent elements are shifted to the left 4558 * (substracts one from their indices). If the array doesn't contains 4559 * such an element, no elements are removed from the array.</p> 4560 * 4561 * <p>This method returns a new array with the same elements of the input 4562 * array except the first occurrence of the specified element. The component 4563 * type of the returned array is always the same as that of the input 4564 * array.</p> 4565 * 4566 * <pre> 4567 * ArrayUtils.removeElement(null, 'a') = null 4568 * ArrayUtils.removeElement([], 'a') = [] 4569 * ArrayUtils.removeElement(['a'], 'b') = ['a'] 4570 * ArrayUtils.removeElement(['a', 'b'], 'a') = ['b'] 4571 * ArrayUtils.removeElement(['a', 'b', 'a'], 'a') = ['b', 'a'] 4572 * </pre> 4573 * 4574 * @param array the array to remove the element from, may be <code>null</code> 4575 * @param element the element to be removed 4576 * @return A new array containing the existing elements except the first 4577 * occurrence of the specified element. 4578 * @since 2.1 4579 */ 4580 public static char[] removeElement(char[] array, char element) { 4581 int index = indexOf(array, element); 4582 if (index == INDEX_NOT_FOUND) { 4583 return clone(array); 4584 } 4585 return remove(array, index); 4586 } 4587 4588 /** 4589 * <p>Removes the element at the specified position from the specified array. 4590 * All subsequent elements are shifted to the left (substracts one from 4591 * their indices).</p> 4592 * 4593 * <p>This method returns a new array with the same elements of the input 4594 * array except the element on the specified position. The component 4595 * type of the returned array is always the same as that of the input 4596 * array.</p> 4597 * 4598 * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException 4599 * will be thrown, because in that case no valid index can be specified.</p> 4600 * 4601 * <pre> 4602 * ArrayUtils.remove([1.1], 0) = [] 4603 * ArrayUtils.remove([2.5, 6.0], 0) = [6.0] 4604 * ArrayUtils.remove([2.5, 6.0], 1) = [2.5] 4605 * ArrayUtils.remove([2.5, 6.0, 3.8], 1) = [2.5, 3.8] 4606 * </pre> 4607 * 4608 * @param array the array to remove the element from, may not be <code>null</code> 4609 * @param index the position of the element to be removed 4610 * @return A new array containing the existing elements except the element 4611 * at the specified position. 4612 * @throws IndexOutOfBoundsException if the index is out of range 4613 * (index < 0 || index >= array.length), or if the array is <code>null</code>. 4614 * @since 2.1 4615 */ 4616 public static double[] remove(double[] array, int index) { 4617 return (double[]) remove((Object) array, index); 4618 } 4619 4620 /** 4621 * <p>Removes the first occurrence of the specified element from the 4622 * specified array. All subsequent elements are shifted to the left 4623 * (substracts one from their indices). If the array doesn't contains 4624 * such an element, no elements are removed from the array.</p> 4625 * 4626 * <p>This method returns a new array with the same elements of the input 4627 * array except the first occurrence of the specified element. The component 4628 * type of the returned array is always the same as that of the input 4629 * array.</p> 4630 * 4631 * <pre> 4632 * ArrayUtils.removeElement(null, 1.1) = null 4633 * ArrayUtils.removeElement([], 1.1) = [] 4634 * ArrayUtils.removeElement([1.1], 1.2) = [1.1] 4635 * ArrayUtils.removeElement([1.1, 2.3], 1.1) = [2.3] 4636 * ArrayUtils.removeElement([1.1, 2.3, 1.1], 1.1) = [2.3, 1.1] 4637 * </pre> 4638 * 4639 * @param array the array to remove the element from, may be <code>null</code> 4640 * @param element the element to be removed 4641 * @return A new array containing the existing elements except the first 4642 * occurrence of the specified element. 4643 * @since 2.1 4644 */ 4645 public static double[] removeElement(double[] array, double element) { 4646 int index = indexOf(array, element); 4647 if (index == INDEX_NOT_FOUND) { 4648 return clone(array); 4649 } 4650 return remove(array, index); 4651 } 4652 4653 /** 4654 * <p>Removes the element at the specified position from the specified array. 4655 * All subsequent elements are shifted to the left (substracts one from 4656 * their indices).</p> 4657 * 4658 * <p>This method returns a new array with the same elements of the input 4659 * array except the element on the specified position. The component 4660 * type of the returned array is always the same as that of the input 4661 * array.</p> 4662 * 4663 * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException 4664 * will be thrown, because in that case no valid index can be specified.</p> 4665 * 4666 * <pre> 4667 * ArrayUtils.remove([1.1], 0) = [] 4668 * ArrayUtils.remove([2.5, 6.0], 0) = [6.0] 4669 * ArrayUtils.remove([2.5, 6.0], 1) = [2.5] 4670 * ArrayUtils.remove([2.5, 6.0, 3.8], 1) = [2.5, 3.8] 4671 * </pre> 4672 * 4673 * @param array the array to remove the element from, may not be <code>null</code> 4674 * @param index the position of the element to be removed 4675 * @return A new array containing the existing elements except the element 4676 * at the specified position. 4677 * @throws IndexOutOfBoundsException if the index is out of range 4678 * (index < 0 || index >= array.length), or if the array is <code>null</code>. 4679 * @since 2.1 4680 */ 4681 public static float[] remove(float[] array, int index) { 4682 return (float[]) remove((Object) array, index); 4683 } 4684 4685 /** 4686 * <p>Removes the first occurrence of the specified element from the 4687 * specified array. All subsequent elements are shifted to the left 4688 * (substracts one from their indices). If the array doesn't contains 4689 * such an element, no elements are removed from the array.</p> 4690 * 4691 * <p>This method returns a new array with the same elements of the input 4692 * array except the first occurrence of the specified element. The component 4693 * type of the returned array is always the same as that of the input 4694 * array.</p> 4695 * 4696 * <pre> 4697 * ArrayUtils.removeElement(null, 1.1) = null 4698 * ArrayUtils.removeElement([], 1.1) = [] 4699 * ArrayUtils.removeElement([1.1], 1.2) = [1.1] 4700 * ArrayUtils.removeElement([1.1, 2.3], 1.1) = [2.3] 4701 * ArrayUtils.removeElement([1.1, 2.3, 1.1], 1.1) = [2.3, 1.1] 4702 * </pre> 4703 * 4704 * @param array the array to remove the element from, may be <code>null</code> 4705 * @param element the element to be removed 4706 * @return A new array containing the existing elements except the first 4707 * occurrence of the specified element. 4708 * @since 2.1 4709 */ 4710 public static float[] removeElement(float[] array, float element) { 4711 int index = indexOf(array, element); 4712 if (index == INDEX_NOT_FOUND) { 4713 return clone(array); 4714 } 4715 return remove(array, index); 4716 } 4717 4718 /** 4719 * <p>Removes the element at the specified position from the specified array. 4720 * All subsequent elements are shifted to the left (substracts one from 4721 * their indices).</p> 4722 * 4723 * <p>This method returns a new array with the same elements of the input 4724 * array except the element on the specified position. The component 4725 * type of the returned array is always the same as that of the input 4726 * array.</p> 4727 * 4728 * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException 4729 * will be thrown, because in that case no valid index can be specified.</p> 4730 * 4731 * <pre> 4732 * ArrayUtils.remove([1], 0) = [] 4733 * ArrayUtils.remove([2, 6], 0) = [6] 4734 * ArrayUtils.remove([2, 6], 1) = [2] 4735 * ArrayUtils.remove([2, 6, 3], 1) = [2, 3] 4736 * </pre> 4737 * 4738 * @param array the array to remove the element from, may not be <code>null</code> 4739 * @param index the position of the element to be removed 4740 * @return A new array containing the existing elements except the element 4741 * at the specified position. 4742 * @throws IndexOutOfBoundsException if the index is out of range 4743 * (index < 0 || index >= array.length), or if the array is <code>null</code>. 4744 * @since 2.1 4745 */ 4746 public static int[] remove(int[] array, int index) { 4747 return (int[]) remove((Object) array, index); 4748 } 4749 4750 /** 4751 * <p>Removes the first occurrence of the specified element from the 4752 * specified array. All subsequent elements are shifted to the left 4753 * (substracts one from their indices). If the array doesn't contains 4754 * such an element, no elements are removed from the array.</p> 4755 * 4756 * <p>This method returns a new array with the same elements of the input 4757 * array except the first occurrence of the specified element. The component 4758 * type of the returned array is always the same as that of the input 4759 * array.</p> 4760 * 4761 * <pre> 4762 * ArrayUtils.removeElement(null, 1) = null 4763 * ArrayUtils.removeElement([], 1) = [] 4764 * ArrayUtils.removeElement([1], 2) = [1] 4765 * ArrayUtils.removeElement([1, 3], 1) = [3] 4766 * ArrayUtils.removeElement([1, 3, 1], 1) = [3, 1] 4767 * </pre> 4768 * 4769 * @param array the array to remove the element from, may be <code>null</code> 4770 * @param element the element to be removed 4771 * @return A new array containing the existing elements except the first 4772 * occurrence of the specified element. 4773 * @since 2.1 4774 */ 4775 public static int[] removeElement(int[] array, int element) { 4776 int index = indexOf(array, element); 4777 if (index == INDEX_NOT_FOUND) { 4778 return clone(array); 4779 } 4780 return remove(array, index); 4781 } 4782 4783 /** 4784 * <p>Removes the element at the specified position from the specified array. 4785 * All subsequent elements are shifted to the left (substracts one from 4786 * their indices).</p> 4787 * 4788 * <p>This method returns a new array with the same elements of the input 4789 * array except the element on the specified position. The component 4790 * type of the returned array is always the same as that of the input 4791 * array.</p> 4792 * 4793 * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException 4794 * will be thrown, because in that case no valid index can be specified.</p> 4795 * 4796 * <pre> 4797 * ArrayUtils.remove([1], 0) = [] 4798 * ArrayUtils.remove([2, 6], 0) = [6] 4799 * ArrayUtils.remove([2, 6], 1) = [2] 4800 * ArrayUtils.remove([2, 6, 3], 1) = [2, 3] 4801 * </pre> 4802 * 4803 * @param array the array to remove the element from, may not be <code>null</code> 4804 * @param index the position of the element to be removed 4805 * @return A new array containing the existing elements except the element 4806 * at the specified position. 4807 * @throws IndexOutOfBoundsException if the index is out of range 4808 * (index < 0 || index >= array.length), or if the array is <code>null</code>. 4809 * @since 2.1 4810 */ 4811 public static long[] remove(long[] array, int index) { 4812 return (long[]) remove((Object) array, index); 4813 } 4814 4815 /** 4816 * <p>Removes the first occurrence of the specified element from the 4817 * specified array. All subsequent elements are shifted to the left 4818 * (substracts one from their indices). If the array doesn't contains 4819 * such an element, no elements are removed from the array.</p> 4820 * 4821 * <p>This method returns a new array with the same elements of the input 4822 * array except the first occurrence of the specified element. The component 4823 * type of the returned array is always the same as that of the input 4824 * array.</p> 4825 * 4826 * <pre> 4827 * ArrayUtils.removeElement(null, 1) = null 4828 * ArrayUtils.removeElement([], 1) = [] 4829 * ArrayUtils.removeElement([1], 2) = [1] 4830 * ArrayUtils.removeElement([1, 3], 1) = [3] 4831 * ArrayUtils.removeElement([1, 3, 1], 1) = [3, 1] 4832 * </pre> 4833 * 4834 * @param array the array to remove the element from, may be <code>null</code> 4835 * @param element the element to be removed 4836 * @return A new array containing the existing elements except the first 4837 * occurrence of the specified element. 4838 * @since 2.1 4839 */ 4840 public static long[] removeElement(long[] array, long element) { 4841 int index = indexOf(array, element); 4842 if (index == INDEX_NOT_FOUND) { 4843 return clone(array); 4844 } 4845 return remove(array, index); 4846 } 4847 4848 /** 4849 * <p>Removes the element at the specified position from the specified array. 4850 * All subsequent elements are shifted to the left (substracts one from 4851 * their indices).</p> 4852 * 4853 * <p>This method returns a new array with the same elements of the input 4854 * array except the element on the specified position. The component 4855 * type of the returned array is always the same as that of the input 4856 * array.</p> 4857 * 4858 * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException 4859 * will be thrown, because in that case no valid index can be specified.</p> 4860 * 4861 * <pre> 4862 * ArrayUtils.remove([1], 0) = [] 4863 * ArrayUtils.remove([2, 6], 0) = [6] 4864 * ArrayUtils.remove([2, 6], 1) = [2] 4865 * ArrayUtils.remove([2, 6, 3], 1) = [2, 3] 4866 * </pre> 4867 * 4868 * @param array the array to remove the element from, may not be <code>null</code> 4869 * @param index the position of the element to be removed 4870 * @return A new array containing the existing elements except the element 4871 * at the specified position. 4872 * @throws IndexOutOfBoundsException if the index is out of range 4873 * (index < 0 || index >= array.length), or if the array is <code>null</code>. 4874 * @since 2.1 4875 */ 4876 public static short[] remove(short[] array, int index) { 4877 return (short[]) remove((Object) array, index); 4878 } 4879 4880 /** 4881 * <p>Removes the first occurrence of the specified element from the 4882 * specified array. All subsequent elements are shifted to the left 4883 * (substracts one from their indices). If the array doesn't contains 4884 * such an element, no elements are removed from the array.</p> 4885 * 4886 * <p>This method returns a new array with the same elements of the input 4887 * array except the first occurrence of the specified element. The component 4888 * type of the returned array is always the same as that of the input 4889 * array.</p> 4890 * 4891 * <pre> 4892 * ArrayUtils.removeElement(null, 1) = null 4893 * ArrayUtils.removeElement([], 1) = [] 4894 * ArrayUtils.removeElement([1], 2) = [1] 4895 * ArrayUtils.removeElement([1, 3], 1) = [3] 4896 * ArrayUtils.removeElement([1, 3, 1], 1) = [3, 1] 4897 * </pre> 4898 * 4899 * @param array the array to remove the element from, may be <code>null</code> 4900 * @param element the element to be removed 4901 * @return A new array containing the existing elements except the first 4902 * occurrence of the specified element. 4903 * @since 2.1 4904 */ 4905 public static short[] removeElement(short[] array, short element) { 4906 int index = indexOf(array, element); 4907 if (index == INDEX_NOT_FOUND) { 4908 return clone(array); 4909 } 4910 return remove(array, index); 4911 } 4912 4913 /** 4914 * <p>Removes the element at the specified position from the specified array. 4915 * All subsequent elements are shifted to the left (substracts one from 4916 * their indices).</p> 4917 * 4918 * <p>This method returns a new array with the same elements of the input 4919 * array except the element on the specified position. The component 4920 * type of the returned array is always the same as that of the input 4921 * array.</p> 4922 * 4923 * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException 4924 * will be thrown, because in that case no valid index can be specified.</p> 4925 * 4926 * @param array the array to remove the element from, may not be <code>null</code> 4927 * @param index the position of the element to be removed 4928 * @return A new array containing the existing elements except the element 4929 * at the specified position. 4930 * @throws IndexOutOfBoundsException if the index is out of range 4931 * (index < 0 || index >= array.length), or if the array is <code>null</code>. 4932 * @since 2.1 4933 */ 4934 private static Object remove(Object array, int index) { 4935 int length = getLength(array); 4936 if (index < 0 || index >= length) { 4937 throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length); 4938 } 4939 4940 Object result = Array.newInstance(array.getClass().getComponentType(), length - 1); 4941 System.arraycopy(array, 0, result, 0, index); 4942 if (index < length - 1) { 4943 System.arraycopy(array, index + 1, result, index, length - index - 1); 4944 } 4945 4946 return result; 4947 } 4948 4949 }