KezvhLib/src-lib/net/kezvh/collections/KezvhArrays.java

   1 package net.kezvh.collections;
   2
   3 import java.lang.reflect.Array;
   4 import java.util.Arrays;
   5 import java.util.ListIterator;
   6 import java.util.NoSuchElementException;
   7
   8 import net.kezvh.lang.UtilityClassInstantiationException;
   9 import net.kezvh.text.StringUtilities;
  10
  11 /**
  12  * @author mjacob
  13  *
  14  */
  15 public final class KezvhArrays {
  16         private KezvhArrays() {
  17                 throw new UtilityClassInstantiationException(KezvhArrays.class);
  18         }
  19
  20         private static final class ArrayIterator<T> extends AbstractListIterator<T> {
  21                 private final T[] array;
  22                 private int cursor = 0;
  23                 private final int end;
  24
  25                 public ArrayIterator(final T[] array) {
  26                         this(array, 0, 0, array.length);
  27                 }
  28
  29                 public ArrayIterator(final T[] array, final int firstIndex, final int startIndex, final int lastIndex) {
  30                         super(startIndex);
  31                         this.array = Arrays.copyOf(array, array.length);
  32                         this.cursor = firstIndex;
  33                         this.end = lastIndex;
  34                 }
  35
  36                 @Override
  37                 protected void add0(final T e) {
  38                         throw new UnsupportedOperationException();
  39                 }
  40
  41                 @Override
  42                 protected T findNext() throws NoSuchElementException {
  43                         if (this.cursor >= this.end)
  44                                 throw new NoSuchElementException();
  45                         return this.array[this.cursor++];
  46                 }
  47
  48                 @Override
  49                 protected T findPrevious() throws NoSuchElementException {
  50                         if (this.cursor == 0)
  51                                 throw new NoSuchElementException();
  52                         return this.array[--this.cursor];
  53                 }
  54
  55                 @Override
  56                 protected void remove(final boolean previous) {
  57                         throw new UnsupportedOperationException();
  58                 }
  59
  60                 @Override
  61                 protected void set(final T e, final boolean previous) {
  62                         if (previous)
  63                                 this.array[this.cursor] = e;
  64                         else
  65                                 this.array[this.cursor - 1] = e;
  66                 }
  67         }
  68
  69         /**
  70          * @param <T> COMMENT
  71          * @param array COMMENT
  72          * @return COMMENT
  73          */
  74         public static <T> ListIterator<T> getIterator(final T[] array) {
  75                 return new ArrayIterator<T>(array);
  76         }
  77
  78         /**
  79          * @param string COMMENT
  80          * @return COMMENT
  81          */
  82         public static int[] getInts(final String string) {
  83                 final String[] numbers = StringUtilities.getAllGroups("([0-9]+)", string);
  84                 final int[] ints = new int[numbers.length];
  85                 for (int i = 0; i < numbers.length; i++)
  86                         ints[i] = Integer.parseInt(numbers[i]);
  87                 return ints;
  88         }
  89
  90         /**
  91          * @param <T>  COMMENT
  92          * @param array COMMENT
  93          */
  94         public static <T> void reverse(final T[] array) {
  95                 final int mid = array.length / 2;
  96                 for (int i = 0, j = array.length - 1; i < mid; i++, j--) {
  97                         final T tmp = array[i];
  98                         array[i] = array[j];
  99                         array[j] = tmp;
 100                 }
 101         }
 102
 103         /**
 104          * @param array COMMENT
 105          */
 106         public static void reverse(final long[] array) {
 107                 final int mid = array.length / 2;
 108                 for (int i = 0, j = array.length - 1; i < mid; i++, j--) {
 109                         final long tmp = array[i];
 110                         array[i] = array[j];
 111                         array[j] = tmp;
 112                 }
 113         }
 114
 115         /**
 116          * @param array COMMENT
 117          */
 118         public static void reverse(final int[] array) {
 119                 final int mid = array.length / 2;
 120                 for (int i = 0, j = array.length - 1; i < mid; i++, j--) {
 121                         final int tmp = array[i];
 122                         array[i] = array[j];
 123                         array[j] = tmp;
 124                 }
 125         }
 126
 127         /**
 128          * @param array COMMENT
 129          */
 130         public static void reverse(final short[] array) {
 131                 final int mid = array.length / 2;
 132                 for (int i = 0, j = array.length - 1; i < mid; i++, j--) {
 133                         final short tmp = array[i];
 134                         array[i] = array[j];
 135                         array[j] = tmp;
 136                 }
 137         }
 138
 139         /**
 140          * @param array COMMENT
 141          */
 142         public static void reverse(final byte[] array) {
 143                 final int mid = array.length / 2;
 144                 for (int i = 0, j = array.length - 1; i < mid; i++, j--) {
 145                         final byte tmp = array[i];
 146                         array[i] = array[j];
 147                         array[j] = tmp;
 148                 }
 149         }
 150
 151         /**
 152          * @param array COMMENT
 153          */
 154         public static void reverse(final boolean[] array) {
 155                 final int mid = array.length / 2;
 156                 for (int i = 0, j = array.length - 1; i < mid; i++, j--) {
 157                         final boolean tmp = array[i];
 158                         array[i] = array[j];
 159                         array[j] = tmp;
 160                 }
 161         }
 162
 163         /**
 164          * @param array COMMENT
 165          */
 166         public static void reverse(final char[] array) {
 167                 final int mid = array.length / 2;
 168                 for (int i = 0, j = array.length - 1; i < mid; i++, j--) {
 169                         final char tmp = array[i];
 170                         array[i] = array[j];
 171                         array[j] = tmp;
 172                 }
 173         }
 174
 175         /**
 176          * @param array COMMENT
 177          */
 178         public static void reverse(final float[] array) {
 179                 final int mid = array.length / 2;
 180                 for (int i = 0, j = array.length - 1; i < mid; i++, j--) {
 181                         final float tmp = array[i];
 182                         array[i] = array[j];
 183                         array[j] = tmp;
 184                 }
 185         }
 186
 187         /**
 188          * @param array COMMENT
 189          */
 190         public static void reverse(final double[] array) {
 191                 final int mid = array.length / 2;
 192                 for (int i = 0, j = array.length - 1; i < mid; i++, j--) {
 193                         final double tmp = array[i];
 194                         array[i] = array[j];
 195                         array[j] = tmp;
 196                 }
 197         }
 198
 199         /**
 200          * @param <T> COMMENT
 201          * @param n COMMENT
 202          * @param o COMMENT
 203          * @return COMMENT
 204          */
 205         @SuppressWarnings("unchecked")
 206         public static <T> T[] nCopies(final int n, final T o) {
 207                 final T[] copies = (T[]) Array.newInstance(o.getClass(), n);
 208                 for (int i = 0; i < n; i++)
 209                         copies[i] = o;
 210                 return copies;
 211         }
 212
 213         /**
 214          * @param n COMMENT
 215          * @param b COMMENT
 216          * @return COMMENT
 217          */
 218         public static byte[] nCopies(final int n, final byte b) {
 219                 final byte[] copies = new byte[n];
 220                 for (int i = 0; i < n; i++)
 221                         copies[i] = b;
 222                 return copies;
 223         }
 224
 225         /**
 226          * @param n COMMENT
 227          * @param b COMMENT
 228          * @return COMMENT
 229          */
 230         public static short[] nCopies(final int n, final short b) {
 231                 final short[] copies = new short[n];
 232                 for (int i = 0; i < n; i++)
 233                         copies[i] = b;
 234                 return copies;
 235         }
 236
 237         /**
 238          * @param n COMMENT
 239          * @param b COMMENT
 240          * @return COMMENT
 241          */
 242         public static int[] nCopies(final int n, final int b) {
 243                 final int[] copies = new int[n];
 244                 for (int i = 0; i < n; i++)
 245                         copies[i] = b;
 246                 return copies;
 247         }
 248
 249         /**
 250          * @param n COMMENT
 251          * @param b COMMENT
 252          * @return COMMENT
 253          */
 254         public static long[] nCopies(final int n, final long b) {
 255                 final long[] copies = new long[n];
 256                 for (int i = 0; i < n; i++)
 257                         copies[i] = b;
 258                 return copies;
 259         }
 260
 261         /**
 262          * @param n COMMENT
 263          * @param b COMMENT
 264          * @return COMMENT
 265          */
 266         public static float[] nCopies(final int n, final float b) {
 267                 final float[] copies = new float[n];
 268                 for (int i = 0; i < n; i++)
 269                         copies[i] = b;
 270                 return copies;
 271         }
 272
 273         /**
 274          * @param n COMMENT
 275          * @param b COMMENT
 276          * @return COMMENT
 277          */
 278         public static double[] nCopies(final int n, final double b) {
 279                 final double[] copies = new double[n];
 280                 for (int i = 0; i < n; i++)
 281                         copies[i] = b;
 282                 return copies;
 283         }
 284
 285         /**
 286          * @param n COMMENT
 287          * @param b COMMENT
 288          * @return COMMENT
 289          */
 290         public static boolean[] nCopies(final int n, final boolean b) {
 291                 final boolean[] copies = new boolean[n];
 292                 for (int i = 0; i < n; i++)
 293                         copies[i] = b;
 294                 return copies;
 295         }
 296
 297         /**
 298          * @param n COMMENT
 299          * @param b COMMENT
 300          * @return COMMENT
 301          */
 302         public static char[] nCopies(final int n, final char b) {
 303                 final char[] copies = new char[n];
 304                 for (int i = 0; i < n; i++)
 305                         copies[i] = b;
 306                 return copies;
 307         }
 308
 309         /**
 310          * @param array COMMENT
 311          * @param element COMMENT
 312          * @return COMMENT
 313          */
 314         // ///////////////////////////////////////////////////////////
 315         public static int indexOf(final int[] array, final int element) {
 316                 for (int i = 0; i < array.length; i++)
 317                         if (array[i] == element)
 318                                 return i;
 319                 return -1;
 320         }
 321
 322         /**
 323          * @param array COMMENT
 324          * @param element COMMENT
 325          * @return COMMENT
 326          */
 327         public static int indexOf(final long[] array, final long element) {
 328                 for (int i = 0; i < array.length; i++)
 329                         if (array[i] == element)
 330                                 return i;
 331                 return -1;
 332         }
 333
 334         /**
 335          * @param array COMMENT
 336          * @param element COMMENT
 337          * @return COMMENT
 338          */
 339         public static int indexOf(final short[] array, final short element) {
 340                 for (int i = 0; i < array.length; i++)
 341                         if (array[i] == element)
 342                                 return i;
 343                 return -1;
 344         }
 345
 346         /**
 347          * @param array COMMENT
 348          * @param element COMMENT
 349          * @return COMMENT
 350          */
 351         public static int indexOf(final byte[] array, final byte element) {
 352                 for (int i = 0; i < array.length; i++)
 353                         if (array[i] == element)
 354                                 return i;
 355                 return -1;
 356         }
 357
 358         /**
 359          * @param array COMMENT
 360          * @param element COMMENT
 361          * @return COMMENT
 362          */
 363         public static int indexOf(final float[] array, final float element) {
 364                 for (int i = 0; i < array.length; i++)
 365                         if (array[i] == element)
 366                                 return i;
 367                 return -1;
 368         }
 369
 370         /**
 371          * @param array COMMENT
 372          * @param element COMMENT
 373          * @return COMMENT
 374          */
 375         public static int indexOf(final double[] array, final double element) {
 376                 for (int i = 0; i < array.length; i++)
 377                         if (array[i] == element)
 378                                 return i;
 379                 return -1;
 380         }
 381
 382         /**
 383          * @param array COMMENT
 384          * @param element COMMENT
 385          * @return COMMENT
 386          */
 387         public static int indexOf(final boolean[] array, final boolean element) {
 388                 for (int i = 0; i < array.length; i++)
 389                         if (array[i] == element)
 390                                 return i;
 391                 return -1;
 392         }
 393
 394         /**
 395          * @param array COMMENT
 396          * @param element COMMENT
 397          * @return COMMENT
 398          */
 399         public static int indexOf(final char[] array, final char element) {
 400                 for (int i = 0; i < array.length; i++)
 401                         if (array[i] == element)
 402                                 return i;
 403                 return -1;
 404         }
 405
 406         /**
 407          * @param array COMMENT
 408          * @param element COMMENT
 409          * @return COMMENT
 410          */
 411         public static int indexOf(final Object[] array, final Object element) {
 412                 for (int i = 0; i < array.length; i++)
 413                         if (array[i].equals(element))
 414                                 return i;
 415                 return -1;
 416         }
 417
 418         // ///////////////////////////////////////////////////////////
 419
 420         /**
 421          * @param array COMMENT
 422          * @param firstIndex COMMENT
 423          * @param secondIndex COMMENT
 424          */
 425         public static void swap(final int[] array, final int firstIndex, final int secondIndex) {
 426                 final int tmp = array[firstIndex];
 427                 array[firstIndex] = array[secondIndex];
 428                 array[secondIndex] = tmp;
 429         }
 430
 431         /**
 432          * @param array COMMENT
 433          * @param firstIndex COMMENT
 434          * @param secondIndex COMMENT
 435          */
 436         public static void swap(final long[] array, final int firstIndex, final int secondIndex) {
 437                 final long tmp = array[firstIndex];
 438                 array[firstIndex] = array[secondIndex];
 439                 array[secondIndex] = tmp;
 440         }
 441
 442         /**
 443          * @param array COMMENT
 444          * @param firstIndex COMMENT
 445          * @param secondIndex COMMENT
 446          */
 447         public static void swap(final short[] array, final int firstIndex, final int secondIndex) {
 448                 final short tmp = array[firstIndex];
 449                 array[firstIndex] = array[secondIndex];
 450                 array[secondIndex] = tmp;
 451         }
 452
 453         /**
 454          * @param array COMMENT
 455          * @param firstIndex COMMENT
 456          * @param secondIndex COMMENT
 457          */
 458         public static void swap(final byte[] array, final int firstIndex, final int secondIndex) {
 459                 final byte tmp = array[firstIndex];
 460                 array[firstIndex] = array[secondIndex];
 461                 array[secondIndex] = tmp;
 462         }
 463
 464         /**
 465          * @param array COMMENT
 466          * @param firstIndex COMMENT
 467          * @param secondIndex COMMENT
 468          */
 469         public static void swap(final float[] array, final int firstIndex, final int secondIndex) {
 470                 final float tmp = array[firstIndex];
 471                 array[firstIndex] = array[secondIndex];
 472                 array[secondIndex] = tmp;
 473         }
 474
 475         /**
 476          * @param array COMMENT
 477          * @param firstIndex COMMENT
 478          * @param secondIndex COMMENT
 479          */
 480         public static void swap(final double[] array, final int firstIndex, final int secondIndex) {
 481                 final double tmp = array[firstIndex];
 482                 array[firstIndex] = array[secondIndex];
 483                 array[secondIndex] = tmp;
 484         }
 485
 486         /**
 487          * @param array COMMENT
 488          * @param firstIndex COMMENT
 489          * @param secondIndex COMMENT
 490          */
 491         public static void swap(final boolean[] array, final int firstIndex, final int secondIndex) {
 492                 final boolean tmp = array[firstIndex];
 493                 array[firstIndex] = array[secondIndex];
 494                 array[secondIndex] = tmp;
 495         }
 496
 497         /**
 498          * @param array COMMENT
 499          * @param firstIndex COMMENT
 500          * @param secondIndex COMMENT
 501          */
 502         public static void swap(final char[] array, final int firstIndex, final int secondIndex) {
 503                 final char tmp = array[firstIndex];
 504                 array[firstIndex] = array[secondIndex];
 505                 array[secondIndex] = tmp;
 506         }
 507
 508         /**
 509          * @param array COMMENT
 510          * @param firstIndex COMMENT
 511          * @param secondIndex COMMENT
 512          */
 513         public static void swap(final Object[] array, final int firstIndex, final int secondIndex) {
 514                 final Object tmp = array[firstIndex];
 515                 array[firstIndex] = array[secondIndex];
 516                 array[secondIndex] = tmp;
 517         }
 518
 519         // ///////////////////////////////////////////////////////////
 520
 521         /**
 522          * @param array COMMENT
 523          * @param element COMMENT
 524          * @return COMMENT
 525          */
 526         public static int[] insert(final int[] array, final int element) {
 527                 return KezvhArrays.insert(array, 0, element);
 528         }
 529
 530         /**
 531          * @param array COMMENT
 532          * @param index COMMENT
 533          * @param element COMMENT
 534          * @return COMMENT
 535          */
 536         public static int[] insert(final int[] array, final int index, final int element) {
 537                 final int[] newArray = new int[array.length + 1];
 538                 if (index != 0)
 539                         System.arraycopy(array, 0, newArray, 0, index);
 540                 newArray[index] = element;
 541                 if (index != array.length)
 542                         System.arraycopy(array, index, newArray, index + 1, array.length - index);
 543                 return newArray;
 544         }
 545
 546         /**
 547          * @param array COMMENT
 548          * @param element COMMENT
 549          * @return COMMENT
 550          */
 551         public static long[] insert(final long[] array, final long element) {
 552                 return KezvhArrays.insert(array, 0, element);
 553         }
 554
 555         /**
 556          * @param array COMMENT
 557          * @param index COMMENT
 558          * @param element COMMENT
 559          * @return COMMENT
 560          */
 561         public static long[] insert(final long[] array, final int index, final long element) {
 562                 final long[] newArray = new long[array.length + 1];
 563                 if (index != 0)
 564                         System.arraycopy(array, 0, newArray, 0, index);
 565                 newArray[index] = element;
 566                 if (index != array.length)
 567                         System.arraycopy(array, index, newArray, index + 1, array.length - index);
 568                 return newArray;
 569         }
 570
 571         /**
 572          * @param array COMMENT
 573          * @param element COMMENT
 574          * @return COMMENT
 575          */
 576         public static short[] insert(final short[] array, final short element) {
 577                 return KezvhArrays.insert(array, 0, element);
 578         }
 579
 580         /**
 581          * @param array COMMENT
 582          * @param index COMMENT
 583          * @param element COMMENT
 584          * @return COMMENT
 585          */
 586         public static short[] insert(final short[] array, final int index, final short element) {
 587                 final short[] newArray = new short[array.length + 1];
 588                 if (index != 0)
 589                         System.arraycopy(array, 0, newArray, 0, index);
 590                 newArray[index] = element;
 591                 if (index != array.length)
 592                         System.arraycopy(array, index, newArray, index + 1, array.length - index);
 593                 return newArray;
 594         }
 595
 596         /**
 597          * @param array COMMENT
 598          * @param element COMMENT
 599          * @return COMMENT
 600          */
 601         public static byte[] insert(final byte[] array, final byte element) {
 602                 return KezvhArrays.insert(array, 0, element);
 603         }
 604
 605         /**
 606          * @param array COMMENT
 607          * @param index COMMENT
 608          * @param element COMMENT
 609          * @return COMMENT
 610          */
 611         public static byte[] insert(final byte[] array, final int index, final byte element) {
 612                 final byte[] newArray = new byte[array.length + 1];
 613                 if (index != 0)
 614                         System.arraycopy(array, 0, newArray, 0, index);
 615                 newArray[index] = element;
 616                 if (index != array.length)
 617                         System.arraycopy(array, index, newArray, index + 1, array.length - index);
 618                 return newArray;
 619         }
 620
 621         /**
 622          * @param array COMMENT
 623          * @param element COMMENT
 624          * @return COMMENT
 625          */
 626         public static float[] insert(final float[] array, final float element) {
 627                 return KezvhArrays.insert(array, 0, element);
 628         }
 629
 630         /**
 631          * @param array COMMENT
 632          * @param index COMMENT
 633          * @param element COMMENT
 634          * @return COMMENT
 635          */
 636         public static float[] insert(final float[] array, final int index, final float element) {
 637                 final float[] newArray = new float[array.length + 1];
 638                 if (index != 0)
 639                         System.arraycopy(array, 0, newArray, 0, index);
 640                 newArray[index] = element;
 641                 if (index != array.length)
 642                         System.arraycopy(array, index, newArray, index + 1, array.length - index);
 643                 return newArray;
 644         }
 645
 646         /**
 647          * @param array COMMENT
 648          * @param element COMMENT
 649          * @return COMMENT
 650          */
 651         public static double[] insert(final double[] array, final double element) {
 652                 return KezvhArrays.insert(array, 0, element);
 653         }
 654
 655         /**
 656          * @param array COMMENT
 657          * @param index COMMENT
 658          * @param element COMMENT
 659          * @return COMMENT
 660          */
 661         public static double[] insert(final double[] array, final int index, final double element) {
 662                 final double[] newArray = new double[array.length + 1];
 663                 if (index != 0)
 664                         System.arraycopy(array, 0, newArray, 0, index);
 665                 newArray[index] = element;
 666                 if (index != array.length)
 667                         System.arraycopy(array, index, newArray, index + 1, array.length - index);
 668                 return newArray;
 669         }
 670
 671         /**
 672          * @param array COMMENT
 673          * @param element COMMENT
 674          * @return COMMENT
 675          */
 676         public static boolean[] insert(final boolean[] array, final boolean element) {
 677                 return KezvhArrays.insert(array, 0, element);
 678         }
 679
 680         /**
 681          * @param array COMMENT
 682          * @param index COMMENT
 683          * @param element COMMENT
 684          * @return COMMENT
 685          */
 686         public static boolean[] insert(final boolean[] array, final int index, final boolean element) {
 687                 final boolean[] newArray = new boolean[array.length + 1];
 688                 if (index != 0)
 689                         System.arraycopy(array, 0, newArray, 0, index);
 690                 newArray[index] = element;
 691                 if (index != array.length)
 692                         System.arraycopy(array, index, newArray, index + 1, array.length - index);
 693                 return newArray;
 694         }
 695
 696         /**
 697          * @param array COMMENT
 698          * @param element COMMENT
 699          * @return COMMENT
 700          */
 701         public static char[] insert(final char[] array, final char element) {
 702                 return KezvhArrays.insert(array, 0, element);
 703         }
 704
 705         /**
 706          * @param array COMMENT
 707          * @param index COMMENT
 708          * @param element COMMENT
 709          * @return COMMENT
 710          */
 711         public static char[] insert(final char[] array, final int index, final char element) {
 712                 final char[] newArray = new char[array.length + 1];
 713                 if (index != 0)
 714                         System.arraycopy(array, 0, newArray, 0, index);
 715                 newArray[index] = element;
 716                 if (index != array.length)
 717                         System.arraycopy(array, index, newArray, index + 1, array.length - index);
 718                 return newArray;
 719         }
 720
 721         /**
 722          * @param <T> COMMENT
 723          * @param array COMMENT
 724          * @param element COMMENT
 725          * @return COMMENT
 726          */
 727         public static <T> T[] insert(final T[] array, final T element) {
 728                 return KezvhArrays.insert(array, 0, element);
 729         }
 730
 731         /**
 732          * @param <T> COMMENT
 733          * @param array COMMENT
 734          * @param index COMMENT
 735          * @param element COMMENT
 736          * @return COMMENT
 737          */
 738         @SuppressWarnings("unchecked")
 739         public static <T> T[] insert(final T[] array, final int index, final T element) {
 740                 final T[] newArray = (T[]) Array.newInstance(array.getClass().getComponentType(), array.length + 1);
 741                 if (index != 0)
 742                         System.arraycopy(array, 0, newArray, 0, index);
 743                 newArray[index] = element;
 744                 if (index != array.length)
 745                         System.arraycopy(array, index, newArray, index + 1, array.length - index);
 746                 return newArray;
 747         }
 748
 749         /**
 750          * @param array COMMENT
 751          * @param object COMMENT
 752          * @return COMMENT
 753          */
 754         public static Object[] add(final Object[] array, final Object object) {
 755                 Object concat[];
 756                 if (array == null) {
 757                         concat = (Object[]) Array.newInstance(object.getClass(), 1);
 758                         concat[0] = object;
 759                 } else {
 760                         final int newSize = array.length + 1;
 761                         concat = (Object[]) Array.newInstance(array.getClass().getComponentType(), newSize);
 762
 763                         System.arraycopy(array, 0, concat, 0, array.length);
 764                         concat[array.length] = object;
 765                 }
 766                 return concat;
 767         }
 768
 769         /**
 770          * @param array COMMENT
 771          * @param n COMMENT
 772          * @return COMMENT
 773          */
 774         public static int[] add(final int[] array, final int n) {
 775                 if (array == null)
 776                         return new int[] { n };
 777                 final int[] concat = new int[array.length + 1];
 778                 System.arraycopy(array, 0, concat, 0, array.length);
 779                 concat[array.length] = n;
 780                 return concat;
 781         }
 782
 783         /**
 784          * @param array COMMENT
 785          * @param n COMMENT
 786          * @return COMMENT
 787          */
 788         public static int[] remove(final int[] array, final int n) {
 789                 if (array == null)
 790                         return null;
 791                 final int[] concat = new int[array.length + 1];
 792                 System.arraycopy(array, 0, concat, 0, array.length);
 793                 concat[array.length] = n;
 794                 return concat;
 795         }
 796
 797         /**
 798          * @param array COMMENT
 799          * @param toAppend COMMENT
 800          * @return COMMENT
 801          */
 802         public static int[] addAll(final int[] array, final int[] toAppend) {
 803                 final int[] concat = new int[array.length + toAppend.length];
 804                 System.arraycopy(array, 0, concat, 0, array.length);
 805                 System.arraycopy(toAppend, 0, concat, array.length, toAppend.length);
 806                 return concat;
 807         }
 808
 809         // //////////////////////////////////////
 810
 811         /**
 812          * @param values COMMENT
 813          * @param value COMMENT
 814          * @return COMMENT
 815          */
 816         public static boolean contains(final int values[], final int value) {
 817                 for (final int element : values)
 818                         if (element == value)
 819                                 return true;
 820
 821                 return false;
 822         }
 823
 824         /**
 825          * @param values COMMENT
 826          * @param value COMMENT
 827          * @return COMMENT
 828          */
 829         public static boolean contains(final long values[], final long value) {
 830                 for (final long element : values)
 831                         if (element == value)
 832                                 return true;
 833
 834                 return false;
 835         }
 836
 837         /**
 838          * @param values COMMENT
 839          * @param value COMMENT
 840          * @return COMMENT
 841          */
 842         public static boolean contains(final short values[], final short value) {
 843                 for (final short element : values)
 844                         if (element == value)
 845                                 return true;
 846
 847                 return false;
 848         }
 849
 850         /**
 851          * @param values COMMENT
 852          * @param value COMMENT
 853          * @return COMMENT
 854          */
 855         public static boolean contains(final byte values[], final byte value) {
 856                 for (final byte element : values)
 857                         if (element == value)
 858                                 return true;
 859
 860                 return false;
 861         }
 862
 863         /**
 864          * @param values COMMENT
 865          * @param value COMMENT
 866          * @return COMMENT
 867          */
 868         public static boolean contains(final float values[], final float value) {
 869                 for (final float element : values)
 870                         if (element == value)
 871                                 return true;
 872
 873                 return false;
 874         }
 875
 876         /**
 877          * @param values COMMENT
 878          * @param value COMMENT
 879          * @return COMMENT
 880          */
 881         public static boolean contains(final double values[], final double value) {
 882                 for (final double element : values)
 883                         if (element == value)
 884                                 return true;
 885
 886                 return false;
 887         }
 888
 889         // ///////////////////////////////////
 890
 891         /**
 892          * @param array COMMENT
 893          * @param indicies COMMENT
 894          * @return COMMENT
 895          */
 896         public static int[] slice(final int[] array, final int[] indicies) {
 897                 final int[] values = new int[indicies.length];
 898                 for (int i = 0; i < indicies.length; i++)
 899                         values[i] = array[indicies[i]];
 900                 return values;
 901         }
 902
 903         /**
 904          * @param array COMMENT
 905          * @param indicies COMMENT
 906          * @return COMMENT
 907          */
 908         public static long[] slice(final long[] array, final int[] indicies) {
 909                 final long[] values = new long[indicies.length];
 910                 for (int i = 0; i < indicies.length; i++)
 911                         values[i] = array[indicies[i]];
 912                 return values;
 913         }
 914
 915         /**
 916          * @param array COMMENT
 917          * @param indicies COMMENT
 918          * @return COMMENT
 919          */
 920         public static float[] slice(final float[] array, final int[] indicies) {
 921                 final float[] values = new float[indicies.length];
 922                 for (int i = 0; i < indicies.length; i++)
 923                         values[i] = array[indicies[i]];
 924                 return values;
 925         }
 926
 927         /**
 928          * @param array COMMENT
 929          * @param indicies COMMENT
 930          * @return COMMENT
 931          */
 932         public static double[] slice(final double[] array, final int[] indicies) {
 933                 final double[] values = new double[indicies.length];
 934                 for (int i = 0; i < indicies.length; i++)
 935                         values[i] = array[indicies[i]];
 936                 return values;
 937         }
 938
 939         /**
 940          * @param array COMMENT
 941          * @param indicies COMMENT
 942          * @return COMMENT
 943          */
 944         public static byte[] slice(final byte[] array, final int[] indicies) {
 945                 final byte[] values = new byte[indicies.length];
 946                 for (int i = 0; i < indicies.length; i++)
 947                         values[i] = array[indicies[i]];
 948                 return values;
 949         }
 950
 951         /**
 952          * @param array COMMENT
 953          * @param indicies COMMENT
 954          * @return COMMENT
 955          */
 956         public static short[] slice(final short[] array, final int[] indicies) {
 957                 final short[] values = new short[indicies.length];
 958                 for (int i = 0; i < indicies.length; i++)
 959                         values[i] = array[indicies[i]];
 960                 return values;
 961         }
 962
 963         /**
 964          * @param array COMMENT
 965          * @param indicies COMMENT
 966          * @return COMMENT
 967          */
 968         public static char[] slice(final char[] array, final int[] indicies) {
 969                 final char[] values = new char[indicies.length];
 970                 for (int i = 0; i < indicies.length; i++)
 971                         values[i] = array[indicies[i]];
 972                 return values;
 973         }
 974
 975         /**
 976          * @param array COMMENT
 977          * @param indicies COMMENT
 978          * @return COMMENT
 979          */
 980         public static boolean[] slice(final boolean[] array, final int[] indicies) {
 981                 final boolean[] values = new boolean[indicies.length];
 982                 for (int i = 0; i < indicies.length; i++)
 983                         values[i] = array[indicies[i]];
 984                 return values;
 985         }
 986
 987         /**
 988          * @param array COMMENT
 989          * @param indicies COMMENT
 990          * @return COMMENT
 991          */
 992         public static Object[] slice(final Object[] array, final int[] indicies) {
 993                 final Object[] values = new Object[indicies.length];
 994                 for (int i = 0; i < indicies.length; i++)
 995                         values[i] = array[indicies[i]];
 996                 return values;
 997         }
 998
 999         // ///////////////////////////////
1000
1001         /**
1002          * @param array COMMENT
1003          * @return COMMENT
1004          */
1005         public static Integer[] toObjects(final int[] array) {
1006                 final Integer[] objects = new Integer[array.length];
1007
1008                 for (int i = 0; i < array.length; i++)
1009                         objects[i] = Integer.valueOf(array[i]);
1010
1011                 return objects;
1012         }
1013
1014         /**
1015          * @param array COMMENT
1016          * @return COMMENT
1017          */
1018         public static Long[] toObjects(final long[] array) {
1019                 final Long[] objects = new Long[array.length];
1020
1021                 for (int i = 0; i < array.length; i++)
1022                         objects[i] = Long.valueOf(array[i]);
1023
1024                 return objects;
1025         }
1026
1027         /**
1028          * @param array COMMENT
1029          * @return COMMENT
1030          */
1031         public static Float[] toObjects(final float[] array) {
1032                 final Float[] objects = new Float[array.length];
1033
1034                 for (int i = 0; i < array.length; i++)
1035                         objects[i] = Float.valueOf(array[i]);
1036
1037                 return objects;
1038         }
1039
1040         /**
1041          * @param array COMMENT
1042          * @return COMMENT
1043          */
1044         public static Double[] toObjects(final double[] array) {
1045                 final Double[] objects = new Double[array.length];
1046
1047                 for (int i = 0; i < array.length; i++)
1048                         objects[i] = Double.valueOf(array[i]);
1049
1050                 return objects;
1051         }
1052
1053         /**
1054          * @param array COMMENT
1055          * @return COMMENT
1056          */
1057         public static Byte[] toObjects(final byte[] array) {
1058                 final Byte[] objects = new Byte[array.length];
1059
1060                 for (int i = 0; i < array.length; i++)
1061                         objects[i] = Byte.valueOf(array[i]);
1062
1063                 return objects;
1064         }
1065
1066         /**
1067          * @param array COMMENT
1068          * @return COMMENT
1069          */
1070         public static Short[] toObjects(final short[] array) {
1071                 final Short[] objects = new Short[array.length];
1072
1073                 for (int i = 0; i < array.length; i++)
1074                         objects[i] = Short.valueOf(array[i]);
1075
1076                 return objects;
1077         }
1078
1079         /**
1080          * @param array COMMENT
1081          * @return COMMENT
1082          */
1083         public static Boolean[] toObjects(final boolean[] array) {
1084                 final Boolean[] objects = new Boolean[array.length];
1085
1086                 for (int i = 0; i < array.length; i++)
1087                         objects[i] = Boolean.valueOf(array[i]);
1088
1089                 return objects;
1090         }
1091
1092         /**
1093          * @param array COMMENT
1094          * @return COMMENT
1095          */
1096         public static Character[] toObjects(final char[] array) {
1097                 final Character[] objects = new Character[array.length];
1098
1099                 for (int i = 0; i < array.length; i++)
1100                         objects[i] = Character.valueOf(array[i]);
1101
1102                 return objects;
1103         }
1104
1105         // ////////////////////////////////
1106
1107         /**
1108          * @param array COMMENT
1109          * @return COMMENT
1110          */
1111         public static int[] toPrimatives(final Integer[] array) {
1112                 final int[] objects = new int[array.length];
1113
1114                 for (int i = 0; i < array.length; i++)
1115                         objects[i] = array[i].intValue();
1116
1117                 return objects;
1118         }
1119
1120         /**
1121          * @param array COMMENT
1122          * @return COMMENT
1123          */
1124         public static long[] toPrimatives(final Long[] array) {
1125                 final long[] objects = new long[array.length];
1126
1127                 for (int i = 0; i < array.length; i++)
1128                         objects[i] = array[i].longValue();
1129
1130                 return objects;
1131         }
1132
1133         /**
1134          * @param array COMMENT
1135          * @return COMMENT
1136          */
1137         public static short[] toPrimatives(final Short[] array) {
1138                 final short[] objects = new short[array.length];
1139
1140                 for (int i = 0; i < array.length; i++)
1141                         objects[i] = array[i].shortValue();
1142
1143                 return objects;
1144         }
1145
1146         /**
1147          * @param array COMMENT
1148          * @return COMMENT
1149          */
1150         public static byte[] toPrimatives(final Byte[] array) {
1151                 final byte[] objects = new byte[array.length];
1152
1153                 for (int i = 0; i < array.length; i++)
1154                         objects[i] = array[i].byteValue();
1155
1156                 return objects;
1157         }
1158
1159         /**
1160          * @param array COMMENT
1161          * @return COMMENT
1162          */
1163         public static char[] toPrimatives(final Character[] array) {
1164                 final char[] objects = new char[array.length];
1165
1166                 for (int i = 0; i < array.length; i++)
1167                         objects[i] = array[i].charValue();
1168
1169                 return objects;
1170         }
1171
1172         /**
1173          * @param array COMMENT
1174          * @return COMMENT
1175          */
1176         public static boolean[] toPrimatives(final Boolean[] array) {
1177                 final boolean[] objects = new boolean[array.length];
1178
1179                 for (int i = 0; i < array.length; i++)
1180                         objects[i] = array[i].booleanValue();
1181
1182                 return objects;
1183         }
1184
1185         /**
1186          * @param array COMMENT
1187          * @return COMMENT
1188          */
1189         public static float[] toPrimatives(final Float[] array) {
1190                 final float[] objects = new float[array.length];
1191
1192                 for (int i = 0; i < array.length; i++)
1193                         objects[i] = array[i].floatValue();
1194
1195                 return objects;
1196         }
1197
1198         /**
1199          * @param array COMMENT
1200          * @return COMMENT
1201          */
1202         public static double[] toPrimatives(final Double[] array) {
1203                 final double[] objects = new double[array.length];
1204
1205                 for (int i = 0; i < array.length; i++)
1206                         objects[i] = array[i].doubleValue();
1207
1208                 return objects;
1209         }
1210
1211         /**
1212      * is actually instance of morphism.anamorphism
1213      * @param start FIXME comment
1214      * @param end FIXME comment
1215      * @return xxx
1216      */
1217     public static char[] range(final char start, final char end) {
1218         if (start > end)
1219                 throw new IllegalArgumentException("end character '" + end + "' is lexically before start char '" + start + "'");
1220         final char[] range = new char[end - start];
1221         int i = 0;
1222         char current = start;
1223         while (i < range.length)
1224                 range[i++] = current++;
1225
1226         return range;
1227     }
1228
1229         /**
1230      * is actually a catamorpishm (fold)
1231      * @param arrays FIXME comment
1232      * @return concatenation
1233      */
1234     public static char[] toArray(final char[]... arrays) {
1235         int size = 0;
1236         for (final char[] element : arrays)
1237                 size += element.length;
1238
1239         final char[] array = new char[size];
1240
1241         for (int i = 0, j = 0; i < size; j++, i += arrays[i].length)
1242                 System.arraycopy(arrays[j], i, array, 0, arrays[j].length);
1243
1244         return array;
1245     }
1246
1247         /**
1248      * is actually instance of morphism.anamorphism
1249      * @param start FIXME comment
1250      * @param end FIXME comment
1251      * @return xxx
1252      */
1253     public static int[] range(final int start, final int end) {
1254         if (start > end)
1255                 throw new IllegalArgumentException("end character '" + end + "' is lexically before start char '" + start + "'");
1256         final int[] range = new int[end - start];
1257         int i = 0;
1258         int current = start;
1259         while (i < range.length)
1260                 range[i++] = current++;
1261
1262         return range;
1263     }
1264
1265         /**
1266      * is actually a catamorpishm (fold)
1267      * @param arrays FIXME comment
1268      * @return concatenation
1269      */
1270     public static int[] toArray(final int[]... arrays) {
1271         int size = 0;
1272         for (final int[] element : arrays)
1273                 size += element.length;
1274
1275         final int[] array = new int[size];
1276
1277         for (int i = 0, j = 0; i < size; j++, i += arrays[i].length)
1278                 System.arraycopy(arrays[j], i, array, 0, arrays[j].length);
1279
1280         return array;
1281     }
1282
1283         /**
1284      * @param <T> COMMENT
1285      * @param clazz COMMENT
1286      * @param length COMMENT
1287      * @return COMMENT
1288      */
1289     @SuppressWarnings("unchecked")
1290     public static <T> T[] createArray(final Class<?> clazz, final int length) {
1291         return (T[]) Array.newInstance(clazz, length);
1292     }
1293
1294 }