JAVA核心編程教學

經常使用類

Ø 1.1 String和StringBuffer

String類封裝了對字符串的常見操做，使用頻率很是高，因此應該熟練掌握，

String類的方法比較多，無需死記硬背，而是大概瞭解，用的時候不清楚再查手冊，

有些東西用多了，就熟練了

 

String類經常使用方法：

length; indexOf; charAt; equals; replace; split; substring; trim; formate

 

String類的賦值：

int a = 5;
a = 3;

上面代碼含義：在內存裏申請一個內存單元，命名爲a，賦值爲3（將3存儲在該內存單元上），再次賦值a爲5（再把5存儲在該內存單元上），這個內存單元的值在被賦值後修改了

 

String str1 = "abc";
str1 = "123";

應該這樣理解：

String str1 = new String("abc");
str1 = new String("123");

因此對於引用來說，賦值並不是改變原引用對象的值，只是調整了引用關係

那麼對於 == 運算符就要特別注意了

String str1 = new String("abc");
String str2 = new String("abc");
System.out.println(str1 == str2);           //地址
System.out.println(str1.equals(str2)); //內容

運行結果

false

true

Str1和str2引用的是不一樣對象，因此str1 == str2爲假

Str1和str2引用的字符串內容相同，因此tr1.equals(str2)爲真

 

public static void main(String[] args) {
    String str1 = "abc";
    change(str1);
}
/**
 * 將字符串中的b替換爲B
 * @param str1 字符串
 */
private static void change(String str1) {
    str1.replace("b","B");
    System.out.println(str1);
}

運行結果

abc

字符串並無被修改，注意String類定義的字符串是不可更改的，此時須要用到StringBuffer類

public static void main(String[] args) {
    String str1 = "abc";
    change1(str1);
    System.out.println(str1);

    StringBuffer str2 = new StringBuffer("abc");
    change2(str2);
    System.out.println(str2);
}
/**
 * 將字符串中追加一個字符
 * @param str1 字符串
 */
private static void change1(String str1) {
    str1 += "123";
}
/**
 * 將字符串中追加一個字符
 * @param str2 字符串
 * @return
 */
private static void change2(StringBuffer str2) {
    str2.append("123");
}

運行結果

abc

abc123

StringBuffer類經常使用方法：

append、insert、deleteCharAt、delete、replace、setCharAt、reverse

 

 

Ø 1.2 Array數組類

public static void main(String[] args) {
    int [] a = {1,7,3,99,16,4};
    System.out.println(Arrays.toString(a));

    int[] array1 = {2, 1, 3};
    int[] array2 = {2, 1, 3};
    int n1 = array1.length;//數組長度
    int n2 = array2.length;
    System.out.println(compareArray(n1,n2,array1,array2));

    System.out.println(Arrays.equals(array1,array2));//判斷數組是否同樣
    System.out.println(Arrays.toString(array1));//打印數組字符串形式

    Arrays.sort(array1);//將數組進行升序排序
    System.out.println(Arrays.toString(array1));

    int [] array3 = Arrays.copyOf(array1,array1.length+1);//複製一個數組
    System.out.println(Arrays.toString(array3));

    Arrays.fill(array3,2);//填充
    System.out.println(Arrays.toString(array3));

    Arrays.binarySearch(array3,2);//折半查找，只能用於有序數組
}
/**
 *
 * @param n1 array1長度
 * @param n2 array2長度
 * @param array1 數組array1
 * @param array2 數組array2
 * @return array1array2是否徹底相同相等
 */
private static boolean compareArray(int n1, int n2, int[] array1, int[] array2) {
    boolean flag =true;
    if (n1==n2) {
        for (int i = 0;i<n1;i++) {
            if(array1[i]!=array2[i]){
                flag=false;
                break;
            }
        }
    }else {
        flag=false;
    }
    return flag;
}

Ø 1.3 Math函數

主要提供數學相關的常量和方法，方法都是靜態的

常量E，PI（π）

方法：abs;ceil;floor;round;max;min;exp;log;pow;sqrt;random;三角函數

public static void main(String[] args) {
    int a = 3;
    int b = 4;
    int c = 7;
    System.out.println(Math.sqrt(a*a + b*b));   //開根
    System.out.println(Math.random());          //0--1間的隨機值
    System.out.println(c/b);                    //向下取整
    System.out.println(Math.max(Math.max(a,b),c));//最大值
    System.out.println(Math.min(Math.min(a,b),c));//最小值
}

Ø 1.4 日期類

v Date

public static void main(String[] args) {
    Date d1 = new Date();   //當前時間（new的那一刻）
    System.out.println(d1);

    long n = d1.getTime();  //獲取自1970-1-1至當前經歷的毫秒數(1秒=1000毫秒
    System.out.println(n);
    n += 1000000;
    Date d2 = new Date(n);
    System.out.println(d2);

    System.out.println(new Date(0));//1970-1-1東8區8時
}

 

Date d = new Date();
DateFormat df1 = DateFormat.getDateInstance(DateFormat.LONG);
System.out.println(df1.format(d));
DateFormat df2 = DateFormat.getDateInstance(DateFormat.SHORT);
System.out.println(df2.format(d));

DateFormat df3 = DateFormat.getDateTimeInstance();
System.out.println(df3.format(d));

運行結果

LONG2017年12月15日

SHORT2017/12/15

GetDateTime2017年12月15日 下午2:47:11

 

 

SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
System.out.println(sdf1.format(d));
SimpleDateFormat sdf2 = new SimpleDateFormat("yy年MM月");
System.out.println(sdf2.format(d));
SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd hh:mm");
System.out.println(sdf3.format(d));

運行結果

"yyyy-MM-dd" 2017-12-15

"yy年MM月" 17年12月

"yyyy-MM-dd hh:mm" 2017-12-15 02:56

v Calendar

public static void main(String[] args) {
    Calendar c = Calendar.getInstance();
    System.out.println(c);                               //全部時間及相關信息
    System.out.println(c.get(Calendar.YEAR));            //年
    System.out.println(c.get(Calendar.MONTH) +1);        //月（外國0開始）
    System.out.println(c.get(Calendar.DAY_OF_WEEK) - 1); //星期幾（外國7開始）
    System.out.println(c.get(Calendar.DATE));            //日
    System.out.println("P.M."+c.get(Calendar.HOUR));     //時AMPM
    System.out.println(c.get(Calendar.HOUR_OF_DAY));     //時24
    System.out.println(c.get(Calendar.MINUTE));          //分
    System.out.println(c.get(Calendar.SECOND));          //秒
}

 

c.set(2017,Calendar.NOVEMBER,1);                  //設置年月日2017-11-1
//c.set(Calendar.YEAR,2017);c.set(Calendar.MONTH,11);c.set(Calendar.DAY_OF_MONTH,1);
c.add(Calendar.DAY_OF_MONTH,-1);                  //日期-1
System.out.println(c.get(Calendar.DAY_OF_MONTH)); //獲得2017-10月天數

 

 

 

 

 

Ø 1.5 包裝類

JAVA中提供的基本類型（int short byte long float double）等，都有對應的包裝類

例如：

int →Integer

float →Float

...

爲何須要包裝類

基本類型的處理和其它類型的處理是有不一樣的

例如：

int a = 3;

int b = 5;

a = b;

...

這種修改是直接改變了變量的值，準確的講是存放的3個內存單元被修改了

案例：以前的泛型的通用數組

 

此處只能用Integer，不能用int

不少地方爲了統一，尤爲是用到泛型的地方，系統提供了基本類型對應的封裝類

裝箱：基本類型→包裝類

拆箱：

 

 

 

 

集合框架

Ø 2.1 Vector

Vector（向量 ）就是動態數組

爲何須要動態數組？不少時候，咱們沒法事先預約數組元素個數，若是使用靜態化數組，小了不夠用，大了浪費空間，這時候須要動態數組

v 添加

package 教學.C103_11_Vector;
import java.util.Vector;
public class case1_添加 {
    public static void main(String[] args) {
        Vector<Integer> x1 = new Vector<>();
        System.out.println("Vector默認容量"+x1.capacity());
        System.out.println("Vector初始元素個數"+x1.size());
        x1.add(1);
        x1.add(2);
        x1.add(3);
        x1.add(4);
        x1.add(5);
        x1.add(6);
        x1.add(7);
        x1.add(8);
        x1.add(9);
        x1.add(10);
        x1.add(11);
        System.out.println("添加11個元素後，Vector默認容量"+x1.capacity());
        System.out.println("添加11個元素後，Vector初始元素個數"+x1.size());

System.out.println(x1);
    }
}

Vector默認容量10

Vector初始元素個數0

添加11個元素後，Vector默認容量20

添加11個元素後，Vector初始元素個數11

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

size：元素個數

capacity：容量

add：在尾部添加元素

v 刪除

package 教學.C103_11_Vector;

import java.util.Vector;

public class case2_刪除 {
    public static void main(String[] args) {
        Integer a1 = new Integer(11);
        Integer a2 = new Integer(22);
        Integer a3 = new Integer(33);
        Integer a4 = new Integer(44);
        Integer a5 = new Integer(55);

        Vector<Integer> v1 = new Vector<>(4,2);
        v1.add(a1);
        v1.add(a2);
        v1.add(a3);
        v1.add(a4);
        v1.add(a5);
        System.out.println("容量："+v1.capacity());
        System.out.println("個數："+v1.size());
        System.out.println("（數組）向量："+v1);

        v1.remove(2);//刪除下標爲2的元素
        v1.remove(a1);//刪除a1元素
        System.out.println("容量："+v1.capacity());
        System.out.println("個數："+v1.size());
        System.out.println("（數組）向量："+v1);

        v1.trimToSize();//修剪;按照現有的元素個數調整容量，元素個數=容量大小
        System.out.println("容量："+v1.capacity());
    }
}

方法

remove(int index)刪除指定位置的元素

remove(Object obj)刪除指定元素

trimToSize()調整容量大小

 

 

v 修改

package 教學.C103_11_Vector;
import java.util.Vector;
public class case3_修改 {
    public static void main(String[] args) {
        Integer a1 = new Integer(11);
        Integer a2 = new Integer(22);
        Integer a3 = new Integer(33);
        Integer a4 = new Integer(44);
        Integer a5 = new Integer(55);
        Vector<Integer> v1 = new Vector<>(4,2);
        v1.add(a1);
        v1.add(a2);
        v1.add(a3);
        v1.add(a4);
        v1.add(a5);
        System.out.println(v1.get(3));//找出下標爲3的元素
        v1.set(3,99);//把下標爲3的元素替換爲其它值
        System.out.println(v1);
        System.out.println(v1.contains(a2));//數組是否包含a2元素，返回boolean
        System.out.println(v1.contains(22));//數組是否包含值爲22的元素，返回boolean
        System.out.println(v1.indexOf(0));//返回數組內值爲33的下標，沒有的話返回-1
        System.out.println(v1.firstElement());//得到數組第一個元素值
    }
}

輸出結果

44

[11, 22, 33, 99, 55]

true

true

-1

11

方法

contains()

indexOf()

firstElement()

get(int index)

set(int index,Object obj)

 

 

 

Ø 2.2 Stack堆棧

接口public class Stack<E>

繼承自extends Vector<E>

 

堆棧

 

在計算機領域，堆棧是一個不容忽視的概念，堆棧是兩種數據結構

堆棧都是一種數據項按序排列的數據結構，只能在一端(稱爲棧頂(top))對數據項進行插入和刪除

在單片機應用中，堆棧是個特殊的存儲區，主要功能是暫時存放數據和地址，一般用來保護斷點和現場

要點：堆，隊列優先,先進先出（FIFO—first in first out）;棧，先進後出(FILO—First-In/Last-Out)

中文名 堆棧

外文名  stack

領域 計算機

定義 數據結構

功能 對數據項進行插入和刪除

 

package 教學.C103_12_Stack堆棧;
import java.util.Stack;
public class case1 {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.push(11);
        stack.push(22);
        stack.push(33);
        System.out.println(stack);
        System.out.println(stack.peek());//獲得棧頂元素
        System.out.println(stack);
        System.out.println(stack.pop());//移除棧頂元素
        System.out.println(stack);
    }
}

方法

push() 表示元素壓入棧頂

pop() 移除棧頂元素

peek() 讀取棧頂元素

 

 

 

Ø 2.3Interface List

List是一個接口‘public interface List<E>’，繼承自Collection ‘extends Collection<E>’

 

它提供了一個集合數據的增刪改查等基本操做，上面講的Vector和Stack都實現了這個接口，這裏再介紹它的一個實現類--ArrayList

 

ArrayList類的用法與Vector很是類似

package 教學.C103_13_List;
import java.util.ArrayList;
import java.util.List;
public class case1 {
    public static void main(String[] args) {
        List<Double> list = new ArrayList<>();
        list.add(11.1);
        list.add(22.1);
        list.add(33.1);
        list.add(44.1);
        System.out.println(list);
        list.set(2,99.1);//改變下標爲2的元素的值
        System.out.println(list);
        list.remove(1);//刪除下標爲1的元素
        System.out.println(list);
    }
}

輸出結果

[11.1, 22.1, 33.1, 44.1]

[11.1, 22.1, 99.1, 44.1]

[11.1, 99.1, 44.1]

方法

list.add

list.set

list.remove

 

Ø 2.4 ForEach

package 教學.C103_14_ForEach;

import java.util.ArrayList;
import java.util.List;
public class case1 {
    public static void main(String[] args) {
        List<Double> list = new ArrayList<>();
        list.add(11.1);
        list.add(22.1);
        list.add(33.1);
        list.add(44.1);
        for(int i=0;i<list.size();i++){
            System.out.printf("%6.2f",list.get(i));
        }
        System.out.println();
        for(Double d:list){
            System.out.printf("%6.2f",d);
        }
    }
}

輸出結果

 11.10 22.10 33.10 44.10

 11.10 22.10 33.10 44.10

從代碼中能夠看出forEach循環比基本的for循環更簡潔，但它只適用於集合相關類

 

for(Double d:list)的含義：d依次引用到List中每個元素

 

 

 

Ø 2.5 Set

Set接口表示無重複元素的集合

import java.util.HashSet;
import java.util.Set;
public class case1 {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        set.add(11);
        set.add(12);
        set.add(13);
        set.add(12);
        System.out.println(set);
    }
}

輸出結果

[11, 12, 13]

 

從結果能夠看出，最後一次添加12沒有成功執行，由於12以前已經有了

 

所謂的重複，指的是e1.equals(e2);true;

先判斷HashCode，再判斷是否equals

 

 

Ø 2.6 Map映射函數

Map是以鍵值對（Key，Vaule）的形式存取數據

package 教學.C103_16_Map;

import java.util.HashMap;
import java.util.Map;

public class case1 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();
        map.put("num1",11);//存儲‘對象’和‘對象關鍵字’
        map.put("num2",22);
        map.put("num3",33);
        map.put("num4",44);

        Integer x = map.get("num3");//經過‘關鍵字’獲得‘對象’
        System.out.println(x);
    }
}

輸出結果

33

方法

map.put()

map.get()

 

 

 

Ø 2.7 Iterator迭代器

Iterator迭代器：相似於C語言中鏈表的指針

p = p → next

 

package 教學.C103_17_Iterator迭代器;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class case2 {
    public static void main(String[] args) {
        List<Double> list = new ArrayList<>();
        list.add(11.1);
        list.add(22.1);
        list.add(33.1);
        list.add(44.1);

        Iterator<Double> iterator = list.iterator();
        while (iterator.hasNext()){
            Double d = iterator.next();
            System.out.println(d);
        }

    }
}

輸出結果

11.1

22.1

33.1

44.1

 

 

Ø 2.8 Collections工具類

package 教學.C103_18_Collections工具類;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class case1 {
    public static void main(String[] args) {
        List<Double> list = new ArrayList<>();
        list.add(22.1);
        list.add(11.1);
        list.add(44.1);
        list.add(33.1);
        System.out.println(list);
        Collections.reverse(list);//降序;倒序;逆序
        System.out.println(list);
        Collections.sort(list);//排序
        System.out.println(list);
        Collections.shuffle(list);//亂序
        System.out.println(list);
        System.out.println(Collections.max(list));//最大值
    }
}

輸出結果

[22.1, 11.1, 44.1, 33.1]

[33.1, 44.1, 11.1, 22.1]

[11.1, 22.1, 33.1, 44.1]

[11.1, 33.1, 44.1, 22.1]

44.1

 

 

IO

Ø 3.1 流的概念

應用程序和設備（主要是CPU）之間常常須要傳輸數據，java爲了屏蔽硬件細節，簡化開發流程，將這種傳輸封裝成流的概念

 

流有兩種：字符流/字節流

字節流 把傳輸的數據當作是沒有特定含義的二進制數據

字符流 把數據當作字符

 

 

Ø 3.2 字節流

InputStream

InputStream提供了字節流的封裝，它是一個抽象類

public abstract class InputStream

extends Object

implements Closeable

 

Direct Known Subclasses: 子類

AudioInputStream, ByteArrayInputStream, FileInputStream, FilterInputStream, InputStream, ObjectInputStream, PipedInputStream, SequenceInputStream, StringBufferInputStream

經過子類的命名前綴能夠看出該類是幹嗎的

Constructor Summary

Constructors  Constructor and Description

InputStream()  

v FileInputStream讀取

public class FileInputStream

extends InputStream

package 教學.C103_21_字節流;
import java.io.FileInputStream;

public class Test1_Input {
    public static void main(String[] args) throws Exception {
       FileInputStream fis = new FileInputStream("C:\\Users\\my\\IdeaProjects\\C103_JAVA核心編程\\src\\教學\\C103_21_字節流\\Student");
       int ch;
       while (true){
           ch = fis.read();
           if(-1 == ch){
               break;
           }
           System.out.println((char)ch);
       }
       fis.close();
    }
}

v FileOutputStream輸出

數據持久化，把數據存到硬盤/數據庫中

 

FileOutputStream，意爲文件輸出流，是用於將數據寫入File或 FileDescriptor的輸出流。

中文名 文件輸出流

外文名 FileOutputStream

定義 java.lang.Object

經常使用方法 返回與此流有關的文件描述符

實現的接口 Closeable, Flushable

package 教學.C103_21_字節流;
        import java.io.FileOutputStream;

public class Test2_Output {
    public static void main(String[] args) throws Exception {
        FileOutputStream fis = new FileOutputStream("C:\\Users\\my\\IdeaProjects\\C103_JAVA核心編程\\src\\教學\\C103_21_字節流\\Student");
        for(int n=1;n<=10;n++){
            fis.write(n);
        }
        fis.close();
    }
}

 

文件路徑字符串要特別注意

"E:\xt.txt"是錯誤的路徑，由於Java會將其中的「\t」理解成轉義字符，因此正確的表示方式是「E:/xt.txt」或「E:\ \xt.txt」

此時輸出的文件若是用記事本等工具打開，極可能是顯示亂七八糟的東西，由於記事本打開文件是要將其中的數據理解成字符，顯然有些數據是沒有對應的可顯示字符

能夠藉助十六進制編輯器等工具（好比winHex）來打開文件，以十六進制形式來顯示文件內容

 

 

package 教學.C103_21_字節流;

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class case1 {
    public static void main(String[] args) throws Exception {//調用main函數拋出全部異常
        FileInputStream   fis = new FileInputStream  ("C:\\Users\\my\\Documents\\Music\\大谷和夫 - M-23.mp3");//位置讀取文件
        FileOutputStream  fos = new FileOutputStream ("C:\\Users\\my\\Music\\大谷和夫 - M-23.mp3");//位置輸出文件
        int music;
        while (true){//邊讀邊寫（循環）
            music = fis.read();//讀取
            if(-1 == music){ break; }//讀完結束
            fos.write(music);//輸出
        }
        fis.close();//關閉讀取文件
    }
}

 

 

Ø 3.3 字符流

提供了兩個頂級父類

Class Reader

java.lang.Object

java.io.Reader

讀取字符流的抽象類；這一類必須實現的惟一方法是讀（char []，int，int）和（）；然而，大多數子類將覆蓋這裏定義的一些方法，以便提供更高的效率、附加功能或二者

 

子類

BufferedReader, LineNumberReader, CharArrayReader, InputStreamReader, FileReader, FilterReader, PushbackReader, PipedReader, StringReader

 

Class Writer

java.lang.Object

java.io.Writer

用於字符流寫入的抽象類；這一類必須實現的惟一方法是寫（char []，int，int），flush()，和（）；然而，大多數子類將覆蓋這裏定義的一些方法，以便提供更高的效率、附加功能或二者

 

子類

Writer, BufferedWriter, CharArrayWriter, FilterWriter, OutputStreamWriter, FileWriter, PipedWriter, PrintWriter, StringWriter

 

常見IO類繼承關係圖

箭頭表示：子類—-〉父類

字節流：（讀取單位爲byte）

 

字符流：（讀取單位爲char）

 

字符流和字節流的區別：

 

字節流就是按照byte單位來讀取，能夠用來讀取其餘格式的文件

字符流是在字節流的基礎上實現的，用來讀取文本文件，一個字符一個字符的讀取

若是字節流是一滴水一滴水的轉移，那麼字符流是用勺子一勺一勺水的轉移，速度明顯加快

固然使用緩衝Buffer之後，就是一桶一桶水的轉移了

一個字節佔8位，java採用unicode編碼，佔兩個字節，即16位，也就是java一個字符是2byte，16位，

那麼在文本copy的時候，用字節流就是一byte-byte的copy，字符流就是一個字符一個字符的copy

 

 

 

v FileWriter

package 教學.C103_22_字符流.FileWriter;

import java.io.FileWriter;

public class case1 {
    public static void main(String[] args)  throws Exception{
        FileWriter fileWriter = new FileWriter("C:\\Users\\my\\IdeaProjects\\C103_JAVA核心編程\\src\\教學\\C103_22_字符流\\FileWrite\\Demo");
        fileWriter.write("...");
        //fileWriter.flush();//刷新緩衝區
        fileWriter.close();//關閉位置文件，執行前會調用flush
    }
}

write():往 流 裏寫內容

flush():刷新緩衝區

close():關閉此流，但要先刷新它(緩衝區)，執行前會調用flush

每次往裏面寫東西時，會覆蓋原有的內容

fileWriter.close();//關閉位置文件，執行前會調用flush
fileWriter.write("...");

Exception in thread "main" java.io.IOException: Stream closed

執行close後不能再寫入，不然會報錯IOException

 

Windows操做系統下

fileWriter.write("a\r\n"+"b\r\n"+"c\r\n"); //輸出文件內換行

fileWriter.write("a\t"+"b\t"+"c\t"); //輸出文件內空格

系統通用換行方法

System.getProperty("line.separator");

 

 

 

 

 

 

 

 

 

 

 

v FileReader

package 教學.C103_22_字符流.FileReader;

import java.io.FileReader;

public class case1 {
    public static void main(String[] args) throws Exception {
        FileReader fileReader = new FileReader("C:\\Users\\my\\IdeaProjects\\C103_JAVA核心編程\\src\\教學\\C103_22_字符流\\FileReader\\Demo");
        //while (true){
        //    int num = fileReader.read();
        //    if (num == -1){break;}
        //    System.out.println((char)num);
        //}
        int num;
        while ((num = fileReader.read())!=-1){
            System.out.println((char)num);
        }
        fileReader.close();
    }
}

 

 

public static void main(String[] args) throws Exception {
    FileReader fileReader = new FileReader("C:\\Users\\my\\IdeaProjects\\C103_JAVA核心編程\\src\\教學\\C103_22_字符流\\FileReader\\Demo");
    char [] EnglishLetter = new char[26];
    fileReader.read(EnglishLetter,0,10);//一次讀取26個英文字母前10個
    fileReader.close();
    System.out.println(EnglishLetter);
}

 

                            

                     

 

Ø 3.4 緩衝區

v BufferedWriter

 

package 教學.C103_23_緩衝區.BufferedWriter;

import java.io.BufferedWriter;
import java.io.FileWriter;

public class case1 {
    public static void main(String[] args) throws Exception{
        FileWriter fileWriter = new FileWriter("C:\\Users\\my\\IdeaProjects\\C103_JAVA核心編程\\src\\教學\\C103_23_緩衝區\\BufferedWriter\\Demo");
        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
        bufferedWriter.write("abc");
        bufferedWriter.newLine();//換行
        bufferedWriter.write("123");
        bufferedWriter.flush();//刷新緩衝區
        bufferedWriter.close();
        //fileWriter.close();
    }
}

 

Ø 3.5 File類

字節流和字符流能夠實現對文檔內容的操做，可是對於文件屬性就無能爲力。

屬性包括：文件名、類型、最後一次修改時間、存儲路徑、文件大小

 

- 什麼是File對象?

1) 用來將文件或者文件夾封裝成對象

2) 方便對文件夾或文件屬性信息進行操做

3) File對象做爲參數傳遞給 流 的構造方法（構造方法摘要FileWriter(File file)）

 

- File對象的建立

package 教學.C103_24_File;
import java.io.File;

public class case1 {
    public static void main(String[] args) {
        creatFile();
    }
    private static void creatFile() {
        File file1 = new File("C:\\a1.txt");

        File file2 = new File("C:\\","a2.txt");

        File file3 = new File("C:\\");
        File file4 = new File(file3,"a3.txt");

        File file5 = new File("C:\\"+File.separator+"a4.txt");
        System.out.println(file5);

        File file6 = new File("C:\\Users\\my\\Documents\\Music\\大谷和夫 - M-23.mp3");
        System.out.println(file6.getName());
    }
}

輸出結果

C:\a4.txt

大谷和夫 - M-23.mp3

 

 

 

- File的經常使用方法

1) 獲取相關（名稱;路徑;大小;最後修改）

2) 建立刪除（文件;文件夾;重命名）

3) 判斷類（判斷是否文件夾;判斷是路徑仍是文件;判斷是否存在;判斷是否隱藏）

//獲取相關 名稱;路徑;大小;最後修改

public class case1 {
    public static void main(String[] args) {
        getInfo();//演示獲取
    }
private static void getInfo() {
    File file = new File("C:\\Users\\my\\Documents\\Music\\大谷和夫 - M-5.mp3");
    System.out.println(file.getName());//名稱
    System.out.println("-----------------------------------------------------------------");
    System.out.println(file.getAbsolutePath());//絕對路徑
    System.out.println("-----------------------------------------------------------------");
    System.out.println(file.length());//文件大小
    System.out.println("-----------------------------------------------------------------");
    System.out.println(file.lastModified());//最後修改 時間戳 1970-01-01-00:00至最後修改時間中間的毫秒數
    System.out.println("-----------------------------------------------------------------");
    Date date = new Date(file.lastModified());
    System.out.println(date);

大谷和夫 - M-5.mp3

-----------------------------------------------------------------

C:\Users\my\Documents\Music\大谷和夫 - M-5.mp3

-----------------------------------------------------------------

4898568

-----------------------------------------------------------------

1509526598083

-----------------------------------------------------------------

Wed Nov 01 16:56:38 CST 2017