Arrays类学习

package com.song.source.java;

import java.io.Serializable;
import java.util.AbstractList;
import java.util.Objects;
import java.util.RandomAccess;

public class Arrays {

  private Arrays() {}

  private static class ArrayList<E> extends AbstractList<E> implements RandomAccess,Serializable {

    private final E[] a;

    ArrayList(E[] array){
      a = Objects.requireNonNull(array);
    }

    /**
     * 获得角标对应的数值
     * @param index 角标
     * @return 数组对应值
     */
    @Override
    public E get(int index) {
      return a[index];
    }

    /**
     * 返回数组大小
     * @return
     */
    @Override
    public int size() {
      return a.length;
    }


    /**
     * 数组的set赋值，将所给的值赋值到对应的位置上，将旧的值返回
     * @param index 角标
     * @param element 元素
     * @return 旧的值
     */
    @Override
    public E set(int index, E element) {
        E oldValue =  a[index];
        a[index] = element;
        return oldValue;
    }

    /**
     * 转变为数组
     * @return
     */
    @Override
    public Object[] toArray() {
      return a.clone();
    }


    @Override
    public <T> T[] toArray(T[] a) {
      return super.toArray(a);
    }

    /**
     * 传入参数，第一次出现的位置.
     *    思想：
     *      对传入值进行判断？
     *        1.传入为null，遍历数组匹配,返回下标
     *        2.传入不为null，遍历数组匹配,返回下标
     *        3.返回 -1
     */
    @Override
    public int indexOf(Object o) {
       if(o == null) {
         for(int i = 0; i < a.length; i++) {
            if(a[i] == null){
              return i;
            }
         }
       } else {
         for(int i = 0; i < a.length; i++) {
            if(a[i] == o){
              return i;
            }
         }
       }
       return -1;
    }


    /**
     * 给定数组，判定数组中是否包含。
     *   思想：遍历查找，null和非null的情况，
     *      1.如果找到了，result != -1
     *      2.如果找不到, result == -1
     *      可以使用  -1 作为判定条件
     * @param o
     * @return
     */
    @Override
    public boolean contains(Object o) {
      return indexOf(o) != -1;
    }
  }

  /**
   * 传入一个对象，toString()操作
   *   1.传入参数为 "null"
   *   2.传入参数不为null,
   *      1.传入数组长度为空 , 返回 " [] "
   *      2.如果传入的数组不为空 ，不为空，遍历数组元素 ,显示格式为[ 1,2,3...]
   *
   * @param
   * @return
   */
  public static String toString(Object[] a) {
    if (a == null) {
      return "null";
    }

    int max = a.length - 1;
    // 判断传入的数组是否为空
    if (max == -1) {
      return "[]";
    }
    // 如果传入的数组不为空
    StringBuilder b = new StringBuilder();
    b.append("[");
    for (int i = 0; ; i++) {
      b.append(a[i]);
      //结束程序
      if (i == max) {
        return b.append("]").toString();
      }
      // ，就是后面有元素的时候加
      b.append(",");
    }
  }


  /**
   * 比较两个数组是否相等
   *
   *  思考：
   *    1.两个数组是否为null
   *    2.比较两个数组的长度
   *       1.长度相等
   *            遍历，比较每一元素
   *       2.长度不等 false
   *
   * @param a 第一个数组
   * @param b 第二个数组
   * @return boolean
   */
  public static boolean equals(Object[] a , Object[] b) {
      if(a == b) {
        return true;
      }

      if(a == null || b == null) {
        return false;
      }

      int length = b.length;

      if(a.length != length) {
         return false;
      }
      //两个数组不为空，且长度不一致
      for(int i = 0; i < length ;i++) {
        Object o1 = a[i];
        Object o2 = b[i];
        // 数组元素存在null 且两个数组元素的元素不相等 则false
        if(!(o1 == null ? o2 == null : o1.equals(o2))) {
            return false;
        }
      }
      return true;
  }


  /**
   * 比较int类型数组是否相等
   * @author Song Lv Jun
   * @param a 第一个数组
   * @param b 第二个数组
   * @return boolean
   */
  public static boolean equals(int[] a , int[] b) {

    // 先比较对象是否相等
    if(a == b) {
      return true;
    }

    // 判定是否为null
    if(a == null || b == null) {
      return false;
    }

    // 判定长度
    int length = b.length;
    if(a.length != length) {
      return false;
    }

    //如果对象不等，不为null或者是长度不等，则具体判断数组内容
    for(int i = 0; i < length; i++) {
      if(a[i] != b[i]) {
        return false;
      }
    }
    return true;
  }

  /**
   * 将指定的值，赋值给数组的每一个元素
   * @param a 数组
   * @param val 指定的值
   */
  public static void fill(int[] a, int val) {
     for(int i = 0, len = a.length; i < len; i++) {
        a[i] = val;
     }
  }

  /**
   * 支持对 int 转化成String
   * @param a
   * @return
   */
  public static String toString(int[] a) {
    // 如果传入的数组为null,那么返回 []
     if(a == null) {
        return "null";
     }

    // 如果传入的数组为空，那么返回 []
    int iMax = a.length - 1;
    if( iMax == -1) {
      return  "[]";
    }

    StringBuilder sb = new StringBuilder();
    sb.append("[");
    for(int i = 0; ; i++) {
      sb.append(a[i]);
      if(i == iMax) {
        return sb.append("]").toString();
      }
      sb.append(",");
    }
  }

  /**
   * 给指定数组，从开始索引，到结束索引,填充指定值，
   * @param a 数组
   * @param fromIndex 开始索引
   * @param toIndex 结束索引
   * @param val 指定值
   */
  public static void fill(int[] a, int fromIndex, int toIndex, int val) {
    // 索引范围检查
    rangeCheck(a.length,fromIndex,toIndex);
    // 将传入指定的值，设置到范围内确定的索引上
    for(int i = fromIndex; i < toIndex; i++) {
      a[i] = val;
    }
  }

  /**
   * 数组索引检查
   * @param arrayLength 数组长度
   * @param fromIndex 开始位置
   * @param toIndex 结束位置
   */
  private static void rangeCheck(int arrayLength, int fromIndex, int toIndex) {
    // 首先对传入的开始位置与结束位置判断
    if(fromIndex > toIndex) {
      throw new IllegalArgumentException(
        "fromIndex(" + fromIndex + ") > toIndex(" + toIndex + ")");
    }

    // 如果开始索引小于0
    if(fromIndex < 0) {
      throw new ArrayIndexOutOfBoundsException(fromIndex);
    }

    // 如果结束索引大于数组长度
    if(toIndex > arrayLength) {
      throw new ArrayIndexOutOfBoundsException(toIndex);
    }
  }
/**
 * 数组copy指定的长度
 * @param original
 * @param newLength
 */
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;
}
}

package com.song.source.java;

public class Test {
    public static void main(String[] args){
      int[] a = {1,2,4};
      int[] b = {1,2,4,2};
      // 实现想等性判断
      boolean equals = Arrays.equals(a, b);
      System.out.println(equals);
      // 将指定的值分配给数组的每一个元素
      Arrays.fill(a,1);
      System.out.println(Arrays.toString(a));
      // 使用指定数，填充数组
      Arrays.fill(a,0,2,90);
      // 实现toString()
      System.out.println(Arrays.toString(a));
      // 实现折半查找
      Arrays.binarySearch(a,1);
      System.out.println(Arrays.toString(a));
      System.out.println(Arrays.binarySearch(a,99));
      // 实现数组拷贝
      Arrays.copyOf(a,3);

      System.out.println(Arrays.toString(java.util.Arrays.copyOf(a,16)));
      System.out.println(Arrays.toString(java.util.Arrays.copyOf(a,0)));
      System.out.println(Arrays.toString(Arrays.copyOf(a,3)));
  }
}