Est-ce que java a un équivalent du C # & # 8220; using & # 8221; clause
https://stackoverflow.com/questions/141241
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
J'ai vu dans certaines questions postées par C # la référence à "en utilisant". clause. Java a-t-il l'équivalent?
La solution
Oui. Java 1.7 a introduit la structure try-with-resources permettant de: écrire:
try(InputStream is1 = new FileInputStream("/tmp/foo");
InputStream is2 = new FileInputStream("/tmp/bar")) {
/* do stuff with is1 and is2 */
}
... comme un utilisant .
Malheureusement, avant Java 1.7, les programmeurs Java étaient obligés d'utiliser try {...} finally {...}. 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();
}
Autres conseils
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 passés en tant que paramètres de l'instruction try doivent implémenter java.lang.AutoCloseable . Jetez un coup d'œil à la documents officiels .
Pour les anciennes versions de Java Checkout, cette réponse et cette réponse .
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 que la forme générale est toujours:
acquire;
try {
use;
} finally {
release;
}
Si l’acquisition se trouve dans le bloc try, vous libérez le logiciel en cas d’échec de l’acquisition. Dans certains cas, vous pourrez peut-être utiliser du code inutile (en général, tester l'exemple de null ci-dessus), mais dans le cas de, par exemple, ReentrantLock, de mauvaises choses se produiront.
Si vous faites souvent la même chose, vous pouvez utiliser l'option "exécuter autour de". idiome. Malheureusement, la syntaxe de Java est verbeuse, il y a donc beaucoup de bolier plate.
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, les exceptions d'emballage.
Pas que je sache. Vous pouvez un peu simuler en essayant ... de bloquer, mais ce n’est pas tout à fait pareil.
Le plus proche que vous pouvez obtenir en Java est try / finally. De plus, Java ne fournit pas de type implicite jetable.
C #: portée de la variable en dehors d'un bloc d'utilisation
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: définition 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 #: analyse de la variable à l'intérieur d'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: définition de la variable à l'intérieur 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) {}
}
}
Cela prenait du temps, mais avec Java 7, les try-with -resources statement a été ajouté, ainsi que la AutoCloseable interface.
Je pense que vous pouvez obtenir quelque chose de similaire à l'option "utiliser". bloquer, implémenter une classe interne anonyme. Comme le fait le printemps avec les "Modèles Dao".
Eh bien, l’utilisation du sucre syntaxique était de toute façon une solution pour que les boursiers Java ne le suent pas.
Si nous obtenons des fermetures BGGA en Java, cela s’ouvrirait également pour des structures similaires en Java. Gafter a utilisé cet exemple dans ses diapositives, par exemple:
withLock(lock) { //closure }
Le langage utilisé par la plupart des programmeurs pour le premier exemple est le suivant:
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 d'indentation avec cet idiome, ce qui devient encore plus important lorsque vous avez plus de 2 ressources à nettoyer.
De plus, vous pouvez ajouter une clause catch à la structure qui traitera du lancement par le nouveau FileStream () d’une exception si vous en avez besoin. Dans le premier exemple, vous devriez avoir un autre bloc try / catch englobant si vous voulez le faire.
Non, il n'y en a pas.
Vous pouvez
public void func(){
{
ArrayList l = new ArrayList();
}
System.out.println("Hello");
}
Ceci vous donne la portée limitée de la clause using, 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, utiliser des finaliseurs en Java est généralement une mauvaise idée.
Non, Java n’est pas utilisé, la fonctionnalité la plus similaire est l’option " import " mot clé.
