数组链表工具

import java.lang.reflect.Array;
import java.util.*;

/**

• 数组、链表工具
  /
  public class ArrayUtil {
  /*

  • 创建数组
  • @param obj 对象列表
  • @param
  • @return
    /
    public static T[] create(T… obj) {
    Class calcedType=calcElementType(obj);
    Object newArray = Array.newInstance(calcedType, obj.length);
    for (int i = 0; i < obj.length; i++) {
    Array.set(newArray,i,obj[i]);
    }
    return (T[]) newArray;
    }
    /*
  • 数组转List
  • @param arr 数组
  • @param
  • @return
    /
    public static List arrayToList(T[] arr) {
    List result = new ArrayList<>();
    for (T t : arr) {
    result.add(t);
    }
    return result;
    }
    /*
  • List转数组
  • @param list List对象
  • @param
  • @return
    /
    public static T[] listToArray(List list) {
    Class arrClz = calcElementType(list);
    Object result = Array.newInstance(arrClz, list.size());
    for (int i = 0; i < list.size(); i++) {
    Array.set(result, i, list.get(i));
    }
    return (T[]) result;
    }
    /*
  • 获取数组元素的类型
  • 如果存在类型不一致的情况，则获取Object的类型
  • @param array List对象
  • @param
  • @return
    /
    public static Class calcElementType(T[] array) {
    List types = new ArrayList<>();
    Class arrClz = null;
    for (T t : array) {
    if (t != null && !types.contains(t.getClass())) {
    types.add(t.getClass());
    }
    }
    if (types.size() == 1) {
    arrClz = types.get(0);
    } else {
    arrClz = Object.class;
    }
    return arrClz;
    }
    /*
  • 获取集合元素的类型
  • 如果存在类型不一致的情况，则获取Object的类型
  • @param list List对象
  • @param
  • @return
    /
    public static Class calcElementType(Collection list) {
    List types = new ArrayList<>();
    Class arrClz = null;
    for (T t : list) {
    if (t != null && !types.contains(t.getClass())) {
    types.add(t.getClass());
    }
    }
    if (types.size() == 1) {
    arrClz = types.get(0);
    } else {
    arrClz = Object.class;
    }
    return arrClz;
    }
    /*
  • 数组转下标索引表
  • @param array 数组/List
  • @param offset 转换后下标偏移
  • @return
    /
    public static Map<Integer, T> toIndexMap(T[] array, int offset) {
    Map<Integer, T> result = new LinkedHashMap<>();
    if (!ObjectUtil.isArray(array)) {
    throw new RuntimeException(“转换下标索引表错误：不是数组”);
    }
    int size = ObjectUtil.size(array);
    for (int i = 0; i < size; i++) {
    result.put(i + offset, (T) ObjectUtil.get(array, i));
    }
    return result;
    }
    /*
  • 数组转下标索引表
  • @param array 数组/List
  • @return
    /
    public static Map<Integer, T> toIndexMap(T[] array) {
    return toIndexMap(array, 0);
    }
    /*
  • 下标索引表转数组
  • @param indexMap 下标索引表
  • @param offset 下标偏移量修正
  • @return
    /
    public static T[] fromIndexMap(Map<Integer, T> indexMap, int offset) {
    List keys = ObjectUtil.getKeys(indexMap);
    List insertKeys = new ArrayList<>();
    for (Object key : keys) {
    insertKeys.add(Integer.parseInt(key.toString()) + offset);
    }
    int maxIndex = 0;
    for (Integer insertKey : insertKeys) {
    if (insertKey > maxIndex) {
    maxIndex = insertKey;
    }
    }
    Class calcedType = calcElementType(indexMap.values());
    Object result = Array.newInstance(calcedType, maxIndex + 1);
    for (Integer insertKey : insertKeys) {
    Array.set(result, insertKey, ObjectUtil.get(indexMap, insertKey - offset));
    }
    return (T[]) result;
    }
    /*
  • 下标索引表转数组
  • @param indexMap 下标索引表
  • @return
    */
    public static T[] fromIndexMap(Map<Integer, T> indexMap){
    return fromIndexMap(indexMap,0);
    }

  /**

  • 将数组转换为指定类型数组
  • @param array
  • @param clz
  • @param
  • @param
  • @return
    */
    public static <T,K> T[] parseArray(K[] array, Class clz){
    Object newArray = Array.newInstance(clz, array.length);
    for (int i = 0; i < array.length; i++) {
    if(“String”.equals(clz.getSimpleName())&&array[i]!=null){
    Array.set(newArray,i,array[i].toString());
    }else{
    Array.set(newArray,i,array[i]);
    }
    }
    return (T[]) newArray;
    }

  /**

  • 转为String数组
  • @param array
  • @param
  • @return
    */
    public static String[] parseStringArray(T[] array){
    return parseArray(array,String.class);
    }

  /**

  • 转换为Integer数组
  • @param array
  • @param
  • @return
    */
    public static Integer[] parseIntegerArray(T[] array){
    return parseArray(array,Integer.class);
    }

  /**

  • 转换为Boolean数组
  • @param array
  • @param
  • @return
    */
    public static Boolean[] parseBooleanArray(T[] array){
    return parseArray(array,Boolean.class);
    }

  /**

  • 转换为Double数组
  • @param array
  • @param
  • @return
    */
    public static Double[] parseDoubleArray(T[] array){
    return parseArray(array,Double.class);
    }

  /**

  • 转换为Long数组
  • @param array
  • @param
  • @return
    */
    public static Long[] parseLongArray(T[] array){
    return parseArray(array,Long.class);
    }

  /**

  • 转换为Short数组
  • @param array
  • @param
  • @return
    */
    public static Short[] parseShortArray(T[] array){
    return parseArray(array,Short.class);
    }

  /**

  • 转换为Char数组
  • @param array
  • @param
  • @return
    */
    public static Character[] parseCharArray(T[] array){
    return parseArray(array,Character.class);
    }

  /**

  • 将高维数组第二层降维到第一层
  • @param array 数组
  • @return
    */
    public static Object[] dimensionReduction(Object[] array){
    List result=new ArrayList<>();
    for (int i = 0; i < array.length; i++) {
    if(ObjectUtil.isArray(array[i])){
    int innerSize = ObjectUtil.size(array[i]);
    for (int j = 0; j < innerSize; j++) {
    result.add(ObjectUtil.get(array[i],j));
    }
    }else{
    result.add(array[i]);
    }
    }
    return result.toArray(new Object[]{});
    }
    }