精华内容
下载资源
问答
  • Java try-with-resource

    千次阅读 2019-04-29 13:47:35
    Java try-with-resource语句 Try-with-resourse语句类似于Python中的with语句,都是自动释放资源,而不用像传统的try-catch-finally一样必须使用finally关闭资源,而且当资源释放比较多的时候,会出现嵌套关闭资源的现象...

    Java try-with-resource语句

    Try-with-resourse语句类似于Python中的with语句,都是自动释放资源,而不用像传统的try-catch-finally一样必须使用finally关闭资源,而且当资源释放比较多的时候,会出现嵌套关闭资源的现象.

    下面是一些具体使用方法

    普通的资源释放方法

    /**
        * @Description: 普通的资源释放方法
        * @Param: []
        * @return: void
        * @Author: Chen
        */
        @Test
        public void testDemo2() {
            Scanner scanner = null;
            try {
                scanner = new Scanner(new File("H:\\TestProject\\src\\main\\java\\com\\chen\\test.txt"));       //这里的路径一定要写完整路径
                while (scanner.hasNext()) {
                    System.out.println(scanner.nextLine()); //逐行读取
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } finally {
                //读取完毕则关闭
                if (scanner != null) {
                    scanner.close();
                }
            }
        }
    

    使用try-with-resource方法会自动关闭资源

    /**
        * @Description: 使用try-with-resource方法会自动关闭资源
        * @Param: []
        * @return: void
        * @Author: Chen
        */
        @Test
        public void testDemo3() {
            try (Scanner scanner = new Scanner(new File("H:\\TestProject\\src\\main\\java\\com\\chen\\test.txt"))) {
                while (scanner.hasNext()) {
                    //逐行读取文件中的内容
                    System.out.println(scanner.nextLine());
                }
            } catch (FileNotFoundException file) {
                file.printStackTrace();
            }
        }
    

    使用try-with-resource关闭多个资源

    /**
        * @Description: 使用try-with-resource关闭多个资源
        * @Param:
        * @return:
        * @Author: Chen
        */
        @Test
        public void testDemo4() {
            try (Scanner scanner = new Scanner(new File("H:\\TestProject\\src\\main\\java\\com\\chen\\test.txt"));
                PrintWriter writer = new PrintWriter(new File("H:\\TestProject\\src\\main\\java\\com\\chen\\testWrite.txt"))
            ) {
                while (scanner.hasNext()) {
                    //test.txt文件的内容写入到test2中
                    writer.println(scanner.nextLine());
                }
            } catch (FileNotFoundException file) {
                file.printStackTrace();
            }
        }
    

    测试资源关闭的顺序

    import java.io.File;
    import java.util.Scanner;
    
    public class AutoCloseableResourcesFirst implements AutoCloseable {
        /**
        * @program: TestProject
        * @description: 需要被关闭的资源
        * @author: Mr.Wang
        * @create: 2019-04-29 11:37
        **/
        public AutoCloseableResourcesFirst() {
            System.out.println("构造方法----->第一个被自动释放的资源");
        }
    
        public void doSomething() {
            System.out.println("someThing方法----->第一个被自动释放的资源");
        }
    
        public void close() throws Exception {
            System.out.println("自动关闭资源1");
        }
    
    }
    
    public class AutoCloseableResourcesSecond implements AutoCloseable{
        /**
        * @program: TestProject
        * @description: 第二个被自动关闭资源的类
        * @author: Mr.Wang
        * @create: 2019-04-29 12:41
        **/
        public AutoCloseableResourcesSecond() {
            System.out.println("构造方法----->第二个被自动释放的资源");
        }
    
        public void doSomething() {
            System.out.println("someThing方法----->第二个被自动释放的资源");
        }
    
        public void close() throws Exception {
            System.out.println("自动关闭资源2");
        }
    }
    
    /**
     * @Description: 测试资源关闭的顺序
     * @Param: []
     * @return: void
     * @Author: Chen
     */
    @Test
    public void testDemo5() {
        try (AutoCloseableResourcesFirst af = new AutoCloseableResourcesFirst();
             AutoCloseableResourcesSecond as = new AutoCloseableResourcesSecond()) {
            af.doSomething();
            as.doSomething();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    
    展开全文
  • java try catch 异常后还会继续执行吗

    万次阅读 2019-08-06 18:37:40
    java try catch 异常后还会继续执行吗? catch 中如果你没有再抛出异常 , 那么catch之后的代码是可以继续执行的 , 但是try中 , 报错的那一行代码之后 一直到try结束为止的这一段代码 , 是不会再执行的 所以,try块...

    java try catch 异常后还会继续执行吗?

    catch 中如果你没有再抛出异常 , 那么catch之后的代码是可以继续执行的 , 但是try中 , 报错的那一行代码之后 一直到try结束为止的这一段代码 , 是不会再执行的

    所以,try块不要写的太大

    展开全文
  • java try-with-resources 语句

    千次阅读 2015-10-29 16:51:18
    java try-with-resources 语句

    – Start
    首先,我们看下面的代码。

    BufferedReader br = null;
    try {
        br = new BufferedReader(new FileReader("test.txt"));
        br.readLine();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        if (br != null)
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
    }

    有些资源使用完是需要释放的,通常我们在 finally 语句中做这件事情。这样的代码看上去会很乱,要是 java 能帮我们自动释放资源就好了。我们的美好愿望实现了,Java SE 7 引入了 try-with-resources 语句,只要你的类实现了接口 java.lang.AutoCloseable, java 自动帮我们调用 close 方法释放资源,看看下面的代码吧,是不是非常整洁。

    try (BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
        br.readLine();
    } catch (Exception e) {
        e.printStackTrace();
    }

    – 更多参见:Java SE 精萃
    – 声 明:转载请注明出处
    – Last Updated on 2015-10-29
    – Written by ShangBo on 2015-10-29
    – End

    展开全文
  • Java Try with Resources

    千次阅读 2018-05-01 19:28:30
    Java7之前,没有自动资源管理,我们应该在我们的工作完成后明确地关闭资源。 通常,它是在try-catch语句的finally块中完成的。 当我们忘记关闭资源时,这种方法会导致内存泄漏和性能问题。 before Java 7: ...

    资源是一个程序利用后必须关闭的对象。 例如,用于数据库连接的文件资源或JDBC资源或套接字连接资源。 在Java7之前,没有自动资源管理,我们应该在我们的工作完成后明确地关闭资源。 通常,它是在try-catch语句的finally块中完成的。 当我们忘记关闭资源时,这种方法会导致内存泄漏和性能问题。

    before Java 7:

    try{
        //open resources like File, Database connection, Sockets etc
    } catch (FileNotFoundException e) {
        // Exception handling like FileNotFoundException, IOException etc
    }finally{
        // close resources
    }

    Java 7 try with resources implementation:

    try(// open resources here){
        // use resources
    } catch (FileNotFoundException e) {
        // exception handling
    }
    // resources are closed as soon as try-catch block is executed.

    接下来分别看看Java6和Java7的简单例子:

    Java 6 :

    public class Java6ResourceManager {
    
        public static void main (String[] args) {
            BufferedReader bufferedReader = null;
            try {
                bufferedReader = new BufferedReader(new FileReader("C:\\Users\\10944\\Desktop\\python.txt"));
                System.out.println(bufferedReader.readLine());
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (bufferedReader != null) {
                        bufferedReader.close();
                    }
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        }
    
    }

    Java 7:

    public class Java7ResourceManager {
    
        public static void main (String[] args) {
            try (BufferedReader bufferedReader = new BufferedReader(new FileReader("C:\\Users\\10944\\Desktop\\python.txt"))) {
                System.out.println(bufferedReader.readLine());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
    }

    Java try with resources 的好处:

    1. 代码的可读性更好,更易于编写代码
    2. 自动化的资源管理
    3. 代码的行数被减少
    4. 不需要使用finally块来关闭资源
    5. 我们可以通过在try-with-resources中使用分号来间隔多个资源,例子如下:
    try (BufferedReader br = new BufferedReader(new FileReader(
                    "C:\\python.txt"));
                    java.io.BufferedWriter writer = java.nio.file.Files.newBufferedWriter(FileSystems.getDefault().getPath("C:\\journaldev.txt"), Charset.defaultCharset())) {
                System.out.println(br.readLine());
            } catch (IOException e) {
                e.printStackTrace();
            }

    7.当我们在try-with-resources中使用多个资源的时候,try-with-resources会在关闭时通过逆序的方式关闭,从而避免出现资源依赖的问题。

    Java 7 介绍了一个新的接口:java.lang.AutoCloseable。任何资源在用于 try-with-resources 时,都需要实现这个接口,否则Java编译器会抛出编译问题。

    以下是个简单的例子:

    public class Java7ResourceManagement {
    
        public static void main(String[] args) {
    
            try (MyResource mr = new MyResource()) {
                System.out.println("MyResource created in try-with-resources");
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("Out of try-catch block.");
        }
    
        static class MyResource implements AutoCloseable{
    
            @Override
            public void close() throws Exception {
                System.out.println("Closing MyResource");
            }
    
        }
    }

    上面的程序运行结果是:

    MyResource created in try-with-resources
    Closing MyResource
    Out of try-catch block.

    从上面的输出可以清晰的看出,只要try-catch模块完成,资源关闭的方法就会被调用。

    Try with Resources Exceptions:

    在异常的情况下,try-catch-finally 和 try-with-resources 是有不同的地方的。

    如果一个异常在 try 块和 finally 块中被抛出,最终方法返回的将是在finally快块中抛出的异常。

    而对 try-with-resources 而言,如果一个异常在 try 块和 try-with-resources 中被抛出,那么方法返回的将是在 try 中抛出的异常。

    以下讲一个简单的例子:

    public class Java7ResourceManagerDiff {
    
        public static void main (String[] args) throws Exception {
            try {
                tryWithResourceException();
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
    
            try {
                normalTryException();
            }catch (Exception e) {
                System.out.println(e.getMessage());
            }
        }
    
    
        private static void normalTryException () throws Exception {
            MyResource myResource = null;
            try {
                myResource = new MyResource();
                System.out.println("MyResource created in block!");
                if (true) {
                    throw new Exception("Exception in try block");
                }
            } finally {
                if (myResource != null) {
                    myResource.close();
                }
            }
        }
    
        private static void tryWithResourceException () throws Exception{
            try (MyResource myResource = new MyResource()) {
                System.out.println("MyResource created in try-with block!");
                if (true) {
                    throw new Exception("Exception in try block");
                }
            }
        }
    
        static class MyResource implements AutoCloseable {
    
            @Override
            public void close() throws Exception {
                System.out.println("Closing MyResource!");
                throw new Exception("Exception in Closing");
            }
        }
    
    }

    上面的输出是:

    MyResource created in try-with block!
    Closing MyResource!
    Exception in try block
    MyResource created in block!
    Closing MyResource!
    Exception in Closing

    原文:
    https://www.journaldev.com/592/java-try-with-resources

    展开全文
  • java try-catch语句

    千次阅读 2018-07-03 13:10:44
    try-catch语句 Java使用try-catch语句来处理异常,将可能出现的异常操作放在try-catch语句的try部分,一旦try部分抛出异常对象,或调用某个可能抛出异常对象的方法,并且该方法抛出了异常对象,那么try部分将立刻...
  • java try没有catch

    千次阅读 2018-06-13 10:44:05
    JDK并发工具包中,很多异常处理都使用了如下的结构,如AbstractExecutorService,即只有try和finally没有catch。 [java] view plain copy print?class X   { &...
  • Java try语句的嵌套

    千次阅读 2018-06-25 13:48:30
    Try语句可以被嵌套。也就是说,一个try语句可以在另一个try块内部。每次进入try语句,异常的前后关系都会被推入堆栈。如果一个内部的try语句不含特殊...如果没有catch语句匹配,Java的运行时系统将处理这个异常。...
  • java try后面括号的作用

    千次阅读 2018-03-07 16:49:28
    Java7新特性,支持使用try后面跟随()括号管理释放资源例如通常使用try代码块 1 try { 2 fis = new FileInputStream(source); 3 fos = new FileOutputStream(target); 4 5 byte[] buf = new byte[8192]; 6 ....
  • 需要知道的是:finally的语句会先于try或者catch的返回语句之前执行,如果finally中有return语句,那么try或catch中的return语句会被finally中的return覆盖,不建议在finally中放return 情况一:try、catch和finally...
  • 本文链接:https://blog.csdn.net/qq_38225558/article/details/82054100try {可能出现异常的代码(包括不会出现异常的代码)} catch (Exception e) { //()里为接收try{}代码块中出现异常的类型如...
  • java try with resources方式关闭资源

    千次阅读 2018-07-23 16:01:38
    在我们使用资源时,一般资源使用完毕,都需要把资源关闭掉,在JDK7之前,我们一般都是使用try-catch-finally在finally中进行资源的关闭。 示例如下: public static void test1(){ FileInputStream ins = null...
  • Java7提供了try-with-resources机制,其类似Python中的with语句,将实现了 java.lang.AutoCloseable 接口的资源定义在 try 后面的小括号中,不管 try 块是正常结束还是异常结束,这个资源都会被自动关闭。...
  • java trycatch变量是局部的

    千次阅读 2017-03-10 10:03:59
    java变量的作用域分为四个级别:类级、对象实例级、方法级、块级。 块级变量就是定义在一个块({})内部的变量都是局部变量 try{}中try后面的{}就是一个块级作用域,所以内部定义的变量是局部变量。错误的写法...
  • 应用场景:当我们使用带资源的try语句时,使用finally也许会造成一个异常被覆盖的问题,即try语句块中会抛出某个异常,执行finally语句块中跑出了同样的异常,这样的话就会导致原有的异常会丢失,转而抛出的finally...
  • Java try/catch的实现原理与性能

    千次阅读 2019-05-06 13:56:40
    首先明确一个概念,在Java中如果不发生异常的话,try/catch其实不会造成任何性能损失。这是如何做到的呢 首先,在Java文件编译成为字节码之后,其实正常流程与异常处理部分是分开来的,如下图所示: ...
  • Java的江湖中,存在着一种名为finally的功夫,它可以保证当你习武走火入魔之时,还可以做一些自救的操作。在远古时代,处理资源关闭的代码通常写在finally块中。然而,如果你同时打开了多个资源,那么将会出现噩梦...
  • Java try和catch的使用

    千次阅读 2016-11-23 16:50:26
    尽管由Java运行时系统提供的默认异常处理程序对于调试是很有用的,但通常你希望自己处理异常。这样做有两个好处。第一,它允许你修正错误。第二,它防止程序自动终止。 package com.lyf;public class My { public ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 76,860
精华内容 30,744
关键字:

javatry

java 订阅