एक बार विधि निष्पादित करना संभव है?

Question

मैं पाश और इस तरह की संरचना के लिए एक है:

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

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

उस में के लिए पाश केवल एक बार निष्पादित करने के लिए एक विधि के लिए संभव है?

Answer 1

ज़रूर से एक नज़र here है ..

if(!alreadyExecuted) { 
    doTrick(); 
    alreadyExecuted = true; 
} 

Answer 2

शायद ब्रेक कीवर्ड आपको क्या चाहिए? विधि कॉल ब्रेक चलाने के बाद; मुझे खेद है कि 100% स्पष्ट नहीं है कि आप अपने प्रश्न से क्या मतलब रखते हैं।

सूरज डॉक्स

Answer 3

आप इस चाल का उपयोग करके if() से बच सकते हैं:

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(); 
     ... 
    } 
} 

Answer 4

एक और overkill समाधान:

आप जो करना चाहते हैं उसके आधार पर, स्थिर प्रारंभिक ब्लॉक का उपयोग करना संभव हो सकता है।

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 
    } 
} 

सरल समाधान:

या, बजाय तुम सिर्फ पाश के बाहर पहले भाग पर अमल करना चाहते हैं:

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

Answer 5

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); 
     } 
    } 
} 

Answer 6

मेरे ऐप से मेरी नमूना:

boolean alreadyExecuted = false; 

तो

:

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); 
     } 

Answer 7

जावा 8 में, आप प्रभावी रूप से इस का उपयोग कर स्वत: Memoization को यहां बताए गए कर सकते हैं: Do it in Java 8: Automatic memoization

मुझे लगता है कि Memoization मानता हूँ एक "एक बार चलाने" परिदृश्य के लिए overkill माना जा सकता है, लेकिन यह पिछले उत्तरों में वर्णित कुछ लोगों के लिए एक साफ विकल्प है।

उदाहरण के लिए:

public void doSomething() { ... } 

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

public void doSomethingOnce() { 
    cache.computeIfAbsent(true, x -> { 
    doSomething(); 
    return true; 
    }); 
} 

Answer 8

आपका यकीन है कि काम केवल कहा जाता है पहली बार बनाने के लिए AtomicBoolean उपयोग कर सकते हैं:

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

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

उपयोग:

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

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