精华内容
下载资源
问答
  • 推迟一周示例: Calendar curr = Calendar.getInstance(); //获取当前时间curr.set(Calendar.DAY_OF_... //给当前时间增加一周Date date=curr.getTime();//获取新的时间推迟一个月示例: Calendar curr = Calendar...
    推迟一周示例: 
    Calendar curr = Calendar.getInstance(); //获取当前时间
    curr.set(Calendar.DAY_OF_MONTH,curr.get(Calendar.DAY_OF_MONTH)+7); //给当前时间增加一周
    Date date=curr.getTime();//获取新的时间
    推迟一个月示例:
    Calendar curr = Calendar.getInstance();
    curr.set(Calendar.MONTH,curr.get(Calendar.MONTH)+1); //增加一月
    Date date=curr.getTime();
    推迟一年示例:
    Calendar curr = Calendar.getInstance();
    curr.set(Calendar.YEAR,curr.get(Calendar.YEAR)+1); //增加一年
    Date date=curr.getTime();


    //判断是否是闰年
    int years=curr.get(Calendar.YEAR);
    if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)) {
      //判断是否闰年,闰年366天
        days = 366;
     }else{
        days=365;
     }

    转载于:https://www.cnblogs.com/hujunli90/p/3823363.html

    展开全文
  • 2.中国工作日计算(将放假信息包含在内,暂只支持2021年),包括判断当前日期是否为工作日和下个工作日等方法。3.获取准确的起始时间方法,将准确结束时间精确到纳秒。4.代码优化,增加注释和文档等。...

    xk-time 3.0.0 已经发布 ,更新如下:

    1.时间自然语言分析工具类(NLP) TimeNLPUtil。

    包括功能:

    (1)以当前时间为基础分析时间自然语言。

    (2)以指定时间为基础分析时间自然语言。

    2.中国工作日计算(将放假信息包含在内,暂只支持2021年),包括判断当前日期是否为工作日和下一个工作日等方法。

    3.获取准确的起始时间方法,将准确结束时间精确到纳秒。

    4.代码优化,增加注释和文档等。

    软件介绍:

    xk-time 是时间转换,时间计算,时间格式化,时间解析,日历,时间cron表达式和时间NLP等的工具,使用Java8,线程安全,简单易用,多达70几种常用日期格式化模板,支持Java8时间类和Date,轻量级,无第三方依赖。

    xk-time is a tool for time conversion, time calculation, time formatting, time parsing, calendar, time cron expression and time NLP, etc. It uses Java8, thread-safe, easy to use, and more than 70 common date formatting templates , Support Java8 time class and Date, lightweight, no third-party dependencies.

    安装项目

    (1)Maven

    com.github.xkzhangsan

    xk-time

    3.0.0

    (2)Gradle

    compile group: 'com.github.xkzhangsan', name: 'xk-time', version: '3.0.0'

    注意:Android谨慎使用,Android端因为需要兼容低版本而不支持Java8,建议继续使用其他工具,如果有需要本项目相关的功能,可以参考源码实现,或留言给我。感谢支持!

    为什么要开发这个工具?

    (1)Java8以前的Date API设计不太好,使用不方便,往往会有线程安全问题。

    xk-time工具包,使用java8 api,其中Instant、LocalDate、LocalDateTime、LocalTime、ZonedDateTime等都是线程安全的类,而且增加了更丰富的方法,在此基础上开发相关工具类,线程安全,让使用更方便。

    (2)常见的DateUtil,往往将时间转换,计算,格式化,解析等功能都放在同一个类中,导致类功能复杂,方法太多,查找不方便。

    xk-time工具包,将上面功能按照时间转换,时间计算,时间格式化解析分成3个工具类:DateTimeConverterUtil,DateTimeCalculatorUtil,DateTimeFormatterUtil,每个类只做一个种功能,方便使用。

    (3)为了将与时间紧密相关的节假日、农历、二十四节气、十二星座、十二生肖、十二时辰和日历等功能集中起来开发成工具,方便使用。

    主要功能说明

    1.日期转换工具类 DateTimeConverterUtil

    包含Date、LocalDate、LocalDateTime、LocalTime、Instant、ZonedDateTime、YearMonth、Timestamp和long等互相转换

    注意,ZonedDateTime相关的转换,尤其是其他时间转ZonedDateTime,要注意时间和对应时区一致。

    详细使用可以查看相关测试代码。

    2.日期计算工具类 DateTimeCalculatorUtil

    包括:

    (1)获取时间属性方法(支持年月日时分秒毫秒,星期,时间戳等),get* 比如getYear(Date date) 获取年部分,getMonthCnLong(Date date)获取月份中文,getDayOfWeekCn(Date date),获取星期中文。

    (2)获取时间加操作方法,plus* 比如plusYears(Date date, long amountToAdd) 当前时间年增加amountToAdd值。

    (3)获取时间减操作方法,minus* 比如minusYears(Date date, long amountToSubtract) 当前时间年减少amountToSubtract值。

    (4)获取时间修改属性方法,with* 比如withYear(Date date, long newValue) 修改当前时间年值为newValue。

    (5)获取比较2个时间方法,between* 比如betweenYears(Date startInclusive, Date endExclusive) 比较2个时间,获取年部分。

    (6)其他常用方法,比如isLeapYear(Date date) 判断是否闰年,isWeekend(Date date) 判断是否周末,isExpiry(String yearMonthStr) 是否过期等

    (7)时区转换计算方法,transform*,比如transform(ZonedDateTime zonedDateTime, String zoneId)

    (8)比较2个时间大小和相等方法,compare*,比如compare(Date date1, Date date2)

    (9)获取准确的起始时间方法,start,end,比如startTimeOfMonth() 当月起始时间 当月第一天日期+00:00:00,endTimeOfMonth() 当月最后一天日期+23:59:59 精确到秒;endAccuracyTimeOf*,精确到毫秒(Date),精确到纳秒(LocalDateTime)。

    (10)相同月日比较判断方法,isSameMonthDay,betweenNextSameMonthDay,nextSameMonthDay*, 比如用于生日,节日等周期性的日期比较判断。

    (11)星座计算方法,getConstellation*,比如getConstellationNameCn(String monthDayStr),根据日期计算星座。

    (12)计算指定年月或起始时间区间的时间列表,get*List, 比如getDateList(int year, int month),计算指定年月的时间列表。

    (13)减少时间精度方法,reduceAccuracyTo*, 比如reduceAccuracyToDay(Date date),减少时间精度到天,其他补0,返回如,2020-04-23 00:00:00。

    (14)获取时间戳方法,getEpoch*, 比如getEpochMilli()获取时间戳,getEpochMilliFormat()获取时间戳格式化字符串(yyyy-MM-dd HH:mm:ss)

    (15)计算年龄方法,getAge*, 比如getAge(Date birthDay),通过生日计算年龄。

    (16)判断是否到生日方法,isBirthDay*, 比如isBirthDay(Date birthDay),根据生日判断当前日期是否到生日。

    (17)周数计算方法,weekof*, 比如weekOfMonth(Date date),日期所在月中第几周。

    (18)判断星期一,星期五方法,isMonday,isZhouYi, 比如isZhouYi(Date date),是否为周一。

    (19)十二时辰计算方法,getTwelveTwo*, 比如getTwelveTwo(Date date),获取指定时间对应的十二时辰。

    (20)季度计算方法,getQuarter*, 比如getQuarter(Date date),获取指定时间对应的季度。

    (21)获取季度准确的起始时间方法(四个季度),startTimeOf*Quarter, 比如startTimeOfFirstQuarter(int year),获取指定年的第一季度。

    (22) 获取年准确的起始时间方法,startTimeOfYear, 比如startTimeOfYear(int year),获取指定年的开始时间。

    (23)常用时间(明天,下周,下月,明年等)计算方法,比如tomorrow(),计算明天,返回Date。

    (24)修改星期值方法 withDayOfWeek*,比如withDayOfWeek(Date date, long newValue),修改星期为指定值newValue,返回Date。

    (25)中国工作日计算(将放假信息包含在内,暂只支持2021年),包括判断当前日期是否为工作日和下一个工作日等方法, isChineseWorkDay,nextChineseWorkDay,比 如isChineseWorkDay(Date),nextChineseWorkDay(Date date)。

    详细使用可以查看相关测试代码。

    3.日期格式化和解析工具类 DateTimeFormatterUtil

    包含常用日期格式如:

    yyyy-MM-dd

    HH:mm:ss

    yyyy-MM-dd HH:mm:ss

    yyyy-MM-dd HH:mm:ss.SSS

    yyyy-MM-dd HH:mm:ss.SSSSSS

    yyyy-MM-dd HH:mm:ss.SSSSSSSSS

    yyyy-MM-dd'T'HH:mm:ssZ

    等等 ,支持毫秒、微秒和纳秒等精确时间。

    (1)格式化方法, format*, 比如formatToDateStr(Date date) 格式化,返回日期部分,如:yyyy-MM-dd;

    format(Date date, DateTimeFormatter formatter) formatter 可以选择已定义好的formatter比如YYYY_MM_DD_HH_MM_SS_FMT(yyyy-MM-dd HH:mm:ss)格式化日期。

    (2)解析方法, parse*, 比如parseDateStrToDate(String text) 解析日期yyyy-MM-dd,返回Date;

    parseToDate(String text, DateTimeFormatter formatter) 根据 formatter解析为 Date。

    (3)自动解析方法,根据字符串特点自动识别解析,smartParse*,比如smartParseToDate(String text) 自动解析Date。

    (4)ISO格式(包含T)自动解析方法,根据字符串特点自动识别解析,parseIso*,比如parseIsoToDate(String text) 自动解析Date。

    (5)解析时间戳方法, parseEpochMilli*, 比如parseEpochMilliToDate(String text),解析时间戳为Date,如 1590224790000。

    (6)解析Date默认格式,parseDateDefaultStr*,比如parseDateDefaultStrToDate(String text)

    解析 EEE MMM dd HH:mm:ss zzz yyyy 比如: Sat May 23 17:06:30 CST 2020 为Date。

    (7)自定义时区格式化方法,比如 format(Date date, DateTimeFormatter formatter, String zoneId),根据zoneId格式化Date。

    (8)自定义模板格式化方法,比如 format(Date date, String dateFormatPattern),根据dateFormatPattern格式化Date。

    (9)自定义模板解析方法,比如 parseToDate(String text, String dateFormatPattern),根据dateFormatPattern格式化Date。

    (10)Timestamp默认格式( yyyy-mm-dd hh:mm:ss.fffffffff 其中 fffffffff 纳秒,省略后面的0)格式化方法。

    比如 formatTimestampStyle(Date date)。

    (11)Timestamp默认格式( yyyy-mm-dd hh:mm:ss.fffffffff 其中 fffffffff 纳秒,省略后面的0)解析方法。

    比如 parseTimestampStyleToDate(String text)。

    (12)验证日期格式是否正确方法,isValidDate*, 比如isValidDate(String text),验证yyyy-MM-dd 格式字符串是否正确。

    (13)根据自定义模板数组解析方法, 比如parseToDate(String text, String[] dateFormatPatterns),dateFormatPatterns 支持多种模板,只要其中一个解析成功就返回对应Date。

    (14)解析自然语言时间,今天,明天,下周,下月,明年,昨天,上周,上月,去年等, 比如parseNaturalLanguageToDate(String text),

    parseNaturalLanguageToDate(String text, Map naturalLanguageMap) 支持自定义解析自然语言时间map

    注意:格式化和解析与系统时区不同的时间时,使用自定义时区格式化方法,或可以使用withZone方法重新设置时区,比如:

    YYYY_MM_DD_HH_MM_SS_SSS_FMT.withZone(ZoneId.of("Europe/Paris") 。

    详细使用可以查看相关测试代码。

    4.日历工具类 CalendarUtil

    包括:

    (1)生成指定时间的日历(包含年、月和日层级关系的日历)方法,generateCalendar* 比如generateCalendar(int year, int month) 生成指定年月的日历。

    (2)生成指定时间的日历(包含年、月和日层级关系的日历),包含农历和所有节假日信息方法,generateCalendarWithHoliday*, 比generateCalendarWithHoliday(int year, int month, Map localHolidayMap,Map chineseHolidayMap, Map dateTypeMap)生成指定年月的日历,包含农历和所有节假日信息,可以自定义节假日和工作日等。

    详细使用可以查看相关测试代码。

    5.农历日期类 LunarDate

    包含:

    (1)农历日期年月日计算。

    (2)农历岁次,生肖属相计算。

    (3)二十四节气计算等

    注意: 仅支持公历1900-2100年的农历转换。

    详细使用可以查看相关测试代码。

    6.节假日计算工具类 HolidayUtil

    包含:

    (1)公历节假日计算, getLocalHoliday* 比如getLocalHoliday(Date date) 计算date的公历节日,getLocalHoliday(Date date, Map localHolidayMap) 可以传入自定义公历节日数据。

    (2)农历节假日计算, getChineseHoliday* 比如getChineseHoliday(Date date) 计算date的农历节日,getChineseHoliday(Date date, Map chineseHolidayMap) 可以传入自定义农历节日数据。

    (3)二十四节气计算, getSolarTerm* 比如getSolarTerm(Date date) 计算date的二十四节气。

    注意: 农历和二十四节气使用农历日期类 LunarDate,仅支持公历1900-2100年的计算。

    详细使用可以查看相关测试代码。

    7.Cron表达式工具类 CronExpressionUtil

    cron表达式从左到右(用空格隔开):秒(0-59) 分(0-59) 小时(0-23) 日期(1-31) 月份(1-12的整数或者 JAN-DEC) 星期(1-7的整数或者 SUN-SAT (1=SUN)) 年份(可选,1970-2099)

    所有字段均可使用特殊字符:, - * / 分别是枚举,范围,任意,间隔

    日期另外可使用:? L W 分别是任意,最后,有效工作日(周一到周五)

    星期另外可使用:? L # 分别是任意,最后,每个月第几个星期几

    常用cron表达式:

    (1)0 0 2 1 * ? * 表示在每月的1日的凌晨2点触发

    (2)0 15 10 ? * MON-FRI 表示周一到周五每天上午10:15执行作业

    (3)0 15 10 ? * 6L 2002-2006 表示2002-2006年的每个月的最后一个星期五上午10:15执行作

    (4)0 0/30 9-17 * * ? 朝九晚五工作时间内每半小时

    (5)0 15 10 L * ? 每月最后一日的上午10:15触发

    (6)0 15 10 ? * 6#3 每月的第三个星期五上午10:15触发

    包含

    (1)验证和格式化Cron表达式方法,isValidExpression和formatExpression。

    (2)生成下一个或多个执行时间方法,getNextTime和getNextTimeList。

    (3)生成下一个或多个执行时间的日期格式化(yyyy-MM-dd HH:mm:ss)方法,getNextTimeStr和getNextTimeStrList。

    (4)对比Cron表达式下一个执行时间是否与指定date相等方法,isSatisfiedBy。

    注意: 底层使用 quartz的CronExpression处理。

    详细使用可以查看相关测试代码。

    8.计算耗时工具 CostUtil

    计算耗时工具,支持秒,毫秒,纳秒

    包括:

    (1)计算耗时,返回耗时结果。

    (2)计算耗时,自定义任务名称,输出耗时结果。

    (3)计算耗时,返回精确计时,带3小数的结果,使用ROUND_DOWN 舍弃超过3位的小数部分等。

    详细使用可以查看相关测试代码。

    9.时间自然语言分析工具类(NLP) TimeNLPUtil

    包括功能:

    (1)以当前时间为基础分析时间自然语言。

    (2)以指定时间为基础分析时间自然语言。

    修改自 https://github.com/shinyke/Time-NLP

    做了一些修改如下:

    (1)封装属性,重命名使符合驼峰命名标准。

    (2)将加载正则资源文件改为单例加载。

    (3)将类按照功能重新划分为单独的多个类。

    (4)使用Java8日期API重写。

    (5)增加注释说明,优化代码。

    (6)修复原项目中的issue:标准时间yyyy-MM-dd、yyyy-MM-dd HH:mm:ss和yyyy-MM-dd HH:mm解析问题。

    (7)修复原项目中的issue:1小时后,1个半小时后,1小时50分钟等解析问题;并且支持到秒,比如50秒后,10分钟30秒后等。

    (8)修复原项目中的issue:修复当前时间是上午10点,那么下午三点 会识别为明天下午三点问题。

    (9)修复原项目中的issue:修复小数解析异常问题。

    注意:NLP会有一定的识别失败率,在不断迭代开发提高成功率。

    详细使用可以查看相关测试代码。

    作者|侠客张三|OSCHINA

    展开全文
  • 当我们遇上一些时间上的问题的时候就会出现一种疑惑,比如给会员续费的时候如何在原会员过期时间的基础上增加一时间段呢?前些天在公司处理业务的时候遇上这个问题,于是自己写了一个时间段增加与减少的工具类。 ...

    当我们遇上一些时间上的问题的时候就会出现一种疑惑,比如给会员续费的时候如何在原会员过期时间的基础上增加一个时间段呢?前些天在公司处理业务的时候遇上这个问题,于是自己写了一个时间段增加与减少的工具类。


    附上代码:


    /**
     * 通过计算获取增加时间或者减少时间
     * 参数1、当前时间,2、增加还是减少标识符,3、时间段(天,周,月,季,半年,年),4、数量
     */
    public static Date test(Date currentData, Boolean isAdd, String type, Integer number) {
        //获取时间格式
        Calendar cal = Calendar.getInstance();
        if (currentData == null) {
            cal.setTime(new Date());
        } else {
            cal.setTime(currentData);
        }
        switch (type) {
            case "year":
                if (isAdd) {
                    cal.add(Calendar.YEAR, number);
                } else
                    cal.set(Calendar.YEAR, cal.get(Calendar.YEAR) - number);
                break;
            case "halfYear":
                if (isAdd) {
                    cal.add(Calendar.MONTH, +6);
                } else
                    cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) - 6);
                break;
            case "season":
                if (isAdd) {
                    cal.add(Calendar.MONTH, +3);
                } else
                    cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) - 3);
                break;
            case "month":
                if (isAdd) {
                    cal.add(Calendar.MONTH, +1);
                } else
                    cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) - 1);
                break;
            case "week":
                if (isAdd) {
                    cal.add(Calendar.DATE, +7);
                } else
                    cal.set(Calendar.DATE, cal.get(Calendar.DATE) - 7);
                break;
            case "day":
                if (isAdd) {
                    cal.add(Calendar.DATE, +number);
                } else
                    cal.set(Calendar.DATE, cal.get(Calendar.DATE) - number);
                break;
            default:
                if (isAdd) {
                    cal.add(Calendar.DATE, +number);
                } else
                    cal.set(Calendar.DATE, cal.get(Calendar.DATE) - number);
                break;
        }
        return cal.getTime();
    }


    测试代码:

    public static void main(String[] arg) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = test(new Date(), true, "year", 1);
        String date1 = simpleDateFormat.format(date);
        String date2 = simpleDateFormat.format(new Date());
        System.out.println(date2 + "==============" + date1);
    }
    测试结果:

    2017-11-13 11:20:55==============2018-11-13 11:20:55

    Process finished with exit code 0


    =====================分割线===================================================

    电影《肖申克的救赎》里有个词“体制化(institutionalizing)“。虽然我们不是在监狱那种体制化,但我们在生活中是否存在某种“体制化”呢?



    展开全文
  • 第十一周Java实验作业

    2019-10-02 04:37:40
    实验时间2018-11-8 1、实验目的与要求 (1)掌握Vetor、Stack、Hashtable三个类的用途及常用API; Vector类类似长度可变的数组,其中只能存放对象,其中的元素通过下标进行访问。 Vetor类关键属性:  capacity...

    实验十一   集合

    实验时间 2018-11-8

    1、实验目的与要求

    (1) 掌握Vetor、Stack、Hashtable三个类的用途及常用API;

    Vector类类似长度可变的数组,其中只能存放对象,其中的元素通过下标进行访问。

    Vetor类关键属性:

      capacity表示集合最多能容纳的元素个数。

      capacityIncrement表示每次增加多少容量。

      siize集合当前元素个数。

    Vector v = new Vector (100);

    StackVector的子类。

    Stack类描述堆栈数据结构,即LIFO 

    Stack类的关键方法:

      public void push(Object item)//把栈压入栈顶

      public Object pop()//移除栈顶对象并作为此函数的值返回对象

      public Object peek()//查看栈顶对象而不移除它

      public boolean empty()//推测堆栈是否为空

    Hashtable通过键来查找元素。

    Hastable用散列码(hastable)来确定键。所有对象都有有一个散列码,可以通过Object类的hastable()方法获得。

    (2) 了解java集合框架体系组成;

     

    (2) 掌握ArrayList、LinkList两个类的用途及常用API。

    ArrayList可以将其看作是能够自动增长容量的数组。

    利用ArrayList类的toArray返回一个数组。

    Arrays.asList()返回一个列表。

    LinkedList是采用双向循环列表实现的。

    (4) 了解HashSet类、TreeSet类的用途及常用API。

      HashSet()  构造一个空散列表

      HashSet(Collection<?extends E>elements)  构造一个散列集,并将集合中的所有元素添加到这个散列集中

      HashSet(int initialCapacity) 构造一个空的具有指定容量的(桶数)的散列集。

      HashSet(int initialCapacity, float loadFactor)构造一个具有指定容量和装填因子(一个0.0~1.0之间的数值,确定散列表填充的百分比,当大于这个百分比时,散列表进行再散列)的空散列集。

    (5)了解HashMap、TreeMap两个类的用途及常用API;

    Map接口的实现类主要有HashMap,TreeMap,HashTable,Properties。

    HashMap对key进行散列。

    TreeMap按照key进行排序。

    HashMap的速度通常都比TreeMap快,只有在需要排序功能的时候,才使用TreeMap。

    (6) 结对编程(Pair programming)练习,体验程序开发中的两人合作。

    2、实验内容和步骤

    实验1: 导入第9章示例程序,测试程序并进行代码注释。

    测试程序1:

    l 使用JDK命令运行编辑、运行以下三个示例程序,结合运行结果理解程序;

    l 掌握Vetor、Stack、Hashtable三个类的用途及常用API。

    出现运行时异常,输出Dog #7 时,类型不匹配。附上两种修改方法。 

    示例程序1:

    package 小陈;
    import java.util.Vector;
    
    class Cat {
        private int catNumber;
    
        Cat(int i) {
            catNumber = i;
        }
    
        void print() {
            System.out.println("Cat #" + catNumber);
        }
    }
    
    class Dog {
        private int dogNumber;
    
        Dog(int i) {
            dogNumber = i;
        }
    
        void print() {
            System.out.println("Dog #" + dogNumber);
        }
    }
    
    public class CatsAndDogs {
        public static void main(String[] args) {
            Vector cats = new Vector();
            for (int i = 0; i < 7; i++)
                cats.addElement(new Cat(i));
            cats.addElement(new Dog(7));
            for (int i = 0; i < cats.size()-1; i++) {
                System.out.println(cats.get(i).getClass());//获得类名
                //if(cats.get(i).getClass()  )
                ((Cat) cats.elementAt(i)).print();
        }
            System.out.println(cats.get(7).getClass());//获得类名
            ((Dog) cats.elementAt(7)).print();
        }
    }
    /*public class CatsAndDogs {
        public static void main(String[] args) {
            Vector cats = new Vector();
            for (int i = 0; i < 7; i++)
                cats.addElement(new Cat(i));
            cats.addElement(new Dog(7));
            for (int i = 0; i < 7; i++) {
                System.out.println(cats.get(i).getClass());//获得类名
                //if(cats.get(i).getClass()  )
                ((Cat) cats.elementAt(i)).print();
            for ( i = 0; i < cats.size(); i++) {
                System.out.println(cats.get(i).getClass());//获得类名
                //if(cats.get(i).getClass()  )
                ((Dog) cats.elementAt(i)).print();
            }
        }
            System.out.println(cats.get(7).getClass());//获得类名
            ((Dog) cats.elementAt(7)).print();
        }
    
    }*/
    
    /*public class CatsAndDogs {
        public static void main(String[] args) {
            Vector cats = new Vector();
            for (int i = 0; i < 7; i++)
                cats.addElement(new Cat(i));
            cats.addElement(new Dog(7));
            for (int i = 0; i < cats.size(); i++) {
                System.out.println(cats.get(i).getClass());//获得类名
                if(cats.elementAt(i) instanceof Cat)
                {
                    ((Cat) cats.elementAt(i)).print();
                }else {
                    ((Dog) cats.elementAt(i)).print();
                }
        }
        }
    }*/
    CatsAndDogs

    运行结果:

                    

     示例程序2:

    package 小陈3.src;
    
    import java.util.*;
    
    public class Stacks {
        static String[] months = { "1", "2", "3", "4" };
    
        public static void main(String[] args) {
            Stack stk = new Stack();
            for (int i = 0; i < months.length; i++)
                stk.push(months[i]);
            System.out.println(stk);
            System.out.println("element 2=" + stk.elementAt(2));
            while (!stk.empty())
                System.out.println(stk.pop());
        }
    }
    Stacks

    运行结果:

    示例程序3:

    package 小陈1;
    import java.util.*;
    
    class Counter {
        int i = 1;//不加任何访问权限修饰符,只允许在同一个包中进行访问。
    
        public String toString() {
            return Integer.toString(i);
        }
    }
    
    public class Statistics {
        public static void main(String[] args) {
            Hashtable ht = new Hashtable();//生成哈希表类对象,哈希表存储的数据是键值
            for (int i = 0; i < 10000; i++) {
                Integer r = new Integer((int) (Math.random() * 20));
    //使用Math.random方法生成整型随机数r,范围是0到20
                if (ht.containsKey(r))
    //通过对象调用containsKey(),判断r值是否是哈希表里的键值,如果是,返回true,否则返回false
                    ((Counter) ht.get(r)).i++;//获得哈希表里面的键值,引用Counter的属性,输出r出现的频次
                else
                    ht.put(r, new Counter());//调用put方法向哈希表里面添加键值
            }
            System.out.println(ht);
        }
    }
    Statistics

    运行结果:

    测试程序3:

    l 使用JDK命令编辑运行ArrayListDemo和LinkedListDemo两个程序,结合程序运行结果理解程序;

    package 小陈3;
    import java.util.*;
    
    public class ArrayListDemo {
        public static void main(String[] argv) {
            ArrayList<Comparable> al = new ArrayList<Comparable>();
            // Add lots of elements to the ArrayList...
            al.add(new Integer(11));//添加对象元素
            al.add(new Integer(12));
            al.add(new Integer(13));
            al.add(new String("hello"));
            // First print them out using a for loop.
            System.out.println("Retrieving by index:");
            //System.out.println(al.size());//输出al数组的长度
            for (int i = 0; i < al.size(); i++) {
                System.out.println("Element " + i + " = " + al.get(i));//get方法存放索引值
            }
        }
    }
    ArrayListDemo

    运行结果:

    package 小陈4;
    import java.util.*;
    public class LinkedListDemo {
        public static void main(String[] argv) {
            LinkedList l = new LinkedList();//构造一个空链表,实质为创建一个数组
            l.add(new Object());//调用add方法向链表添加元素
            l.add("Hello");
            l.add("zhangsan");
            ListIterator li = l.listIterator(0);//构造一个迭代器
            while (li.hasNext())
                //hasNext() 用于检查序列中是否还有元素,如果仍然有元素可以迭代,则返回true,返回迭代的下一个元素
                System.out.println(li.next());//next()返回当前next()的一个对象
            if (l.indexOf("Hello") < 0)   
                System.err.println("Lookup does not work");
            else
                System.err.println("Lookup works");
       }
    }
    LinkListDemo.

    运行结果:

    l 在Elipse环境下编辑运行调试教材360页程序9-1,结合程序运行结果理解程序;

    l 掌握ArrayList、LinkList两个类的用途及常用API。

    package linkedList;
    
    import java.util.*;
    
    /**
     * This program demonstrates operations on linked lists.
     * @version 1.11 2012-01-26
     * @author Cay Horstmann
     */
    public class LinkedListTest
    {
       public static void main(String[] args)
       {
          List<String> a = new LinkedList<>();//构造一个空链表,实质为创建一个String类型的数组a
          a.add("Amy");//调用add方法向数组添加元素
          a.add("Carl");
          a.add("Erica");
        
          List<String> b = new LinkedList<>();
          b.add("Bob");
          b.add("Doug");
          b.add("Frances");
          b.add("Gloria");
    
          // merge the words from b into a,将a数组的内容合并到b中
    
          ListIterator<String> aIter = a.listIterator();
          //使用LinkList类的listIterator方法返回一个实现了listIterator接口的迭代器对象
          Iterator<String> bIter = b.iterator();
    
          while (bIter.hasNext())
          {
             if (aIter.hasNext()) aIter.next();
             aIter.add(bIter.next());
          }
    
          System.out.println(a);
    
          // remove every second word from b,从b数组中删除第二个单词
    
          bIter = b.iterator();
          while (bIter.hasNext())
          {
             bIter.next(); // skip one element
             if (bIter.hasNext())
             {
                bIter.next(); // skip next element
                bIter.remove(); // remove that element
             }
          }
    
          System.out.println(b);
    
          // bulk operation: remove all words in b from a
    
          a.removeAll(b);
    
          System.out.println(a);
       }
    }
    LinkedListTest

    测试程序3:

    l 运行SetDemo程序,结合运行结果理解程序;

    package 小陈3.src;
    import java.util.*;
    public class SetDemo {
        public static void main(String[] argv) {
            HashSet h = new HashSet(); //也可以 Set h=new HashSet()
    //构造一个空散列表 h.add("One"); h.add("Two"); h.add("One"); // DUPLICATE h.add("Three"); Iterator it = h.iterator(); while (it.hasNext()) { System.out.println(it.next()); } } }

    运行结果: 

      

    l 在Elipse环境下调试教材365页程序9-2,结合运行结果理解程序;了解HashSet类的用途及常用API。

    package set;
    
    import java.util.*;
    
    /**
     * This program uses a set to print all unique words in System.in.
     * @version 1.12 2015-06-21
     * @author Cay Horstmann
     */
    public class SetTest
    {
       public static void main(String[] args)
       {
          Set<String> words = new HashSet<>(); // HashSet implements Set,利用HashSet实现Set接口
          long totalTime = 0;
    
          try (Scanner in = new Scanner(System.in))
          {
             while (in.hasNext())
             {
                String word = in.next();
                long callTime = System.currentTimeMillis();
                words.add(word);
                callTime = System.currentTimeMillis() - callTime;
                totalTime += callTime;
             }
          }
    
          Iterator<String> iter = words.iterator();
          for (int i = 1; i <= 20 && iter.hasNext(); i++)
             System.out.println(iter.next());
          System.out.println(". . .");
          System.out.println(words.size() + " distinct words. " + totalTime + " milliseconds.");
       }
    }
    SetTest

    运行结果:

    l 在Elipse环境下调试教材367页-368程序9-3、9-4,结合程序运行结果理解程序;了解TreeSet类的用途及常用API。

    package treeSet;
    
    import java.util.*;
    
    /**
     * This program sorts a set of item by comparing their descriptions.
     * @version 1.12 2015-06-21
     * @author Cay Horstmann
     */
    public class TreeSetTest
    {
       public static void main(String[] args)
       {
          SortedSet<Item> parts = new TreeSet<>();//构造一个空树集。
          parts.add(new Item("Toaster", 1234));
          parts.add(new Item("Widget", 4562));
          parts.add(new Item("Modem", 9912));
          System.out.println(parts);
    
          NavigableSet<Item> sortByDescription = new TreeSet<>(
                Comparator.comparing(Item::getDescription));
    
          sortByDescription.addAll(parts);
          System.out.println(sortByDescription);
       }
    }
    TreeSet
    package treeSet;
    
    import java.util.*;
    
    /**
     * An item with a description and a part number.
     */
    public class Item implements Comparable<Item>
    {
       private String description;
       private int partNumber;
    
       /**
        * Constructs an item.
        * 
        * @param aDescription
        *           the item's description
        * @param aPartNumber
        *           the item's part number
        */
       public Item(String aDescription, int aPartNumber)
       {
          description = aDescription;
          partNumber = aPartNumber;
       }
    
       /**
        * Gets the description of this item.
        * 
        * @return the description
        */
       public String getDescription()
       {
          return description;
       }
    
       public String toString()
       {
          return "[description=" + description + ", partNumber=" + partNumber + "]";
       }
    
       public boolean equals(Object otherObject)
       {
          if (this == otherObject) return true;
          if (otherObject == null) return false;
          if (getClass() != otherObject.getClass()) return false;
          Item other = (Item) otherObject;
          return Objects.equals(description, other.description) && partNumber == other.partNumber;
       }
    
       public int hashCode()
       {
          return Objects.hash(description, partNumber);
       }
    
       public int compareTo(Item other)
       {
          int diff = Integer.compare(partNumber, other.partNumber);
          return diff != 0 ? diff : description.compareTo(other.description);
       }
    }
    Item

    运行结果:

    测试程序4:

    l 使用JDK命令运行HashMapDemo程序,结合程序运行结果理解程序;

    package treeSet;
    import java.util.*;
    public class HashMapDemo {
       public static void main(String[] argv) {
          HashMap h = new HashMap();//构造一个空散列映射
          // The hash maps from company name to address.
          h.put("Adobe", "Mountain View, CA");//将这些元素插入到映射中
          h.put("IBM", "White Plains, NY");
          h.put("Sun", "Mountain View, CA");
          String queryString = "Adobe";
          String resultString = (String)h.get(queryString);
          System.out.println("They are located in: " +  resultString);
      }
    }
    HashMapDemo

    运行结果:

    l 在Elipse环境下调试教材373页程序9-6,结合程序运行结果理解程序;

    了解HashMap、TreeMap两个类的用途及常用API。

    package map;
    
    import java.util.*;
    
    /**
     * This program demonstrates the use of a map with key type String and value type Employee.
     * @version 1.12 2015-06-21
     * @author Cay Horstmann
     */
    public class MapTest
    {
       public static void main(String[] args)
       {
          Map<String, Employee> staff = new HashMap<>();//为存储的员工信息建立一个散列映射
          staff.put("144-25-5464", new Employee("Amy Lee"));//a将员工信息添加到映射中
          staff.put("567-24-2546", new Employee("Harry Hacker"));
          staff.put("157-62-7935", new Employee("Gary Cooper"));
          staff.put("456-62-5527", new Employee("Francesca Cruz"));
    
          // print all entries
    
          System.out.println(staff);
    
          // remove an entry
    
          staff.remove("567-24-2546");
    
          // replace an entry
    
          staff.put("456-62-5527", new Employee("Francesca Miller"));
    
          // look up a value
    
          System.out.println(staff.get("157-62-7935"));
    
          // iterate through all entries
    
          staff.forEach((k, v) -> 
             System.out.println("key=" + k + ", value=" + v));
       }
    }
    MapTest
    package map;
    
    /**
     * A minimalist employee class for testing purposes.
     */
    public class Employee
    {
       private String name;
       private double salary;
    
       /**
        * Constructs an employee with $0 salary.
        * @param n the employee name
        */
       public Employee(String name)
       {
          this.name = name;
          salary = 0;
       }
    
       public String toString()
       {
          return "[name=" + name + ", salary=" + salary + "]";
       }
    }
    Employee

    运行结果:

    实验2:结对编程练习:

    l 关于结对编程:以下图片是一个结对编程场景:两位学习伙伴坐在一起,面对着同一台显示器,使用着同一键盘,同一个鼠标,他们一起思考问题,一起分析问题,一起编写程序。

    l 关于结对编程的阐述可参见以下链接:

     

    http://www.cnblogs.com/xinz/archive/2011/08/07/2130332.html

    http://en.wikipedia.org/wiki/Pair_programming

    l 对于结对编程中代码设计规范的要求参考:

    http://www.cnblogs.com/xinz/archive/2011/11/20/2255971.html

     

    以下实验,就让我们来体验一下结对编程的魅力。

    l 确定本次实验结对编程合作伙伴;

    l 各自运行合作伙伴实验九编程练习1,结合使用体验对所运行程序提出完善建议;

    l 各自运行合作伙伴实验十编程练习2,结合使用体验对所运行程序提出完善建议;

    l 采用结对编程方式,与学习伙伴合作完成实验九编程练习1;

    l 采用结对编程方式,与学习伙伴合作完成实验十编程练习2。

    合作伙伴:王燕

    合作伙伴的代码:

    身份证号文件处理:

    package 看到谁;
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.Scanner;
    
    public class Check{
        private static ArrayList<Student> studentlist;
        public static void main(String[] args) {
            studentlist = new ArrayList<>();
            Scanner scanner = new Scanner(System.in);
            File file = new File("C:\\下载\\身份证号.txt");//文件读取
            try {
                FileInputStream fis = new FileInputStream(file);
                BufferedReader in = new BufferedReader(new InputStreamReader(fis));
                String temp = null;
                while ((temp = in.readLine()) != null) {
                    
                    Scanner linescanner = new Scanner(temp);
                    
                    linescanner.useDelimiter(" ");    
                    String name = linescanner.next();
                    String number = linescanner.next();
                    String sex = linescanner.next();
                    String age = linescanner.next();
                    String province =linescanner.nextLine();
                    Student student = new Student();
                    student.setName(name);
                    student.setnumber(number);
                    student.setsex(sex);
                    int a = Integer.parseInt(age);
                    student.setage(a);
                    student.setprovince(province);
                    studentlist.add(student);
    
                }
            } catch (FileNotFoundException e) {//捕获异常
                System.out.println("学生信息文件找不到");
                e.printStackTrace();
            } catch (IOException e) {
                System.out.println("学生信息文件读取错误");
                e.printStackTrace();
            }
            //加入异常处理机制,维护代码的健壮性
            boolean isTrue = true;
            //选择所要进行的操作
            while (isTrue) {
                System.out.println("选择你的操作,输入正确格式的选项");
                System.out.println("1.按姓名字典序输出人员信息");
                System.out.println("2.输出年龄最大和年龄最小的人");
                System.out.println("3.查找老乡");
                System.out.println("4.查找年龄相近的人");
                System.out.println("5.退出");
                String m = scanner.next();
                switch (m) {
                case "1":
                    Collections.sort(studentlist);              
                    System.out.println(studentlist.toString());
                    break;
                case "2":
                     int max=0,min=100;
                     int j,k1 = 0,k2=0;
                     for(int i=1;i<studentlist.size();i++)
                     {
                         j=studentlist.get(i).getage();
                     if(j>max)
                     {
                         max=j; 
                         k1=i;
                     }
                     if(j<min)
                     {
                       min=j; 
                       k2=i;
                     }
                     
                     }  
                     System.out.println("年龄最大:"+studentlist.get(k1));
                     System.out.println("年龄最小:"+studentlist.get(k2));
                    break;
                case "3":
                     System.out.println("输入省份");
                     String find = scanner.next();        
                     String place=find.substring(0,3);
                     for (int i = 0; i <studentlist.size(); i++) 
                     {
                         if(studentlist.get(i).getprovince().substring(1,4).equals(place)) 
                             System.out.println("老乡"+studentlist.get(i));
                     }             
                     break;
                     
                case "4":
                    System.out.println("年龄:");
                    int yourage = scanner.nextInt();
                    int near=agenear(yourage);
                    int value=yourage-studentlist.get(near).getage();
                    System.out.println(""+studentlist.get(near));
                    break;
                case "5":
                    isTrue = false;
                    System.out.println("退出程序!");
                    break;
                    default:
                    System.out.println("输入有误");
    
                }
            }
        }
            public static int agenear(int age) {      
            int j=0,min=53,value=0,k=0;
             for (int i = 0; i < studentlist.size(); i++)
             {
                 value=studentlist.get(i).getage()-age;
                 if(value<0) value=-value; 
                 if (value<min) 
                 {
                    min=value;
                    k=i;
                 } 
              }    
             return k;         
          }
    
    }
    Check
    package 看到谁;
    public class Student implements Comparable<Student> {
    
        private String name;
        private String number ;
        private String sex ;
        private int age;
        private String province;
       
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public String getnumber() {
            return number;
        }
        public void setnumber(String number) {
            this.number = number;
        }
        public String getsex() {
            return sex ;
        }
        public void setsex(String sex ) {
            this.sex =sex ;
        }
        public int getage() {
    
            return age;
            }
            public void setage(int age) {
                // int a = Integer.parseInt(age);
            this.age= age;
            }
    
        public String getprovince() {
            return province;
        }
        public void setprovince(String province) {
            this.province=province ;
        }
    
        public int compareTo(Student o) {
           return this.name.compareTo(o.getName());
        }//对姓名进行字典排序
    
        public String toString() {
            return  name+"\t"+sex+"\t"+age+"\t"+number+"\t"+province+"\n";
        }    
    }
    Student

    简易计算器:

    package 看到谁;
    import java.io.FileNotFoundException;
    import java.io.PrintWriter;
    import java.util.Scanner;
    public class Caculator {
        public static void main(String[] args) {
            Scanner in = new Scanner(System.in);
            Caculator1 computing=new Caculator1();
            PrintWriter output = null;
            //使用了异常处理机制,增强代码的安全性
            try {
                output = new PrintWriter("Caculator.txt");
            } catch (Exception e) {
            }
            int sum = 0;
                //随机数生成,提供后续题目所用的数据
            for (int i = 1; i < 11; i++) {
                int a = (int) Math.round(Math.random() * 100);
                int b = (int) Math.round(Math.random() * 100);
                int s = (int) Math.round(Math.random() * 3);
                //选择所要进行的操作
            switch(s)//s为随机数,可随机执行下面四种操作
            {
               case 1:
                   System.out.println(i+": "+a+"/"+b+"=");
                   while(b==0){  
                       b = (int) Math.round(Math.random() * 100); 
                       }
                   double c = in.nextDouble();
                   output.println(a+"/"+b+"="+c);
                   //修改建议:生成除法题目时,对a,b两个数进行条件判断,确保整除,还有除数不为0
                   if (c == (double)computing.division(a, b)) {
                       sum += 10;
                       System.out.println("T");
                   }
                   else {
                       System.out.println("F");
                   }
                
                   break;
                //
               case 2:
                   System.out.println(i+": "+a+"*"+b+"=");
                   int c1 = in.nextInt();
                   output.println(a+"*"+b+"="+c1);
                   if (c1 == computing.multiplication(a, b)) {
                       sum += 10;
                       System.out.println("T");
                   }
                   else {
                       System.out.println("F");
                   }
                   break;
               case 3:
                   System.out.println(i+": "+a+"+"+b+"=");
                   int c2 = in.nextInt();
                   output.println(a+"+"+b+"="+c2);
                   if (c2 == computing.addition(a, b)) {
                       sum += 10;
                       System.out.println("T");
                   }
                   else {
                       System.out.println("F");
                   }
                   
                   break ;
               case 4:
                   System.out.println(i+": "+a+"-"+b+"=");
                   int c3 = in.nextInt();
                   output.println(a+"-"+b+"="+c3);
                   if (c3 == computing.subtraction(a, b)) {
                       sum += 10;
                       System.out.println("T");
                   }
                   else {
                       System.out.println("F");
                   }
                   break ;
    
                   } 
        
              }
            System.out.println("scores:"+sum);
            output.println("scores:"+sum);
            output.close();
             
        }
    }
    class Caculator1
    {
           private int a;
           private int b;
            public int  addition(int a,int b)
            {
                return a+b;
            }
            public int  subtraction(int a,int b)
            {
                if((a-b)<0)
                    return 0;
                else
                return a-b;
            }
            public int   multiplication(int a,int b)
            {
                return a*b;
            }
            public int   division(int a,int b)
            {
                if(b!=0)
                return a/b;    
                else
            return 0;
            }
    
            
    }
    四则运算

    合作代码:

     身份证号文件处理:

    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.Scanner;
    public class Identity{
        private static ArrayList<Student> studentlist;
        public static void main(String[] args) {
            studentlist = new ArrayList<>();
            Scanner scanner = new Scanner(System.in);
            File file = new File("C:/身份证号.txt");
            try {
                FileInputStream fis = new FileInputStream(file);
                BufferedReader in = new BufferedReader(new InputStreamReader(fis));
                String temp = null;
                while ((temp = in.readLine()) != null) {
                    
                    Scanner linescanner = new Scanner(temp);
                    
                    linescanner.useDelimiter(" ");    
                    String name = linescanner.next();
                    String number = linescanner.next();
                    String sex = linescanner.next();
                    String age = linescanner.next();
                    String province =linescanner.nextLine();
                    Student student = new Student();
                    student.setName(name);
                    student.setnumber(number);
                    student.setsex(sex);
                    int a = Integer.parseInt(age);
                    student.setage(a);
                    student.setprovince(province);
                    studentlist.add(student);
                }
            } catch (FileNotFoundException e) {
                System.out.println("学生信息文件找不到");
                e.printStackTrace();
            } catch (IOException e) {
                System.out.println("学生信息文件读取错误");
                e.printStackTrace();
            }
            boolean isTrue = true;
            while (isTrue) {
                System.out.println("选择你的操作,输入正确格式的选项");
                System.out.println("1.字典排序");
                System.out.println("2.输出年龄最大和年龄最小的人");
                System.out.println("3.寻找老乡");
                System.out.println("4.寻找年龄相近的人");
                System.out.println("0.退出");
                int status = scanner.nextInt();
                switch (status) {
                case 1:
                    Collections.sort(studentlist);              
                    System.out.println(studentlist.toString());
                    break;
                case 2:
                     int max=0,min=100;
                     int j,k1 = 0,k2=0;
                     for(int i=1;i<studentlist.size();i++)
                     {
                         j=studentlist.get(i).getage();
                     if(j>max)
                     {
                         max=j; 
                         k1=i;
                     }
                     if(j<min)
                     {
                       min=j; 
                       k2=i;
                     }
                     
                     }  
                     System.out.println("年龄最大:"+studentlist.get(k1));
                     System.out.println("年龄最小:"+studentlist.get(k2));
                    break;
                case 3:
                     System.out.println("老家?");
                     String find = scanner.next();        
                     String place=find.substring(0,3);
                     for (int i = 0; i <studentlist.size(); i++) 
                     {
                         if(studentlist.get(i).getprovince().substring(1,4).equals(place)) 
                             System.out.println("老乡"+studentlist.get(i));
                     }             
                     break;
                     
                case 4:
                    System.out.println("年龄:");
                    int yourage = scanner.nextInt();
                    int near=agenear(yourage);
                    int value=yourage-studentlist.get(near).getage();
                    System.out.println(""+studentlist.get(near));
                    break;
               
                    case 0:
                        status = 0;
                        System.out.println("程序已退出!");
                        break;
                   default:
                       System.out.println("输入错误");
                   }
                 }
                }
            public static int agenear(int age) {      
            int min=53,value=0,k=0;
             for (int i = 0; i < studentlist.size(); i++)
             {
                 value=studentlist.get(i).getage()-age;
                 if(value<0) value=-value; 
                 if (value<min) 
                 {
                    min=value;
                    k=i;
                 } 
              }    
             return k;         
          }
          
    }
    Identity
    package 看到谁;
    
    public  class Student implements Comparable<Student> {
        private    String name;
        private    String number ;
        private    String sex ;
        private    int age;
        private    String province;
     
         
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public String getnumber() {
            return number;
        }
        public void setnumber(String number) {
            this.number = number;
        }
        public String getsex() {
            return sex ;
        }
        public void setsex(String sex ) {
            this.sex =sex ;
        }
        public int getage() {
            return age;
        }
        public void setage(int age ) {
            this.age=age ;
        }
        public String getprovince() {
            return province;
        }
        public void setprovince(String province) {
            this.province=province ;
        }
    @Override
    public int compareTo(Student other) {
        // TODO Auto-generated method stub
         return this.name.compareTo(other.getName());
    }
    
    public String toString() {
        return  name+"\t"+sex+"\t"+age+"\t"+number+"\t"+province+"\n";
    }    
    }
    Student

    运行结果:

     

    简易计算器:

    import java.io.FileNotFoundException;
    import java.io.PrintWriter;
    import java.util.Scanner;
    public class Caculator {
        public static void main(String[] args) {
            Scanner in = new Scanner(System.in);
            Caculator1 computing=new Caculator1();
            PrintWriter output = null;
            try {
                output = new PrintWriter("Caculator.txt");
            } catch (Exception e) {
            }
            int sum = 0;
    
            for (int i = 1; i < 11; i++) {
                int a = (int) Math.round(Math.random() * 100);
                int b = (int) Math.round(Math.random() * 100);
                int s = (int) Math.round(Math.random() * 3);
            switch(s)
            {
               case 1:
                   System.out.println(i+": "+a+"/"+b+"=");
                   while(b==0){  
                       b = (int) Math.round(Math.random() * 100); 
                       }
                   double c = in.nextDouble();
                   output.println(a+"/"+b+"="+c);
                   if (c == (double)computing.division(a, b)) {
                       sum += 10;
                       System.out.println("T");
                   }
                   else {
                       System.out.println("F");
                   }
                
                   break;
                
               case 2:
                   System.out.println(i+": "+a+"*"+b+"=");
                   int c1 = in.nextInt();
                   output.println(a+"*"+b+"="+c1);
                   if (c1 == computing.multiplication(a, b)) {
                       sum += 10;
                       System.out.println("T");
                   }
                   else {
                       System.out.println("F");
                   }
                   break;
               case 3:
                   System.out.println(i+": "+a+"+"+b+"=");
                   int c2 = in.nextInt();
                   output.println(a+"+"+b+"="+c2);
                   if (c2 == computing.addition(a, b)) {
                       sum += 10;
                       System.out.println("T");
                   }
                   else {
                       System.out.println("F");
                   }
                   
                   break ;
               case 4:
                   System.out.println(i+": "+a+"-"+b+"=");
                   int c3 = in.nextInt();
                   output.println(a+"-"+b+"="+c3);
                   if (c3 == computing.subtraction(a, b)) {
                       sum += 10;
                       System.out.println("T");
                   }
                   else {
                       System.out.println("F");
                   }
                   break ;
    
                   } 
        
              }
            System.out.println("scores:"+sum);
            output.println("scores:"+sum);
            output.close();
             
        }
    }
    class Caculator1
    {
           private int a;
           private int b;
            public int  addition(int a,int b)
            {
                return a+b;
            }
            public int  subtraction(int a,int b)
            {
                if((a-b)<0)
                    return 0;
                else
                return a-b;
            }
            public int   multiplication(int a,int b)
            {
                return a*b;
            }
            public int   division(int a,int b)
            {
                     if(b!=0 && a%b==0)
                         return a/b;
                     else
                         return 0;
                 }
            }       
    四则运算

    运行结果:

     总结:本周主要学习了集合的相关知识,课本上对代码的解释也很少,感觉这一章的代码有点读不懂,还需要继续进行学习,除此之外,本周的实验内容还有结对编程,在阅读了合作伙伴的代码之后,可以从合作伙伴身上学到很多。对

    HashMap,HashSet,TreeMap,TreeSet还是不够清楚。

    转载于:https://www.cnblogs.com/980303CYR/p/9941796.html

    展开全文
  • 到第二,我已经明显感受到难度的增加了。做题的时候非常考验逻辑思维能力,对于没有算法基础的我来说,是个比较困难的事情。而且学校里的课程非常多,给我专心学习JAVA造成了不小的挑战。如何进行高效、合理的...
  • 一周总结

    2016-04-04 21:29:00
    的学习时间比上两周增加了两个小时,通过这自己在网上查找视频学习java也对java有了更深入的了解,我觉得java和C#各有千秋Java中对内存的分配是动态的,它采用面向对象的机制,采用运算符new为每个对象分配内存...
  • 谷歌的平台作为种服务 , 谷歌应用程序引擎已经在本周收到了大修,增加互补的Java 7语言功能 GAE的1.7.3版本由于Java 7功能加入了SDK而得到了增强,并且即将推出全面的Java 7支持。 这也许表明,尽管其他一些PaaS...
  • Java8 处理日期和时间

    2019-05-15 09:06:52
    Java 8 中检查像生日这种周期性事件6、在 Java 8 中获取当前时间7、在现有的时间增加小时8、计算一周后的日期9、计算一年前或一年后的日期10、使用 Java 8 的 Clock 时钟类11、如何用 Java 判断日期是早于还是晚于...
  • 推迟一周示例: Calendar curr = Calendar.getInstance(); //获取当前时间 curr.set(Calendar.DAY_OF_... //给当前时间增加一周 Date date=curr.getTime();//获取新的时间推迟一个月示例: Calendar curr = Calen
  • 一周的编程题是需要你在课程所给的时钟程序的基础上修改而成。但是我们并不直接给你时钟程序的代码,请根据视频自己输入时钟程序的Display和Clock类的代码,然后来做这个题目。 我们需要给时钟程序加上一个表示秒...
  • java8 日期时间处理

    千次阅读 2017-11-06 23:35:27
    最近了解了一下java8的新日期时间类库,简直方便到感人。重构了一下代码,行数少了多一半,有些方法直接删掉了,因为已经自带了。适用多种业务场景:展示、统计、设置有效期、增加/减少日期、日期比较等。 package ...
  • 晚上听了尚学堂马士兵老师的找工作系列...最近一周多又看了一些,在tomcat,esclipse等的配置以及bbs,商城项目的部署,可以顺利运行,过了一把建立服务器部署项目给人浏览的瘾。其中配置过程中可能遇到的问题,都差
  • 1、JDK 5.0 中增加的泛型类型,是Java 语言中类型安全的次重要改进。 2、 泛型:也称参数化类型(parameterized type),就是在定义类、接口和方法时,通过类型参数指示将要处理的对象类型。(如ArrayList类) 3、...
  • 1、获取今天的日期 2、在Java 8 中获取年、月、日信息 3、在Java 8 中处理特定日期 ...8、计算一周后的日期 9、计算一年前或一年后的日期 10、使用 Java 8 的 Clock 时钟类 11、如何用 Java 判断日期是...
  • Java 8新的时间日期库的20个使用示例、 如何 在Java 8中获取...比如说生日六、如何在Java 8中获取当前时间七、如何增加时间里面的小时数八、如何获取1后的日期九、一年前后的日期十、在Java 8中使用时钟十一、...
  • JAVA核心知识点--JDK1.8中的日期处理

    万次阅读 多人点赞 2017-12-12 19:22:54
    目录 在Java 8中如何处理日期和时间 示例 1、在Java 8中获取今天的日期 示例 2、在Java 8中获取年、月、日信息 示例 3、在Java 8中处理特定日期 示例 4、在Java 8中判断两个...示例 8、如何计算一周后的日期 ...
  • 时隔一周多,今天终于抽出时间来更新一波代码生成器,最近公司让我研究rpa,弄得焦头烂额的,话不多说,进入正题。 之前有朋友让我讲一下代码生成器的原理,这篇博客就大体描述一下,以后慢慢细致讲解。 双击...
  • 上班一周了,谈谈感想

    千次阅读 2006-07-28 10:41:00
    从周一到新大陆上班开始,一周时间也差不多结束了.感觉还是增加了点知识吧. 这周的任务是JAVA的学习,认识到JAVA模式之单态模式.JAVA的设计模式,这还是我第一次见到,很开心,开始见到新技术了.用这种模式,原因是在于我...
  • 假期第一周每天上午去补习班兼职当老师,然后健身房健身。下午休息,学习。每天学习java程序设计大概1-2个小时,以...下周的安排大体不变,适当增加java的学习时间,开始进行简单的编程。加油!!! 转载于:https:...
  • 在线的java编译器和在线运行帮助我们轻松编译代码...也就很有帮助,如果不需要编写java代码而定期一周甚至一天几次。增加电脑的速度,减少从您的计算机未使用的软件数量。但如果不想错过它,可以尝试免费的在线编译...
  • 原标题:五个免费在线Java...也就很有帮助,如果不需要编写Java代码而定期一周甚至一天几次。增加电脑的速度,减少从您的计算机未使用的软件数量。但如果不想错过它,可以尝试免费的在线编译器分享收藏。现在,在这...
  • Java8日期处理

    2019-08-13 09:26:22
    Java8日期处理使用示例示例 1、在 Java 8 中获取今天的日期示例 2、在 Java 8 中获取年...6、在 Java 8 中获取当前时间示例 7、如何在现有的时间增加小时示例 8、如何计算一周后的日期示例 9、计算一年前或一年后...
  • JAVA之旅

    2019-04-13 23:22:56
    老师换了种教学方法,有点不太适应,虽然说这样的教学方式,比之前的方法要好一点,更多的时间是让我们自己动脑思考,增加了更多我们对JAVA 的了解,但是也正是因为这教学方法的实施,让我知道我之前学的...
  • 当没有损失的时间增加时间要考虑时,该测试通常会全年通过.但是现在这很令人讨厌....但是现在可以理解,当Java日期代码在初始化新的JWT Claim之后调用setExp()时,它们距未来一周还有一个小时的路程....
  • 坑一之时间格式 之前掉进过一个坑 SimpleDateFormat(&quot;...假如今天是20181231(是周一),那么因为本周也有2019年的日子5天 (周二-周六)因此会认为当前是19年第一周 假如取值明天的话得到的...

空空如也

空空如也

1 2 3 4 5
收藏数 86
精华内容 34
关键字:

java时间增加一周

java 订阅