Java Array.getLength方法代码示例

import java.lang.reflect.Array; //导入方法依赖的package包/类
@Override
public String toString() {
    if (userData == null) {
        return null;
    }
    if (userData.getClass().isArray()) {
        String name =
                Utils.getArrayClassName(userData.getClass().getName());
        int length = Array.getLength(userData);
        return name + "[" + length + "]";
    }

    if (userData instanceof CompositeData ||
            userData instanceof TabularData) {
        return userData.getClass().getName();
    }

    return userData.toString();
}
 

import java.lang.reflect.Array; //导入方法依赖的package包/类
/**
 * Convert the given array (which may be a primitive array) to an
 * object array (if necessary of primitive wrapper objects).
 * <p>A {@code null} source value will be converted to an
 * empty Object array.
 * @param source the (potentially primitive) array
 * @return the corresponding object array (never {@code null})
 * @throws IllegalArgumentException if the parameter is not an array
 */
public static Object[] toObjectArray(Object source) {
	if (source instanceof Object[]) {
		return (Object[]) source;
	}
	if (source == null) {
		return new Object[0];
	}
	if (!source.getClass().isArray()) {
		throw new IllegalArgumentException("Source is not an array: " + source);
	}
	int length = Array.getLength(source);
	if (length == 0) {
		return new Object[0];
	}
	Class<?> wrapperType = Array.get(source, 0).getClass();
	Object[] newArray = (Object[]) Array.newInstance(wrapperType, length);
	for (int i = 0; i < length; i++) {
		newArray[i] = Array.get(source, i);
	}
	return newArray;
}
 

import java.lang.reflect.Array; //导入方法依赖的package包/类
private static void print(FeatureDescriptor descriptor) {
    String name = descriptor.getName();
    String display = descriptor.getDisplayName();
    String description = descriptor.getShortDescription();
    System.out.println("name: " + name);
    if (!Objects.equals(name, display)) {
        System.out.println("display name: " + display);
    }
    if (!Objects.equals(display, description)) {
        System.out.println("description: " + description.trim());
    }
    print("expert", descriptor.isExpert());
    print("hidden", descriptor.isHidden());
    print("preferred", descriptor.isPreferred());
    TreeMap<String,Object> map = new TreeMap<>();
    Enumeration<String> enumeration = descriptor.attributeNames();
    while (enumeration.hasMoreElements()) {
        String id = enumeration.nextElement();
        Object value = descriptor.getValue(id);
        if (value.getClass().isArray()) {
            TreeSet<String> set = new TreeSet<>();
            int index = 0;
            int length = Array.getLength(value);
            while (index < length) {
                set.add(Array.get(value, index++) + ", " +
                        Array.get(value, index++) + ", " +
                        Array.get(value, index++));
            }
            value = set.toString();
        }
        map.put(id, value);
    }
    for (Entry<String,Object> entry : map.entrySet()) {
        System.out.println(entry.getKey() + ": " + entry.getValue());
    }
}
 

import java.lang.reflect.Array; //导入方法依赖的package包/类
/**
 * 配列の値をIN句として加工してバインドする
 *
 * @param transformContext transformコンテキスト
 * @param values バインドする値の配列
 */
private void bindArray(final TransformContext transformContext, final Object values) {
	int length = Array.getLength(values);
	if (length == 0) {
		throw new ParameterNotFoundRuntimeException("Parameter is not set. [" + expression + "]");
	}

	transformContext.addSqlPart("(?");
	transformContext.addBindVariable(Array.get(values, 0));
	for (int i = 1; i < length; i++) {
		transformContext.addSqlPart(", ?");
		transformContext.addBindVariable(Array.get(values, i));
	}
	transformContext.addSqlPart(")/*").addSqlPart(expression).addSqlPart("*/");
	transformContext.addBindName(expression);
}
 

import java.lang.reflect.Array; //导入方法依赖的package包/类
@Override
public Serializable disassemble(CollectionPersister persister) throws HibernateException {
	final int length = Array.getLength( array );
	final Serializable[] result = new Serializable[length];
	for ( int i=0; i<length; i++ ) {
		result[i] = persister.getElementType().disassemble( Array.get( array,i ), getSession(), null );
	}

	return result;
}
 

import java.lang.reflect.Array; //导入方法依赖的package包/类
@SuppressWarnings("rawtypes")
protected Object getArrayItem(final Object currentObject, int index) {
    if (currentObject == null) {
        return null;
    }

    if (currentObject instanceof List) {
        List list = (List) currentObject;

        if (index >= 0) {
            if (index < list.size()) {
                return list.get(index);
            }
            return null;
        } else {
            if (Math.abs(index) <= list.size()) {
                return list.get(list.size() + index);
            }
            return null;
        }
    }

    if (currentObject.getClass().isArray()) {
        int arrayLenth = Array.getLength(currentObject);

        if (index >= 0) {
            if (index < arrayLenth) {
                return Array.get(currentObject, index);
            }
            return null;
        } else {
            if (Math.abs(index) <= arrayLenth) {
                return Array.get(currentObject, arrayLenth + index);
            }
            return null;
        }
    }

    throw new UnsupportedOperationException();
}
 

import java.lang.reflect.Array; //导入方法依赖的package包/类
public static MethodCall create(String method, Object param) {
    MethodCall methodCall = new MethodCall();
    methodCall.methodName = method;

    if (param.getClass() == byte[].class) {
        methodCall.params = Collections.singletonList(Param.from(param));
    } else if (param.getClass().isArray()) {
        // Treat param as array of individual parameters
        int length = Array.getLength(param);
        methodCall.params = new ArrayList<>(length);
        for (int i = 0; i < length; i++) {
            methodCall.params.add(Param.from(Array.get(param, i)));
        }
    } else if (param instanceof Iterable) {
        // Treat param as collection of individual parameters
        Iterator iter = ((Iterable) param).iterator();
        methodCall.params = new ArrayList<>();
        while (iter.hasNext()) {
            methodCall.params.add(Param.from(iter.next()));
        }
    } else if (param instanceof Boolean || param instanceof Integer || param instanceof Long || param
            instanceof Double || param instanceof String) {
        methodCall.params = Collections.singletonList(Param.from(param));
    } else {
        // Treat param a an input object of which the fields represent the parameters
        Field[] fields = param.getClass().getDeclaredFields();
        methodCall.params = new ArrayList<>(fields.length);
        for (Field field : fields) {
            if (Modifier.isStatic(field.getModifiers()) || Modifier.isTransient(field.getModifiers())) {
                continue;
            }
            try {
                methodCall.params.add(Param.from(field.get(param)));
            } catch (IllegalAccessException e) {
                throw new RuntimeException(field.getName() + " could not be accessed to read XML-RPC param");
            }
        }
    }
    return methodCall;
}
 

import java.lang.reflect.Array; //导入方法依赖的package包/类
/**
 * @param name context of result
 * @param result
 */
protected void echoResult(String name, Object result) {
    if (isEcho()) {
        if (result.getClass().isArray()) {
            for (int i = 0; i < Array.getLength(result); i++) {
                handleOutput(name + "." + i + "=" + Array.get(result, i));
            }
        } else
            handleOutput(name + "=" + result);
    }
}
 

import java.lang.reflect.Array; //导入方法依赖的package包/类
private void assertEQ(T t, Object returned) {
    if (rtype.isArray()) {
        Asserts.assertEQ(t.getClass(), returned.getClass());
        int n = Array.getLength(t);
        Asserts.assertEQ(n, Array.getLength(returned));
        for (int i = 0; i < n; ++i) {
            Asserts.assertEQ(Array.get(t, i), Array.get(returned, i));
        }
    } else {
        Asserts.assertEQ(t, returned);
    }
}
 

import java.lang.reflect.Array; //导入方法依赖的package包/类
private void writeObject(JsonGenerator jg, Object value) throws IOException {
  if(value == null) {
    jg.writeNull();
  } else {
    Class<?> c = value.getClass();
    if (c.isArray()) {
      jg.writeStartArray();
      int len = Array.getLength(value);
      for (int j = 0; j < len; j++) {
        Object item = Array.get(value, j);
        writeObject(jg, item);
      }
      jg.writeEndArray();
    } else if(value instanceof Number) {
      Number n = (Number)value;
      jg.writeNumber(n.toString());
    } else if(value instanceof Boolean) {
      Boolean b = (Boolean)value;
      jg.writeBoolean(b);
    } else if(value instanceof CompositeData) {
      CompositeData cds = (CompositeData)value;
      CompositeType comp = cds.getCompositeType();
      Set<String> keys = comp.keySet();
      jg.writeStartObject();
      for(String key: keys) {
        writeAttribute(jg, key, cds.get(key));
      }
      jg.writeEndObject();
    } else if(value instanceof TabularData) {
      TabularData tds = (TabularData)value;
      jg.writeStartArray();
      for(Object entry : tds.values()) {
        writeObject(jg, entry);
      }
      jg.writeEndArray();
    } else {
      jg.writeString(value.toString());
    }
  }
}
 

import java.lang.reflect.Array; //导入方法依赖的package包/类
/**
 * {@link Arrays#toString(Object[])} with {@link Arrays#toString(Object[])} for array elements.
 */
public static Object arrayToString(final Object obj) {
    if (obj != null && obj.getClass().isArray()) {
        final int len = Array.getLength(obj);
        final String[] strings = new String[len];
        for (int i = 0; i < len; i++) {
            strings[i] = String.valueOf(Array.get(obj, i));
        }
        return Arrays.toString(strings);
    } else {
        return obj;
    }
}
 

import java.lang.reflect.Array; //导入方法依赖的package包/类
/**
 * @see PersistentCollection#entries
 */
public Iterator elements() {
	//if (array==null) return tempList.iterator();
	int length = Array.getLength(array);
	java.util.List list = new ArrayList(length);
	for (int i=0; i<length; i++) {
		list.add( Array.get(array, i) );
	}
	return list.iterator();
}
 

import java.lang.reflect.Array; //导入方法依赖的package包/类
private static boolean isEmptyObject(Object object){
	if(object == null){
		return true;
	}else if(object instanceof String){
		return ((String)object).trim().equals("") || ((String)object).trim().equals("null");
	}else if(object instanceof Collection<?>){
		return ((Collection<?>)object).isEmpty();
	}else if(object instanceof Map<?,?>){
		return ((Map<?,?>)object).isEmpty();
	}else if(object.getClass().isArray()){
		return Array.getLength(object) == 0;
	}else{
		return false;
	}
}
 

import java.lang.reflect.Array; //导入方法依赖的package包/类
public static void testOK(Class<?> expectClass, int expectLen, Callable<Object> test) throws Exception {
    for (int c = 0; c < ITERS; c++) {
        Object res = test.call();
        Class<?> actualClass = res.getClass();
        if (!actualClass.equals(expectClass)) {
            throw new IllegalStateException("Wrong class: expected = " + expectClass + ", but got " + actualClass);
        }
        int actualLen = Array.getLength(res);
        if (actualLen != expectLen) {
            throw new IllegalStateException("Wrong length: expected = " + expectLen + ", but got " + actualLen);
        }
    }
}
 

import java.lang.reflect.Array; //导入方法依赖的package包/类
/**
 * Construct a JSONArray from an array
 *
 * @throws JSONException
 *             If not an array.
 */
public JSONArray(Object array) throws JSONException {
    this();
    if (array.getClass().isArray()) {
        int length = Array.getLength(array);
        for (int i = 0; i < length; i += 1) {
            this.put(JSONObject.wrap(Array.get(array, i)));
        }
    } else {
        throw new JSONException(
                "JSONArray initial value should be a string or collection or array.");
    }
}