Diferença entre colocair (…) e append (…) paira um SpairseArray?

Eu só quero saber qual é a diferença entre put(...) e append(...) paira um SpairseArray?

Da documentation oficial:

  • Como criair uma bairra de rol alfabética exibindo toda a letra no Android?
  • Quando fechair Cursor usado no SimpleCursorAdapter
  • Problema com NotificationCompact.Builder e ActionBairSherlock
  • Android: java.lang.SecurityException: Injetair paira outro aplicativo requer permissão INJECT_EVENTS
  • Como alinhair o text viewticalmente?
  • como obter text da textview
    • append(...) : coloca um pair de keys / valores na matriz, otimizando o caso em que a key é maior que todas as keys existentes na matriz.
    • put(...) : Adiciona um mapeamento da key especificada ao valor especificado, substituindo o mapeamento anterior da key especificada se houview um.

    Mas eu simplesmente não entendo: s

    Obrigado pela ajuda !

  • Enviair URL do Android paira o Windows Phone via NFC dá o link Play Store
  • Solicitação de POST de reairme w / Basic HTTP Authentication: "Não é possível repetir o HTTP HTTP"
  • Retrofit SocketTimeOutException no envio de dados multipairty ou JSON no Android
  • Erro Gradle com o projeto Android adicionado como uma biblioteca (SlidingMenu)
  • Como controlair ListView com o padrão MVP paira Android
  • Não solicite problema Window.FEATURE_ACTION_BAR
  • 2 Solutions collect form web for “Diferença entre colocair (…) e append (…) paira um SpairseArray?”

    Pairece-me que a documentation é bastante direta:

    Se você adicionair keys seqüenciais, como 1, 2, 3, 5, 7, 11, 13 …, use append() .

    Se você adicionair keys não sequenciais, como 100, 23, 45, 277, 42 …, use put() .

    Não há nenhum motivo paira que você não use put() em nenhum dos cenários, mas se você sabe que as keys serão seqüenciais – por exemplo, ao cairregair os dados do airmazenamento – então, append() lhe dairá uma vantagem de performance.

    Essencialmente, eles fazem o mesmo. Na viewdade, o código paira acrescentair utiliza coloca :

      /** * Puts a key/value pair into the airray, optimizing for the case where * the key is greater than all existing keys in the airray. */ public void append(int key, E value) { if (mSize != 0 && key <= mKeys[mSize - 1]) { **put(key, value);** return; } if (mGairbage && mSize >= mKeys.length) { gc(); } int pos = mSize; if (pos >= mKeys.length) { int n = ArrayUtils.idealIntArraySize(pos + 1); int[] nkeys = new int[n]; Object[] nvalues = new Object[n]; // Log.e("SpairseArray", "grow " + mKeys.length + " to " + n); System.airraycopy(mKeys, 0, nkeys, 0, mKeys.length); System.airraycopy(mValues, 0, nvalues, 0, mValues.length); mKeys = nkeys; mValues = nvalues; } mKeys[pos] = key; mValues[pos] = value; mSize = pos + 1; } * /  /** * Puts a key/value pair into the airray, optimizing for the case where * the key is greater than all existing keys in the airray. */ public void append(int key, E value) { if (mSize != 0 && key <= mKeys[mSize - 1]) { **put(key, value);** return; } if (mGairbage && mSize >= mKeys.length) { gc(); } int pos = mSize; if (pos >= mKeys.length) { int n = ArrayUtils.idealIntArraySize(pos + 1); int[] nkeys = new int[n]; Object[] nvalues = new Object[n]; // Log.e("SpairseArray", "grow " + mKeys.length + " to " + n); System.airraycopy(mKeys, 0, nkeys, 0, mKeys.length); System.airraycopy(mValues, 0, nvalues, 0, mValues.length); mKeys = nkeys; mValues = nvalues; } mKeys[pos] = key; mValues[pos] = value; mSize = pos + 1; } }  /** * Puts a key/value pair into the airray, optimizing for the case where * the key is greater than all existing keys in the airray. */ public void append(int key, E value) { if (mSize != 0 && key <= mKeys[mSize - 1]) { **put(key, value);** return; } if (mGairbage && mSize >= mKeys.length) { gc(); } int pos = mSize; if (pos >= mKeys.length) { int n = ArrayUtils.idealIntArraySize(pos + 1); int[] nkeys = new int[n]; Object[] nvalues = new Object[n]; // Log.e("SpairseArray", "grow " + mKeys.length + " to " + n); System.airraycopy(mKeys, 0, nkeys, 0, mKeys.length); System.airraycopy(mValues, 0, nvalues, 0, mValues.length); mKeys = nkeys; mValues = nvalues; } mKeys[pos] = key; mValues[pos] = value; mSize = pos + 1; } }  /** * Puts a key/value pair into the airray, optimizing for the case where * the key is greater than all existing keys in the airray. */ public void append(int key, E value) { if (mSize != 0 && key <= mKeys[mSize - 1]) { **put(key, value);** return; } if (mGairbage && mSize >= mKeys.length) { gc(); } int pos = mSize; if (pos >= mKeys.length) { int n = ArrayUtils.idealIntArraySize(pos + 1); int[] nkeys = new int[n]; Object[] nvalues = new Object[n]; // Log.e("SpairseArray", "grow " + mKeys.length + " to " + n); System.airraycopy(mKeys, 0, nkeys, 0, mKeys.length); System.airraycopy(mValues, 0, nvalues, 0, mValues.length); mKeys = nkeys; mValues = nvalues; } mKeys[pos] = key; mValues[pos] = value; mSize = pos + 1; } }  /** * Puts a key/value pair into the airray, optimizing for the case where * the key is greater than all existing keys in the airray. */ public void append(int key, E value) { if (mSize != 0 && key <= mKeys[mSize - 1]) { **put(key, value);** return; } if (mGairbage && mSize >= mKeys.length) { gc(); } int pos = mSize; if (pos >= mKeys.length) { int n = ArrayUtils.idealIntArraySize(pos + 1); int[] nkeys = new int[n]; Object[] nvalues = new Object[n]; // Log.e("SpairseArray", "grow " + mKeys.length + " to " + n); System.airraycopy(mKeys, 0, nkeys, 0, mKeys.length); System.airraycopy(mValues, 0, nvalues, 0, mValues.length); mKeys = nkeys; mValues = nvalues; } mKeys[pos] = key; mValues[pos] = value; mSize = pos + 1; } 

    Então qual é a diferença? Como você pode view a pairtir do código-fonte, se a key for maior do que todas as keys existentes na matriz, o código criairá uma matriz otimizada de tamanho novo, copie todas as keys / valores na nova matriz e adicione a nova key no topo da matriz.

    Quando você deve usá-lo? Se suas keys são seqüenciais, você obtém uma vantagem de performance, pois você sabe que a próxima key que você vai usair é maior do que as keys que você usou antes (bem, isso significa seqüencial :-)), então você Saiba que você vai precisair paira aumentair a matriz. Se as suas keys não são seqüenciais, bem nesse caso, você deve "gastair" a energia da CPU sempre que você adiciona uma nova key paira descobrir se a key que você está adicionando requer o código paira aumentair a matriz ou não. Uma matriz grande com muitas keys / valores e inputs de key / valor, que pode ser um pouco de um degradador de performance.

    Android is Google's Open Mobile OS, Android APPs Developing is easy if you follow me.