Será que java tem um equivalente ao C # “usando” cláusula
https://stackoverflow.com/questions/141241
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Eu vi em algum C # posted perguntas para um "usando" cláusula. Será java ter o equivalente?
Solução
Sim. Java 1.7 introduziu o tentar-com-recursos construir o que lhe permite escreve:
try(InputStream is1 = new FileInputStream("/tmp/foo");
InputStream is2 = new FileInputStream("/tmp/bar")) {
/* do stuff with is1 and is2 */
}
... assim como uma declaração using. |
Infelizmente, antes de Java 1.7, os programadores Java foram forçados a usar try {...} finally {...}. Em 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();
}
Outras dicas
Sim, desde que Java 7 você pode reescrever:
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();
}
Como
try(InputStream is1 = new FileInputStream("/tmp/foo");
InputStream is2 = new FileInputStream("/tmp/bar")) {
/* do stuff with is1 and is2 */
}
Os objetos passados ??como parâmetros para a instrução try deve implementar java.lang.AutoCloseable.Have uma olhada no documentação oficial .
Para versões mais antigas do Java check-out esta resposta e esta resposta .
O equivalente mais próximo dentro da linguagem é usar try-finally.
using (InputStream in as FileInputStream("myfile")) {
... use in ...
}
se torna
final InputStream in = FileInputStream("myfile");
try {
... use in ...
} finally {
in.close();
}
Observe a forma geral é sempre:
acquire;
try {
use;
} finally {
release;
}
Se a aquisição está dentro do bloco try, você vai lançar no caso em que a aquisição falhar. Em alguns casos você pode ser capaz de cortar ao redor com código desnecessário (tipicamente teste para NULL no exemplo acima), mas no caso de, digamos, ReentrantLock coisas ruins vão acontecer.
Se você está fazendo a mesma coisa muitas vezes, você pode usar o "executar em torno de" idioma. Infelizmente sintaxe do Java é detalhado, para que haja um monte de placa bolier.
fileInput("myfile", new FileInput<Void>() {
public Void read(InputStream in) throws IOException {
... use in ...
return null;
}
});
onde
public static <T> T fileInput(FileInput<T> handler) throws IOException {
final InputStream in = FileInputStream("myfile");
try {
handler.read(in);
} finally {
in.close();
}
}
exemplo mais complicado o meu, por exemplo, exceções envoltório.
Não que eu estou ciente de. Você tanto pode simular com um try ... finally bloco, mas ainda não é bem o mesmo.
O mais próximo que você pode obter em Java é try / finally. Além disso, Java não fornece um tipo descartável implícita.
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: o escopo da variável fora de um bloco
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 #: escopo da variável dentro de um bloco
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: o escopo da variável dentro de um bloco
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) {}
}
}
Foi um tempo para chegar, mas com Java 7 a tentar-com -Recursos declaração foi adicionado, juntamente com a Interface AutoCloseable .
Eu acho que você pode conseguir algo semelhante a "usar" bloco, implementar uma classe interna anônima. Como Primavera faz com o "Dao De Visita".
Bem, usando foi açúcar sintático assim mesmo assim companheiros Java, não se preocupe.
Se conseguirmos fechamentos BGGA em Java, este seria também abrir para estruturas semelhantes em Java. Gafter usou este exemplo em seus slides, por exemplo:
withLock(lock) { //closure }
O idioma real usado pela maioria dos programadores para o primeiro exemplo deste é:
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();
}
}
Há menos o recuo usando esse idioma, que se torna ainda mais importante quando você tem mais de 2 recursos para limpeza.
Além disso, você pode adicionar uma cláusula catch para a estrutura que vai lidar com o novo FileStream () 's lançar uma exceção se você precisar dele para. No primeiro exemplo, você teria que ter um outro bloco try / catch, se você queria fazer isso.
Não, não é.
Você pode
public void func(){
{
ArrayList l = new ArrayList();
}
System.out.println("Hello");
}
Isto dá-lhe o alcance limitado da cláusula de usar, mas não há qualquer interface IDisposable para chamar finalização código. Você pode usar try {} catch () {} {} Por fim, mas não tem o açúcar de usar. Aliás usando finalizadores em Java é geralmente uma má idéia.
Não, não há usando em Java, a funcionalidade mais semelhante é a palavra-chave "importação".
