java名称数组如何设置_java数组操作

@Bizlet("数据对象扩展运算逻辑")

public class DataObjectExt {

private DataObjectExt(){

//工具类不能实例化

}

/**

* 将变长的源数组内容添加到目标Xpath数组

* @param targetXpath 目标数组的xpath

* @param sourceXpath 变长的源数组Xpath

*/

@Bizlet(

value="将变长的源数组内容添加到目标Xpath数组",

params = {

@BizletParam(index = 0, type = ParamType.CONSTANT,paramAlias="targetXpath"),

@BizletParam(index=1,type=ParamType.CONSTANT,paramAlias="strings")

}

)

public static void appendObject(String targetXpath,String...sourceXpath){

for(String xpath:sourceXpath){

appendObject(targetXpath,xpath);

}

}

/**

* 将源数组添加到目标Xpath数组

* @param targetXpath 目标数组的xpath名称

* @param dataObjects 源对象数组

*/

private static void appendObject(String targetXpath,String sourceXpath){

IDataContext context=DataContextManager.current().getDefaultContext();

Object[] sourceObjects=convertObjectArray(context.get(sourceXpath));

if(sourceObjects==null||sourceObjects.length==0)

return ;

Object[] targetObjects=convertObjectArray(context.get(targetXpath));

if(targetObjects==null||targetObjects.length==0){

targetObjects=new DataObject[sourceObjects.length];

System.arraycopy(sourceObjects, 0, targetObjects, 0, sourceObjects.length);

}else{

//临时交换变量

Object[] temp=new Object[targetObjects.length];

System.arraycopy(targetObjects, 0, temp, 0, targetObjects.length);

targetObjects=new Object[targetObjects.length+sourceObjects.length];

System.arraycopy(temp, 0, targetObjects, 0, temp.length);

System.arraycopy(sourceObjects, 0, targetObjects, temp.length, sourceObjects.length);

}

context.set(targetXpath, targetObjects);

}

private static Object[] convertObjectArray(Object object){

Object[] target=null;

if(object instanceof Collection){

Collection> collection=(Collection)object;

target=(Object[])collection.toArray(new Object[collection.size()]);

}else if(object instanceof Object[]){

target=(Object[])object;

}

return target;

}

/**

* 获取指定不重复属性值的数组

* @param xpath 目标数组的xpath

* @param propertyName 指定不重复的属性值

* @return 返回不重复属性值的对象数组

*/

@Bizlet(

value="获取指定不重复属性值的数组",

params = {

@BizletParam(index = 0, type = ParamType.CONSTANT,paramAlias="xpath"),

@BizletParam(index = 1, type = ParamType.CONSTANT,paramAlias="propertyName")

}

)

@SuppressWarnings("unchecked")

public static void getUniqueObjects(String xpath,final String propertyName){

IDataContext context=DataContextManager.current().getDefaultContext();

Object[] target=convertObjectArray(context.get(xpath));

if( target!=null && target.length>0) {

List targetList=Arrays.asList(target);

java.util.Collections.sort(targetList, new Comparator() {

public int compare(final Object o1, final Object o2){

final DataObject m1 = (DataObject)o1;

final DataObject m2 = (DataObject)o2;

if(m1.get(propertyName)!=null&&m2.get(propertyName)!=null){

final String order1=m1.get(propertyName).toString();

final String order2=m2.get(propertyName).toString();

return order1.compareTo(order2);

}

return 0;

}

});

Object value=null;

List result=new ArrayList();

for(Iterator it = targetList.iterator(); it.hasNext();) {

DataObject obj=(DataObject)it.next();

if(obj.get(propertyName)!=null&&obj.get(propertyName).equals(value)){

//it.remove()不能使用，从Arrays.asList的数组是不可修改的!!!

}else{

result.add(obj);

value=obj.get(propertyName);

}

}

context.set(xpath, (Object[])result.toArray(new Object[result.size()]));

}

}

/**

* 向当前DataContext中的数组对象或者list对象添加DataObject对象

* 如果对应的PropertyName已经存在，则不添加;如果propertyName为null则不检查对象的属性是否重复

* @param xpath DataObject数组或者list所在xpath。

* @param dataObject 需要添加的DataObject对象。

* @param propertyName 检查DataObject对象实体名的属性值是否已经存在数组中。

*/

@SuppressWarnings("unchecked")

@Bizlet(

value="添加不重复的数据对象到目标Xpath数组",

params = {

@BizletParam(index = 0, type = ParamType.CONSTANT,paramAlias="xpath"),

@BizletParam(index=1,type=ParamType.VARIABLE,paramAlias="dataObject"),

@BizletParam(index = 2, type = ParamType.CONSTANT,paramAlias="propertyName")

}

)

public static void appendObject(String xpath, DataObject dataObject,String propertyName) {

if (null == dataObject)

return ;

IDataContext ctx=DataContextManager.current().getDefaultContext();

DataObject[] target=null;

DataObject[] dataObjects=(DataObject[])ctx.get(xpath);

if(propertyName!=null&&isDuplicateProperty(dataObjects,dataObject,propertyName)){

return ;

}

int length = (dataObjects == null) ? 0 : Array.getLength(dataObjects);

target = new DataObject[length + 1];

for (int i = 0; i

target[i] = (DataObject) Array.get(dataObjects, i);

target[length] = dataObject;

ctx.set(xpath, target);

}

/**

* 判断目标数组中的对象是否存在与源对象中相同的属性值

* @param targets 目标数组

* @param source 源对象

* @param propertyName 属性名

* @return 存在返回true,不存在返回false

*/

private static boolean isDuplicateProperty(DataObject[] targets,DataObject source,String propertyName){

if(source==null||source.get(propertyName)==null)

return false;

if(targets!=null&&targets.length>0){

for(int i=0;i

if(source.get(propertyName).equals(targets[i].get(propertyName))){

return true;

}

}

}

return false;

}

/**

* 不设置数据对象指定的属性值

* @param dataobject DataObject数据对象

* @param properties 属性名称动态数组

*/

@Bizlet(

value="不设置数据对象指定的属性",

params = {

@BizletParam(index = 0, type = ParamType.VARIABLE,paramAlias="dataObject"),

@BizletParam(index=1,type=ParamType.VARIABLE,paramAlias="properties")

}

)

public static void unSetProperties(DataObject dataobject, String... properties){

for(String propertyName:properties){

dataobject.unset(propertyName);

}

}

/**

* 不设置数据对象指定的属性,如果当前xpath的对象为集合或对象数组,则有相同属性的全部不设置属性值

* @param xpath 数据对象的xpath

* @param properties 属性名称动态数组

*/

@Bizlet(

value="不设置数据对象指定的属性",

params = {

@BizletParam(index = 0, type = ParamType.CONSTANT,paramAlias="xpath"),

@BizletParam(index=1,type=ParamType.VARIABLE,paramAlias="properties")

}

)

public static void unSetProperties(String xpath,String... properties){

IDataContext context=DataContextManager.current().getDefaultContext();

Object obj=context.get(xpath);

if(obj instanceof java.util.Collection){

java.util.Collection> collection=(java.util.Collection)obj;

context.set(xpath, unSetProperties((DataObject[])collection.toArray(new DataObject[collection.size()]),properties));

}

else if(obj instanceof DataObject[]){

DataObject[] dataObjects=(DataObject[])obj;

context.set(xpath, unSetProperties(dataObjects,properties));

}else if(obj instanceof DataObject){

DataObject dataObject=(DataObject)obj;

for(String propertyName:properties)

dataObject.unset(propertyName);

context.set(xpath, obj);

}

}

/**

* 清除数据对象的所有属性值

* @param dataObject DataObject对象

*/

@Bizlet(

value="清除数据对象的所有属性值",

params = {

@BizletParam(index = 0, type = ParamType.VARIABLE,paramAlias="dataObject"),

}

)

public static void cleanProperties(DataObject dataObject){

Iterator properties=dataObject.getType().getProperties().iterator();

while(properties.hasNext()){

Property property=(Property)properties.next();

dataObject.unset(property);

}

}

private static DataObject[] unSetProperties(DataObject[] obj,String... properties){

DataObject[] dataObjects=(DataObject[])obj;

List result=new ArrayList();

for(DataObject array:dataObjects){

for(String propertyName:properties){

array.unset(propertyName);

}

result.add(array);

}

return (DataObject[])result.toArray(new DataObject[result.size()]);

}

}