Java基礎_常用類_18

常用類

• 包裝類
• • Interger
• 日期相關類
• • java.util.Date
  • java.sql.Date
  • SimpleDateFormat
  • Calendar
  • • 列印出月曆
  • LocalDate/LocalTime/LocalDateTime
  • DateTimeFormatter
• Math
• • Math常用方法
  • Random類
• String
• StringBuilder和StringBuffer
• • StringBuilder
  • 可變數組和不可變數組的差別
  • StringBuilder的常用方法
  • StringBuffer在常用方法上和StringBuilder沒有差別
  • String，StringBuilder和StringBuffer的差別

包裝類

1. 什麼是包裝類：

   以前定義變量，經常使用基本資料類型，

   對于基本資料類型來說，它就是一個數，加點屬性，加點方法，加點構造器，

   将基本資料類型對應進行了一個封裝，産生了一個新的類，—》包裝類。

   int,byte…—>基本資料類型

   包裝類—>引用資料類型

2. 對應關系：

   基本資料類型·············對應的包裝類 ················繼承關系

   byte·······························Byte········- ····· ····Number—>Object

   short····························· Short····················Number—>Object

   int································ Integer······· ·····—>Number—>Object

   long······························ Long·················—>Number—>Object

   float·································Float ············· —>Number—>Object

   double··························Double ·················—>Number—>Object

   char ·····························Character ················Object

   boolean····························Boolean···················Object

3. 已經有基本資料類型了，為什麼要封裝為包裝類？

   （1）java語言 面向對象的語言，最擅長的操作各種各樣的類。

   （2）以前學習裝資料的—》數組，int[] String[] double[] Student[]

   以後學習的裝資料的—》集合，有一個特點，隻能裝引用資料類型的資料

4. 是不是有了包裝類以後就不用基本資料類型了？

   `

   不是。

Interger

public class InnerMethod {
    public static void main(String[] args) {
        //CompareTo
        Integer i = new Integer(6);
        Integer i2 = new Integer(12);
        System.out.println(i.compareTo(i2));
        /*public static int compare(int x, int y) {
            return (x < y) ? -1 : ((x == y) ? 0 : 1);
        }*/

        //equals
        //equals:Integer對Object中的equals方法進行了重寫，比較的是底層封裝的那個value的值。
        //Integer對象是通過new關鍵字建立的對象：
        Integer i3 = new Integer(12);
        Integer i4 = new Integer(12);
        System.out.println(i3 == i4);
        boolean flag =i3.equals(i4);
        System.out.println(flag);

        //Integer對象通過自動裝箱來完成：
        Integer i5 = 130;
        Integer i6 = 130;
        System.out.println(i5.equals(i6));
        System.out.println(i5==i6);
        /*
        如果自動裝箱值在-128~127之間，那麼比較的就是具體的數值
        否在，比較的就是對象的位址
         */

        //intValue
        Integer i7 = 130;
        int i8 = i7.intValue();
        System.out.println(i8);

        //parseInt:String-->int
        int i1 = Integer.parseInt("8");
        System.out.println(i1);

        //toString:Integer-->String
        Integer i9 = 130;
        System.out.println(i9.toString());

    }
}

           

日期相關類

java.util.Date

public class Test {
    public static void main(String[] args) {
        Date d = new Date();
        System.out.println(d);
        System.out.println(d.toString());
        System.out.println(d.toGMTString());
        System.out.println(d.toLocaleString());

        System.out.println(d.getYear()+1900);
        System.out.println(d.getMonth()+1);

        System.out.println(d.getTime());
        System.out.println(System.currentTimeMillis());
        /*
        疑問：以後擷取時間差使用getTime還是currentTimeMillis呢？
        答案：currentTimeMillis()--》因為這個方法是靜态的，可以類名.方法名直接調用
        （2）public static native long currentTimeMillis();這是個本地方法；
        沒有方法體，因為這個方法的具體實作不是通過java寫的。
        （3）這個方法的作用：
        一般會去衡量一些算法所用的時間
         */
        long startTime = System.currentTimeMillis();
        for (int i=0;i<100000;i++){
            System.out.println(i);
        }
        long endTime = System.currentTimeMillis();
        System.out.println(endTime-startTime);
    }
}

           

1. 以後擷取時間差使用getTime還是currentTimeMillis呢？

   答案：currentTimeMillis()–》因為這個方法是靜态的，可以類名.方法名直接調用

2. public static native long currentTimeMillis();這是個本地方法；

   沒有方法體，因為這個方法的具體實作不是通過java寫的。

3. 這個方法的作用：

   一般會去衡量一些算法所用的時間

java.sql.Date

關注valueOf這個方法

public class Test {
    public static void main(String[] args) {
        Date d = new Date(1592055964263L);
        System.out.println(d);
       
        java.util.Date date = new Date(1592055964263L);
        //util-->sql
        //方式一：向下轉型
        Date date1 = (Date) date;
        //方式二：利用構造器
        Date date2 = new Date(date.getTime());

        //sql-->util
        java.util.Date date3 = d;

        //[3]String--->sql.Date:
        Date date4 =  Date.valueOf("2019-3-8");
    }
}

           

1. java.util.Date和java.sql.Date的差別

   java.util.Date：年月日 時分秒

   java.sql.Date：年月日

2. java.sql.Date和java.util.Date的聯系：

   java.sql.Date(子類) extends java.util.Date （父類）

SimpleDateFormat

關注parse和Format兩個方法即可
           

public class Test {
    public static void main(String[] args) {
        //日期轉換
        //SimpleDateFormat(子類)  entends DateFormat(父類)；
        DateFormat df = new SimpleDateFormat("yyyy\\MM\\dd HH:mm:ss");
        //String-->Date;
        try {
            Date d = df.parse("2019\\4\\6 12:23:54");
            System.out.println(d);//Sat Apr 06 12:23:54 CST 2019
        } catch (ParseException e) {
            e.printStackTrace();
        }
        //Date-->String;
        String format= df.format(new Date());
        System.out.println(format);//2021\01\14 10:40:10
        //下面幾個date-->String的效果并不好
        Date date = new Date();
        System.out.println(date.toString());//Thu Jan 14 10:40:10 CST 2021
        System.out.println(date.getTime());//1610592010799
        System.out.println(date.toLocaleString());//2021-1-14 10:40:10,-->格式不能變，中間必須是橫杠-，而Format的格式可以随意的變，如|，/,-,等等
    }
}

           

Calendar

public class InnerMethod {
    public static void main(String[] args) {
        //Calendar是一個抽象類，不可以直接建立對象
        //GregorianCalendar()子類 extends Calendar（父類是一個抽象類）
        Calendar ca = new GregorianCalendar();
        //這個也行
        Calendar ca2 = Calendar.getInstance();
        System.out.println(ca);

        //常用的方法
        System.out.println(ca.get(Calendar.YEAR));
        System.out.println(ca.get(Calendar.MONTH)+1);//月
        System.out.println(ca.get(Calendar.DATE));//日
        System.out.println(ca.get(Calendar.DAY_OF_WEEK));//一個星期的第幾天
        System.out.println(ca.getActualMaximum(Calendar.DATE));//擷取當月日期的最大天數
        System.out.println(ca.getActualMinimum(Calendar.DATE));//擷取當月日期的最小天數

        //set方法
        ca.set(Calendar.YEAR,1999);
        ca.set(Calendar.MONTH,04);
        ca.set(Calendar.DATE,16);
        System.out.println(ca);

        //String-->Calendar
        //分解
        //String-->Java.sql.Date
        java.sql.Date date = java.sql.Date.valueOf("1999-04-16");
        //java.sql.date-->Calendar
        ca.setTime(date);
        System.out.println(ca);
    }
}

           

列印出月曆

public class Test {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        System.out.print("請輸入你想要檢視的日期：（提示：請按照例如2012-5-6的格式書寫）");
        String str = sc.next();
        //String-->Calendar
        java.sql.Date date = java.sql.Date.valueOf(str);
        Calendar ca = Calendar.getInstance();
        ca.setTime(date);

        //後續操作
        //星期提示
        System.out.println("日\t一\t二\t三\t四\t五\t六");
        //擷取本月的最大天數
        int maxDay = ca.getActualMaximum(Calendar.DATE);
        //擷取本月的日期中的日
        int nowDay = ca.get(Calendar.DATE);

        //将日期調為本月的1号
        ca.set(Calendar.DATE,1);
        //擷取這個一号是本周的第幾天：
        int num = ca.get(Calendar.DAY_OF_WEEK);
        /*System.out.println(num);*/

        //前面空出來的天數為：
        int day = num - 1;
        //引入計數器
        int count = 0;
        //在日期前的空格打出來

        for (int i = 1;i<=day;i++){
            System.out.print("\t");

        }
        //空出來的日子也要放入計數器：
        count = count+day;
        //周遊：從一号開始到maxDay号進行周遊
        for (int i=1;i<=maxDay;i++){
            if (i==nowDay){//如果周遊的i和目前日子一樣的話，後面多拼一個*
                System.out.print(i+"*\t");
            }else{
                System.out.print(i+"\t");
            }
            count++;
            if(count%7 ==0){//當計數器的個數是7的倍數的時候，就換行操作
                System.out.println();
            }
        }
    }
}

           

LocalDate/LocalTime/LocalDateTime

public class Test {
    public static void main(String[] args) {
        //1.完成執行個體化
        //方法1：now（）;擷取目前的日期；時間，日期加時間
        LocalDate localDate = LocalDate.now();
        System.out.println(localDate);
        LocalTime localTime = LocalTime.now();
        System.out.println(localTime);
        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println(localDateTime);

        //2.of（）;
        LocalDate of = LocalDate.of(2020, 1, 14);
        System.out.println(of);
        LocalTime of1 = LocalTime.of(12, 58, 35);
        System.out.println(of1);
        LocalDateTime of2 = LocalDateTime.of(2020, 1, 14, 5, 32);
        System.out.println(of2);

        //LocalDate,localTime用的不如LocaldateTime多
        //下面講解用localDateTime
        //get**方法
        System.out.println(localDateTime.getYear());//2021
        System.out.println(localDateTime.getMonth());//January
        System.out.println(localDateTime.getMonthValue());//1
        System.out.println(localDateTime.getDayOfMonth());//14
        System.out.println(localDateTime.getHour());//13
        System.out.println(localDateTime.getMinute());//6
        System.out.println(localDateTime.getSecond());//30

        //不是set方法，而是with
        //體會不可變性
        LocalDateTime localDateTime1 = localDateTime.withMonth(2);
        System.out.println(localDateTime);
        System.out.println(localDateTime1);

        //提供了加減操作
        //加
        LocalDateTime localDateTime2 = localDateTime.plusMonths(4);
        System.out.println(localDateTime);//2021-01-14T13:13:30.960
        System.out.println(localDateTime2);//2021-05-14T13:13:30.960
        //減
        LocalDateTime localDateTime3 = localDateTime.minusMonths(5);
        System.out.println(localDateTime);//2021-01-14T13:14:49.065
        System.out.println(localDateTime3);//2020-08-14T13:14:49.065


    }
}

           

DateTimeFormatter

public class DateTimeFormatterMethod {
    public static void main(String[] args) {
        //格式化類：DateTimeFormatter
        //方式一:預定義的标準格式。如:
        // ISO_LOCAL_DATE_TIME;
        // ISO_LOCAL_DATE;
        // IS0_LOCAL_TIME
        DateTimeFormatter df1 = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
        //df1就可以幫我們完成LocalDateTime和String之間的互相轉換：
        //LocalDateTime-->String:
        LocalDateTime now = LocalDateTime.now();
        String str = df1.format(now);
        System.out.println(str);//2021-01-14T13:22:13.99
        //String-->LocalDatetime
        TemporalAccessor parse = df1.parse("2021-01-14T13:22:13.99");
        System.out.println(parse);//{},ISO resolved to 2021-01-14T13:22:13.990

        //方法2：本地化相關格式如：ofLocalizeDateTime（）;
        //參數：FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT
        //FormatStyle.LONG :2020年6月15日 下午03時17分13秒
        //FormatStyle.MEDIUM: 2020-6-15 15:17:42
        //FormatStyle.SHORT:20-6-15 下午3:18
        DateTimeFormatter df2 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
        //LocalDateTime-->String
        LocalDateTime now1 = LocalDateTime.now();
        String str2 = df2.format(now1);
        System.out.println(str2);
        //String-->LocaldateTime
        TemporalAccessor parse1 = df2.parse("20-6-15 下午3:18");
        System.out.println(parse1);

        //方法3：自定義格式
        DateTimeFormatter df3 = DateTimeFormatter.ofPattern("yyyy--MM--ss hh:mm:ss");
        LocalDateTime-->String
        LocalDateTime now2 = LocalDateTime.now();
        String format = df3.format(now2);
        System.out.println(format);//2021-01-26 01:36:26
        //String-->LocaldateTime
        TemporalAccessor parse2 = df3.parse("2021--01--26 01:36:26");
        System.out.println(parse2);//{SecondOfMinute=26, HourOfAmPm=1, MilliOfSecond=0, NanoOfSecond=0, MicroOfSecond=0, MinuteOfHour=36, Year=2021, MonthOfYear=1},ISO


    }
}
           

Math

Math常用方法

import static java.lang.Math.*;//靜态導入

public class Method {
    public static void main(String[] args) {
        //常用屬性
        System.out.println(Math.PI);
        //常用方法
        System.out.println(Math.random());//随機數
        System.out.println(Math.abs(-80));//取絕對值
        System.out.println(Math.ceil(9.1));//10//相上取值
        System.out.println(Math.floor(9.1));//9//向下取值
        System.out.println(Math.round(99.3));//四舍五入
        System.out.println(Math.max(12, 23));//取較大的值
        System.out.println(Math.min(12, 23));//取較小的值
        System.out.println(min(15, 23));//靜态導入，import用static修飾

    }
    //如果跟Math中方法重複了，那麼會優先走本類中的方法（就近原則）
    public static int random(){
        return 100;

    }
}
           

Random類

public class RandomMethod {
    public static void main(String[] args) {
        System.out.println("随機數："+Math.random());
        
        //學習Random類
        //利用帶參構造器建立對象
        Random r = new Random(System.currentTimeMillis());
        int i = r.nextInt();
        System.out.println(i);

        //利用空參構造器建立對象
        Random r2 = new Random();
        System.out.println(r2.nextInt(10));在 0（包括）和指定值（不包括）之間均勻分布的 int 值。

        System.out.println( (r2.nextDouble()));在 0.0 和 1.0 之間均勻分布的 double 值。


    }
}

           

String

public class Method {
    public static void main(String[] args) {
        String str = "abd";
        String str2 = "";
        System.out.println(str);
        String s = new String();
        String s1 = new String("abc");
        String s2 = new String(new char[]{'a','1','c'});
        String s4 = "abc";
        System.out.println("字元串的長度"+s4.length());
        String s5 = new String();
        System.out.println("字元串是否為空："+s5.isEmpty());
        System.out.println("擷取字元串下标對應的字元："+s4.charAt(1));

        //equals
        String s6 = "abc";
        String s7 = "abc";
        System.out.println(s6.equals(s7));//true

        //compareTo
        String s8 = new String("abc");
        String s9 = new String("abcd456");
        System.out.println(s8.compareTo(s9));//-1

        //substring:字元串截取
        String s10 = new String("abcd456");
        s10.substring(1);
        System.out.println(s10.substring(3, 5));//不包括索引為5的這個字元
        
        //字元串拼接
        System.out.println(s10.concat("890"));

        //字元串中的字元的替換：
        String s11 = "abcd";
        System.out.println(s11.replace('a', 'u'));

        //spilt:按照指定的字元串進行分裂為數組的形式
        String s12 = "a-b-c-d-e-f";
        String[] split = s12.split("-");
        System.out.println(Arrays.toString(split));//[a, b, c, d, e, f]

        //轉換大小寫
        String s13 = "abc";
        System.out.println(s13.toUpperCase());//ABC
        System.out.println(s13.toUpperCase().toLowerCase());//abc

        //去除首尾空格
        String s14 = "     a   b    c    ";
        System.out.println(s14.trim());//a   b    c

        //toString
        String s15 = "abx";
        System.out.println(s15.toString());

        //valueOf：轉換為String類型
        String valueOf = String.valueOf(true);
        System.out.println(valueOf);
    }

}

           

StringBuilder和StringBuffer

• 與String不同，這兩個屬于可變字元串

StringBuilder

public class Builder {
    public static void main(String[] args) {
        //建立StringBuilder的對象
        StringBuilder builder = new StringBuilder();//表面上調用StringBuilder的空構造器，實際底層是對value數組進行初始化，長度為16
        StringBuilder builder1 = new StringBuilder(3);//表面上調用StringBuilder的有參構造器，傳入一個int類型的數，實際底層就是對value數組進行初始化，長度為你傳入的數字
        StringBuilder builder2 = new StringBuilder("abc");
        System.out.println(builder2.append("defghi").append("jklmn").append("opqrst").append("uvwxyz").toString());
//abcdefghijklmnopqrstuvwxyz
    }
}

           

可變數組和不可變數組的差別

不可變：在位址不變的情況下，想把“abc”變成“abcdef”是不可能的

可變：在StringBuilder這個對象的位址不變的情況下，想把“abc”變成“abcdef”是可能的，直接追加即可

StringBuilder的常用方法

public class Builder {
    public static void main(String[] args) {
        //建立StringBuilder的對象
       

        //常用方法
        StringBuilder sb = new StringBuilder("abcdefghi");
        //增
        sb.append("這是字母表");
        System.out.println(sb);  //abcdefghi 這是字母表

        //删
        sb.delete(1, 2);//删除位置在[1,2)上的字元，不包括索引2
        System.out.println(sb);//acdefghi這是字母表

        sb.deleteCharAt(0);//删除索引為0位置上的字元
        System.out.println(sb);//cdefghi這是字母表

        //改-->插入
        sb.insert(3, "--");//在下标為3的位置上插入--
        System.out.println(sb);//cde--fghi這是字母表

        //改-->替換
        sb.replace(0, 1, "++");//在下标[0,1)位置上替換字元串
        System.out.println(sb);//++de--fghi這是字母表
        sb.setCharAt(1, '-');//在下标1位置上替換字元
        System.out.println(sb);//+-de--fghi這是字母表

        //查
        for (int i= 0;i<sb.length();i++){
            System.out.print(sb.charAt(i)+"\t");//+	-	d	e	-	-	f	g	h	i	這	是	字	母	表
        }
        System.out.println();

        //截取
        String substring = sb.substring(0, 2);//截取[0,2)傳回的是一個新的String，對StringBuilder沒有影響
        System.out.println(substring);//+-
    }
}

           

StringBuffer在常用方法上和StringBuilder沒有差別

String，StringBuilder和StringBuffer的差別

1. String類是不可變類，即一旦一個String對象被建立後，包含在這個對象中的字元序列是不可改變的，直至這個對象銷毀。
2. StringBuffer類則代表一個字元序列可變的字元串，可以通過append、insert、reverse、setChartAt、setLength等方法改變其内容。一旦生成了最終的字元串，調用toString方法将其轉變為String
3. JDK1.5新增了一個StringBuilder類，與StringBuffer相似，構造方法和方法基本相同。不同是StringBuffer是線程安全的，而StringBuilder是線程不安全的，是以性能略高。通常情況下，建立一個内容可變的字元串，應該優先考慮使用StringBuilder

   StringBuilder:JDK1.5開始  效率高   線程不安全
   
   
            StringBuffer:JDK1.0開始   效率低    線程安全
              

有不懂的地方可以私信~

内容來源于馬士兵教育趙珊珊老師的Java筆記。