面试初级Java开发问到Arrays

1 . <T> List<T>  asList(T... a)

Integer[] array = new Integer[]{ 1 , 2 , 3 }; int [] array2 = new int []{ 1 , 2 , 3 };

List<Integer> list1 = Arrays.asList( 1 , 2 , 3 );

List<Integer> list2 = Arrays.asList(array); //加入Java开发交流君样：593142328一起吹水聊天

List< int []> list3 = Arrays.asList(array2);

int [] array = new int []{ 1 , 2 , 3 };

Arrays.fill(array, 1 );

Arrays.fill(array, 0 , 2 , 1 ); // {1,1,3}

String[] str = { "123" };

Arrays.fill(str, "1" );

/** * Assigns the specified double value to each element of the specified

   * range of the specified array of doubles.  The range to be filled

   * extends from index <tt>fromIndex</tt>, inclusive, to index

   * <tt>toIndex</tt>, exclusive.  (If <tt>fromIndex==toIndex</tt>, the

   * range to be filled is empty.)

   *

   * @param a the array to be filled

   * @param fromIndex the index of the first element (inclusive) to be

   *        filled with the specified value

   * @param toIndex the index of the last element (exclusive) to be

   *        filled with the specified value//加入Java开发交流君样：593142328一起吹水聊天

   * @param val the value to be stored in all elements of the array

   * @throws IllegalArgumentException if <tt>fromIndex &gt; toIndex</tt>

   * @throws ArrayIndexOutOfBoundsException if <tt>fromIndex &lt; 0</tt> or

   *         <tt>toIndex &gt; a.length</tt> */

  public static void fill( double [] a, int fromIndex, int toIndex, double val){

      rangeCheck(a.length, fromIndex, toIndex); for (

      int i = fromIndex; i < toIndex; i++)

          a[i] = val;

  } /** * Assigns the specified float value to each element of the specified array

   * of floats.

   *

   * @param a the array to be filled

   * @param val the value to be stored in all elements of the array */

  public static void fill( float [] a, float val) {

   for ( int i = 0 , len = a.length; i < len; i++)

          a[i] = val;

  } /** * Checks that {@code fromIndex} and {@code toIndex} are in

   * the range and throws an exception if they aren't. */

  private static void rangeCheck( int arrayLength, int fromIndex, int toIndex) {

  if (fromIndex > toIndex) { throw new IllegalArgumentException( "fromIndex(" + fromIndex + ") > toIndex(" + toIndex + ")" );

      } if (fromIndex < 0 ) {

      throw new ArrayIndexOutOfBoundsException(fromIndex);

      } if (toIndex > arrayLength) { //加入Java开发交流君样：593142328一起吹水聊天

       throw new ArrayIndexOutOfBoundsException(toIndex);

      }

  }

int [] array = new int []{ 1 , 2 , 3 };

int [] array2 = Arrays.copyOf(array, 4 );

public static int [] copyOf(

int [] original, int newLength) {

int [] copy = new int [newLength];

         System.arraycopy(original, 0 , copy, 0 ,

                          Math.min(original.length, newLength));

                           return copy;

     }

int [] array = new int []{ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 };

int [] array2 = Arrays.copyOfRange(array, 3 , 6 );

int [] array3 = Arrays.copyOfRange(array, 3 , 10 );

/** * Copies the specified range of the specified array into a new array.

   * The initial index of the range (<tt>from</tt>) must lie between zero

   * and <tt>original.length</tt>, inclusive.  The value at

   * <tt>original[from]</tt> is placed into the initial element of the copy

   * (unless <tt>from == original.length</tt> or <tt>from == to</tt>).

   * Values from subsequent elements in the original array are placed into

   * subsequent elements in the copy.  The final index of the range

   * (<tt>to</tt>), which must be greater than or equal to <tt>from</tt>,

   * may be greater than <tt>original.length</tt>, in which case

   * <tt>0</tt> is placed in all elements of the copy whose index is

   * greater than or equal to <tt>original.length - from</tt>.  The length

   * of the returned array will be <tt>to - from</tt>.

   *

   * @param original the array from which a range is to be copied

   * @param from the initial index of the range to be copied, inclusive

   * @param to the final index of the range to be copied, exclusive.

   *     (This index may lie outside the array.)

   * @return a new array containing the specified range from the original array,

   *     truncated or padded with zeros to obtain the required length

   * @throws ArrayIndexOutOfBoundsException if {@code from < 0}

   *     or {@code from > original.length}

   * @throws IllegalArgumentException if <tt>from &gt; to</tt>

   * @throws NullPointerException if <tt>original</tt> is null

   * @since 1.6 */ //加入Java开发交流君样： 593142328 一起吹水聊天

  public static int [] copyOfRange( int [] original, int from, int to) { int newLength = to - from; if (newLength < 0 ) throw new IllegalArgumentException(from + " > " + to); int [] copy = new int [newLength];

      System.arraycopy(original, from, copy, 0 ,

                       Math.min(original.length - from, newLength)); return copy;

  }

public static boolean equals( int [] a, int [] a2) { if (a==a2) return true ; if (a== null || a2== null ) return false ; int length = a.length; if (a2.length != length) return false ; for ( int i= 0 ; i<length; i++) if (a[i] != a2[i]) return false ; return true ;

     } public static boolean equals(Object[] a, Object[] a2) { if (a==a2) return true ; if (a== null || a2== null ) return false ; int length = a.length; if (a2.length != length) return false ; for ( int i= 0 ; i<length; i++) {

             Object o1 = a[i];

             Object o2 = a2[i]; if (!(o1== null ? o2== null : o1.equals(o2))) return false ;

         } return true ;

     }

public static String toString( int [] a) {

if (a == null ) return "null" ; int iMax = a.length - 1 ; if (iMax == - 1 ) return "[]" ;

         StringBuilder b = new StringBuilder();

         b.append( '[' ); for ( int i = 0 ; ; i++) {

             b.append(a[i]); if (i == iMax) return b.append( ']' ).toString();

             b.append( ", " );

         }

     }

1   public static int binarySearch( int [] a, int fromIndex, int toIndex,

2                                     int key) {

3          rangeCheck(a.length, fromIndex, toIndex);

  4          return binarySearch0(a, fromIndex, toIndex, key);

  5      }

  6

  7      // Like public version, but without range checks.

  8      private static int binarySearch0( int [] a, int fromIndex, int toIndex,

  9                                       int key) {

  10          int low = fromIndex;

  11          int high = toIndex - 1 ;

  12

13          while (low <= high) {

  14              int mid = (low + high) >>> 1 ;

  15              int midVal = a[mid];

  16

17              if (midVal < key)

18                  low = mid + 1 ;

19              else if (midVal > key)

20                  high = mid - 1 ;

21              else

22                  return mid; // key found

23 }

24          return -(low + 1 );  // key not found.

25      }