Java System.arraycopy方法代码示例

import java.lang.System; //导入方法依赖的package包/类
/***************************************************************
   Function: trunc_col
   Description: Truncates each column to the 'correct' length.
   **************************************************************/
 private void trunc_col
   (
    )
     {
int n;
int i;
CDTrans dtrans;

n = m_spec.m_dtrans_vector.size();
for (i = 0; i < n; ++i)
  {
    int[] ndtrans = new int[m_spec.m_dtrans_ncols];
    dtrans = (CDTrans) m_spec.m_dtrans_vector.elementAt(i);
    System.arraycopy(dtrans.m_dtrans, 0, ndtrans, 0, ndtrans.length);
    dtrans.m_dtrans = ndtrans;
  }
     }
 

import java.lang.System; //导入方法依赖的package包/类
@SuppressWarnings({"unchecked"})
public ArrayListCursor(String[] columnNames, ArrayList<ArrayList> rows) {
    int colCount = columnNames.length;
    boolean foundID = false;
    // Add an _id column if not in columnNames
    for (int i = 0; i < colCount; ++i) {
        if (columnNames[i].compareToIgnoreCase("_id") == 0) {
            mColumnNames = columnNames;
            foundID = true;
            break;
        }
    }

    if (!foundID) {
        mColumnNames = new String[colCount + 1];
        System.arraycopy(columnNames, 0, mColumnNames, 0, columnNames.length);
        mColumnNames[colCount] = "_id";
    }

    int rowCount = rows.size();
    mRows = new ArrayList[rowCount];

    for (int i = 0; i < rowCount; ++i) {
        mRows[i] = rows.get(i);
        if (!foundID) {
            mRows[i].add(i);
        }
    }
}
 

import java.lang.System; //导入方法依赖的package包/类
private void new_block(int idx, int bnum) {
if (size==bits.length) { // resize
    long[] nbits = new long[size*3];
    int [] noffs = new int [size*3];
    System.arraycopy(bits, 0, nbits, 0, size);
    System.arraycopy(offs, 0, noffs, 0, size);
    bits = nbits;
    offs = noffs;
}
CUtility.ASSERT(size<bits.length);
insert_block(idx, bnum);
   }
 

import java.lang.System; //导入方法依赖的package包/类
private void insert_block(int idx, int bnum) {
CUtility.ASSERT(idx<=size);
CUtility.ASSERT(idx==size || offs[idx]!=bnum);
System.arraycopy(bits, idx, bits, idx+1, size-idx);
System.arraycopy(offs, idx, offs, idx+1, size-idx);
offs[idx]=bnum;
bits[idx]=0; //clear them bits.
size++;
   }
 

import java.lang.System; //导入方法依赖的package包/类
private int readIncremental(byte[] buffer, int offset, int length) throws IOException {
  int readLength = 0;
  if (null != overflowBuffer) {
    if (overflowBuffer.length > length) {
      System.arraycopy(overflowBuffer, 0, buffer, offset, length);
      overflowBuffer = Arrays.copyOfRange(overflowBuffer, length, overflowBuffer.length);
      return length;
    } else if (overflowBuffer.length == length) {
      System.arraycopy(overflowBuffer, 0, buffer, offset, length);
      overflowBuffer = null;
      return length;
    } else {
      System.arraycopy(overflowBuffer, 0, buffer, offset, overflowBuffer.length);
      readLength += overflowBuffer.length;
      offset += readLength;
      length -= readLength;
      overflowBuffer = null;
    }
  }

  if (length + totalRead > totalDataSize)
    length = (int)(totalDataSize - totalRead);

  byte[] internalBuffer = new byte[length];
  int read              = super.read(internalBuffer, 0, internalBuffer.length <= cipher.getBlockSize() ? internalBuffer.length : internalBuffer.length - cipher.getBlockSize());
  totalRead            += read;

  try {
    mac.update(internalBuffer, 0, read);

    int outputLen = cipher.getOutputSize(read);

    if (outputLen <= length) {
      readLength += cipher.update(internalBuffer, 0, read, buffer, offset);
      return readLength;
    }

    byte[] transientBuffer = new byte[outputLen];
    outputLen = cipher.update(internalBuffer, 0, read, transientBuffer, 0);
    if (outputLen <= length) {
      System.arraycopy(transientBuffer, 0, buffer, offset, outputLen);
      readLength += outputLen;
    } else {
      System.arraycopy(transientBuffer, 0, buffer, offset, length);
      overflowBuffer = Arrays.copyOfRange(transientBuffer, length, outputLen);
      readLength += length;
    }
    return readLength;
  } catch (ShortBufferException e) {
    throw new AssertionError(e);
  }
}
 

import java.lang.System; //导入方法依赖的package包/类
public static byte[] randombytes(byte [] x, int len) {
   byte [] b = randombytes(len);
   System.arraycopy(b, 0, x, 0, len);
   return x;
}
 

import java.lang.System; //导入方法依赖的package包/类
private static final void binop(SparseBitSet a, SparseBitSet b, BinOp op) {
int  nsize = a.size + b.size;
long[] nbits; 
int [] noffs;
int a_zero, a_size;
// be very clever and avoid allocating more memory if we can.
if (a.bits.length < nsize) { // oh well, have to make working space.
    nbits = new long[nsize];
    noffs = new int [nsize];
    a_zero  = 0; a_size = a.size;
} else { // reduce, reuse, recycle!
    nbits = a.bits;
    noffs = a.offs;
    a_zero = a.bits.length - a.size; a_size = a.bits.length;
    System.arraycopy(a.bits, 0, a.bits, a_zero, a.size);
    System.arraycopy(a.offs, 0, a.offs, a_zero, a.size);
}
// ok, crunch through and binop those sets!
nsize = 0;
for (int i=a_zero, j=0; i<a_size || j<b.size; ) {
    long nb; int no;
    if (i<a_size && (j>=b.size || a.offs[i] < b.offs[j])) {
	nb = op.op(a.bits[i], 0);
	no = a.offs[i];
	i++;
    } else if (j<b.size && (i>=a_size || a.offs[i] > b.offs[j])) {
	nb = op.op(0, b.bits[j]);
	no = b.offs[j];
	j++;
    } else { // equal keys; merge.
	nb = op.op(a.bits[i], b.bits[j]);
	no = a.offs[i];
	i++; j++;
    }
    if (nb!=0) {
	nbits[nsize] = nb;
	noffs[nsize] = no;
	nsize++;
    }
}
a.bits = nbits;
a.offs = noffs;
a.size = nsize;
   }