Un tableau est une structure de données linéaire où tous les éléments sont disposés séquentiellement. Il s'agit d'une collection d'éléments du même type de données stockés à des mémoire contiguë emplacements.
public class Array<T> {
private T[] self;
private int size;
@SuppressWarnings("unchecked")
public Array(int size) {
if (size <= 0) {
throw new IllegalArgumentException("Invalid array size (must be positive): " + size);
} else {
this.size = size;
this.self = (T[]) new Object[size];
}
}
}
Dans Core Array Class, nous allons stocker la taille du tableau et un squelette général pour l'initialisation du tableau. Dans le constructeur, nous demandons la taille du tableau, créons un objet et le transposons dans le tableau souhaité.
public void set(T item, int index) {
if (index >= this.size || index < 0) {
throw new IndexOutOfBoundsException("Index Out of bounds: " + index);
} else {
this.self[index] = item;
}
}
Cette méthode demande qu'un élément soit stocké dans un tableau et un index sur lequel l'élément doit être stocké.
public T get(int index) {
if (index >= this.size || index < 0) {
throw new IndexOutOfBoundsException("Index Out of bounds");
} else {
return self[index];
}
}
La méthode Get demande un index et récupère l'élément de cet index.
public void print() {
for (int i = 0; i < size; i++) {
System.out.println(this.self[i]+" ");
}
}
La méthode d'impression consiste simplement à imprimer tous les membres d'un tableau sur une seule ligne avec un espace séparant chaque élément entre eux.
Des tableaux mais ayant une fonctionnalité pour trier les éléments lui-même.
public class SortedArray<T extends Comparable<T>> {
private T[] array;
private int size;
private final int maxSize;
@SuppressWarnings("unchecked")
public SortedArray(int maxSize) {
if (maxSize <= 0) {
throw new IllegalArgumentException("Invalid array max size (must be positive): " + maxSize);
}
this.array = (T[]) new Comparable[maxSize];
this.size = 0;
this.maxSize = maxSize;
}
}
Dans la classe Tableau trié, nous allons stocker la taille du tableau et demander également la taille maximale du tableau ainsi qu'un squelette général pour l'initialisation du tableau. Dans le constructeur, nous demandons la taille maximale du tableau, créons un objet et le transposons dans le tableau souhaité.
public int length() {
return this.size;
}
public int maxLength() {
return this.maxSize;
}
public T get(int index) {
if (index < 0 || index >= this.size) {
throw new IndexOutOfBoundsException("Index out of
bounds: " + index);
}
return this.array[index];
}
private int findInsertionPosition(T item) {
int left = 0;
int right = size - 1;
while (left <= right) {
int mid = (left + right) / 2;
int cmp = item.compareTo(this.array[mid]);
if (cmp < 0) {
right = mid - 1;
} else {
left = mid + 1;
}
}
return left;
}
public void insert(T item) {
if (this.size >= this.maxSize) {
throw new IllegalStateException("The array is already full");
}
int position = findInsertionPosition(item);
for (int i = size; i > position; i--) {
this.array[i] = this.array[i - 1];
}
this.array[position] = item;
size++;
}
La méthode Insert insère l'élément à sa position sous forme triée.
public void delete(T item) {
int index = binarySearch(item);
if (index == -1) {
throw new IllegalArgumentException("Unable to delete element " + item + ": the entry is not in the array");
}
for (int i = index; i < size - 1; i++) {
this.array[i] = this.array[i + 1];
}
this.array[size - 1] = null;
size--;
}
private int binarySearch(T target) {
int left = 0;
int right = size - 1;
while (left <= right) {
int mid = (left + right) / 2;
int cmp = target.compareTo(this.array[mid]);
if (cmp == 0) {
return mid;
} else if (cmp < 0) {
right = mid - 1;
} else {
left = mid + 1;
}
}
return -1;
}
public Integer find(T target) {
int index = binarySearch(target);
return index == -1 ? null : index;
}
public void traverse(Callback<T> callback) {
for (int i = 0; i < this.size; i++) {
callback.call(this.array[i]);
}
}
public interface Callback<T> {
void call(T item);
}
public class UppercaseCallback implements UnsortedArray.Callback<String> {
@Override
public void call(String item) {
System.out.println(item.toUpperCase());
}
}
C'est presque pareil vu d'en haut
L'initialisation et les getters sont identiques.
public void insert(T item) {
if (this.size >= this.maxSize) {
throw new IllegalStateException("The array is already full");
} else {
this.self[this.size] = item;
this.size++;
}
}
La méthode de suppression est également la même
public Integer find(T target) {
for (int i = 0; i < this.size; i++) {
if (this.self[i].equals(target)) {
return i;
}
}
return null;
}
Les tableaux dynamiques sont comme des listes de tableaux ou des listes.
public class DynamicArray<T> {
private T[] array;
private int size;
private int capacity;
@SuppressWarnings("unchecked")
public DynamicArray(int initialCapacity) {
if (initialCapacity <= 0) {
throw new IllegalArgumentException("Invalid initial capacity: " + initialCapacity);
}
this.capacity = initialCapacity;
this.array = (T[]) new Object[initialCapacity];
this.size = 0;
}
}
private void resize(int newCapacity) {
@SuppressWarnings("unchecked")
T[] newArray = (T[]) new Object[newCapacity];
for (int i = 0; i < size; i++) {
newArray[i] = array[i];
}
array = newArray;
capacity = newCapacity;
}
public void insert(T item) {
if (size >= capacity) {
resize(2 * capacity);
}
array[size++] = item;
}
public void delete(T item) {
int index = find(item);
if (index == -1) {
throw new IllegalArgumentException("Item not found: " + item);
}
for (int i = index; i < size - 1; i++) {
array[i] = array[i + 1];
}
array[--size] = null;
if (capacity > 1 && size <= capacity / 4) {
resize(capacity / 2);
}
}
Tout le reste est pareil.
J'espère que cela vous aidera à travailler avec des tableaux. Bonne chance !
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
