java进阶知识点精讲

目录
前言
Math
System
Runtime
BigInteger
BigDecimal
Object
时间类Api
数据包装类
Arrays
正则表达式
lambda表达式
集合进阶

前言

java 大一的时候学的java基础,后来摆烂都忘了大部分所以此笔记用于复习在java中常用到的api 帮助我们解决·需求解决

Math

math是java核心包lang下的类无需引入
常用方法:

获取绝对值

 Math.abs(-12)

ceil 向上取整数轴向正方向取整进1
ps:

 System.out.println(Math.ceil(120.2));//121                                                  
System.out.println(Math.ceil(120.8));//121
System.out.println(Math.ceil(-12.2));//输出-12.0  不是-13

floor向下取整数轴左边(负)方向取整数进1
ps:

System.out.println(Math.floor(-13.2));//-14
System.out.println(Math.floor(13.2));//13

四舍五入
Math.round(4.5)
比较俩个数值的较大值
Math.max(5,8)
底层其实是三元运算符号

  public static int max(int a, int b) {
        return (a >= b) ? a : b;
    }

比较a,b的较小值 min(a,b)

底层逻辑类似
  public static int min(int a, int b) {
        return (a <= b) ? a : b;
    }

-获取a的次幂 pow

System.out.println("5的2此方"+Math.pow(5,2));
System.out.println("5的-2此方"+Math.pow(5,-2));//1/5^2
System.out.println("5的1/2此方"+Math.pow(5,0.5));//更号5  但是不建议这样

更号运算

sqrt平方
cbrt 立方

  System.out.println("------------------------");
    System.out.println("跟更号4"+Math.sqrt(4));//开平方
    System.out.println("8开立方根"+Math.cbrt(8));//立方根

随机数(0~1)

System.out.println("0~1之间的随机数值"+Math.random());//[0,1.0)
        System.out.println("0~100之间的随机整数值"+Math.floor(Math.random()*100));//[0,100)+1  去掉小数值+1 才是 【0,100】

System

该类也是java核心包中的无需引入

-停止当jvm的进程静态方法exit

   System.exit(0);//0正常停止jvm虚拟机 非0异常停止

获取当前系统本地时间搓毫秒

时间搓知识:时间搓从1970 1月1日 0:0:0(时间原点)到现在的毫秒我国在东八区
有8小时时差,所以是在标准时间搓的基础上加8小时时间毫秒值

System.out.println("当前时间搓:"+System.currentTimeMillis())

ps:该方法是获取当前虚拟机所在系统的时间搓,是在标准时间搓上已经获得计算的

数组拷贝

 int[] arr1 = new int[10];//空数组
        int[] arr2={1,2,3,4,5,6,7,8,9};
        /**ps:
         * srcpos :数据源索引
         * destpos :目标数组索引
         * 最后一个参数是拷贝多长
         * 细节:1.如果都是基本数据类型 ,俩者的数据类型必须相同
         * 2.如果数据源素组和目标数组都是引用类型,那么子类可以赋值给父类 因为应用数据类型拷贝的是数据的内存地址 赋值也是
         *    person person1 = new person( "John",15);
         *         person person2 = new person();
         *         person2=person1;
         *         person2.age=20;
         *         System.out.println(person1.age);  此时输出person1的age属性值是20 相同的内存地址 修改了其他引用类使用的值也会发生改变
         */
        System.arraycopy(arr2,0,arr1,0,arr2.length);
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i] );//原素组长度为10 比数据源长 所以长出的一位是10
        }

RunTime

Lang包下的java运行环境类

.静态方法获取Runtime的对象

  Runtime runtime = Runtime.getRuntime();

关闭虚拟机

runtime.exit(0);

System.exit(0)方法关闭虚拟机的底层就是运行环境关闭

public static void exit(int status) {
    Runtime.getRuntime().exit(status);
}

获取当前系统获取cpu的线程数 availableProcessors

 System.out.println("当先环境的运行线程数量："+runtime.availableProcessors());

虚拟机可以获取的最大总内存大小 maxMemory

System.out.println("可以从当先操作系统中获取最多"+runtime.maxMemory()/Math.pow(1024,2)+"个mb内存");

获取虚拟机在当前系统已经获取的内存大小 totalMemory

System.out.println("当前内存消耗:"+runtime.totalMemory()/1024/1024+"MB")

当前获取的内存还有多少空闲 freeMemory

 System.out.println("当前虚拟机剩余空间大小:"+runtime.freeMemory()/1024/1024+"mb");//说明当前程序消耗内存4mb  消耗内存=totalmemory-freememory

exec 运行系统指令

 try {
        Runtime.getRuntime().exec("notepad");//打开系统自带记事本
    } catch (IOException e) {
        e.printStackTrace();
    }

BigInterger

java中的整数 byte 1字节 short 2字 int4字节 long 8b 1b=8bit,所以long可以有64位二进制位存储数字第一位符号位,但是当long的范围也不够用时就可以使用 bitInteger上限接近无限

实例化BigInteger方法
1.第一种范围构造方法初始化
ps:bitInteger对象一旦创建内部数据无法改变和String一样

// 实际开发中用于初始化随机数
 BigInteger bigInterger = new BigInteger(4, new Random());// Random对象 范围是 【0,2】   ,  这里是实例化一个 (pram1的parm2幂此方)-1 范围的随机数   这里是0~15的随机数

2.第二种构造方法制定初始化数值
ps :bit Innteger是整数初始化的时候这个字符串参数只能写整数

   BigInteger b2 = new BigInteger("944444444555555555555555555555555555555555555555555551");//这里范围已经超过long了

3.通过静态方法Valueof实例化

  BigInteger b3 = BigInteger.valueOf(99999);//参数的取值是根据long对象的范围决定的

该方法有一小细节:
当初始化值在 -16 ~16 时采用类似单例模式只会初始化一个对象只是赋予引用地址(类似spring中的单列模式)

 BigInteger b21 = BigInteger.valueOf(13);
        BigInteger b22 = BigInteger.valueOf(13);
System.out.println(b21==b22);

结果:

一般建议使用第二个构造方法实例化 ,范围大无局限

加法
bitInteger的数据操作都是返回一个新的BigInteger对象

BigInteger bigInterger = new BigInteger(4, new Random())
BigInteger radd = bigInterger.add(BigInteger.valueOf(5))

减法

System.out.println(b21.subtract(BigInteger.valueOf(5)))

 BigInteger multiply = b21.multiply(BigInteger.valueOf(5));
        System.out.println(multiply);

除法取商 divide

 BigInteger divide = b21.divide(BigInteger.valueOf(5));
        System.out.println(divide);

除法取余 divideAndRemainder
该方法返回的是一个BigInteger的数组,该数组在源码中长度为2

索引0是商,索引1是余数

  BigInteger[] x = b21.divideAndRemainder(BigInteger.valueOf(5));
        System.out.println("商是:"+x[0]+"余数"+x[1]);

次幂

   BigInteger pow = b2.pow(2);

较大值和较小值
ps:比较是方法返回最大值和较小值不是新建对象

 BigInteger moremax = b2.max(b21);
   BigInteger min = b2.min(BigInteger.valueOf(15));

和其他整数类型的转换

 BigInteger bigIntegerdemo = new BigInteger("55555");
        int i = bigIntegerdemo.intValue();
        long l = bigIntegerdemo.longValue();
        double d= bigIntegerdemo.doubleValue();
        System.out.println("int:"+i);
        System.out.println("long:"+l);
        System.out.println("double:"+d);

运行结果:

BigDecimal

和BigInteger一样都是为了解决数据类型的范围或者精度缺陷而使用的数据类,有着相同的特点,创建后不可改变,且运算对象是返回一个崭新的数据,构造方法和操作方法都大体相同

当使用小数进行加减乘除时候计算机转换为二进制时候会出现精度损失所以才需要该api
用于高精度的运算,比如基金,银行等高数据精度运算

BigDecimal 的实例化
1.通过double类型的小数创建对象 ps:精度会出现误差

  BigDecimal b = new BigDecimal(0.01);
        System.out.println(b);

误差较大 ,不适用

2. 构造方法传递字符串

  BigDecimal b2 = new BigDecimal("0.00001");//精度过高时候会采用16精
    System.out.println(b2);

3.通过静态方法实列化对象

  BigDecimal b3 = BigDecimal.valueOf(10.00005);
        System.out.println(b3);

System.out.println("加法:"+b2.add(BigDecimal.valueOf(12.5)));

System.out.println("减法:"+b2.subtract(BigDecimal.valueOf(12.5)));

   System.out.println("乘法:"+b2.multiply(BigDecimal.valueOf(12.5)));

  System.out.println("除法(只取余商):"+b2.divide(BigDecimal.valueOf(12.5)));
        System.out.println("除法商:"+b2.divideAndRemainder(BigDecimal.valueOf(12.5))[0]+":::除法余:"+b2.divideAndRemainder(BigDecimal.valueOf(12.5))[1]);//和BigInteger一样返回是个数组

除法规定小数点后几位

/**
         * @param1 被除数
         * @param2 保留小数点后几位
         * @param3 表示小数点精度最后一位四舍五入规则up表示原理数轴0的方向进1 down反之 ,ceil向正方向进1,floor表示精度向负方向进1,half_up 数学中的标准的=四舍五入  ,
         */
        System.out.println("保留小数点三位除法:"+b4.divide(BigDecimal.valueOf(3),3,BigDecimal.ROUND_UP));
        System.out.println(b2.max(BigDecimal.valueOf(12.5)));
        System.out.println(b2.min(BigDecimal.valueOf(12.5)));

Object

Object是所有类的超类其中有几个常用方法

tostring
当输出实例化对象的时候默认调用的就是toString

源码:

输出类名和hash值
 public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

实际开发中我们重写该方法输出成员属性:

   @Override
    public String toString() {
        return "student{" +
                "score=" + score +
                '}';
    }

equals 比较俩个对象(引用类型)是否相等
源码:

 public boolean equals(Object obj) {
        return (this == obj);
    }
  //  对于基础类型的变量和常量：变量和引用存储在栈中，常量存储在常量池中。
 //引用对象内存申请在堆中 地址在栈 地址指向内存
  //equals方法实际就是==比较俩个对象的地址

  student s1 = new student();
        s1.age=4;s1.name="test";s1.score=79;
        student s2 = new student();
        s2.age=4;s2.name="test";s2.score=79;
       //俩个实例化对象地址不同 false
        System.out.println("调用equals方法比较"+s1.equals(s2));//ideal重写写后可以比较属性 true euals本来比较的是引用地址

输出结果:

对象克隆对象拷贝

  User Originuser = new User("user1", "{等级:200,攻击力:100,防御:20}", 1656,Signs);
        try {
            User clone2 = (User)Originuser.clone();
            System.out.println("原来对象u1"+Originuser);
            System.out.println("克隆对象u2"+clone2);
            System.out.println(Originuser==clone2);//克隆的是属性 内存地址不通
            //PS:细节这种克隆为浅克隆当对象中有引用数据时候 clone的是内存地址  基本数据类型 拷贝数据值·引用类型拷贝地址值
            clone2.Signs[8]=999;
            System.out.println("这种克隆方式是浅克隆,引用对象克隆的是地址,所以克隆对象修改了引用属性,原对象也会改变"+Originuser.Signs[8]);
            System.out.println(Originuser.Signs==clone2.Signs);//clone方法浅克隆的弊端 无法独立操作
            // 深克隆会将所有属性都是进行数值克隆 引用对象也是 而Object的clone是浅克隆 深clone需要自己改写
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

Obects 对象操作的工具类

常用方法能做到见名知意不多做论述

java中表示时间的类

时间类在Jdk8做了次更新，所以分二段讲解

1.jdk8之前

Date时间类时间的计算标准是格林威治时间变为现在的时间标准

 Date now=new Date();//空参数 表示当前时间
 System.out.println("当前时间"+now);

输出格式

传参制定时间对象(已过时)

Date currentTime = new Date(2008,5,30,11,32);

源码

@Deprecated
public Date(int year, int month, int date, int hrs, int min) {
    this(year, month, date, hrs, min, 0);
}

构造参数为0L时候就是时间原点

   System.out.println("时间原点"+new Date(0L));//设置0L就是时间原点

时间格式化器 SimpleDateFormat
1.用于格式化Date对象

MM表示月 HH表示24的小时
System.out.println("当前时间:"+new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 EE").format(new Date()))

官方文档:

2.用于解析文本时间 (要求格式符号必须对得上)

  //作用2解析字符串时间
        try {
            Date date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2013-07-24 23:11:11");//解析的时间又恢复原始的时间格式
            System.out.println("解析的时间"+date);
        } catch (ParseException e) {
            e.printStackTrace();
        }

Calendar 日历类

  System.out.println("==========================演示日历类 ==============");
        Calendar calendar = Calendar.getInstance();//抽象类只能通过抽象类获取
        System.out.println("当前是几月?"+calendar.get(Calendar.MONTH)+1);//根据系统所在的时区域不同获取日历对象  月:0-11 周日到-周六:1-7  周日是第一天
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
        System.out.println("当前是本周"+(calendar.get(Calendar.DAY_OF_WEEK)-1)//0纪元 1年 2月 3一年的几周 4一月的第几周
        );
        );

该类的核心方法是 get 获取日历的各项数据 ,参数封装在了Calendar自身中
值得注意的是:月份是0-11,而在国外周日才是一周的开始所以周日对应代码1 周一到周日:234561

2.jdk8 时间类

zoneId类表示时区

获取时区

  ZoneId zoneId = ZoneId.systemDefault();//当前系统时区域
  Set<String> availableZoneIds = ZoneId.getAvailableZoneIds();//获取所有时区
        //获取指定时区
        ZoneId of = ZoneId.of("America/Antigua");

instant 时间搓类所有的操作都是返回一个新的instant对象
该对象获取的是标准时间搓
1.now 当前时间搓(标准)

Instant instant = Instant.now();//2.1获取当前时间搓 标准到时间原点的时间搓 需要+8小时
        System.out.println("当前的标准时间搓:"+instant);

2.atZone (指定时区的时间搓)

  ZonedDateTime time = instant.atZone(ZoneId.of("Asia/Aqtau"));
        System.out.println("制定的硅谷时间 搓为:"+time);

3.is 进行时间前后判断

 Instant now1 = Instant.ofEpochMilli(0L);//该方法是获取实例化时间
        Instant now2 = Instant.ofEpochMilli(1000L);//时间圆点+1s
        boolean r = now1.isBefore(now2);
        System.out.println("now1是否在now2之前:"+r);
        System.out.println("now2是否在now1之后:"+now2.isAfter(now1));

4.时间搓进行运算

Instant currenttime = Instant.now();
        
        Instant minuscurrenttime = currenttime.minusMillis(20000L);
        System.out.println("当前时间错"+currenttime+'\n'+"减少时间20s后"+minuscurrenttime);

minus 减法,plus 则是加

5.带时区的时间搓

//.ZoneFateTime 带时区的时间类
        ZonedDateTime now3 = ZonedDateTime.now();
        System.out.println("获取带时区的时间对象"+now3);
        ZonedDateTime zonedDateTime = now3.withMonth(1);//3.1with 修改某部分为固定数值
        ZonedDateTime zonedDateTime1 = now3.withYear(2035);
        System.out.println("修改后的年份"+zonedDateTime1);

格式化时间类

/**
         * DateTimeFormatter 用于时间的格式化和解析
         */
        //1.ofPattern
        //获取时间对象
        ZonedDateTime nowdate = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));//指定时区 什么地方的应用对应时区不同
        //解析/格式化
        String date = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss").format(ZonedDateTime.now()); //用法和simpleDateFormatter一样
//        String date = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format(nowdate); //用法和simpleDateFormatter一样
        System.out.println("格式化的时间"+date);

是不是感觉特别繁琐 ,但是相对于之前增加的is方法可以进行对时间的判断

日历类

localDate 系统时区的年月日期

System.out.println("当前系统所在年份日期"+LocalDate.now());

LocalDate.of() 指定年月

 System.out.println("申明指定时间"+LocalDate.of(2005,5,13));

3.localTime 当前分秒使用场景秒杀活动纳秒级别

 System.out.println("当前系统所时分秒"+LocalTime.now());

4.LocalDateTime 年月时分秒都详细包含

System.out.println("当前系统详细时间:"+LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy年MM月dd日 :HH时mm分ss秒")))

上面三个日历类都可以进行minus,plus,isxx,get等操作

时间比较工具类
```
  1.Duration 时间间隔 s 纳秒
```

  Duration duration = Duration.between(LocalTime.now(), LocalTime.of(5, 25, 29));
    System.out.println(duration);
   
        System.out.println("间隔了多少小时:"+duration.toHours());//砖换间隔

    2.Period 年月日 时间单位

  Period period = Period.between(LocalDate.now(), LocalDate.of(2005, 11, 29));//参数2减去参数1
    System.out.println("间隔多少年{}"+period.getYears());

    /3.ChronoUnit所有时间单位的间隔

通过静态方法选择时间单位
 ChronoUnit.HOURS.between();
 ChronoUnit.SECONDS.between();

可以这样使用因为底层使用到了枚举

mysql中的timestamp类型和java中的localdatetime刚好对应

基本数据的包装类

何为包装类如何理解
包装类和引用对象一样,是把基础数据类型,封装在一个对象中的类.好处是可以传参更广,且集合只能存储引用类型

并且可以对基本数据类型进行各进制的封装
各个数据类型的包装类
处理int 和char 其他的包装类都是首字母大写,接下来演示Integer 作为代表
实例化获取对象的方式

主要是构造方法和静态方法

但是俩种方式有区别代码演示:

Integer i1 = Integer.valueOf("127");
        Integer i2 = Integer.valueOf("127");
        System.out.println(i1==i2);

        Integer i3 = Integer.valueOf("128");
        Integer i4 = Integer.valueOf("128");
        System.out.println(i3==i4);
        //创建新空间 地址肯定不同
        Integer integer = new Integer("127");
        Integer integer2 = new Integer("127");
        System.out.println(integer==integer2);

输出结果:

可以通过==进行比较内存地址发现,其中new申请内存空间的方式实例化,肯定地址不同而静态方法,127为什么俩个对象地址相同呢

查看源码

发现范围在IntegerCache(缓存)的高地范围之间是直接返回缓存

high被设计成127,这样在-128 到127这个常用区间运算,数据无须重复申请内存.

运算

 int i3 = i2.intValue()+ i1.intValue();

因为引用对象无法直接运算 ,只能转为基本类型运算,这样代码量过于冗杂,所以jdk5以后实现了自动装箱(包装)和自动拆箱(数据转换),可以理解包装类就是数据本身了,大大便利了开发

自动装箱拆箱

 ArrayList<Integer> arrayList1=new ArrayList<>();
  Integer a=8;//可以直接申明数据
        arrayList1.add(1);//默认int 和Integer是一种数据处理方式
        arrayList1.add(a);
        arrayList1.add(Integer.valueOf("2"));
        arrayList1.add(3);
        Integer x = arrayList1.get(0);
        int y = arrayList1.get(0);//可以转换

        System.out.println(x);
        System.out.println(y);

        ps:之前练习用到Scanner的next方法,说一下nest方法遇到空格和回车停止输入,nextline只有回车才停止输入,所以建议Scanner工具默认nextline方法控制台输入

包装转换进制

Arrays 数组工具类

属于util包下的工具类,简化数组开发,以下是常用方法

tostring 将数组转换为字符串输出

     Integer[] array = {2,45,44,34,6,78};
        System.out.println("默认升序排序:"+Arrays.toString(array));

(重点) sort 排序

 Arrays.sort(array); //默认升序排序

也可以选择重载的方法自己书写排序规则() ,第二个参数是函数式接口使用匿名内部类方式实例化对象,然后重写函数

   /**
         *重写的    Comparator(比较器) 中的compare(比较方法)
         * @param1 a1表示无序序列中的便利的每一个参数  表示要插入的数据
         * @param2 a2表示已经排好的有序序列中的便利的每一个参数  表示已经经过排序的数据
         * @return 返回值值是负数 a1放在当a2之前,反之之后
         */
      Arrays.sort(array, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;//降序排序
            }
        });

验证并且输出o1,o2

        Integer[] array = {2,45,44,34,6,78};
Arrays.sort(array, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        System.out.println("未排序:"+o1);
        System.out.println("排序:"+o2);
        return o1-o2;//升序排序 也就是 sort参数的默认排序
    }
});

输出结果:
采用快速排序算法,参数一-参数2升序,反之降序

binarySearch 查找元素
细节:1.二分查找要求数组有序升序 2.存在元素返回索引, 不存在返回-应在位置插入点-1

负应在位置插入点-1什么意思呢?代码演示如下

  System.out.println("原数组"+Arrays.toString(array));
        int i = Arrays.binarySearch(array, 10);
        System.out.println("二分查找,该元素10应该在在索引"+i+"的位置");

返回值-3 为什么呢?因为采用二分查找,10如果存在应该在6和34之间,也就是索引2 ,变为负数-1,所以返回-2-1=-3.

数组拷贝 copyof 数组拷贝

Integer[] copy = Arrays.copyOf(array, 8);//参数1 元素组,参数2 拷贝后长度
        System.out.println(Arrays.toString(copy));//跟拷贝长度有关 1.范围=原长度全部拷贝 2.大于全部范围则拷贝的数组补齐默认值(null)

原数组没有到达长度8所以补默认值

copyofRange 数组拷贝(限定范围)

 /**
         * 细节该方法拷贝数组范围[)     俗记 包头不包尾
         */
        Integer[] ofRange = Arrays.copyOfRange(array, 0, 5);
        System.out.println("拷贝结果:"+Arrays.toString(ofRange));

所以输出结果不报阔索引5的数据

fill 填充

 System.out.println("====================fill 数组填充================================");
        Arrays.fill(array,0,2,100);//表示填充0-2部分 填充值100 也是包头不包尾巴
        Arrays.fill(array,1000);//全填充

数组转集合 asList

List<Integer> x = Arrays.asList(array);

正则表达式

当java中判断一个字符串是否满足我们需要的需求,我们会采用正则表达式(regex)。

比如判断一个字符串是否为QQ号,就可以使用字符串的matches方法进行判断
满足规则返回true 否则返回false

  String qq="2613867717";
        //1.使用正则表达式 限制字符串格式

        System.out.println(qq.matches("[1-9]\\d{5,19}"));

正则表达式规则

首先在做练习之前先了解转义字符
\(此处是打了俩个反斜杠,Markdown语法也会识别转义字符,单个反斜杠不可可见),在转义字符后边的字母会改变原本的字符意思,\n(换行),\t(空格)等…以上都是打了俩个反斜杠才表示一个反斜杠(速记双反斜杠才是单反斜杆的作用,单反斜杠本身就被识别转义)

  比如:输出反斜杠

 System.out.println("\\");

这样才是单一斜杠

正则表达式能看懂,并且按照要求改写就行细节如下
1.[] 表示一个字符
2.- 表示字符范围
3.()限定范围比如,&&表示交集,|表示并集

[1-9]\d{16}(\d|x|X)
这里表示的就是 1-9其中一个数字开头,跟16个数字,在拼接任意数字或者X或x,如果不加()
限定范围 则代表整个|符号前和|符号后进行或运算.

4.一般预定义字符和数量词混用
比如\d{5,10} 表示字符串必须满足5个以上,10个数字已下的规则

Idea中正则表达式的插件 –any-rule
1.插件下载 Setting ->plugin 搜索下载

2.插件的使用申明空白字符串右击鼠标点击anyrule 进行选择然后更改

3.进行演示
这里选择身份证号

 String regex="/^[1-9]\d{7}(?:0\d|10|11|12)(?:0[1-9]|[1-2][\d]|30|31)\d{3}$/";

这样肯定报错,/^ 和$/ 是正则表达式的开始和结束符号 ,JAVA自动底层编译 ,在讲单个反斜杠\,改成双斜杠;

//我这里选择的是一代身份证 anyrule有三代身份证  可以改成三代身份证自行验证
        String regex="[1-9]\\d{7}(?:0\\d|10|11|12)(?:0[1-9]|[1-2][\\d]|30|31)\\d{3}";

lambda表达式

lambda表达式的作用一般是用于简化匿名内部类做参数的书写

代码演示:

原来需要匿名内部类实现
Arrays.sort(ar, new Comparator<Integer>() {
    //匿名内部类 无需特意实列化一个对象重写需要的方法
    // Lambda表达式就是对匿名内部类的简化 无需new对象 在逐个改写 直接(参数)->{方法题}
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1 - o2;
    }

});

lambda表达式优化后:

俩种:当重写的方法体只有一行代码时候,可以省略return 和方法体{},以及;
 Arrays.sort(ar, (Integer o1, Integer o2) -> { return o1 - o2;});
Arrays.sort(ar, ( o1,  o2) -> o2 - o1  );

格式分析

参数由原来的匿名内部类,转变为(参数)->{ }的格式,因为使用匿名内部类的目的式为了实列化接口的方法,lambda表达式跳过面向对象的过程,可以直使用参数

//只需要 专注于方法的改写  ,无需在关注接口及实现类本身
(Integer o1, Integer o2) -> { 
return o1 - o2;
}

使用细节

1.lambda 表达式可以用来简化匿名内部类的书写
2.Lambda表达式只能简化函数式接口的匿名内部类写法
3.函数式接口:
仅有一个抽象方法的接口叫函数式接口,接口上可添加@FunctionalInterface
4.当方法体只有一行代码时,可以省略 return ,;,{},且必须同时省略

Arrays.sort(ar, (o1,  o2) -> { return o1 - o2;});
简化为:Arrays.sort(ar, ( o1,  o2) -> o2 - o1  );

5.参数类型可以省略,当参数只有一个时,()也可以省略
比如这里我们自定义函数式接口

 public static void mehod1(Swim s) {  //参数是实例化该函数式接口
        s.swimming();
    }
    interface Swim{
public abstract void swimming();
}

调用 :

mehod1(()-> System.out.println("lambda式输出自定义接口"));

总结

得益于函数式接口只有一个抽象方法,所以lambda表达式简化的就是申请接口内存空间,选择重写方法的过程只有是重写抽象方法只有一个,所以参数类型也可以省略(相对应),lambda表达式基本格式在形参需要函数式接口的地方无需再实例化(参数)->{方法体}

集合进阶

集合体系

集合体系庞大

总体大类可以分为单列集合List,Set和双列集合Map

集合大类虽然繁多,单都是继承了顶级接口根据数据结构不同改写的子类,应该按数据接口记忆即可

泛型

在使用集合之前需要了解使用泛型

泛型是jdk5 中引入的特性用于在编译阶段(java 的泛型其实是个伪泛型 , 只在编译时期有效)约束操作数据,并且进行检查
格式:<数据类型>
只支持引用类型

使用场景

 ArrayList<Integer> List = new ArrayList<>();//泛型约束

如果指明泛型,那么集合可以存储任意类型

   ArrayList arrayList = new ArrayList();//不约束 可以存储任意数值   等同于	        ArrayList

java进阶知识点精讲

前言

Math

System

RunTime

BigInterger

BigDecimal

Object

java中表示时间的类

1.jdk8之前

2.jdk8 时间类

基本数据的包装类

Arrays 数组工具类

正则表达式

lambda表达式

代码演示:

格式分析

使用细节

总结

集合进阶

集合体系

泛型

泛型的使用

关于泛型的细节

collecon

常用方法

集合的便利

代码演示

List分支

常用方法

List的便利方式

ArrayList源码分析

LinkedList源码分析

Set系列

Set

HashSet

linkedHashset

代码验证

Treeset

代码验证

有参构造指定排序规则

双列集合Map

你可能感兴趣的:(Java,java,jvm)