Java Arrays.sort方法代码示例

import com.sun.squawk.util.Arrays; //导入方法依赖的package包/类
/**
 * Creates a stripped copy of an array of MethodMetadata. The value of <code>metadatas</code>
 * is not modified. The line number tables are stripped if {@link #preserveLineNumberTables}
 * has not been called. The local variable tables are stripped if {@link #preserveLineNumberTables}
 * has not been called.
 *
 * @param metadatas  the array to create a stripped copy of
 * @return the stripped copy of <code>metadatas</code>
 */
static MethodMetadata[] strip(MethodMetadata[] metadatas) {
    if (metadatas != null) {
        if (preserveLineNumberTables || preserveLocalVariableTables) {
            SquawkVector temp = new SquawkVector(metadatas.length);
            for (int i = 0; i != metadatas.length; ++i) {
                MethodMetadata md = metadatas[i];
                if (md != null) {
                    temp.addElement(md.strip(preserveLineNumberTables, preserveLocalVariableTables));
                }
            }
            if (temp.size() == 0) {
                return null;
            }
            
            MethodMetadata[] result = new MethodMetadata[temp.size()];
            temp.copyInto(result);
            Arrays.sort(result, new MethodMetadataComparer());
            return result;
        }
    }
    return null;
}
 

import com.sun.squawk.util.Arrays; //导入方法依赖的package包/类
/**
	 * Installs a collection of IMlet property values into this suite.
	 *
	 * @param property IMlet property to install
	 */
	public void installProperty(ManifestProperty property) {
		checkWrite();
        // There could be more than one manifest property for a given key,
        // as is the case if JAD properties are added, so take this into account
        int index = Arrays.binarySearch(manifestProperties, property.name, ManifestProperty.comparer);
        if (index < 0) {
/*if[ENABLE_VERBOSE]*/	    	    
            if (VM.isVerbose()) {
                System.out.println("[Adding property key: |" + property.name + "| value: |" + property.value + "|]");
            }
/*end[ENABLE_VERBOSE]*/	    	    
            System.arraycopy(manifestProperties, 0, manifestProperties = new ManifestProperty[manifestProperties.length + 1], 0, manifestProperties.length - 1);
            manifestProperties[manifestProperties.length - 1] = property;
            Arrays.sort(manifestProperties, ManifestProperty.comparer);
        } else {
/*if[ENABLE_VERBOSE]*/	    	    
            if (VM.isVerbose()) {
                System.out.println("[Overwriting property key: |" + property.name + "| value: |" + property.value + "|]");
            }
/*end[ENABLE_VERBOSE]*/	    	    
            manifestProperties[index] = property;
        }
	}
 

import com.sun.squawk.util.Arrays; //导入方法依赖的package包/类
/**
 * Sorts an array of fields by the data size of their types in
 * descending order.
 *
 * @param fields  the array of fields to sort
 */
private void sortFields(ClassFileField[] fields) {
    Arrays.sort(fields, new Comparer() {
        public int compare(Object o1, Object o2) {
            if (o1 == o2) {
                return 0;
            }

            Klass t1 = ((ClassFileField)o1).getType();
            Klass t2 = ((ClassFileField)o2).getType();

            /*
             * Sort by data size of field's type
             */
            if (t1.getDataSize() < t2.getDataSize()) {
                return 1;
            } else if (t1.getDataSize() > t2.getDataSize()) {
                return -1;
            } else {
                return 0;
            }
        }
    });
}
 

import com.sun.squawk.util.Arrays; //导入方法依赖的package包/类
protected final void init(INorFlashSectorState[] sectorStates) {
    Arrays.sort(sectorStates, new Comparer() {
        public int compare(Object a, Object b) {
            Address aStart = ((INorFlashSectorState) a).getStartAddress();
            Address bStart = ((INorFlashSectorState) b).getStartAddress();
            if (aStart.eq(bStart)) {
                return 0;
            }
            if (aStart.lo(bStart)) {
                return -1;
            }
            return +1;
        }
    });
    this.sectorStates = sectorStates;
    erasedSequenceCurrentValue = 0;
}
 

import com.sun.squawk.util.Arrays; //导入方法依赖的package包/类
/**
 * Installs a collection of IMlet property values into this suite.
 *
 * @param property IMlet property to install
 */
public void installProperty(ManifestProperty property) {
	checkWrite();
       // There could be more than one manifest property for a given key,
       // as is the case if JAD properties are added, so take this into account
       int index = Arrays.binarySearch(manifestProperties, property.name, ManifestProperty.comparer);
       if (index < 0) {
           if (VM.isVerbose()) {
               System.out.println("[Adding property key: |" + property.name + "| value: |" + property.value + "|]");
           }
           System.arraycopy(manifestProperties, 0, manifestProperties = new ManifestProperty[manifestProperties.length + 1], 0, manifestProperties.length - 1);
           manifestProperties[manifestProperties.length - 1] = property;
           Arrays.sort(manifestProperties, ManifestProperty.comparer);
       } else {
           if (VM.isVerbose()) {
               System.out.println("[Overwriting property key: |" + property.name + "| value: |" + property.value + "|]");
           }
           manifestProperties[index] = property;
       }
}
 

import com.sun.squawk.util.Arrays; //导入方法依赖的package包/类
/**
 * Gets the object table as an array of objects that have been sorted by frequency of access.
 *
 * @return the sorted object array
 */
Object[] getConstantObjectArray() {
    Object[] list = new Object[objectTable.size()];
    Enumeration e = objectTable.elements();
    for (int i = 0 ; i < list.length ; i++) {
        list[i] = e.nextElement();
    }
    Arrays.sort(list, new Comparer() {
        public int compare(Object o1, Object o2) {
            if (o1 == o2) {
                return 0;
            }
            ObjectCounter t1 = (ObjectCounter)o1;
            ObjectCounter t2 = (ObjectCounter)o2;
            if (t1.getIndex() < t2.getIndex()) {
                return -1;
            } else if (t1.getIndex() > t2.getIndex()) {
                return 1;
            } else {
                return 0;
            }
        }
    });

    for (int i = 0 ; i < list.length ; i++) {
        ObjectCounter oc = ((ObjectCounter) list[i]);
        list[i] = oc.getObject();
    }
    return list;
}
 

import com.sun.squawk.util.Arrays; //导入方法依赖的package包/类
/**
 * Gets the bytecode positions in a sorted array.
 *
 * @return the bytecode positions in a sorted array
 */
private Position[] sortPositions() {
    Assert.that(positions != null);
    Position[] sorted = new Position[positions.size()];
    Enumeration e = positions.elements();
    for (int i = 0; i != sorted.length; ++i) {
        sorted[i] = (Position)e.nextElement();
    }
    Arrays.sort(sorted, new Comparer() {
        public int compare(Object o1, Object o2) {
            return ((Position)o1).getBytecodeOffset() - ((Position)o2).getBytecodeOffset();
        }
    });
    return sorted;
}
 

import com.sun.squawk.util.Arrays; //导入方法依赖的package包/类
/**
 * Scan through allocated blocks in all sectors in this MemoryHeap. 
 * Update toBeErasedSectorStateList, inUseSectorStateList, and currentSectorState. Also update the writeHeadPosition for each sector state.
 *    
 * It is guaranteed that the order that blocks were allocated in, is the order in which they will be iterated.
 * 
 * @param scanner operation to perform on each block. May be null.
 * @throws RecordStoreException
 */
public synchronized void scanBlocks(INorFlashMemoryHeapScanner scanner) throws RecordStoreException {
    INorFlashSectorState[] sectorStatesSortedBySequence = new INorFlashSectorState[sectorStates.length];
    System.arraycopy(sectorStates, 0, sectorStatesSortedBySequence, 0, sectorStates.length);
    Arrays.sort(sectorStatesSortedBySequence, new Comparer() {
        public int compare(Object a, Object b) {
            return (int) (((INorFlashSectorState) a).getSequence() - ((INorFlashSectorState) b).getSequence());
        }
    });

    for (int i=0, maxI=sectorStatesSortedBySequence.length, lastI=sectorStatesSortedBySequence.length-1; i < maxI; i++) {
        INorFlashSectorState sectorState;
        sectorState = sectorStatesSortedBySequence[i];
        if (!sectorState.hasErasedHeader()) {
            toBeErasedSectorStateList.addLast(sectorState);
            continue;
        }
        int originalWriteHead =  sectorState.getWriteHeadPosition();
        sectorState.resetHead();
        int offset = sectorState.getWriteHeadPosition();
        MemoryHeapBlock block = new MemoryHeapBlock();
        while (true) {
            if (!getBlockAt(block, sectorState, offset)) {
                break;
            }
            if (block.isAllocated()) {
                sectorState.incrementAllocatedBlockCount();
                if (scanner != null) {
                    scanner.scanBlock(block);
                }
            } else {
                sectorState.incrementFreedBlockCount();
            }
            offset = block.getNextBlockOffset();
        }
        sectorState.setWriteHeadPosition(offset);
        if (i == lastI) {
            currentSectorState = sectorState;
        } else {
            if (sectorState.getAllocatedBlockCount() == 0) {
                toBeErasedSectorStateList.addLast(sectorState);
            } else {
                inUseSectorStateList.addLast(sectorState);
            }
        }
    }
    hasScannedBlocks = true;
}