Die Codekopie lautet wie folgt:
Import Java.util.Arrays;
/**
* Implementierung sequentieller linearer Tabellen
*/
öffentliche Klasse Linelist <e> {
Private int Größe; // Länge
privates Objekt [] Array; // das zugrunde liegende Array
private endgültige int default_length = 16; // Standardlänge
/**
* Nicht-Parameter-Konstruktionsmethode
*/
public Linelist () {
Größe = 0;
// Konstruieren Sie ein Array mit der Standardlänge
Array = New Object [default_length];
}
/**
* Geben Sie die Länge für die Konstruktion an
* @Param Länge Geben Sie die anfängliche Länge an
*/
public Linelist (int Länge) {
if (Länge <0) {
Neue IllegalArgumentException werfen ("Anfangslänge ist illegal:"+Länge);
}
// Konstruieren Sie ein Array mit einer bestimmten Länge
Array = neues Objekt [Länge];
}
/**
* Geben Sie das Initialisierungselement und die Länge für die Konstruktion an
* @Param Element initialisieren Element
* @Param Länge Initialisierungslänge
*/
public Linelist (E -Element, int Länge) {
if (Länge <1) {
Neue IllegalArgumentException werfen ("Anfangslänge ist illegal:"+Länge);
}
// Konstruieren Sie ein Array mit einer bestimmten Länge
Array = neues Objekt [Länge];
// das erste Element initialisieren
Array [0] = Element;
Größe ++;
}
/**
* Geben Sie Initialisierungselemente für die Konstruktion an
* @Param Element initialisieren Element
*/
public Linelist (E Element) {
// Initialisieren Sie das Array mit Standardlänge
Array = New Object [default_length];
// das erste Element initialisieren
Array [0] = Element;
}
/**
* Holen Sie sich die Anzahl der Elemente
*/
public int size () {
Renditegröße;
}
/**
* Bestimmen Sie, ob es leer ist
*/
public boolean isempty () {
Return Size == 0;
}
/**
* Bestimmen Sie, ob dieses Element enthalten ist
*/
public boolean enthält (e e) {
if (indexof (e) == -1) {
false zurückgeben;
}
zurückkehren;
}
/**
* Format als Array
*/
öffentliches Objekt [] toarray () {
return arrays.copyof (Array, Größe);
}
/**
* Fügen Sie dem Schwanz der linearen Tabelle ein Element hinzu
* @param e
* @zurückkehren
*/
public void add (e e) {
ExtendCapacity (Größe+1);
Array [Größe] = e;
Größe ++;
}
/**
* Kapazität erweitern
* @Param Länge die erforderliche Länge
*/
private void extendCapacity (int länge) {
// Die Stromarraylänge und die erforderliche Länge sollten maximal sein
int mincapacity = math.max (Array.length, Länge);
// Beurteilen Sie, ob eine Kapazitätserweiterung erforderlich ist
if (mincapacity - array.length> 0) {
// Arraylänge wird um die Hälfte erhöht
int newLength = array.length + array.length/2;
// Wenn die neue Länge kleiner als die Anforderung ist, verwenden Sie die erforderliche Länge als Arraylänge
if (newLength <mincapacity) {
NewLength = Mincapacity;
}
// Die Arraylänge darf Integer.max_Value nicht überschreiten
if (newLength> Integer.max_value - 8) {
NewLength = Integer.max_Value;
}
// Array -Erweiterung
Array = arrays.copyof (Array, NewLength);
}
}
/**
* Entfernen Sie all dieses Element aus der linearen Tabelle
* @param e Elemente, die entfernt werden müssen
* @zurückkehren
*/
public void removeall (e e) {
if (e == null) {
für (int i = 0; i <size; i ++) {
if (Array [i] == null) {
Fastremove (i);
}
}
}anders{
für (int i = 0; i <size; i ++) {
if (e.equals (Array [i])) {
Fastremove (i);
}
}
}
}
/**
* Löschen Sie das Element am Index und bewegen Sie die folgenden Elemente nacheinander nach vorne
* @param Index den Index, der gelöscht werden muss
*/
private void fastremove (int index) {
if (Größe-Index-1> 0) {
// Arrays starten von Index+1 und alle bewegen sich vorwärts
System.ArrayCopy (Array, Index+1, Array, Index, Größe-1);
}
// Bitte leeren Sie das letzte Element
Array [-Größe] = null;
}
/**
* Löschen Sie die lineare Tabelle
*/
public void clear () {
// Füllen Sie alle Arrays in NULL aus
Arrays.fill (Array, NULL);
// Ändern Sie die Anzahl der Elemente auf 0
Größe = 0;
}
/**
* Holen Sie sich das Element im Index
* @param Index
* @Return Element bei Index
*/
@Suppresswarnings ("Unbekämpft")
public e get (int index) {
checkIndex (Index);
return (e) Array [Index];
}
/**
* Überprüfen Sie, ob der Index außerhalb der Grenzen liegt
* @param Index
*/
private void checkIndex (int index) {
if (index> = Größe || index <0) {
Neue indexoutofBoundSexception ("indexoutBoundSexception") werfen;
}
}
/**
* Ändern Sie das Element am Index in ein neues Element
* @param Indexindexposition
* @param Element
* @Return Element im ursprünglichen Index
*/
@Suppresswarnings ("Unbekämpft")
public e set (int index, e element) {
checkIndex (Index);
E e = (e) Array [Index];
Array [Index] = Element;
Rückkehr e;
}
/**
* Fügen Sie das angegebene Element am angegebenen Index ein
* @param Indexindexposition
* @param Element
*/
public void add (int Index, E -Element) {
// Überprüfen Sie den Index
checkIndex (Index);
// ist es notwendig, die Kapazität zu erweitern
ExtendCapacity (Größe+1);
// Kopieren Sie das Array
System.ArrayCopy (Array, Index, Array, Index+1, Größe-Index);
Array [Index] = Element;
}
/**
* Entfernen Sie Elemente im Index
* @param Index Index
* @Return gelöschte Elemente
*/
@Suppresswarnings ("Unbekämpft")
public e remove (int index) {
checkIndex (Index);
// Holen Sie sich das Indexpositionselement
E e = (e) Array [Index];
Fastremove (Index);
Rückkehr e;
}
/**
* Holen Sie sich den Index des Ortes, an dem das Element zum ersten Mal erscheint
* @param e Element, nach denen man suchen muss
* @return Wenn es -1 ist, bedeutet dies, dass die lineare Tabelle dieses Element nicht hat
*/
public int indexof (e e) {
if (e == null) {
für (int i = 0; i <size; i ++) {
if (e == Array [i]) {
kehre I zurück;
}
}
}
für (int i = 0; i <size; i ++) {
if (e.equals (Array [i])) {
kehre I zurück;
}
}
Return -1;
}
/**
* Holen Sie sich den Index des letzten Auftretens des Elements
* @param e Element, nach denen man suchen muss
* @return Wenn es -1 ist, bedeutet dies, dass die lineare Tabelle dieses Element nicht hat
*/
public int lastIndexof (e e) {
// beurteilen, ob das Element null ist
if (e == null) {
für (int i = size-1; i> = 0; i-) {
if (e == Array [i]) {
kehre I zurück;
}
}
}
für (int i = size-1; i> = 0; i-) {
// Wenn null eine Nullpoint -Ausnahme hier ausgeführt wird
// Sie müssen also die Überprüfung hinzufügen, ob es sich um null handelt
if (e.equals (Array [i])) {
kehre I zurück;
}
}
Return -1;
}
/**
* Fangen Sie die lineare Tabelle ab
* @param von iNdex starten Sie die Indexierung
* @param toIdex Endindex
* @return abgefangene lineare Tabelle
*/
@Suppresswarnings ("Unbekämpft")
public Linelist <e> sublist (int vonIndex, int toIndex) {
// Beurteilen Sie, ob der Startindex außerhalb der Grenzen liegt
if (von iNdex <0 || von iNdex> = Größe) {
Neue IndexoutOfBoundSexception werfen ("Startindex grenzüberschreitend:"+von iNdex);
}
// Beurteilen Sie, ob der Endindex außerhalb der Grenzen liegt
if (toIndex> = Größe || von iNdex <0) {
Neue indexoutofBoundSexception werfen ("Endindex -Outbound:"+toIndex);
}
// Beurteilen Sie, ob der Startindex und der Endindex korrekt sind
if (von iNdex> toIndex) {
Neue IllegalArgumentException werfen ("Der Parameter ist falsch, der Startindex sollte größer oder gleich dem Endindex sein").
}
Linelist <E> list = new Linelist <e> ();
für (int i = von iNdex, j = toIdex; i <= j; i ++) {
list.add ((e) Array [i]);
}
Rückgabeliste;
}
}