20-API-新特性

IO资源释放

概念：
IO里为了资源一定会被释放，通常要写在finally语句块中，但是写起来非常复杂繁琐。

​ jdk7的新特性，把IO释放资源过程进行了优化，可以实现IO的自动资源管理。

代码案例

//这个类用来测试IO释放资源
public class Test2_IO {
    public static void main(String[] args) {
		 method();//jdk7.0前
         method2();//jdk7.0后
    }
    //jdk7.0后--try with resources
    private static void method2() {
        try(
            //读取资源
            InputStream in = new BufferedInputStream ( new FileInputStream("D:\\iotest\\1.txt")  );
            //写出资源
            OutputStream out = new BufferedOutputStream (  new FileOutputStream("D:\\iotest\\2.txt")   );
        ) {
            //边读边写
            int b;//记录读取到的数据
            while ((b = in.read()) != -1) {
                out.write(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //jdk7.0前
    private static void method() {
        //因为finally里已经变量的作用范围，所以需要把变量的作用范围扩大。
        InputStream in = null;
        OutputStream out = null;
        try {
            //读取资源
            in = new FileInputStream("D:\\iotest\\1.txt");
            //写出资源
            out = new FileOutputStream("D:\\iotest\\2.txt");
            //边读边写
            int b;//记录读取到的数据
            while ((b = in.read()) != -1) {
                out.write(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {//我有  必须要  执行的代码。
            //释放资源  --  怎么保证资源一定会被释放！！！
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

集合工具类

为Collection集合提供的工具类，提供了丰富的方法

常用方法

方法名	解释
addAll(Collection<? super T> c, T... elements)	将所有指定的元素添加到指定的集合。
max(Collection<? extends T> coll)	求集合中元素的最大值
min(Collection<? extends T> coll)	求集合中元素的最小值
static void``reverse(List<?> list)	反转指定列表中元素的顺序。
sort(List<T> list)	对指定的列表进行排序。
static void``swap(List<?> list, int i, int j)	交换指定列表中指定位置的元素。

案例

//这个类用来测试 集合工具类 Collections
public class Test3_Collection {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        //1、没用工具类前，需要一个个往里添加元素
        //        list.add(1);
        //        list.add(2);
        //        list.add(3);
        //2、用了工具类，一次性向，指定集合中添加多个元素
        Collections.addAll(list,1,2,3,4,5);
        System.out.println(list);//[1, 2, 3, 4, 5]

        System.out.println( Collections.max(list)  );//获取指定集合中的最大值
        System.out.println( Collections.min(list)  );//获取指定集合中的最小值

        Collections.reverse(list);//把指定集合中的元素 反转
        Collections.sort(list);//给指定集合排序，从小到大
        Collections.swap(list,2,4);//将指定集合中的指定下标元素进行交换

        System.out.println(list);//[1, 2, 5, 4, 3]

    }
}

线程池

概念：
多线程可以提高程序的执行效率，因为提高了CPU的使用率。
线程池优化了多线程的操作，比如：线程池提供已经new好的线程，并且会自动回收。实现线程的复用性。
Executors工具类：辅助创建线程池

创建对象	解释
static ExecutorService newCachedThreadPool()	新建带有缓存的线程池
static ExecutorService newFixedThreadPool(int nThreads)	新建固定大小的线程池
static ExecutorService newSingleThreadExecutor()	创建一个线程

ExecutorService工具类：执行一个或多个异步任务
void execute(Runnable command) 在未来某个时间执行给定的命令

测试案例

//这个类用来测试 线程池
public class Test4_ThreadPool {
    public static void main(String[] args) {
        //1、创建线程池对象 -- 参数是 线程池的大小(线程数)
        ExecutorService pool = Executors.newFixedThreadPool(3);
        //2、利用线程池执行线程任务
        //execute();//参数需要Runnable接口类型  --  我们直接传入  匿名对象+匿名内部类
        for (int i = 0; i < 3; i++) {  //4、循环3次，就会执行3次，因为execute执行了3次。
            pool.execute( new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 100 ; i++) {
                        System.out.println(Thread.currentThread().getName()+"==="+i);
                        //3、线程名：
			//pool-1-thread-3===80   pool-1-thread-2===41  pool-1-thread-1===8
                    }
                }
            }
       );
        }

    }
}

可变参数

是jdk种的一个新特性,可以传入多个参数,可变参数本质上是一个数组,但是要出现在参数列表的最后位置

案例演示

package cn.tedu.bubble;

import java.util.Arrays;

//这个类用来测试 jdk新特性 -- 可变参数：反射中用到了Class工具类有体现！！
public class Test5_Variable {
    public static void main(String[] args) {
        add(1,2);
        add(1,2,3);
        add(1,2,3,4,5);
    }
    //是方法名相同，但是参数列表不同的方法  --  叫方法的重载  --  出现的目的是提高程序的灵活性
    //1、...就是可变参数的体现，体现了参数的个数  省略不管。
    private static void add(int b,int...a) {//3、可变参数必须是参数列表中的最后一个
        //2、可变参数，为什么传入几个参数  a接收呢？---本质上a是数组  --  [I@1b6d3586
        System.out.println(a);
        System.out.println(Arrays.toString(a));//[1, 2, 3, 4, 5]
    }

}

lambda表达式

​ Lambda 表达式（lambda expression）是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象（lambda abstraction），是一个匿名函数，即没有函数名的函数

Lambda表达式：优化了匿名内部类的编写

Lambda表达式要求接口中，只能有一个抽象方法。

语法：(参数列表) -> {语句或语句块}

代码展示

public class Test6_Lambda {
    public static void main(String[] args) {
        //2、利用匿名对象  +  匿名内部类，使用接口的功能
        Demo d = new Demo(){
            @Override
            public void save() {
                System.out.println("save()...");
            }
        } ;
        d.save();
        //3、Lambda表达式优化匿名内部类
        //      Demo d2 = (参数列表) -> { 方法体  } ;
        Demo d2 = () -> {  System.out.println("save()...lambda");  } ;
        //3.1、Lambda表达式没参数
        d2.save();
        Demo2 demo2 = (int x,int y) -> {  System.out.println(x+y); } ;
        //4、Lambda表达式有参数
        demo2.add(1,2);
        //4.1、把实参1 和 2 传递给了形参 x 和 y ，并打印求和的结果

        Demo3 demo3 = (int m,int n)->  { return m+n ;  } ; 
        //5、Lambda表达式有参数 有返回值，通过return把值返回
        System.out.println( demo3.add(5,10)  );
        //5.1、把实参5 和 10 传递给了形参 m 和 n ，求和，并返回结果
    }
}
interface Demo3{
    int add(int a,int b);
}
interface Demo2{
    void add(int a,int b) ;
}
//1、准备接口：Lambda表达式要求接口中，只能有一个抽象方法。
interface Demo{
    void save ();
}