A classe System.Collection.ArrayList é uma matriz especial. Ao adicionar e remover elementos, o comprimento da matriz pode ser alterado dinamicamente.
um. vantagem
1. Suporta função de mudança de tamanho automático
2. Inserção flexível de elementos
3. Exclusão flexível de elementos
dois. limitação
Comparado com matrizes comuns, a velocidade é um pouco pior
três. Adicione elementos
1. PublicVirtualIntadd (ObjectValue);
Adicionar objeto ao fim do Arraylist
Arraylist alist = new ArrayList (); alist.add ("a"); alist.add ("b"); alist.add ("c"); alist.add ("d"); alist.add ("e");O conteúdo é
ABCDE
2.
Insira o elemento no índice especificado da Arraylist
Arraylist alist = new ArrayList (); alist.add ("a"); alist.add ("b"); alist.add ("c"); alist.add ("d"); alist.add ("e"); alist.Insert (0, "aa");O resultado é
AAABCDE
3.
Insira um elemento na coleção no índice especificado da Arraylist
Arraylist alist = new ArrayList (); alist.add ("a"); alist.add ("b"); alist.add ("c"); alist.add ("d"); alist.add ("e"); Arraylist list2 = newArrayList (); list2.add ("tt"); list2.add ("ttt"); alist.inserTrange (2, list2);O resultado é
ABTTTTTCDE
Quatro. excluir
1.
Remova a primeira partida de um objeto específico de uma lista de Array, observe que é o primeiro
Arraylist alist = new ArrayList (); alist.add ("a"); alist.add ("b"); alist.add ("c"); alist.add ("d"); alist.add ("e"); alist.Rove ("a");O resultado é
bcde
2. PublicVirtualVoidRemoveat (Intindex);
Remove elementos no índice especificado da Arraylist
alist.add ("a"); alist.add ("b"); alist.add ("c"); alist.add ("d"); alist.add ("e"); alist.Removeat (0);O resultado é
bcde
3.
Remove uma variedade de elementos do ArrayList. Índice representa o índice, a contagem representa o número a partir do índice
alist.add ("a"); alist.add ("b"); alist.add ("c"); alist.add ("d"); alist.add ("e"); alist.Removerman (1,3);O resultado é
Copie o código da seguinte maneira: ae
4. PublicVirtualVoidClear ();
Remova todos os elementos da ArrayList.
cinco. Organizar
1.PublicVirtualVoidSort ();
Classifique os elementos em um Arraylist ou parte dele.
ArrayListalist = newArrayList (); alist.add ("e"); alist.add ("a"); alist.add ("b"); alist.add ("c"); alist.Adddn ("d"); suspenso;O resultado é
EABCD
ArrayListalist = newArrayList (); alist.add ("a"); alist.add ("b"); alist.add ("c"); alist.add ("d"); alist.add ("e"); alist.sort (); // classificação Suspenso listado1.dataSource = alist; // suspensoListDropDownList1; suspensoLlist1.databind ();O resultado é
ABCDE
2.PublicVirtualVoidReverse ();
Reverte a ordem dos elementos em uma lista de Array ou parte dela.
ArrayListalist = newArrayList (); alist.add ("a"); alist.add ("b"); alist.add ("c"); alist.add ("d"); alist.add ("e"); alist.ververse (); // reversa Suspenso listado1.dataSource = alist; // suspensoListDropDownList1; suspensoLlist1.databind ();O resultado é
EDCBA
seis. Encontrar
1.PublicVirtualIntIndexOf (objeto);
2.PublicVirtualIntIndexOf (Object, int);
3.PublicVirtualIntIndexOf (objeto, int, int);
Retorna o índice baseado em zero da primeira partida de uma lista de Array ou parte dele. Nenhum retorno -1 foi encontrado.
Arraylist alist = new ArrayList (); alist.add ("A"); alist.add ("b"); alist.add ("C"); alist.add ("d"); alist.add ("e"); intnindex = alist.indexof ("a"); // 1 nindex = alist.indexof ("p"); // não encontrado, -1 4.PublicVirtualIntLastIndexOf (objeto);
5.PublicVirtualIntLastIndexOf (Object, Int);
6.PublicVirtualIntLastIndexOf (Object, int, int);
Retorna o índice baseado em zero da última partida de uma lista de Array ou parte dele.
Arraylist alist = new ArrayList (); alist.add ("A"); alist.add ("b"); alist.add ("a"); // o mesmo que 0 alist.add ("d"); alist.add ("e"); intnindex = alist.lastindexof ("a"); // o valor é 2 em vez de 0 7.PublicVirtualBoolContains (ObjectItem);
Determina se um elemento está em uma lista de Array. Retorne true se incluído, caso contrário, retorne falso
Sete. outro
1. PublicVirtualIntCapacity {get; set;}
Obtém ou define o número de elementos que uma lista de Array pode conter.
2. PublicVirtualIntCount {get;}
Obtém o número de elementos realmente contidos no ArrayList.
Capacidade é o número de elementos que uma lista de Array pode armazenar. A contagem é o número de elementos realmente contidos no ArrayList. A capacidade é sempre maior ou igual à contagem. Se a contagem exceder a capacidade ao adicionar um elemento, a capacidade da lista é dobrada ao realocar automaticamente a matriz interna.
Se o valor da capacidade for definido explicitamente, a matriz interna também precisará ser transferida para acomodar a capacidade especificada. Se a capacidade for explicitamente definida como 0, o tempo de execução do idioma comum o define para sua capacidade padrão. A capacidade padrão é 16.
Depois de ligar para o claro, a contagem é 0 e, neste momento, o corte da capacidade é a capacidade padrão de 16, não 0
3. PublicVirtualVoidTrimtosize ();
Defina a capacidade para o número real de elementos na lista de Array.
Se você não adicionar novos elementos à lista, esse método poderá ser usado para minimizar a sobrecarga do sistema de memória da lista.
Para limpar completamente todos os elementos da lista, ligue para o método claro antes de ligar para Trimtosize. Cortar uma lista de Array -Lista vazia definirá a capacidade da Arraylist para a capacidade padrão, não zero.
Arraylist alist = new ArrayList (); alist.add ("a"); alist.add ("b"); alist.add ("c"); alist.add ("d"); alist.add ("e"); // count = 5, = 16, alist.Trimtose (); // "); 8. Análise do código -fonte
Uma classe de implementação da interface da lista usa internamente uma matriz para armazenar valores de elementos, que é equivalente a uma matriz de tamanho variável.
1. Assinatura
Public Class ArrayList <e> estende a lista de implementos abstrata -list <e>
Você pode ver que o ArrayList herda a classe abstrata abstrata, que implementa a maioria dos métodos da interface da lista. Se você deseja implementar uma lista imutável, basta herdar esta classe e implementar os métodos get (int) e tamanho. Se você deseja implementar uma lista mutável, precisará substituir o conjunto (int, e). Além disso, se o tamanho da lista for variável, os métodos Add (int, e) e remover () também devem ser substituídos.
2. Construtor
Arraylist fornece três construtores:
ArrayList () ArrayList (coleção <? Extends e> C) ArrayList (int InitialCapacity)
A Convenção da Interface de Coleta que cada classe de coleta deve fornecer dois construtores "padrão", um é um construtor sem parâmetros (o primeiro acima) e o outro é um construtor com um único parâmetro (o segundo acima). A ArrayList também fornece um terceiro construtor que aceita um valor int para definir o tamanho inicial do Arrayli (o tamanho padrão é 10).
3. Métodos relacionados
Trimtosizepublic void TRIMTOSIZE () {modCount ++; int OldCapacity = ElementData.Length; if (size <OldCapacity) {ElementData = Arrays.copyof (elementData, tamanho); }}Usado para reduzir a capacidade da Arraylist ao seu tamanho real atual e reduzir a capacidade de armazenamento. O ModCount variável é herdado da AbstractList, registrando o número de vezes que a lista é estruturalmente modificada. O elemento do Arraylist é realmente armazenado em elementData, que é declarado como: objeto transitório privado [] elementData; Tamanho variável é o número de elementos do Arraylist. Quando tamanho <antigo capacidade, ligue para o método ARRAYS.COPYOF para obter redução.
4.IndexOF e LasindexOF
public int indexof (objeto o) {if (o == null) {for (int i = 0; i <tamanho; i ++) if (elementData [i] == null) retornar i; } else {for (int i = 0; i <tamanho; i ++) se (o.equals (elementData [i])) retornar i; } retornar -1; }Esses dois métodos retornam o subscrito do elemento especificado e queremos distinguir se o parâmetro é nulo. O LastIndexOF é semelhante ao indexOF, mas pesquisando por trás para a frente.
5
public void EnsureCapacity (int mincapacity) {if (Mincapacity> 0) SecurEcApacityInternal (MinCapacity); } vazio privado EnsureCapacityInternal (int mincapacity) {modCount ++; // Código consciente de transbordamento if (Mincapacity - ElementData.Length> 0) Grow (MinCapacity); } Void privado Grow (int mincapacity) {// Código consciente do Overflow int OldCapacity = ElementData.length; int newCapacity = OldCapacity + (OldCapacity >> 1); if (newCapacity - MinCapacity <0) newCapacity = Mincapacity; if (newCapacity - max_array_size> 0) newCapacity = hugecapacity (mincapacidade); // MinCapacity geralmente é próximo do tamanho, então isso é uma vitória: elementData = Arrays.copyof (ElementData, NewCapacity); }Este método garante o tamanho da Arraylist
6.Add e addall
public void add (int index, e elemento) {rangucheckforadd (index); garantir o internal (tamanho + 1); // incrementos modCount !! System.ArrayCopy (ElementData, Index, ElementData, índice + 1, tamanho - índice); elementData [index] = elemento; tamanho ++; } Adicionar (índice int, e elemento e adicionar um elemento à posição especificada. Primeiro, ligue para RangecheckForAdd para verificar se o índice é válido. Se índice> tamanho || ÍNDICE <0, uma exceção será lançada. Em seguida, verifique se a capacidade é aumentada em 1 e ligue para o sistema.ArrayCopy para mover o elemento a partir do índice uma posição para trás. Finalmente, defina o valor no índice como o elemento adicionado. Há também um método de add (e) sobrecarregado que adiciona diretamente o elemento ao final.
Addall (coleção <? Extende e> c) e Addall (índice int, coleta <? Extends e> c) Adicione todos os elementos na coleção ao final e nas posições especificadas, respectivamente.
7.Remove e removelando
public boolean Remover (objeto o) {if (o == null) {for (int index = 0; index <size; index ++) if (elementData [index] == null) {fastremove (index); retornar true; }} else {for (int index = 0; index <size; index ++) if (o.equals (elementData [index])) {fastremove (index); retornar true; }} retornar false; }O método Remover (objeto O) exclui o elemento especificado. Primeiro, procure o local do elemento e depois ligue para Fastremove (Index) para excluí -lo. O código é o seguinte:
private void fastremove (int index) {modCount ++; int numMoved = size - índice - 1; if (numMoved> 0) // mova todos os elementos por trás do índice+1 One Position Forward System.arrayCopy (ElementData, Index+1, ElementData, Index, numMoved); elementData [-size] = null; // Deixe o GC fazer seu trabalho} O método Remover Remover (Int Index) sobrecarregado é usado para excluir elementos no local especificado. A remoção (int a partir do Index, int toIndex) é usada para excluir todos os elementos entre os locais especificados.
Removeall (coleção <?> C) e RETINALALL (Coleção <?> C) Códigos são os seguintes:
public boolean Removeall (coleção <?> c) {objects.RequirenOnnull (c); Retornar BatchRemove (C, falso); } public boolean reternalall (coleção <?> c) {objects.requiirenonnull (c); retornar BatchRemove (C, True); }Todos eles são implementados chamando o método BatchRemove, e seu código é o seguinte:
Private Boolean BatchRemove (coleção <?> C, complemento booleano) {Final Object [] elementData = this.ElementData; int r = 0, w = 0; booleano modificado = false; tente {for (; r <size; r ++) if (c.contains (elementData [r]) == complement) elementData [w ++] = elementData [r]; } finalmente {// preserva a compatibilidade comportamental com o abstractCollection, // mesmo se c.contains () lança. if (r! = size) {System.ArrayCopy (ElementData, R, ElementData, W, Size - R); w += tamanho - r; } if (w! = size) {// limpe para deixar o gc fazer seu trabalho para (int i = w; i <tamanho; i ++) elementData [i] = null; modCount += tamanho - w; tamanho = w; modificado = true; }} retornar modificado; }Este método possui dois parâmetros. A primeira é a coleção de operações e a segunda é um valor booleano. Ao defini -lo como verdadeiro ou falso, ele seleciona se deve remover ou reter. A declaração em Try coloca os restantes entre 0 e W e, finalmente, o segundo, se finalmente lida com o espaço após W, e o primeiro é executado quando C.Contains () lança uma exceção.