La copie de code est la suivante:
import java.util.arrays;
/ **
* Implémentation de tables linéaires séquentielles
* /
classe publique Linelist <e> {
taille int privée; // longueur
objet privé [] Array; // le tableau sous-jacent
private final int default_length = 16; // la longueur par défaut
/ **
* Méthode de construction non paramètre
* /
Linelist public () {
taille = 0;
// Construisez un tableau en utilisant la longueur par défaut
array = nouvel objet [default_length];
}
/ **
* Spécifiez la longueur de la construction
* la longueur @param spécifie la longueur initiale
* /
Linelist public (int le long) {
if (longueur <0) {
Jetez un nouveau IllégalArgumentException ("La longueur initiale est illégale:" + longueur);
}
// Construisez un tableau avec une longueur spécifiée
array = nouvel objet [longueur];
}
/ **
* Spécifiez l'élément d'initialisation et la longueur de la construction
* @param élément initialiser l'élément
* Longueur d'initialisation de la longueur @param
* /
Lineliste publique (élément e, longueur int) {
if (longueur <1) {
Jetez un nouveau IllégalArgumentException ("La longueur initiale est illégale:" + longueur);
}
// Construisez un tableau avec une longueur spécifiée
array = nouvel objet [longueur];
// initialise le premier élément
Array [0] = élément;
taille ++;
}
/ **
* Spécifiez les éléments d'initialisation de la construction
* @param élément initialiser l'élément
* /
Linelist public (e élément) {
// initialise le tableau avec une longueur par défaut
array = nouvel objet [default_length];
// initialise le premier élément
Array [0] = élément;
}
/ **
* Obtenez le nombre d'éléments
* /
public int size () {
taille de retour;
}
/ **
* Déterminez s'il est vide
* /
public booléen iSempty () {
taille de retour == 0;
}
/ **
* Déterminez si cet élément est inclus
* /
Le booléen public contient (e e) {
if (indexof (e) == -1) {
retourne false;
}
Retour Vrai;
}
/ **
* Format comme un tableau
* /
objet public [] toArray () {
Return Arrays.CopyOf (tableau, taille);
}
/ **
* Ajoutez un élément à la queue de la table linéaire
* @param e
* @retour
* /
public void add (e e) {
extensioncapacité (taille + 1);
Array [Taille] = E;
taille ++;
}
/ **
* Élargir la capacité
* @param longueur la longueur requise
* /
Private void extendCapacity (int longueur) {
// La longueur de réseau actuelle et la longueur requise doivent être le maximum
int mincapacity = math.max (array.length, longueur);
// juger si l'expansion de la capacité est requise
if (mincapacity - array.length> 0) {
// la longueur du tableau augmente de moitié
int newLength = array.length + array.length / 2;
// Si la nouvelle longueur est plus petite que l'exigence, utilisez la longueur requise comme longueur de tableau
if (newLength <mincapacity) {
newLength = mincapacity;
}
// La longueur du tableau ne peut pas dépasser Integer.max_value
if (newLength> Integer.max_value - 8) {
newLength = Integer.max_value;
}
// Extension du tableau
array = arrays.copyof (array, newLength);
}
}
/ **
* Retirez tout cet élément de la table linéaire
* @param e éléments qui doivent être supprimés
* @retour
* /
public void reroveall (e e) {
if (e == null) {
pour (int i = 0; i <size; i ++) {
if (array [i] == null) {
FastreMove (i);
}
}
}autre{
pour (int i = 0; i <size; i ++) {
if (e.equals (array [i])) {
FastreMove (i);
}
}
}
}
/ **
* Supprimer l'élément à l'index et faire avancer les éléments suivants
* @param index l'indice qui doit être supprimé
* /
VOID privé FastreMove (INT INDEX) {
if (size-index-1> 0) {
// Les tableaux commencent à partir de l'index + 1 et tous avancent
System.ArrayCopy (tableau, index + 1, tableau, index, taille-1);
}
// Veuillez vider le dernier élément
Array [- Size] = NULL;
}
/ **
* Effacer la table linéaire
* /
public void clear () {
// Remplissez tous les tableaux en null
Arrays.filt (tableau, null);
// modifie le nombre d'éléments en 0
taille = 0;
}
/ **
* Obtenez l'élément à l'index
* index @param
* élément @return à index
* /
@SuppressWarnings ("non contrôlé")
public e get (int index) {
checkIndex (index);
return (e) array [index];
}
/ **
* Vérifiez si l'index est hors limites
* index @param
* /
private void checkIndex (int index) {
if (index> = size || index <0) {
lancer une nouvelle indexoutofboundSexception ("indexoutboundSexception");
}
}
/ **
* Modifiez l'élément de l'index dans un nouvel élément
* Position d'index d'index @param
* élément @param
* @return élément à l'index d'origine
* /
@SuppressWarnings ("non contrôlé")
public e set (int index, e élément) {
checkIndex (index);
E e = (e) Array [index];
array [index] = élément;
retour e;
}
/ **
* Insérez l'élément spécifié à l'index spécifié
* Position d'index d'index @param
* élément @param
* /
public void add (int index, e élément) {
// Vérifiez l'index
checkIndex (index);
// est-il nécessaire d'élargir la capacité
extensioncapacité (taille + 1);
// Copiez le tableau
System.ArrayCopy (tableau, index, tableau, index + 1, indice de taille);
array [index] = élément;
}
/ **
* Supprimer les éléments à l'index
* index de l'indice @param
* @return supprimé des éléments
* /
@SuppressWarnings ("non contrôlé")
public e re Suppor (int index) {
checkIndex (index);
// Obtenez l'élément de position d'index
E e = (e) Array [index];
FastreMove (index);
retour e;
}
/ **
* Obtenez l'index de l'emplacement où l'élément apparaît pour la première fois
* @param e élément à rechercher
* @return si c'est -1, cela signifie que la table linéaire n'a pas cet élément
* /
index int publique (e e) {
if (e == null) {
pour (int i = 0; i <size; i ++) {
if (e == array [i]) {
retour i;
}
}
}
pour (int i = 0; i <size; i ++) {
if (e.equals (array [i])) {
retour i;
}
}
retour -1;
}
/ **
* Obtenez l'indice de la dernière occurrence de l'élément
* @param e élément à rechercher
* @return si c'est -1, cela signifie que la table linéaire n'a pas cet élément
* /
public int lastIndexof (e e) {
// juger si l'élément est nul
if (e == null) {
pour (int i = size-1; i> = 0; i -) {
if (e == array [i]) {
retour i;
}
}
}
pour (int i = size-1; i> = 0; i -) {
// Si null, une exception NullPoint sera exécutée ici
// Vous devez donc ajouter la vérification si c'est nul
if (e.equals (array [i])) {
retour i;
}
}
retour -1;
}
/ **
* Intercepter la table linéaire
* @param fromindex start indexing
* @param toindex final index
* Table linéaire interceptée @return
* /
@SuppressWarnings ("non contrôlé")
Linelist public <e> sublist (int FromIndex, int toindex) {
// juger si l'indice de démarrage est hors limites
if (fromIndex <0 || fromIndex> = size) {
Jetez une nouvelle indexoutofboundSexception ("Start Index Cross-Border:" + FromIndex);
}
// juger si l'indice final est hors limites
if (toindex> = size || fromindex <0) {
Jetez une nouvelle indexoutofboundSexception ("End Index Outbound:" + ToIndex);
}
// jugez si l'index de démarrage et l'indice final sont corrects
if (fromIndex> toindex) {
Jetez un nouveau IllégalArgumentException ("Le paramètre est incorrect, l'indice de démarrage doit être supérieur ou égal à l'indice final");
}
Linelist <e> list = new LineList <e> ();
for (int i = fromindex, j = toindex; i <= j; i ++) {
list.add ((e) array [i]);
}
Liste de retour;
}
}