Il est possible de faire une méthode execute qu'une seule fois?

J'ai une boucle for et de structure comme ceci:

for(....)
....
....
if(isTrue)
... do something..
.. method to be executed once (doTrick) is declared outside for loop.
....endif
endfor

public void doTrick()
...
...
..end

Est-il possible qu'une méthode pour la boucle sera exécutée qu'une seule fois?

quelle est la différence?
Tous les bouchons implique que c'est un acronyme, qui elle ne l'est pas.
Ce n'est pas un acronyme mais un nom afin de ne pas écrire en majuscules
hmm eh bien, nous savions tous ce que je voulais dire donc il n'y a pas de différence, puisque James dire ..

OriginalL'auteur Gandalf StormCrow | 2010-04-19

java

37

Sûr!..
```
if(!alreadyExecuted) {
    doTrick();
    alreadyExecuted = true;
}
```
Dans un environnement multithread vous souhaitez synchroniser ce bloc.
Sans doute si l'alreadyExecuted va être une variable locale même si,

OriginalL'auteur Rosdi Kasim

Votre pouvez utiliser AtomicBoolean pour s'assurer que la tâche n'est appelée la première fois:

public class Once {
    private AtomicBoolean done = new AtomicBoolean();

    public void run(Runnable task) {
        if (done.get()) return;
        if (done.compareAndSet(false, true)) {
            task.run();
        }
    }
}

Utilisation:

Once once = new Once();
once.run(new Runnable() {
    @Override
    public void run() {
        foo();
    }
});

//or java 8
once.run(() -> foo());

OriginalL'auteur Hover Ruan

4

Vous pouvez éviter la if() en utilisant cette astuce:
```
private Runnable once;
private final static Runnable NOP = new Runnable () {
    public void run () {
        //Do nothing
    }
}

public void method () {
    once = new Runnable () {
        public void run () {
            doTrick();
            once = NOP;
        }
    }

    for (...) {
        ...
        once.run();
        ...
    }
}
```
Qui pourrait fonctionner, mais c'est un peu exagéré, n'est-ce pas? Rosdi la réponse est beaucoup plus simple/plus clair.
-1 Pourquoi vous voulez éviter les si() ?
Pour élargir votre horizon 🙂
C'est pour un cas simple. Dès que les conditions deviennent plus complexes et vous avez besoin de plus qu'une "exécuter une fois" par boucle, cette astuce peut devenir beaucoup plus lisible puisque vous pouvez extraire du code de la boucle, à peu de frais.
Désolé, pas convaincu, si le code d'aller dans le si est compliqué ensuite de le déplacer dans une méthode privée, si la logique est devenue plus complexe, alors que l'op aurait besoin de refactoriser à ce point, sans doute aller en bas de la stratégie/méthode de modèle de route. De cette manière rend l'unité de test plus compliqué, et à l'aide d'un exécutable aurait développeurs à essayer de comprendre où filetage devient concernés.

OriginalL'auteur Aaron Digulla
3

Dans Java 8, vous pouvez effectivement le faire à l'aide automatique memoization comme décrit ici: Le faire en Java 8: Automatique memoization

Je vais vous avouer que memoization pourrait être considérée comme excessive pour un "exécuter en une seule fois" le scénario, mais c'est plutôt une alternative propre à certains décrites dans les réponses précédentes.

Par exemple:
```
public void doSomething() { ... }

Map<Boolean, Boolean> cache = new ConcurrentHashMap<>();

public void doSomethingOnce() {
  cache.computeIfAbsent(true, x -> {
    doSomething();
    return true;
  });
}
```
OriginalL'auteur mkrufky
2

peut-être le mot-clé break est ce que vous avez besoin? Après l'exécution, vous l'appel de la méthode break; je suis désolé de ses pas 100% clair ce que vous voulez dire à partir de votre question.

Ont un look ici du soleil docs

Une pause serait la fin de la boucle for immédiatement. Comme la boucle contient plus de code, que seule la méthode de l'appel, je suppose une rupture n'est pas prévu.

OriginalL'auteur Paul Whelan

Un autre excès de solution:

En fonction de ce que vous voulez faire, il pourrait être possible d'utiliser un bloc d'initialisation statique.

public class YourKlass{
    public void yourMethod(){

        DoTrick trick; 

        for( int i = 0; condition; i++){
            //... (1)
            trick = new DoTrick(); //or any kind of accessing DoTrick
            //... (2)
        }

    } 
}

public class DoTrick{
    static{
        //Whatever should be executed only once 
    }
}

Solution Simple:

Ou, au contraire, vous voulez juste pour exécuter la première partie de l'extérieur de la boucle:

int i = 0;
if( condition ){
    //... (1)
    //do trick
    //... (2)
}
for(i = 1; condition; i++){
    //... (1)
    //... (2)
}

-1 la Première solution est overkill, la deuxième solution n'est pas DANS la boucle.

OriginalL'auteur Mike

import java.util.ArrayList;

class RemoveDuplicate {
    public static void main(String[] args) {
        ArrayList<String> originalList = new ArrayList<String>();
        originalList.add("foo");
        originalList.add("bar");
        originalList.add("bat");
        originalList.add("baz");
        originalList.add("bar");
        originalList.add("bar");
        String str="bar";
        ArrayList<String> duplicateList = new ArrayList<String>();

        //adding duplicates to duplicateList
        for(String currentString : originalList) {
        if(currentString.startsWith(str)) {
                duplicateList.add(currentString);
            }
        }
        //removing duplicates in duplicatesList
        for(String removeString : duplicateList) {
            originalList.remove(removeString);
        }
        //finally adding duplicateElement
        originalList.add(str);

        for(String currEntry : originalList) {
            System.out.println(currEntry);
        }
    }
}

Comment est-ce lié à la question?

OriginalL'auteur Ranga Reddy

mon exemple de partir de mon application:

boolean alreadyExecuted = false;

alors :

private void startMyService() {

    if(!alreadyExecuted) {

        final Handler handler = new Handler();
        handler.postDelayed(new Runnable() {
          @Override
          public void run() {
            //Do something after 4 seconds
              context.startService(new Intent(context, myService.class));
              alreadyExecuted = true;
          }
        }, 4000);
       }

alreadyExecuted n'est pas utilisé dans votre code postal.

OriginalL'auteur Joolah

Vous devez vous connecter pour publier un commentaire.