FastElementSequence
Restez organisé à l'aide des collections
Enregistrez et classez les contenus selon vos préférences.
Une séquence recyclant la même instance NdArray
lors de l'itération de ses éléments
Méthodes héritées
De la classe java.lang.Object booléen | est égal à (Objet arg0) |
Classe finale<?> | obtenirClasse () |
int | Code de hachage () |
vide final | notifier () |
vide final | notifierTous () |
Chaîne | àChaîne () |
vide final | attendre (long arg0, int arg1) |
vide final | attendez (long arg0) |
vide final | attendez () |
Depuis l'interface java.lang.Iterable vide abstrait | forEach (Consommateur <? super T> arg0) |
abstrait Iterator<U étend NdArray <T>> | itérateur () |
abstrait Spliterator<U étend NdArray <T>> | séparateur () |
Méthodes publiques
Renvoie chaque élément sous la forme d'une nouvelle tranche.
Contrairement aux collections Java conventionnelles, les éléments d'un NdArraySequence
sont transitoires, c'est-à-dire que de nouvelles instances NdArray
sont allouées à chaque itération. Pour améliorer les performances, la même instance peut être recyclée pour afficher tous les éléments de cette séquence, à l'aide d'un DataBufferWindow
.
Dans certains cas cependant, il peut être préférable de désactiver ces optimisations pour garantir que chaque élément renvoyé est une nouvelle tranche du tableau d'origine. Par exemple, si un ou plusieurs éléments visités doivent vivre au-delà de la portée de l'itération de la séquence, asSlices()
s'assure que tous les éléments renvoyés par la séquence sont des instances uniques.
final List<IntNdArray> vectors = new ArrayList<>();
IntNdArray matrix = NdArrays.ofInts(Shape.of(6, 6));
ndArray.elements(0).forEach(e -> vectors::add); // Not safe, as `e` might always be the same recycled instance
ndArray.elements(0).asSlices().forEach(e -> vectors::add); // Safe, each `e` is a distinct NdArray instance
Retours
- une séquence qui renvoie chaque élément itéré comme une nouvelle tranche
public void forEachIndexed (BiConsumer<long[], U> consommateur)
public Iterator<U> itérateur ()
Sauf indication contraire, le contenu de cette page est régi par une licence Creative Commons Attribution 4.0, et les échantillons de code sont régis par une licence Apache 2.0. Pour en savoir plus, consultez les Règles du site Google Developers. Java est une marque déposée d'Oracle et/ou de ses sociétés affiliées.
Dernière mise à jour le 2025/07/25 (UTC).
[null,null,["Dernière mise à jour le 2025/07/25 (UTC)."],[],[],null,["# FastElementSequence\n\npublic final class **FastElementSequence** \nA sequence recycling the same `NdArray` instance when iterating its elements \n\n### Public Constructors\n\n|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| | [FastElementSequence](/jvm/api_docs/java/org/tensorflow/ndarray/impl/sequence/FastElementSequence#FastElementSequence(org.tensorflow.ndarray.impl.AbstractNdArray\u003cT, U\u003e, int, U, org.tensorflow.ndarray.buffer.DataBufferWindow\u003c?\u003e))([AbstractNdArray](/jvm/api_docs/java/org/tensorflow/ndarray/impl/AbstractNdArray)\\\u003cT, U\\\u003e ndArray, int dimensionIdx, U element, [DataBufferWindow](/jvm/api_docs/java/org/tensorflow/ndarray/buffer/DataBufferWindow)\\\u003c?\\\u003e elementWindow) |\n\n### Public Methods\n\n|-----------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| [NdArraySequence](/jvm/api_docs/java/org/tensorflow/ndarray/NdArraySequence)\\\u003cU\\\u003e | [asSlices](/jvm/api_docs/java/org/tensorflow/ndarray/impl/sequence/FastElementSequence#asSlices())() Returns each element as a new slice. |\n| void | [forEachIndexed](/jvm/api_docs/java/org/tensorflow/ndarray/impl/sequence/FastElementSequence#forEachIndexed(java.util.function.BiConsumer\u003clong[], U\u003e))(BiConsumer\\\u003clong\\[\\], U\\\u003e consumer) |\n| Iterator\\\u003cU\\\u003e | [iterator](/jvm/api_docs/java/org/tensorflow/ndarray/impl/sequence/FastElementSequence#iterator())() |\n\n### Inherited Methods\n\nFrom class java.lang.Object \n\n|------------------|---------------------------|\n| boolean | equals(Object arg0) |\n| final Class\\\u003c?\\\u003e | getClass() |\n| int | hashCode() |\n| final void | notify() |\n| final void | notifyAll() |\n| String | toString() |\n| final void | wait(long arg0, int arg1) |\n| final void | wait(long arg0) |\n| final void | wait() |\n\nFrom interface [org.tensorflow.ndarray.NdArraySequence](/jvm/api_docs/java/org/tensorflow/ndarray/NdArraySequence) \n\n|----------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| abstract [NdArraySequence](/jvm/api_docs/java/org/tensorflow/ndarray/NdArraySequence)\\\u003cU extends [NdArray](/jvm/api_docs/java/org/tensorflow/ndarray/NdArray)\\\u003cT\\\u003e\\\u003e | [asSlices](/jvm/api_docs/java/org/tensorflow/ndarray/NdArraySequence#asSlices())() Returns each element as a new slice. |\n| abstract void | [forEachIndexed](/jvm/api_docs/java/org/tensorflow/ndarray/NdArraySequence#forEachIndexed(java.util.function.BiConsumer\u003clong[], T\u003e))(BiConsumer\\\u003clong\\[\\], U extends [NdArray](/jvm/api_docs/java/org/tensorflow/ndarray/NdArray)\\\u003cT\\\u003e\\\u003e consumer) Visit each elements of this iteration and their respective coordinates. |\n\nFrom interface java.lang.Iterable \n\n|-----------------------------------------------------------------------------------------------------|-------------------------------------|\n| abstract void | forEach(Consumer\\\u003c? super T\\\u003e arg0) |\n| abstract Iterator\\\u003cU extends [NdArray](/jvm/api_docs/java/org/tensorflow/ndarray/NdArray)\\\u003cT\\\u003e\\\u003e | iterator() |\n| abstract Spliterator\\\u003cU extends [NdArray](/jvm/api_docs/java/org/tensorflow/ndarray/NdArray)\\\u003cT\\\u003e\\\u003e | spliterator() |\n\nPublic Constructors\n-------------------\n\n#### public\n**FastElementSequence**\n([AbstractNdArray](/jvm/api_docs/java/org/tensorflow/ndarray/impl/AbstractNdArray)\\\u003cT, U\\\u003e ndArray, int dimensionIdx, U element, [DataBufferWindow](/jvm/api_docs/java/org/tensorflow/ndarray/buffer/DataBufferWindow)\\\u003c?\\\u003e elementWindow)\n\n\u003cbr /\u003e\n\nPublic Methods\n--------------\n\n#### public [NdArraySequence](/jvm/api_docs/java/org/tensorflow/ndarray/NdArraySequence)\\\u003cU\\\u003e\n**asSlices**\n()\n\nReturns each element as a new slice.\n\nUnlike conventional Java collections, elements of a `NdArraySequence` are transient, i.e. new `NdArray`\ninstances are allocated for each iteration. To improve performance, the same instance can be recycled to view\nall elements of this sequence, using a [DataBufferWindow](/jvm/api_docs/java/org/tensorflow/ndarray/buffer/DataBufferWindow).\n\nIn some cases though, it might be preferable to disable such optimizations to ensure that each element returned is a\nnew slice of the original array. For example, if one or more elements visited must live beyond the scope of the sequence\niteration, `asSlices()` makes sure that all elements returned by the sequence are unique instances.\n\n final List\u003cIntNdArray\u003e vectors = new ArrayList\u003c\u003e();\n IntNdArray matrix = NdArrays.ofInts(Shape.of(6, 6));\n ndArray.elements(0).forEach(e -\u003e vectors::add); // Not safe, as `e` might always be the same recycled instance\n ndArray.elements(0).asSlices().forEach(e -\u003e vectors::add); // Safe, each `e` is a distinct NdArray instance\n \n\u003cbr /\u003e\n\n\u003cbr /\u003e\n\n\u003cbr /\u003e\n\n##### Returns\n\n- a sequence that returns each elements iterated as a new slice \n\n#### public void\n**forEachIndexed**\n(BiConsumer\\\u003clong\\[\\], U\\\u003e consumer)\n\n\u003cbr /\u003e\n\n#### public Iterator\\\u003cU\\\u003e\n**iterator**\n()\n\n\u003cbr /\u003e"]]