क्या जावा के पास सी # "उपयोग" खंड के बराबर है

Question

मैंने कुछ सी # पोस्ट किए गए प्रश्नों में "उपयोग" खंड में संदर्भ देखा है। क्या जावा के बराबर है?

Answer 1

हां। जावा 1.7 की शुरुआत की try-with-resources निर्माण आप लिखने के लिए अनुमति देता है:

try(InputStream is1 = new FileInputStream("/tmp/foo"); 
    InputStream is2 = new FileInputStream("/tmp/bar")) { 
     /* do stuff with is1 and is2 */ 
} 

... सिर्फ एक using बयान की तरह।

दुर्भाग्य से, जावा 1.7 से पहले, जावा प्रोग्रामर को {...} अंत में {...} का उपयोग करने के लिए मजबूर होना पड़ा। जावा 1.6:

InputStream is1 = new FileInputStream("/tmp/foo"); 
try{ 

    InputStream is2 = new FileInputStream("/tmp/bar"); 
    try{ 
     /* do stuff with is1 and is 2 */ 

    } finally { 
     is2.close(); 
    } 
} finally { 
    is1.close(); 
} 

Answer 2

ऐसा नहीं है कि मुझे पता है। आप कुछ हद तक कोशिश कर सकते हैं ... आखिरकार ब्लॉक करें, लेकिन यह अभी भी वही नहीं है।

Answer 3

नहीं, जावा में कोई उपयोग नहीं है, सबसे समान कार्यक्षमता "आयात" कीवर्ड है।

Answer 4

कोई नहीं है।

आप कर सकते हैं

public void func(){ 

    { 
    ArrayList l = new ArrayList(); 
    } 
    System.out.println("Hello"); 

} 

यह आपको खंड का उपयोग कर के सीमित दायरे देता है, लेकिन वहाँ अंतिम रूप दिए जाने कोड कॉल करने के लिए किसी भी IDisposable इंटरफ़ेस नहीं है। आप कोशिश {} पकड़() {} अंत में {} का उपयोग कर सकते हैं, लेकिन इसका उपयोग करने की चीनी नहीं है। संयोग से जावा में फाइनलाइज़र का उपयोग करना आम तौर पर एक बुरा विचार है।

Answer 5

मुझे लगता है कि आप किसी अज्ञात आंतरिक वर्ग को लागू करने, "उपयोग" ब्लॉक के समान कुछ प्राप्त कर सकते हैं। वसंत की तरह "दाओ टेम्पलेट्स" के साथ करता है।

Answer 6

जावा में सबसे नज़दीक आप प्राप्त कर सकते हैं/अंत में। इसके अलावा, जावा एक अंतर्निहित डिस्पोजेबल प्रकार प्रदान नहीं करता है।

सी #: एक ब्लॉक के बाहर चर देखते हुए

public class X { 

    public void dispose() { 
     System.out.println("dispose"); 
    } 

    private static void demo() { 
     X x = new X(); 
     try { 
      int i = 1/0; 
     } finally { 
      x.dispose(); 
     }   
    } 

    public static void main(String[] args) { 
     try { 
      demo(); 
     } catch(ArithmeticException e) {} 
    } 

} 

सी #: एक ब्लॉक के अंदर चर देखते हुए

एक का उपयोग कर ब्लॉक

public class X : System.IDisposable { 

    public void Dispose() { 
     System.Console.WriteLine("dispose"); 
    } 

    private static void Demo() { 
     X x = new X(); 
     using(x) { 
      int i = 1; 
      i = i/0; 
     } 
    } 

    public static void Main(System.String[] args) { 
     try { 
      Demo(); 
     } catch (System.DivideByZeroException) {} 
    } 

} 

जावा के बाहर चर देखते हुए

public class X : System.IDisposable { public void Dispose() { System.Console.WriteLine("dispose"); } private static void Demo() { using(X x = new X()) { int i = 1; i = i/0; } } public static void Main(System.String[] args) { try { Demo(); } catch (System.DivideByZeroException) {} } } 

जावा: एक ब्लॉक

public class X { 

    public void dispose() { 
     System.out.println("dispose"); 
    } 

    private static void demo() { 
     { 
      X x = new X(); 
      try { 
       int i = 1/0; 
      } finally { 
       x.dispose(); 
      } 
     } 
    } 

    public static void main(String[] args) { 
     try { 
      demo(); 
     } catch(ArithmeticException e) {} 
    } 

} 

Answer 7

खैर अंदर चर देखते हुए, का उपयोग कर वाक्यात्मक चीनी वैसे भी था, इसलिए जावा साथियों, यह पसीना नहीं आता।

Answer 8

भाषा के भीतर निकटतम समतुल्य प्रयास-अंत का उपयोग करना है।

using (InputStream in as FileInputStream("myfile")) { 
    ... use in ... 
} 

हो जाता है

final InputStream in = FileInputStream("myfile"); 
try { 
    ... use in ... 
} finally { 
    in.close(); 
} 

नोट सामान्य रूप हमेशा होता है:

acquire; 
try { 
    use; 
} finally { 
    release; 
} 

तो अधिग्रहण की कोशिश ब्लॉक में है, तो ऐसा होता है कि अधिग्रहण में विफल रहता है में जारी करेंगे। कुछ मामलों में आप अनावश्यक कोड (आमतौर पर उपरोक्त उदाहरण में शून्य के लिए परीक्षण) के साथ हैक करने में सक्षम हो सकते हैं, लेकिन कहने के मामले में, ReentrantLock खराब चीजें होती हैं।

यदि आप अक्सर वही काम कर रहे हैं, तो आप "निष्पादित" मूर्खता का उपयोग कर सकते हैं। दुर्भाग्यवश जावा का वाक्यविन्यास वर्बोज़ है, इसलिए बहुत सारी बोलीर प्लेट है।

fileInput("myfile", new FileInput<Void>() { 
    public Void read(InputStream in) throws IOException { 
     ... use in ... 
     return null; 
    } 
}); 

जहां

public static <T> T fileInput(FileInput<T> handler) throws IOException { 
    final InputStream in = FileInputStream("myfile"); 
    try { 
     handler.read(in); 
    } finally { 
     in.close(); 
    } 
} 

अधिक जटिल उदाहरण मेरी, उदाहरण के लिए, अपवाद लपेट दें।

Answer 9

यदि हमें जावा में बीजीजीए बंद हो जाता है, तो यह जावा में समान संरचनाओं के लिए भी खुल जाएगा। Gafter उदाहरण के लिए, अपने स्लाइड में इस उदाहरण का इस्तेमाल किया गया:

withLock(lock) { //closure } 

Answer 10

वास्तविक पहला उदाहरण के लिए सबसे प्रोग्रामर द्वारा इस्तेमाल किया मुहावरा यह है:

InputStream is1 = null; 
InputStream is2 = null; 
try{ 
    is1 = new FileInputStream("/tmp/bar"); 
    is2 = new FileInputStream("/tmp/foo"); 

    /* do stuff with is1 and is 2 */ 

} finally { 
    if (is1 != null) { 
     is1.close(); 
    } 
    if (is2 != null) { 
     is2.close(); 
    } 
} 

वहाँ कम इस मुहावरा है, जो हो जाता है का उपयोग कर इंडेंट है और भी महत्वपूर्ण जब आपके पास सफाई के लिए 2 संसाधन हैं।

इसके अलावा, आप संरचना के लिए एक पकड़ खंड जोड़ सकते हैं जो आपको नई फ़ाइलस्ट्रीम() के अपवाद को फेंकने के साथ सौदा करेगा यदि आपको इसकी आवश्यकता है। अगर आप ऐसा करना चाहते हैं तो पहले उदाहरण में आपको एक और संलग्न प्रयास/पकड़ ब्लॉक होना होगा।

Answer 11

यह लंबे समय से आ रहा था लेकिन जावा 7 के साथ try-with-resources statementAutoCloseable इंटरफ़ेस के साथ जोड़ा गया था।

Answer 12

हाँ, जावा 7 के बाद से आप को फिर से लिखने कर सकते हैं:

InputStream is1 = new FileInputStream("/tmp/foo"); 
try{ 

    InputStream is2 = new FileInputStream("/tmp/bar"); 
    try{ 
     /* do stuff with is1 and is2 */ 

    } finally { 
     is2.close(); 
    } 
} finally { 
    is1.close(); 
} 

रूप

try(InputStream is1 = new FileInputStream("/tmp/foo"); 
    InputStream is2 = new FileInputStream("/tmp/bar")) { 
     /* do stuff with is1 and is2 */ 
} 

वस्तुओं कोशिश बयान के पैरामीटर के रूप में पारित कर दिया java.lang.AutoCloseable .Have official docs पर एक नज़र लागू करना चाहिए।

जावा चेकआउट this answer और this answer के पुराने संस्करणों के लिए।