精华内容
下载资源
问答
  • 我们可以看到通过不同的按钮可以释放不同的技能 这里我用的是NGUI来搭建的场景 首先添加一个UIPanle 然后是一个UISprite 然后再是一个遮挡的UISprite 我们通过改变Fill Amount的值来对图片进行360度的旋转剪切 ...

    首先看下运行的截图
    这里写图片描述
    我们可以看到通过不同的按钮可以释放不同的技能
    这里我用的是NGUI来搭建的场景
    首先添加一个UIPanle
    然后是一个UISprite
    然后再是一个遮挡的UISprite 我们通过改变Fill Amount的值来对图片进行360度的旋转剪切
    然后添加UILable 添加冷却时间和按键提示
    下面我写了一个SkillCp.cs的脚本来实现上面的功能

    using UnityEngine;
    using System.Collections;
    
    public class SkillCp : MonoBehaviour {
    
        UISprite Sprite;
        UILabel Lable;
        public string SpriteName;
        public string LableName;
    
        public string Q;//用来对不同的按键进行选择
        // Use this for initialization
        void Start () {
            Sprite = transform.Find(SpriteName).GetComponent<UISprite>();//找到对应的图片
            Lable = transform.Find(LableName).GetComponent<UILabel>();//找到对应的时间
        }
        bool isCude = false;
        public float TimeSpeed=2;
        // Update is called once per frame
        void Update () {
            if (Q == "Q")
            {
                if (Input.GetKey(KeyCode.Q) && !isCude)
                {
                    Sprite.fillAmount = 1;
                    Lable.text = TimeSpeed.ToString("f1");
                    isCude = true;
                }
            }
            if (Q == "E")
            {
                if (Input.GetKey(KeyCode.E) && !isCude)
                {
                    Sprite.fillAmount = 1;
                    Lable.text = TimeSpeed.ToString("f1");
                    isCude = true;
                }
            }
            if (Q == "W")
            {
                if (Input.GetKey(KeyCode.W) && !isCude)
                {
                    Sprite.fillAmount = 1;
                    Lable.text = TimeSpeed.ToString("f1");
                    isCude = true;
                }
            }
            if (Q == "R")
            {
                if (Input.GetKey(KeyCode.R) && !isCude)
                {
                    Sprite.fillAmount = 1;
                    Lable.text = TimeSpeed.ToString("f1");
                    isCude = true;
                }
            }
            if (isCude)
            {
                Sprite.fillAmount -= (1f / TimeSpeed) * Time.deltaTime;//对图片按照时间进行360度的旋转剪切
                Lable.text = (TimeSpeed * Sprite.fillAmount).ToString("f1");//改变冷却时间
                if (Sprite.fillAmount <= 0.05f)
                {
                    isCude = false;
                    Sprite.fillAmount = 0;
                    Lable.text = "";
                }
            }
        }
    }
    
    展开全文
  • 高效工程师系列(二) 花时间学习新技能 高效工程师系列(三) 持续学习  工作中很容易被各种必须完成的事压得喘不过气来。我指导过的那些人,通常都是刚开始工作的人经常感觉到他们的工作任务清单在持续增长,...

    高效工程师系列(一) 如何找到一个利于自己成长的环境
    高效工程师系列(二) 花时间学习新技能
    高效工程师系列(三) 持续学习
      工作中很容易被各种必须完成的事压得喘不过气来。我指导过的那些人,通常都是刚开始工作的人经常感觉到他们的工作任务清单在持续增长,而且进度远远的落在了后面,他们总是花很长时间追赶进度而不是花足够的时间开发能让他们更高效的新技能。
      关于这点,我从Google借鉴了一个解决方案。Google开创新的提出了一个”20%时间”的理念,就是相当于工程师可以每周花一天的时间来做一些别的能让公司更好的项目。最初,20%时间是一个有争议的提议,有人怀疑这提高了公司的底线。事实上这种投入使得工程师能创造出像Gmail、Google新闻、AdSense这些最后成为google核心竞争力的产品。 许多其他公司也纷纷效仿。
      想让自己得到成长,你必须付出你20%的时间。每天1-2小时比每周用一整天的时间学习效果要好,这样你可以把提升自己的技能变成一个日常习惯。可能刚开始你的效率会有所下降(你把你上网或者做什么其他分散你注意力的事的时间拿过来学习根本也不会有什么影响),但在长期来看肯定是能提高效率的。
      所以你应该用这20%的时间做什么?你可以深入去理解下你工作的领域或者你用的工具。或者,你可以从微软Windows部门前负责人史蒂文•辛诺夫斯基(Steven Sinofsky)所说的“相邻学科”中获得经验。有些学科和你的核心角色相关,可以让你变得更自信和高效。如果你是一名产品工程师,你的相邻学科可能有产品管理、用研甚至是后端开发。如果你是一名基础研发工程师,你的相邻学科可能包括机器学习、数据库内核、网页开发等。如果你是一名关注增长的工程师,相邻学科可能有数据科学、时间、行为心理学。邻近学科的知识不仅有用,而且你还会更有可能记住信息,因为你会积极地练习它。
      无论你选择哪条路线,这有10条关于利用你身边可用资源的建议。

    • 学习你们公司最优秀程序员写的代码。 通常而言如果你在一个大科技公司,一般都会有一个共享代码库可以看到早期员工写的核心库。从一个你用过的开始看,问问自己能不能写一套类似的代码并且你能从中学到什么。理解为什么他们这么选择和如何实现,看看早起版本是否被重写以解决缺陷。你也可以把这种方法用在任何你们公司正在用或者考虑用的设计良好的开源项目上。
    • 写更多代码 如果你感觉变成是你的弱点,多把时间从会议往编码上倾斜。十多年在学习上的研究表明,当你从记忆中获取知识的时候,你越努力,你就越能更快的学会和记住这些想法。因为编程比被动的阅读代码更耗费精力,你会发现实践是你提高编程技巧最有效的方式。此外,你很容易理解你读过的东西,但当你真正去做的时候你才会发现有大量的知识空白。
    • 利用好任何内部可用的教育材料 例如在Google,有大量经验丰富的工程师写的核心抽象代码库。如果你的公司维护设计文档或者举办技术讲座,这些都是很好的学习机会。
    • 熟练掌握你使用的变成语言 看一两本相关的好书,专注于扎实掌握该语言的先进概念,熟悉核心代码库。确保至少有一门语言是脚本语言(比如 python或ruby),它可以成为你快速任务的瑞士军刀。
    • 让最严厉的人review你的代码 优化好的有思想的反馈比降低你工作的门槛好的多。多问下你不自信的实现细节。 和你们公司最好的设计师讨论软件设计避免你写出设计良好但不工作的代码。
    • 注册一门你想提高领域的课程 这些课程可以是公司的、附近大学的或者在线课程,比如Coursera、edX、Udemy、Udacity等。在线教育井喷式发展,你很容易就能注册一门机器学习、移动开发、计算机网络、编译或者其他课程。这些课程基本上都是世界级教授所教授的,比如斯坦福、MIT等。有些大公司甚至会帮你的课程付费。
    • 参加你感兴趣的设计讨论 不要等着别人邀请你,问下项目lead是否介意你旁听或者参与到设计会议里。如果内部邮件组开发,直接把自己加进去,或者直接阅读存档中的关键对话。
    • 参加多样性的项目 如果你发现你直接一直在用相似的方法做相似的东西,是时候学一些新技能了。交错参与不同的项目可以教会你哪些问题在项目中是常见的,哪些可能只存在于你当前项目中。此外,研究表明,不同技能的交叉练习比重复的、集中练习的一种技能更有效,它可以帮助人们解决不熟悉的问题。
    • 确保你们团队至少有一个你可以学习的高级工程师 如果没有,考虑下换个项目或团队,这可以帮你在剩下的80%的时间里提升学习率。
    • 勇敢的扎进你不懂的代码里 经过多年的观察,前facebook的工程主管Bobby Johnson总结出工程的成功和『无畏地扎进他们不懂的代码是强相关的』。害怕失败经常拖累我们,导致我们在开始尝试前就放弃了。但Bobby Johnson解释道『在实践中深挖你不懂的东西,能让你写出更好的代码』。

        从你20%的时间里创造学习机会,你就会稳步提高你的技能和生产力。

    展开全文
  • 高级JAVA开发必须掌握技能java8 新日期时间API((二)JSR-310:常用的日期时间API
    技术活,该赏
    点赞,收藏再看,养成习惯
    

    大家好,我是小虚竹。之前有粉丝私聊我,问能不能把JAVA8 新的日期时间API(JSR-310)知识点梳理出来。答案是肯定的,谁让我宠粉呢。由于内容偏多(超十万字了),会拆成多篇来写。

    闲话就聊到这,请看下面的正文。

    文章目录

    常用的日期时间API简介

    介绍下java8API比较常用的日期时间API,按java.time 包的类顺序:

    • Clock:时钟
    • Instant:瞬间时间。
    • LocalDate:本地日期。只有表示年月日
    • LocalDateTime:本地日期时间,LocalDate+LocalTime
    • LocalTime:本地时间,只有表示时分秒
    • OffsetDateTime:有时间偏移量的日期时间(不包含基于ZoneRegion的时间偏移量)
    • OffsetTime:有时间偏移量的时间
    • ZonedDateTime:有时间偏移量的日期时间(包含基于ZoneRegion的时间偏移量)

    博主把这些类都点开看了,都是属于不可变类。而且官方也说了,java.time包 下的类都是线程安全的。

    Clock

    Clock类说明

    public abstract class Clock {
    ...
    }
    

    Clock 是抽象类,内部提供了四个内部类,这是它的内部实现类

    image-2021081496702

    • FixedClock :始终返回相同瞬间的时钟,通常使用于测试。
    • OffsetClock :偏移时钟,时间偏移量的单位是Duration。
    • SystemClock :系统默认本地时钟。
    • TickClock :偏移时钟,时间偏移量的单位是纳秒。

    Clock 提供了下面这几个常用的方法(这几个方法在实现类里都有对应的实现):

    // 获取时钟的当前Instant对象。
    public abstract Instant instant()
    
    // 获取时钟的当前毫秒数值
    public long millis()
    
    // 获取用于创建时钟的时区。
    public abstract ZoneId	getZone()
    
    // 返回具有指定时区的当前时钟的新实例
    public abstract Clock withZone(ZoneId zone)
    
    

    FixedClock

    Clock.fixed

    public static Clock fixed(Instant fixedInstant, ZoneId zone)
    

    需要传递instantzone,并将返回具有固定瞬间的时钟。

    		Instant instant = Instant.now();
    		Clock fixedClock = Clock.fixed(instant, ZoneId.of("Asia/Shanghai"));
    		Clock fixedClock1 = Clock.fixed(instant, ZoneId.of("GMT"));
    		System.out.println("中国时区的Clock:"+fixedClock);
    		System.out.println("GMT时区的Clock:"+fixedClock1);
    

    image-20210814195855581

    由运行结果可知,返回的结果是有带对应时区的。

    验证获取的时钟会不会改变:

    		Clock clock = Clock.systemDefaultZone();
    		Clock fixedClock = Clock.fixed(clock.instant(), ZoneId.of("Asia/Shanghai"));
    		System.out.println(fixedClock.instant());
    		try {
    			Thread.sleep(1000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		System.out.println(fixedClock.instant());
    

    image-202108149044323

    Clock.fixed 创建一个固定的时钟,clock 对象将始终提供与指定相同的时刻。。如图所示,强制睡眠1秒,但是时刻没变。

    Clock.fixed 跟 Offset 方法更配

    由上面可知Clock.fixed 得到一个固定的时钟,那要添加时间或者减去时间就要用到Offset 方法

    示例代码如下

    		Clock clock = Clock.systemDefaultZone();
    		Clock fixedClock = Clock.fixed(clock.instant(), ZoneId.of("Asia/Shanghai"));
    		System.out.println(fixedClock.instant());
    		Clock clockAdd = Clock.offset(clock, Duration.ofMinutes(20));
    		Clock clockSub = Clock.offset(clock, Duration.ofMinutes(-10));
    		System.out.println("原先的: " + clock.instant());
    		System.out.println("加了20分钟: " + clockAdd.instant());
    		System.out.println("减了10分钟: " + clockSub.instant());
    
    

    image-202108141995813

    OffsetClock

    OffsetClock 是偏移时钟,时间偏移量的单位是Duration。

    //Clock
         public static Clock offset(Clock baseClock, Duration offsetDuration) {
            Objects.requireNonNull(baseClock, "baseClock");
            Objects.requireNonNull(offsetDuration, "offsetDuration");
            if (offsetDuration.equals(Duration.ZERO)) {
                return baseClock;
            }
            return new OffsetClock(baseClock, offsetDuration);
        }
    

    由源码可知,使用Clock.offset方法 返回的是OffsetClock实例对象

    		Clock clock = Clock.systemDefaultZone();
    		Clock fixedClock = Clock.fixed(clock.instant(), ZoneId.of("Asia/Shanghai"));
    		System.out.println(fixedClock.instant());
    		Clock clockAdd = Clock.offset(clock, Duration.ofMinutes(20));
    		System.out.println("原先的: " + clock.instant());
    		System.out.println("加了20分钟: " + clockAdd.instant());
    

    image-20210814944060

    SystemClock

    SystemClock 是系统默认的本地时钟。

    			Clock clock = Clock.systemDefaultZone();
    		System.out.println(clock.millis());
    		Clock utc = Clock.systemUTC();
    		System.out.println(utc.millis());
    		System.out.println(System.currentTimeMillis());
    

    image-20210814904947

    居然完全一样。这就要看下源码了

    Clock.systemDefaultZone()

    用的是系统默认的时区ZoneId.systemDefault()

        public static Clock systemDefaultZone() {
            return new SystemClock(ZoneId.systemDefault());
        }
    

    image-2021081495878

    最终调用的也是System.currentTimeMillis()

    Clock.systemUTC()

    用的是UTC时区ZoneOffset.UTC

         public static Clock systemUTC() {
            return new SystemClock(ZoneOffset.UTC);
        }
    

    image-2021081495878

    最终调用的也是System.currentTimeMillis()

    结论

    Clock.systemDefaultZone() 和Clock.systemUTC()获取的millis()时间戳是一样的,就是对应时区的差别。

    TickClock

    TickClock 是偏移时钟,时间偏移量的最小单位是纳秒。

    如图所示,Clock主要提供下面三个方法

    //构造的时钟的计时单位是自定义的偏移量单位
    public static Clock tick(Clock baseClock, Duration tickDuration); 
    //构造的时钟的计时单位是分 
    public static Clock tickMinutes(ZoneId zone);
    //构造的时钟的计时单位是秒
    public static Clock tickSeconds(ZoneId zone) ;
    

    image-202108149595

    实战:

    		Clock tickClock = Clock.tick(Clock.systemDefaultZone(),Duration.ofHours(1L));		
    		Clock tickMinutes = Clock.tickMinutes(ZoneId.of("Asia/Shanghai"));		
    		Clock tickSeconds = Clock.tickSeconds(ZoneId.of("Asia/Shanghai"));		
    		LocalDateTime tickClockLocalDateTime = LocalDateTime.ofInstant(Instant.ofEpochMilli(tickClock.millis()),ZoneId.of("Asia/Shanghai"));		
    		LocalDateTime tickMinutesLocalDateTime = LocalDateTime.ofInstant(Instant.ofEpochMilli(tickMinutes.millis()),ZoneId.of("Asia/Shanghai"));		
    		LocalDateTime tickSecondsLocalDateTime = LocalDateTime.ofInstant(Instant.ofEpochMilli(tickSeconds.millis()),ZoneId.of("Asia/Shanghai"));		
    		System.out.println("tickClock  :"+tickClock.millis() +" 转为date时间:"+tickClockLocalDateTime);	
    		System.out.println("tickMinutes:"+tickMinutes.millis() +" 转为date时间:"+tickMinutesLocalDateTime);	
    		System.out.println("tickSeconds:"+tickSeconds.millis() +" 转为date时间:"+tickSecondsLocalDateTime);
    

    偏移量的单位支持:天,时,分,秒,豪秒,纳秒

    image-20210814909314

    image-2021081495696

    Instant

    Instant类说明

    public final class Instant
            implements Temporal, TemporalAdjuster, Comparable<Instant>, Serializable {
            ...
            }
    

    Instant表示瞬间时间。也是不可变类且是线程安全的。其实Java.time 这个包是线程安全的。

    Instant是java 8新增的特性,里面有两个核心的字段

    	...		
    	private final long seconds;       
    	 private final int nanos;	...
    

    一个是单位为秒的时间戳,另一个是单位为纳秒的时间戳。

    是不是跟**System.currentTimeMillis()**返回的long时间戳很像,System.currentTimeMillis()返回的是毫秒级,Instant多了更精确的纳秒级时间戳。

    Instant常用的用法

     		Instant now = Instant.now();
    		System.out.println("now:"+now);
    		System.out.println(now.getEpochSecond()); // 秒
    		System.out.println(now.toEpochMilli()); // 毫秒
    

    image-20210720905353

    Instant是没有时区的,但是Instant加上时区后,可以转化为ZonedDateTime

    		Instant ins = Instant.now();
    		ZonedDateTime zdt = ins.atZone(ZoneId.systemDefault());
    		System.out.println(zdt);
    

    image-202107205211996

    long型时间戳转Instant

    要注意long型时间戳的时间单位选择Instant对应的方法转化

    //1626796436 为秒级时间戳
    Instant ins = Instant.ofEpochSecond(1626796436);
    ZonedDateTime zdt = ins.atZone(ZoneId.systemDefault());
    System.out.println("秒级时间戳转化:"+zdt);
    //1626796436111l 为秒级时间戳
    Instant ins1 = Instant.ofEpochMilli(1626796436111l);
    ZonedDateTime zdt1 = ins1.atZone(ZoneId.systemDefault());
    System.out.println("毫秒级时间戳转化:"+zdt1);
    

    Instant的坑

    Instant.now()获取的时间与北京时间相差8个时区,这是一个细节,要避坑。

    看源码,用的是UTC时间。

    public static Instant now() {     
       return Clock.systemUTC().instant();  
         }
    

    解决方案:

    Instant now = Instant.now().plusMillis(TimeUnit.HOURS.toMillis(8));
    System.out.println("now:"+now);
    

    image-202107234326190

    LocalDate

    LocalDate类说明

    LocalDate表示本地日期。只有表示年月日。相当于:yyyy-MM-dd。

    LocalDate常用的用法

    获取当前日期

    		LocalDate localDate1 = LocalDate.now();		
    		LocalDate localDate2 = LocalDate.now(ZoneId.of("Asia/Shanghai"));		
    		LocalDate localDate3 = LocalDate.now(Clock.systemUTC());
    		System.out.println("now         :"+localDate1);	
    		System.out.println("now by zone :"+localDate2);
    		System.out.println("now by Clock:"+localDate3);
    

    image-2021081496781

    获取localDate对象

    		LocalDate localDate1 = LocalDate.of(2021, 8, 14);
    		LocalDate localDate2 = LocalDate.parse("2021-08-14");
    		System.out.println(localDate1);		
    		System.out.println(localDate2);
    

    image-2021081497325

    获取指定日期的年月日

    		
    LocalDate localDate1 = LocalDate.of(2021, 8, 14);		
    // 当前日期年份:2021		
    System.out.println(localDate1.getYear());		
    // 当前日期月份对象:AUGUST		
    System.out.println(localDate1.getMonth());		
    // 当前日期月份:8		
    System.out.println(localDate1.getMonthValue());		
    // 该日期是当前周的第几天:6		
    System.out.println(localDate1.getDayOfWeek().getValue());		
    // 该日期是当前月的第几天:14		
    System.out.println(localDate1.getDayOfMonth());		
    // 该日期是当前年的第几天:226		
    System.out.println(localDate1.getDayOfYear());
    

    image-2021081498430

    修改年月日

    		LocalDate localDate1 = LocalDate.of(2021, 8, 14);
    		// 修改该日期的年份:2022-08-14
    		System.out.println(localDate1.withYear(2022));
    		// 修改该日期的月份:2021-12-14
    		System.out.println(localDate1.withMonth(12));
    		// 修改该日期在当月的天数:2021-08-01
    		System.out.println(localDate1.withDayOfMonth(1));
    

    image-20210814935404

    比较日期

    		LocalDate localDate1 = LocalDate.of(2021, 8, 14);
    		// 比较指定日期和参数日期,返回正数,那么指定日期时间较晚(数字较大):13
    		int i = localDate1.compareTo(LocalDate.of(2021, 8, 1));
    		System.out.println(i);
    		// 比较指定日期是否比参数日期早(true为早):true
    		System.out.println(localDate1.isBefore(LocalDate.of(2021,8,31)));
    		// 比较指定日期是否比参数日期晚(true为晚):false
    		System.out.println(localDate1.isAfter(LocalDate.of(2021,8,31)));
    		// 比较两个日期是否相等:true
    		System.out.println(localDate1.isEqual(LocalDate.of(2021, 8, 14)));
    

    image-202108149597

    LocalDate 和String相互转化、Date和LocalDate相互转化

    LocalDate 和String相互转化

    		LocalDate localDate1 = LocalDate.of(2021, 8, 14);
    		// LocalDate 转 String
    		DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    		String dateString = localDate1.format(dateTimeFormatter);
    		System.out.println("LocalDate 转 String:"+dateString);
    		// String 转 LocalDate
    		String str = "2021-08-14";
    		DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    		LocalDate date = LocalDate.parse(str, fmt);
    		System.out.println("String 转 LocalDate:"+date);
    

    image-2021081499979

    Date和LocalDate相互转化

    	// Date 转 LocalDate
    		Date now = new Date();
    		// 先将Date转换为ZonedDateTime
    		Instant instant = now.toInstant();
    		ZonedDateTime zonedDateTime = instant.atZone(ZoneId.of("Asia/Shanghai"));
    		LocalDate localDate = zonedDateTime.toLocalDate();
    		// Sat Aug 14 23:16:28 CST 2021
    		System.out.println(now);
    		// 2021-08-14
    		System.out.println(localDate);
    
    		// LocalDate 转 Date
    		LocalDate now1 = LocalDate.now();
    		ZonedDateTime dateTime = now1.atStartOfDay(ZoneId.of("Asia/Shanghai"));
    		Date date1 = Date.from(dateTime.toInstant());
    		System.out.println(date1);
    

    image-2021081492237

    LocalDateTime

    LocalDateTime类说明

    表示当前日期时间,相当于:yyyy-MM-ddTHH:mm:ss

    LocalDateTime常用的用法

    获取当前日期和时间

    		LocalDate d = LocalDate.now(); // 当前日期
    		LocalTime t = LocalTime.now(); // 当前时间
    		LocalDateTime dt = LocalDateTime.now(); // 当前日期和时间
    		System.out.println(d); // 严格按照ISO 8601格式打印
    		System.out.println(t); // 严格按照ISO 8601格式打印
    		System.out.println(dt); // 严格按照ISO 8601格式打印
    

    image-20210714857780

    由运行结果可行,本地日期时间通过now()获取到的总是以当前默认时区返回的

    获取指定日期和时间

    		LocalDate d2 = LocalDate.of(2021, 07, 14); // 2021-07-14, 注意07=07月
    		LocalTime t2 = LocalTime.of(13, 14, 20); // 13:14:20
    		LocalDateTime dt2 = LocalDateTime.of(2021, 07, 14, 13, 14, 20);
    		LocalDateTime dt3 = LocalDateTime.of(d2, t2);
    		System.out.println("指定日期时间:"+dt2);
    		System.out.println("指定日期时间:"+dt3);
    

    image-20210714803165

    日期时间的加减法及修改

    		LocalDateTime currentTime = LocalDateTime.now(); // 当前日期和时间
    		System.out.println("------------------时间的加减法及修改-----------------------");
    		//3.LocalDateTime的加减法包含了LocalDate和LocalTime的所有加减,上面说过,这里就只做简单介绍
    		System.out.println("3.当前时间:" + currentTime);
    		System.out.println("3.当前时间加5年:" + currentTime.plusYears(5));
    		System.out.println("3.当前时间加2个月:" + currentTime.plusMonths(2));
    		System.out.println("3.当前时间减2天:" + currentTime.minusDays(2));
    		System.out.println("3.当前时间减5个小时:" + currentTime.minusHours(5));
    		System.out.println("3.当前时间加5分钟:" + currentTime.plusMinutes(5));
    		System.out.println("3.当前时间加20秒:" + currentTime.plusSeconds(20));
    		//还可以灵活运用比如:向后加一年,向前减一天,向后加2个小时,向前减5分钟,可以进行连写
    		System.out.println("3.同时修改(向后加一年,向前减一天,向后加2个小时,向前减5分钟):" + currentTime.plusYears(1).minusDays(1).plusHours(2).minusMinutes(5));
    		System.out.println("3.修改年为2025年:" + currentTime.withYear(2025));
    		System.out.println("3.修改月为12月:" + currentTime.withMonth(12));
    		System.out.println("3.修改日为27日:" + currentTime.withDayOfMonth(27));
    		System.out.println("3.修改小时为12:" + currentTime.withHour(12));
    		System.out.println("3.修改分钟为12:" + currentTime.withMinute(12));
    		System.out.println("3.修改秒为12:" + currentTime.withSecond(12));
    

    image-20210714941902

    LocalDateTime和Date相互转化

    Date转LocalDateTime

    		System.out.println("------------------方法一:分步写-----------------------");
    		//实例化一个时间对象
    		Date date = new Date();
    		//返回表示时间轴上同一点的瞬间作为日期对象
    		Instant instant = date.toInstant();
    		//获取系统默认时区
    		ZoneId zoneId = ZoneId.systemDefault();
    		//根据时区获取带时区的日期和时间
    		ZonedDateTime zonedDateTime = instant.atZone(zoneId);
    		//转化为LocalDateTime
    		LocalDateTime localDateTime = zonedDateTime.toLocalDateTime();
    		System.out.println("方法一:原Date = " + date);
    		System.out.println("方法一:转化后的LocalDateTime = " + localDateTime);
    
    		System.out.println("------------------方法二:一步到位(推荐使用)-----------------------");
    		//实例化一个时间对象
    		Date todayDate = new Date();
    		//Instant.ofEpochMilli(long l)使用1970-01-01T00:00:00Z的纪元中的毫秒来获取Instant的实例
    		LocalDateTime ldt = Instant.ofEpochMilli(todayDate.getTime()).atZone(ZoneId.systemDefault()).toLocalDateTime();
    		System.out.println("方法二:原Date = " + todayDate);
    		System.out.println("方法二:转化后的LocalDateTime = " + ldt);
    

    image-20210714210839339

    LocalDateTime转Date

    		System.out.println("------------------方法一:分步写-----------------------");
    		//获取LocalDateTime对象,当前时间
    		LocalDateTime localDateTime = LocalDateTime.now();
    		//获取系统默认时区
    		ZoneId zoneId = ZoneId.systemDefault();
    		//根据时区获取带时区的日期和时间
    		ZonedDateTime zonedDateTime = localDateTime.atZone(zoneId);
    		//返回表示时间轴上同一点的瞬间作为日期对象
    		Instant instant = zonedDateTime.toInstant();
    		//转化为Date
    		Date date = Date.from(instant);
    		System.out.println("方法一:原LocalDateTime = " + localDateTime);
    		System.out.println("方法一:转化后的Date = " + date);
    
    		System.out.println("------------------方法二:一步到位(推荐使用)-----------------------");
    		//实例化一个LocalDateTime对象
    		LocalDateTime now = LocalDateTime.now();
    		//转化为date
    		Date dateResult = Date.from(now.atZone(ZoneId.systemDefault()).toInstant());
    		System.out.println("方法二:原LocalDateTime = " + now);
    		System.out.println("方法二:转化后的Date = " + dateResult);
    

    image-20210714211035080

    LocalTime

    LocalTime类说明

    LocalTime:本地时间,只有表示时分秒

    LocalTime常用的用法

    获取当前时间

    		LocalTime localTime1 = LocalTime.now();
    		LocalTime localTime2 = LocalTime.now(ZoneId.of("Asia/Shanghai"));
    		LocalTime localTime3 = LocalTime.now(Clock.systemDefaultZone());
    
    		System.out.println("now         :"+localTime1);
    		System.out.println("now by zone :"+localTime2);
    		System.out.println("now by Clock:"+localTime3);
    

    image-2021081498171

    获取LocalTime对象

    		LocalTime localTime1 = LocalTime.of(23, 26, 30);
    		LocalTime localTime2 = LocalTime.of(23, 26);
    		System.out.println(localTime1);
    		System.out.println(localTime2);
    

    image-2021081494673

    获取指定日期的时分秒

    		LocalTime localTime1 = LocalTime.of(23, 26, 30);
    		//当前时间的时:23
    		System.out.println(localTime1.getHour());
    		//当前时间的分:26
    		System.out.println(localTime1.getMinute());
    		//当前时间的秒:30
    		System.out.println(localTime1.getSecond());
    

    image-2021081492055

    修改时分秒

    		LocalTime localTime1 = LocalTime.of(23, 26, 30);
    		//修改时间的时:00:26:30
    		System.out.println(localTime1.withHour(0));
    		//修改时间的分:23:30:30
    		System.out.println(localTime1.withMinute(30));
    		//修改时间的秒:23:26:59
    		System.out.println(localTime1.withSecond(59));
    

    image-202108149774

    比较时间

    		LocalTime localTime1 = LocalTime.of(23, 26, 30);
    		LocalTime localTime2 = LocalTime.of(23, 26, 32);
    		// 两个时间进行比较 大返回1,小就返回-1,一样就返回0:-1
    		System.out.println(localTime1.compareTo(localTime2));
    
    		// 比较指定时间是否比参数时间早(true为早):true
    		System.out.println(localTime1.isBefore(localTime2));
    		// 比较指定时间是否比参数时间晚(true为晚):false
    		System.out.println(localTime1.isAfter(localTime2));
    		// 比较两个时间是否相等:true
    		System.out.println(localTime1.equals(LocalTime.of(23, 26, 30)));
    

    image-2021081498214

    OffsetDateTime

    OffsetDateTime类说明

    OffsetDateTime:有时间偏移量的日期时间(不包含基于ZoneRegion的时间偏移量)

    public final class OffsetDateTime
            implements Temporal, TemporalAdjuster, Comparable<OffsetDateTime>, Serializable {
        //The minimum supported {@code OffsetDateTime}, '-999999999-01-01T00:00:00+18:00' 
        public static final OffsetDateTime MIN = LocalDateTime.MIN.atOffset(ZoneOffset.MAX);
        // The maximum supported {@code OffsetDateTime}, '+999999999-12-31T23:59:59.999999999-18:00'.
        public static final OffsetDateTime MAX = LocalDateTime.MAX.atOffset(ZoneOffset.MIN);
            ...
            }
    

    上面的MINMAX 是公有静态变量。

    OffsetDateTime常用的用法

    获取当前日期时间

    		OffsetDateTime offsetDateTime1 = OffsetDateTime.now();
    		OffsetDateTime offsetDateTime2 = OffsetDateTime.now(ZoneId.of("Asia/Shanghai"));
    		OffsetDateTime offsetDateTime3 = OffsetDateTime.now(Clock.systemUTC());
    
    		System.out.println("now         :"+offsetDateTime1);
    		System.out.println("now by zone :"+offsetDateTime2);
    		System.out.println("now by Clock:"+offsetDateTime3);
    

    image-2021082196097

    获取OffsetDateTime对象

    		LocalDateTime localDateTime1 = LocalDateTime.of(2021, 8, 15, 13, 14, 20);
    		OffsetDateTime offsetDateTime1 = OffsetDateTime.of(localDateTime1, ZoneOffset.ofHours(8));
    		OffsetDateTime offsetDateTime2 = OffsetDateTime. of(2021, 8, 15, 13, 14, 20,0, ZoneOffset.ofHours(8));
    		Instant now = Instant.now();
    		OffsetDateTime offsetDateTime3 = OffsetDateTime.ofInstant(now, ZoneId.of("Asia/Shanghai"));
    
    		System.out.println(offsetDateTime1);
    		System.out.println(offsetDateTime2);
    		System.out.println(offsetDateTime3);
    

    image-20210821900413

    获取指定日期的年月日时分秒

    		LocalDateTime localDateTime1 = LocalDateTime.of(2021, 8, 15, 13, 14, 20);
    		OffsetDateTime offsetDateTime1 = OffsetDateTime.of(localDateTime1, ZoneOffset.ofHours(8));
    		//当前时间的年:2021
    		System.out.println(offsetDateTime1.getYear());
    		//当前时间的月:8
    		System.out.println(offsetDateTime1.getMonthValue());
    		//当前时间的日:15
    		System.out.println(offsetDateTime1.getDayOfMonth());
    		//当前时间的时:13
    		System.out.println(offsetDateTime1.getHour());
    		//当前时间的分:14
    		System.out.println(offsetDateTime1.getMinute());
    		//当前时间的秒:20
    		System.out.println(offsetDateTime1.getSecond());
    

    image-2021082193542

    修改年月日时分秒

    		LocalDateTime localDateTime1 = LocalDateTime.of(2021, 8, 15, 13, 14, 20);
    		OffsetDateTime offsetDateTime1 = OffsetDateTime.of(localDateTime1, ZoneOffset.ofHours(8));
    		//修改时间的年:2022-08-15T13:14:20+08:00
    		System.out.println(offsetDateTime1.withYear(2022));
    		//修改时间的月:2021-09-15T13:14:20+08:00
    		System.out.println(offsetDateTime1.withMonth(9));
    		//修改时间的日:2021-08-30T13:14:20+08:00
    		System.out.println(offsetDateTime1.withDayOfMonth(30));
    		//修改时间的时:2021-08-15T00:14:20+08:00
    		System.out.println(offsetDateTime1.withHour(0));
    		//修改时间的分:2021-08-15T13:30:20+08:00
    		System.out.println(offsetDateTime1.withMinute(30));
    		//修改时间的秒:2021-08-15T13:14:59+08:00
    		System.out.println(offsetDateTime1.withSecond(59));
    

    image-2021082194524

    比较日期时间

    		LocalDateTime localDateTime1 = LocalDateTime.of(2021, 8, 15, 13, 14, 20);
    		OffsetDateTime offsetDateTime1 = OffsetDateTime.of(localDateTime1, ZoneOffset.ofHours(8));
    		OffsetDateTime offsetDateTime3 = OffsetDateTime.of(localDateTime1, ZoneOffset.ofHours(8));
    
    		LocalDateTime localDateTime2 = LocalDateTime.of(2021, 8, 15, 13, 14, 30);
    		OffsetDateTime offsetDateTime2 = OffsetDateTime.of(localDateTime2, ZoneOffset.ofHours(8));
    
    		// 两个时间进行比较 大返回1,小就返回-1,一样就返回0:-1
    		System.out.println(offsetDateTime1.compareTo(offsetDateTime2));
    
    		// 比较指定时间是否比参数时间早(true为早):true
    		System.out.println(offsetDateTime1.isBefore(offsetDateTime2));
    		// 比较指定时间是否比参数时间晚(true为晚):false
    		System.out.println(offsetDateTime1.isAfter(offsetDateTime2));
    		// 比较两个时间是否相等:true
    		System.out.println(offsetDateTime1.equals(offsetDateTime3));
    

    image-20210821944542

    字符串转化为OffsetDateTime对象

    				String str = "2021-08-15T10:15:30+08:00";
    		OffsetDateTime offsetDateTime1 = OffsetDateTime.parse(str);
    		OffsetDateTime offsetDateTime2 = OffsetDateTime.parse(str,DateTimeFormatter.ISO_OFFSET_DATE_TIME);
    
    		System.out.println(offsetDateTime1);
    		System.out.println(offsetDateTime2);
    

    image-2021082196169

    OffsetTime

    OffsetTime类说明

    OffsetTime:有时间偏移量的时间

    public final class OffsetTime
            implements Temporal, TemporalAdjuster, Comparable<OffsetTime>, Serializable {
       //The minimum supported {@code OffsetTime}, '00:00:00+18:00'.
        public static final OffsetTime MIN = LocalTime.MIN.atOffset(ZoneOffset.MAX);
        
        //The maximum supported {@code OffsetTime}, '23:59:59.999999999-18:00'.
        public static final OffsetTime MAX = LocalTime.MAX.atOffset(ZoneOffset.MIN);
        ...
    }
    

    上面的MINMAX 是公有静态变量。

    OffsetTime常用的用法

    获取当前时间

    		OffsetTime offsetTime1 = OffsetTime.now();
    		OffsetTime offsetTime2 = OffsetTime.now(ZoneId.of("Asia/Shanghai"));
    		OffsetTime offsetTime3 = OffsetTime.now(Clock.systemUTC());
    
    		System.out.println("now         :"+offsetTime1);
    		System.out.println("now by zone :"+offsetTime2);
    		System.out.println("now by Clock:"+offsetTime3);
    

    image-2021088203

    获取OffsetTime对象

    		LocalTime localTime1 = LocalTime.of(13, 14, 20);
    		OffsetTime offsetTime1 = OffsetTime.of(localTime1, ZoneOffset.ofHours(8));
    		OffsetTime offsetTime2 = OffsetTime. of(13, 14, 20,0, ZoneOffset.ofHours(8));
    		Instant now = Instant.now();
    		OffsetTime offsetTime3 = OffsetTime.ofInstant(now, ZoneId.of("Asia/Shanghai"));
    
    		System.out.println(offsetTime1);
    		System.out.println(offsetTime2);
    		System.out.println(offsetTime3);
    

    image-20210895380

    获取指定时间的时分秒

    		LocalTime localTime1 = LocalTime.of( 13, 14, 20);
    		OffsetTime offsetTime1 = OffsetTime.of(localTime1, ZoneOffset.ofHours(8));
    
    		//当前时间的时:13
    		System.out.println(offsetTime1.getHour());
    		//当前时间的分:14
    		System.out.println(offsetTime1.getMinute());
    		//当前时间的秒:20
    		System.out.println(offsetTime1.getSecond());
    

    image-202108802988

    修改时分秒

    		LocalTime localTime1 = LocalTime.of( 13, 14, 20);
    		OffsetTime offsetTime1 = OffsetTime.of(localTime1, ZoneOffset.ofHours(8));
    
    		//修改时间的时:00:14:20+08:00
    		System.out.println(offsetTime1.withHour(0));
    		//修改时间的分:13:30:20+08:00
    		System.out.println(offsetTime1.withMinute(30));
    		//修改时间的秒:13:14:59+08:00
    		System.out.println(offsetTime1.withSecond(59));
    

    image-202108945483

    比较时间

    		LocalTime localTime1 = LocalTime.of( 13, 14, 20);
    		OffsetTime offsetTime1 = OffsetTime.of(localTime1, ZoneOffset.ofHours(8));
    		OffsetTime offsetTime3 = OffsetTime.of(localTime1, ZoneOffset.ofHours(8));
    
    		LocalTime localTime2 = LocalTime.of(13, 14, 30);
    		OffsetTime offsetTime2 = OffsetTime.of(localTime2, ZoneOffset.ofHours(8));
    		// 两个时间进行比较 大返回1,小就返回-1,一样就返回0:-1
    		System.out.println(offsetTime1.compareTo(offsetTime2));
    
    		// 比较指定时间是否比参数时间早(true为早):true
    		System.out.println(offsetTime1.isBefore(offsetTime2));
    		// 比较指定时间是否比参数时间晚(true为晚):false
    		System.out.println(offsetTime1.isAfter(offsetTime2));
    		// 比较两个时间是否相等:true
    		System.out.println(offsetTime1.equals(offsetTime3));
    

    image-2021089109890

    ZonedDateTime

    ZonedDateTime类说明

    表示一个带时区的日期和时间,ZonedDateTime可以理解为LocalDateTime+ZoneId

    从源码可以看出来,ZonedDateTime类中定义了LocalDateTime和ZoneId两个变量。

    且ZonedDateTime类也是不可变类且是线程安全的。

    public final class ZonedDateTime
            implements Temporal, ChronoZonedDateTime<LocalDate>, Serializable {
    
        /**
         * Serialization version.
         */
        private static final long serialVersionUID = -6260982410461394882L;
    
        /**
         * The local date-time.
         */
        private final LocalDateTime dateTime;
        /**
         * The time-zone.
         */
        private final ZoneId zone;
        
        ...
    }
    

    ZonedDateTime常用的用法

    获取当前日期时间

    		// 默认时区获取当前时间
    		ZonedDateTime zonedDateTime = ZonedDateTime.now();
    		// 用指定时区获取当前时间,Asia/Shanghai为上海时区
    		ZonedDateTime zonedDateTime1 = ZonedDateTime.now(ZoneId.of("Asia/Shanghai"));
    		//withZoneSameInstant为转换时区,参数为ZoneId
    		ZonedDateTime zonedDateTime2 = zonedDateTime.withZoneSameInstant(ZoneId.of("America/New_York"));
    		System.out.println(zonedDateTime);
    		System.out.println(zonedDateTime1);
    		System.out.println(zonedDateTime2);
    

    image-202107205246938

    		ZonedDateTime zonedDateTime1 = ZonedDateTime.now();
    		ZonedDateTime zonedDateTime2 = ZonedDateTime.now(ZoneId.of("Asia/Shanghai"));
    		ZonedDateTime zonedDateTime3 = ZonedDateTime.now(Clock.systemUTC());
    
    		System.out.println("now         :"+zonedDateTime1);
    		System.out.println("now by zone :"+zonedDateTime2);
    		System.out.println("now by Clock:"+zonedDateTime3);
    

    image-202108957912

    获取ZonedDateTime对象

    		LocalDateTime localDateTime1 = LocalDateTime.of(2021, 8, 15, 13, 14, 20);
    		ZonedDateTime zonedDateTime1 = ZonedDateTime.of(localDateTime1, ZoneOffset.ofHours(8));
    		ZonedDateTime zonedDateTime2 = ZonedDateTime. of(2021, 8, 15, 13, 14, 20,0, ZoneOffset.ofHours(8));
    		Instant now = Instant.now();
    		ZonedDateTime zonedDateTime3 = ZonedDateTime.ofInstant(now, ZoneId.of("Asia/Shanghai"));
    
    		System.out.println(zonedDateTime1);
    		System.out.println(zonedDateTime2);
    		System.out.println(zonedDateTime3);
    

    image-2021088020148

    获取指定日期的年月日时分秒

    		LocalDateTime localDateTime1 = LocalDateTime.of(2021, 8, 15, 13, 14, 20);
    		ZonedDateTime zonedDateTime1 = ZonedDateTime.of(localDateTime1, ZoneOffset.ofHours(8));
    		//当前时间的年:2021
    		System.out.println(zonedDateTime1.getYear());
    		//当前时间的月:8
    		System.out.println(zonedDateTime1.getMonthValue());
    		//当前时间的日:15
    		System.out.println(zonedDateTime1.getDayOfMonth());
    		//当前时间的时:13
    		System.out.println(zonedDateTime1.getHour());
    		//当前时间的分:14
    		System.out.println(zonedDateTime1.getMinute());
    		//当前时间的秒:20
    		System.out.println(zonedDateTime1.getSecond());
    

    image-202108219231845

    修改年月日时分秒

    		LocalDateTime localDateTime1 = LocalDateTime.of(2021, 8, 15, 13, 14, 20);
    		ZonedDateTime zonedDateTime1 = ZonedDateTime.of(localDateTime1, ZoneOffset.ofHours(8));
    		//修改时间的年:2022-08-15T13:14:20+08:00
    		System.out.println(zonedDateTime1.withYear(2022));
    		//修改时间的月:2021-09-15T13:14:20+08:00
    		System.out.println(zonedDateTime1.withMonth(9));
    		//修改时间的日:2021-08-30T13:14:20+08:00
    		System.out.println(zonedDateTime1.withDayOfMonth(30));
    		//修改时间的时:2021-08-15T00:14:20+08:00
    		System.out.println(zonedDateTime1.withHour(0));
    		//修改时间的分:2021-08-15T13:30:20+08:00
    		System.out.println(zonedDateTime1.withMinute(30));
    		//修改时间的秒:2021-08-15T13:14:59+08:00
    		System.out.println(zonedDateTime1.withSecond(59));
    

    image-20210821998

    比较日期时间

    		LocalDateTime localDateTime1 = LocalDateTime.of(2021, 8, 15, 13, 14, 20);
    		ZonedDateTime zonedDateTime1 = ZonedDateTime.of(localDateTime1, ZoneOffset.ofHours(8));
    
    		ZonedDateTime zonedDateTime3 = ZonedDateTime.of(localDateTime1, ZoneOffset.ofHours(8));
    
    		LocalDateTime localDateTime2 = LocalDateTime.of(2021, 8, 15, 13, 14, 30);
    		ZonedDateTime zonedDateTime2 = ZonedDateTime.of(localDateTime2, ZoneOffset.ofHours(8));
    
    		// 两个时间进行比较 大返回1,小就返回-1,一样就返回0:-1
    		System.out.println(zonedDateTime1.compareTo(zonedDateTime2));
    
    		// 比较指定时间是否比参数时间早(true为早):true
    		System.out.println(zonedDateTime1.isBefore(zonedDateTime2));
    		// 比较指定时间是否比参数时间晚(true为晚):false
    		System.out.println(zonedDateTime1.isAfter(zonedDateTime2));
    		// 比较两个时间是否相等:true
    		System.out.println(zonedDateTime1.equals(zonedDateTime3));
    

    image-20210821907094

    LocalDateTime+ZoneId变ZonedDateTime

    		LocalDateTime localDateTime = LocalDateTime.now();
    		ZonedDateTime zonedDateTime1 = localDateTime.atZone(ZoneId.systemDefault());
    		ZonedDateTime zonedDateTime2 = localDateTime.atZone(ZoneId.of("America/New_York"));
    		System.out.println(zonedDateTime1);
    		System.out.println(zonedDateTime2);
    

    image-2021072094003

    上面的例子说明了,LocalDateTime是可以转成ZonedDateTime的。

    推荐相关文章

    hutool日期时间系列文章

    1DateUtil(时间工具类)-当前时间和当前时间戳

    2DateUtil(时间工具类)-常用的时间类型Date,DateTime,Calendar和TemporalAccessor(LocalDateTime)转换

    3DateUtil(时间工具类)-获取日期的各种内容

    4DateUtil(时间工具类)-格式化时间

    5DateUtil(时间工具类)-解析被格式化的时间

    6DateUtil(时间工具类)-时间偏移量获取

    7DateUtil(时间工具类)-日期计算

    8ChineseDate(农历日期工具类)

    9LocalDateTimeUtil(JDK8+中的{@link LocalDateTime} 工具类封装)

    10TemporalAccessorUtil{@link TemporalAccessor} 工具类封装

    其他

    要探索JDK的核心底层源码,那必须掌握native用法

    万字博文教你搞懂java源码的日期和时间相关用法

    java的SimpleDateFormat线程不安全出问题了,虚竹教你多种解决方案

    源码分析:JDK获取默认时区的风险和最佳实践

    展开全文
  • 今天为大家奉上项目经理必备时间管理技能—麦肯锡30秒电梯理论。麦肯锡公司曾经得到过一次沉痛的教训:该公司曾经为一家重要的大客户做咨询。咨询结束的时候,麦肯锡的项目负责人在电梯间里遇见了对方的董事长,该...

    项目经理很忙?项目经理很忙!鲁迅先生说过:时间就像海绵里的水,挤挤总会有的。忙碌的项目经理想要挤出时间,就需要掌握好卓越的个人时间管理方法。今天为大家奉上项目经理必备时间管理技能—麦肯锡30秒电梯理论。

    麦肯锡公司曾经得到过一次沉痛的教训:该公司曾经为一家重要的大客户做咨询。咨询结束的时候,麦肯锡的项目负责人在电梯间里遇见了对方的董事长,该董事长问麦肯锡的项目负责人:“你能不能说一下现在的结果呢?”由于该项目负责人没有准备,而且即使有准备,也无法在电梯从30层到1层的30秒钟内把结果说清楚。最终,麦肯锡失去了这一重要客户。

    t阿达asd 啊img.jpg

    从此,麦肯锡要求公司员工凡事要在最短的时间内把结果表达清楚,凡事要直奔主题、直奔结果。麦肯锡认为,一般情况下人们最多记得住一二三,记不住四五六,所以凡事要归纳在3条以内。这就是如今在商界流传甚广的“30秒钟电梯理论”或称“电梯演讲”。

    虽然是一个关于谈话的故事,但是对于项目经理来说却是非常有用的。作为一名PM,无论是与领导沟通,与需求方沟通,与团队成员沟通,都是很耗费时间的,而项目经理的时间是非常紧,或者领导、需求方、团队成员的时间很紧,谁都有一堆的事情要处理,这个时候,就需要在最短的有效时间内完成核心部分交流,让对方记住自己所要表达的内容。缩短沟通时间,提高执行效率,原本需要一个小时去沟通的时间,现在可以用更短的时间去完成,那么在单位时间上所创造的工作效率就会相当高,这将直接带动双方的后续做事效率。

    而想要做好这一点,也不是简单说说的。你需要做到(锻炼)如下三点:

    1、充分的前期准备

    任何业务要勤于积累,足够多的积累是巧妙应变的前提。俗话说,不打无把握之仗,对要沟通对象的历史、现状、周边、优势、接洽人的特点等进行详细的分析,做到心中有数,对谈话中可能出现的问题做好充足的准备。对方做出决定的时间就是一杯咖啡的时间,而你实现目的的时间也就只有一杯咖啡的时间,所以在作任何事情之前的充分准备尤为重要。

    2、快速的分析能力

    QQ截图20180326163240.jpg

    人之间的对话,变数最大,千亿次运转的计算机,也没人脑的变化快。当交流中的对方提出问题时,应当立即调动大脑进行全面的、立体的分析。快速的分析后找出共同点和答复方案,给与针对性的答复。同时要直达要点节省时间,以做到有效时间内最核心化表述。

    3、果断的归纳提炼

    对要答复的内容进行迅速归纳和提炼,总结出三个以内重点,抓住对方的心,果断地、自信的进行答复,把握交谈的主动权,争取达到双赢的目的。归纳表述时,人的思路和条理性是很重要的,要让别人听到之后就知道自己的思路和层次。归纳能力要求的是在对问题的分析基础上,有条理地说明问题,可以经常对自己需要讲话的内容列出提纲,再按照提纲的结构去表述。这样可以不断的锻炼这个方面的能力。

    通过以上三点,沟通的时候做到语出惊人、短小精悍、提炼观点,让你的沟通不再浪费你仅有的时间,让你的沟通与工作更加的有效率。

    展开全文
  • Unity3D UGUI实现冷却时间技能图标

    千次阅读 2016-07-29 21:01:15
    利用了Image组件的功能,接下来就为大家一步步实现这个小技能。先为大家介绍一下Image组件的ImageType属性。 (1)Simple: 最普通模式,用原图显示。 (2)Sliced: 切片模式,首先对图片本身的SpriteEditor编辑器,...
  • 极客时间 IT 20+ 张 各架构 高清技能图谱

    千次阅读 多人点赞 2019-04-16 13:54:34
  • 1. 此脚本可应用于各种网络游戏,用于自动间隔时间使用辅助技能,可自定义三个技能和间隔时间。 2. 脚本开始运行前请先在按键精灵主界面上设置自定义参数,修改后点击上方的“保存”按钮。 3. 可定义辅助技能...
  • AS3中技能或物品CD时间案例(转)

    千次阅读 2012-12-05 14:46:12
    下面我来介绍下,我们玩游戏的时候经常会看到有些技能释放后有一定的冷却时间的,就好像有一个阴影围着那个技能转圈圈一样,当圈圈转完之后技能又可以释放了,这个在AS3中怎么才能实现呢? 参考:...
  • 程序员第一定律:关于技能与收入

    万次阅读 多人点赞 2012-02-13 00:16:17
    现实中种种利益纷争、观点之争看似纷繁,但在大时间尺度下来看却都是规则的实现手段。这就好比下围棋,每一手都要为谋得利益而计算,但结局却只有三种:赢、输或和,这就是规则的力量。 民以食为天,所以第一定律从...
  • 技能冷却效果需要能和实际的冷却时间想关联,因此接下来需要通过代码实现: 6 编写冷却计时与冷却效果控制代码(C#),此代码作为参考,仅提供实现思路,实际使用还需要根据具体情况进行调整。 private ...
  • 关于Java程序员技能和面试注意事项

    千次阅读 2015-04-16 10:38:14
    想要成为合格的Java程序员或...本文陈列的这些内容既可以作为个人简历中的内容,也可以作为面试的时候跟面试官聊的东西,你可以把这些内容写到你的简历中,当然更需要的是你在面试的时候向面试官展示这些专业技能
  • BruceWoo ... 这篇文章是我在无意间浏览时发现的,对像我们这些刚接触运维的人来说这篇文章给了我一些对运维以后工作的方式及一个运维需要掌握的技术...曾经在一年多前写了一篇关于要成为linux运维需要掌握哪些技能...
  • 高效程序员的7个技能

    千次阅读 多人点赞 2020-06-06 19:33:08
    软件工程师往往会花大量的时间在刷面试题和整理履历上。但一旦在谷歌、亚马逊或其他创始公司找到工作,会发现找工作时所学习和准备的技能与实际工作中所使用的技能并不匹配。 PS:这也就是我们所说的“面试造火箭,...
  • 高级JAVA开发必须掌握技能java8 新日期时间API((一)JSR-310:ZoneId 时区和偏移量)
  • 运维工程师岗位工作技能的评定类别(3)和(4)3.运维监控技术级别0,什么都不懂级别1,常见监控工具或软件系统的基本安装、配置、使用,照猫画虎会使用而已。级别2,熟悉监控系统的基本原理和常用配置项,熟练配置...
  • CSDN学院推出限时优惠小程序课程,正是为了第一时间帮助小伙伴们了解微信小程序API,包括页面布局、网络交互、媒体文件、本地缓存、地理位置、WebSocket和传感器技术,最后以翼健康为模板,开发一套完整的求医问诊...
  • Android 技能

    千次阅读 2016-09-29 01:29:33
    为此,特地腾出时间整理一些资料,罗列一些重要的技能点。持续更新中。。。先大致分为如下几块吧: java基本语法(封装、继承、多态;锁机制、范型、反射、注解、lambda) 常用包(Collection、lang、concurrent、io...
  • 软件技能

    千次阅读 2018-02-27 13:44:53
    摘要:根据我的开发实践及理解,梳理了作为软件工程师解决现实问题应当具备的基础技能。 难度:中级。 编程开发本质是运用程序和计算机来解决现实中的各种问题。因此,编程开发人员的才智发挥载体是计算机或者说...
  • 开发人员的必备技能

    千次阅读 多人点赞 2017-05-10 10:06:29
    本文尝试列举出最重要的几个技能,也期望通过此列表能给新人一个比较明确的学习重点和路径。
  • 构思我们很少能听到关于技能的一个定义或描述,那么,如果我们需要用程序思维来概括技能,我们应该怎么措辞才比较准确?当然,对于不同的游戏,技能的设计复杂度也大不一样,复杂的可以复杂到如Dota每个角色的主动...
  • 数据(配置表和资源)、技能属性(消耗能量、冷却时间等)、事件操作(这是一个大的范畴,后面分析)、目标(施法者、目标、攻击方、弹道、目标点)、施加的状态Modifier(这也是一个比较大的范畴,后面分析)。...
  • 今天带给大家的是一个关于技能CD的效果制作。 此效果不仅可以用于技能CD,一些按钮的CD也是可以用的。 为了照顾大家迫不及待(猴急)的心情,我写了一个DEMO给大家。DEMO上面做了5个英雄的技能和一个XP技能的CD,...
  • 技能雷达图

    千次阅读 2017-06-22 14:04:49
    那就是一张技能雷达图。大致如下: 但是遗憾的是CSDN官方并不支持这一实现,其实对于技能雷达图而言,言简意赅的能表现出一个技术者擅长的领域,以及不擅长的领域。抱着玩一玩的态度,我也着手实现了一下针对CSDN...
  • 无论上是初学Python的小伙伴,还是学过一段时间有一定经验的小伙伴或多或少都会有迷茫和疑惑: 看着大家都说Python好学,好就业,可到底该怎么学,学到什么程度才能去找工作呢? 我想学Python相关领域的知识点,但...
  • 个人IOS技能

    千次阅读 2015-05-29 15:29:19
    一转眼,进入IOS领域已经半年了,整理了一下个人发展技能树,暂定时间为一年,技能树的最终目的是成为好的程序员,并且最终超越程序员
  • 游戏技能系统实现

    千次阅读 2014-10-22 15:50:05
    2、吟唱类技能:需要一段时间进行施法前的准备过程,可以被打断,打断施法失败 3、引导类技能:需要持续进行施法,一旦停止施法,则停止伤害 B、技能的影响对象 1、自已 2、敌方 3、队友 4、任意单位
  • 获得阿里巴巴编码规范技能认证

    万次阅读 多人点赞 2018-10-28 15:56:18
     (3)考试时间为90分钟;内容为50道选择题(大部分为多选题少部分为单选题;每道题2分);  (4)最终得分超过80分即为通过,可以多次考试;  3、我的证书: 【小结】  规范中有很多需要借鉴的...
  • mysql DBA技能

    千次阅读 2017-11-02 21:25:31
    DBA技能主备启动slave thread:登录到sql后运行start slave; 查看主备:show slave status\G 主备切换发生切换的原因是ha在固定时间内来测试数据库能否访问,如果数据库在多长时间内一直不能访问才会发生主备切换 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 337,788
精华内容 135,115
关键字:

关于时间的技能