9
votes

Manière non obsolète d'ajouter un élément à une liste dans Scala 2.7.5?

Comment ajoutez-vous un élément à une liste dans scala 2.7.5, sans créer de nouvelle liste et sans utiliser de solution obsolète.


2 commentaires

La mutation est mauvaise, mmkay :)


Peut-être devriez-vous clarifier si par "sans créer une nouvelle liste " Vous voulez dire ne pas dupliquer toute la liste en mémoire ou que toutes les références à la liste reflètent le changement. Ce dernier n'est pas possible, comme la liste , à Scala, est immuable.


6 Réponses :


2
votes

La méthode + = sur une liste est obsolète car elle ajoute un élément à la queue, ce qui est coûteux. Le moyen le moins coûteux d'ajouter un élément à une liste consiste à ajouter à la tête à l'aide de :: = .

L'avertissement de dépréciation est donc un indice subtil que vous devez redéfinir votre programme pour travailler en prépendeur. Au lieu d'ajouter: xxx

(Notez que :: = et + = sur un var ne sont pas des méthodes réelles, mais le sucre pour l = l :: elem , etc.)


6 commentaires

Mais est l toujours la même liste? De plus, vous êtes en train de préparer, pas à l'annexe.


Eh bien, vous n'avez pas répondu à la question :)


Souvent, la vraie solution au problème sous-jacent n'est pas une réponse directe à la question initiale.


@Leppie Les questions posent comment on ajoute un élément. Le titre de la question mentionne l'annexe. Il a donc répondu à la question, mais pas le titre. :-)


@Daniel: Non, il a demandé comment le faire sans créer une nouvelle liste.


Leppie, si vous êtes au courant de la manière dont le sucre syntaxique de Scala permet des opérations de style apparemment mutables sur des objets immuables variables, il est logique d'interpréter cette partie de la question comme «sans explicitement créer une nouvelle liste ". Et au cas où il / elle n'était pas au courant de cela, je l'ai mentionné aussi.



17
votes

Il convient de souligner que la liste a une signification très spécifique dans Scala, qui n'est pas équivalente à l'interface java.util.list . Liste est une classe abstraite scellée, représentant une structure de données reconsive qui a une tête et a queue . (Il existe des structures de liste de liste Java à Scala, dont certaines sont mutables.)

La liste Scala's s sont immuables ; La modification d'une liste de quelque manière que ce soit n'est pas possible, bien que vous puissiez créer une nouvelle liste, préparez-vous à un nouvel objet (qui donne un nouvel objet). Même s'ils sont immuables, la structure n'est plus chère en termes de création d'objets que, par exemple, ajoute à un java.util.linkedlist

La méthode + a été obsolète pour une bonne raison car elle est inefficace; Utilisez plutôt: xxx

Je suppose qu'une manière différente serait de préparer avec 2 inversions: xxx

Je doute que c'est Plus efficace! En général, si je veux appendez comportement, j'utilise prépendez , puis inverse (au point d'avoir besoin d'accéder à la liste): xxx


4 commentaires

C'est une argumentation, pourquoi la question pourrait être une mauvaise. Mais cela ne répond pas à la question.


Cela répond exactement à la question. Le questionneur a demandé comment ajouter à une liste sans créer une nouvelle liste. C'est impossible! Peut-être devriez-vous développer pourquoi vous avez bownvothed ma réponse (correcte)


Jens, pour appliquer votre propre raisonnement, vous n'avez pas répondu à la question que cela vous demande comment appendez-le à une liste , pas un linkedlist ou listbuffer , dont aucun des deux résultat de la liste . (Pourtant, votre réponse est toujours utile.)


J'aime annoncer la liste existante à une nouvelle liste d'une approche de l'article!



1
votes

1 commentaires

c'est possible, mais va contre l'esprit de Scala



24
votes

Vous pouvez utiliser un listbuffer , qui fournit une heure constante ajoute: xxx


0 commentaires

15
votes

voie non obsolète d'ajouter un élément à une liste dans Scala 2.7.5?

Cela n'existe pas, et il n'existera jamais.

Comment ajoutez-vous un élément à une liste dans Scala 2.7.5, sans créer de nouveau Liste et sans utiliser de dépréciation Solution.

utiliser :: : xxx

ou, si list est un var , xxx

Il ne crée pas de nouvelle liste (cependant, il crée un nouveau :: , également appelé contre ), et il ajoute un élément à celui-ci.

Si vous souhaitez ajouter des éléments à une séquence sans créer de nouvelle séquence, utilisez une structure de données mutable.


3 commentaires

Ceci réellement achète un élément à une liste, qui est différent d'un fonctionnement append .


@OPENSAS LISTE est immuable, vous ne pouvez donc pas le changer. Vous devez affecter une nouvelle liste à la variable, ce qui nécessite d'utiliser une mission.


Oups, je pensais que si la liste était un var, ce n'était plus immuable



1
votes

Ce qui suit n'est pas vrai pour la mise en œuvre de la liste des opérations. Merci à Sschaef pour la correction.


Un point très important que je n'ai pas vu mentionné ici est que la création d'une nouvelle collection d'une autre collection n'est pas nécessairement aussi coûteuse à Scala que dans Java. Ce concept s'appelle la persistance. Daniel Spiewak le prévoit dans son article, http://www.codecommit.com/blog/scala/scala-collections-for-the-astillement-bored-Part-1 .

Voici un extrait de la section correspondante,

Bien sûr, la question naturelle qui vient à l'esprit est, qu'en est-il de la performance? Si chaque invocation crée en fait un nouvel ensemble pour chaque appel récursif, cela ne nécessite que beaucoup de copie d'objet inefficace et d'opérations de tas? Eh bien, comme il s'avère, ce n'est pas vraiment le cas. Oui, une nouvelle instance doit être créée à chaque tour, ce qui est une opération relativement coûteuse sur la JVM, mais presque rien n'est copié. Toutes les structures de données immuables de SCALA ont une propriété appelée persistance, ce qui signifie que vous ne copiez pas les données de l'ancien conteneur lors de la création d'une nouvelle référence, vous venez d'avoir la nouvelle référence à l'ancienne et de traiter tout son contenu comme s'il s'agissait étaient ses propres.

Donc, alors qu'il sera moins coûteux d'utiliser une liste mutable, il n'est pas autant de préoccupation que c'est sous Java.


3 commentaires

Ceci n'est vrai que pour les structures de données immuables dont le contenu peut être partagé en raison de ses références existantes. Ce n'est pas le cas lorsque vous souhaitez ajouter un élément à la liste Scalas, car il s'agit d'une liste unique liée et aucune référence au dernier élément n'existe. Cela signifie que chaque élément doit être copié afin d'annoncer un élément qui est O (n). En revanche, un élément est O (1) parce que le nouvel élément peut pointer vers l'ancienne liste sans rien copier (c'est ce que votre devis décrit).


@sschaf, ah merci de me corriger, je suis nouveau à Scala et je tiens à tout comprendre.


Pour votre édition: il est vrai pour la liste, mais pas pour toutes les opérations. La même chose avec d'autres structures de données ...