You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by br...@apache.org on 2014/03/18 19:32:37 UTC
svn commit: r902220 [3/14] - in
/websites/production/commons/content/proper/commons-lang: ./
apidocs/org/apache/commons/lang3/ apidocs/org/apache/commons/lang3/time/
apidocs/src-html/org/apache/commons/lang3/
apidocs/src-html/org/apache/commons/lang3/t...
Modified: websites/production/commons/content/proper/commons-lang/apidocs/src-html/org/apache/commons/lang3/ArrayUtils.html
==============================================================================
--- websites/production/commons/content/proper/commons-lang/apidocs/src-html/org/apache/commons/lang3/ArrayUtils.html (original)
+++ websites/production/commons/content/proper/commons-lang/apidocs/src-html/org/apache/commons/lang3/ArrayUtils.html Tue Mar 18 18:32:33 2014
@@ -47,7 +47,7 @@
<span class="sourceLineNo">039</span> *<a name="line.39"></a>
<span class="sourceLineNo">040</span> * <p>#ThreadSafe#</p><a name="line.40"></a>
<span class="sourceLineNo">041</span> * @since 2.0<a name="line.41"></a>
-<span class="sourceLineNo">042</span> * @version $Id: ArrayUtils.java 1553927 2013-12-28 21:17:57Z ggregory $<a name="line.42"></a>
+<span class="sourceLineNo">042</span> * @version $Id: ArrayUtils.java 1578214 2014-03-17 02:44:58Z ggregory $<a name="line.42"></a>
<span class="sourceLineNo">043</span> */<a name="line.43"></a>
<span class="sourceLineNo">044</span>public class ArrayUtils {<a name="line.44"></a>
<span class="sourceLineNo">045</span><a name="line.45"></a>
@@ -4288,1816 +4288,1814 @@
<span class="sourceLineNo">4280</span> * @param index the position of the new object<a name="line.4280"></a>
<span class="sourceLineNo">4281</span> * @param element the object to add<a name="line.4281"></a>
<span class="sourceLineNo">4282</span> * @return A new array containing the existing elements and the new element<a name="line.4282"></a>
-<span class="sourceLineNo">4283</span> * @throws IndexOutOfBoundsException if the index is out of range<a name="line.4283"></a>
-<span class="sourceLineNo">4284</span> * (index < 0 || index > array.length).<a name="line.4284"></a>
-<span class="sourceLineNo">4285</span> * @throws IllegalArgumentException if both array and element are null<a name="line.4285"></a>
-<span class="sourceLineNo">4286</span> */<a name="line.4286"></a>
-<span class="sourceLineNo">4287</span> public static <T> T[] add(final T[] array, final int index, final T element) {<a name="line.4287"></a>
-<span class="sourceLineNo">4288</span> Class<?> clss = null;<a name="line.4288"></a>
-<span class="sourceLineNo">4289</span> if (array != null) {<a name="line.4289"></a>
-<span class="sourceLineNo">4290</span> clss = array.getClass().getComponentType();<a name="line.4290"></a>
-<span class="sourceLineNo">4291</span> } else if (element != null) {<a name="line.4291"></a>
-<span class="sourceLineNo">4292</span> clss = element.getClass();<a name="line.4292"></a>
-<span class="sourceLineNo">4293</span> } else {<a name="line.4293"></a>
-<span class="sourceLineNo">4294</span> throw new IllegalArgumentException("Array and element cannot both be null");<a name="line.4294"></a>
-<span class="sourceLineNo">4295</span> }<a name="line.4295"></a>
-<span class="sourceLineNo">4296</span> @SuppressWarnings("unchecked") // the add method creates an array of type clss, which is type T<a name="line.4296"></a>
-<span class="sourceLineNo">4297</span> final T[] newArray = (T[]) add(array, index, element, clss);<a name="line.4297"></a>
-<span class="sourceLineNo">4298</span> return newArray;<a name="line.4298"></a>
-<span class="sourceLineNo">4299</span> }<a name="line.4299"></a>
-<span class="sourceLineNo">4300</span><a name="line.4300"></a>
-<span class="sourceLineNo">4301</span> /**<a name="line.4301"></a>
-<span class="sourceLineNo">4302</span> * <p>Inserts the specified element at the specified position in the array.<a name="line.4302"></a>
-<span class="sourceLineNo">4303</span> * Shifts the element currently at that position (if any) and any subsequent<a name="line.4303"></a>
-<span class="sourceLineNo">4304</span> * elements to the right (adds one to their indices).</p><a name="line.4304"></a>
-<span class="sourceLineNo">4305</span> *<a name="line.4305"></a>
-<span class="sourceLineNo">4306</span> * <p>This method returns a new array with the same elements of the input<a name="line.4306"></a>
-<span class="sourceLineNo">4307</span> * array plus the given element on the specified position. The component<a name="line.4307"></a>
-<span class="sourceLineNo">4308</span> * type of the returned array is always the same as that of the input<a name="line.4308"></a>
-<span class="sourceLineNo">4309</span> * array.</p><a name="line.4309"></a>
-<span class="sourceLineNo">4310</span> *<a name="line.4310"></a>
-<span class="sourceLineNo">4311</span> * <p>If the input array is {@code null}, a new one element array is returned<a name="line.4311"></a>
-<span class="sourceLineNo">4312</span> * whose component type is the same as the element.</p><a name="line.4312"></a>
-<span class="sourceLineNo">4313</span> *<a name="line.4313"></a>
-<span class="sourceLineNo">4314</span> * <pre><a name="line.4314"></a>
-<span class="sourceLineNo">4315</span> * ArrayUtils.add(null, 0, true) = [true]<a name="line.4315"></a>
-<span class="sourceLineNo">4316</span> * ArrayUtils.add([true], 0, false) = [false, true]<a name="line.4316"></a>
-<span class="sourceLineNo">4317</span> * ArrayUtils.add([false], 1, true) = [false, true]<a name="line.4317"></a>
-<span class="sourceLineNo">4318</span> * ArrayUtils.add([true, false], 1, true) = [true, true, false]<a name="line.4318"></a>
-<span class="sourceLineNo">4319</span> * </pre><a name="line.4319"></a>
-<span class="sourceLineNo">4320</span> *<a name="line.4320"></a>
-<span class="sourceLineNo">4321</span> * @param array the array to add the element to, may be {@code null}<a name="line.4321"></a>
-<span class="sourceLineNo">4322</span> * @param index the position of the new object<a name="line.4322"></a>
-<span class="sourceLineNo">4323</span> * @param element the object to add<a name="line.4323"></a>
-<span class="sourceLineNo">4324</span> * @return A new array containing the existing elements and the new element<a name="line.4324"></a>
-<span class="sourceLineNo">4325</span> * @throws IndexOutOfBoundsException if the index is out of range<a name="line.4325"></a>
-<span class="sourceLineNo">4326</span> * (index < 0 || index > array.length).<a name="line.4326"></a>
-<span class="sourceLineNo">4327</span> */<a name="line.4327"></a>
-<span class="sourceLineNo">4328</span> public static boolean[] add(final boolean[] array, final int index, final boolean element) {<a name="line.4328"></a>
-<span class="sourceLineNo">4329</span> return (boolean[]) add(array, index, Boolean.valueOf(element), Boolean.TYPE);<a name="line.4329"></a>
-<span class="sourceLineNo">4330</span> }<a name="line.4330"></a>
-<span class="sourceLineNo">4331</span><a name="line.4331"></a>
-<span class="sourceLineNo">4332</span> /**<a name="line.4332"></a>
-<span class="sourceLineNo">4333</span> * <p>Inserts the specified element at the specified position in the array.<a name="line.4333"></a>
-<span class="sourceLineNo">4334</span> * Shifts the element currently at that position (if any) and any subsequent<a name="line.4334"></a>
-<span class="sourceLineNo">4335</span> * elements to the right (adds one to their indices).</p><a name="line.4335"></a>
-<span class="sourceLineNo">4336</span> *<a name="line.4336"></a>
-<span class="sourceLineNo">4337</span> * <p>This method returns a new array with the same elements of the input<a name="line.4337"></a>
-<span class="sourceLineNo">4338</span> * array plus the given element on the specified position. The component<a name="line.4338"></a>
-<span class="sourceLineNo">4339</span> * type of the returned array is always the same as that of the input<a name="line.4339"></a>
-<span class="sourceLineNo">4340</span> * array.</p><a name="line.4340"></a>
-<span class="sourceLineNo">4341</span> *<a name="line.4341"></a>
-<span class="sourceLineNo">4342</span> * <p>If the input array is {@code null}, a new one element array is returned<a name="line.4342"></a>
-<span class="sourceLineNo">4343</span> * whose component type is the same as the element.</p><a name="line.4343"></a>
-<span class="sourceLineNo">4344</span> *<a name="line.4344"></a>
-<span class="sourceLineNo">4345</span> * <pre><a name="line.4345"></a>
-<span class="sourceLineNo">4346</span> * ArrayUtils.add(null, 0, 'a') = ['a']<a name="line.4346"></a>
-<span class="sourceLineNo">4347</span> * ArrayUtils.add(['a'], 0, 'b') = ['b', 'a']<a name="line.4347"></a>
-<span class="sourceLineNo">4348</span> * ArrayUtils.add(['a', 'b'], 0, 'c') = ['c', 'a', 'b']<a name="line.4348"></a>
-<span class="sourceLineNo">4349</span> * ArrayUtils.add(['a', 'b'], 1, 'k') = ['a', 'k', 'b']<a name="line.4349"></a>
-<span class="sourceLineNo">4350</span> * ArrayUtils.add(['a', 'b', 'c'], 1, 't') = ['a', 't', 'b', 'c']<a name="line.4350"></a>
-<span class="sourceLineNo">4351</span> * </pre><a name="line.4351"></a>
-<span class="sourceLineNo">4352</span> *<a name="line.4352"></a>
-<span class="sourceLineNo">4353</span> * @param array the array to add the element to, may be {@code null}<a name="line.4353"></a>
-<span class="sourceLineNo">4354</span> * @param index the position of the new object<a name="line.4354"></a>
-<span class="sourceLineNo">4355</span> * @param element the object to add<a name="line.4355"></a>
-<span class="sourceLineNo">4356</span> * @return A new array containing the existing elements and the new element<a name="line.4356"></a>
-<span class="sourceLineNo">4357</span> * @throws IndexOutOfBoundsException if the index is out of range<a name="line.4357"></a>
-<span class="sourceLineNo">4358</span> * (index < 0 || index > array.length).<a name="line.4358"></a>
-<span class="sourceLineNo">4359</span> */<a name="line.4359"></a>
-<span class="sourceLineNo">4360</span> public static char[] add(final char[] array, final int index, final char element) {<a name="line.4360"></a>
-<span class="sourceLineNo">4361</span> return (char[]) add(array, index, Character.valueOf(element), Character.TYPE);<a name="line.4361"></a>
-<span class="sourceLineNo">4362</span> }<a name="line.4362"></a>
-<span class="sourceLineNo">4363</span><a name="line.4363"></a>
-<span class="sourceLineNo">4364</span> /**<a name="line.4364"></a>
-<span class="sourceLineNo">4365</span> * <p>Inserts the specified element at the specified position in the array.<a name="line.4365"></a>
-<span class="sourceLineNo">4366</span> * Shifts the element currently at that position (if any) and any subsequent<a name="line.4366"></a>
-<span class="sourceLineNo">4367</span> * elements to the right (adds one to their indices).</p><a name="line.4367"></a>
-<span class="sourceLineNo">4368</span> *<a name="line.4368"></a>
-<span class="sourceLineNo">4369</span> * <p>This method returns a new array with the same elements of the input<a name="line.4369"></a>
-<span class="sourceLineNo">4370</span> * array plus the given element on the specified position. The component<a name="line.4370"></a>
-<span class="sourceLineNo">4371</span> * type of the returned array is always the same as that of the input<a name="line.4371"></a>
-<span class="sourceLineNo">4372</span> * array.</p><a name="line.4372"></a>
-<span class="sourceLineNo">4373</span> *<a name="line.4373"></a>
-<span class="sourceLineNo">4374</span> * <p>If the input array is {@code null}, a new one element array is returned<a name="line.4374"></a>
-<span class="sourceLineNo">4375</span> * whose component type is the same as the element.</p><a name="line.4375"></a>
-<span class="sourceLineNo">4376</span> *<a name="line.4376"></a>
-<span class="sourceLineNo">4377</span> * <pre><a name="line.4377"></a>
-<span class="sourceLineNo">4378</span> * ArrayUtils.add([1], 0, 2) = [2, 1]<a name="line.4378"></a>
-<span class="sourceLineNo">4379</span> * ArrayUtils.add([2, 6], 2, 3) = [2, 6, 3]<a name="line.4379"></a>
-<span class="sourceLineNo">4380</span> * ArrayUtils.add([2, 6], 0, 1) = [1, 2, 6]<a name="line.4380"></a>
-<span class="sourceLineNo">4381</span> * ArrayUtils.add([2, 6, 3], 2, 1) = [2, 6, 1, 3]<a name="line.4381"></a>
-<span class="sourceLineNo">4382</span> * </pre><a name="line.4382"></a>
-<span class="sourceLineNo">4383</span> *<a name="line.4383"></a>
-<span class="sourceLineNo">4384</span> * @param array the array to add the element to, may be {@code null}<a name="line.4384"></a>
-<span class="sourceLineNo">4385</span> * @param index the position of the new object<a name="line.4385"></a>
-<span class="sourceLineNo">4386</span> * @param element the object to add<a name="line.4386"></a>
-<span class="sourceLineNo">4387</span> * @return A new array containing the existing elements and the new element<a name="line.4387"></a>
-<span class="sourceLineNo">4388</span> * @throws IndexOutOfBoundsException if the index is out of range<a name="line.4388"></a>
-<span class="sourceLineNo">4389</span> * (index < 0 || index > array.length).<a name="line.4389"></a>
-<span class="sourceLineNo">4390</span> */<a name="line.4390"></a>
-<span class="sourceLineNo">4391</span> public static byte[] add(final byte[] array, final int index, final byte element) {<a name="line.4391"></a>
-<span class="sourceLineNo">4392</span> return (byte[]) add(array, index, Byte.valueOf(element), Byte.TYPE);<a name="line.4392"></a>
-<span class="sourceLineNo">4393</span> }<a name="line.4393"></a>
-<span class="sourceLineNo">4394</span><a name="line.4394"></a>
-<span class="sourceLineNo">4395</span> /**<a name="line.4395"></a>
-<span class="sourceLineNo">4396</span> * <p>Inserts the specified element at the specified position in the array.<a name="line.4396"></a>
-<span class="sourceLineNo">4397</span> * Shifts the element currently at that position (if any) and any subsequent<a name="line.4397"></a>
-<span class="sourceLineNo">4398</span> * elements to the right (adds one to their indices).</p><a name="line.4398"></a>
-<span class="sourceLineNo">4399</span> *<a name="line.4399"></a>
-<span class="sourceLineNo">4400</span> * <p>This method returns a new array with the same elements of the input<a name="line.4400"></a>
-<span class="sourceLineNo">4401</span> * array plus the given element on the specified position. The component<a name="line.4401"></a>
-<span class="sourceLineNo">4402</span> * type of the returned array is always the same as that of the input<a name="line.4402"></a>
-<span class="sourceLineNo">4403</span> * array.</p><a name="line.4403"></a>
-<span class="sourceLineNo">4404</span> *<a name="line.4404"></a>
-<span class="sourceLineNo">4405</span> * <p>If the input array is {@code null}, a new one element array is returned<a name="line.4405"></a>
-<span class="sourceLineNo">4406</span> * whose component type is the same as the element.</p><a name="line.4406"></a>
-<span class="sourceLineNo">4407</span> *<a name="line.4407"></a>
-<span class="sourceLineNo">4408</span> * <pre><a name="line.4408"></a>
-<span class="sourceLineNo">4409</span> * ArrayUtils.add([1], 0, 2) = [2, 1]<a name="line.4409"></a>
-<span class="sourceLineNo">4410</span> * ArrayUtils.add([2, 6], 2, 10) = [2, 6, 10]<a name="line.4410"></a>
-<span class="sourceLineNo">4411</span> * ArrayUtils.add([2, 6], 0, -4) = [-4, 2, 6]<a name="line.4411"></a>
-<span class="sourceLineNo">4412</span> * ArrayUtils.add([2, 6, 3], 2, 1) = [2, 6, 1, 3]<a name="line.4412"></a>
-<span class="sourceLineNo">4413</span> * </pre><a name="line.4413"></a>
-<span class="sourceLineNo">4414</span> *<a name="line.4414"></a>
-<span class="sourceLineNo">4415</span> * @param array the array to add the element to, may be {@code null}<a name="line.4415"></a>
-<span class="sourceLineNo">4416</span> * @param index the position of the new object<a name="line.4416"></a>
-<span class="sourceLineNo">4417</span> * @param element the object to add<a name="line.4417"></a>
-<span class="sourceLineNo">4418</span> * @return A new array containing the existing elements and the new element<a name="line.4418"></a>
-<span class="sourceLineNo">4419</span> * @throws IndexOutOfBoundsException if the index is out of range<a name="line.4419"></a>
-<span class="sourceLineNo">4420</span> * (index < 0 || index > array.length).<a name="line.4420"></a>
-<span class="sourceLineNo">4421</span> */<a name="line.4421"></a>
-<span class="sourceLineNo">4422</span> public static short[] add(final short[] array, final int index, final short element) {<a name="line.4422"></a>
-<span class="sourceLineNo">4423</span> return (short[]) add(array, index, Short.valueOf(element), Short.TYPE);<a name="line.4423"></a>
-<span class="sourceLineNo">4424</span> }<a name="line.4424"></a>
-<span class="sourceLineNo">4425</span><a name="line.4425"></a>
-<span class="sourceLineNo">4426</span> /**<a name="line.4426"></a>
-<span class="sourceLineNo">4427</span> * <p>Inserts the specified element at the specified position in the array.<a name="line.4427"></a>
-<span class="sourceLineNo">4428</span> * Shifts the element currently at that position (if any) and any subsequent<a name="line.4428"></a>
-<span class="sourceLineNo">4429</span> * elements to the right (adds one to their indices).</p><a name="line.4429"></a>
-<span class="sourceLineNo">4430</span> *<a name="line.4430"></a>
-<span class="sourceLineNo">4431</span> * <p>This method returns a new array with the same elements of the input<a name="line.4431"></a>
-<span class="sourceLineNo">4432</span> * array plus the given element on the specified position. The component<a name="line.4432"></a>
-<span class="sourceLineNo">4433</span> * type of the returned array is always the same as that of the input<a name="line.4433"></a>
-<span class="sourceLineNo">4434</span> * array.</p><a name="line.4434"></a>
-<span class="sourceLineNo">4435</span> *<a name="line.4435"></a>
-<span class="sourceLineNo">4436</span> * <p>If the input array is {@code null}, a new one element array is returned<a name="line.4436"></a>
-<span class="sourceLineNo">4437</span> * whose component type is the same as the element.</p><a name="line.4437"></a>
-<span class="sourceLineNo">4438</span> *<a name="line.4438"></a>
-<span class="sourceLineNo">4439</span> * <pre><a name="line.4439"></a>
-<span class="sourceLineNo">4440</span> * ArrayUtils.add([1], 0, 2) = [2, 1]<a name="line.4440"></a>
-<span class="sourceLineNo">4441</span> * ArrayUtils.add([2, 6], 2, 10) = [2, 6, 10]<a name="line.4441"></a>
-<span class="sourceLineNo">4442</span> * ArrayUtils.add([2, 6], 0, -4) = [-4, 2, 6]<a name="line.4442"></a>
-<span class="sourceLineNo">4443</span> * ArrayUtils.add([2, 6, 3], 2, 1) = [2, 6, 1, 3]<a name="line.4443"></a>
-<span class="sourceLineNo">4444</span> * </pre><a name="line.4444"></a>
-<span class="sourceLineNo">4445</span> *<a name="line.4445"></a>
-<span class="sourceLineNo">4446</span> * @param array the array to add the element to, may be {@code null}<a name="line.4446"></a>
-<span class="sourceLineNo">4447</span> * @param index the position of the new object<a name="line.4447"></a>
-<span class="sourceLineNo">4448</span> * @param element the object to add<a name="line.4448"></a>
-<span class="sourceLineNo">4449</span> * @return A new array containing the existing elements and the new element<a name="line.4449"></a>
-<span class="sourceLineNo">4450</span> * @throws IndexOutOfBoundsException if the index is out of range<a name="line.4450"></a>
-<span class="sourceLineNo">4451</span> * (index < 0 || index > array.length).<a name="line.4451"></a>
-<span class="sourceLineNo">4452</span> */<a name="line.4452"></a>
-<span class="sourceLineNo">4453</span> public static int[] add(final int[] array, final int index, final int element) {<a name="line.4453"></a>
-<span class="sourceLineNo">4454</span> return (int[]) add(array, index, Integer.valueOf(element), Integer.TYPE);<a name="line.4454"></a>
-<span class="sourceLineNo">4455</span> }<a name="line.4455"></a>
-<span class="sourceLineNo">4456</span><a name="line.4456"></a>
-<span class="sourceLineNo">4457</span> /**<a name="line.4457"></a>
-<span class="sourceLineNo">4458</span> * <p>Inserts the specified element at the specified position in the array.<a name="line.4458"></a>
-<span class="sourceLineNo">4459</span> * Shifts the element currently at that position (if any) and any subsequent<a name="line.4459"></a>
-<span class="sourceLineNo">4460</span> * elements to the right (adds one to their indices).</p><a name="line.4460"></a>
-<span class="sourceLineNo">4461</span> *<a name="line.4461"></a>
-<span class="sourceLineNo">4462</span> * <p>This method returns a new array with the same elements of the input<a name="line.4462"></a>
-<span class="sourceLineNo">4463</span> * array plus the given element on the specified position. The component<a name="line.4463"></a>
-<span class="sourceLineNo">4464</span> * type of the returned array is always the same as that of the input<a name="line.4464"></a>
-<span class="sourceLineNo">4465</span> * array.</p><a name="line.4465"></a>
-<span class="sourceLineNo">4466</span> *<a name="line.4466"></a>
-<span class="sourceLineNo">4467</span> * <p>If the input array is {@code null}, a new one element array is returned<a name="line.4467"></a>
-<span class="sourceLineNo">4468</span> * whose component type is the same as the element.</p><a name="line.4468"></a>
-<span class="sourceLineNo">4469</span> *<a name="line.4469"></a>
-<span class="sourceLineNo">4470</span> * <pre><a name="line.4470"></a>
-<span class="sourceLineNo">4471</span> * ArrayUtils.add([1L], 0, 2L) = [2L, 1L]<a name="line.4471"></a>
-<span class="sourceLineNo">4472</span> * ArrayUtils.add([2L, 6L], 2, 10L) = [2L, 6L, 10L]<a name="line.4472"></a>
-<span class="sourceLineNo">4473</span> * ArrayUtils.add([2L, 6L], 0, -4L) = [-4L, 2L, 6L]<a name="line.4473"></a>
-<span class="sourceLineNo">4474</span> * ArrayUtils.add([2L, 6L, 3L], 2, 1L) = [2L, 6L, 1L, 3L]<a name="line.4474"></a>
-<span class="sourceLineNo">4475</span> * </pre><a name="line.4475"></a>
-<span class="sourceLineNo">4476</span> *<a name="line.4476"></a>
-<span class="sourceLineNo">4477</span> * @param array the array to add the element to, may be {@code null}<a name="line.4477"></a>
-<span class="sourceLineNo">4478</span> * @param index the position of the new object<a name="line.4478"></a>
-<span class="sourceLineNo">4479</span> * @param element the object to add<a name="line.4479"></a>
-<span class="sourceLineNo">4480</span> * @return A new array containing the existing elements and the new element<a name="line.4480"></a>
-<span class="sourceLineNo">4481</span> * @throws IndexOutOfBoundsException if the index is out of range<a name="line.4481"></a>
-<span class="sourceLineNo">4482</span> * (index < 0 || index > array.length).<a name="line.4482"></a>
-<span class="sourceLineNo">4483</span> */<a name="line.4483"></a>
-<span class="sourceLineNo">4484</span> public static long[] add(final long[] array, final int index, final long element) {<a name="line.4484"></a>
-<span class="sourceLineNo">4485</span> return (long[]) add(array, index, Long.valueOf(element), Long.TYPE);<a name="line.4485"></a>
-<span class="sourceLineNo">4486</span> }<a name="line.4486"></a>
-<span class="sourceLineNo">4487</span><a name="line.4487"></a>
-<span class="sourceLineNo">4488</span> /**<a name="line.4488"></a>
-<span class="sourceLineNo">4489</span> * <p>Inserts the specified element at the specified position in the array.<a name="line.4489"></a>
-<span class="sourceLineNo">4490</span> * Shifts the element currently at that position (if any) and any subsequent<a name="line.4490"></a>
-<span class="sourceLineNo">4491</span> * elements to the right (adds one to their indices).</p><a name="line.4491"></a>
-<span class="sourceLineNo">4492</span> *<a name="line.4492"></a>
-<span class="sourceLineNo">4493</span> * <p>This method returns a new array with the same elements of the input<a name="line.4493"></a>
-<span class="sourceLineNo">4494</span> * array plus the given element on the specified position. The component<a name="line.4494"></a>
-<span class="sourceLineNo">4495</span> * type of the returned array is always the same as that of the input<a name="line.4495"></a>
-<span class="sourceLineNo">4496</span> * array.</p><a name="line.4496"></a>
-<span class="sourceLineNo">4497</span> *<a name="line.4497"></a>
-<span class="sourceLineNo">4498</span> * <p>If the input array is {@code null}, a new one element array is returned<a name="line.4498"></a>
-<span class="sourceLineNo">4499</span> * whose component type is the same as the element.</p><a name="line.4499"></a>
-<span class="sourceLineNo">4500</span> *<a name="line.4500"></a>
-<span class="sourceLineNo">4501</span> * <pre><a name="line.4501"></a>
-<span class="sourceLineNo">4502</span> * ArrayUtils.add([1.1f], 0, 2.2f) = [2.2f, 1.1f]<a name="line.4502"></a>
-<span class="sourceLineNo">4503</span> * ArrayUtils.add([2.3f, 6.4f], 2, 10.5f) = [2.3f, 6.4f, 10.5f]<a name="line.4503"></a>
-<span class="sourceLineNo">4504</span> * ArrayUtils.add([2.6f, 6.7f], 0, -4.8f) = [-4.8f, 2.6f, 6.7f]<a name="line.4504"></a>
-<span class="sourceLineNo">4505</span> * ArrayUtils.add([2.9f, 6.0f, 0.3f], 2, 1.0f) = [2.9f, 6.0f, 1.0f, 0.3f]<a name="line.4505"></a>
-<span class="sourceLineNo">4506</span> * </pre><a name="line.4506"></a>
-<span class="sourceLineNo">4507</span> *<a name="line.4507"></a>
-<span class="sourceLineNo">4508</span> * @param array the array to add the element to, may be {@code null}<a name="line.4508"></a>
-<span class="sourceLineNo">4509</span> * @param index the position of the new object<a name="line.4509"></a>
-<span class="sourceLineNo">4510</span> * @param element the object to add<a name="line.4510"></a>
-<span class="sourceLineNo">4511</span> * @return A new array containing the existing elements and the new element<a name="line.4511"></a>
-<span class="sourceLineNo">4512</span> * @throws IndexOutOfBoundsException if the index is out of range<a name="line.4512"></a>
-<span class="sourceLineNo">4513</span> * (index < 0 || index > array.length).<a name="line.4513"></a>
-<span class="sourceLineNo">4514</span> */<a name="line.4514"></a>
-<span class="sourceLineNo">4515</span> public static float[] add(final float[] array, final int index, final float element) {<a name="line.4515"></a>
-<span class="sourceLineNo">4516</span> return (float[]) add(array, index, Float.valueOf(element), Float.TYPE);<a name="line.4516"></a>
-<span class="sourceLineNo">4517</span> }<a name="line.4517"></a>
-<span class="sourceLineNo">4518</span><a name="line.4518"></a>
-<span class="sourceLineNo">4519</span> /**<a name="line.4519"></a>
-<span class="sourceLineNo">4520</span> * <p>Inserts the specified element at the specified position in the array.<a name="line.4520"></a>
-<span class="sourceLineNo">4521</span> * Shifts the element currently at that position (if any) and any subsequent<a name="line.4521"></a>
-<span class="sourceLineNo">4522</span> * elements to the right (adds one to their indices).</p><a name="line.4522"></a>
-<span class="sourceLineNo">4523</span> *<a name="line.4523"></a>
-<span class="sourceLineNo">4524</span> * <p>This method returns a new array with the same elements of the input<a name="line.4524"></a>
-<span class="sourceLineNo">4525</span> * array plus the given element on the specified position. The component<a name="line.4525"></a>
-<span class="sourceLineNo">4526</span> * type of the returned array is always the same as that of the input<a name="line.4526"></a>
-<span class="sourceLineNo">4527</span> * array.</p><a name="line.4527"></a>
-<span class="sourceLineNo">4528</span> *<a name="line.4528"></a>
-<span class="sourceLineNo">4529</span> * <p>If the input array is {@code null}, a new one element array is returned<a name="line.4529"></a>
-<span class="sourceLineNo">4530</span> * whose component type is the same as the element.</p><a name="line.4530"></a>
-<span class="sourceLineNo">4531</span> *<a name="line.4531"></a>
-<span class="sourceLineNo">4532</span> * <pre><a name="line.4532"></a>
-<span class="sourceLineNo">4533</span> * ArrayUtils.add([1.1], 0, 2.2) = [2.2, 1.1]<a name="line.4533"></a>
-<span class="sourceLineNo">4534</span> * ArrayUtils.add([2.3, 6.4], 2, 10.5) = [2.3, 6.4, 10.5]<a name="line.4534"></a>
-<span class="sourceLineNo">4535</span> * ArrayUtils.add([2.6, 6.7], 0, -4.8) = [-4.8, 2.6, 6.7]<a name="line.4535"></a>
-<span class="sourceLineNo">4536</span> * ArrayUtils.add([2.9, 6.0, 0.3], 2, 1.0) = [2.9, 6.0, 1.0, 0.3]<a name="line.4536"></a>
-<span class="sourceLineNo">4537</span> * </pre><a name="line.4537"></a>
-<span class="sourceLineNo">4538</span> *<a name="line.4538"></a>
-<span class="sourceLineNo">4539</span> * @param array the array to add the element to, may be {@code null}<a name="line.4539"></a>
-<span class="sourceLineNo">4540</span> * @param index the position of the new object<a name="line.4540"></a>
-<span class="sourceLineNo">4541</span> * @param element the object to add<a name="line.4541"></a>
-<span class="sourceLineNo">4542</span> * @return A new array containing the existing elements and the new element<a name="line.4542"></a>
-<span class="sourceLineNo">4543</span> * @throws IndexOutOfBoundsException if the index is out of range<a name="line.4543"></a>
-<span class="sourceLineNo">4544</span> * (index < 0 || index > array.length).<a name="line.4544"></a>
-<span class="sourceLineNo">4545</span> */<a name="line.4545"></a>
-<span class="sourceLineNo">4546</span> public static double[] add(final double[] array, final int index, final double element) {<a name="line.4546"></a>
-<span class="sourceLineNo">4547</span> return (double[]) add(array, index, Double.valueOf(element), Double.TYPE);<a name="line.4547"></a>
-<span class="sourceLineNo">4548</span> }<a name="line.4548"></a>
-<span class="sourceLineNo">4549</span><a name="line.4549"></a>
-<span class="sourceLineNo">4550</span> /**<a name="line.4550"></a>
-<span class="sourceLineNo">4551</span> * Underlying implementation of add(array, index, element) methods.<a name="line.4551"></a>
-<span class="sourceLineNo">4552</span> * The last parameter is the class, which may not equal element.getClass<a name="line.4552"></a>
-<span class="sourceLineNo">4553</span> * for primitives.<a name="line.4553"></a>
-<span class="sourceLineNo">4554</span> *<a name="line.4554"></a>
-<span class="sourceLineNo">4555</span> * @param array the array to add the element to, may be {@code null}<a name="line.4555"></a>
-<span class="sourceLineNo">4556</span> * @param index the position of the new object<a name="line.4556"></a>
-<span class="sourceLineNo">4557</span> * @param element the object to add<a name="line.4557"></a>
-<span class="sourceLineNo">4558</span> * @param clss the type of the element being added<a name="line.4558"></a>
-<span class="sourceLineNo">4559</span> * @return A new array containing the existing elements and the new element<a name="line.4559"></a>
-<span class="sourceLineNo">4560</span> */<a name="line.4560"></a>
-<span class="sourceLineNo">4561</span> private static Object add(final Object array, final int index, final Object element, final Class<?> clss) {<a name="line.4561"></a>
-<span class="sourceLineNo">4562</span> if (array == null) {<a name="line.4562"></a>
-<span class="sourceLineNo">4563</span> if (index != 0) {<a name="line.4563"></a>
-<span class="sourceLineNo">4564</span> throw new IndexOutOfBoundsException("Index: " + index + ", Length: 0");<a name="line.4564"></a>
-<span class="sourceLineNo">4565</span> }<a name="line.4565"></a>
-<span class="sourceLineNo">4566</span> final Object joinedArray = Array.newInstance(clss, 1);<a name="line.4566"></a>
-<span class="sourceLineNo">4567</span> Array.set(joinedArray, 0, element);<a name="line.4567"></a>
-<span class="sourceLineNo">4568</span> return joinedArray;<a name="line.4568"></a>
-<span class="sourceLineNo">4569</span> }<a name="line.4569"></a>
-<span class="sourceLineNo">4570</span> final int length = Array.getLength(array);<a name="line.4570"></a>
-<span class="sourceLineNo">4571</span> if (index > length || index < 0) {<a name="line.4571"></a>
-<span class="sourceLineNo">4572</span> throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length);<a name="line.4572"></a>
-<span class="sourceLineNo">4573</span> }<a name="line.4573"></a>
-<span class="sourceLineNo">4574</span> final Object result = Array.newInstance(clss, length + 1);<a name="line.4574"></a>
-<span class="sourceLineNo">4575</span> System.arraycopy(array, 0, result, 0, index);<a name="line.4575"></a>
-<span class="sourceLineNo">4576</span> Array.set(result, index, element);<a name="line.4576"></a>
-<span class="sourceLineNo">4577</span> if (index < length) {<a name="line.4577"></a>
-<span class="sourceLineNo">4578</span> System.arraycopy(array, index, result, index + 1, length - index);<a name="line.4578"></a>
-<span class="sourceLineNo">4579</span> }<a name="line.4579"></a>
-<span class="sourceLineNo">4580</span> return result;<a name="line.4580"></a>
-<span class="sourceLineNo">4581</span> }<a name="line.4581"></a>
-<span class="sourceLineNo">4582</span><a name="line.4582"></a>
-<span class="sourceLineNo">4583</span> /**<a name="line.4583"></a>
-<span class="sourceLineNo">4584</span> * <p>Removes the element at the specified position from the specified array.<a name="line.4584"></a>
-<span class="sourceLineNo">4585</span> * All subsequent elements are shifted to the left (subtracts one from<a name="line.4585"></a>
-<span class="sourceLineNo">4586</span> * their indices).</p><a name="line.4586"></a>
-<span class="sourceLineNo">4587</span> *<a name="line.4587"></a>
-<span class="sourceLineNo">4588</span> * <p>This method returns a new array with the same elements of the input<a name="line.4588"></a>
-<span class="sourceLineNo">4589</span> * array except the element on the specified position. The component<a name="line.4589"></a>
-<span class="sourceLineNo">4590</span> * type of the returned array is always the same as that of the input<a name="line.4590"></a>
-<span class="sourceLineNo">4591</span> * array.</p><a name="line.4591"></a>
-<span class="sourceLineNo">4592</span> *<a name="line.4592"></a>
-<span class="sourceLineNo">4593</span> * <p>If the input array is {@code null}, an IndexOutOfBoundsException<a name="line.4593"></a>
-<span class="sourceLineNo">4594</span> * will be thrown, because in that case no valid index can be specified.</p><a name="line.4594"></a>
-<span class="sourceLineNo">4595</span> *<a name="line.4595"></a>
-<span class="sourceLineNo">4596</span> * <pre><a name="line.4596"></a>
-<span class="sourceLineNo">4597</span> * ArrayUtils.remove(["a"], 0) = []<a name="line.4597"></a>
-<span class="sourceLineNo">4598</span> * ArrayUtils.remove(["a", "b"], 0) = ["b"]<a name="line.4598"></a>
-<span class="sourceLineNo">4599</span> * ArrayUtils.remove(["a", "b"], 1) = ["a"]<a name="line.4599"></a>
-<span class="sourceLineNo">4600</span> * ArrayUtils.remove(["a", "b", "c"], 1) = ["a", "c"]<a name="line.4600"></a>
-<span class="sourceLineNo">4601</span> * </pre><a name="line.4601"></a>
-<span class="sourceLineNo">4602</span> *<a name="line.4602"></a>
-<span class="sourceLineNo">4603</span> * @param <T> the component type of the array<a name="line.4603"></a>
-<span class="sourceLineNo">4604</span> * @param array the array to remove the element from, may not be {@code null}<a name="line.4604"></a>
-<span class="sourceLineNo">4605</span> * @param index the position of the element to be removed<a name="line.4605"></a>
-<span class="sourceLineNo">4606</span> * @return A new array containing the existing elements except the element<a name="line.4606"></a>
-<span class="sourceLineNo">4607</span> * at the specified position.<a name="line.4607"></a>
-<span class="sourceLineNo">4608</span> * @throws IndexOutOfBoundsException if the index is out of range<a name="line.4608"></a>
-<span class="sourceLineNo">4609</span> * (index < 0 || index >= array.length), or if the array is {@code null}.<a name="line.4609"></a>
-<span class="sourceLineNo">4610</span> * @since 2.1<a name="line.4610"></a>
-<span class="sourceLineNo">4611</span> */<a name="line.4611"></a>
-<span class="sourceLineNo">4612</span> @SuppressWarnings("unchecked") // remove() always creates an array of the same type as its input<a name="line.4612"></a>
-<span class="sourceLineNo">4613</span> public static <T> T[] remove(final T[] array, final int index) {<a name="line.4613"></a>
-<span class="sourceLineNo">4614</span> return (T[]) remove((Object) array, index);<a name="line.4614"></a>
-<span class="sourceLineNo">4615</span> }<a name="line.4615"></a>
-<span class="sourceLineNo">4616</span><a name="line.4616"></a>
-<span class="sourceLineNo">4617</span> /**<a name="line.4617"></a>
-<span class="sourceLineNo">4618</span> * <p>Removes the first occurrence of the specified element from the<a name="line.4618"></a>
-<span class="sourceLineNo">4619</span> * specified array. All subsequent elements are shifted to the left<a name="line.4619"></a>
-<span class="sourceLineNo">4620</span> * (subtracts one from their indices). If the array doesn't contains<a name="line.4620"></a>
-<span class="sourceLineNo">4621</span> * such an element, no elements are removed from the array.</p><a name="line.4621"></a>
-<span class="sourceLineNo">4622</span> *<a name="line.4622"></a>
-<span class="sourceLineNo">4623</span> * <p>This method returns a new array with the same elements of the input<a name="line.4623"></a>
-<span class="sourceLineNo">4624</span> * array except the first occurrence of the specified element. The component<a name="line.4624"></a>
-<span class="sourceLineNo">4625</span> * type of the returned array is always the same as that of the input<a name="line.4625"></a>
-<span class="sourceLineNo">4626</span> * array.</p><a name="line.4626"></a>
-<span class="sourceLineNo">4627</span> *<a name="line.4627"></a>
-<span class="sourceLineNo">4628</span> * <pre><a name="line.4628"></a>
-<span class="sourceLineNo">4629</span> * ArrayUtils.removeElement(null, "a") = null<a name="line.4629"></a>
-<span class="sourceLineNo">4630</span> * ArrayUtils.removeElement([], "a") = []<a name="line.4630"></a>
-<span class="sourceLineNo">4631</span> * ArrayUtils.removeElement(["a"], "b") = ["a"]<a name="line.4631"></a>
-<span class="sourceLineNo">4632</span> * ArrayUtils.removeElement(["a", "b"], "a") = ["b"]<a name="line.4632"></a>
-<span class="sourceLineNo">4633</span> * ArrayUtils.removeElement(["a", "b", "a"], "a") = ["b", "a"]<a name="line.4633"></a>
-<span class="sourceLineNo">4634</span> * </pre><a name="line.4634"></a>
-<span class="sourceLineNo">4635</span> *<a name="line.4635"></a>
-<span class="sourceLineNo">4636</span> * @param <T> the component type of the array<a name="line.4636"></a>
-<span class="sourceLineNo">4637</span> * @param array the array to remove the element from, may be {@code null}<a name="line.4637"></a>
-<span class="sourceLineNo">4638</span> * @param element the element to be removed<a name="line.4638"></a>
-<span class="sourceLineNo">4639</span> * @return A new array containing the existing elements except the first<a name="line.4639"></a>
-<span class="sourceLineNo">4640</span> * occurrence of the specified element.<a name="line.4640"></a>
-<span class="sourceLineNo">4641</span> * @since 2.1<a name="line.4641"></a>
-<span class="sourceLineNo">4642</span> */<a name="line.4642"></a>
-<span class="sourceLineNo">4643</span> public static <T> T[] removeElement(final T[] array, final Object element) {<a name="line.4643"></a>
-<span class="sourceLineNo">4644</span> final int index = indexOf(array, element);<a name="line.4644"></a>
-<span class="sourceLineNo">4645</span> if (index == INDEX_NOT_FOUND) {<a name="line.4645"></a>
-<span class="sourceLineNo">4646</span> return clone(array);<a name="line.4646"></a>
-<span class="sourceLineNo">4647</span> }<a name="line.4647"></a>
-<span class="sourceLineNo">4648</span> return remove(array, index);<a name="line.4648"></a>
-<span class="sourceLineNo">4649</span> }<a name="line.4649"></a>
-<span class="sourceLineNo">4650</span><a name="line.4650"></a>
-<span class="sourceLineNo">4651</span> /**<a name="line.4651"></a>
-<span class="sourceLineNo">4652</span> * <p>Removes the element at the specified position from the specified array.<a name="line.4652"></a>
-<span class="sourceLineNo">4653</span> * All subsequent elements are shifted to the left (subtracts one from<a name="line.4653"></a>
-<span class="sourceLineNo">4654</span> * their indices).</p><a name="line.4654"></a>
-<span class="sourceLineNo">4655</span> *<a name="line.4655"></a>
-<span class="sourceLineNo">4656</span> * <p>This method returns a new array with the same elements of the input<a name="line.4656"></a>
-<span class="sourceLineNo">4657</span> * array except the element on the specified position. The component<a name="line.4657"></a>
-<span class="sourceLineNo">4658</span> * type of the returned array is always the same as that of the input<a name="line.4658"></a>
-<span class="sourceLineNo">4659</span> * array.</p><a name="line.4659"></a>
-<span class="sourceLineNo">4660</span> *<a name="line.4660"></a>
-<span class="sourceLineNo">4661</span> * <p>If the input array is {@code null}, an IndexOutOfBoundsException<a name="line.4661"></a>
-<span class="sourceLineNo">4662</span> * will be thrown, because in that case no valid index can be specified.</p><a name="line.4662"></a>
-<span class="sourceLineNo">4663</span> *<a name="line.4663"></a>
-<span class="sourceLineNo">4664</span> * <pre><a name="line.4664"></a>
-<span class="sourceLineNo">4665</span> * ArrayUtils.remove([true], 0) = []<a name="line.4665"></a>
-<span class="sourceLineNo">4666</span> * ArrayUtils.remove([true, false], 0) = [false]<a name="line.4666"></a>
-<span class="sourceLineNo">4667</span> * ArrayUtils.remove([true, false], 1) = [true]<a name="line.4667"></a>
-<span class="sourceLineNo">4668</span> * ArrayUtils.remove([true, true, false], 1) = [true, false]<a name="line.4668"></a>
-<span class="sourceLineNo">4669</span> * </pre><a name="line.4669"></a>
-<span class="sourceLineNo">4670</span> *<a name="line.4670"></a>
-<span class="sourceLineNo">4671</span> * @param array the array to remove the element from, may not be {@code null}<a name="line.4671"></a>
-<span class="sourceLineNo">4672</span> * @param index the position of the element to be removed<a name="line.4672"></a>
-<span class="sourceLineNo">4673</span> * @return A new array containing the existing elements except the element<a name="line.4673"></a>
-<span class="sourceLineNo">4674</span> * at the specified position.<a name="line.4674"></a>
-<span class="sourceLineNo">4675</span> * @throws IndexOutOfBoundsException if the index is out of range<a name="line.4675"></a>
-<span class="sourceLineNo">4676</span> * (index < 0 || index >= array.length), or if the array is {@code null}.<a name="line.4676"></a>
-<span class="sourceLineNo">4677</span> * @since 2.1<a name="line.4677"></a>
-<span class="sourceLineNo">4678</span> */<a name="line.4678"></a>
-<span class="sourceLineNo">4679</span> public static boolean[] remove(final boolean[] array, final int index) {<a name="line.4679"></a>
-<span class="sourceLineNo">4680</span> return (boolean[]) remove((Object) array, index);<a name="line.4680"></a>
-<span class="sourceLineNo">4681</span> }<a name="line.4681"></a>
-<span class="sourceLineNo">4682</span><a name="line.4682"></a>
-<span class="sourceLineNo">4683</span> /**<a name="line.4683"></a>
-<span class="sourceLineNo">4684</span> * <p>Removes the first occurrence of the specified element from the<a name="line.4684"></a>
-<span class="sourceLineNo">4685</span> * specified array. All subsequent elements are shifted to the left<a name="line.4685"></a>
-<span class="sourceLineNo">4686</span> * (subtracts one from their indices). If the array doesn't contains<a name="line.4686"></a>
-<span class="sourceLineNo">4687</span> * such an element, no elements are removed from the array.</p><a name="line.4687"></a>
-<span class="sourceLineNo">4688</span> *<a name="line.4688"></a>
-<span class="sourceLineNo">4689</span> * <p>This method returns a new array with the same elements of the input<a name="line.4689"></a>
-<span class="sourceLineNo">4690</span> * array except the first occurrence of the specified element. The component<a name="line.4690"></a>
-<span class="sourceLineNo">4691</span> * type of the returned array is always the same as that of the input<a name="line.4691"></a>
-<span class="sourceLineNo">4692</span> * array.</p><a name="line.4692"></a>
-<span class="sourceLineNo">4693</span> *<a name="line.4693"></a>
-<span class="sourceLineNo">4694</span> * <pre><a name="line.4694"></a>
-<span class="sourceLineNo">4695</span> * ArrayUtils.removeElement(null, true) = null<a name="line.4695"></a>
-<span class="sourceLineNo">4696</span> * ArrayUtils.removeElement([], true) = []<a name="line.4696"></a>
-<span class="sourceLineNo">4697</span> * ArrayUtils.removeElement([true], false) = [true]<a name="line.4697"></a>
-<span class="sourceLineNo">4698</span> * ArrayUtils.removeElement([true, false], false) = [true]<a name="line.4698"></a>
-<span class="sourceLineNo">4699</span> * ArrayUtils.removeElement([true, false, true], true) = [false, true]<a name="line.4699"></a>
-<span class="sourceLineNo">4700</span> * </pre><a name="line.4700"></a>
-<span class="sourceLineNo">4701</span> *<a name="line.4701"></a>
-<span class="sourceLineNo">4702</span> * @param array the array to remove the element from, may be {@code null}<a name="line.4702"></a>
-<span class="sourceLineNo">4703</span> * @param element the element to be removed<a name="line.4703"></a>
-<span class="sourceLineNo">4704</span> * @return A new array containing the existing elements except the first<a name="line.4704"></a>
-<span class="sourceLineNo">4705</span> * occurrence of the specified element.<a name="line.4705"></a>
-<span class="sourceLineNo">4706</span> * @since 2.1<a name="line.4706"></a>
-<span class="sourceLineNo">4707</span> */<a name="line.4707"></a>
-<span class="sourceLineNo">4708</span> public static boolean[] removeElement(final boolean[] array, final boolean element) {<a name="line.4708"></a>
-<span class="sourceLineNo">4709</span> final int index = indexOf(array, element);<a name="line.4709"></a>
-<span class="sourceLineNo">4710</span> if (index == INDEX_NOT_FOUND) {<a name="line.4710"></a>
-<span class="sourceLineNo">4711</span> return clone(array);<a name="line.4711"></a>
-<span class="sourceLineNo">4712</span> }<a name="line.4712"></a>
-<span class="sourceLineNo">4713</span> return remove(array, index);<a name="line.4713"></a>
-<span class="sourceLineNo">4714</span> }<a name="line.4714"></a>
-<span class="sourceLineNo">4715</span><a name="line.4715"></a>
-<span class="sourceLineNo">4716</span> /**<a name="line.4716"></a>
-<span class="sourceLineNo">4717</span> * <p>Removes the element at the specified position from the specified array.<a name="line.4717"></a>
-<span class="sourceLineNo">4718</span> * All subsequent elements are shifted to the left (subtracts one from<a name="line.4718"></a>
-<span class="sourceLineNo">4719</span> * their indices).</p><a name="line.4719"></a>
-<span class="sourceLineNo">4720</span> *<a name="line.4720"></a>
-<span class="sourceLineNo">4721</span> * <p>This method returns a new array with the same elements of the input<a name="line.4721"></a>
-<span class="sourceLineNo">4722</span> * array except the element on the specified position. The component<a name="line.4722"></a>
-<span class="sourceLineNo">4723</span> * type of the returned array is always the same as that of the input<a name="line.4723"></a>
-<span class="sourceLineNo">4724</span> * array.</p><a name="line.4724"></a>
-<span class="sourceLineNo">4725</span> *<a name="line.4725"></a>
-<span class="sourceLineNo">4726</span> * <p>If the input array is {@code null}, an IndexOutOfBoundsException<a name="line.4726"></a>
-<span class="sourceLineNo">4727</span> * will be thrown, because in that case no valid index can be specified.</p><a name="line.4727"></a>
-<span class="sourceLineNo">4728</span> *<a name="line.4728"></a>
-<span class="sourceLineNo">4729</span> * <pre><a name="line.4729"></a>
-<span class="sourceLineNo">4730</span> * ArrayUtils.remove([1], 0) = []<a name="line.4730"></a>
-<span class="sourceLineNo">4731</span> * ArrayUtils.remove([1, 0], 0) = [0]<a name="line.4731"></a>
-<span class="sourceLineNo">4732</span> * ArrayUtils.remove([1, 0], 1) = [1]<a name="line.4732"></a>
-<span class="sourceLineNo">4733</span> * ArrayUtils.remove([1, 0, 1], 1) = [1, 1]<a name="line.4733"></a>
-<span class="sourceLineNo">4734</span> * </pre><a name="line.4734"></a>
-<span class="sourceLineNo">4735</span> *<a name="line.4735"></a>
-<span class="sourceLineNo">4736</span> * @param array the array to remove the element from, may not be {@code null}<a name="line.4736"></a>
-<span class="sourceLineNo">4737</span> * @param index the position of the element to be removed<a name="line.4737"></a>
-<span class="sourceLineNo">4738</span> * @return A new array containing the existing elements except the element<a name="line.4738"></a>
-<span class="sourceLineNo">4739</span> * at the specified position.<a name="line.4739"></a>
-<span class="sourceLineNo">4740</span> * @throws IndexOutOfBoundsException if the index is out of range<a name="line.4740"></a>
-<span class="sourceLineNo">4741</span> * (index < 0 || index >= array.length), or if the array is {@code null}.<a name="line.4741"></a>
-<span class="sourceLineNo">4742</span> * @since 2.1<a name="line.4742"></a>
-<span class="sourceLineNo">4743</span> */<a name="line.4743"></a>
-<span class="sourceLineNo">4744</span> public static byte[] remove(final byte[] array, final int index) {<a name="line.4744"></a>
-<span class="sourceLineNo">4745</span> return (byte[]) remove((Object) array, index);<a name="line.4745"></a>
-<span class="sourceLineNo">4746</span> }<a name="line.4746"></a>
-<span class="sourceLineNo">4747</span><a name="line.4747"></a>
-<span class="sourceLineNo">4748</span> /**<a name="line.4748"></a>
-<span class="sourceLineNo">4749</span> * <p>Removes the first occurrence of the specified element from the<a name="line.4749"></a>
-<span class="sourceLineNo">4750</span> * specified array. All subsequent elements are shifted to the left<a name="line.4750"></a>
-<span class="sourceLineNo">4751</span> * (subtracts one from their indices). If the array doesn't contains<a name="line.4751"></a>
-<span class="sourceLineNo">4752</span> * such an element, no elements are removed from the array.</p><a name="line.4752"></a>
-<span class="sourceLineNo">4753</span> *<a name="line.4753"></a>
-<span class="sourceLineNo">4754</span> * <p>This method returns a new array with the same elements of the input<a name="line.4754"></a>
-<span class="sourceLineNo">4755</span> * array except the first occurrence of the specified element. The component<a name="line.4755"></a>
-<span class="sourceLineNo">4756</span> * type of the returned array is always the same as that of the input<a name="line.4756"></a>
-<span class="sourceLineNo">4757</span> * array.</p><a name="line.4757"></a>
-<span class="sourceLineNo">4758</span> *<a name="line.4758"></a>
-<span class="sourceLineNo">4759</span> * <pre><a name="line.4759"></a>
-<span class="sourceLineNo">4760</span> * ArrayUtils.removeElement(null, 1) = null<a name="line.4760"></a>
-<span class="sourceLineNo">4761</span> * ArrayUtils.removeElement([], 1) = []<a name="line.4761"></a>
-<span class="sourceLineNo">4762</span> * ArrayUtils.removeElement([1], 0) = [1]<a name="line.4762"></a>
-<span class="sourceLineNo">4763</span> * ArrayUtils.removeElement([1, 0], 0) = [1]<a name="line.4763"></a>
-<span class="sourceLineNo">4764</span> * ArrayUtils.removeElement([1, 0, 1], 1) = [0, 1]<a name="line.4764"></a>
-<span class="sourceLineNo">4765</span> * </pre><a name="line.4765"></a>
-<span class="sourceLineNo">4766</span> *<a name="line.4766"></a>
-<span class="sourceLineNo">4767</span> * @param array the array to remove the element from, may be {@code null}<a name="line.4767"></a>
-<span class="sourceLineNo">4768</span> * @param element the element to be removed<a name="line.4768"></a>
-<span class="sourceLineNo">4769</span> * @return A new array containing the existing elements except the first<a name="line.4769"></a>
-<span class="sourceLineNo">4770</span> * occurrence of the specified element.<a name="line.4770"></a>
-<span class="sourceLineNo">4771</span> * @since 2.1<a name="line.4771"></a>
-<span class="sourceLineNo">4772</span> */<a name="line.4772"></a>
-<span class="sourceLineNo">4773</span> public static byte[] removeElement(final byte[] array, final byte element) {<a name="line.4773"></a>
-<span class="sourceLineNo">4774</span> final int index = indexOf(array, element);<a name="line.4774"></a>
-<span class="sourceLineNo">4775</span> if (index == INDEX_NOT_FOUND) {<a name="line.4775"></a>
-<span class="sourceLineNo">4776</span> return clone(array);<a name="line.4776"></a>
-<span class="sourceLineNo">4777</span> }<a name="line.4777"></a>
-<span class="sourceLineNo">4778</span> return remove(array, index);<a name="line.4778"></a>
-<span class="sourceLineNo">4779</span> }<a name="line.4779"></a>
-<span class="sourceLineNo">4780</span><a name="line.4780"></a>
-<span class="sourceLineNo">4781</span> /**<a name="line.4781"></a>
-<span class="sourceLineNo">4782</span> * <p>Removes the element at the specified position from the specified array.<a name="line.4782"></a>
-<span class="sourceLineNo">4783</span> * All subsequent elements are shifted to the left (subtracts one from<a name="line.4783"></a>
-<span class="sourceLineNo">4784</span> * their indices).</p><a name="line.4784"></a>
-<span class="sourceLineNo">4785</span> *<a name="line.4785"></a>
-<span class="sourceLineNo">4786</span> * <p>This method returns a new array with the same elements of the input<a name="line.4786"></a>
-<span class="sourceLineNo">4787</span> * array except the element on the specified position. The component<a name="line.4787"></a>
-<span class="sourceLineNo">4788</span> * type of the returned array is always the same as that of the input<a name="line.4788"></a>
-<span class="sourceLineNo">4789</span> * array.</p><a name="line.4789"></a>
-<span class="sourceLineNo">4790</span> *<a name="line.4790"></a>
-<span class="sourceLineNo">4791</span> * <p>If the input array is {@code null}, an IndexOutOfBoundsException<a name="line.4791"></a>
-<span class="sourceLineNo">4792</span> * will be thrown, because in that case no valid index can be specified.</p><a name="line.4792"></a>
-<span class="sourceLineNo">4793</span> *<a name="line.4793"></a>
-<span class="sourceLineNo">4794</span> * <pre><a name="line.4794"></a>
-<span class="sourceLineNo">4795</span> * ArrayUtils.remove(['a'], 0) = []<a name="line.4795"></a>
-<span class="sourceLineNo">4796</span> * ArrayUtils.remove(['a', 'b'], 0) = ['b']<a name="line.4796"></a>
-<span class="sourceLineNo">4797</span> * ArrayUtils.remove(['a', 'b'], 1) = ['a']<a name="line.4797"></a>
-<span class="sourceLineNo">4798</span> * ArrayUtils.remove(['a', 'b', 'c'], 1) = ['a', 'c']<a name="line.4798"></a>
-<span class="sourceLineNo">4799</span> * </pre><a name="line.4799"></a>
-<span class="sourceLineNo">4800</span> *<a name="line.4800"></a>
-<span class="sourceLineNo">4801</span> * @param array the array to remove the element from, may not be {@code null}<a name="line.4801"></a>
-<span class="sourceLineNo">4802</span> * @param index the position of the element to be removed<a name="line.4802"></a>
-<span class="sourceLineNo">4803</span> * @return A new array containing the existing elements except the element<a name="line.4803"></a>
-<span class="sourceLineNo">4804</span> * at the specified position.<a name="line.4804"></a>
-<span class="sourceLineNo">4805</span> * @throws IndexOutOfBoundsException if the index is out of range<a name="line.4805"></a>
-<span class="sourceLineNo">4806</span> * (index < 0 || index >= array.length), or if the array is {@code null}.<a name="line.4806"></a>
-<span class="sourceLineNo">4807</span> * @since 2.1<a name="line.4807"></a>
-<span class="sourceLineNo">4808</span> */<a name="line.4808"></a>
-<span class="sourceLineNo">4809</span> public static char[] remove(final char[] array, final int index) {<a name="line.4809"></a>
-<span class="sourceLineNo">4810</span> return (char[]) remove((Object) array, index);<a name="line.4810"></a>
-<span class="sourceLineNo">4811</span> }<a name="line.4811"></a>
-<span class="sourceLineNo">4812</span><a name="line.4812"></a>
-<span class="sourceLineNo">4813</span> /**<a name="line.4813"></a>
-<span class="sourceLineNo">4814</span> * <p>Removes the first occurrence of the specified element from the<a name="line.4814"></a>
-<span class="sourceLineNo">4815</span> * specified array. All subsequent elements are shifted to the left<a name="line.4815"></a>
-<span class="sourceLineNo">4816</span> * (subtracts one from their indices). If the array doesn't contains<a name="line.4816"></a>
-<span class="sourceLineNo">4817</span> * such an element, no elements are removed from the array.</p><a name="line.4817"></a>
-<span class="sourceLineNo">4818</span> *<a name="line.4818"></a>
-<span class="sourceLineNo">4819</span> * <p>This method returns a new array with the same elements of the input<a name="line.4819"></a>
-<span class="sourceLineNo">4820</span> * array except the first occurrence of the specified element. The component<a name="line.4820"></a>
-<span class="sourceLineNo">4821</span> * type of the returned array is always the same as that of the input<a name="line.4821"></a>
-<span class="sourceLineNo">4822</span> * array.</p><a name="line.4822"></a>
-<span class="sourceLineNo">4823</span> *<a name="line.4823"></a>
-<span class="sourceLineNo">4824</span> * <pre><a name="line.4824"></a>
-<span class="sourceLineNo">4825</span> * ArrayUtils.removeElement(null, 'a') = null<a name="line.4825"></a>
-<span class="sourceLineNo">4826</span> * ArrayUtils.removeElement([], 'a') = []<a name="line.4826"></a>
-<span class="sourceLineNo">4827</span> * ArrayUtils.removeElement(['a'], 'b') = ['a']<a name="line.4827"></a>
-<span class="sourceLineNo">4828</span> * ArrayUtils.removeElement(['a', 'b'], 'a') = ['b']<a name="line.4828"></a>
-<span class="sourceLineNo">4829</span> * ArrayUtils.removeElement(['a', 'b', 'a'], 'a') = ['b', 'a']<a name="line.4829"></a>
-<span class="sourceLineNo">4830</span> * </pre><a name="line.4830"></a>
-<span class="sourceLineNo">4831</span> *<a name="line.4831"></a>
-<span class="sourceLineNo">4832</span> * @param array the array to remove the element from, may be {@code null}<a name="line.4832"></a>
-<span class="sourceLineNo">4833</span> * @param element the element to be removed<a name="line.4833"></a>
-<span class="sourceLineNo">4834</span> * @return A new array containing the existing elements except the first<a name="line.4834"></a>
-<span class="sourceLineNo">4835</span> * occurrence of the specified element.<a name="line.4835"></a>
-<span class="sourceLineNo">4836</span> * @since 2.1<a name="line.4836"></a>
-<span class="sourceLineNo">4837</span> */<a name="line.4837"></a>
-<span class="sourceLineNo">4838</span> public static char[] removeElement(final char[] array, final char element) {<a name="line.4838"></a>
-<span class="sourceLineNo">4839</span> final int index = indexOf(array, element);<a name="line.4839"></a>
-<span class="sourceLineNo">4840</span> if (index == INDEX_NOT_FOUND) {<a name="line.4840"></a>
-<span class="sourceLineNo">4841</span> return clone(array);<a name="line.4841"></a>
-<span class="sourceLineNo">4842</span> }<a name="line.4842"></a>
-<span class="sourceLineNo">4843</span> return remove(array, index);<a name="line.4843"></a>
-<span class="sourceLineNo">4844</span> }<a name="line.4844"></a>
-<span class="sourceLineNo">4845</span><a name="line.4845"></a>
-<span class="sourceLineNo">4846</span> /**<a name="line.4846"></a>
-<span class="sourceLineNo">4847</span> * <p>Removes the element at the specified position from the specified array.<a name="line.4847"></a>
-<span class="sourceLineNo">4848</span> * All subsequent elements are shifted to the left (subtracts one from<a name="line.4848"></a>
-<span class="sourceLineNo">4849</span> * their indices).</p><a name="line.4849"></a>
-<span class="sourceLineNo">4850</span> *<a name="line.4850"></a>
-<span class="sourceLineNo">4851</span> * <p>This method returns a new array with the same elements of the input<a name="line.4851"></a>
-<span class="sourceLineNo">4852</span> * array except the element on the specified position. The component<a name="line.4852"></a>
-<span class="sourceLineNo">4853</span> * type of the returned array is always the same as that of the input<a name="line.4853"></a>
-<span class="sourceLineNo">4854</span> * array.</p><a name="line.4854"></a>
-<span class="sourceLineNo">4855</span> *<a name="line.4855"></a>
-<span class="sourceLineNo">4856</span> * <p>If the input array is {@code null}, an IndexOutOfBoundsException<a name="line.4856"></a>
-<span class="sourceLineNo">4857</span> * will be thrown, because in that case no valid index can be specified.</p><a name="line.4857"></a>
-<span class="sourceLineNo">4858</span> *<a name="line.4858"></a>
-<span class="sourceLineNo">4859</span> * <pre><a name="line.4859"></a>
-<span class="sourceLineNo">4860</span> * ArrayUtils.remove([1.1], 0) = []<a name="line.4860"></a>
-<span class="sourceLineNo">4861</span> * ArrayUtils.remove([2.5, 6.0], 0) = [6.0]<a name="line.4861"></a>
-<span class="sourceLineNo">4862</span> * ArrayUtils.remove([2.5, 6.0], 1) = [2.5]<a name="line.4862"></a>
-<span class="sourceLineNo">4863</span> * ArrayUtils.remove([2.5, 6.0, 3.8], 1) = [2.5, 3.8]<a name="line.4863"></a>
-<span class="sourceLineNo">4864</span> * </pre><a name="line.4864"></a>
-<span class="sourceLineNo">4865</span> *<a name="line.4865"></a>
-<span class="sourceLineNo">4866</span> * @param array the array to remove the element from, may not be {@code null}<a name="line.4866"></a>
-<span class="sourceLineNo">4867</span> * @param index the position of the element to be removed<a name="line.4867"></a>
-<span class="sourceLineNo">4868</span> * @return A new array containing the existing elements except the element<a name="line.4868"></a>
-<span class="sourceLineNo">4869</span> * at the specified position.<a name="line.4869"></a>
-<span class="sourceLineNo">4870</span> * @throws IndexOutOfBoundsException if the index is out of range<a name="line.4870"></a>
-<span class="sourceLineNo">4871</span> * (index < 0 || index >= array.length), or if the array is {@code null}.<a name="line.4871"></a>
-<span class="sourceLineNo">4872</span> * @since 2.1<a name="line.4872"></a>
-<span class="sourceLineNo">4873</span> */<a name="line.4873"></a>
-<span class="sourceLineNo">4874</span> public static double[] remove(final double[] array, final int index) {<a name="line.4874"></a>
-<span class="sourceLineNo">4875</span> return (double[]) remove((Object) array, index);<a name="line.4875"></a>
-<span class="sourceLineNo">4876</span> }<a name="line.4876"></a>
-<span class="sourceLineNo">4877</span><a name="line.4877"></a>
-<span class="sourceLineNo">4878</span> /**<a name="line.4878"></a>
-<span class="sourceLineNo">4879</span> * <p>Removes the first occurrence of the specified element from the<a name="line.4879"></a>
-<span class="sourceLineNo">4880</span> * specified array. All subsequent elements are shifted to the left<a name="line.4880"></a>
-<span class="sourceLineNo">4881</span> * (subtracts one from their indices). If the array doesn't contains<a name="line.4881"></a>
-<span class="sourceLineNo">4882</span> * such an element, no elements are removed from the array.</p><a name="line.4882"></a>
-<span class="sourceLineNo">4883</span> *<a name="line.4883"></a>
-<span class="sourceLineNo">4884</span> * <p>This method returns a new array with the same elements of the input<a name="line.4884"></a>
-<span class="sourceLineNo">4885</span> * array except the first occurrence of the specified element. The component<a name="line.4885"></a>
-<span class="sourceLineNo">4886</span> * type of the returned array is always the same as that of the input<a name="line.4886"></a>
-<span class="sourceLineNo">4887</span> * array.</p><a name="line.4887"></a>
-<span class="sourceLineNo">4888</span> *<a name="line.4888"></a>
-<span class="sourceLineNo">4889</span> * <pre><a name="line.4889"></a>
-<span class="sourceLineNo">4890</span> * ArrayUtils.removeElement(null, 1.1) = null<a name="line.4890"></a>
-<span class="sourceLineNo">4891</span> * ArrayUtils.removeElement([], 1.1) = []<a name="line.4891"></a>
-<span class="sourceLineNo">4892</span> * ArrayUtils.removeElement([1.1], 1.2) = [1.1]<a name="line.4892"></a>
-<span class="sourceLineNo">4893</span> * ArrayUtils.removeElement([1.1, 2.3], 1.1) = [2.3]<a name="line.4893"></a>
-<span class="sourceLineNo">4894</span> * ArrayUtils.removeElement([1.1, 2.3, 1.1], 1.1) = [2.3, 1.1]<a name="line.4894"></a>
-<span class="sourceLineNo">4895</span> * </pre><a name="line.4895"></a>
-<span class="sourceLineNo">4896</span> *<a name="line.4896"></a>
-<span class="sourceLineNo">4897</span> * @param array the array to remove the element from, may be {@code null}<a name="line.4897"></a>
-<span class="sourceLineNo">4898</span> * @param element the element to be removed<a name="line.4898"></a>
-<span class="sourceLineNo">4899</span> * @return A new array containing the existing elements except the first<a name="line.4899"></a>
-<span class="sourceLineNo">4900</span> * occurrence of the specified element.<a name="line.4900"></a>
-<span class="sourceLineNo">4901</span> * @since 2.1<a name="line.4901"></a>
-<span class="sourceLineNo">4902</span> */<a name="line.4902"></a>
-<span class="sourceLineNo">4903</span> public static double[] removeElement(final double[] array, final double element) {<a name="line.4903"></a>
-<span class="sourceLineNo">4904</span> final int index = indexOf(array, element);<a name="line.4904"></a>
-<span class="sourceLineNo">4905</span> if (index == INDEX_NOT_FOUND) {<a name="line.4905"></a>
-<span class="sourceLineNo">4906</span> return clone(array);<a name="line.4906"></a>
-<span class="sourceLineNo">4907</span> }<a name="line.4907"></a>
-<span class="sourceLineNo">4908</span> return remove(array, index);<a name="line.4908"></a>
-<span class="sourceLineNo">4909</span> }<a name="line.4909"></a>
-<span class="sourceLineNo">4910</span><a name="line.4910"></a>
-<span class="sourceLineNo">4911</span> /**<a name="line.4911"></a>
-<span class="sourceLineNo">4912</span> * <p>Removes the element at the specified position from the specified array.<a name="line.4912"></a>
-<span class="sourceLineNo">4913</span> * All subsequent elements are shifted to the left (subtracts one from<a name="line.4913"></a>
-<span class="sourceLineNo">4914</span> * their indices).</p><a name="line.4914"></a>
-<span class="sourceLineNo">4915</span> *<a name="line.4915"></a>
-<span class="sourceLineNo">4916</span> * <p>This method returns a new array with the same elements of the input<a name="line.4916"></a>
-<span class="sourceLineNo">4917</span> * array except the element on the specified position. The component<a name="line.4917"></a>
-<span class="sourceLineNo">4918</span> * type of the returned array is always the same as that of the input<a name="line.4918"></a>
-<span class="sourceLineNo">4919</span> * array.</p><a name="line.4919"></a>
-<span class="sourceLineNo">4920</span> *<a name="line.4920"></a>
-<span class="sourceLineNo">4921</span> * <p>If the input array is {@code null}, an IndexOutOfBoundsException<a name="line.4921"></a>
-<span class="sourceLineNo">4922</span> * will be thrown, because in that case no valid index can be specified.</p><a name="line.4922"></a>
-<span class="sourceLineNo">4923</span> *<a name="line.4923"></a>
-<span class="sourceLineNo">4924</span> * <pre><a name="line.4924"></a>
-<span class="sourceLineNo">4925</span> * ArrayUtils.remove([1.1], 0) = []<a name="line.4925"></a>
-<span class="sourceLineNo">4926</span> * ArrayUtils.remove([2.5, 6.0], 0) = [6.0]<a name="line.4926"></a>
-<span class="sourceLineNo">4927</span> * ArrayUtils.remove([2.5, 6.0], 1) = [2.5]<a name="line.4927"></a>
-<span class="sourceLineNo">4928</span> * ArrayUtils.remove([2.5, 6.0, 3.8], 1) = [2.5, 3.8]<a name="line.4928"></a>
-<span class="sourceLineNo">4929</span> * </pre><a name="line.4929"></a>
-<span class="sourceLineNo">4930</span> *<a name="line.4930"></a>
-<span class="sourceLineNo">4931</span> * @param array the array to remove the element from, may not be {@code null}<a name="line.4931"></a>
-<span class="sourceLineNo">4932</span> * @param index the position of the element to be removed<a name="line.4932"></a>
-<span class="sourceLineNo">4933</span> * @return A new array containing the existing elements except the element<a name="line.4933"></a>
-<span class="sourceLineNo">4934</span> * at the specified position.<a name="line.4934"></a>
-<span class="sourceLineNo">4935</span> * @throws IndexOutOfBoundsException if the index is out of range<a name="line.4935"></a>
-<span class="sourceLineNo">4936</span> * (index < 0 || index >= array.length), or if the array is {@code null}.<a name="line.4936"></a>
-<span class="sourceLineNo">4937</span> * @since 2.1<a name="line.4937"></a>
-<span class="sourceLineNo">4938</span> */<a name="line.4938"></a>
-<span class="sourceLineNo">4939</span> public static float[] remove(final float[] array, final int index) {<a name="line.4939"></a>
-<span class="sourceLineNo">4940</span> return (float[]) remove((Object) array, index);<a name="line.4940"></a>
-<span class="sourceLineNo">4941</span> }<a name="line.4941"></a>
-<span class="sourceLineNo">4942</span><a name="line.4942"></a>
-<span class="sourceLineNo">4943</span> /**<a name="line.4943"></a>
-<span class="sourceLineNo">4944</span> * <p>Removes the first occurrence of the specified element from the<a name="line.4944"></a>
-<span class="sourceLineNo">4945</span> * specified array. All subsequent elements are shifted to the left<a name="line.4945"></a>
-<span class="sourceLineNo">4946</span> * (subtracts one from their indices). If the array doesn't contains<a name="line.4946"></a>
-<span class="sourceLineNo">4947</span> * such an element, no elements are removed from the array.</p><a name="line.4947"></a>
-<span class="sourceLineNo">4948</span> *<a name="line.4948"></a>
-<span class="sourceLineNo">4949</span> * <p>This method returns a new array with the same elements of the input<a name="line.4949"></a>
-<span class="sourceLineNo">4950</span> * array except the first occurrence of the specified element. The component<a name="line.4950"></a>
-<span class="sourceLineNo">4951</span> * type of the returned array is always the same as that of the input<a name="line.4951"></a>
-<span class="sourceLineNo">4952</span> * array.</p><a name="line.4952"></a>
-<span class="sourceLineNo">4953</span> *<a name="line.4953"></a>
-<span class="sourceLineNo">4954</span> * <pre><a name="line.4954"></a>
-<span class="sourceLineNo">4955</span> * ArrayUtils.removeElement(null, 1.1) = null<a name="line.4955"></a>
-<span class="sourceLineNo">4956</span> * ArrayUtils.removeElement([], 1.1) = []<a name="line.4956"></a>
-<span class="sourceLineNo">4957</span> * ArrayUtils.removeElement([1.1], 1.2) = [1.1]<a name="line.4957"></a>
-<span class="sourceLineNo">4958</span> * ArrayUtils.removeElement([1.1, 2.3], 1.1) = [2.3]<a name="line.4958"></a>
-<span class="sourceLineNo">4959</span> * ArrayUtils.removeElement([1.1, 2.3, 1.1], 1.1) = [2.3, 1.1]<a name="line.4959"></a>
-<span class="sourceLineNo">4960</span> * </pre><a name="line.4960"></a>
-<span class="sourceLineNo">4961</span> *<a name="line.4961"></a>
-<span class="sourceLineNo">4962</span> * @param array the array to remove the element from, may be {@code null}<a name="line.4962"></a>
-<span class="sourceLineNo">4963</span> * @param element the element to be removed<a name="line.4963"></a>
-<span class="sourceLineNo">4964</span> * @return A new array containing the existing elements except the first<a name="line.4964"></a>
-<span class="sourceLineNo">4965</span> * occurrence of the specified element.<a name="line.4965"></a>
-<span class="sourceLineNo">4966</span> * @since 2.1<a name="line.4966"></a>
-<span class="sourceLineNo">4967</span> */<a name="line.4967"></a>
-<span class="sourceLineNo">4968</span> public static float[] removeElement(final float[] array, final float element) {<a name="line.4968"></a>
-<span class="sourceLineNo">4969</span> final int index = indexOf(array, element);<a name="line.4969"></a>
-<span class="sourceLineNo">4970</span> if (index == INDEX_NOT_FOUND) {<a name="line.4970"></a>
-<span class="sourceLineNo">4971</span> return clone(array);<a name="line.4971"></a>
-<span class="sourceLineNo">4972</span> }<a name="line.4972"></a>
-<span class="sourceLineNo">4973</span> return remove(array, index);<a name="line.4973"></a>
-<span class="sourceLineNo">4974</span> }<a name="line.4974"></a>
-<span class="sourceLineNo">4975</span><a name="line.4975"></a>
-<span class="sourceLineNo">4976</span> /**<a name="line.4976"></a>
-<span class="sourceLineNo">4977</span> * <p>Removes the element at the specified position from the specified array.<a name="line.4977"></a>
-<span class="sourceLineNo">4978</span> * All subsequent elements are shifted to the left (subtracts one from<a name="line.4978"></a>
-<span class="sourceLineNo">4979</span> * their indices).</p><a name="line.4979"></a>
-<span class="sourceLineNo">4980</span> *<a name="line.4980"></a>
-<span class="sourceLineNo">4981</span> * <p>This method returns a new array with the same elements of the input<a name="line.4981"></a>
-<span class="sourceLineNo">4982</span> * array except the element on the specified position. The component<a name="line.4982"></a>
-<span class="sourceLineNo">4983</span> * type of the returned array is always the same as that of the input<a name="line.4983"></a>
-<span class="sourceLineNo">4984</span> * array.</p><a name="line.4984"></a>
-<span class="sourceLineNo">4985</span> *<a name="line.4985"></a>
-<span class="sourceLineNo">4986</span> * <p>If the input array is {@code null}, an IndexOutOfBoundsException<a name="line.4986"></a>
-<span class="sourceLineNo">4987</span> * will be thrown, because in that case no valid index can be specified.</p><a name="line.4987"></a>
-<span class="sourceLineNo">4988</span> *<a name="line.4988"></a>
-<span class="sourceLineNo">4989</span> * <pre><a name="line.4989"></a>
-<span class="sourceLineNo">4990</span> * ArrayUtils.remove([1], 0) = []<a name="line.4990"></a>
-<span class="sourceLineNo">4991</span> * ArrayUtils.remove([2, 6], 0) = [6]<a name="line.4991"></a>
-<span class="sourceLineNo">4992</span> * ArrayUtils.remove([2, 6], 1) = [2]<a name="line.4992"></a>
-<span class="sourceLineNo">4993</span> * ArrayUtils.remove([2, 6, 3], 1) = [2, 3]<a name="line.4993"></a>
-<span class="sourceLineNo">4994</span> * </pre><a name="line.4994"></a>
-<span class="sourceLineNo">4995</span> *<a name="line.4995"></a>
-<span class="sourceLineNo">4996</span> * @param array the array to remove the element from, may not be {@code null}<a name="line.4996"></a>
-<span class="sourceLineNo">4997</span> * @param index the position of the element to be removed<a name="line.4997"></a>
-<span class="sourceLineNo">4998</span> * @return A new array containing the existing elements except the element<a name="line.4998"></a>
-<span class="sourceLineNo">4999</span> * at the specified position.<a name="line.4999"></a>
-<span class="sourceLineNo">5000</span> * @throws IndexOutOfBoundsException if the index is out of range<a name="line.5000"></a>
-<span class="sourceLineNo">5001</span> * (index < 0 || index >= array.length), or if the array is {@code null}.<a name="line.5001"></a>
-<span class="sourceLineNo">5002</span> * @since 2.1<a name="line.5002"></a>
-<span class="sourceLineNo">5003</span> */<a name="line.5003"></a>
-<span class="sourceLineNo">5004</span> public static int[] remove(final int[] array, final int index) {<a name="line.5004"></a>
-<span class="sourceLineNo">5005</span> return (int[]) remove((Object) array, index);<a name="line.5005"></a>
-<span class="sourceLineNo">5006</span> }<a name="line.5006"></a>
-<span class="sourceLineNo">5007</span><a name="line.5007"></a>
-<span class="sourceLineNo">5008</span> /**<a name="line.5008"></a>
-<span class="sourceLineNo">5009</span> * <p>Removes the first occurrence of the specified element from the<a name="line.5009"></a>
-<span class="sourceLineNo">5010</span> * specified array. All subsequent elements are shifted to the left<a name="line.5010"></a>
-<span class="sourceLineNo">5011</span> * (subtracts one from their indices). If the array doesn't contains<a name="line.5011"></a>
-<span class="sourceLineNo">5012</span> * such an element, no elements are removed from the array.</p><a name="line.5012"></a>
-<span class="sourceLineNo">5013</span> *<a name="line.5013"></a>
-<span class="sourceLineNo">5014</span> * <p>This method returns a new array with the same elements of the input<a name="line.5014"></a>
-<span class="sourceLineNo">5015</span> * array except the first occurrence of the specified element. The component<a name="line.5015"></a>
-<span class="sourceLineNo">5016</span> * type of the returned array is always the same as that of the input<a name="line.5016"></a>
-<span class="sourceLineNo">5017</span> * array.</p><a name="line.5017"></a>
-<span class="sourceLineNo">5018</span> *<a name="line.5018"></a>
-<span class="sourceLineNo">5019</span> * <pre><a name="line.5019"></a>
-<span class="sourceLineNo">5020</span> * ArrayUtils.removeElement(null, 1) = null<a name="line.5020"></a>
-<span class="sourceLineNo">5021</span> * ArrayUtils.removeElement([], 1) = []<a name="line.5021"></a>
-<span class="sourceLineNo">5022</span> * ArrayUtils.removeElement([1], 2) = [1]<a name="line.5022"></a>
-<span class="sourceLineNo">5023</span> * ArrayUtils.removeElement([1, 3], 1) = [3]<a name="line.5023"></a>
-<span class="sourceLineNo">5024</span> * ArrayUtils.removeElement([1, 3, 1], 1) = [3, 1]<a name="line.5024"></a>
-<span class="sourceLineNo">5025</span> * </pre><a name="line.5025"></a>
-<span class="sourceLineNo">5026</span> *<a name="line.5026"></a>
-<span class="sourceLineNo">5027</span> * @param array the array to remove the element from, may be {@code null}<a name="line.5027"></a>
-<span class="sourceLineNo">5028</span> * @param element the element to be removed<a name="line.5028"></a>
-<span class="sourceLineNo">5029</span> * @return A new array containing the existing elements except the first<a name="line.5029"></a>
-<span class="sourceLineNo">5030</span> * occurrence of the specified element.<a name="line.5030"></a>
-<span class="sourceLineNo">5031</span> * @since 2.1<a name="line.5031"></a>
-<span class="sourceLineNo">5032</span> */<a name="line.5032"></a>
-<span class="sourceLineNo">5033</span> public static int[] removeElement(final int[] array, final int element) {<a name="line.5033"></a>
-<span class="sourceLineNo">5034</span> final int index = indexOf(array, element);<a name="line.5034"></a>
-<span class="sourceLineNo">5035</span> if (index == INDEX_NOT_FOUND) {<a name="line.5035"></a>
-<span class="sourceLineNo">5036</span> return clone(array);<a name="line.5036"></a>
-<span class="sourceLineNo">5037</span> }<a name="line.5037"></a>
-<span class="sourceLineNo">5038</span> return remove(array, index);<a name="line.5038"></a>
-<span class="sourceLineNo">5039</span> }<a name="line.5039"></a>
-<span class="sourceLineNo">5040</span><a name="line.5040"></a>
-<span class="sourceLineNo">5041</span> /**<a name="line.5041"></a>
-<span class="sourceLineNo">5042</span> * <p>Removes the element at the specified position from the specified array.<a name="line.5042"></a>
-<span class="sourceLineNo">5043</span> * All subsequent elements are shifted to the left (subtracts one from<a name="line.5043"></a>
-<span class="sourceLineNo">5044</span> * their indices).</p><a name="line.5044"></a>
-<span class="sourceLineNo">5045</span> *<a name="line.5045"></a>
-<span class="sourceLineNo">5046</span> * <p>This method returns a new array with the same elements of the input<a name="line.5046"></a>
-<span class="sourceLineNo">5047</span> * array except the element on the specified position. The component<a name="line.5047"></a>
-<span class="sourceLineNo">5048</span> * type of the returned array is always the same as that of the input<a name="line.5048"></a>
-<span class="sourceLineNo">5049</span> * array.</p><a name="line.5049"></a>
-<span class="sourceLineNo">5050</span> *<a name="line.5050"></a>
-<span class="sourceLineNo">5051</span> * <p>If the input array is {@code null}, an IndexOutOfBoundsException<a name="line.5051"></a>
-<span class="sourceLineNo">5052</span> * will be thrown, because in that case no valid index can be specified.</p><a name="line.5052"></a>
-<span class="sourceLineNo">5053</span> *<a name="line.5053"></a>
-<span class="sourceLineNo">5054</span> * <pre><a name="line.5054"></a>
-<span class="sourceLineNo">5055</span> * ArrayUtils.remove([1], 0) = []<a name="line.5055"></a>
-<span class="sourceLineNo">5056</span> * ArrayUtils.remove([2, 6], 0) = [6]<a name="line.5056"></a>
-<span class="sourceLineNo">5057</span> * ArrayUtils.remove([2, 6], 1) = [2]<a name="line.5057"></a>
-<span class="sourceLineNo">5058</span> * ArrayUtils.remove([2, 6, 3], 1) = [2, 3]<a name="line.5058"></a>
-<span class="sourceLineNo">5059</span> * </pre><a name="line.5059"></a>
-<span class="sourceLineNo">5060</span> *<a name="line.5060"></a>
-<span class="sourceLineNo">5061</span> * @param array the array to remove the element from, may not be {@code null}<a name="line.5061"></a>
-<span class="sourceLineNo">5062</span> * @param index the position of the element to be removed<a name="line.5062"></a>
-<span class="sourceLineNo">5063</span> * @return A new array containing the existing elements except the element<a name="line.5063"></a>
-<span class="sourceLineNo">5064</span> * at the specified position.<a name="line.5064"></a>
-<span class="sourceLineNo">5065</span> * @throws IndexOutOfBoundsException if the index is out of range<a name="line.5065"></a>
-<span class="sourceLineNo">5066</span> * (index < 0 || index >= array.length), or if the array is {@code null}.<a name="line.5066"></a>
-<span class="sourceLineNo">5067</span> * @since 2.1<a name="line.5067"></a>
-<span class="sourceLineNo">5068</span> */<a name="line.5068"></a>
-<span class="sourceLineNo">5069</span> public static long[] remove(final long[] array, final int index) {<a name="line.5069"></a>
-<span class="sourceLineNo">5070</span> return (long[]) remove((Object) array, index);<a name="line.5070"></a>
-<span class="sourceLineNo">5071</span> }<a name="line.5071"></a>
-<span class="sourceLineNo">5072</span><a name="line.5072"></a>
-<span class="sourceLineNo">5073</span> /**<a name="line.5073"></a>
-<span class="sourceLineNo">5074</span> * <p>Removes the first occurrence of the specified element from the<a name="line.5074"></a>
-<span class="sourceLineNo">5075</span> * specified array. All subsequent elements are shifted to the left<a name="line.5075"></a>
-<span class="sourceLineNo">5076</span> * (subtracts one from their indices). If the array doesn't contains<a name="line.5076"></a>
-<span class="sourceLineNo">5077</span> * such an element, no elements are removed from the array.</p><a name="line.5077"></a>
-<span class="sourceLineNo">5078</span> *<a name="line.5078"></a>
-<span class="sourceLineNo">5079</span> * <p>This method returns a new array with the same elements of the input<a name="line.5079"></a>
-<span class="sourceLineNo">5080</span> * array except the first occurrence of the specified element. The component<a name="line.5080"></a>
-<span class="sourceLineNo">5081</span> * type of the returned array is always the same as that of the input<a name="line.5081"></a>
-<span class="sourceLineNo">5082</span> * array.</p><a name="line.5082"></a>
-<span class="sourceLineNo">5083</span> *<a name="line.5083"></a>
-<span class="sourceLineNo">5084</span> * <pre><a name="line.5084"></a>
-<span class="sourceLineNo">5085</span> * ArrayUtils.removeElement(null, 1) = null<a name="line.5085"></a>
-<span class="sourceLineNo">5086</span> * ArrayUtils.removeElement([], 1) = []<a name="line.5086"></a>
-<span class="sourceLineNo">5087</span> * ArrayUtils.removeElement([1], 2) = [1]<a name="line.5087"></a>
[... 2817 lines stripped ...]