精华内容
下载资源
问答
  • Java8编程实战

    万人学习 2016-12-31 18:03:03
    Java一直作为优秀的编程语言活跃于软件开发行业,掌握Java不仅是一件兴奋的事,更是一把可以帮助你轻松进入软件行业大门的一把金钥匙,本套课程将为读者讲解Java8的所有核心技术知识,一共240集的Java8开发课程,...
  • Java.Utils:JAVA 8 时间工具类

    万次阅读 2019-12-12 12:27:47
    基于Java 8,新的日期和时间API package com.xxx.xxx.common.utils; import java.time.*; import java.time.format.DateTimeFormatter; import java.time.temporal.Temporal; import java.time.temporal....

    基于 Java 1.8,新的日期和时间 API 封装

    package com.bood.common.utils;
    
    import java.time.*;
    import java.time.format.DateTimeFormatter;
    import java.time.temporal.Temporal;
    import java.time.temporal.TemporalAdjuster;
    import java.time.temporal.TemporalAdjusters;
    import java.util.Date;
    
    /**
     * <p>
     * JAVA 8 时间工具类
     * </p>
     *
     * @author:bood
     * @date:2020/9/25
     */
    public class DateTimeUtils {
    
        /**
         * 格式:yyyy-MM-dd HH:mm:ss
         */
        public static final DateTimeFormatter DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        /**
         * 格式:yyyy-MM-dd
         */
        public static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        /**
         * 格式:HH:mm:ss
         */
        public static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern("HH:mm:ss");
    
    
        private DateTimeUtils() {
        }
    
    
        // ------------------------------------------- 获取时间 -------------------------------------------
    
        /**
         * 返回 当前时间的(yyyy-MM-dd HH:mm:ss)
         *
         * @return yyyy-MM-dd HH:mm:ss
         */
        public static LocalDateTime get() {
            return LocalDateTime.now();
        }
    
        /**
         * 返回 当前时间的(yyyy-MM-dd)
         *
         * @return yyyy-MM-dd
         */
        public static LocalDate getCurrentLocalDate() {
            return LocalDate.now();
        }
    
        /**
         * 返回 当前时间的(HH:mm:ss)
         *
         * @return HH:mm:ss
         */
        public static LocalTime getCurrentLocalTime() {
            return LocalTime.now();
        }
    
        // ------------------------------------------- 时间格式化 -------------------------------------------
    
        /**
         * <p>
         * yyyy-MM-dd HH:mm:ss 转 LocalDateTime 类型
         * </p>
         *
         * @param dateTimeStr: yyyy-MM-dd HH:mm:ss
         * @return:java.time.LocalDateTime
         * @author:bood
         * @date:2020/9/25
         */
        public static LocalDateTime parseLocalDateTime(String dateTimeStr) {
            return LocalDateTime.parse(dateTimeStr, DATETIME_FORMATTER);
        }
    
        /**
         * <p>
         * yyyy-MM-dd 转 LocalDate 类型
         * </p>
         *
         * @param dateStr: yyyy-MM-dd
         * @return:java.time.LocalDate
         * @author:bood
         * @date:2020/9/25
         */
        public static LocalDate parseLocalDate(String dateStr) {
            return LocalDate.parse(dateStr, DATE_FORMATTER);
        }
    
        /**
         * <p>
         * HH:mm:ss 转 LocalTime 类型
         * </p>
         *
         * @param timeStr: HH:mm:ss
         * @return:java.time.LocalTime
         * @author:bood
         * @date:2020/9/25
         */
        public static LocalTime parseLocalTime(String timeStr) {
            return LocalTime.parse(timeStr, TIME_FORMATTER);
        }
    
        /**
         * <p>
         * LocalDateTime 转 yyyy-MM-dd HH:mm:ss
         * </p>
         *
         * @param datetime: LocalDateTime
         * @return:java.lang.String
         * @author:bood
         * @date:2020/9/25
         */
        public static String formatLocalDateTime(LocalDateTime datetime) {
            return datetime.format(DATETIME_FORMATTER);
        }
    
        /**
         * <p>
         * LocalDate 转 yyyy-MM-dd
         * </p>
         *
         * @param date: LocalDate
         * @return:java.lang.String
         * @author:bood
         * @date:2020/9/25
         */
        public static String formatLocalDate(LocalDate date) {
            return date.format(DATE_FORMATTER);
        }
    
        /**
         * <p>
         * LocalTime 转 HH:mm:ss
         * </p>
         *
         * @param time: LocalTime
         * @return:java.lang.String
         * @author:bood
         * @date:2020/9/25
         */
        public static String formatLocalTime(LocalTime time) {
            return time.format(TIME_FORMATTER);
        }
    
        // ------------------------------------------- 时间计算 -------------------------------------------
    
        /**
         * <p>
         * 当前时间延期几天
         * </p>
         *
         * @param days: 天数
         * @return:java.time.LocalDateTime
         * @author:bood
         * @date:2020/9/25
         */
        public static LocalDateTime plusDays(int days) {
            return get().plusDays(days);
        }
    
        /**
         * <p>
         * 日期相隔天数
         * </p>
         *
         * @param startDateInclusive: 开始时间
         * @param endDateExclusive:   结束时间
         * @return:int
         * @author:bood
         * @date:2020/9/25
         */
        public static int periodDays(LocalDate startDateInclusive, LocalDate endDateExclusive) {
            return Period.between(startDateInclusive, endDateExclusive).getDays();
        }
    
        /**
         * <p>
         * 日期相隔小时
         * </p>
         *
         * @param startInclusive: 开始时间
         * @param endExclusive:   结束时间
         * @return:long
         * @author:bood
         * @date:2020/9/25
         */
        public static long durationHours(Temporal startInclusive, Temporal endExclusive) {
            return Duration.between(startInclusive, endExclusive).toHours();
        }
    
        /**
         * <p>
         * 日期相隔分钟
         * </p>
         *
         * @param startInclusive: 开始时间
         * @param endExclusive:   结束时间
         * @return:long
         * @author:bood
         * @date:2020/9/25
         */
        public static long durationMinutes(Temporal startInclusive, Temporal endExclusive) {
            return Duration.between(startInclusive, endExclusive).toMinutes();
        }
    
        /**
         * <p>
         * 日期相隔毫秒数
         * </p>
         *
         * @param startInclusive: 开始时间
         * @param endExclusive:   结束时间
         * @return:long
         * @author:bood
         * @date:2020/9/25
         */
        public static long durationMillis(Temporal startInclusive, Temporal endExclusive) {
            return Duration.between(startInclusive, endExclusive).toMillis();
        }
    
        /**
         * <p>
         * 返回 指定年份的(yyyy-MM-dd HH:mm:ss)
         * </p>
         *
         * @param year: 年份
         * @return:java.time.LocalDateTime
         * @author:bood
         * @date:2020/9/25
         */
        public static LocalDateTime withYear(int year) {
            return get().withYear(year);
        }
    
        /**
         * <p>
         * 返回 指定年份的 第一天时间
         * </p>
         *
         * @param year: 年份
         * @return:java.time.LocalDateTime
         * @author:bood
         * @date:2020/9/25
         */
        public static LocalDateTime firstDayOfThisYear(int year) {
            return withYear(year).with(TemporalAdjusters.firstDayOfYear()).with(LocalTime.MIN);
        }
    
        /**
         * <p>
         * 返回 指定年份的 最末天时间
         * </p>
         *
         * @param year: 年份
         * @return:java.time.LocalDateTime
         * @author:bood
         * @date:2020/9/25
         */
        public static LocalDateTime lastDayOfThisYear(int year) {
            return withYear(year).with(TemporalAdjusters.lastDayOfYear()).with(LocalTime.MAX);
        }
    
        /**
         * <p>
         * 返回 指定年份的 第一天时间
         * </p>
         *
         * @param year: 年份
         * @return:java.lang.String
         * @author:bood
         * @date:2020/9/25
         */
        public static String getFirstDayOfThisDate(int year) {
            LocalDateTime firstDayOfThisYear = firstDayOfThisYear(year);
            return DATETIME_FORMATTER.format(firstDayOfThisYear);
        }
    
        /**
         * <p>
         * 返回 指定年份的 最末天时间
         * </p>
         *
         * @param year: 年份
         * @return:java.lang.String
         * @author:bood
         * @date:2020/9/25
         */
        public static String getLastDayOfThisDate(int year) {
            LocalDateTime lastDayOfThisYear = lastDayOfThisYear(year);
            return DATETIME_FORMATTER.format(lastDayOfThisYear);
        }
    
        /**
         * <p>
         * 获取本月的第一天(当前时间)
         * </p>
         *
         * @return:java.lang.String
         * @author:bood
         * @date:2020/9/25
         */
        public static String getFirstDayOfThisMonth() {
            LocalDateTime firstDayOfThisYear = get().with(TemporalAdjusters.firstDayOfMonth());
            return DATETIME_FORMATTER.format(firstDayOfThisYear);
        }
    
        /**
         * <p>
         * 获取本月的最末天(当前时间)
         * </p>
         *
         * @return:java.lang.String
         * @author:bood
         * @date:2020/9/25
         */
        public static String getLastDayOfThisMonth() {
            LocalDateTime firstDayOfThisYear = get().with(TemporalAdjusters.lastDayOfMonth());
            return DATETIME_FORMATTER.format(firstDayOfThisYear);
        }
    
        /**
         * <p>
         * 当天开始时间
         * </p>
         *
         * @return:java.time.LocalDateTime
         * @author:bood
         * @date:2020/9/25
         */
        public static LocalDateTime todayStart() {
            return LocalDateTime.of(getCurrentLocalDate(), LocalTime.MIN);
        }
    
        /**
         * <p>
         * 当天结束时间
         * </p>
         *
         * @return:java.time.LocalDateTime
         * @author:bood
         * @date:2020/9/25
         */
        public static LocalDateTime todayEnd() {
            return LocalDateTime.of(getCurrentLocalDate(), LocalTime.MAX);
        }
    
        /**
         * <p>
         * 获取 指定年月的 第一个周一
         * </p>
         *
         * @param year:  年份
         * @param month: 月份
         * @return:java.time.LocalDateTime
         * @author:bood
         * @date:2020/9/25
         */
        public static LocalDateTime firstDayOfWeekInYearMonth(int year, int month) {
            return get().withYear(year).withMonth(month).with(TemporalAdjusters.firstInMonth(DayOfWeek.MONDAY));
        }
    
        /**
         * <p>
         * 获取 本周 第一天
         * </p>
         *
         * @return:java.lang.String
         * @author:bood
         * @date:2020/9/25
         */
        public static String getStartDayOfWeekToString() {
            return formatLocalDate(getStartDayOfWeek());
        }
    
        /**
         * <p>
         * 获取 本周 第一天
         * </p>
         *
         * @return:java.time.LocalDate
         * @author:bood
         * @date:2020/9/25
         */
        public static LocalDate getStartDayOfWeek() {
            TemporalAdjuster first_of_week = TemporalAdjusters.ofDateAdjuster(localDate -> localDate.minusDays(localDate
                    .getDayOfWeek().getValue() - DayOfWeek.MONDAY.getValue()));
            return getCurrentLocalDate().with(first_of_week);
        }
    
        /**
         * <p>
         * 获取 本周 第末天
         * </p>
         *
         * @return:java.lang.String
         * @author:bood
         * @date:2020/9/25
         */
        public static String getEndDayOfWeekToString() {
            return formatLocalDate(getEndDayOfWeek());
        }
    
        /**
         * <p>
         * 获取 本周 第末天
         * </p>
         *
         * @return:java.time.LocalDate
         * @author:bood
         * @date:2020/9/25
         */
        public static LocalDate getEndDayOfWeek() {
            TemporalAdjuster last_of_week = TemporalAdjusters.ofDateAdjuster(localDate -> localDate.plusDays(
                    DayOfWeek.SUNDAY.getValue() - localDate.getDayOfWeek().getValue()));
            return getCurrentLocalDate().with(last_of_week);
        }
    
        /**
         * <p>
         * LocalDateTime 转 Date
         * </p>
         *
         * @param localDateTime: LocalDate 类型
         * @return:java.util.Date
         * @author:bood
         * @date:2020/9/25
         */
        public static Date asDate(LocalDateTime localDateTime) {
            return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
        }
    
        /**
         * <p>
         * Date 转 LocalDateTime
         * </p>
         *
         * @param date: Date 类型
         * @return:java.time.LocalDateTime
         * @author:bood
         * @date:2020/9/25
         */
        public static LocalDateTime asLocalDateTime(Date date) {
            return Instant.ofEpochMilli(date.getTime()).atZone(ZoneId.systemDefault()).toLocalDateTime();
        }
    
        /**
         * <p>
         * LocalDate 转 Date
         * </p>
         *
         * @param localDate: LocalDate 类型
         * @return:java.util.Date
         * @author:bood
         * @date:2020/9/25
         */
        public static Date asDate(LocalDate localDate) {
            return Date.from(localDate.atStartOfDay().atZone(ZoneId.systemDefault()).toInstant());
        }
    
        /**
         * <p>
         * Date 转 LocalDate
         * </p>
         *
         * @param date: Date 类型
         * @return:java.time.LocalDate
         * @author:bood
         * @date:2020/9/25
         */
        public static LocalDate asLocalDate(Date date) {
            return Instant.ofEpochMilli(date.getTime()).atZone(ZoneId.systemDefault()).toLocalDate();
        }
    
    }
    

    混〔IT〕的小学生 热爱编程,喜欢挑战新事物! 撩撩博主 😃

    展开全文
  • Java8

    千次阅读 2014-11-04 10:30:18
    相信对于java8这个字眼大家都已经不陌生了,但是对于java8的了解和使用很多人还不是很清楚,甚至很多人还在犹豫着要不要用java8,那么我写这篇文章的目的就是告诉你,你一定要使用java8以及你为什么要使用java8.

    java8优势  

    相信对于java8这个字眼大家都已经不陌生了,但是对于java8的了解和使用很多人还不是很清楚,甚至很多人还在犹豫着要不要用java8,那么我写这篇文章的目的就是告诉你,你一定要使用java8以及你为什么要使用java8.  


    lambda   

    在Java7以及之前的代码里,为了实现带一个方法的接口,往往需要定义一个匿名类并复写接口方法,代码显得很臃肿。  
    比如我们用来给数组排序的Comparator接口:  
    String[] str = "aa、bb、cc、dd".split("、");
    Arrays.sort(str, new Comparator<String>() {
        @Override
        public int compare(String s1, String s2) {
            return s1.toLowerCase().compareTo(s2.toLowerCase());
        }
    });

    然而对于这种只有一个方法的接口,在Java8里面,我们可以把它视为一个函数,用lambda表示式简化如下的操作:  
    String[] str = "aa、bb、cc、dd".split("、");
    Arrays.sort(str, (s1, s2) -> {
        return s1.toLowerCase().compareTo(s2.toLowerCase());
    });

    这样我们的代码看着就简洁了很多,或许单单看这一个例子大家还体会不到lambda那神奇的魔力.  
    如果接触过jedis的朋友,相信都知道在使用jedis的时候会有获取连接,进行操作,释放连接这几个步骤。  
    大家能看出来,除了进行操作这个步骤是不同的,连接的获取和释放代码是相同的,那么这时候我们就可以考虑用lambda表达式把他封装起来。


    stream   

    集合类新增的stream()方法用于把一个集合变成Stream,然后,通过filter()、map()等实现Stream的变换。Stream还有一个forEach()来完成每个元素的迭代。

    例如要遍历一个list,要对这个list做一个for遍历  

    代码是这样的:  
     List<String> a = new ArrayList<String>();
            for (String o : a) {
                System.out.println(o)
            }
    而我用了stream之后,代码却简洁成这个样子:  
            List<String> a = new ArrayList<>();
            a.stream().forEach(c-> System.out.println(c));


    在比如我想取得这个list的的前10项:  
    List<String> list = oldList.limit(10).collect(Collectors.toList());
    那么如果我想取得数列的第20~30项,可以这样做:  
    List<String> list = oldList.skip(20).limit(10).collect(Collectors.toList());
    而且Stream有串行和并行两种,串行Stream上的操作是在一个线程中依次完成,而并行Stream则是在多个线程上同时执行。  
    stream提供了parallelStream使用多线程进行操作,加大了运算效率.  

    Stream中还有fifter、sorted、Match、map、Reduce这一类的api,大家可以在日后的使用中慢慢去体会他的强大之处.    

     

    optional

    Optional 不是函数是接口,这是个用来防止NullPointerException异常的辅助类型,这是下一届中将要用到的重要概念,他最初源自于google出的框架包guava之中,于1.8正式引入到jdk中使用  

    Optional 被定义为一个简单的容器,其值可能是null或者不是null。在之前一般某个函数应该返回非空对象但是偶尔却可能返回了null,然后这样的结果或许可能会让你的程序出现NullPointerException,会造成程序的崩溃等不可预估的问题,而在Java 8中,不推荐你返回null而是返回Optional。  
    Optional<String> optional = Optional.of("bam");
    
    
    optional.isPresent();           // true
    optional.get();                 // "bam"
    optional.orElse("fallback");    // "bam"
    
    
    optional.ifPresent((s) -> System.out.println(s.charAt(0)));     // "b"


    构造函数  

    在java8之前我们新建一个对象都是这样的`User u = new User()`   
    而在java8中我们可以这么写代码`User u = User::new `   


    方法引用 

    我经常把方法引用和lambda合在一起使用   
    比如我们有一个业务需要把集合里每个元素做处理   
    那么我们根据业务规范要把这个处理的事件写成一个业务方法,然后遍历集合元素,并传递元素调用该方法   

    一般我们在使用java8以前都是这么写的:  
    //声明一个名为doSomeThing的方法  
    public void doSomeThing(String item){
       // TODO
    }
    
    
    List<String> list = new ArrayList<String>();
    for(String item:list){
       doSomeThing(item);
    }
    那么在java8中,上面的东西我很简单的就搞定了`list.stream().foreach(item->doSomeThing(item))`  

    我用方法引用再简化一下上面的代码,就变成了现在这个样子`list.stream().foreach(this:: doSomeThing)`,很牛逼是不是!  


    hashMap的优化  

    - 如果在hash冲突的时候,链表长度大于默认因子数8的时候,会变更为红黑树,利用红黑树快速增删改查的特点提高HashMap的性能,用以提高效率.  
    - JDK1.7中rehash的时候,旧链表迁移新链表的时候,如果在新表的数组索引位置相同,则链表元素会倒置,JDK1.8不会倒置.  

    详细的优化请参考美团技术团队写的这篇文章*[Java 8系列之重新认识HashMap](http://tech.meituan.com/java-hashmap.html)*    


    concurrentHashMap的优化 

    concurrentHashMap变成了cas无锁模式,只有在扩容的时候才会用sync进行锁,cas的无锁模式使得concurrentHashMap在吞吐量上有了一定等级的提升  

    参考的文章

    展开全文
  • 对于中间操作和终端操作的定义,请看《JAVA8 stream接口 中间操作和终端操作》,这篇主要讲述的是stream的count,anyMatch,allMatch,noneMatch操作,我们先看下函数的定义 long count(); boolean anyMatch...

    对于中间操作和终端操作的定义,请看《JAVA8 stream接口 中间操作和终端操作》,这篇主要讲述的是stream的count,anyMatch,allMatch,noneMatch操作,我们先看下函数的定义

        long count();  
      
        boolean anyMatch(Predicate<? super T> predicate);  
      
        boolean allMatch(Predicate<? super T> predicate);  
      
        boolean noneMatch(Predicate<? super T> predicate);

    count方法,跟List接口的size一样,返回的都是这个集合流的元素的长度,不同的是,流是集合的一个高级工厂,中间操作是工厂里的每一道工序,我们对这个流操作完成后,可以进行元素的数量的和;

    剩下的三个方法,传入的都是Predicate的函数式接口,接口定义请看《JAVA8 Predicate接口》

    anyMatch表示,判断的条件里,任意一个元素成功,返回true

    allMatch表示,判断条件里的元素,所有的都是,返回true

    noneMatch跟allMatch相反,判断条件里的元素,所有的都不是,返回true

    下面,看几个例子

    List<String> strs = Arrays.asList("a", "a", "a", "a", "b");
            boolean aa = strs.stream().anyMatch(str -> str.equals("a"));
            boolean bb = strs.stream().allMatch(str -> str.equals("a"));
            boolean cc = strs.stream().noneMatch(str -> str.equals("a"));
            long count = strs.stream().filter(str -> str.equals("a")).count();
            System.out.println(aa);// TRUE
            System.out.println(bb);// FALSE
            System.out.println(cc);// FALSE
            System.out.println(count);// 4

    通过例子可以看到,变量aa的表达式,strs里的元素,任意有“a”,表示true

    变量bb的表达式,strs里的元素,全部为“a”,表示true,否则false

    变量cc的表达式,strs里的元素,全部不为“a”,表示true,否则false

    --------------------分割线---------------------------------------

    先看下如下代码

     public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            boolean allMatch = list.stream().allMatch(e -> e.equals("a"));
            boolean anyMatch = list.stream().anyMatch(e -> e.equals("a"));
            boolean noneMatch = list.stream().noneMatch(e -> e.equals("a"));
            System.out.println(allMatch);// true
            System.out.println(anyMatch);// false
            System.out.println(noneMatch);// true
        }

    最近,有小伙伴留言说,boolean allMatch = list.stream().allMatch(e -> e.equals("a"));

    当list的为空集合时候,这个返回默认为true;按照实际的业务,理解这个的话,应该为false;然后网上搜索了一下,比较尴尬的是,很多都是抄下我之前的文章,秉承着,严谨的原则,查看了源码,下面是整个分析的过程;

    详细看《java8 stream接口终端操作allMatch 当list为空集合的一些思考》

     

    1.lambda表达式

    《java8 Lambda表达式简介》

    《java8 lambda表达式,方法的引用以及构造器的引用》

    2.函数式接口

    《java8 函数式接口简介》

    《JAVA8 Function接口以及同类型的特化的接口》

    《JAVA8 Consumer接口》

    《JAVA8 Supplier接口》

    《JAVA8 UnaryOperator接口》

    《JAVA8 BiConsumer 接口》

    3.stream接口操作

    《java8 Stream接口简介》

    《 java8 Stream-创建流的几种方式》

    《JAVA8 stream接口 中间操作和终端操作》

    《JAVA8 Stream接口,map操作,filter操作,flatMap操作》

    《JAVA8 stream接口 distinct,sorted,peek,limit,skip》

    《java8 stream接口 终端操作 forEachOrdered和forEach》

    《java8 stream接口 终端操作 toArray操作》

    《java8 stream接口 终端操作 min,max,findFirst,findAny操作》

    《java8 stream接口终端操作 count,anyMatch,allMatch,noneMatch》

    《java8 srteam接口终端操作reduce操作》

    《java8 stream接口 终端操作 collect操作》

    4.其他部分

    《java8 Optional静态类简介,以及用法》

    展开全文
  • 2020年支持java8的Java反编译工具汇总

    万次阅读 多人点赞 2018-06-29 10:58:53
    luyten是一款操作简单、功能实用的java反编译工具,软件支持*.JAR、*.zip、*.class等类型文件的反编译操作,还原度非常高,支持更多功能设置,如显式导入、类型、合成组件等等,用户可根据不同的需求选择合适的显示...

         大多商业软件,会对程序进行加密、加壳等安全措施以防范软件被破解,从而使得反编译越来越难。反编译是一个对目标可执行程序进行逆向分析,从而得到源代码的过程。尤其是像Java这样的运行在虚拟机上的编程语言,更容易进行反编译得到源代码。

          我们知道,在代码支撑方面,JDK 1.7引入了字符串Switch、泛型接口改进等新功能,1.8增加了lambda表达式、方法传递、多重注解等新特性,这使得反编译工具的编写难度加大。今天我们盘点一下目前仍然可用的、相对功能很强大的Java反编译工具(Eclipse插件不做评价),比较老的反编译工具很难支持Java8及其以上版本。

     

    1、Java 反编译器 JD-GUI

    JD-GUI 是一个用 C++ 开发的 Java 反编译工具,由 Pavel Kouznetsov开发,支持Windows、Linux和苹果Mac Os三个平台。而且提供了Eclipse平台下的插件JD-Eclipse、IntelliJ的插件JD-IntelliJ。JD-GUI不需要安装,直接点击运行,可以反编译jar,class文件。

    最新版本1.4.0,官方网站:http://jd.benow.ca/

     

    2、Java 反编译器 procyon-decompiler及其window下独立UI工具luyten

         Procyon-Decompiler支持JDK1.8类的反编译,在很多方面做得非常不错,如反编译匿名类、内部类、Java8 Lambda等等。Procyon-Decompiler支持JDK1.8类的反编译,在很多方面做得非常不错:字符串的Switch、枚举声明方面、注解方面、匿名类、内部类、Java8新接口规范、Java8 Lambda表达式、Java8 方法传递等。

          luytenProcyon的GUI,是一款操作简单、功能实用的java反编译工具,软件支持*.JAR、*.zip、*.class等类型文件的反编译操作,还原度非常高,支持更多功能设置,如显式导入、类型、合成组件等等,用户可根据不同的需求选择合适的显示项目,结果更明了。

         luyten的最新版本0.53,官方网址:https://github.com/deathmarine/Luyten,只需要下载luyten即可,不用下载ProcyonProcyon最新版本0.5.30。

     

    3、Android反编译gui工具Jadx

         jadx是一款Android反编译gui工具,它支持apk、dex、jar、class、zip、aar等文件。jadx操作方便,反编译后的代码可读性高,同时还拥有较完善的gui界面,除去混淆部分的代码,jadx已经非常接近源代码了。

       Jadx最高版本v0.7.1,官方地址https://github.com/skylot/jadx/

       三个工具中JD-GUI打开jar文件反编译速度飞快、luyten次之、Jadx最慢(有时候需要等好一会,喝杯咖啡先。三者都会遇到反编译不出来的情况,建议配合使用。

    展开全文
  • java8 手把手教你学会写lambda表达式

    万次阅读 多人点赞 2017-04-16 14:24:31
    Java8发布已经有一段时间了,这次发布的改动比较大,很多人将这次改动与Java5的升级相提并论。Java8其中一个很重要的新特性就是lambda表达式,允许我们将行为传到函数中。想想看,在Java8 之前我们想要将行为传入...
  • 对于中间操作和终端操作的定义,请看《JAVA8 stream接口 中间操作和终端操作》,这篇主要讲述的是stream的min,max,findFirst,findAny操作,我们先看下函数的定义 Optional<T> min(Comparator<? super...
  • 采用java8 lambda表达式 实现java list 交集/并集/差集/去重并集一般的javaList 交、并集采用简单的 removeAll retainAll 等操作,不过这也破坏了原始的javaList对象,采用java8 lambda表达式流操作则可以不影响原始...
  • Java关键字(Java 8版本)

    万次阅读 多人点赞 2019-09-28 22:11:04
    定义 被Java语言赋予了特殊含义,用作专门...Java关键字(Java 8版本) Java关键字(Java 8 以后版本) 注意事项 true,false和,null看起来像关键字,但它们实际上是文字; 您不能在程序中将它们用作标识符。 ...
  •   如果你还不熟悉java8的新特性,可以看下下面这篇文章 或者 B站红康师傅讲解的java8新特性,宋红康老师讲的不止有java8哦,乃至java 9-15的新特性都有,可以在B站中找到,或者尚硅谷官网可以免费获取到。...
  • java8安装

    万次阅读 多人点赞 2019-05-19 10:31:50
    首先获取java8的安装包 可以通过百度搜索jdk1.8,第一个点击进入即为下载页面 点击进入还会有jdk8版本的不同更新时间的小版本,推荐使用最后更新的那个,大致如下图 点击接受,然后可以选择下载,可以根据自己系统...
  • Java8 Stream分割list集合

    万次阅读 2020-03-04 22:43:37
    使用Java8 Stream分割list集合,写好的工具类,可以直接用 package com.example.java8; import com.example.excel.Student; import org.apache.commons.collections4.CollectionUtils; import java.util.ArrayList...
  • JAVA8 十大新特性详解

    万次阅读 多人点赞 2017-02-09 10:25:14
    前言: Java 8 已经发布很久了,很多报道表明Java 8 是一次重大的版本升级。在Java Code Geeks上已经有很多介绍Java 8新特性的文章,例如Playing with Java 8 – Lambdas and Concurrency、Java 8 Date Time API ...
  • Java8】 lambda 特性讲解

    万次阅读 多人点赞 2019-11-20 20:15:45
    Lambda 表达式,也可称为闭包,它是推动 Java 8 发布的最重要新特性。Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法...Java8新特性待学习。 语法 lambda 表达式的语法格式如下:(parameters) ->...
  • Java 14 都快来了,为什么还有这么多人固守Java 8

    万次阅读 多人点赞 2020-01-02 08:47:00
    Java 9开始,Java版本的发布就让人眼花缭乱了。每隔6个月,都会冒出一个新版本出来,Java 10 , Java 11, Java 12, Java 13, 到2020年3月份,...
  • JAVA8 Stream接口,map操作,filter操作,flatMap操作

    万次阅读 多人点赞 2018-06-10 17:22:18
    这篇,我们来看Stream的一些中间操作,关于中间操作的一些介绍,可以看《JAVA8 stream接口 中间操作和终端操作》 1,filter操作,我们先看方法的定义 Stream<T> filter(Predicate<? super T> ...
  • Java8中的LocalDateTime工具类

    万次阅读 多人点赞 2017-07-22 22:57:14
    网上搜索了半天都没有找到Java8的LocalDateTime的工具类,只好自己写了一个,常用功能基本都有。还在用Date的Java同道该换换了。 个人项目地址:https://github.com/KingBoyWorld/common.git,Common模块中有很多...
  • JDK1.8,Java8常用新特性

    万次阅读 多人点赞 2018-09-17 10:43:24
    1.Java8概述 Java8,也就是jdk1.8,是意义深远的一个新版本 是Java5之后一个大的版本升级,让Java语言和库仿佛获得了新生 新特性包含: a.随着大数据的兴起,函数式编程在处理大数据上的优势开始体现,引入了...
  • Java8与JDK1.8与JDK8的区别是什么? Java是面向对象的编程语言,在我们开发Java应用的程序员的专业术语里,Java这个单词其实指的是Java开发工具,也就是Java Development Kit。所以我们常常在CSDN等各大程序员论坛...
  • JAVA8——StringJoiner类

    万次阅读 2018-08-30 23:39:15
    JAVA8——StringJoiner类 引言:在阅读项目代码是,突然看到了StringJoiner这个类的使用,感觉很有意思,对实际开发中也有用,实际上是运用了StringBuilder的一个拼接字符串的封装处理。 介绍 StringJoiner...
  • Java8零基础入门视频教程

    万人学习 2016-09-29 14:23:29
    这门课程基于主流的java8平台,由浅入深的详细讲解了java SE的开发技术,可以使java方向的入门学员,快速扎实的掌握java开发技术!
  • java8中的Stream用法详解

    万次阅读 多人点赞 2017-11-09 17:37:10
    1.为什么java8中加入StreamStream 作为 Java 8 的一大亮点,它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。Java 8 中的 Stream 是对集合(Collection)对象功能的增强,它专注于对集合对象...
  • 前几天写了一篇 Java 8 即将在 2019 年停止免费向企业提供更新的文章,企图迫使用户向更新一代的 Java 版本升级,但让人遗憾的是,小编今天收到了 Oracle Java 版本的升级推送,装完居然是 Java 10 !!!! 很意外,...
  • 两者最大的区别是,Java8的DateTimeFormatter是线程安全的,而SimpleDateFormat并不是线程安全。 package com.main; import java.text.DateFormat; import java.text.SimpleDateFormat; import java.time....
  • JAVA 8 '::' 关键字

    万次阅读 多人点赞 2018-06-05 16:07:08
    Java 8 中我们可以通过 `::` 关键字来访问类的构造方法,对象方法,静态方法。现有一个类 Somethingclass Something { // constructor methods Something() {} Something(String something) { System.out....
  • Java8 Map computeIfAbsent方法说明

    万次阅读 多人点赞 2018-07-20 11:29:02
    computeIfAbsent // 方法定义 default V computeIfAbsent(K key, Function&...// java8之前。从map中根据key获取value操作可能会有下面的操作 Object key = map.get("key"); if...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 325,293
精华内容 130,117
关键字:

java8

java 订阅