Est-ce que java a un équivalent à la clause C# "using"

Question

J'ai vu des références dans certaines questions postées par C# à une clause "using". Est-ce que java a l'équivalent?

Answer 1

Oui. Java 1.7 a introduit la construction try-with-resources vous permettant d'écrire:

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

... comme une déclaration using.

Malheureusement, avant Java 1.7, les programmeurs Java étaient obligés d'utiliser try {...} enfin {...}. En Java 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

Pas que je sache. Vous pouvez simuler un peu avec un try ... finally block, mais ce n'est toujours pas pareil.

Answer 3

Non, il n'y a pas d'utilisation en Java, la fonctionnalité la plus similaire est le mot clé "import".

Answer 4

Non, il n'y en a pas.

Vous pouvez

public void func(){ 

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

} 

Cela vous donne la portée limitée de la clause à l'aide, mais il n'y a pas d'interface IDisposable pour appeler le code de finalisation. Vous pouvez utiliser try {} catch() {} Finally {}, mais il n'a pas le sucre d'utiliser. Incidemment, l'utilisation de finaliseurs en Java est généralement une mauvaise idée.

Answer 5

Je pense que vous pouvez réaliser quelque chose de similaire au bloc "using", en implémentant une classe interne anonyme. Comme le fait le printemps avec les "modèles Dao".

Answer 6

Le plus proche que vous pouvez obtenir en Java est try/finally. En outre, Java ne fournit pas de type jetable implicite.

C#: la portée de la variable en dehors d'un aide de bloc

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

} 

Java: la portée de la variable en dehors d'un bloc

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

} 

C#: la portée de la variable dans un bloc

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

} 

Java: la portée de la variable dans un bloc

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

Eh bien, en utilisant du sucre syntaxique était de toute façon si Java semblables, ne transpirent pas.

Answer 8

L'équivalent le plus proche dans la langue est d'utiliser try-finally.

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

devient

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

Notez la forme générale est toujours:

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

Si l'acquisition est dans le bloc d'essai, vous publierons dans le cas où l'acquisition échoue. Dans certains cas, vous pourriez être en mesure de pirater avec du code inutile (typiquement tester null dans l'exemple ci-dessus), mais dans le cas de, disons, ReentrantLock mauvaises choses vont se passer.

Si vous faites souvent la même chose, vous pouvez utiliser l'idiome "execute around". Malheureusement, la syntaxe de Java est verbeuse, donc il y a beaucoup de plaque de Bolier.

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

où

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

exemple plus compliqué mon, par exemple, enveloppez exceptions.

Answer 9

Si nous obtenons des fermetures BGGA en Java, cela ouvrirait aussi des structures similaires en Java. Gafter a utilisé cet exemple dans ses diapositives, par exemple:

withLock(lock) { //closure } 

Answer 10

L'idiome réel utilisé par la plupart des programmeurs pour le premier exemple est la suivante:

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

Il y a moins indentation en utilisant cet idiome, qui devient encore plus important lorsque vous avez plus de 2 ressources à nettoyer.

De plus, vous pouvez ajouter une clause catch à la structure qui va traiter les nouvelles FileStream() en lançant une exception si vous en avez besoin. Dans le premier exemple, vous devriez avoir un autre bloc essay/catch si vous vouliez le faire.

Answer 11

Il a fallu attendre longtemps, mais avec Java 7, le try-with-resources statement a été ajouté, ainsi que l'interface AutoCloseable.

Answer 12

Oui, depuis Java 7, vous pouvez réécrire:

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

Comme

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

Les objets transmis en tant que paramètres à l'instruction try devrait mettre en œuvre java.lang.AutoCloseable .Have un regard sur le official docs.

Pour les versions plus anciennes de Java, passez la commande this answer et this answer.