Java eqivalent méthode de “splice(a,b,...)” dans la méthode JavaScript

someArray.splice(a,b,...) méthode en JavaScript ajoute ou supprime des éléments à/de la matrice. Ce qui pourrait être une bonne solution et simple à mettre en œuvre une telle méthode en langage Java? Supposons que nous avons String[] tableau.

Si vous êtes à la recherche d'un moyen de redimensionner tableau alors vous devriez probablement utiliser List au lieu de tableau. Cela vous donnera addAll(index, Collection) que vous pouvez utiliser comme addAll(index, Arrays.aslList("foo", "bar"))
En Java, les tableaux ne peuvent pas être ajoutés à (cultivé) . Utilisation ArrayList.

OriginalL'auteur Ernestas Gruodis | 2015-03-14

Ici est une implémentation Java de la Array.prototype.splice() méthode que par la JavaScript MDN spécification.

  public static <T>T[] splice(final T[] array, int start) {
if (start < 0)
start += array.length;
return splice(array, start, array.length - start);
}
@SuppressWarnings("unchecked")
public static <T>T[] splice(final T[] array, int start, final int deleteCount) {
if (start < 0)
start += array.length;
final T[] spliced = (T[])Array.newInstance(array.getClass().getComponentType(), array.length - deleteCount);
if (start != 0)
System.arraycopy(array, 0, spliced, 0, start);
if (start + deleteCount != array.length)
System.arraycopy(array, start + deleteCount, spliced, start, array.length - start - deleteCount);
return spliced;
}
@SuppressWarnings("unchecked")
public static <T>T[] splice(final T[] array, int start, final int deleteCount, final T ... items) {
if (start < 0)
start += array.length;
final T[] spliced = (T[])Array.newInstance(array.getClass().getComponentType(), array.length - deleteCount + items.length);
if (start != 0)
System.arraycopy(array, 0, spliced, 0, start);
if (items.length > 0)
System.arraycopy(items, 0, spliced, start, items.length);
if (start + deleteCount != array.length)
System.arraycopy(array, start + deleteCount, spliced, start + items.length, array.length - start - deleteCount);
return spliced;
}

Suivantes JUnit tests de code de cette mise en œuvre:

@Test
public void testSplice() {
final String[] array = new String[] {"a", "b", "c", "d", "e", "f"};
Assert.assertArrayEquals(new String[] {"c", "d", "e", "f"}, Arrays.splice(array, 0, 2));
Assert.assertArrayEquals(new String[] {"a", "d", "e", "f"}, Arrays.splice(array, 1, 2));
Assert.assertArrayEquals(new String[] {"a", "b", "e", "f"}, Arrays.splice(array, 2, 2));
Assert.assertArrayEquals(new String[] {"a", "b", "c", "f"}, Arrays.splice(array, 3, 2));
Assert.assertArrayEquals(new String[] {"a", "b", "c", "d"}, Arrays.splice(array, 4, 2));
try {
Arrays.splice(array, 5, 2);
Assert.fail("Expected ArrayIndexOutOfBoundsException");
}
catch (final ArrayIndexOutOfBoundsException e) {
}
try {
Arrays.splice(array, -2, 3);
Assert.fail("Expected ArrayIndexOutOfBoundsException");
}
catch (final ArrayIndexOutOfBoundsException e) {
}
Assert.assertArrayEquals(new String[] {"a", "b", "c", "d"}, Arrays.splice(array, -2, 2));
Assert.assertArrayEquals(new String[] {"a", "b", "c", "f"}, Arrays.splice(array, -3, 2));
Assert.assertArrayEquals(new String[] {"a", "b", "e", "f"}, Arrays.splice(array, -4, 2));
Assert.assertArrayEquals(new String[] {"a", "d", "e", "f"}, Arrays.splice(array, -5, 2));
Assert.assertArrayEquals(new String[] {"c", "d", "e", "f"}, Arrays.splice(array, -6, 2));
try {
Arrays.splice(array, -7, 2);
Assert.fail("Expected ArrayIndexOutOfBoundsException");
}
catch (final ArrayIndexOutOfBoundsException e) {
}
Assert.assertArrayEquals(new String[] {}, Arrays.splice(array, 0));
Assert.assertArrayEquals(new String[] {"a"}, Arrays.splice(array, 1));
Assert.assertArrayEquals(new String[] {"a", "b"}, Arrays.splice(array, 2));
Assert.assertArrayEquals(new String[] {"a", "b", "c"}, Arrays.splice(array, 3));
Assert.assertArrayEquals(new String[] {"a", "b", "c", "d"}, Arrays.splice(array, 4));
Assert.assertArrayEquals(new String[] {"a", "b", "c", "d", "e"}, Arrays.splice(array, 5));
Assert.assertArrayEquals(new String[] {"a", "b", "c", "d", "e", "f"}, Arrays.splice(array, 6));
try {
Arrays.splice(array, 7);
Assert.fail("Expected ArrayIndexOutOfBoundsException");
}
catch (final ArrayIndexOutOfBoundsException e) {
}
Assert.assertArrayEquals(new String[] {"a", "b", "c", "d", "e"}, Arrays.splice(array, -1));
Assert.assertArrayEquals(new String[] {"a", "b", "c", "d"}, Arrays.splice(array, -2));
Assert.assertArrayEquals(new String[] {"a", "b", "c"}, Arrays.splice(array, -3));
Assert.assertArrayEquals(new String[] {"a", "b"}, Arrays.splice(array, -4));
Assert.assertArrayEquals(new String[] {"a"}, Arrays.splice(array, -5));
Assert.assertArrayEquals(new String[] {}, Arrays.splice(array, -6));
try {
Arrays.splice(array, -7);
Assert.fail("Expected NegativeArraySizeException");
}
catch (final NegativeArraySizeException e) {
}
Assert.assertArrayEquals(new String[] {"x", "y", "z", "c", "d", "e", "f"}, Arrays.splice(array, 0, 2, "x", "y", "z"));
Assert.assertArrayEquals(new String[] {"a", "x", "y", "z", "d", "e", "f"}, Arrays.splice(array, 1, 2, "x", "y", "z"));
Assert.assertArrayEquals(new String[] {"a", "b", "x", "y", "z", "e", "f"}, Arrays.splice(array, 2, 2, "x", "y", "z"));
Assert.assertArrayEquals(new String[] {"a", "b", "c", "x", "y", "z", "f"}, Arrays.splice(array, 3, 2, "x", "y", "z"));
Assert.assertArrayEquals(new String[] {"a", "b", "c", "d", "x", "y", "z"}, Arrays.splice(array, 4, 2, "x", "y", "z"));
try {
Arrays.splice(array, 5, 2, "x", "y", "z");
Assert.fail("Expected ArrayIndexOutOfBoundsException");
}
catch (final ArrayIndexOutOfBoundsException e) {
}
Assert.assertArrayEquals(new String[] {"a", "b", "c", "d", "x", "y", "z"}, Arrays.splice(array, -2, 2, "x", "y", "z"));
Assert.assertArrayEquals(new String[] {"a", "b", "c", "x", "y", "z", "f"}, Arrays.splice(array, -3, 2, "x", "y", "z"));
Assert.assertArrayEquals(new String[] {"a", "b", "x", "y", "z", "e", "f"}, Arrays.splice(array, -4, 2, "x", "y", "z"));
Assert.assertArrayEquals(new String[] {"a", "x", "y", "z", "d", "e", "f"}, Arrays.splice(array, -5, 2, "x", "y", "z"));
Assert.assertArrayEquals(new String[] {"x", "y", "z", "c", "d", "e", "f"}, Arrays.splice(array, -6, 2, "x", "y", "z"));
try {
Arrays.splice(array, -7, 2, "x", "y", "z");
Assert.fail("Expected ArrayIndexOutOfBoundsException");
}
catch (final ArrayIndexOutOfBoundsException e) {
}
}

Edit: @denys-séguret a souligné correctement, cette mise en œuvre diffère du JavaScript spec comme il n'a pas muter/modifier le tableau d'origine. Au lieu de cela, cette mise en œuvre renvoie une nouvelle instance de l'objet array.

Edit: Cette mise en œuvre est disponible avec les artefact maven, à la repo maven:

<project>
...
<dependencies>
<dependency>
<groupId>org.safris.commons</groupId>
<artifactId>commons-lang</artifactId>
<version>1.6.4</version>
</dependency>
</dependencies>
...
<repositories>
<repository>
<id>mvn.repo.safris.org</id>
<url>http://mvn.repo.safris.org/m2</url>
</repository>
</repositories>
...
</project>

J'aime bien cette solution, merci. C'est le travail.
Veuillez corriger votre introduction, il n'est pas de mettre en œuvre de splice spécification comme il ne modifie pas le tableau transmis, mais retourne une nouvelle. Comme déjà répondu, la modification d'un tableau en Java n'est pas possible (et à l'aide d'une liste est intelligente et rapide des meilleures pratiques).
Je veux ce qu'une bibliothèque. Merci 🙂
J'ai mis à jour la réponse avec un artefact maven, vous pouvez référencer en tant que dépendance.

OriginalL'auteur Seva Safris

4

Java les tableaux ont une longueur fixe, donc il n'y a pas une telle méthode.

Vous pourriez imaginer l'écriture d'une fonction d'utilité similaire à épissure en Java, mais il serait de retour un tableau différent. Il n'y a aucun point en ayant des tableaux en java si vous les redimensionnez: il n'est pas efficace, et vous ne pouvez pas partager de l'instance.

L'habitude et nettoyer la solution est d'utiliser un Liste, qui est un redimensionnables collection. ArrayList, la plus couramment utilisée de la Liste de mise en œuvre est soutenue par un tableau, mais qui est efficace tant que le tableau n'est pas changé chaque fois que vous redimensionnez la collection.

Maintenant, je suis en train de réfléchir substring() méthode. Nous allons le voir.
Quelle est la relation avec substring ?
Je peux convertir Array à String, puis substring() et de créer Array. Mais pas de manière efficace..
Il suffit d'utiliser une ArrayList<String>...

OriginalL'auteur Denys Séguret
0

Dans les bibliothèques de base de Java, il n'existe pas de fonctionnalité équivalente.

Il est java.util.Arrays classe, mais aucune des fonctionnalités similaires.

OriginalL'auteur Crazyjavahacking
0

Java les tableaux ont une longueur fixe, donc cela ne peut être fait directement.

Si vous souhaitez combiner les deux tableaux, regardez cette réponse.

Si vous souhaitez ajouter à la table, vous devez utiliser un List ou un ArrayList à la place.

OriginalL'auteur JonasCz
0

J'ai mal lu votre question et mélangé splice et slice.

La classe java.util.Arrays fournit quelques fonctions statiques utiles lorsque l'on travaille avec des tableaux. Voir la documentation officielle pour d'autres fonctions: http://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html.

Java est l'équivalent pour slice est: Arrays.copyOfRange(array, from, to).

Une méthode similaire pour splice est addAll (http://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html#addAll-int-java.util.Collection-). Mais vous avez besoin d'utiliser un java.util.ArrayList au lieu d'un tableau et il n'est pas possible de supprimer des éléments. Vous devez fournir les éléments d'une autre collection, par exemple, un ArrayList. Donc, il est équivalent à l'appel de splice(index, 0, element1, element2, ...)

Non, il n'est pas. Il parle de mutation, cela va créer une copie de la matrice.
Non, il renvoie un nouveau tableau. Le point intéressant dans splice est qu'il change le tableau source.
Je suppose que c' splice: w3schools.com/jsref/jsref_slice_array.asp et cela ne change pas le tableau, il est appelé, mais renvoie un nouveau tableau.
J'aime cette méthode, va essayer bientôt.
Mais splice méthode peut également ajouter à Array, de la rendre plus... Donc je pense que la seule façon est de travailler avec ArrayList.

OriginalL'auteur DenisG
0

Tableaux en Java ont un nombre fixe d'éléments. Mais vous pouvez faire de cet élément null comme ceci:

tableau[élément]==null;

Et c'est la même que la suppression de la pile. Vous pouvez également avoir une variable qui garde une trace de la façon dont beaucoup d'éléments ne sont pas nulles, de sorte que vous pouvez même disposer d'un tableau.la longueur est le genre de chose qui suit. c'est ce que je fais de toute façon.

OriginalL'auteur lincoln pepper

Vous devez vous connecter pour publier un commentaire.