API官方文档

API官方文档

Date

  1. package org.forten.api.date;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateTest003 {
 public static void main(String[] args) throws ParseException {
     String dateStr = "2019-01-01";
     String dateTimeStr = "2019-10-01 09:10:22";
     //把日期格式的字符串转型为Java.util.Date类型的对象
     //使用SimpleDateFormat对象的parse(String)方法，此方法需要处理ParseException
     //yy:两位的年份，小于50表示20XX年，大于50表示19XX年
     //yyyy:四位的年份
     //MM:月份(1~12)
     //HH:24小时制(0~23)
     //hh:12小时制(1~12)
     //mm:分钟(0~59)
     //ss:秒
     //SSS：毫秒
     SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
     Date date1 = sdf1.parse(dateStr);
     System.out.println(date1);

     SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
     Date dateTime1 = sdf2.parse(dateTimeStr);
     System.out.println(dateTime1);
     
     
     //包java.util.Date类型的日期对象转型为某种日期格式的字符串
     //使用SimpleDateFormat对象的format(Date)方法
     SimpleDateFormat sdf3 = new SimpleDateFormat("MM/dd/yyyy");
     String dateStr2 = sdf3.format(date1);
     System.out.println(dateStr2);

     SimpleDateFormat sdf4 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
     String dateTimeStr2 = sdf4.format(dateTime1);
     System.out.println(dateTimeStr2);
 }
}

  2. package org.forten.api.date;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoField;

public class LocalDateTest001 {
 public static void main(String[] args) {
 //得到当前日期
 LocalDate currentDate=LocalDate.now();
 System.ou.println(currentDate);
 //指定年月日，得到具体对应的日期对象
 LocalDate date1=LocalDate.of(2020,8,25);
 System.out.println(date1);
 
 //通过对日期字符串的解析，得到日期对象
 LocalDate date2=LocalDate.parse("2020-02-18");
 System.out.println(date2);
     LocalDate date3 = LocalDate.parse("20200218", DateTimeFormatter.ofPattern("yyyyMMdd"));
     System.out.println(date3);
 //使用minus()方法在原日期上减去相应单位的数量，并返回一个新的LocalDate对象
 //LocalDate date4=date1.minus(41,ChronoUnit.Years);
 LocalDate date4 = date1.minusYears(41);
     System.out.println(date1);
     System.out.println(date4);
 //LocalDate date5=date2.minus(30,Chronounit.DAYS);
 LocalDate date5 = date2.plusDays(30);
     System.out.println(date2);
     System.out.println(date5);

     int year = date5.get(ChronoField.YEAR);
     System.out.println(year);
     int monthValue = date5.getMonthValue();
     System.out.println(monthValue);
 //日期转字符串
 LocalDate date6 = LocalDate.of(1985, 9, 1);
     String studentDay = date6.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日"));
     System.out.println(studentDay);

     LocalDateTime dateTime1 = date6.atTime(7, 30, 0);
     studentDay = dateTime1.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss"));
     System.out.println(studentDay);
     
     LocalDateTime dateTime2 = LocalDateTime.parse(studentDay, DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss"));
     System.out.println(dateTime2);
 }
}
 

  3. package org.forten.api.packagetype;

public class BooleanTest001 {
 public static void main(String[] args) {
     Boolean b1 = Boolean.valueOf(true);
     Boolean b2 = Boolean.valueOf(true);
     System.out.println(b1 == b2);// 

     b1 = Boolean.valueOf(false);
     b2 = Boolean.valueOf(false);
     System.out.println(b1 == b2);// 
 }
}

  4. package org.forten.api.packagetype;

public class IntegerTest001 {
 public static void main(String[] args) {
 //Integer.valueOf(int)
 //得到int值对应的Intger对象
 Integer i1 = Integer.valueOf(-128);
     Integer i2 = Integer.valueOf(-128);
     System.out.println(i1 == i2);// true

     Integer i3 = Integer.valueOf(-129);
     Integer i4 = Integer.valueOf(-129);
     System.out.println(i3 == i4);
 
 //通过intValue()得到与Integer相应的int类型的值
 //XXXValue()可以返回XXX基本数据类型的值
 ／／不同的数字包装类都包含这些方法
 int int1 = i1.intValue();
     byte byte1 = i1.byteValue();
     double double1 = i1.doubleValue();
     long long1 = i1.longValue();
     
 //integer.valueOf(String,int)
 //String:待转换的数字格式字符串
 //int：进制数
 Integer i6 = Integer.valueOf("ff", 16);
     System.out.println(i6);
     i6 = Integer.valueOf("1000", 2);
     System.out.println(i6);
     i6 = Integer.valueOf("15", 22);
     System.out.println(i6);
     i6 = Integer.valueOf("1k", 22);
     System.out.println(i6);

     int int2 = 20;
     System.out.println(Integer.toBinaryString(int2));
     System.out.println(Integer.toOctalString(int2));
     System.out.println(Integer.toHexString(int2));
     System.out.println(Integer.toString(int2, 22));
     
     int int3 = -2147483648;
     long long2 = Integer.toUnsignedLong(int3);
     System.out.println(long2);
     
     
     //String与Integer的转换
     Integer i7 = Integer.parseInt("-123");
     System.out.println(i7);
     i7 = Integer.parseInt("1e",16);
     System.out.println(i7);
 }
}

  5. package org.forten.api.packagetype;

public class IntegerTest002 {
 public static void main(String[] args) {
 //Java5以前包装类对象和相应的基本数据类型
 //必须以显示的方式调用进行转换
 Integer xxx = Integer.valueOf(100);
     int yyy = xxx.intValue();
 //Java5后引入了自动装箱/拆箱操作，简化了之间的方法调用
 //次方法特性是为语法糖
 Integer i1 = 100;// 自动装箱
     int i2 = i1;// 自动拆箱
     System.out.println(i1); 
     System.out.println(i2); 
 }
}

    1. package org.forten.api.sort;

public class Apple implements Comparable<Apple> {
  private String name;
  private int heavy;
  private int price;

  public Apple(String name, int heavy, int price) {
      super();
      this.name = name;
      this.heavy = heavy;
      this.price = price;
  }

  public String getName() {
      return name;
  }

  public int getHeavy() {
      return heavy;
  }

  public int getPrice() {
      return price;
  }

  @Override
  public String toString() {
      return "Apple [name=" + name + ", heavy=" + heavy + ", price=" + price + "]";
  }

  @Override
  public int compareTo(Apple that) {
      if (this.price > that.price) {
          return 1;
      } else if (this.price < that.price) {
          return -1;
      } else {
          return 0;
      }
      //优点：简洁
      //缺点：在数字比较运算过程中有可能会出现数据越界的情况
  }
}

    2. package org.forten.api.sort;

import java.util.Comparator;

public class HeavyComparator implements Comparator<Apple> {

  @Override
  public int compare(Apple o1, Apple o2) {
      if (o1.getHeavy() > o2.getHeavy()) {
          return 1;
      } else if (o1.getHeavy() < o2.getHeavy()) {
          return -1;
      } else {
          return 0;
      }
  }

}

    3. package org.forten.api.sort;

import java.util.Arrays;
import java.util.Comparator;
//一般的外部类：很多类中都会使用这个外部类提供的逻辑
//非静态内部类：本类中多个方法共享的逻辑，在内部类中要访问外部类的非静态成员
//静态内部类：在本类中多个方法共享的逻辑，在内部类中不用 访问外部类的非静态成员
//匿名内部类：只有在方法参数上使用一次的逻辑(可以用Java8的Lambda表达式替代)
public class SortTest001 {
  public static void main(String[] args) {
      Integer[] intArr = { 28, 38, 122, 12, -38, 4, 0, 1, 32, 62, 91 };
      Arrays.sort(intArr);
      System.out.println(Arrays.toString(intArr));

      Apple a1 = new Apple("国光", 30, 3);
      Apple a2 = new Apple("蛇果", 100, 30);
      Apple a3 = new Apple("黄香蕉", 150, 15);
      Apple a4 = new Apple("红富士", 120, 10);
      Apple a5 = new Apple("塑料苹果", 10, 8);
      Apple a6 = new Apple("红香蕉", 160, 15);

      Apple[] appleArr = { a1, a2, a3, a4, a5, a6 };
      Arrays.sort(appleArr);
      System.out.println(Arrays.toString(appleArr));

      Arrays.sort(appleArr, new HeavyComparator());
      System.out.println(Arrays.toString(appleArr));

      Arrays.sort(appleArr, new SortTest001().new ReverseHeavyComparator());
      System.out.println(Arrays.toString(appleArr));

      Arrays.sort(appleArr, new SortTest001.ReversePriceComparator());
      System.out.println(Arrays.toString(appleArr));
//匿名内部类
//new(implements|extends)interface|abstractclass
Arrays.sort(appleArr, new Comparator<Apple>() {
          @Override
          public int compare(Apple o1, Apple o2) {
              if (o1.getPrice() > o2.getPrice()) {
                  return 1;
              } else if (o1.getPrice() < o2.getPrice()) {
                  return -1;
              } else {
                  if (o1.getHeavy() > o2.getHeavy()) {
                      return -1;
                  } else if (o1.getHeavy() < o2.getHeavy()) {
                      return 1;
                  } else {
                      return 0;
                  }
              }
          }
      });
      System.out.println(Arrays.toString(appleArr));

      Arrays.sort(appleArr, (o1, o2) -> {
          if (o1.getPrice() > o2.getPrice()) {
              return 1;
          } else if (o1.getPrice() < o2.getPrice()) {
              return -1;
          } else {
              if (o1.getHeavy() > o2.getHeavy()) {
                  return -1;
              } else if (o1.getHeavy() < o2.getHeavy()) {
                  return 1;
              } else {
                  return 0;
              }
          }
      });
      System.out.println(Arrays.toString(appleArr));

      Arrays.sort(appleArr, SortTest001::compareWithPriceAndReverseWeight);
      System.out.println(Arrays.toString(appleArr));
  }

  private static int compareWithPriceAndReverseWeight(Apple o1, Apple o2) {
      if (o1.getPrice() > o2.getPrice()) {
          return 1;
      } else if (o1.getPrice() < o2.getPrice()) {
          return -1;
      } else {
          if (o1.getHeavy() > o2.getHeavy()) {
              return -1;
          } else if (o1.getHeavy() < o2.getHeavy()) {
              return 1;
          } else {
              return 0;
          }
      }
  }

  private static class ReversePriceComparator implements Comparator<Apple> {
      @Override
      public int compare(Apple o1, Apple o2) {
          if (o1.getPrice() > o2.getPrice()) {
              return -1;
          } else if (o1.getPrice() < o2.getPrice()) {
              return 1;
          } else {
              return 0;
          }
      }
  }

  private class ReverseHeavyComparator implements Comparator<Apple> {
      @Override
      public int compare(Apple o1, Apple o2) {
          if (o1.getHeavy() > o2.getHeavy()) {
              return -1;
          } else if (o1.getHeavy() < o2.getHeavy()) {
              return 1;
          } else {
              return 0;
          }
      }
  }
}
Arrays.sort(appleArr, new Comparator<Apple>() {
          @Override
          public int compare(Apple o1, Apple o2) {
              if (o1.getPrice() > o2.getPrice()) {
                  return 1;
              } else if (o1.getPrice() < o2.getPrice()) {
                  return -1;
              } else {
                  if (o1.getHeavy() > o2.getHeavy()) {
                      return -1;
                  } else if (o1.getHeavy() < o2.getHeavy()) {
                      return 1;
                  } else {
                      return 0;
                  }
              }
          }
      });
      System.out.println(Arrays.toString(appleArr));

      Arrays.sort(appleArr, (o1, o2) -> {
          if (o1.getPrice() > o2.getPrice()) {
              return 1;
          } else if (o1.getPrice() < o2.getPrice()) {
              return -1;
          } else {
              if (o1.getHeavy() > o2.getHeavy()) {
                  return -1;
              } else if (o1.getHeavy() < o2.getHeavy()) {
                  return 1;
              } else {
                  return 0;
              }
          }
      });
      System.out.println(Arrays.toString(appleArr));

      Arrays.sort(appleArr, SortTest001::compareWithPriceAndReverseWeight);
      System.out.println(Arrays.toString(appleArr));
  }

  private static int compareWithPriceAndReverseWeight(Apple o1, Apple o2) {
      if (o1.getPrice() > o2.getPrice()) {
          return 1;
      } else if (o1.getPrice() < o2.getPrice()) {
          return -1;
      } else {
          if (o1.getHeavy() > o2.getHeavy()) {
              return -1;
          } else if (o1.getHeavy() < o2.getHeavy()) {
              return 1;
          } else {
              return 0;
          }
      }
  }

  private static class ReversePriceComparator implements Comparator<Apple> {
      @Override
      public int compare(Apple o1, Apple o2) {
          if (o1.getPrice() > o2.getPrice()) {
              return -1;
          } else if (o1.getPrice() < o2.getPrice()) {
              return 1;
          } else {
              return 0;
          }
      }
  }

  private class ReverseHeavyComparator implements Comparator<Apple> {
      @Override
      public int compare(Apple o1, Apple o2) {
          if (o1.getHeavy() > o2.getHeavy()) {
              return -1;
          } else if (o1.getHeavy() < o2.getHeavy()) {
              return 1;
          } else {
              return 0;
          }
      }
  }
}
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 214,904评论 6赞 497
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 91,581评论 3赞 389
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 160,527评论 0赞 350
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 57,463评论 1赞 288
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 66,546评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 50,572评论 1赞 293
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,582评论 3赞 414
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,330评论 0赞 270
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,776评论 1赞 307
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,087评论 2赞 330
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,257评论 1赞 344
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,923评论 5赞 338
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,571评论 3赞 322
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,192评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,436评论 1赞 268
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,145评论 2赞 366
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,127评论 2赞 352

推荐阅读更多精彩内容

  • java编程思想读书笔记二
    泛型 对象和实例是一个意思，类与对象的关系就像数据类型和变量一样。 泛型的主要目的之一就是用来指定类（如：容器）要...
    yueyue_projects阅读 575评论 0赞 0
  • JAVA笔试题之算法与编程
    Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java 技术具有卓越的通用性、高效性、平台移植性和...
    Java小辰阅读 977评论 0赞 5
  • 纯干货！JAVA细节标注+源码分析
    一、基本数据类型 注释 单行注释：// 区域注释：/* */ 文档注释：/** */ 数值 对于byte类型而言...
    龙猫小爷阅读 4,257评论 0赞 16
  • Java经典问题算法大全
    Java经典问题算法大全 /*【程序1】 题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子...
    赵宇_阿特奇阅读 1,858评论 0赞 2
  • 2018-06-12 第三十七天
    一、线程安全 线程安全的问题，是针对多线程的程序。单线程的情况下，是不存在线程安全问题。 产生线程安全问题的原因：...
    fe0180bd6eaf阅读 333评论 0赞 1