关于Java新特性的学习

java8新特性

一、

interface Animals{  //定义一个动物接口
    void run();     //跑   的方法
    void shout();   //叫  的方法
}

//狗接口
interface Dog{
    void shout();
}
class jinmao implements Animals,Dog{ //定义一个金毛类实现这两个接口
    public void print(){
        System.out.println("动物");
    }
    //重写方法就不写了 （简单）
}
class erha implements Animals,Dog{//定义一个二哈类实现这两个接口
    public void print(){
        System.out.println("动物");
    }
    //方法重写就不写了（简单）
}

如以上的代码，倘若有多个实现类中要求输出“动物”，一个一个输出麻烦。java8之前 接口中写方法体没意义。java新特性如下

interface Animals{
    void run;
    void shout;
    //新特性
    default void print(){
        System.out.println("动物");
    };
}

二、内部类
一个文件定义多个类不是内部类，就像下面

public class demo{
}                      //两个类相互独立，没有关系
class demo{
}

1、内部类

public class demo1{
    pinlic static void main(String[],args){
    Demo d = new Demo();
    d.fun();
    
    //需要导入包
    Inner i = new Inner();
    i.print(); 
    }
    
    //结果输出两个内部类打印

}
class demo{
    private String str = "外部类中的字符串"；
    static class Inner{
        private String instr = "内部类中的字符串"；
        public void print(){ 
            //静态内部类无法调用非静态的外部参数
            // System.out.println(str);
            System.out.println(s"内部类打印");
        }
        
    }
    public void fun(){ //重新定义一个方法
        //在外部类创建内部类对象
        
        Inner i = new inner(){
        i.print();
        }
    }
    
}

2、匿名内部类

public clas Demo3{
    public static void print(){
    //以前都是定义一个类，实现这个接口
        //匿名类的使用
        new Inter(){
            @Override
            public void test(){
                System.out.println("hhh");
            }
        }.test();
    }
    //内部类 1----n的累加
    public static void test(){
        class XXs{
            int count = 0;
            public void sum(int n){
                for(int i;i<=n;i++){
                    count = count +i;
                    System.out.println(count);
                }
            }
        }
        XXx x = new XXx();
        x.sum(100);          //输出1+2+...+100的值
    }
}
interface Inter{
    void test();
}

lambda表达式

把代码变得更加简单，可读性较差

interface Inter{
    int c();
}
interface Inter1{
    int c1(int x);
}
interface Inter2{
    int c2(int a int b);
}
interface Str{
  void str(String s);
}
public class Demo{
    public static void main(){
        //匿名类
       
        new Inter(){
            @Override
            public int c(){
                return 6;
            } 
        }.c();
        //lambda表达式简化法
        //1、没有参数,直接返回 :() -> 6;  （参数列表）-> 语句块；
        Inter d = () -> 6;
        d.c();
        
        //有参数的
        new Inter1(){
             @Override
             public int c1(int x){
                 return x * 2;
             }
        }.c1(100);
        
        //2、接受一个参数lambda（类型） -> x * 2;
        Inter1 d1 = (y) -> {return y * 2;};
        d1.(100);
         
        //3、两个参数的lambda实现Inter2
        //（a,b）-> {return a - b};
        Inter2 d2 = (x,y) -> {return x - y;};
        d2.(23,20);

        //4、接受声明类型参数
        Inter2 d3 = (int x, int y) ->{return x - y;};
        Inter2 d3_1 = (int x, int y) -> x - y;
        Inter2 d3_2 = (int x, int y) -> x * y;
        Inter2 d3_3 = (int x, int y) -> x / y;
        Inter2 d3_4 = (int x, int y) -> x + y;
        
        //5、传递接口
        //函数传递的形式 parm1=数值1 pram2=数值2 pram3=运算方式
        private static int test(int x, int y, Inter a){
            a.c2(x,y);
        }
        int m = test(1,2,d3_4);
        System.out.println(s);
        System.out.println(1,2,d3_1);
        
        //6、接受字符串对象，并在控制台打印
        Str d4 = (String s) -> {System.out.println(s);};
        
        Str d4_1 = (s) -> System.out.println(s);
        d4-1.str("hello");
    }
}

方法的引用 ::

public class Demo{
    public static void main(){
        String[] strs = new String[]{"a", "b","c"};
        Arrays.asList(strs);

        List<String> list = new ArrayList<String>();
        list.add("a");
        list.add("b");
        list,forEach((String b) -> System.out.println(b));
        list.forEach(e -> System.out.println(e));
        
        //方法引用
        list.forEach(System.out::print)
    }
}

Java高级特性stream流

如图，一串数据每个字母之间用空格隔开
这时候就可以利用空格，使用spit（" "）来拆分 存储在一个map里面（把这串横向的数据转化成竖状。当然在这之前可以先进行排序也就是sorted（），最后存在容器里。
过滤filter–map–聚合reduce。

List<Integer> list = Arrays.asList{100,500,200,600,700};
//foEach迭代每个数据
//Stream()--为list集合去创建串行流
Stream stream = list.stream();
//map把数据拆分
stream.map(new Function<Integer,Integer>(){
    @Override
    public Integer apply(Integer t){
        
        return t / 2;
    }
});
//遍历
map.forEach(System.out::print)  //拆分后打印
//发现打印后没排序，所以我们可以在拆分之前加一个排序


//简化lambda
Arrays.asList{100,500,200,600,700}.stream().map((i) -> i / 2).forEach(System.out::println);

Integer[] num = {1,2,3,4,5,6,7};
//Stream.of  管道流 /从里面取奇偶数   filter方法
Stream.of(num).filter(n -> n%2==0).forEach(System.out::print);

//偶数放在数组中
Integer[] ii=Stream.of(num).filter(n -> n%2==0).toArray(Integer[]::new);

//奇数放在容器
Stream.of(num).filter(n -> n%2！=0).collect(Collectors.toList());

reduce

//求和 求最大 求最小 聚合操作

Integer[] nums = {1,2,3,4,5,6,7};
Stream.of(nums).reduce(0,(a,b) -> a + b); //0是初始值， 后面是聚合的条件

//也可以使用Number里面的sum函数
Stream.of(nums).reduce(0,Integer::sum);
System.out.println(sum);

//[1]  [2,3]  [4,5,6]
Stream<List<Integer>> inputStream = Stream.of(Array.asList(1),Array.asList(2,3),Array.asList(4,5,6));

//扁平化处理（把上面三个数组变成一个数组）
stream<Integer> outputStream = inputStream.flatMap(x -> x.stream());