Java基礎2小時速成(下篇) - 掌握核心技术「卷」

                                    本篇適用於
                          ----======================----
                              - 考前急用Java基礎人群 -
                             - Java基礎知識點速記人群 -
                            - 像我一樣很久沒看java人群 -
                          ----======================----
                          若無基礎看不懂請不要來責怪本篇教程

Java多態

有個小短篇 寫過 可以看一下這個: Java多態

java異常處理

程序在運行過程中 出現的非正常情況 最終會導致java虛擬機（jvm）的非正常停止

Try Catch Finally

package com.throwTest;

public class ExceptionTest {
    public static void main(String[] args) {
        try {
            int a = 10/0;
            System.out.println(a);
        } catch (Exception e) {
            System.out.println("異常為：" + e);
        } finally {
            int a = 3;
            System.out.println("a為：" + a);
        } 
    }
}

Throws Throw

throws 是方法可能拋出異常的聲明 表示該方法可能拋出異常
throw 是拋出異常的語句

public void doA(int A) throws Exception1,Exception3 {}

try {
    //...
} catch (Exception1 e) {
    throw e;
}

自定義異常

package com.throwTest;

import java.util.Scanner;

public class MyException extends Exception {
    public MyException() {
    }

    public MyException(String msg) {
        super(msg);
    }
}

class TestClass {
    public static void main(String[] args) throws MyException {
        System.out.println("請輸入年齡：");
        Scanner sc = new Scanner(System.in);
        int age = sc.nextInt();
        if (age < 0) {
            throw new MyException("年齡最小為0");
        }else {
            System.out.println("輸入年齡合法");
        }
    }
}

java常用類庫

String / StringBuffer / Random / Math / 包裝類

String

string类 是不可以变序列
String 不变的性质是因为每次都从 String池 里面取，如果有则直接用，否则创建新的放入

String類常見操作

char charAt(int index); // 返回指定索引位置的字符
String concat(String str); // 字符串拼接
boolean equals(Object anObject); // 將字符串與指定字符比較
int indexOf(char ch); // 返回字符在此字符串中第一次出現事的索引
int indexOf(String str, int fromIndex); // 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始搜索
boolean startsWith(String prefix); // 判断此字符串是否以指定的前缀开始
String replace(char oldChar, char newChar); // 将字符串中所有出现的指定旧字符 oldChar 替换为新字符 newChar
String replaceAll(String regex, String replacement); // 使用给定的替换字符串 replacement 替换此字符串中匹配给定正则表达式 regex 的每个子字符串，最终返回一个新的字符串，原字符串保持不变
char[] toCharArray(); // 將此字符串傳喚為一個新的字符數組
String trim(); // 返回字符串的副本 忽略前部和尾部的空白

StringBuffer類

String類 是不可變序列 為了方便修改字符串的內容 提供了 StringBuffer 類

class TestClass {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("helloworld");
        sb.append("!"); // helloworld!
        sb.insert(1, "1"); // h1elloworld
        sb.delete(1, 3); // 起始索引 到 結束索引(不包含結束索引)
        sb.reverse(); // 字符串反轉
        System.out.println(sb);
    }
}

Random類

Math 創建隨機數的類

• Random() 創建一個隨機數生成器
• Random(long seed) 使用單個long種子創建一個新的隨機數生成器

class TestClass {
    public static void main(String[] args) {
        Random rand = new Random();
        for (int i = 0; i < 10; i++) {
            System.out.println(rand.nextInt(100)); // [0 -> 99)
        }
    }
}

Math類

Math

• Math.random() 返回伪随机数，范围在 0.0 到 1.0 之间
• Math.abs(a) 絕對值
• Math.max(a, b) 返回两值中的较大值
• Math.min(a, b) 返回两个值中的较小值
• Math.pow(a, b) 返回a的b次方
• Math.sqrt(X) 計算平方根
• Math.cbrt(X) 計算立方根
• Math.ceil(X) 接近此數的大的整數的值
• Math.floor(X) 接近此數的小的整數的值
• Math.round(X) 四捨五入

class TestClass {
    public static void main(String[] args) {
        System.out.println(Math.random());
        System.out.println(Math.abs(-3.3));
        System.out.println(Math.sqrt(4));
        System.out.println(Math.cbrt(8));
        System.out.println(Math.pow(2, 3));
        System.out.println(Math.max(1, 2));
        System.out.println(Math.min(1, 2));
        System.out.println(Math.ceil(3.4));
        System.out.println(Math.floor(3.4));
        System.out.println(Math.round(3.5));
    }
}

包裝類

自動裝箱

自動裝箱即自動將基本數據類型轉換成包裝類型
java5 before ⬇️

Integer i1 = new Integer(8);
Integer i2 = Integer.valueOf(8); // int --> Integer

now ⬇️ 現在是自動裝箱 自動基本數據類型 --> 包裝類型轉換

Integer i1 = 8;

自動拆箱

自動拆箱即自動將包裝類型轉換成基本數據類型
java5 before ⬇️

Float i = 3.3;
float f = i.floatValue();

Integer i1 = 3;
int m = i1.intValue();

now ⬇️

Integer i = 3;
int i4 = i;

class TestClass {
    public static void main(String[] args) {
        // 自動裝箱
        Integer i = 3; // int型
        // 自動拆箱
        int m = i;

        System.out.println(m); // 3
    }
}

java常用類庫補充

System類.arraycopy()

/**
 * src 源數組
 * srcPos 源數組的起始位置
 * dest 目標數組
 * destPos 目標數組的起始位置
 * length 要複製的數組元素的個數
 */
System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length) // 從指定源數組中複製一個數組，複製從指定位置開始，到目標數組的指定位置結束

package com.futao;
public class InnerTest {
    public static void main(String[] args) {
        int[] a = new int[]{1, 2, 3, 4};
        int[] b = new int[7];

        System.arraycopy(a, 1, b, 0, 2);
        for (int i : b) {
            System.out.println(i); // 2 3 0 0 0 0 0
        }
    }
}

System類.currentTimeMillis()

// 返回以毫秒爲單位的當前時間
package com.futao;
public class InnerTest {
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis()); // 1970-01-01 - now
    }
}

System類.getProperties()

// 獲取系統的所有屬性
package com.futao;

import java.util.Properties;

public class InnerTest {
    public static void main(String[] args) {
        Properties prop = System.getProperties();
        System.out.println(prop);
        System.out.println(prop.getProperty("java.version"));
        System.out.println(prop.getProperty("os.name"));
    }
}

Runtime類

freeMemory() // 返回java虛擬機中空閒內存
totalMemory() // 返回java虛擬機中總內存
maxMemory() // 返回java虛擬機中可分配的最大內存

package com.futao;

public class InnerTest {
    public static void main(String[] args) {
        Runtime rt = Runtime.getRuntime();
        System.out.println(rt);
        System.out.println("虚拟机空闲内存:"+rt.freeMemory());
        System. out.println("虚拟机试图使用的最多空闲内存:"+rt.maxMemory());
        System.out.println("虚拟机的内存总量:"+rt.totalMemory());
    }
}

Date類

package com.futao;

import java.util.Date;

public class InnerTest {
    public static void main(String[] args) {
        Date d = new Date();
        System.out.println(d);
        System.out.println(d.getTime());
        System.out.println(d.getYear());
        System.out.println(d.getMonth());
        System.out.println(d.getDate());
    }
}

把Date轉化為 YYYY-MM-DD HH:mm:ss 格式 ⬇️

Simpledateformat

// 將Date轉換為指定的字符串 同時也可以指定的字符串轉換為Date對象
package com.futao;

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

public class InnerTest {
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = sdf.format(new Date());
        System.out.println(format); // 2025-03-18 21:16:41

        // 指定字符串轉化為Date對象
        String format1 = new String("2025-02-01 20:00:00");
        System.out.println(sdf.parse(format1)); // Sat Feb 01 20:00:00 CST 2025
    }
}

Calendar類

Calendar類（日曆🗓） 不能被new
Calendar類是抽象類，不能被實例化，通過getInstance()方法獲取實例

package com.futao;

import java.util.Calendar;

public class InnerTest {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.YEAR, 2018); // 設置 set
        System.out.println(calendar.get(Calendar.YEAR)); // 獲取 get
        System.out.println(calendar.get(Calendar.MONTH) + 1);
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));

        // 獲取當年的最大月數 或 最大天數 getActualMaximum()
        System.out.println(calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
    }
}

JDK8的日期與時間類

package com.futao;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;

public class InnerTest {
    public static void main(String[] args) {
        // 當前日期 yyyy-MM-dd
        LocalDate localDate1 = LocalDate.now();
        System.out.println(localDate1);
        // 創建一個日期
        LocalDate localDate2 = LocalDate.of(2018, 01, 01);
        System.out.println(localDate2);
        // 獲取指定時區的當前時間
        LocalDateTime localDateTime = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
        System.out.println(localDateTime);
        // 某年的第幾天的日期
        LocalDate localDate3 = LocalDate.ofYearDay(2018, 200);
        System.out.println(localDate3);
    }
}

java 內部類

內部類是在一個類的內部再定義一個類

• 成員內部類是最普通的內部類 它的定義位於一個類的內部
• 成員內部類可以無條件的訪問外部類所有的屬性和方法(包括private成員和靜態成員)

package com.futao;

public class InnerTest {
    private String name;

    class User {
        public void myPrint() {
            System.out.println("你好" + name);
        }
    }
}

如果外部類要訪問內部類成員,需要創建內部類對象

package com.futao;

public class InnerTest {
    private String name;

    class User {
        public void myPrint() {
            System.out.println("你好" + name);
        }
    }

    public static void main(String[] args) {

        // 步骤 1：创建外部类的实例
        InnerTest outer = new InnerTest();
        // 可以为外部类的成员变量赋值
        outer.name = "张三";

        // 步骤 2：通过外部类实例创建内部类的实例
        InnerTest.User inner = outer.new User();

        // 步骤 3：调用内部类的方法
        inner.myPrint();
    }
}

靜態內部類

# 靜態内部類不能使用外部類的非static成員變量或方法
package com.futao;

public class InnerTest {
    // private String name;
    private static String name;

    static class User {
        public void myPrint() {
            System.out.println("你好" + name); // 不加static name獲取不到
        }
    }
}

匿名内部類

一般用於監聽事件…

Java集合

set代表无序、不可重复的集合
List代表有序、重复集合
而Map则代表具有映射关系的集合

集合和數組都是容器 有什麼區別

• 數組的長度是固定的
• 集合的長度是可變的
• 數組中存儲的是同一類型的元素, 可以存儲的是基本數據類型
• 集合存儲的都是對象, 而且對象的類型可以不一致, 在開發中一般當對象多的時候, 使用集合進行存儲

Collection集合

所有單列集合的父接口都是 Collection, 單列集合(List/Set)是Collection的子類, 每次操作的時候都只能保存一個對象的數據

// 常用方法
public boolean add(E e); // 把給定的對象添加到當前集合中
public void clear(); // 清空集合中所有的元素
public boolean remove(E e); // 刪除當前集合中給定的對象
public boolean contains(E e); // 當前集合中是否包含給定的對象
public boolean isEmpty(); // 判斷當前集合是否為空
public int size(); // 返回當前集合的元素個數
public Object[] toArray(); // 把集合中的元素，存儲到數組中

List接口

繼承了Collection接口, 並且添加了特有方法

public void add(int index, E element); // 將指定的元素 添加到該集合指定的位置上
public E get(int index); // 返回集合中指定位置的元素
public E remove(int index); // 刪除指定位置的元素。 返回的是被移除的元素
public E set(int index, E element); // 用指定的元素代替集合中指定位置的元素，返回值更新前的元素

List子類有 ArrayList, LinkList, Vector

ArrayList

線程不安全 擁有 List 和 Collection 的所有方法, 默認長度為10

package com.futao;

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList al = new ArrayList();
        // 增加
        al.add(1);
        al.add("2");
        al.add(3.3);
        // 查看
//        System.out.println(al.get(0));
//        Iterator iterator = al.iterator();
//
//        while (iterator.hasNext()) {
//            System.out.println(iterator.next());
//        }

        // 修改
//        al.set(0, "SET");
//        Iterator iterator = al.iterator();
//        while (iterator.hasNext()) {
//            System.out.println(iterator.next());
//        }

        // 刪除
//        al.remove(0); // 刪除下標為0的元素
//        Iterator iterator = al.iterator();
//        while (iterator.hasNext()) {
//            System.out.println(iterator.next());
//        }

        // 返回長度
//        System.out.println(al.size());

        // 是否包含某一個元素
//        System.out.println(al.contains("2")); // true/false
    }
}

hashMap

Map集合存儲的是一個個的鍵值對數據 key value, key不可重複
Map<K, V>

void clear(); // 清空Map集合中的內容
boolean containsKey(Object key); // 判斷集合中是否存在指定的key
boolean containsValue(Object value); // 判斷集合中是否存在指定的value
Set<Map.Entry<K, V>> entrySet(); // 將Map接口變為Set集合
V get(Object key); // 根據key找到其對應的value
boolean isEmpty(); // 判斷是否為空
Set<K> keySet(); // 將全部的key變為Set集合
Collection<V> values(); // 將全部的value變為Collection集合
V put(K key, V value); // 向集合中增加內容
void putAll(Map<? extends K, ? extends V> m); // 增加一組集合
V remove(Object key); // 根據key刪除內容

// 示例
package com.futao;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class ArrayListTest {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("ZS", "張三");
        map.put("LS", "李四");
        map.put("WW", "王五");
        map.put("ZL", "趙六");
        map.put("SQ", "孫七");

        Set<String> keySet = map.keySet(); // 得到全部的key

        Iterator<String> iterator = keySet.iterator();

        while (iterator.hasNext()) {
            String key = iterator.next(); // 得到key
            System.out.println(key + ":" + map.get(key));
        }

//        for (String key : keySet) {
//            String value = map.get(key);
//            System.out.println(key + ":" + value);
//        }
    }
}

增刪改查

package com.futao;

import java.util.*;

public class ArrayListTest {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        // 增
        map.put("name", "張三");
        map.put("lover", "自己");
        // 查詢
        String lover = (String) map.get("lover");
        System.out.println(lover);

        // 查詢所有的key
        Set set = map.keySet();
        System.out.println(set);
        // 查詢所有value
        Collection values = map.values();
        System.out.println(values);

        // 遍歷所有的value
//        Collection values1 = map.values();
//        Iterator iterator = values1.iterator();
//        while (iterator.hasNext()) {
//            System.out.println(iterator.next());
//        }
        
        // 遍歷key value
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        Iterator<Map.Entry<String, String>> iterator = entrySet.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        // 修改
        map.put("name", "趙四");
        System.out.println(map);

        // 刪除
        map.remove("name");
        map.remove("lover", "自己");
        System.out.println(map);

        // 判斷是否為空
//        System.out.println(map.isEmpty());

        // 是否包含指定的key
//        System.out.println(map.containsKey("lover"));
    }
}

java 集合補充

LinedList

// 存儲的結構是鏈錶結構List裡面的方法都有 同時還有自己的特有方法

public void addFirst(E e): 將指定元素插入此列表的開頭
public void addLast(E e): 將指定元素插入此列表的結尾
public E getFirst(): 返回此列表的第一個元素
public E getLast(): 返回此列表的最后一個元素
public E removeFirst(): 刪除此列表的第一個元素
public E removeLast(): 刪除此列表的最后一個元素
public E pop(): 從此列表所表示的堆棧處彈出一個元素
public void push(E e): 將元素推入此列表所表示的堆棧
public boolean isEmpty(): 如果此列表不包含元素，則返回true

Iterator 接口

// 用來遍歷Collcection集合下的所有集合(List, Set. Map)...

public E next(): 返回迭代的下一個元素 同時指針下移
public E previous(): 返回迭代的上一個元素 同時指針上移
public boolean hasNext(): 如果還有元素則返回true

增強for循环: for(E e: list) {}

Set 接口

Set接口也是Collection接口的子接口, 與List接口最大的差異是Set接口不允許有重複的元素

無get方法

獲取方法⬇️
iterator迭代
toArray進行遍歷

HashSet

Set 的子類, 也無 get 方法, 也不允許重複 散列存放(順序不能保證)

獲取方法 ⬇️

iterator迭代
toArray進行遍歷

舉例⬇️
HashSet<String> set = new HashSet<>();
set.add("aaa");
set.add("bbb");
set.add("ccc");

Iterator<String> it = set.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

TreeSet 和 Comparable 接口

TreeSet 是有序的, 並且可以進行排序, 但是需要實現Comparable接口
自定義類實現對象排序 ⬇️

public class Person implements Comparable<Person> {
    private String name;
    private int age;

    public int compareTo(Person o) {
        if (this.age > o.age) {
            return 1;
        } else if (this.age < o.age) {
            return -1;
        } else {
            return 0;
        }
    }
}

Comparator比較器

將Comparator傳遞給sort方法(如: Collections.sort 或 Arrays.sort), 從而允許在排序順序上實現精確控制

排序方法 按照第一個單詞降序

Collections.sort(list, new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        return o2.charAt(0) - o1.charAt(0);
    }
})

HashMap

可以去看看 HashMap 增加過程

如果key相同 並且hashcode相同 那麼value會被覆蓋
如果key相同 但是hashcode不同 那麼value不會被覆蓋

TreeMap 和 LinkedHashMap

TreeMap(自動排序)的Map集合
LinkedHashMap 也是有序的 又有hashMao快速查找的優點

java多線程

Java中实现多线程的方式

package com.futao;

// 什麼是進程 什麼是線程
// 進程是一個應用程序(1個進程是一個軟體)
// 線程是一個進程中的執行場景/執行單元
// 一個進程可以啟動多個線程

// Java線程具有5種基本狀態
// 1. 新建狀態(New)：當線程對象創建後 即進入了新建狀態 如： Thread t = new Thread()；
// 2. 就緒狀態(Runnable)： 当调用线程对象的start（）方法(t. start（）;），线程即进入就绪状态。处于就绪状态的线程，只是说明此
//线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start（）此线程立即就会执行;
// 3. 运行状态(Running)：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；
// 4. 阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：
    // 4.1 等待阻塞：运行状态中的线程执行wait（）方法，使本线程进入到等待阻塞状态；
    // 4.2 同步阻塞--线程在获取synchronized同步锁失败（因为锁被其它线程所占用》，它会进入同步阻塞状态;
    // 4.3 其他阻塞--通过调用线程的sleep（）或join(）或发出了I/0请求时,线程会进入到阻塞状态。当sleep（）状态超时、join(）等待线程终止或者超时、或者I/0处理完毕时，线程重新转入就绪状态。
// 5. 死亡状态（Dead）：线程执行完了或者因异常退出了run（）方法，该线程结束生命周期。

public class Thread1 extends Thread {
    public void run() {
        for (int i=0; i<10; i++) {
            System.out.println(Thread.currentThread().getName() + "      i=" + i);
        }
    }
}

class Thread2 implements Runnable {
    @Override
    public void run() {
        try {
            // 睡眠
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        for (int i=10; i<20; i++) {
            System.out.println(Thread.currentThread().getName() + "      i=" + i);
        }
    }
}

class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        Thread1 t1 = new Thread1();
        t1.start();
        Thread t2 = new Thread(new Thread2());
        t2.start();
//        t2.join();
        System.out.println("Main thread started");
        for (int i=0; i<10; i++) {
            System.out.println("Main thread id=" + i);
        }
    }
}

API

sleep() // 使當前線程進入阻塞狀態， 在指定時間內不會執行，自動甦醒
wait() // 不會主動甦醒 需要另外的線程調用 notify() or notifyAll()方法喚醒
t.join() // 方法只會使主線程(或者說調用t.join()的線程)進入等待池並等待t线程执行完毕后才会被唤醒
interrupt() // 線程中斷，會拋出 InterruptedException
notify()/notifyAll() // 喚醒在某些條件下等待的線程

sleep()方法和wait()方法⬇️
相同點: 一旦執行方法以後 都會是當前進程進入阻塞狀態
不同點:
1. 方法聲明方式不同, sleep()是Thread類的方法, wait()是Object類的方法
2. 调用的条件不同，sleep可以在任何需要的场景下调用，wait必须使用在同步代码块或者同步方法中
3. 是否释放锁，sleep不会释放，wait会释放

Java文件IO

最重要的就是5个类和一个接口。5个类指的是File、0utputStream、InputStream、Writer、Reader;一个接口指的是Serializable.

• File(文件特征与管理)：用于文件或者目录的描述信息，例如生成新目录，修改文件名，删除文件，判断文件所在路径等
• OutputStream(二進制格式操作 输出流)：抽象類 用于向文件写入字节，例如将字节数组写入文件，将字符串写入文件等
• InputStream(二進制格式操作 输入流)：抽象類 用于从文件读取字节，例如将文件读取为字节数组，将文件读取为字符串等
• Writer(文件格式操作 字符输出流)：抽象類 用于向文件写入字符，例如将字符数组写入文件，将字符串写入文件等
• Reader(文件格式操作 字符输入流)：抽象類 用于从文件读取字符，例如将文件读取为字符数组，将文件读取为字符串等

IO流分類

• 根據處理數據類型不同分為: 字符流和字節流
• 字符流的由来：Java中字符是采用Unicode标准，即一个字符使用两个字节来表示，本质其实就是基于字节流读取时根据数据流向不同分为：输入流和输出流

Reader & Writer

Reader和Writer是转么用来读取字符的，避免了很多的字符乱码问题，读取字符十分的方便。但是不能像InputStream和OutputStream用于
读取图片，视频等，只能用于读取字符

package com.futao;

import java.io.*;

public class JavaIoTest {
    public static void main(String[] args) throws IOException {
        // Reader Writer
        Reader reader = new FileReader("C:/Users/FuTao/Desktop/a.txt");
        Writer writer = new FileWriter("C:/Users/FuTao/Desktop/b.txt", true); //  _ ,true 如果文件有數據 那麼在尾部追加
        char[] buf = new char[1024]; // 定義字符數組 用來讀取
        int len = 0; // 定義最大讀取長度
        while ((len = reader.read(buf)) != -1) { // 當文件讀取到末尾的時候 長度是 = -1的
            writer.write(buf, 0, len);
            writer.flush(); // 在內存中的數據寫入到文件中
        }
        reader.close();
        writer.close();
    }
}

OutputStream & InputStream

InputStream字节输入流为抽象接口，不能直接创建对象，可以通过其子类FileInputStream来创建对象

InputStream is = new FileInputStream("C:/Users/FuTao/Desktop/a.txt");

OutputStream字节输出流为抽象接口，不能直接创建对象，可以通过其子类FileOutputStream来创建对象

OutputStream os = new FileOutputStream("C:/Users/FuTao/Desktop/a.txt");

package com.futao;

import java.io.*;

public class JavaIoTest {
    public static void main(String[] args) throws IOException {
        // InputStream OutputStream
        InputStream is = new FileInputStream("C:/Users/ZhuanZ/Desktop/a.txt");
        OutputStream os = new FileOutputStream("C:/Users/ZhuanZ/Desktop/b.txt");
        byte[] buffer = new byte[1024];
        int length = 0; // 指定最大寫入字節數
        while ((length = is.read(buffer)) != -1) {
            os.write(buffer, 0, length);
            os.flush();
        }
        is.close();
        os.close();
    }
}

File類方法

創建 : File file = new File("C:/Users/FuTao/Desktop/a.txt");

1) public boolean exists() // 判斷文件是否存在
2) public boolean isFile() // 判斷文件是否是文件
3) public boolean isDirectory() // 判斷文件是否是目錄
4) public String getName() // 獲取文件名
5) public String getPuth()   // 獲取文件路徑
6) public long length() // 獲取文件長度
7) public String[] list() // 獲取文件下所有文件名

File類中還定義了一些對文件或目錄進行管理,操作的方法,常用方法有
1) public boolean renameTo(File newFile) // 重命名文件
2) public boolean delete() // 删除文件
3) public boolean mkdir() // 创建文件目录

package com.futao;

import java.io.*;

public class JavaIoTest {
    public static void main(String[] args) throws IOException {
        // File
        File file = new File("C:/Users/ZhuanZ/Desktop/a.txt");
        System.out.println(file.isFile()); // true / false
        System.out.println(file.length()); // N / 0
    }
}