List of usage examples for org.apache.commons.lang ArrayUtils clone
public static boolean[] clone(boolean[] array)
Clones an array returning a typecast result and handling null.
From source file:net.sourceforge.vulcan.shell.ShellProjectConfig.java
@Override public BaseDto copy() { final ShellProjectConfig copy = (ShellProjectConfig) super.copy(); copy.setArguments((String[]) ArrayUtils.clone(arguments)); copy.setEnvironmentVariables((String[]) ArrayUtils.clone(environmentVariables)); return copy;//from w ww . j ava 2 s .c om }
From source file:nqueenproblem.NQueenProblem.java
/** * @param args the command line arguments *///from w w w . ja v a 2s.c o m public static void main(String[] args) { // TODO code application logic here Random r = new Random(); //// // queenSet trya = new queenSet(4); // trya.array[0] = 2; // trya.array[1] = 1; // trya.array[2] = 0; // trya.array[3] = 3; // // queenSet trya1 = new queenSet(4); // trya1.array[0] = 2; // trya1.array[1] = 3; // trya1.array[2] = 0; // trya1.array[3] = 1; // // System.out.println(fitness(trya.array)); // System.out.println(fitness(trya1.array)); // // queenSet a = new queenSet(4); // queenSet b = new queenSet(4); // a.array = ArrayUtils.clone(trya.array); // b.array = ArrayUtils.clone(trya1.array); // // // int k = 0 ; // for (int i = a.array.length / 2; i < a.array.length || k < a.array.length/2; i++) { // if (i == a.array.length) { // i = 0; // } // boolean temp = true; // for (int j = 0; j < b.array.length / 2; j++) { // if (a.array[i] == b.array[j]) { // temp = false; // break; // // } // // } // if(temp) // b.array[k++] = a.array[i]; // // } // // k = 0 ; // for (int i = b.array.length / 2; i < b.array.length || k < b.array.length/2; i++) { // if (i == b.array.length) { // i = 0; // } // boolean temp = true; // for (int j = 0; j < a.array.length / 2; j++) { // if (b.array[i] == a.array[j]) { // temp = false; // break; // // } // // } // if(temp) // a.array[k++] = b.array[i]; // // } // for (int j = 0, k = 4 / 2; j < 4 / 2 && k < 4; j++, k++) { // a.array[k] = getDiff(trya1.array, trya.array, k); // b.array[j] = getDiff(trya.array, trya1.array, k); // // System.out.println("--------!!!!!!!!"); // // System.out.println(Arrays.toString(trya.array)); // System.out.println(Arrays.toString(trya1.array)); // } // System.out.println(Arrays.toString(a.array)); // System.out.println(Arrays.toString(b.array)); int n = 4; // int initPopCount = 4; //// // ArrayList<queenSet> qu = new ArrayList<>(); //// queenSet[] qu = new queenSet[1000]; // while (true) { //// for (int k = 0; k < 20; k++) { // // qu.add(new queenSet(n)); // // for (int j = 0; j < qu.get(i).array.length; j++) { // int rand = r.nextInt(qu.get(i).array.length); // qu.get(i).array[j] = rand; // } //// System.out.println(Arrays.toString(qu.get(i).array)); // qu.get(i).fx = fitness(qu.get(i).array); //// System.out.println(qu.get(i).fx); //// } // // if (qu.get(i).fx == qu.get(i).array.length) { // System.out.println(Arrays.toString(qu.get(i).array)); // System.out.println(qu.get(i).fx); // System.out.println(i); // break; // } // i++; // // } int initChildCount = 2; double mutationProb = 0.6; queenSet[] result = new queenSet[initPopCount]; // ArrayList arr = new ArrayList(); // queenSet[] initPop = new queenSet[initPopCount]; queenSet[] childPop = new queenSet[initChildCount]; // // for (int j = 0; j < childPop.length; j++) { // childPop[j] = new queenSet(n); // } // for (int o = 0; o < initPopCount; o++) { initPop[o] = new queenSet(n); for (int j = 0; j < initPop[o].array.length; j++) { initPop[o].array[j] = genrateDiffRand(initPop[o].array, n, j); } System.out.println(Arrays.toString(initPop[o].array)); initPop[o].fx = fitness(initPop[o].array); System.out.println(initPop[o].fx); } // int index = 0; //// while (true) { for (int g = 0; g < 10; g++) { queenSet[] selectedParents = new queenSet[2]; selectedParents[0] = initPop[r.nextInt(initPop.length)]; selectedParents[1] = initPop[r.nextInt(initPop.length)]; System.out.println(Arrays.toString(selectedParents[0].array)); System.out.println(Arrays.toString(selectedParents[1].array)); for (int m = 0; m < initChildCount; m += 2) { childPop[m] = selectedParents[0]; childPop[m + 1] = selectedParents[1]; queenSet a = new queenSet(4); queenSet b = new queenSet(4); // System.out.println(childPop[m]); a.array = ArrayUtils.clone(childPop[m].array); b.array = ArrayUtils.clone(childPop[m + 1].array); int k = 0; for (int i = a.array.length / 2; i < a.array.length || k < a.array.length / 2; i++) { if (i == a.array.length) { i = 0; } boolean temp = true; for (int j = 0; j < b.array.length / 2; j++) { if (a.array[i] == b.array[j]) { temp = false; break; } } if (temp) { b.array[k++] = a.array[i]; } System.out.println(i + " " + k); } k = 0; for (int i = b.array.length / 2; i < b.array.length && k < b.array.length / 2; i++) { if (i == b.array.length) { i = 0; } boolean temp = true; for (int j = 0; j < a.array.length; j++) { if (b.array[i] == a.array[j]) { temp = false; break; } if (j == a.array.length) { k++; } } if (temp) { a.array[k++] = b.array[i]; } System.out.println("b"); } childPop[m].array = ArrayUtils.clone(a.array); childPop[m + 1].array = ArrayUtils.clone(b.array); childPop[m].fx = fitness(childPop[m].array); childPop[m + 1].fx = fitness(childPop[m + 1].array); System.out.println(Arrays.toString(childPop[m].array)); System.out.println(Arrays.toString(childPop[m + 1].array)); } System.out.println("Loop se bahar "); queenSet[] tempArray = (queenSet[]) ArrayUtils.addAll(initPop, childPop); for (int j = 0; j < tempArray.length - 1; j++) { for (int k = 0; k < tempArray.length - j - 1; k++) { if (tempArray[k].fx < tempArray[k + 1].fx) { queenSet temp = tempArray[k]; tempArray[k] = tempArray[k + 1]; tempArray[k + 1] = temp; } } } System.out.println("---Sorteddddd-\n\n"); for (int j = 0; j < tempArray.length; j++) { System.out.println(Arrays.toString(tempArray[j].array)); System.out.println(tempArray[j].fx); } System.out.println("---"); initPop = Arrays.copyOfRange(tempArray, 0, initPopCount); arr.add(initPop[0].fx); result = initPop; if (result[0].fx == 4) { break; } } System.out.println(Arrays.toString(result[0].array)); System.out.println(result[0].fx); }
From source file:org.apache.cassandra.db.clock.IncrementCounterContextTest.java
@Test public void testDiff() { byte[] left = new byte[HEADER_LENGTH + (3 * stepLength)]; byte[] right; // equality: equal nodes, all counts same icc.writeElementAtStepOffset(left, 0, FBUtilities.toByteArray(3), 3L); icc.writeElementAtStepOffset(left, 1, FBUtilities.toByteArray(6), 2L); icc.writeElementAtStepOffset(left, 2, FBUtilities.toByteArray(9), 1L); right = ArrayUtils.clone(left); assert ClockRelationship.EQUAL == icc.diff(left, right); // greater than: left has superset of nodes (counts equal) left = new byte[HEADER_LENGTH + (4 * stepLength)]; icc.writeElementAtStepOffset(left, 0, FBUtilities.toByteArray(3), 3L); icc.writeElementAtStepOffset(left, 1, FBUtilities.toByteArray(6), 2L); icc.writeElementAtStepOffset(left, 2, FBUtilities.toByteArray(9), 1L); icc.writeElementAtStepOffset(left, 3, FBUtilities.toByteArray(12), 0L); right = new byte[HEADER_LENGTH + (3 * stepLength)]; icc.writeElementAtStepOffset(right, 0, FBUtilities.toByteArray(3), 3L); icc.writeElementAtStepOffset(right, 1, FBUtilities.toByteArray(6), 2L); icc.writeElementAtStepOffset(right, 2, FBUtilities.toByteArray(9), 1L); assert ClockRelationship.GREATER_THAN == icc.diff(left, right); // less than: left has subset of nodes (counts equal) left = new byte[HEADER_LENGTH + (3 * stepLength)]; icc.writeElementAtStepOffset(left, 0, FBUtilities.toByteArray(3), 3L); icc.writeElementAtStepOffset(left, 1, FBUtilities.toByteArray(6), 2L); icc.writeElementAtStepOffset(left, 2, FBUtilities.toByteArray(9), 1L); right = new byte[HEADER_LENGTH + (4 * stepLength)]; icc.writeElementAtStepOffset(right, 0, FBUtilities.toByteArray(3), 3L); icc.writeElementAtStepOffset(right, 1, FBUtilities.toByteArray(6), 2L); icc.writeElementAtStepOffset(right, 2, FBUtilities.toByteArray(9), 1L); icc.writeElementAtStepOffset(right, 3, FBUtilities.toByteArray(12), 0L); assert ClockRelationship.LESS_THAN == icc.diff(left, right); // greater than: equal nodes, but left has higher counts left = new byte[HEADER_LENGTH + (3 * stepLength)]; icc.writeElementAtStepOffset(left, 0, FBUtilities.toByteArray(3), 3L); icc.writeElementAtStepOffset(left, 1, FBUtilities.toByteArray(6), 2L); icc.writeElementAtStepOffset(left, 2, FBUtilities.toByteArray(9), 3L); right = new byte[HEADER_LENGTH + (3 * stepLength)]; icc.writeElementAtStepOffset(right, 0, FBUtilities.toByteArray(3), 3L); icc.writeElementAtStepOffset(right, 1, FBUtilities.toByteArray(6), 2L); icc.writeElementAtStepOffset(right, 2, FBUtilities.toByteArray(9), 1L); assert ClockRelationship.GREATER_THAN == icc.diff(left, right); // less than: equal nodes, but right has higher counts left = new byte[HEADER_LENGTH + (3 * stepLength)]; icc.writeElementAtStepOffset(left, 0, FBUtilities.toByteArray(3), 3L); icc.writeElementAtStepOffset(left, 1, FBUtilities.toByteArray(6), 2L); icc.writeElementAtStepOffset(left, 2, FBUtilities.toByteArray(9), 3L); right = new byte[HEADER_LENGTH + (3 * stepLength)]; icc.writeElementAtStepOffset(right, 0, FBUtilities.toByteArray(3), 3L); icc.writeElementAtStepOffset(right, 1, FBUtilities.toByteArray(6), 9L); icc.writeElementAtStepOffset(right, 2, FBUtilities.toByteArray(9), 3L); assert ClockRelationship.LESS_THAN == icc.diff(left, right); // disjoint: right and left have disjoint node sets left = new byte[HEADER_LENGTH + (3 * stepLength)]; icc.writeElementAtStepOffset(left, 0, FBUtilities.toByteArray(3), 1L); icc.writeElementAtStepOffset(left, 1, FBUtilities.toByteArray(4), 1L); icc.writeElementAtStepOffset(left, 2, FBUtilities.toByteArray(9), 1L); right = new byte[HEADER_LENGTH + (3 * stepLength)]; icc.writeElementAtStepOffset(right, 0, FBUtilities.toByteArray(3), 1L); icc.writeElementAtStepOffset(right, 1, FBUtilities.toByteArray(6), 1L); icc.writeElementAtStepOffset(right, 2, FBUtilities.toByteArray(9), 1L); assert ClockRelationship.DISJOINT == icc.diff(left, right); left = new byte[HEADER_LENGTH + (3 * stepLength)]; icc.writeElementAtStepOffset(left, 0, FBUtilities.toByteArray(3), 1L); icc.writeElementAtStepOffset(left, 1, FBUtilities.toByteArray(4), 1L); icc.writeElementAtStepOffset(left, 2, FBUtilities.toByteArray(9), 1L); right = new byte[HEADER_LENGTH + (3 * stepLength)]; icc.writeElementAtStepOffset(right, 0, FBUtilities.toByteArray(2), 1L); icc.writeElementAtStepOffset(right, 1, FBUtilities.toByteArray(6), 1L); icc.writeElementAtStepOffset(right, 2, FBUtilities.toByteArray(12), 1L); assert ClockRelationship.DISJOINT == icc.diff(left, right); // disjoint: equal nodes, but right and left have higher counts in differing nodes left = new byte[HEADER_LENGTH + (3 * stepLength)]; icc.writeElementAtStepOffset(left, 0, FBUtilities.toByteArray(3), 1L); icc.writeElementAtStepOffset(left, 1, FBUtilities.toByteArray(6), 3L); icc.writeElementAtStepOffset(left, 2, FBUtilities.toByteArray(9), 1L); right = new byte[HEADER_LENGTH + (3 * stepLength)]; icc.writeElementAtStepOffset(right, 0, FBUtilities.toByteArray(3), 1L); icc.writeElementAtStepOffset(right, 1, FBUtilities.toByteArray(6), 1L); icc.writeElementAtStepOffset(right, 2, FBUtilities.toByteArray(9), 5L); assert ClockRelationship.DISJOINT == icc.diff(left, right); left = new byte[HEADER_LENGTH + (3 * stepLength)]; icc.writeElementAtStepOffset(left, 0, FBUtilities.toByteArray(3), 2L); icc.writeElementAtStepOffset(left, 1, FBUtilities.toByteArray(6), 3L); icc.writeElementAtStepOffset(left, 2, FBUtilities.toByteArray(9), 1L); right = new byte[HEADER_LENGTH + (3 * stepLength)]; icc.writeElementAtStepOffset(right, 0, FBUtilities.toByteArray(3), 1L); icc.writeElementAtStepOffset(right, 1, FBUtilities.toByteArray(6), 9L); icc.writeElementAtStepOffset(right, 2, FBUtilities.toByteArray(9), 5L); assert ClockRelationship.DISJOINT == icc.diff(left, right); // disjoint: left has more nodes, but lower counts left = new byte[HEADER_LENGTH + (4 * stepLength)]; icc.writeElementAtStepOffset(left, 0, FBUtilities.toByteArray(3), 2L); icc.writeElementAtStepOffset(left, 1, FBUtilities.toByteArray(6), 3L); icc.writeElementAtStepOffset(left, 2, FBUtilities.toByteArray(9), 1L); icc.writeElementAtStepOffset(left, 3, FBUtilities.toByteArray(12), 1L); right = new byte[HEADER_LENGTH + (3 * stepLength)]; icc.writeElementAtStepOffset(right, 0, FBUtilities.toByteArray(3), 4L); icc.writeElementAtStepOffset(right, 1, FBUtilities.toByteArray(6), 9L); icc.writeElementAtStepOffset(right, 2, FBUtilities.toByteArray(9), 5L); assert ClockRelationship.DISJOINT == icc.diff(left, right); // disjoint: left has less nodes, but higher counts left = new byte[HEADER_LENGTH + (3 * stepLength)]; icc.writeElementAtStepOffset(left, 0, FBUtilities.toByteArray(3), 5L); icc.writeElementAtStepOffset(left, 1, FBUtilities.toByteArray(6), 3L); icc.writeElementAtStepOffset(left, 2, FBUtilities.toByteArray(9), 2L); right = new byte[HEADER_LENGTH + (4 * stepLength)]; icc.writeElementAtStepOffset(right, 0, FBUtilities.toByteArray(3), 4L); icc.writeElementAtStepOffset(right, 1, FBUtilities.toByteArray(6), 3L); icc.writeElementAtStepOffset(right, 2, FBUtilities.toByteArray(9), 2L); icc.writeElementAtStepOffset(right, 3, FBUtilities.toByteArray(12), 1L); assert ClockRelationship.DISJOINT == icc.diff(left, right); // disjoint: mixed nodes and counts left = new byte[HEADER_LENGTH + (3 * stepLength)]; icc.writeElementAtStepOffset(left, 0, FBUtilities.toByteArray(3), 5L); icc.writeElementAtStepOffset(left, 1, FBUtilities.toByteArray(6), 2L); icc.writeElementAtStepOffset(left, 2, FBUtilities.toByteArray(9), 2L); right = new byte[HEADER_LENGTH + (4 * stepLength)]; icc.writeElementAtStepOffset(right, 0, FBUtilities.toByteArray(3), 4L); icc.writeElementAtStepOffset(right, 1, FBUtilities.toByteArray(6), 3L); icc.writeElementAtStepOffset(right, 2, FBUtilities.toByteArray(9), 2L); icc.writeElementAtStepOffset(right, 3, FBUtilities.toByteArray(12), 1L); assert ClockRelationship.DISJOINT == icc.diff(left, right); left = new byte[HEADER_LENGTH + (4 * stepLength)]; icc.writeElementAtStepOffset(left, 0, FBUtilities.toByteArray(3), 5L); icc.writeElementAtStepOffset(left, 1, FBUtilities.toByteArray(6), 2L); icc.writeElementAtStepOffset(left, 2, FBUtilities.toByteArray(7), 2L); icc.writeElementAtStepOffset(left, 3, FBUtilities.toByteArray(9), 2L); right = new byte[HEADER_LENGTH + (3 * stepLength)]; icc.writeElementAtStepOffset(right, 0, FBUtilities.toByteArray(3), 4L); icc.writeElementAtStepOffset(right, 1, FBUtilities.toByteArray(6), 3L); icc.writeElementAtStepOffset(right, 2, FBUtilities.toByteArray(9), 2L); assert ClockRelationship.DISJOINT == icc.diff(left, right); }
From source file:org.apache.hadoop.hdfs.util.EnumCounters.java
/** @return the values of counter as a shadow copy of array*/ public long[] asArray() { return ArrayUtils.clone(counters); }
From source file:org.apache.openjpa.azure.beans.PersonBIN_PK.java
public byte[] getCode() { return ArrayUtils.clone(code); }
From source file:org.apache.openjpa.azure.beans.PersonBIN_PK.java
public void setCode(byte[] code) { this.code = ArrayUtils.clone(code); }
From source file:org.debux.webmotion.server.handler.ParametersExtractorHandler.java
protected static ParameterTree toTree(Map<String, Object> parameters) { ParameterTree tree = new ParameterTree(); for (Map.Entry<String, Object> entry : parameters.entrySet()) { String paramName = entry.getKey(); Object paramValue = entry.getValue(); ParameterTree current = tree;//ww w. j a v a 2 s. c o m Matcher matcher = pattern.matcher(paramName); while (matcher.find()) { String name = matcher.group(1); String index = matcher.group(3); ParameterTree next; if (index == null) { Map<String, ParameterTree> object = current.getObject(); if (object == null) { object = new HashMap<String, ParameterTree>(); current.setObject(object); } next = object.get(name); if (next == null) { next = new ParameterTree(); object.put(name, next); } } else { Map<String, List<ParameterTree>> array = current.getArray(); if (array == null) { array = new HashMap<String, List<ParameterTree>>(); current.setArray(array); } List<ParameterTree> list = array.get(name); if (list == null) { list = new ArrayList<ParameterTree>(); array.put(name, list); } int position = new Integer(index); if (position >= 0 && position < list.size()) { next = list.get(position); if (next == null) { next = new ParameterTree(); list.set(position, next); } } else { int fill = position - list.size(); for (int i = 0; i < fill; i++) { list.add(null); } next = new ParameterTree(); list.add(next); } } current = next; } if (paramValue != null) { if (paramValue.getClass().isArray()) { Object[] currentValues = (Object[]) current.getValue(); if (currentValues == null) { current.setValue(ArrayUtils.clone((Object[]) paramValue)); } else { current.setValue(ArrayUtils.addAll(currentValues, (Object[]) paramValue)); } } else { current.setValue(paramValue); } } } return tree; }
From source file:org.diffkit.db.DKDBTable.java
public DKDBTable(String catalog_, String schema_, String tableName_, DKDBColumn[] columns_, DKDBPrimaryKey primaryKey_) {//from w ww. ja v a 2 s . com _catalog = catalog_; _schema = schema_; _tableName = tableName_; _columns = (DKDBColumn[]) ArrayUtils.clone(columns_); Arrays.sort(_columns); _primaryKey = primaryKey_; DKValidate.notNull(_tableName); this.validatePrimaryKey(_primaryKey, _columns); this.ensureRelationships(_columns); }
From source file:org.diffkit.diff.diffor.DKChainDiffor.java
public DKChainDiffor(DKDiffor... diffors_) { _diffors = (DKDiffor[]) ArrayUtils.clone(diffors_); DKValidate.notNull((Object) _diffors); }
From source file:org.displaytag.exception.MissingAttributeException.java
/** * Constructor for MissingAttributeException. * @param source Class where the exception is generated * @param attributeNames String attribute name *//*www . j av a 2s .co m*/ public MissingAttributeException(Class source, String[] attributeNames) { super(source, Messages.getString("MissingAttributeException.msg", //$NON-NLS-1$ new Object[] { ArrayUtils.toString(attributeNames) })); // copy attributes to allow them to be retrieved using getAttributeNames() this.attributes = (String[]) ArrayUtils.clone(attributeNames); }