斷斷續續五個月，總算把Java基礎系統學習了一遍，本節主要是對前面學習的一個總結文，由于本人已經作業，深知基礎的重要性，即使作業很忙，也還是擠著時間努力輸入，有時覺得堅持很難很難，好在自己還是堅持了過來，不過這只是編程路上跨過的小小一步，前路漫漫，吾將持續求索，

此篇文章為Java基礎的一個小結束，是我編程之旅的新起點，
時光不負趕路人，星光不負追夢人，加油！！！

本文已收錄于[ 專欄 ]

🌳《Java入門》系列🌳

文章目錄

前言
1.必備常識概念
- 1.1 面向物件語言與面向程序語言區別
- 1.2 類、包、介面、抽象、列舉、函式(方法)、常量、變數名詞含義
- 1.3 Java的編譯程序,位元組碼、虛擬機JVM含義
2.編程語言基礎
- 2.1 變數命名,變數型別，大小駝峰命名方式,常量命名
- 2.2 變數賦值，基本資料型別、陣列、參考型別含義
- 2.3 算術運算、邏輯運算、位運算
- 2.4 回圈、與分支選擇
- 2.5 封裝、繼承、多型的含義
3.lang包掌握
- 3.1 lang包為何不用匯入
- 3.2 八大基本型別的對應封裝類
- 3.3 Exception與Error的區別,RuntimeException
- 3.4 Object
- 3.5 Number與Math
- 3.6 System
4. String
- 4.1 String 與char的關系
- 4.2 字串查找出所在位置下標
- 4.3 字串截取
- 4.4 字串替換
- 4.5 字串拼接
- 4.6 切割成多個字串
- 4.7 StringBuilder與StringBuffer
5. 容器(集合)
- 5.1 List
- 5.2 Set
- 5.3 Map
- 5.4 集合的遍歷方式
- 5.5 Collections與排序、篩選
6 . 日常業務功能
- 6.1 Date與Calendar
- 6.2 例外處理與finally作用
- 6.3 IO流操作

前言

按照下面分類的知識點，形成一張表格以便時時檢驗自己的基本功，
在這里插入圖片描述

1.必備常識概念

1.1 面向物件語言與面向程序語言區別

先舉個例子，給定一個業務：Panda飛豬要學會Java并且利用Java語言編程，
面向程序的老師A首先讓Panda飛豬第一步看視頻做筆記，第二步做題寫代碼，第三部系統看書寫代碼來達到Panda飛豬想要的目的，
面向物件的老師B首先讓Panda飛豬找所有可以學習Java的工具：書、視頻、編程的工具IDEA，接著讓Panda飛豬自己利用這些物件達到Panda飛豬想要達到的目的，
可以很明顯的看到，面向物件的老師讓Panda飛豬找到了物件，但是Panda飛豬還是需要去學習面向程序的老師A的一些方法去真正利用物件達到目的，

面向程序：是一種以程序為中心的編程思想,它是一種基礎的順序的思維方式,面向物件方法的基礎實作中也包含面向程序思想，

面向物件：按人們認識客觀世界的系統思維方式，采用基于物件（物體）的概念建立模型，模擬客觀世界分析、設計、實作軟體的辦法，通過面向物件的理念使計算機軟體系統能與現實世界中的系統一一對應，

面向物件語言是只一切操作都以物件為基礎，它是由面向程序語言發展而來的，但正是它的這個特性使得面向物件語言對底層的操作不是很方便，例如：java語言，
面向程序語言是以程序或函式為基礎的，這種語言對底層硬體，記憶體等操作比較方便，但是寫代碼和除錯維護等會很麻煩，例如：c語言，

總結一下哦，有如下幾個方面的不同：

出發點不同

面向物件強調把問題直接映射到物件之間的介面上，面向程序強調的程序的抽象化與模塊化，以程序為中心，構造、處理世界，

資料處理方式與控制程式方式不同

面向物件，資料與對應的代碼封裝成一個整體，原則上其他物件不能直接修改其資料，物件的修改只能由自身的完成；面向程序，通程序式處理資料，處理完顯示結果，在控制方式上是按照設計呼叫或回傳程式，不能自由導航，各模塊之間存在著控制與被控制，調動與被呼叫的關系，

分析設計與編碼轉換方式不同

面向物件方法貫穿于軟體生命周期的分析，設計及編碼中，是一種平滑程序，即實作的是無縫連接，面向程序，強調分析、設計及編碼之間按規則進行，實作的是有縫連接，

1.2 類、包、介面、抽象、列舉、函式(方法)、常量、變數名詞含義

名稱	含義
類	class ：用來描述某一類物件的共同特征
物件	具體的事物、物體
包	Package,可以放很多類
介面	與抽象類相似，是一批類要遵守的規范 interface
抽象	abstract，只宣告方法不實作方法
列舉	一組固定的常量組成合法值的型別
函式	用來實作某個功能的方法
常量	final修飾，值不變的量
變數	可被多次改變數值的量

1.3 Java的編譯程序,位元組碼、虛擬機JVM含義

Java源檔案由編譯器編譯成位元組碼（ByteCode），位元組碼由java虛擬機（JVM）解釋運行，
手動編譯Java源代碼程序

2.編程語言基礎

2.1 變數命名,變數型別，大小駝峰命名方式,常量命名

如下面例子：定義了類、常量、變數、方法

package com.algorithm;

/**
 * @Author: qp
 * @Time: 2021/10/18 21:57
 * @Description　
 */
public class DemoPractice {
    static final float TEST_PI=3.14f;
    final float PI=3.14f;
    float testPi =3.14f;

    @Override
    public String toString() {
        return "DemoPractice{" +
                "TEST_PI=" + TEST_PI +
                ", testPi=" + testPi +
                '}';
    }
}

2.2 變數賦值，基本資料型別、陣列、參考型別含義

如下面例子：

package com.algorithm;

import java.util.ArrayList;

/**
 * @Author: qp
 * @Time: 2021/10/18 21:57
 * @Description
 */
public class DemoPractice {
    byte aByte = 1;
    short aShort = 2;
    int anInt = 4;
    long aLong = 8;

    final float TEST_PI = 3.14f;
    float testPi = 3.14f;
    double aDouble = 3.24;
    char aChar = 'c';
    boolean aBoolean=false;

    String string="你好";
    Integer integer1 = new Integer(1);　
}

2.3 算術運算、邏輯運算、位運算

如下面例子：

public class DemoPractice {
    byte aByte = 1;
    short aShort = 2;
    int anInt = 4;
    long aLong = 8;

    final float TEST_PI = 3.14f;
    float testPi = 3.14f;
    double aDouble = 3.24;
    char aChar = 'c';
    boolean aBoolean = false;

    String string = "你好";
    ArrayList arrayList = new ArrayList();
    
    private void math() {
        int i = aByte + aShort;
        i-=aShort;
        i*=aByte;
        i/=aByte;

        long max=(anInt>aLong)?anInt:aLong;
        i=1>>2;
    }
}

2.4 回圈、與分支選擇

如下面的代碼：回圈的三種代碼實作，選擇中嵌套分支結構

public class Demo {

    //while回圈
    private static int sum1(int num, int sum) {
        while (num <= 100) {
            sum = sum + num;
            num++;
        }
        return sum;
    }


    //do　while回圈
    private static int sum2(int num, int sum) {
        do {
            sum = sum + num;
            num++;

        } while (num <= 100);
        return sum;
    }


    //for回圈
    private static int sum3(int num, int sum) {
        for (int i = 1; i <= 100; i++) {
            sum = sum + num;
            num++;
        }
        return sum;
    }

    public static void main(String[] args) {
        int sum = 0;
        int num = 1;
        Scanner scanner = new Scanner(System.in);
        int choice= scanner.nextInt();


        switch (choice){
            case(1):
                System.out.println("第１種求和方式"+sum3(num, sum));
                break;
            case(2):
                System.out.println("第２種求和方式"+sum2(num, sum));
                break;
            case (3):
                System.out.println("第３種求和方式"+sum3(num, sum));
                break;
            default:
                System.out.println("默認求和方式"+sum3(num, sum));
                break;
        }
    }

}

2.5 封裝、繼承、多型的含義

一篇文章讀懂封裝、繼承、多型，接下來，舉個例子說明封裝、繼承、多型；

import java.beans.DesignMode;
import java.util.Scanner;

/**
 * Math類中封裝了2個求和的方法
 */
class Math {
    //while回圈
    protected  int sum1(int num, int sum) {
        while (num <= 100) {
            sum = sum + num;
            num++;
        }
        return sum;
    }


    //do　while回圈
    protected  int sum2(int num, int sum) {
        do {
            sum = sum + num;
            num++;

        } while (num <= 100);
        return sum;
    }
}


/**
 * Demo繼承了Math中所有的非private修飾的方法并且可以重寫
 */
public class Demo extends Math{

    /**
     * @param num
     * @param sum
     * @return 重寫了求和方法,編譯時多型
     */
    @Override
    protected int sum1(int num, int sum) {
        for (int i = 1; i <= 100; i++) {
            sum = sum + num;
            num++;
        }
        return sum;

    }

    public static void main(String[] args) {
            int sum = 0;
            int num = 1;
//向上型別轉換,運行時的多型
            Math math = new Demo();
            math.sum1(2,0);
        }
}

3.lang包掌握

3.1 lang包為何不用匯入

java.lang包是java語言的核心，它提供了java中的基礎類，包括基本Object類、Class類、String類、基本型別的包裝類、基本的數學類等等最基本的類， java.lang包提供利用java編程語言進行程式設計的基礎類，它在程式生成時就幫你自動多加了一段程式匯入了，

3.2 八大基本型別的對應封裝類

java中的資料型別int，double等不是物件，無法通過向上轉型獲取到Object提供的方法，而像String卻可以，只因為String是一個物件而不是一個型別，基本資料型別由于這樣的特性，導致無法參與轉型，泛型，反射等程序，為了彌補這個缺陷，java提供了包裝類，
有8大基本資料型別,其對應的包裝類分別為：

型別	位元組型	字符型	布爾型	短整型	整型	長整型	單精度實型	雙精度實型
基本資料型別名	byte	char	boolean	short	int	long	float	double
包裝類名	Byte	Character	Boolean	Short	Integer	Long	Float	Double

3.3 Exception與Error的區別,RuntimeException

Error（錯誤）：通常是災難性的致命錯誤，不是程式（程式猿）可以控制的，如記憶體耗盡、JVM系統錯誤、堆疊溢位等，應用程式不應該去處理此類錯誤，且程式員不應該實作任何Error類的子類，
Exception（例外）：用戶可能捕獲的例外情況，可以使用針對性的代碼進行處理，如：空指標例外、網路連接中斷、陣列下標越界等，
RuntimeException類及其子類稱為非檢查型例外，Java編譯器會自動按照例外產生的原因引發相應型別的例外，程式中可以選擇捕獲處理也可以不處理，雖然Java編譯器不會檢查運行時例外，但是也可以去進行捕獲和拋出處理，RuntimeException類和子類以及Error類都是非受檢例外，

3.4 Object

Object類是Javajava.lang包下的核心類，Object類是所有類的父類，何一個類時候如果沒有明確的繼承一個父類的話，那么它就是Object的子類；
Object 類屬于java.lang包，此包下的所有類在使用時無需手動匯入，系統會在程式編譯期間自動匯入

3.5 Number與Math

Math類定義了基本數學運算的屬性和方法，所有方法都為static，可以通過math類在主函式直接呼叫，
所有的包裝類（Integer、Long、Byte、Double、Float、Short）都是抽象類 Number 的子類；

public class Demo1 {

    public static void main(String[] args) {
//        實作小數四舍五入
        Double aDouble = new Double(1.73);
        System.out.println(Math.round(aDouble));
    }
}

3.6 System

System類代表系統，系統級的很多屬性和控制方法都放置在該類的內部，該類位于java.lang包，
由于該類的構造方法是private的，所以無法創建該類的物件，也就是無法實體化該類，其內部的成員方法和成員變數都是static（靜態）的，所以也可以很方便的呼叫他，


public class Demo1 {

    private static final String TAG ="Demo1" ;

    public static void main(String[] args) {
//        列印當前時間毫米值
        System.out.println(System.currentTimeMillis());
//        復制陣列
        int[] i = {1, 2, 3};
        int[] j = new int[5];
        System.arraycopy(i, 0, j, 2, 3);
    }
}

4. String

4.1 String 與char的關系

字串效果相當于陣列（char[]），char是一個可以用來存盤字符資料的變數型別，而string就是一個存盤一串字符資料的變數型別，他們的共同點就是他們都是變數型別，都是用來存盤字符的
字串String是參考資料型別，char是基本資料型別

4.2 字串查找出所在位置下標

String str ="hello word";
char c1 = str.charAt(0);//c1的值為'h'
char c2 = str.chatAt(6);//c1的值為'w'

4.3 字串截取

String str1 = "我每天學習";
String str2 = str1.substring(1);//str1="每天學習"
String str3 = str1.substring(0,3)//str2="我每天"

4.4 字串替換

 String string = new String("hello");
 String str = string.replaceAll("h", "y");//str =yello

4.5 字串拼接

String s1 = "I am";
String s2 = " a student";
String s3 = s1 + s2;
String s4 = s1.concat(s2);
int s5 = s1.concat(s2)
System.out.println(s3);
System.out.println(s4);
System.out.println("s3=s4:"+(s3==s4));//字1符串連接邏輯例外

4.6 切割成多個字串

String str="1234@abc";
String[] a = str.split("@");
System.out.println("處理結果: "+a[0]+","+a[1]);   //輸出的是: 處理結果: 1234,abc

4.7 StringBuilder與StringBuffer

String類是不可變類，任何對String的改變都會引發新的String物件的生成；
StringBuffer是可變類，任何對它所指代的字串的改變都不會產生新的物件，執行緒安全的，
StringBuilder是可變類，線性不安全的，不支持并發操作，不適合多執行緒中使用，但其在單執行緒中的性能比StringBuffer高，

StringBuffer strBuf = new StringBuffer("abc");
String str = strBuf.append("def");//str = "abcdef"
StringBuilder bu1 = new StringBuilder();
System.out.println("bu1"+bu1);// bu1
StringBuilder bu2 = new StringBuilder("abc");
System.out.println("bu2:"+bu2);// bu2:abc

5. 容器(集合)

5.1 List

List集合,有兩種實作類：ArrayList、LinkedList，
ArrayList和陣列類似，順序排列，訪問速度快，插入和洗掉速度塊較慢

LinkedList，采用鏈表資料結構，訪問速度慢，插入和洗掉速度塊

class Example8_5{
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("c");
        System.out.println("arrayList的元素為："+arrayList);
        arrayList.set(0,"c");//將索引為０的位置物件a修改為物件c
        System.out.println("arrayList的元素為"+arrayList);
        arrayList.add(1,"e");//將物件e添加到索引為１的位置
        System.out.print("arrayList的元素為:");
        for (int i=0;i<arrayList.size();i++){
            System.out.print(arrayList.get(i));//for回圈迭代arrayList集合元素
        }
        System.out.println("");
        System.out.println("arrayList指定元素c位置的索引為"+arrayList.indexOf("c"));//回傳串列中指定元素c位置的索引
        System.out.println("arrayList指定元素c最后位置的索引為"+arrayList.lastIndexOf("c"));//回傳串列中指定元素c最后位置的索引
        System.out.println("arrayList的指定區域為"+arrayList.subList(1,2));//回傳串列中指回傳一個指定區域的List集合物件[1,2)

        LinkedList linkedList = new LinkedList();
        linkedList.add("a");
        linkedList.add("b");
        linkedList.add("c");
        linkedList.add("d");
        //獲得并輸入串列開頭的物件
        System.out.println("串列開頭元素為："+linkedList.getFirst()+"串列結尾元素為："+linkedList.getLast());

        linkedList.addFirst("rr");//向串列開頭添加一個物件
        System.out.println("串列中所有元素："+linkedList);
        linkedList.removeLast();//移除串列結尾元素
        System.out.println("串列結尾元素為："+linkedList.getLast());//獲取并輸出串列結尾的物件
    }
}

5.2 Set

TreeSet集合中元素唯一且已經排好序，采用額外的紅黑樹演算法進行排序，如果需要一個保持順序的集合時，應該選擇TreeSet；

HashSet集合中元素唯一且已經排好序，它按照Hash演算法進行排序，如果經常對元素進行添加、查詢操作，應該選擇HashSet；

LinkedHashSet是HashSet的一個子類，具有HashSet的特性，也是根據元素的hashCode值來確定元素的存盤位置，它使用鏈表維護元素的次序，因此插入和洗掉性能比HashSet低，迭代訪問集合中全部元素時性能高，

public class Example8_8 {
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
        hashSet.add("a");
        hashSet.add("null");
        hashSet.add("b");
        hashSet.add("c");
        hashSet.add("d");
        System.out.println("集合中的元素為:"+hashSet);
        hashSet.remove("b");
        System.out.println("集合中是否包含b元素:"+hashSet.contains("b"));
        Object[] objects = hashSet.toArray();
        System.out.print("陣列中的元素為:");
        for (Object o:objects){
            System.out.print(o);
        }
        hashSet.clear();
        System.out.println("\n"+"集合中是否不包含任何元素:"+hashSet.isEmpty());


        TreeSet treeSet = new TreeSet();
        TreeSet treeSet1 = new TreeSet();
        treeSet.add(10);
        treeSet.add(3);
        treeSet.add(8);
        treeSet.add(0);
        treeSet1.add("b");
        treeSet1.add("k");
        treeSet1.add("z");
        treeSet1.add("a");
        //輸出集合元素，看到集合已經處于排序狀態
        System.out.println("treeSet集合中的元素"+treeSet);
        System.out.println("treeSet1集合中的元素"+treeSet1);
        System.out.println("treeSet集合中的第一個元素："+treeSet.first()+",treeSet集合中的最后一個元素："+treeSet.last());
        System.out.println("treeSet1集合中的第一個元素："+treeSet1.first()+",treeSet1集合中的最后一個元素："+treeSet1.last());
        //回傳集合中小于５的集合，不包含５；
        System.out.println(treeSet.headSet(5));
        //回傳集合中小于c的集合
        System.out.println(treeSet1.headSet("c"));
        //回傳大于等于８的集合
        System.out.println(treeSet.tailSet(8));
        //回傳大于等于９，小于１１的集合
        System.out.println(treeSet.subSet(9,11));
    }
}

輸出結果：

集合中的元素為:[a, b, c, null, d]
集合中是否包含b元素:false
陣列中的元素為:acnulld
集合中是否不包含任何元素:true
treeSet集合中的元素[0, 3, 8, 10]
treeSet1集合中的元素[a, b, k, z]
treeSet集合中的第一個元素：0,treeSet集合中的最后一個元素：10
treeSet1集合中的第一個元素：a,treeSet1集合中的最后一個元素：z
[0, 3]
[a, b]
[8, 10]
[10]

5.3 Map

HashMap沒有按照鍵值大小輸出，如果需要對key-value進行插入、洗掉操作，優先使用HashMap;
TreeMap按照鍵值大小輸出,，針對需要排序的Map，優先使用TreeMap，

public class Example8_13 {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put(109, "PS");
        map.put(107, "c語言");
        map.put(108, "Js");
        map.put(99, "資料結構");
        map.put(99, "Java程式設計");//存在相同的key時，后插入的會被覆寫
        System.out.println(map);

        Map map1 = new HashMap<>();
        map1.put(1001, "Bill");
        map1.put(1001, "Bi");//存在相同的key時，后插入的會被覆寫
        System.out.println(map1);

        System.out.println(map.containsKey(99));
        for(Object o:map.keySet()){
            System.out.println(o+"-->"+map.get(o));
        }
        
        TreeMap treeMap = new TreeMap();
        treeMap.put(10,"a");
        treeMap.put(1,"a");
        treeMap.put(9,null);
        treeMap.put(5,"c");
        treeMap.put(3,null);
        System.out.println(treeMap);
        System.out.println(treeMap.lastKey());
        System.out.println(treeMap.headMap(2));
        System.out.println(treeMap.tailMap(2));
        TreeMap treeMap1 = new TreeMap(treeMap);
        System.out.println(treeMap1);
    }
}