1. /**
  2. * @author Albert Beaupre
  3. */
  4. @SuppressWarnings("unchecked")
  5. public final class ArrayUtility {
  7. /**
  8. * A pseudorandom number generator
  9. **/
  10. private static Random r = new Random();
  12. /**
  13. * Creates an array starting from the specified {@code start} argument and
  14. * ending at the {@code end} argument incrementing at the specified
  15. * {@code increment} argument.
  16. *
  17. * @param start the starting value
  18. * @param end the ending value
  19. * @param increment the value to increment by
  20. * @return an array filled with the values ranging from start to end by the
  21. * increment value
  22. */
  23. public static double[] range(double start, double end, double increment) {
  24. double[] a = new double[(int) (Math.abs(start - end) / increment)];
  25. int index = 0;
  26. double j = start < end ? (increment < 0 ? -increment : increment) : (increment < 0 ? increment : -increment);
  27. for (double i = start; start < end ? i <= end : i >= end; i += j) {
  28. a = Arrays.copyOf(a, index + 1);
  29. a[index++] = i;
  30. }
  31. return a;
  32. }
  34. /**
  35. * Creates an array starting from the specified {@code start} argument and
  36. * ending at the {@code end} argument incrementing at the specified
  37. * {@code increment} argument.
  38. *
  39. * @param start the starting value
  40. * @param end the ending value
  41. * @param increment the value to increment by
  42. * @return an array filled with the values ranging from start to end by the
  43. * increment value
  44. */
  45. public static int[] range(int start, int end, int increment) {
  46. int[] a = new int[Math.abs(start - end) / increment];
  47. int index = 0;
  48. int j = start < end ? (increment < 0 ? -increment : increment) : (increment < 0 ? increment : -increment);
  49. for (int i = start; start < end ? i <= end : i >= end; i += j) {
  50. a = Arrays.copyOf(a, index + 1);
  51. a[index++] = i;
  52. }
  53. return a;
  54. }
  56. /**
  57. * Creates an array starting from the specified {@code start} argument and
  58. * ending at the {@code end} argument incrementing at the specified
  59. * {@code increment} argument.
  60. *
  61. * @param start the starting value
  62. * @param end the ending value
  63. * @param increment the value to increment by
  64. * @return an array filled with the values ranging from start to end by the
  65. * increment value
  66. */
  67. public static float[] range(float start, float end, float increment) {
  68. float[] a = new float[(int) (Math.abs(start - end) / increment)];
  69. int index = 0;
  70. float j = start < end ? (increment < 0 ? -increment : increment) : (increment < 0 ? increment : -increment);
  71. for (float i = start; start < end ? i <= end : i >= end; i += j) {
  72. a = Arrays.copyOf(a, index + 1);
  73. a[index++] = i;
  74. }
  75. return a;
  76. }
  78. /**
  79. * Creates an array starting from the specified {@code start} argument and
  80. * ending at the {@code end} argument incrementing at the specified
  81. * {@code increment} argument.
  82. *
  83. * @param start the starting value
  84. * @param end the ending value
  85. * @param increment the value to increment by
  86. * @return an array filled with the values ranging from start to end by the
  87. * increment value
  88. */
  89. public static short[] range(short start, short end, short increment) {
  90. short[] a = new short[Math.abs(start - end) / increment];
  91. int index = 0;
  92. short j = (short) (start < end ? (increment < 0 ? -increment : increment) : (increment < 0 ? increment : -increment));
  93. for (short i = start; start < end ? i <= end : i >= end; i += j) {
  94. a = Arrays.copyOf(a, index + 1);
  95. a[index++] = i;
  96. }
  97. return a;
  98. }
  100. /**
  101. * Creates an array starting from the specified {@code start} argument and
  102. * ending at the {@code end} argument incrementing at the specified
  103. * {@code increment} argument.
  104. *
  105. * @param start the starting value
  106. * @param end the ending value
  107. * @param increment the value to increment by
  108. * @return an array filled with the values ranging from start to end by the
  109. * increment value
  110. */
  111. public static long[] range(long start, long end, long increment) {
  112. long[] a = new long[(int) (Math.abs(start - end) / increment)];
  113. int index = 0;
  114. long j = start < end ? (increment < 0 ? -increment : increment) : (increment < 0 ? increment : -increment);
  115. for (long i = start; start < end ? i <= end : i >= end; i += j) {
  116. a = Arrays.copyOf(a, index + 1);
  117. a[index++] = i;
  118. }
  119. return a;
  120. }
  122. /**
  123. * Creates an array starting from the specified {@code start} argument and
  124. * ending at the {@code end} argument incrementing at the specified
  125. * {@code increment} argument.
  126. *
  127. * @param start the starting value
  128. * @param end the ending value
  129. * @param increment the value to increment by
  130. * @return an array filled with the values ranging from start to end by the
  131. * increment value
  132. */
  133. public static byte[] range(byte start, byte end, byte increment) {
  134. byte[] a = new byte[Math.abs(start - end) / increment];
  135. int index = 0;
  136. byte j = (byte) (start < end ? (increment < 0 ? -increment : increment) : (increment < 0 ? increment : -increment));
  137. for (byte i = start; start < end ? i <= end : i >= end; i += j) {
  138. a = Arrays.copyOf(a, index + 1);
  139. a[index++] = i;
  140. }
  141. return a;
  142. }
  144. /**
  145. * Shuffles the elements within the specified {@code Array}.
  146. *
  147. * @param a the array to shuffle
  148. * @return the shuffled array
  149. */
  150. public static <T> void shuffle(T[] a) {
  151. for (int i = 0; i < a.length; i++)
  152. swap(i, r.nextInt(a.length), a);
  153. }
  155. /**
  156. * Shuffles the elements within the specified {@code Array}.
  157. *
  158. * @param a the array to shuffle
  159. * @return the shuffled array
  160. */
  161. public static void shuffle(int[] a) {
  162. for (int i = 0; i < a.length; i++)
  163. swap(i, r.nextInt(a.length), a);
  164. }
  166. /**
  167. * Shuffles the elements within the specified {@code Array}.
  168. *
  169. * @param a the array to shuffle
  170. * @return the shuffled array
  171. */
  172. public static void shuffle(short[] a) {
  173. for (int i = 0; i < a.length; i++)
  174. swap(i, r.nextInt(a.length), a);
  175. }
  177. /**
  178. * Shuffles the elements within the specified {@code Array}.
  179. *
  180. * @param a the array to shuffle
  181. * @return the shuffled array
  182. */
  183. public static void shuffle(float[] a) {
  184. for (int i = 0; i < a.length; i++)
  185. swap(i, r.nextInt(a.length), a);
  186. }
  188. /**
  189. * Shuffles the elements within the specified {@code Array}.
  190. *
  191. * @param a the array to shuffle
  192. * @return the shuffled array
  193. */
  194. public static void shuffle(byte[] a) {
  195. for (int i = 0; i < a.length; i++)
  196. swap(i, r.nextInt(a.length), a);
  197. }
  199. /**
  200. * Shuffles the elements within the specified {@code Array}.
  201. *
  202. * @param a the array to shuffle
  203. * @return the shuffled array
  204. */
  205. public static void shuffle(boolean[] a) {
  206. for (int i = 0; i < a.length; i++)
  207. swap(i, r.nextInt(a.length), a);
  208. }
  210. /**
  211. * Shuffles the elements within the specified {@code Array}.
  212. *
  213. * @param a the array to shuffle
  214. * @return the shuffled array
  215. */
  216. public static void shuffle(long[] a) {
  217. for (int i = 0; i < a.length; i++)
  218. swap(i, r.nextInt(a.length), a);
  219. }
  221. /**
  222. * Shuffles the elements within the specified {@code Array}.
  223. *
  224. * @param a the array to shuffle
  225. * @return the shuffled array
  226. */
  227. public static void shuffle(double[] a) {
  228. for (int i = 0; i < a.length; i++)
  229. swap(i, r.nextInt(a.length), a);
  230. }
  232. /**
  233. * Shuffles the elements within the specified {@code Array}.
  234. *
  235. * @param a the array to shuffle
  236. * @return the shuffled array
  237. */
  238. public static void shuffle(char[] a) {
  239. for (int i = 0; i < a.length; i++)
  240. swap(i, r.nextInt(a.length), a);
  241. }
  243. /**
  244. * Swaps the specified indicies {@code i} and {@code j} in the specified
  245. * array.
  246. *
  247. * @param i the first index to swap
  248. * @param j the second index to swap
  249. * @param a the array to swap the indicies
  250. */
  251. public static <T> void swap(int i, int j, T[] a) {
  252. T old = a[i];
  253. a[i] = a[j];
  254. a[j] = old;
  255. }
  257. /**
  258. * Swaps the specified indicies {@code i} and {@code j} in the specified
  259. * array.
  260. *
  261. * @param i the first index to swap
  262. * @param j the second index to swap
  263. * @param a the array to swap the indicies
  264. */
  265. public static void swap(int i, int j, int[] a) {
  266. int old = a[i];
  267. a[i] = a[j];
  268. a[j] = old;
  269. }
  271. /**
  272. * Swaps the specified indicies {@code i} and {@code j} in the specified
  273. * array.
  274. *
  275. * @param i the first index to swap
  276. * @param j the second index to swap
  277. * @param a the array to swap the indicies
  278. */
  279. public static void swap(int i, int j, short[] a) {
  280. short old = a[i];
  281. a[i] = a[j];
  282. a[j] = old;
  283. }
  285. /**
  286. * Swaps the specified indicies {@code i} and {@code j} in the specified
  287. * array.
  288. *
  289. * @param i the first index to swap
  290. * @param j the second index to swap
  291. * @param a the array to swap the indicies
  292. */
  293. public static void swap(int i, int j, float[] a) {
  294. float old = a[i];
  295. a[i] = a[j];
  296. a[j] = old;
  297. }
  299. /**
  300. * Swaps the specified indicies {@code i} and {@code j} in the specified
  301. * array.
  302. *
  303. * @param i the first index to swap
  304. * @param j the second index to swap
  305. * @param a the array to swap the indicies
  306. */
  307. public static void swap(int i, int j, byte[] a) {
  308. byte old = a[i];
  309. a[i] = a[j];
  310. a[j] = old;
  311. }
  313. /**
  314. * Swaps the specified indicies {@code i} and {@code j} in the specified
  315. * array.
  316. *
  317. * @param i the first index to swap
  318. * @param j the second index to swap
  319. * @param a the array to swap the indicies
  320. */
  321. public static void swap(int i, int j, boolean[] a) {
  322. boolean old = a[i];
  323. a[i] = a[j];
  324. a[j] = old;
  325. }
  327. /**
  328. * Swaps the specified indicies {@code i} and {@code j} in the specified
  329. * array.
  330. *
  331. * @param i the first index to swap
  332. * @param j the second index to swap
  333. * @param a the array to swap the indicies
  334. */
  335. public static void swap(int i, int j, long[] a) {
  336. long old = a[i];
  337. a[i] = a[j];
  338. a[j] = old;
  339. }
  341. /**
  342. * Swaps the specified indicies {@code i} and {@code j} in the specified
  343. * array.
  344. *
  345. * @param i the first index to swap
  346. * @param j the second index to swap
  347. * @param a the array to swap the indicies
  348. */
  349. public static void swap(int i, int j, double[] a) {
  350. double old = a[i];
  351. a[i] = a[j];
  352. a[j] = old;
  353. }
  355. /**
  356. * Swaps the specified indicies {@code i} and {@code j} in the specified
  357. * array.
  358. *
  359. * @param i the first index to swap
  360. * @param j the second index to swap
  361. * @param a the array to swap the indicies
  362. */
  363. public static void swap(int i, int j, char[] a) {
  364. char old = a[i];
  365. a[i] = a[j];
  366. a[j] = old;
  367. }
  369. /**
  370. * Returns true if the specified {@code Array} contains the specified
  371. * {@code type} using the specified {@code equals} filter to check if a type
  372. * is similar.
  373. *
  374. * @param a the array to search
  375. * @param t the object to check
  376. * @return true if the array contains the specified type; return false
  377. * otherwise
  378. */
  379. public static <T> boolean contains(T t, T[] a, Filter<T> equals) {
  380. for (Object o : a)
  381. if (o != null && equals.accept((T) o)) return true;
  382. return false;
  383. }
  385. /**
  386. * Returns true if the specified {@code Array} contains the specified
  387. * {@code type}; false is returned otherwise.
  388. *
  389. * @param a the array to search
  390. * @param t the object to check
  391. * @return true if the array contains the specified type; return false
  392. * otherwise
  393. */
  394. public static <T> boolean contains(T t, T[] a) {
  395. for (Object o : a)
  396. if (o != null && o.equals(t)) return true;
  397. return false;
  398. }
  400. /**
  401. * Returns true if the specified {@code Array} contains the specified
  402. * {@code type}; false is returned otherwise.
  403. *
  404. * @param a the array to search
  405. * @param t the object to check
  406. * @return true if the array contains the specified type; return false
  407. * otherwise
  408. */
  409. public static boolean contains(int t, int[] a) {
  410. for (int o : a)
  411. if (o == t) return true;
  412. return false;
  413. }
  415. /**
  416. * Returns true if the specified {@code Array} contains the specified
  417. * {@code type}; false is returned otherwise.
  418. *
  419. * @param a the array to search
  420. * @param t the object to check
  421. * @return true if the array contains the specified type; return false
  422. * otherwise
  423. */
  424. public static boolean contains(short t, short[] a) {
  425. for (short o : a)
  426. if (o == t) return true;
  427. return false;
  428. }
  430. /**
  431. * Returns true if the specified {@code Array} contains the specified
  432. * {@code type}; false is returned otherwise.
  433. *
  434. * @param a the array to search
  435. * @param t the object to check
  436. * @return true if the array contains the specified type; return false
  437. * otherwise
  438. */
  439. public static boolean contains(double t, double[] a) {
  440. for (double o : a)
  441. if (o == t) return true;
  442. return false;
  443. }
  445. /**
  446. * Returns true if the specified {@code Array} contains the specified
  447. * {@code type}; false is returned otherwise.
  448. *
  449. * @param a the array to search
  450. * @param t the object to check
  451. * @return true if the array contains the specified type; return false
  452. * otherwise
  453. */
  454. public static boolean contains(float t, float[] a) {
  455. for (float o : a)
  456. if (o == t) return true;
  457. return false;
  458. }
  460. /**
  461. * Returns true if the specified {@code Array} contains the specified
  462. * {@code type}; false is returned otherwise.
  463. *
  464. * @param a the array to search
  465. * @param t the object to check
  466. * @return true if the array contains the specified type; return false
  467. * otherwise
  468. */
  469. public static boolean contains(byte t, byte[] a) {
  470. for (byte o : a)
  471. if (o == t) return true;
  472. return false;
  473. }
  475. /**
  476. * Returns true if the specified {@code Array} contains the specified
  477. * {@code type}; false is returned otherwise.
  478. *
  479. * @param a the array to search
  480. * @param t the object to check
  481. * @return true if the array contains the specified type; return false
  482. * otherwise
  483. */
  484. public static boolean contains(char t, char[] a) {
  485. for (char o : a)
  486. if (o == t) return true;
  487. return false;
  488. }
  490. /**
  491. * Returns true if the specified {@code Array} contains the specified
  492. * {@code type}; false is returned otherwise.
  493. *
  494. * @param a the array to search
  495. * @param t the object to check
  496. * @return true if the array contains the specified type; return false
  497. * otherwise
  498. */
  499. public static boolean contains(long t, long[] a) {
  500. for (long o : a)
  501. if (o == t) return true;
  502. return false;
  503. }
  505. /**
  506. * Returns true if the specified {@code Array} contains the specified
  507. * {@code type}; false is returned otherwise.
  508. *
  509. * @param a the array to search
  510. * @param t the object to check
  511. * @return true if the array contains the specified type; return false
  512. * otherwise
  513. */
  514. public static boolean contains(boolean t, boolean[] a) {
  515. for (boolean o : a)
  516. if (o == t) return true;
  517. return false;
  518. }
  520. /**
  521. * Returns the index of the specified {@code o} argument within the
  522. * specified {@code a} Array. If there is no index, -1 is returned instead.
  523. *
  524. * @param o the value to search for
  525. * @param a the array to search
  526. * @return the index of the value; return -1 otherwise
  527. */
  528. public static <T> int indexOf(T o, T[] a) {
  529. for (int i = 0; i < a.length; i++)
  530. if (o == a[i]) return i;
  531. return -1;
  532. }
  534. /**
  535. * Returns the index of the specified {@code o} argument within the
  536. * specified {@code a} Array. If there is no index, -1 is returned instead.
  537. *
  538. * @param o the value to search for
  539. * @param a the array to search
  540. * @return the index of the value; return -1 otherwise
  541. */
  542. public static int indexOf(int o, int[] a) {
  543. for (int i = 0; i < a.length; i++)
  544. if (o == a[i]) return i;
  545. return -1;
  546. }
  548. /**
  549. * Returns the index of the specified {@code o} argument within the
  550. * specified {@code a} Array. If there is no index, -1 is returned instead.
  551. *
  552. * @param o the value to search for
  553. * @param a the array to search
  554. * @return the index of the value; return -1 otherwise
  555. */
  556. public static int indexOf(short o, short[] a) {
  557. for (int i = 0; i < a.length; i++)
  558. if (o == a[i]) return i;
  559. return -1;
  560. }
  562. /**
  563. * Returns the index of the specified {@code o} argument within the
  564. * specified {@code a} Array. If there is no index, -1 is returned instead.
  565. *
  566. * @param o the value to search for
  567. * @param a the array to search
  568. * @return the index of the value; return -1 otherwise
  569. */
  570. public static int indexOf(byte o, byte[] a) {
  571. for (int i = 0; i < a.length; i++)
  572. if (o == a[i]) return i;
  573. return -1;
  574. }
  576. /**
  577. * Returns the index of the specified {@code o} argument within the
  578. * specified {@code a} Array. If there is no index, -1 is returned instead.
  579. *
  580. * @param o the value to search for
  581. * @param a the array to search
  582. * @return the index of the value; return -1 otherwise
  583. */
  584. public static int indexOf(float o, float[] a) {
  585. for (int i = 0; i < a.length; i++)
  586. if (o == a[i]) return i;
  587. return -1;
  588. }
  590. /**
  591. * Returns the index of the specified {@code o} argument within the
  592. * specified {@code a} Array. If there is no index, -1 is returned instead.
  593. *
  594. * @param o the value to search for
  595. * @param a the array to search
  596. * @return the index of the value; return -1 otherwise
  597. */
  598. public static int indexOf(double o, double[] a) {
  599. for (int i = 0; i < a.length; i++)
  600. if (o == a[i]) return i;
  601. return -1;
  602. }
  604. /**
  605. * Returns the index of the specified {@code o} argument within the
  606. * specified {@code a} Array. If there is no index, -1 is returned instead.
  607. *
  608. * @param o the value to search for
  609. * @param a the array to search
  610. * @return the index of the value; return -1 otherwise
  611. */
  612. public static int indexOf(long o, long[] a) {
  613. for (int i = 0; i < a.length; i++)
  614. if (o == a[i]) return i;
  615. return -1;
  616. }
  618. /**
  619. * Returns the index of the specified {@code o} argument within the
  620. * specified {@code a} Array. If there is no index, -1 is returned instead.
  621. *
  622. * @param o the value to search for
  623. * @param a the array to search
  624. * @return the index of the value; return -1 otherwise
  625. */
  626. public static int indexOf(char o, char[] a) {
  627. for (int i = 0; i < a.length; i++)
  628. if (o == a[i]) return i;
  629. return -1;
  630. }
  632. /**
  633. * Returns the index of the specified {@code o} argument within the
  634. * specified {@code a} Array. If there is no index, -1 is returned instead.
  635. *
  636. * @param o the value to search for
  637. * @param a the array to search
  638. * @return the index of the value; return -1 otherwise
  639. */
  640. public static int indexOf(boolean o, boolean[] a) {
  641. for (int i = 0; i < a.length; i++)
  642. if (o == a[i]) return i;
  643. return -1;
  644. }
  646. /**
  647. * Returns the {@code Array} with the specified {@code index} removed from
  648. * the specified {@code a}.
  649. *
  650. * @param a the array to remove the index from
  651. * @param index the index to remove
  652. * @return the array with the removed index
  653. */
  654. public static <T> T[] removeIndex(T[] a, int index) {
  655. T[] n = (T[]) Array.newInstance(a[0].getClass(), a.length - 1);
  656. System.arraycopy(a, 0, n, 0, index);
  657. System.arraycopy(a, index + 1, n, index, a.length - index - 1);
  658. return n;
  659. }
  661. /**
  662. * Returns the {@code Array} with the specified {@code index} removed from
  663. * the specified {@code a}.
  664. *
  665. * @param a the array to remove the index from
  666. * @param index the index to remove
  667. * @return the array with the removed index
  668. */
  669. public static byte[] removeIndex(byte[] a, int index) {
  670. byte[] b = new byte[a.length - 1];
  671. System.arraycopy(a, 0, b, 0, index);
  672. System.arraycopy(a, index + 1, b, index, a.length - index - 1);
  673. return b;
  674. }
  676. /**
  677. * Returns the {@code Array} with the specified {@code index} removed from
  678. * the specified {@code a}.
  679. *
  680. * @param a the array to remove the index from
  681. * @param index the index to remove
  682. * @return the array with the removed index
  683. */
  684. public static int[] removeIndex(int[] a, int index) {
  685. int[] b = new int[a.length - 1];
  686. System.arraycopy(a, 0, b, 0, index);
  687. System.arraycopy(a, index + 1, b, index, a.length - index - 1);
  688. return b;
  689. }
  691. /**
  692. * Returns the {@code Array} with the specified {@code index} removed from
  693. * the specified {@code a}.
  694. *
  695. * @param a the array to remove the index from
  696. * @param index the index to remove
  697. * @return the array with the removed index
  698. */
  699. public static short[] removeIndex(short[] a, int index) {
  700. short[] b = new short[a.length - 1];
  701. System.arraycopy(a, 0, b, 0, index);
  702. System.arraycopy(a, index + 1, b, index, a.length - index - 1);
  703. return b;
  704. }
  706. /**
  707. * Returns the {@code Array} with the specified {@code index} removed from
  708. * the specified {@code a}.
  709. *
  710. * @param a the array to remove the index from
  711. * @param index the index to remove
  712. * @return the array with the removed index
  713. */
  714. public static long[] removeIndex(long[] a, int index) {
  715. long[] b = new long[a.length - 1];
  716. System.arraycopy(a, 0, b, 0, index);
  717. System.arraycopy(a, index + 1, b, index, a.length - index - 1);
  718. return b;
  719. }
  721. /**
  722. * Returns the {@code Array} with the specified {@code index} removed from
  723. * the specified {@code a}.
  724. *
  725. * @param a the array to remove the index from
  726. * @param index the index to remove
  727. * @return the array with the removed index
  728. */
  729. public static float[] removeIndex(float[] a, int index) {
  730. float[] b = new float[a.length - 1];
  731. System.arraycopy(a, 0, b, 0, index);
  732. System.arraycopy(a, index + 1, b, index, a.length - index - 1);
  733. return b;
  734. }
  736. /**
  737. * Returns the {@code Array} with the specified {@code index} removed from
  738. * the specified {@code a}.
  739. *
  740. * @param a the array to remove the index from
  741. * @param index the index to remove
  742. * @return the array with the removed index
  743. */
  744. public static double[] removeIndex(double[] a, int index) {
  745. double[] b = new double[a.length - 1];
  746. System.arraycopy(a, 0, b, 0, index);
  747. System.arraycopy(a, index + 1, b, index, a.length - index - 1);
  748. return b;
  749. }
  751. /**
  752. * Returns the {@code Array} with the specified {@code index} removed from
  753. * the specified {@code a}.
  754. *
  755. * @param a the array to remove the index from
  756. * @param index the index to remove
  757. * @return the array with the removed index
  758. */
  759. public static char[] removeIndex(char[] a, int index) {
  760. char[] b = new char[a.length - 1];
  761. System.arraycopy(a, 0, b, 0, index);
  762. System.arraycopy(a, index + 1, b, index, a.length - index - 1);
  763. return b;
  764. }
  766. /**
  767. * Returns the {@code Array} with the specified {@code index} removed from
  768. * the specified {@code a}.
  769. *
  770. * @param a the array to remove the index from
  771. * @param index the index to remove
  772. * @return the array with the removed index
  773. */
  774. public static boolean[] removeIndex(boolean[] a, int index) {
  775. boolean[] b = new boolean[a.length - 1];
  776. System.arraycopy(a, 0, b, 0, index);
  777. System.arraycopy(a, index + 1, b, index, a.length - index - 1);
  778. return b;
  779. }
  781. /**
  782. * Returns the {@code Array} with the specified {@code element} removed from
  783. * the specified {@code a}.
  784. *
  785. * @param a the array to remove the element from
  786. * @param element the element to remove
  787. * @return the array with the removed element
  788. */
  789. public static <T> T[] removeElement(T[] a, T element) {
  790. return removeIndex(a, ArrayUtility.indexOf(element, a));
  791. }
  793. /**
  794. * Returns the {@code Array} with the specified {@code element} removed from
  795. * the specified {@code a}.
  796. *
  797. * @param a the array to remove the element from
  798. * @param element the element to remove
  799. * @return the array with the removed element
  800. */
  801. public static boolean[] removeElement(boolean[] a, boolean element) {
  802. return removeIndex(a, ArrayUtility.indexOf(element, a));
  803. }
  805. /**
  806. * Returns the {@code Array} with the specified {@code element} removed from
  807. * the specified {@code a}.
  808. *
  809. * @param a the array to remove the element from
  810. * @param element the element to remove
  811. * @return the array with the removed element
  812. */
  813. public static byte[] removeElement(byte[] a, byte element) {
  814. return removeIndex(a, ArrayUtility.indexOf(element, a));
  815. }
  817. /**
  818. * Returns the {@code Array} with the specified {@code element} removed from
  819. * the specified {@code a}.
  820. *
  821. * @param a the array to remove the element from
  822. * @param element the element to remove
  823. * @return the array with the removed element
  824. */
  825. public static char[] removeElement(char[] a, char element) {
  826. return removeIndex(a, ArrayUtility.indexOf(element, a));
  827. }
  829. /**
  830. * Returns the {@code Array} with the specified {@code element} removed from
  831. * the specified {@code a}.
  832. *
  833. * @param a the array to remove the element from
  834. * @param element the element to remove
  835. * @return the array with the removed element
  836. */
  837. public static float[] removeElement(float[] a, float element) {
  838. return removeIndex(a, ArrayUtility.indexOf(element, a));
  839. }
  841. /**
  842. * Returns the {@code Array} with the specified {@code element} removed from
  843. * the specified {@code a}.
  844. *
  845. * @param a the array to remove the element from
  846. * @param element the element to remove
  847. * @return the array with the removed element
  848. */
  849. public static double[] removeElement(double[] a, double element) {
  850. return removeIndex(a, ArrayUtility.indexOf(element, a));
  851. }
  853. /**
  854. * Returns the {@code Array} with the specified {@code element} removed from
  855. * the specified {@code a}.
  856. *
  857. * @param a the array to remove the element from
  858. * @param element the element to remove
  859. * @return the array with the removed element
  860. */
  861. public static long[] removeElement(long[] a, long element) {
  862. return removeIndex(a, ArrayUtility.indexOf(element, a));
  863. }
  865. /**
  866. * Returns the {@code Array} with the specified {@code element} removed from
  867. * the specified {@code a}.
  868. *
  869. * @param a the array to remove the element from
  870. * @param element the element to remove
  871. * @return the array with the removed element
  872. */
  873. public static short[] removeElement(short[] a, short element) {
  874. return removeIndex(a, ArrayUtility.indexOf(element, a));
  875. }
  877. /**
  878. * Returns the {@code Array} with the specified {@code element} removed from
  879. * the specified {@code a}.
  880. *
  881. * @param a the array to remove the element from
  882. * @param element the element to remove
  883. * @return the array with the removed element
  884. */
  885. public static int[] removeElement(int[] a, int element) {
  886. return removeIndex(a, ArrayUtility.indexOf(element, a));
  887. }
  889. /**
  890. * Returns the {@code Array} with the specified {@code element} inserted at
  891. * the end of the specified {@code a}
  892. *
  893. * @param a the array to add the element to
  894. * @param element the element to add
  895. * @return the array with the added element
  896. */
  897. public static <T> T[] addElement(T[] a, T... element) {
  898. T[] b = Arrays.copyOf(a, a.length + element.length);
  899. for (int i = element.length - 1; i >= 0; i--)
  900. b[b.length - (i + 1)] = element[i];
  901. return b;
  902. }
  904. /**
  905. * Returns the {@code Array} with the specified {@code element} inserted at
  906. * the end of the specified {@code a}
  907. *
  908. * @param a the array to add the element to
  909. * @param element the element to add
  910. * @return the array with the added element
  911. */
  912. public static int[] addElement(int[] a, int... element) {
  913. int[] b = Arrays.copyOf(a, a.length + element.length);
  914. for (int i = element.length - 1; i >= 0; i--)
  915. b[b.length - (i + 1)] = element[i];
  916. return b;
  917. }
  919. /**
  920. * Returns the {@code Array} with the specified {@code element} inserted at
  921. * the end of the specified {@code a}
  922. *
  923. * @param a the array to add the element to
  924. * @param element the element to add
  925. * @return the array with the added element
  926. */
  927. public static short[] addElement(short[] a, short... element) {
  928. short[] b = Arrays.copyOf(a, a.length + element.length);
  929. for (int i = element.length - 1; i >= 0; i--)
  930. b[b.length - (i + 1)] = element[i];
  931. return b;
  932. }
  934. /**
  935. * Returns the {@code Array} with the specified {@code element} inserted at
  936. * the end of the specified {@code a}
  937. *
  938. * @param a the array to add the element to
  939. * @param element the element to add
  940. * @return the array with the added element
  941. */
  942. public static long[] addElement(long[] a, long... element) {
  943. long[] b = Arrays.copyOf(a, a.length + element.length);
  944. for (int i = element.length - 1; i >= 0; i--)
  945. b[b.length - (i + 1)] = element[i];
  946. return b;
  947. }
  949. /**
  950. * Returns the {@code Array} with the specified {@code element} inserted at
  951. * the end of the specified {@code a}
  952. *
  953. * @param a the array to add the element to
  954. * @param element the element to add
  955. * @return the array with the added element
  956. */
  957. public static float[] addElement(float[] a, float... element) {
  958. float[] b = Arrays.copyOf(a, a.length + element.length);
  959. for (int i = element.length - 1; i >= 0; i--)
  960. b[b.length - (i + 1)] = element[i];
  961. return b;
  962. }
  964. /**
  965. * Returns the {@code Array} with the specified {@code element} inserted at
  966. * the end of the specified {@code a}
  967. *
  968. * @param a the array to add the element to
  969. * @param element the element to add
  970. * @return the array with the added element
  971. */
  972. public static double[] addElement(double[] a, double... element) {
  973. double[] b = Arrays.copyOf(a, a.length + element.length);
  974. for (int i = element.length - 1; i >= 0; i--)
  975. b[b.length - (i + 1)] = element[i];
  976. return b;
  977. }
  979. /**
  980. * Returns the {@code Array} with the specified {@code element} inserted at
  981. * the end of the specified {@code a}
  982. *
  983. * @param a the array to add the element to
  984. * @param element the element to add
  985. * @return the array with the added element
  986. */
  987. public static byte[] addElement(byte[] a, byte... element) {
  988. byte[] b = Arrays.copyOf(a, a.length + element.length);
  989. for (int i = element.length - 1; i >= 0; i--)
  990. b[b.length - (i + 1)] = element[i];
  991. return b;
  992. }
  994. /**
  995. * Returns the {@code Array} with the specified {@code element} inserted at
  996. * the end of the specified {@code a}
  997. *
  998. * @param a the array to add the element to
  999. * @param element the element to add
  1000. * @return the array with the added element
  1001. */
  1002. public static char[] addElement(char[] a, char... element) {
  1003. char[] b = Arrays.copyOf(a, a.length + element.length);
  1004. for (int i = element.length - 1; i >= 0; i--)
  1005. b[b.length - (i + 1)] = element[i];
  1006. return b;
  1007. }
  1009. /**
  1010. * Returns the {@code Array} with the specified {@code element} inserted at
  1011. * the end of the specified {@code a}
  1012. *
  1013. * @param a the array to add the element to
  1014. * @param element the element to add
  1015. * @return the array with the added element
  1016. */
  1017. public static boolean[] addElement(boolean[] a, boolean... element) {
  1018. boolean[] b = Arrays.copyOf(a, a.length + element.length);
  1019. for (int i = element.length - 1; i >= 0; i--)
  1020. b[b.length - (i + 1)] = element[i];
  1021. return b;
  1022. }
  1024. /**
  1025. * Returns the {@code Array} with the specified {@code element} inserted at
  1026. * the specified {@code index} of the specified {@code a}.
  1027. *
  1028. * @param a the array to insert the element to
  1029. * @param index the index to insert the element at
  1030. * @param element the element to insert
  1031. * @return the array with the inserted element
  1032. */
  1033. public static <T> T[] insertElement(T[] a, int index, T element) {
  1034. T[] b = Arrays.copyOf(a, a.length + 1);
  1035. System.arraycopy(b, index, b, index + 1, a.length - index);
  1036. b[index] = element;
  1037. return b;
  1038. }
  1040. /**
  1041. * Returns the {@code Array} with the specified {@code element} inserted at
  1042. * the specified {@code index} of the specified {@code a}.
  1043. *
  1044. * @param a the array to insert the element to
  1045. * @param index the index to insert the element at
  1046. * @param element the element to insert
  1047. * @return the array with the inserted element
  1048. */
  1049. public static int[] insertElement(int[] a, int index, int element) {
  1050. int[] b = Arrays.copyOf(a, a.length + 1);
  1051. System.arraycopy(b, index, b, index + 1, a.length - index);
  1052. b[index] = element;
  1053. return b;
  1054. }
  1056. /**
  1057. * Returns the {@code Array} with the specified {@code element} inserted at
  1058. * the specified {@code index} of the specified {@code a}.
  1059. *
  1060. * @param a the array to insert the element to
  1061. * @param index the index to insert the element at
  1062. * @param element the element to insert
  1063. * @return the array with the inserted element
  1064. */
  1065. public static long[] insertElement(long[] a, int index, long element) {
  1066. long[] b = Arrays.copyOf(a, a.length + 1);
  1067. System.arraycopy(b, index, b, index + 1, a.length - index);
  1068. b[index] = element;
  1069. return b;
  1070. }
  1072. /**
  1073. * Returns the {@code Array} with the specified {@code element} inserted at
  1074. * the specified {@code index} of the specified {@code a}.
  1075. *
  1076. * @param a the array to insert the element to
  1077. * @param index the index to insert the element at
  1078. * @param element the element to insert
  1079. * @return the array with the inserted element
  1080. */
  1081. public static short[] insertElement(short[] a, int index, short element) {
  1082. short[] b = Arrays.copyOf(a, a.length + 1);
  1083. System.arraycopy(b, index, b, index + 1, a.length - index);
  1084. b[index] = element;
  1085. return b;
  1086. }
  1088. /**
  1089. * Returns the {@code Array} with the specified {@code element} inserted at
  1090. * the specified {@code index} of the specified {@code a}.
  1091. *
  1092. * @param a the array to insert the element to
  1093. * @param index the index to insert the element at
  1094. * @param element the element to insert
  1095. * @return the array with the inserted element
  1096. */
  1097. public static byte[] insertElement(byte[] a, int index, byte element) {
  1098. byte[] b = Arrays.copyOf(a, a.length + 1);
  1099. System.arraycopy(b, index, b, index + 1, a.length - index);
  1100. b[index] = element;
  1101. return b;
  1102. }
  1104. /**
  1105. * Returns the {@code Array} with the specified {@code element} inserted at
  1106. * the specified {@code index} of the specified {@code a}.
  1107. *
  1108. * @param a the array to insert the element to
  1109. * @param index the index to insert the element at
  1110. * @param element the element to insert
  1111. * @return the array with the inserted element
  1112. */
  1113. public static char[] insertElement(char[] a, int index, char element) {
  1114. char[] b = Arrays.copyOf(a, a.length + 1);
  1115. System.arraycopy(b, index, b, index + 1, a.length - index);
  1116. b[index] = element;
  1117. return b;
  1118. }
  1120. /**
  1121. * Returns the {@code Array} with the specified {@code element} inserted at
  1122. * the specified {@code index} of the specified {@code a}.
  1123. *
  1124. * @param a the array to insert the element to
  1125. * @param index the index to insert the element at
  1126. * @param element the element to insert
  1127. * @return the array with the inserted element
  1128. */
  1129. public static float[] insertElement(float[] a, int index, float element) {
  1130. float[] b = Arrays.copyOf(a, a.length + 1);
  1131. System.arraycopy(b, index, b, index + 1, a.length - index);
  1132. b[index] = element;
  1133. return b;
  1134. }
  1136. /**
  1137. * Returns the {@code Array} with the specified {@code element} inserted at
  1138. * the specified {@code index} of the specified {@code a}.
  1139. *
  1140. * @param a the array to insert the element to
  1141. * @param index the index to insert the element at
  1142. * @param element the element to insert
  1143. * @return the array with the inserted element
  1144. */
  1145. public static double[] insertElement(double[] a, int index, double element) {
  1146. double[] b = Arrays.copyOf(a, a.length + 1);
  1147. System.arraycopy(b, index, b, index + 1, a.length - index);
  1148. b[index] = element;
  1149. return b;
  1150. }
  1152. /**
  1153. * Returns the {@code Array} with the specified {@code element} inserted at
  1154. * the specified {@code index} of the specified {@code a}.
  1155. *
  1156. * @param a the array to insert the element to
  1157. * @param index the index to insert the element at
  1158. * @param element the element to insert
  1159. * @return the array with the inserted element
  1160. */
  1161. public static boolean[] insertElement(boolean[] a, int index, boolean element) {
  1162. boolean[] b = Arrays.copyOf(a, a.length + 1);
  1163. System.arraycopy(b, index, b, index + 1, a.length - index);
  1164. b[index] = element;
  1165. return b;
  1166. }
  1168. /**
  1169. * Returns a pseudorandom element from the specified {@code a}.
  1170. *
  1171. * @param a the array to retrieve the pseudorandomly retrieved element from
  1172. * @return the pseudorandomly retrieved element
  1173. */
  1174. public static <T> T randomElement(T[] a) {
  1175. return a[r.nextInt(a.length)];
  1176. }
  1178. /**
  1179. * Returns a pseudorandom element from the specified {@code a}.
  1180. *
  1181. * @param a the array to retrieve the pseudorandomly retrieved element from
  1182. * @return the pseudorandomly retrieved element
  1183. */
  1184. public static int randomElement(int[] a) {
  1185. return a[r.nextInt(a.length)];
  1186. }
  1188. /**
  1189. * Returns a pseudorandom element from the specified {@code a}.
  1190. *
  1191. * @param a the array to retrieve the pseudorandomly retrieved element from
  1192. * @return the pseudorandomly retrieved element
  1193. */
  1194. public static short randomElement(short[] a) {
  1195. return a[r.nextInt(a.length)];
  1196. }
  1198. /**
  1199. * Returns a pseudorandom element from the specified {@code a}.
  1200. *
  1201. * @param a the array to retrieve the pseudorandomly retrieved element from
  1202. * @return the pseudorandomly retrieved element
  1203. */
  1204. public static long randomElement(long[] a) {
  1205. return a[r.nextInt(a.length)];
  1206. }
  1208. /**
  1209. * Returns a pseudorandom element from the specified {@code a}.
  1210. *
  1211. * @param a the array to retrieve the pseudorandomly retrieved element from
  1212. * @return the pseudorandomly retrieved element
  1213. */
  1214. public static byte randomElement(byte[] a) {
  1215. return a[r.nextInt(a.length)];
  1216. }
  1218. /**
  1219. * Returns a pseudorandom element from the specified {@code a}.
  1220. *
  1221. * @param a the array to retrieve the pseudorandomly retrieved element from
  1222. * @return the pseudorandomly retrieved element
  1223. */
  1224. public static float randomElement(float[] a) {
  1225. return a[r.nextInt(a.length)];
  1226. }
  1228. /**
  1229. * Returns a pseudorandom element from the specified {@code a}.
  1230. *
  1231. * @param a the array to retrieve the pseudorandomly retrieved element from
  1232. * @return the pseudorandomly retrieved element
  1233. */
  1234. public static double randomElement(double[] a) {
  1235. return a[r.nextInt(a.length)];
  1236. }
  1238. /**
  1239. * Returns a pseudorandom element from the specified {@code a}.
  1240. *
  1241. * @param a the array to retrieve the pseudorandomly retrieved element from
  1242. * @return the pseudorandomly retrieved element
  1243. */
  1244. public static char randomElement(char[] a) {
  1245. return a[r.nextInt(a.length)];
  1246. }
  1248. /**
  1249. * Returns a pseudorandom element from the specified {@code a}.
  1250. *
  1251. * @param a the array to retrieve the pseudorandomly retrieved element from
  1252. * @return the pseudorandomly retrieved element
  1253. */
  1254. public static boolean randomElement(boolean[] a) {
  1255. return a[r.nextInt(a.length)];
  1256. }
  1258. /**
  1259. * Reverses the elements of the specified {@code a}.
  1260. *
  1261. * @param a the array to reverse
  1262. * @return the reversed array
  1263. */
  1264. public static <T> T[] reverse(T[] a) {
  1265. T[] reverse = (T[]) Array.newInstance(a[0].getClass(), a.length);
  1266. for (int i = a.length - 1; i >= 0; i--)
  1267. reverse[i] = a[a.length - 1 - i];
  1268. return reverse;
  1269. }
  1271. /**
  1272. * Reverses the elements of the specified {@code a}.
  1273. *
  1274. * @param a the array to reverse
  1275. * @return the reversed array
  1276. */
  1277. public static int[] reverse(int[] a) {
  1278. int[] reverse = new int[a.length];
  1279. for (int i = a.length - 1; i >= 0; i--)
  1280. reverse[i] = a[a.length - 1 - i];
  1281. return reverse;
  1282. }
  1284. /**
  1285. * Reverses the elements of the specified {@code a}.
  1286. *
  1287. * @param a the array to reverse
  1288. * @return the reversed array
  1289. */
  1290. public static short[] reverse(short[] a) {
  1291. short[] reverse = new short[a.length];
  1292. for (int i = a.length - 1; i >= 0; i--)
  1293. reverse[i] = a[a.length - 1 - i];
  1294. return reverse;
  1295. }
  1297. /**
  1298. * Reverses the elements of the specified {@code a}.
  1299. *
  1300. * @param a the array to reverse
  1301. * @return the reversed array
  1302. */
  1303. public static long[] reverse(long[] a) {
  1304. long[] reverse = new long[a.length];
  1305. for (int i = a.length - 1; i >= 0; i--)
  1306. reverse[i] = a[a.length - 1 - i];
  1307. return reverse;
  1308. }
  1310. /**
  1311. * Reverses the elements of the specified {@code a}.
  1312. *
  1313. * @param a the array to reverse
  1314. * @return the reversed array
  1315. */
  1316. public static byte[] reverse(byte[] a) {
  1317. byte[] reverse = new byte[a.length];
  1318. for (int i = a.length - 1; i >= 0; i--)
  1319. reverse[i] = a[a.length - 1 - i];
  1320. return reverse;
  1321. }
  1323. /**
  1324. * Reverses the elements of the specified {@code a}.
  1325. *
  1326. * @param a the array to reverse
  1327. * @return the reversed array
  1328. */
  1329. public static float[] reverse(float[] a) {
  1330. float[] reverse = new float[a.length];
  1331. for (int i = a.length - 1; i >= 0; i--)
  1332. reverse[i] = a[a.length - 1 - i];
  1333. return reverse;
  1334. }
  1336. /**
  1337. * Reverses the elements of the specified {@code a}.
  1338. *
  1339. * @param a the array to reverse
  1340. * @return the reversed array
  1341. */
  1342. public static double[] reverse(double[] a) {
  1343. double[] reverse = new double[a.length];
  1344. for (int i = a.length - 1; i >= 0; i--)
  1345. reverse[i] = a[a.length - 1 - i];
  1346. return reverse;
  1347. }
  1349. /**
  1350. * Reverses the elements of the specified {@code a}.
  1351. *
  1352. * @param a the array to reverse
  1353. * @return the reversed array
  1354. */
  1355. public static char[] reverse(char[] a) {
  1356. char[] reverse = new char[a.length];
  1357. for (int i = a.length - 1; i >= 0; i--)
  1358. reverse[i] = a[a.length - 1 - i];
  1359. return reverse;
  1360. }
  1362. /**
  1363. * Reverses the elements of the specified {@code a}.
  1364. *
  1365. * @param a the array to reverse
  1366. * @return the reversed array
  1367. */
  1368. public static boolean[] reverse(boolean[] a) {
  1369. boolean[] reverse = new boolean[a.length];
  1370. for (int i = a.length - 1; i >= 0; i--)
  1371. reverse[i] = a[a.length - 1 - i];
  1372. return reverse;
  1373. }
  1375. /**
  1376. * Filters the specified {@code a} using the specified {@code predicate} for
  1377. * filtering.
  1378. *
  1379. * @param a the array to filter
  1380. * @param predicate the predicate to use for filtering
  1381. * @return the filtered array
  1382. */
  1383. public static <T> T[] filter(T[] a, Filter<T> predicate) {
  1384. T[] arr = (T[]) Array.newInstance(a[0].getClass(), 0);
  1385. for (T t : a)
  1386. if (predicate.accept(t)) arr = addElement(arr, t);
  1387. return arr;
  1388. }
  1390. /**
  1391. * Filters the specified {@code a} using the specified {@code predicate} for
  1392. * filtering.
  1393. *
  1394. * @param a the array to filter
  1395. * @param predicate the predicate to use for filtering
  1396. * @return the filtered array
  1397. */
  1398. public static int[] filter(int[] a, Filter<Integer> filter) {
  1399. int[] arr = new int[0];
  1400. for (int t : a)
  1401. if (filter.accept(t)) arr = addElement(arr, t);
  1402. return arr;
  1403. }
  1405. /**
  1406. * Filters the specified {@code a} using the specified {@code predicate} for
  1407. * filtering.
  1408. *
  1409. * @param a the array to filter
  1410. * @param predicate the predicate to use for filtering
  1411. * @return the filtered array
  1412. */
  1413. public static short[] filter(short[] a, Filter<Short> filter) {
  1414. short[] arr = new short[0];
  1415. for (short t : a)
  1416. if (filter.accept(t)) arr = addElement(arr, t);
  1417. return arr;
  1418. }
  1420. /**
  1421. * Filters the specified {@code a} using the specified {@code predicate} for
  1422. * filtering.
  1423. *
  1424. * @param a the array to filter
  1425. * @param predicate the predicate to use for filtering
  1426. * @return the filtered array
  1427. */
  1428. public static long[] filter(long[] a, Filter<Long> filter) {
  1429. long[] arr = new long[0];
  1430. for (long t : a)
  1431. if (filter.accept(t)) arr = addElement(arr, t);
  1432. return arr;
  1433. }
  1435. /**
  1436. * Filters the specified {@code a} using the specified {@code predicate} for
  1437. * filtering.
  1438. *
  1439. * @param a the array to filter
  1440. * @param predicate the predicate to use for filtering
  1441. * @return the filtered array
  1442. */
  1443. public static byte[] filter(byte[] a, Filter<Byte> filter) {
  1444. byte[] arr = new byte[0];
  1445. for (byte t : a)
  1446. if (filter.accept(t)) arr = addElement(arr, t);
  1447. return arr;
  1448. }
  1450. /**
  1451. * Filters the specified {@code a} using the specified {@code predicate} for
  1452. * filtering.
  1453. *
  1454. * @param a the array to filter
  1455. * @param predicate the predicate to use for filtering
  1456. * @return the filtered array
  1457. */
  1458. public static float[] filter(float[] a, Filter<Float> filter) {
  1459. float[] arr = new float[0];
  1460. for (float t : a)
  1461. if (filter.accept(t)) arr = addElement(arr, t);
  1462. return arr;
  1463. }
  1465. /**
  1466. * Filters the specified {@code a} using the specified {@code predicate} for
  1467. * filtering.
  1468. *
  1469. * @param a the array to filter
  1470. * @param predicate the predicate to use for filtering
  1471. * @return the filtered array
  1472. */
  1473. public static double[] filter(double[] a, Filter<Double> filter) {
  1474. double[] arr = new double[0];
  1475. for (double t : a)
  1476. if (filter.accept(t)) arr = addElement(arr, t);
  1477. return arr;
  1478. }
  1480. /**
  1481. * Filters the specified {@code a} using the specified {@code predicate} for
  1482. * filtering.
  1483. *
  1484. * @param a the array to filter
  1485. * @param predicate the predicate to use for filtering
  1486. * @return the filtered array
  1487. */
  1488. public static char[] filter(char[] a, Filter<Character> filter) {
  1489. char[] arr = new char[0];
  1490. for (char t : a)
  1491. if (filter.accept(t)) arr = addElement(arr, t);
  1492. return arr;
  1493. }
  1495. /**
  1496. * Filters the specified {@code a} using the specified {@code predicate} for
  1497. * filtering.
  1498. *
  1499. * @param a the array to filter
  1500. * @param predicate the predicate to use for filtering
  1501. * @return the filtered array
  1502. */
  1503. public static boolean[] filter(boolean[] a, Filter<Boolean> filter) {
  1504. boolean[] arr = new boolean[0];
  1505. for (boolean t : a)
  1506. if (filter.accept(t)) arr = addElement(arr, t);
  1507. return arr;
  1508. }
  1509. }