Java筆記-07 常用類

文章目錄

包裝類

將基本類型數據轉化成對象，包裝類位於java.lang包中
提供：字符串、基本類型數據、對象之間互相轉化的方式，包含每種基本數據類型的相關屬性如最大值、最小值等

基本數據類型	包裝類
byte	Byte
boolean	Boolean
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double

以Integer爲例

public class TestWapperedClass {
    public static void main(String[] args) {
        int i = 100000;
        //基本數據類型轉換爲包裝類的兩種方式
        Integer a = new Integer(i);
        Integer b = Integer.valueOf(i); //推薦

        //包裝類轉換爲基本數據類型
        int a1 = a; //自動裝箱拆箱
        int a2 = a.intValue();

        //字符串轉換爲包裝類
        Integer a3 = new Integer("1234");
        Integer a4 = Integer.valueOf("1234");
        Integer a5 = Integer.parseInt("1234");

        //包裝類轉換爲字符串
        String s = a3.toString();

        //常用的常量
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.MAX_VALUE);
        //方法
        System.out.println(Integer.max(4,6)); //求最大值
        System.out.println(Integer.compare(6,6));//第一個數是否大於第二個數，結果爲1,-1,0
    }
}

自動裝箱拆箱

        Integer a = 312; //自動裝箱 Integer.valueOf()
        int b = a; //自動拆箱 a.intValue()

緩存 -128到127之間的數字，緩存是個數組
如果數據在-128~127這個區間，那麼在類加載時就已經爲該區間的每個數值創建了對象，並將這256個對象存放到一個名爲cache的數組中。每當自動裝箱過程發生時(或者手動調用valueOf()時)，就會先判斷數據是否在該區間，如果在則直接獲取數組中對應的包裝類對象的引用，如果不在該區間，則會通過new調用包裝類的構造方法來創建對象。

        Integer a1 = -128;
        Integer a2 = -128;
        System.out.println(a1 == a2); //true
        System.out.println(a1.equals(a2)); //true

        Integer a3 = 1234;
        Integer a4 = 1234;
        System.out.println(a3 == a4); //false
        System.out.println(a3.equals(a4)); //false

字符串String

String 類對象代表不可變的Unicode字符序列。private final char value[];
判斷是不是同一個字符串使用equals
==判斷兩個對象是否爲同一個，equals判斷內容是不是相同

        String str1 = "abc";
        String str2 = "123";
        String str3 = str1 + str2;
        String str4 = "abc" + "123";
        System.out.println(str3 == str4); //false
        System.out.println(str4 == "abc123"); //true
        System.out.println(str3.equals(str4)); //true

StringBuilder是可變的字符序列，StringBuffer也是，都是AbstractStringBuilder的子類，前者效率高但是線程不安全，StringBuffer線程安全，效率低
可變字符串，修改時直接修改本身

        StringBuilder sb = new StringBuilder("abcdefg");
        System.out.println(Integer.toHexString(sb.hashCode()));//字符串地址
        sb.setCharAt(2,'k'); //修改一下
        System.out.println(sb); //輸出修改結果
        System.out.println(Integer.toHexString(sb.hashCode()));//再次打印字符串地址

常用方法，追加，刪除，插入，修改

        StringBuilder sb1 = new StringBuilder();
        for(int i = 0;i<26;i++){
            sb1.append((char)('a'+i));//追加26個小寫字母
        }
        System.out.println(sb1);
        sb1.reverse(); //反轉
        System.out.println(sb1);
        sb1.setCharAt(2,'A');//修改一個字符
        System.out.println(sb1);
        //插入，返回對象本身，可以鏈式調用
        sb1.insert(1,"中國").insert(4,"萬歲").insert(7,"萬歲");
        System.out.println(sb1);
        //刪除，也是鏈式調用
        sb1.delete(20,23) ;//刪除一段，從c1到c2，後面的取不到
        System.out.println(sb1);
        sb1.deleteCharAt(22);//刪除一個字符

陷阱：對String字符串的操作實際上是對其副本(原始拷貝)的操作，原來的字符串一點都沒有改變。for循環中使用str = str + i，會產生大量的無用對象，浪費空間時間，應該使用StringBuilder，append方法。測試兩種情況的對比，第一種會產生大量的字符串，既費空間也耗費時間

public class TestStringTime {
    public static void main(String[] args) {
        //測試String佔用的內存時間
        String str = "";
        long memory1 = Runtime.getRuntime().freeMemory();
        long time1 = System.currentTimeMillis();
        for(int i=0;i<5000;i++){
            str = str + i;
        }
        long memory2 = Runtime.getRuntime().freeMemory();
        long time2 = System.currentTimeMillis();
        System.out.println("String佔用內存："+(memory1-memory2));
        System.out.println("String佔用時間："+(time2-time1));

        //StringBuilder的時間

        StringBuilder sb = new StringBuilder();
        long memory3 = Runtime.getRuntime().freeMemory();
        long time3 = System.currentTimeMillis();
        for(int i=0;i<6000;i++){
            sb.append(i);
        }
        long memory4 = Runtime.getRuntime().freeMemory();
        long time4 = System.currentTimeMillis();
        System.out.println("StringBuilder佔用內存："+(memory3-memory4));
        System.out.println("StringBuilder佔用時間："+(time4-time3));
    }
}

//String佔用內存：31958544
//String佔用時間：87
//StringBuilder佔用內存：0
//StringBuilder佔用時間：0

時間處理類

時間 1970年1月1日0點0分0秒爲原點，格林威治時間
使用long類型表示時間，獲取當前時間long now = System.currentTimeMillis()

Date類

java.util.Date
getTime獲取毫秒數

import java.util.Date;

public class TestDate {
    public static void main(String[] args) {
        Date date = new Date(); //直接調用System.currentTimeMillis()
        System.out.println(date); //Mon Feb 10 14:02:20 CST 2020
        //獲取毫秒數
        long t1 = date.getTime();
        System.out.println(t1);
        //獲取參數毫秒數所在的時間，有時區
        Date date0 = new Date(0);
        System.out.println(date0);
        //兩個時間的先後，返回boolean，after before
        System.out.println(date.after(date0));
        //不推薦使用
        Date d3 = new Date(2020-1900,1,3);
        System.out.println(d3);//Mon Feb 03 00:00:00 CST 2020
    }
}

DateFormat

DateFormat是抽象類，一般使用具體實現類，SimpleDateFormat
常用parse和format，用於字符串和時間對象的相互轉換

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

public class TestDateFormat {
    public static void main(String[] args) throws ParseException {
        //傳入模式，將Date對象轉格式化爲字符串
        SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        SimpleDateFormat df2 = new SimpleDateFormat("yyyy年MM月dd日 HH時mm分ss秒");
        String str1 = df1.format(new Date());
        System.out.println(str1);
        System.out.println(df2.format(new Date()));
        //字符串轉換爲時間對象，字符串需和指定的模式一致
        String str2 = "2017年1月10日 16時10分38秒";
        Date d = df2.parse(str2);
        System.out.println(d);

        //一年中的多少天
        SimpleDateFormat df3 = new SimpleDateFormat("D");
        String str3 = df3.format(new Date());
        System.out.println(str3); //2月10日是第41天
        
    }
}
/*
2020-02-10 16:15:40
2020年02月10日 16時15分40秒
Tue Jan 10 16:10:38 CST 2017
41
*/

Calendar

Calendar 類是一個抽象類，爲我們提供了關於日期計算的相關功能，比如：年、月、日、時、分、秒的展示和計算。 GregorianCalendar 是 Calendar 的一個具體子類

import java.util.Date;
import java.util.GregorianCalendar;

public class TestCalendar {
    public static void main(String[] args) {
        //月份從0開始計數,0-11,12表示次年1月
        GregorianCalendar c = new GregorianCalendar(2020,11,5);
        int year = c.get(c.YEAR); //年
        int month = c.get(c.MONTH); //月 0-11
        int day = c.get(c.DAY_OF_MONTH);
        int weekday = c.get(c.DAY_OF_WEEK); //星期1-7，星期日爲1
        System.out.println(year);
        System.out.println(month);
        System.out.println(day);
        System.out.println(weekday);
        //設置日期
        GregorianCalendar c1 = new GregorianCalendar();
        c1.set(c1.YEAR,2022);
        System.out.println(c1);
        //日期延後，100年未來爲正，向過去爲負，修改對象本身
        c1.add(c1.YEAR,-100);
        System.out.println(c1);
        //日期和時間的轉換
        Date d1 = c1.getTime(); //日期轉時間
        System.out.println(d1);
        GregorianCalendar c2 = new GregorianCalendar(); //時間轉日期
        c2.setTime(new Date());
    }
}

給定時間打印日曆

package MyPro08;

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

public class PrintCalendar {
    public static void main(String[] args) throws ParseException {
        String date = "2020-5-20";
        //字符串轉爲Date對象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date date1 = sdf.parse(date);
        //標題
        String weekName = "日\t一\t二\t三\t四\t五\t六\n";
        //System.out.println(weekName);
        //日曆的字符串StringBuilder
        StringBuilder data = new StringBuilder();
        //獲取calendar對象
        GregorianCalendar calendar = new GregorianCalendar(); //時間轉日期
        calendar.setTime(date1);
        int day = calendar.get(calendar.DATE); //當月的第幾天

        //將當前calendar設置爲1日
        calendar.set(calendar.DATE,1);
        //第一天之前幾天，用製表符填充
        int daysBefore1 = calendar.get(calendar.DAY_OF_WEEK);
        for(int i = 0;i<daysBefore1 - 1;i++){
            data.append("\t");
        }
        //一個月有多少天
        int days = calendar.getActualMaximum(Calendar.DATE);

        for(int i = 1;i <= days;i++){
            //獲取天
             ;
            String dayst = "";
            //在後面追加製表，星期六就加換行
            if(calendar.get(calendar.DATE)==day){
                dayst = calendar.get(calendar.DATE) + "*";
            }else{
                dayst = calendar.get(calendar.DATE) + "";
            }

            if(calendar.get(calendar.DAY_OF_WEEK)==7){
                data.append(dayst+"\n");
            }else{
                data.append(dayst+"\t");
            }
            //天數加1
            calendar.add(calendar.DATE,1);
        }
        //將內容輸出
        System.out.println(weekName+data);
    }
}

Math

java.lang.Math

1. abs 絕對值

2. acos,asin,atan,cos,sin,tan 三角函數

3. sqrt 平方根

4. pow(double a, double b) a的b次冪

5. max(double a, double b) 取大值

6. min(double a, double b) 取小值

7. ceil(double a) 大於a的最小整數

8. floor(double a) 小於a的最大整數

9. random() 返回 0.0 到 1.0 的隨機數

10. long round(double a) double型的數據a轉換爲long型(四捨五入)

11. toDegrees(double angrad) 弧度->角度

12. toRadians(double angdeg) 角度->弧度

Random

生成隨機數

import java.util.Random;

public class TestRandom {
    public static void main(String[] args) {
        Random rand = new Random();
        //隨機生成[0,1)之間的double類型的數據
        System.out.println(rand.nextDouble());
        //隨機生成int類型允許範圍之內的整型數據
        System.out.println(rand.nextInt());
        //隨機生成[0,1)之間的float類型的數據
        System.out.println(rand.nextFloat());
        //隨機生成false或者true
        System.out.println(rand.nextBoolean());
        //隨機生成[0,10)之間的int類型的數據
        System.out.print(rand.nextInt(10));
        //隨機生成[20,30)之間的int類型的數據
        System.out.print(20 + rand.nextInt(10));
        //隨機生成[20,30)之間的int類型的數據（此種方法計算較爲複雜）
        System.out.print(20 + (int) (rand.nextDouble() * 10));
    }
}

File

對文件和文件夾的操作，創建，重命名，刪除

import java.io.File;
import java.io.IOException;
import java.util.Date;

public class TestFile {
    public static void main(String[] args) throws IOException {
        //創建文件
        File f = new File("D:\\data\\a.txt");
        f.createNewFile();
        System.out.println(f); //輸出路徑
        //重命名文件
        f.renameTo(new File("D:\\data\\abc.txt"));

        //獲取用戶目錄，即項目所在的目錄
        System.out.println(System.getProperty("user.dir"));
        //在項目目錄下創建文件
        File f1 = new File("heihei.txt");
        f1.createNewFile();

        System.out.println("File是否存在："+f.exists());
        System.out.println("File是否是目錄："+f.isDirectory());
        System.out.println("File是否是文件："+f.isFile());
        System.out.println("File最後修改時間："+new Date(f.lastModified()));
        System.out.println("File的大小："+f.length());
        System.out.println("File的文件名："+f.getName());
        System.out.println("File的目錄路徑："+f1.getPath());
        System.out.println("File的完整路徑："+f1.getAbsolutePath());
        //刪除文件，返回值爲boolean是否成功刪除
        boolean deleteSuccess = f1.delete();
        System.out.println(deleteSuccess);
        //創建文件夾，mkdir只能創建一層，前幾層需要存在
        File f2 = new File("D:\\data\\test\\a\\b\\c");
        boolean isMkdirSuccess = f2.mkdir();
        System.out.println(isMkdirSuccess);

        File f3 = new File("D:\\data\\test\\a\\b\\c");
        boolean isMkDirs = f3.mkdirs();
        System.out.println(isMkDirs);
        //刪除文件夾，不能刪除多層
        File f4 = new File("D:\\data\\test\\a");
        boolean idDelete = f4.delete();
        System.out.println(idDelete);
    }
}

import java.io.File;

public class ListFiles {
    public static void main(String[] args) {
        printFile(new File("D:\\data\\xinganmeng"),0);
    }

    static void printFile(File file, int level) {
        //輸出層次數
        for (int i = 0; i < level; i++) {
            System.out.print("-");
        }
        //輸出文件名
        //System.out.println(file.getName());
        System.out.println(file.getAbsolutePath());
        //如果file是目錄，則獲取子文件列表，並對每個子文件進行相同的操作
        if (file.isDirectory()) {
            File[] files = file.listFiles();
            for (File temp : files) {
                //遞歸調用該方法：注意等+1
                printFile(temp, level + 1);
            }
        }
    }
}

枚舉

枚舉類型的定義包括枚舉聲明和枚舉體
所有的枚舉類型隱性地繼承自 java.lang.Enum。枚舉實質上還是類!而每個被枚舉的成員實質就是一個枚舉類型的實例，他們默認都是public static final修飾的

import java.util.Random;

public class TestEnum {
    public static void main(String[] args) {
        System.out.println(Season.AUTUMN);
        //枚舉的所有的值
        Season[] seasons = Season.values();
        //隨機打印
        Random random = new Random();
        int a = random.nextInt(4);
        System.out.println(a);
        switch (seasons[a]){
            case SPRING:
                System.out.println("春天");
                break;
            case SUMMER:
                System.out.println("夏天");
                break;
            case AUTUMN:
                System.out.println("秋天");
                break;
            case WINTER:
                System.out.println("冬天");
                break;
        }
    }
}
//枚舉定義常量
enum Season{
    SPRING,SUMMER,AUTUMN,WINTER
}

Java筆記-07 常用類

文章目錄

包裝類

字符串String

時間處理類

Date類

DateFormat

Calendar

Math

Random

File

枚舉

Java筆記-07 常用類

Java筆記-06 面向對象進階

14 模式匹配和樣例類

10 特質

scala-19 高級類型

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結