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()方法在原日期上減去相應單位的數(shù)量，并返回一個新的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基本數(shù)據(jù)類型的值
 ／／不同的數(shù)字包裝類都包含這些方法
 int int1 = i1.intValue();
     byte byte1 = i1.byteValue();
     double double1 = i1.doubleValue();
     long long1 = i1.longValue();
     
 //integer.valueOf(String,int)
 //String:待轉換的數(shù)字格式字符串
 //int：進制數(shù)
 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以前包裝類對象和相應的基本數(shù)據(jù)類型
 //必須以顯示的方式調用進行轉換
 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;
      }
      //優(yōu)點：簡潔
      //缺點：在數(shù)字比較運算過程中有可能會出現(xiàn)數(shù)據(jù)越界的情況
  }
}

    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;
//一般的外部類：很多類中都會使用這個外部類提供的邏輯
//非靜態(tài)內部類：本類中多個方法共享的邏輯，在內部類中要訪問外部類的非靜態(tài)成員
//靜態(tài)內部類：在本類中多個方法共享的邏輯，在內部類中不用 訪問外部類的非靜態(tài)成員
//匿名內部類：只有在方法參數(shù)上使用一次的邏輯(可以用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;
          }
      }
  }
}
?著作權歸作者所有,轉載或內容合作請聯(lián)系作者
【社區(qū)內容提示】社區(qū)部分內容疑似由AI輔助生成，瀏覽時請結合常識與多方信息審慎甄別。
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發(fā)布，文章內容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

相關閱讀更多精彩內容

  • 泛型 對象和實例是一個意思，類與對象的關系就像數(shù)據(jù)類型和變量一樣。 泛型的主要目的之一就是用來指定類（如：容器）要...
    yueyue_projects閱讀 624評論 0贊 0
  • Java是一種可以撰寫跨平臺應用軟件的面向對象的程序設計語言。Java 技術具有卓越的通用性、高效性、平臺移植性和...
    Java小辰閱讀 1,034評論 0贊 5
  • 一、基本數(shù)據(jù)類型 注釋 單行注釋：// 區(qū)域注釋：/* */ 文檔注釋：/** */ 數(shù)值 對于byte類型而言...
    龍貓小爺閱讀 4,442評論 0贊 16
  • Java經典問題算法大全 /*【程序1】 題目：古典問題：有一對兔子，從出生后第3個月起每個月都生一對兔子，小兔子...
    趙宇_阿特奇閱讀 2,075評論 0贊 2
  • 一、線程安全 線程安全的問題，是針對多線程的程序。單線程的情況下，是不存在線程安全問題。 產生線程安全問題的原因：...
    fe0180bd6eaf閱讀 382評論 0贊 1

友情鏈接更多精彩內容