A cópia do código é a seguinte:
importar java.util.arrays;
/**
* Implementação de tabelas lineares seqüenciais
*/
classe pública LineList <E> {
Tamanho privado int; // Comprimento
objeto privado [] matriz; // a matriz subjacente
private final int default_length = 16; // Comprimento padrão
/**
* Método de construção não parâmetro
*/
public lineList () {
tamanho = 0;
// Construa uma matriz usando o comprimento padrão
Array = novo objeto [default_length];
}
/**
* Especifique o comprimento para a construção
* @param Comprimento Especifique o comprimento inicial
*/
linelist público (comprimento int) {
if (comprimento <0) {
lançar uma nova ilegalArgumentException ("o comprimento inicial é ilegal:"+comprimento);
}
// Construa uma matriz com um comprimento especificado
Array = novo objeto [comprimento];
}
/**
* Especifique o elemento de inicialização e o comprimento da construção
* elemento @param elemento inicializar
* @Param Comprimento do comprimento do comprimento
*/
linelist público (elemento e, int length) {
if (comprimento <1) {
lançar uma nova ilegalArgumentException ("o comprimento inicial é ilegal:"+comprimento);
}
// Construa uma matriz com um comprimento especificado
Array = novo objeto [comprimento];
// inicialize o primeiro elemento
matriz [0] = elemento;
tamanho ++;
}
/**
* Especifique os elementos de inicialização para construção
* elemento @param elemento inicializar
*/
linelist public (e elemento) {
// inicialize a matriz com comprimento padrão
Array = novo objeto [default_length];
// inicialize o primeiro elemento
matriz [0] = elemento;
}
/**
* Obtenha o número de elementos
*/
public int size () {
tamanho de retorno;
}
/**
* Determinar se está vazio
*/
public boolean isEmpty () {
tamanho de retorno == 0;
}
/**
* Determinar se este elemento está incluído
*/
public boolean contém (e e) {
if (indexOf (e) == -1) {
retornar falso;
}
retornar true;
}
/**
* Formato como uma matriz
*/
objeto público [] ToArray () {
return Arrays.copyof (matriz, tamanho);
}
/**
* Adicione um elemento à cauda da tabela linear
* @param e
* @retornar
*/
public void add (e e) {
ExtendCapacity (tamanho+1);
Array [tamanho] = e;
tamanho ++;
}
/**
* Expandir a capacidade
* @param Comprimento do comprimento necessário
*/
Void privado ExtendCapacity (Int Length) {
// O comprimento da matriz atual e o comprimento necessário devem ser o máximo
int mincapacity = math.max (Array.length, comprimento);
// julga se a expansão da capacidade é necessária
if (Mincapacity - Array.Length> 0) {
// O comprimento da matriz é aumentado pela metade
int newLength = Array.Length + Array.Length/2;
// Se o novo comprimento for menor que o requisito, use o comprimento necessário como o comprimento da matriz
if (newLength <mincapacity) {
newLength = MinCapacity;
}
// O comprimento da matriz não pode exceder o número inteiro.max_value
if (newLength> Integer.max_value - 8) {
newLength = Integer.max_value;
}
// Expansão da matriz
Array = Arrays.copyof (Array, NewLength);
}
}
/**
* Remova todo esse elemento da tabela linear
* @param e elementos que precisam ser removidos
* @retornar
*/
public void removeall (e e) {
if (e == null) {
for (int i = 0; i <tamanho; i ++) {
if (array [i] == null) {
Fastremove (i);
}
}
}outro{
for (int i = 0; i <tamanho; i ++) {
if (E.Equals (Array [i])) {
Fastremove (i);
}
}
}
}
/**
* Exclua o elemento no índice e mova os seguintes elementos adiante por sua vez
* @param índice o índice que precisa ser excluído
*/
private vazio Fastremove (Int Index) {
if (size-index-1> 0) {
// Matrizes começam no índice+1 e todos avançam
System.arraycopy (Array, Index+1, Array, Índice, tamanho 1);
}
// por favor esvazie o último elemento
matriz [-tamanho] = nulo;
}
/**
* Limpe a tabela linear
*/
public void clear () {
// preencha todas as matrizes em nulo
Arrays.fill (Array, NULL);
// altere o número de elementos para 0
tamanho = 0;
}
/**
* Obtenha o elemento no índice
* @param Índice
* elemento @return no índice
*/
@Suppresswarnings ("sem controle")
public e get (int index) {
checkIndex (índice);
return (e) matriz [índice];
}
/**
* Verifique se o índice está fora dos limites
* @param Índice
*/
Private Void CheckIndex (Int Index) {
if (index> = size || índice <0) {
lançar novo indexOutOfBoundSexception ("indexOutBoundSexception");
}
}
/**
* Modifique o elemento no índice em um novo elemento
* @param Índice Index Posição
* elemento @param
* elemento @return no índice original
*/
@Suppresswarnings ("sem controle")
public E Set (Int Index, E Element) {
checkIndex (índice);
E E = (e) matriz [índice];
Array [index] = elemento;
retornar e;
}
/**
* Insira o elemento especificado no índice especificado
* @param Índice Index Posição
* elemento @param
*/
public void add (int índice, e elemento) {
// Verifique o índice
checkIndex (índice);
// é necessário expandir a capacidade
ExtendCapacity (tamanho+1);
// Copie a matriz
System.arrayCopy (Array, Index, Array, Índice+1, Size-Index);
Array [index] = elemento;
}
/**
* Remova os elementos no índice
* Índice de @param Índice
* elementos excluídos @return
*/
@Suppresswarnings ("sem controle")
public e Remover (Int Index) {
checkIndex (índice);
// Obtenha o elemento de posição do índice
E E = (e) matriz [índice];
Fastremove (índice);
retornar e;
}
/**
* Obtenha o índice do local onde o elemento aparece primeiro
* @param e elemento para procurar
* @return Se for -1, significa que a tabela linear não tem esse elemento
*/
public int indexof (e e) {
if (e == null) {
for (int i = 0; i <tamanho; i ++) {
if (e == Array [i]) {
retornar i;
}
}
}
for (int i = 0; i <tamanho; i ++) {
if (E.Equals (Array [i])) {
retornar i;
}
}
retornar -1;
}
/**
* Obtenha o índice da última ocorrência do elemento
* @param e elemento para procurar
* @return Se for -1, significa que a tabela linear não tem esse elemento
*/
public int lastIndexOf (e e) {
// julga se o elemento é nulo
if (e == null) {
for (int i = size-1; i> = 0; i-) {
if (e == Array [i]) {
retornar i;
}
}
}
for (int i = size-1; i> = 0; i-) {
// Se nulo, uma exceção de Nullpoint será executada aqui
// então você precisa adicionar a verificação, seja nula
if (E.Equals (Array [i])) {
retornar i;
}
}
retornar -1;
}
/**
* Interceptar a tabela linear
* @param fromIndex Iniciar indexação
* @param toIndex End Index
* Tabela linear interceptada @return
*/
@Suppresswarnings ("sem controle")
public lineList <e> sublist (int deindex, int toIndex) {
// julga se o índice de início está fora dos limites
if (fromIndex <0 || deindex> = size) {
lançar novo indexOutOfBoundSexception ("Iniciar o índice transfronteiriço:"+FromIndex);
}
// julga se o índice final está fora dos limites
if (toIndex> = size || deindex <0) {
lançar novo indexOutOfBoundSexception ("ENDICE ENTRADO EXTRIBUNDO:"+ToIndex);
}
// julga se o índice de início e o índice final estão corretos
if (fromIndex> toIndex) {
lançar novas ilegalargumentException ("O parâmetro está incorreto, o índice de início deve ser maior ou igual ao índice final");
}
Linelist <e> list = new lineList <E> ();
for (int i = fromIndex, j = toIndex; i <= j; i ++) {
list.add ((e) matriz [i]);
}
lista de retorno;
}
}