Java ha un equivalente della clausola "using" di C #
https://stackoverflow.com/questions/141241
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Ho visto un riferimento in alcune domande pubblicate su C # a un " usando " clausola. Java ha l'equivalente?
Soluzione
Sì. Java 1.7 ha introdotto il costrutto try-with-resources che consente di scrivere:
try(InputStream is1 = new FileInputStream("/tmp/foo");
InputStream is2 = new FileInputStream("/tmp/bar")) {
/* do stuff with is1 and is2 */
}
... proprio come un'istruzione usando .
Sfortunatamente, prima di Java 1.7, i programmatori Java erano costretti a usare try {...} finalmente {...}. In 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();
}
Altri suggerimenti
Sì, da Java 7 è possibile riscrivere:
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();
}
Come
try(InputStream is1 = new FileInputStream("/tmp/foo");
InputStream is2 = new FileInputStream("/tmp/bar")) {
/* do stuff with is1 and is2 */
}
Gli oggetti passati come parametri all'istruzione try dovrebbero implementare java.lang.AutoCloseable . Dai un'occhiata a documenti ufficiali .
Per le versioni precedenti di Google Checkout questa risposta e questa risposta .
L'equivalente più vicino all'interno della lingua è usare try-finally.
using (InputStream in as FileInputStream("myfile")) {
... use in ...
}
diventa
final InputStream in = FileInputStream("myfile");
try {
... use in ...
} finally {
in.close();
}
Nota che il modulo generale è sempre:
acquire;
try {
use;
} finally {
release;
}
Se l'acquisizione si trova all'interno del blocco try, rilascerai nel caso in cui l'acquisizione fallisca. In alcuni casi potresti essere in grado di hackerare con il codice non necessario (in genere test per null nell'esempio precedente), ma nel caso, diciamo, di ReentrantLock succedano cose brutte.
Se fai spesso la stessa cosa, puoi utilizzare " esegui intorno " idioma. Sfortunatamente la sintassi di Java è dettagliata, quindi c'è un sacco di bolier plate.
fileInput("myfile", new FileInput<Void>() {
public Void read(InputStream in) throws IOException {
... use in ...
return null;
}
});
dove
public static <T> T fileInput(FileInput<T> handler) throws IOException {
final InputStream in = FileInputStream("myfile");
try {
handler.read(in);
} finally {
in.close();
}
}
Esempio più complicato, ad esempio, le mie eccezioni a capo.
Non di cui sono a conoscenza. Puoi simulare un po 'con un tentativo ... infine bloccare, ma non è ancora lo stesso.
Il più vicino che puoi ottenere in Java è provare / finalmente. Inoltre, Java non fornisce un tipo Usa e getta implicito.
C #: scoping la variabile all'esterno di un blocco using
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: scoping la variabile all'esterno di un blocco
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 #: scoping la variabile all'interno di un blocco
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: scoping la variabile all'interno di un blocco
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) {}
}
}
È passato molto tempo ma con Java 7 il prova-con -resources statement , insieme a Interfaccia richiudibile automaticamente .
Penso che tu possa ottenere qualcosa di simile al " usando " bloccare, implementando una classe interna anonima. Come fa la primavera con i "Modelli Dao" &
Bene, usare lo zucchero sintattico comunque, così i compagni di Java, non sudare.
Se otteniamo chiusure BGGA in Java, questo si aprirà anche per strutture simili in Java. Gafter ha usato questo esempio nelle sue diapositive, ad esempio:
withLock(lock) { //closure }
Il vero linguaggio usato dalla maggior parte dei programmatori per il primo esempio è questo:
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();
}
}
Ci sono meno rientri nell'uso di questo idioma, che diventa ancora più importante quando hai più di 2 risorse da ripulire.
Inoltre, puoi aggiungere una clausola catch alla struttura che gestirà il nuovo FileStream () generando un'eccezione se ne hai bisogno. Nel primo esempio dovresti avere un altro blocco try / catch racchiuso se vuoi farlo.
No non c'è.
Puoi
public void func(){
{
ArrayList l = new ArrayList();
}
System.out.println("Hello");
}
Questo ti dà l'ambito limitato della clausola using, ma non esiste alcuna interfaccia IDisposable per chiamare il codice di finalizzazione. Puoi usare try {} catch () {} Finalmente {}, ma non ha lo zucchero di usare. L'uso accidentale di finalizzatori in Java è generalmente una cattiva idea.
No, non è possibile utilizzarlo in Java, la funzionalità più simile è "import " parola chiave.
