La copia del código es la siguiente:
importar java.util.arrays;
/**
* Implementación de tablas lineales secuenciales
*/
Linelista de clase pública <E> {
tamaño privado int; // longitud
objeto privado [] matriz; // La matriz subyacente
Private final int default_length = 16; // Longitud predeterminada
/**
* Método de construcción no parámetro
*/
public Linelist () {
tamaño = 0;
// construir una matriz utilizando la longitud predeterminada
array = nuevo objeto [default_length];
}
/**
* Especifique la longitud para la construcción
* @param longitud especificar la longitud inicial
*/
Public Linelist (int longitud) {
if (longitud <0) {
tirar nueva IllegalArgumentException ("La longitud inicial es ilegal:"+longitud);
}
// construir una matriz con una longitud especificada
array = nuevo objeto [longitud];
}
/**
* Especifique el elemento de inicialización y la longitud para la construcción
* @param elemento inicializar elemento
* @Param Longitud Longitud de inicialización
*/
Public Linelist (E Elemento, int longitud) {
if (longitud <1) {
tirar nueva IllegalArgumentException ("La longitud inicial es ilegal:"+longitud);
}
// construir una matriz con una longitud especificada
array = nuevo objeto [longitud];
// Inicializa el primer elemento
matriz [0] = elemento;
tamaño ++;
}
/**
* Especificar elementos de inicialización para la construcción
* @param elemento inicializar elemento
*/
Linelista pública (Elemento E) {
// Inicializar la matriz con longitud predeterminada
array = nuevo objeto [default_length];
// Inicializa el primer elemento
matriz [0] = elemento;
}
/**
* Obtenga el número de elementos
*/
public int size () {
tamaño de retorno;
}
/**
* Determinar si está vacío
*/
Public boolean isEtimty () {
tamaño de retorno == 0;
}
/**
* Determinar si este elemento está incluido
*/
Public Boolean contiene (E E) {
if (indexOf (e) == -1) {
devolver falso;
}
devolver verdadero;
}
/**
* Formato como una matriz
*/
objeto público [] toArray () {
matriz de retorno.copyOf (matriz, tamaño);
}
/**
* Agregue un elemento a la cola de la mesa lineal
* @param e
* @devolver
*/
public void add (e e) {
Extend Capacidad (tamaño+1);
matriz [tamaño] = e;
tamaño ++;
}
/**
* Expandir la capacidad
* @param longitud la longitud requerida
*/
Private Void ExtendCapacity (int long) {
// La longitud de la matriz actual y la longitud requerida deben ser la máxima
int mincapacity = math.max (array.length, longitud);
// juzga si se requiere la expansión de la capacidad
if (mincapacity - array.length> 0) {
// La longitud de la matriz se incrementa a la mitad
int newLength = array.length + array.length/2;
// Si la nueva longitud es menor que el requisito, use la longitud requerida como la longitud de la matriz
if (newLength <mincapacity) {
newLength = mincapacity;
}
// La longitud de la matriz no puede exceder integer.max_value
if (newLength> integer.max_value - 8) {
newLength = integer.max_value;
}
// expansión de la matriz
array = arrays.copyOf (array, newLength);
}
}
/**
* Eliminar todo este elemento de la tabla lineal
* @param e elementos que necesitan ser eliminados
* @devolver
*/
Public void RemoveAll (e e) {
if (e == null) {
para (int i = 0; i <size; i ++) {
if (array [i] == null) {
Fastremove (i);
}
}
}demás{
para (int i = 0; i <size; i ++) {
if (e.equals (array [i])) {
Fastremove (i);
}
}
}
}
/**
* Elimine el elemento en el índice y mueva los siguientes elementos hacia adelante a su vez
* @param index el índice que debe eliminarse
*/
Vacío privado Fastremove (INT índice) {
if (size-index-1> 0) {
// Las matrices comienzan desde el índice+1 y todos avanzan
System.ArrayCopy (matriz, índice+1, matriz, índice, tamaño-1);
}
// Por favor vacíe el último elemento
matriz [-tamaño] = nulo;
}
/**
* Borrar la tabla lineal
*/
public void clear () {
// llenar todas las matrices en nulo
Arrays.fill (matriz, nulo);
// Cambiar el número de elementos a 0
tamaño = 0;
}
/**
* Obtenga el elemento en el índice
* @param índice
* @return elemento en el índice
*/
@SupessWarnings ("sin control")
public e get (int index) {
checkIndex (índice);
return (e) matriz [índice];
}
/**
* Verifique si el índice está fuera de los límites
* @param índice
*/
privado void checkIndex (int index) {
if (index> = size || índice <0) {
tirar nuevo índiceutOfBoundsexception ("indexOutBoundsexception");
}
}
/**
* Modificar el elemento en el índice en un nuevo elemento
* @param Posición del índice del índice
* @param elemento
* @return elemento en el índice original
*/
@SupessWarnings ("sin control")
Public E set (int index, e elemento) {
checkIndex (índice);
E e = (e) matriz [índice];
matriz [índice] = elemento;
regresar e;
}
/**
* Inserte el elemento especificado en el índice especificado
* @param Posición del índice del índice
* @param elemento
*/
public void add (int index, e elemento) {
// Verificar el índice
checkIndex (índice);
// es necesario expandir la capacidad
Extend Capacidad (tamaño+1);
// copia la matriz
System.ArrayCopy (matriz, índice, matriz, índice+1, índice de tamaño);
matriz [índice] = elemento;
}
/**
* Eliminar elementos en el índice
* @Param ÍNDICE ÍNDICE
* @return elementos eliminados
*/
@SupessWarnings ("sin control")
public e remove (int index) {
checkIndex (índice);
// Obtener el elemento de posición de índice
E e = (e) matriz [índice];
Fastremove (índice);
regresar e;
}
/**
* Obtenga el índice de la ubicación donde aparece el elemento por primera vez
* @param e elemento para buscar
* @return Si es -1, significa que la tabla lineal no tiene este elemento
*/
public int indexOf (e e) {
if (e == null) {
para (int i = 0; i <size; i ++) {
if (e == array [i]) {
regresar i;
}
}
}
para (int i = 0; i <size; i ++) {
if (e.equals (array [i])) {
regresar i;
}
}
regreso -1;
}
/**
* Obtenga el índice de la última ocurrencia del elemento
* @param e elemento para buscar
* @return Si es -1, significa que la tabla lineal no tiene este elemento
*/
public int LastIndexof (e e) {
// juzga si el elemento es nulo
if (e == null) {
para (int i = size-1; i> = 0; i-) {
if (e == array [i]) {
regresar i;
}
}
}
para (int i = size-1; i> = 0; i-) {
// Si es nulo, se ejecutará una excepción NullPoint aquí
// Entonces debe agregar la verificación si es nulo
if (e.equals (array [i])) {
regresar i;
}
}
regreso -1;
}
/**
* Interceptar la tabla lineal
* @param fromindex comienza a indexación
* @param toindex end índice
* @return mesa lineal interceptada
*/
@SupessWarnings ("sin control")
Public Linelist <E> Sublist (int fromIndex, int toIndex) {
// juzga si el índice de inicio está fuera de los límites
if (fromIndex <0 || fromIndex> = size) {
tirar el nuevo índiceuToFboundSexception ("Iniciar el índice transfronterizo:"+fromindex);
}
// juzga si el índice final está fuera de los límites
if (toIndex> = size || fromIndex <0) {
tirar el nuevo índiceutoutOfBoundSexception ("Final Index Outbound:"+ToIndex);
}
// juzga si el índice de inicio y el índice final son correctos
if (fromIndex> toIndex) {
arrojar nueva ilegalargumentException ("El parámetro es incorrecto, el índice de inicio debe ser mayor o igual al índice final");
}
Linelist <E> list = new Linelist <E> ();
para (int i = fromIndex, j = toIndex; i <= j; i ++) {
list.add ((e) matriz [i]);
}
lista de devolución;
}
}