【Java基础】全网最详细 - 从入门到转行

public class HelloWorld { // 类名必须与文件名相同
  public static viod main(string[] args) { // main方法为程序入口
    system.out.println("Hello World"); // Java的每个输出与条件语句后面必须带;结束字段
  }
}

Hello World

type * = *;

int num = 1;
float f1 = 1.22f;
boolean b1 = true;

byte numA = 100;
short numB = 1000;
int numC = 100000; 
long numD = 100000L;

float fA = 1.1f;
double fB = 1.2;

char cA = 'a';

class Person {}
class People {}
public class OObject {
  public static void main(String[] args) {
    Object object = new Person();
  }
}

// toString(); 这是一个很常用的方法，该方法是为了获取对象的信息（返回对象的字符串表示形式）

// 数组的基本使用
int[] arr = new int[3];
以上这段话的意思是： 声明一个名称为arr的数组，类型为int型，并且长度最多为3.
在输入时[3]称之为数组的动态初始化.
// 为数组下标位置赋值
在这里讲一句： 下方arr[0,1,2] 中的 0， 1， 2为数组的索引，从0开始.
比如：new int[5]； 它的索引为：0， 1， 2， 3， 4， 长度为5.
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
// 数组的静态初始化
int[] arr = new int[]{5,7,8};
或者
int[] arr = {5,7,8};
静态初始化: 提前写好数据，{}内部的元素为数组元素

String[] arr = new String[]{"1","2","3"};
system.out.println(arr.length); // 3

public class Demo {
  public static void main(String[] args) {
    int a = 1;
    int b = 2;
    System.out.println(a + b); // 3
    System.out.println(a \ b); // 0.5
    System.out.println(a - b); // -1
    System.out.println(a * b); // 2
    System.out.println(a++); // 2
    System.out.println(a--); // 0
  }
}

前缀不带修饰符
String version = "0.0.1";
boolean processOrder() {  
  return true;
}

public class Logger {
  // 对于某些敏感数据的获取以及赋值，需要用到private修饰符
  private String format;
  // 其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量，定义了两个 public 方法
  public String getFormat() { // getFormat() （返回 format的值）
        return this.format;
  }
  public void setFormat(String format) {// setFormat(String)（设置 format 的值）
    this.format = format;
  }
}

// Java 程序的 main() 方法必须设置成公有的，否则，Java 解释器将不能运行该类
public static void main(String[] arguments) {
    ...
}

下面的父类使用了 protected 访问修饰符，子类重载了父类的 openSpeaker() 方法
class AudioPlayer {   
  protected boolean openSpeaker(Speaker sp) { 
      // 实现细节   
  }
} 
class StreamingAudioPlayer {
  boolean openSpeaker(Speaker sp) {
      // 实现细节   
  }
}

static表示“静态的”，它也是一种修饰符，可以修饰属性、方法、代码块和内部类.
static修饰成员变量，表示该成员变量只在内存中存储一份，可以被访问，修改(共享).
static修饰的成员变量，归属于类.
被static修饰的属性(成员变量)称为静态变量，也叫做类变量.
被static修饰的常量称为静态常量.
被static修饰的方法称为静态方法，也叫做类方法.
被static修饰的代码块叫做静态代码块.
被static修饰符的内部类，叫做静态内部类.

// 只存储一份，比如：在线人数
// Num类
public class Num {
  public static int onlineNum = 100;
}
// 推荐使用 类名.成员变量 进行访问
// Demo.java
public class Demo {
  public static void main(String[] args) {
    // 访问static修饰的成员变量
    System.out.println(Num.onlineNum);
    // 不推荐使用对象访问, 虽然是可以的
    Num n = new Num();
    System.out.println(n.onlineNum);
  }
}

final 用在变量的前面表示变量的值不可以改变，此时该变量可以被称为常量
final 修饰的变量即成为常量，只能赋值一次，但是 final 所修饰局部变量和成员变量有所不同。
final 修饰的局部变量必须使用之前被赋值一次才能使用。
final 修饰的成员变量在声明时没有赋值的叫“空白 final 变量”。空白 final 变量必须在构造方法或静态代码块中初始化。

// 此处代码为摘抄
public class FinalDemo {
    void doSomething() {
        // 1.声明常量时并没有被直接赋值
        final int e;
        // 如果未赋值，只能赋值一次
        e = 100;
        System.out.print(e);
        // 2.声明常量时赋值
        final int f = 200;
    }
    // 实例常量
    final int a = 5; // 直接赋值
    final int b; // 空白final变量
    // 静态常量
    final static int c = 12;// 直接赋值
    final static int d; // 空白final变量
    // 静态代码块
    static {
        // 初始化静态变量
        d = 32;
    }
    // 构造方法
    FinalDemo() {
        // 初始化实例变量
        b = 3;
        // 第二次赋值，会发生编译错误
        // b = 4;
    }
}

public class Demo {
    public static void main(String[] args) {
        int a = 10;
        int b = 14;
        int c = a / (b - 1); // a / (b - 1) 为算术表达式
        if (c < b) { // if语句将在下一小节讲到，此处只需知道 c > b 是一个布尔表达式即可
            System.out.println("c小于b");
        }
    }
}

// 单行注释

/*
多
行
注
释
*/

/**
* 功能：***
* 作者：xxx
* 日期： 
*/

public class Demo {
    public static void main(String[] args) {
        int a = 10;
        int b = 14;
        int c = 20
        if (a < b) { // 如果 a 小于 b，那么就执行 if 代码块的内容
            System.out.println("a小于b");
        } else if (a == b) { // 如果 a 等于 b，那么就执行 else if 代码块的内容
      System.out.println("a等于b");
    } else { // 如果 a既不小于b也不等于b，就执行 
      System.out.println("a大于b");
    }
    }
}

switch(条件语句) {
    case 1:
        System.out.println("1");
        break; // break的意思为跳出
  case 2:
    System.out.println("2");
    break;
  default:
    System.out.println("default");
}

public class Demo {
    public static void main(String[] args) {
        int arr = new int[]{1, 3, 4, 5};
    // for循环，打印出数组的每个元素
    // 下面小括号内循环多少次表达式是基于数组的长度循环多少次，就是循环数组
    for(int a = 0; a < arr.length; a++) {
      System.out.println(arr[a]); // a为arr每一项的下标，所以arr[a]就是循环arr的每一项
    }
    }
}

public class Demo {
    public static void main(String[] args) {
        int arr = new int[]{1, 3, 4, 5};
    // 增强for循环，意义与前端的forEach不能说是完全一致，只能说是一模一样
    for(int item: arr) { // 循环arr数组，每一个元素为item
      System.out.println(item); // 循环item，输出为: 1 3 4 5
    }
    }
}

while(条件控制语句) {
  循环体;
  条件控制语句;
}

public class Demo {
    public static void main(String[] args) {
        int count = 5;
    while(i <= 5) {
      System.out.println("HelloWorld");
    }
    }
}

public class Demo {
    public static void main(String[] args) {
        // 1. 定义一个变量，表示一栋楼的高度
      // 2. 定义一个变量，表示一个人的身高
      // 3. 定义一个计数器，用来统计次数
    // 长高高
    // 每次循环人的身高都会长高至自身原身高的2倍
    // 楼的高度 > 人的身高 循环才继续， 否则循环就会停止
    while() {
      // 请作答
    }
    // 4. 打印一下一共长高了多少次
    System.out.println();
    }
}

public class Demo{
  public static void main(String[] args){
    for (int i = 1; i <= 24; i++) {
            System.out.println("正在度过一天！！");
            if(i == 24) { // 24点了
              System.out.println("24点啦，睡觉啦~~");
                break; // 跳出并结束当前循环的执行
            }
        }
    }
}

周1
周2
周3
周4
周5
周六啦！
周天啦！

public class Demo{
  public static void main(String[] args){
    for (int i = 1; i <= 7; i++) {
           // 请作答
        }
    }
}

嗯.... 我的专栏我记得之前写过正则表达式，不过那个写的比较烂，当时分在前端专栏里了.
写一个新的，正好学一学，正则这个东西对我来说，可以算得上是魔鬼了 = -=

// 构造一个Scanner 类的对象，并且与标准输入流System.in关联
Scanner s = new Scanner(System.in); //创建了一个Scanner对象，Scanner为类名，s为对象名。

import java.util.Scanner;
public class demo04 {
  public static void main(String[] args) {
    //创建一个扫描器对象，用于接收键盘数据
    Scanner scan = new Scanner(Scanner.in);
    System.out.println("使用next方式接收：");
    //使用next方式接收
    String str = Scanner.nextLine();
    System.out.println("输出的内容为："+str);
    //及时关闭IO流的类，否则会一直占用资源
    Scanner.close();
  }
}

Scanner scan=new Scanner(System.in);
int i = scan.nextInt();
double d = scan.nextDouble();

class ClassName {
  ...属性;
  ...方法;
}

类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成员属性或者类成员变量。
方法主要说明类具有哪些功能，称为类的成员方法。

class Students {
  int age = 16;
  String name = "xiaoming";
  int id = 1;
  public void getInfo() {
    System.out..println("姓名：" + name + "，年龄：" + age + "，学号：" + id)
  }
}

类名称 对象名称 = new 类名称();

class Student {
  int age;
  String name;
  int id = 1;
  public void getInfo() {
    System.out..println("姓名：" + name + "，年龄：" + age + "，学号：" + id)
  }
}
public class GetInfo() {
  public static void main(String[] args) {
    Student student = new Student(); // 实例化对象
    student.name = "张三"; // 声明属性
    student.age = 15;
    student.getInfo(); // 调用类方法
  }
}

姓名：张三，年龄：15，学号：1

访问权限修饰符 其他修饰符 返回值类型 方法名称(参数...) {
  ...操作
  // 如果返回值类型为 void， 则不用写return
  // 如果为方法体(函数体) 则 return 返回值;
}

public class Demo {
    public static void main(String[] args) {
        getA("zhangsan", 1); // 调用方法
    }
    public static void getA(String a, int b) { // 方法
        System.out.println("姓名:" + a + "年龄" + b);
    }
}

// 字面量创建字符串
String str = "Hello World!";

// String类的构造函数来创建字符串对象
String str = new String("Hello World!");

String str = "Hello World!"; 
int len = str.length(); // len的值将是12

String str = "Hello World!"; 
char c = str.charAt(4); // c的值将是o

String str1 = "Hello";
 String str2 = "World";
 String str3 = str1.concat(str2); // str3的值将是HelloWorld

String str = "Hello World!";
 String subStr = str.substring(6,11); // subStr的值将是World

String str = "Hello World!";
String newStr = str.replace("World","Java"); // newStr的值将是Hello Java!

String str = "Hello World!";
 String upStr = str.toUpperCase(); // upStr的值将是HELLO WORLD!
 String lowStr = str.toLowerCase(); // lowStr的值将是hello world!

String str = "Hello World!";
boolean containsStr = str.contains("World"); // containsStr的值将是true

import java.util.ArrayList;
import java.util.Vector;
// java.util.Vector类是Java中的一个集合类，它实现了可调整大小的数组，可以动态地添加或删除元素。Vector类可以用来存储任何类型的对象，而不只是基本数据类型。
public class Main {
  public static void main(String[] args) {
      Object array = new ArrayList();//创建ArrayList类的对象array
      Check(array);//调用函数判断
  }
  public static void Check(Object array) {
      //判断对象 是哪个类实例化产生的
      if (array instanceof Vector){
        System.out.println("对象array 是 java.util.Vector 类的实例");
      }
      if (array instanceof ArrayList){
         System.out.println("对象array 是 java.util.ArrayList 类的实例");
      }
    }
}

public class Person {
    private String name;    // 姓名，私有属性
    private int age;        // 年龄，私有属性
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 公开方法，获取姓名
    public String getName() {
        return name;
    }
    // 公开方法，设置姓名
    public void setName(String name) {
        this.name = name;
    }
    // 公开方法，获取年龄
    public int getAge() {
        return age;
    }
    // 公开方法，设置年龄
    public void setAge(int age) {
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("张三", 20);
        System.out.println("姓名：" + person.getName() + "，年龄：" + person.getAge());
        person.setName("李四");
        person.setAge(25);
        System.out.println("姓名：" + person.getName() + "，年龄：" + person.getAge());
    }
}

姓名：张三，年龄：20
姓名：李四，年龄：25

具体来说，有static和无static的区别如下：
1. 静态变量：有static关键字的变量是类变量，也称为静态变量。它们在类加载时被初始化，可以通过类名直接访问，不需要创建类的实例。而无static的变量是实例变量，每个类的实例都有自己的一份副本。
2. 静态方法：有static关键字的方法是类方法，也称为静态方法。它们可以通过类名直接调用，不需要创建类的实例。而无static的方法是实例方法，只能通过类的实例调用。
3. 静态代码块：有static关键字的代码块是静态代码块。它们在类加载时执行，只执行一次。而无static的代码块是实例代码块，每次创建类的实例时都会执行。

class OuterClass {
    // 外部类的成员变量和方法
    class InnerClass {
        // 内部类的成员变量和方法
    }
}

public class OuterClass {
    private int x = 10;
    // 非静态内部类
    class InnerClass {
        private int y = 5;
        public void print() {
            System.out.println("x = " + x); // 访问外部类的成员变量
            System.out.println("y = " + y); // 访问内部类的成员变量
        }
    }
    // 静态内部类
    static class StaticInnerClass {
        private int z = 3;
        public void print() {
            System.out.println("z = " + z); // 访问内部类的成员变量
        }
    }
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        InnerClass inner = outer.new InnerClass(); // 创建内部类的实例
        inner.print(); // 调用内部类的方法
        StaticInnerClass staticInner = new StaticInnerClass(); // 创建静态内部类的实例
        staticInner.print(); // 调用静态内部类的方法
    }
}

public class Calculator {
    public static void main(String[] args) {
        // 创建一个匿名内部类实现加法运算
        Operation add = new Operation() {
            @Override
            public int operate(int a, int b) {
                return a + b;
            }
        };
        // 创建一个匿名内部类实现减法运算
        Operation subtract = new Operation() {
            @Override
            public int operate(int a, int b) {
                return a - b;
            }
        };
        // 使用匿名内部类实现的加法运算
        int result1 = add.operate(10, 5);
        System.out.println("10 + 5 = " + result1);
        // 使用匿名内部类实现的减法运算
        int result2 = subtract.operate(10, 5);
        System.out.println("10 - 5 = " + result2);
    }
}
// 定义一个接口，用于实现不同的运算
interface Operation {
    int operate(int a, int b);
}

public class Demo {
  // 单例第一步 构造器私有
  private Demo() {
  }
  // 定义静态变量
  private static Demo instance = new Demo();
  public static Demo getInstance() {
        return instance;
    }
}

public class Demo {
  // 单例第一步 构造器私有
  private Demo() {
  }
  private static Demo instance = null;
  public static Demo getInstance() {
    if (instance == null) {
      instance = new Demo();
    }
    return instance
  }
}

package arraylist;
import java.util.ArrayList;
public class ArrayListDemo {
  public static void main(String[] args) {
    ArrayList arr = new ArrayList();
    arr.add("123");
    arr.add("456");
    arr.add("789");
    // arr.add(new Cat()); // 不用管这一行
    for (int i = 0; i < arr.size(); i++) {
        String e = (String) arr.get(i); // (String) 为强转为字符型的意思
        System.out.println(e);
    }
    System.out.println("----------------------------");
    ArrayList<String> arr2 = new ArrayList<>(); // 在java1.7之后，允许前面定义泛型类型之后，后面可不填写
    arr2.add("999");
    for (int i = 0; i < arr2.size(); i++) {
        String e = arr2.get(i);
        System.out.println(e);
    }
  }
}
class Cat {} // cat类 | 不用管这一行

package fanxingClass;
public class Test {
  public static void main(String[] args) {
    // 泛型类的定义和使用
    // 如果不使用泛型E， 则为Object类型
    MyArrayList<String> list = new MyArrayList<>();
    list.add("Java1");
    list.add("Java2");
    // list.add(23); 报错
    // 取值操作
    String element = list.get(1);
    System.out.println(element);
  }
}

package fanxingClass;
public class MyArrayList<E> {
  // 为什么一定要是Object类型？ Object可装任意类型的数据
  private Object[] arr = new Object[10];
  private int size;
  public boolean add(E e) { // add 方法
    arr[size++] = e;
    return true;
  }
  public E get(int index) { // get 方法
  // return arr[index]; // 报错， 要强转类型 下方代码
  return (E) arr[index];
  }
}

package FileInput;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
 * Author: _LJaXi
 * @author ASUS
 */
class FileInput {
    public static void main(String[] args) throws IOException {
        try {
            FileInputStream fis = new FileInputStream("d:\\aaa.txt");
            // 一次读取多个字节,存到数组中
            // 创建一个长度为3的数组 / 字节类型
            byte[] buf = new byte[3];
            int count = 0;
            // 条件判断循环
            while ((count = fis.read(buf)) != -1) {
                System.out.print(new String(buf,0,count));
            }
            // 3. 关闭
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

package main.java.com.mycode;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
 * Author: _LJaXi
 * @author ASUS
 */
class MyIo {
  public static void main(String[] args) throws IOException {
    try {
      FileInputStream fis = new FileInputStream("d:\\aaa.txt");
      // 读取
      System.out.println(fis.read());
      int data = 0;
      // 循环打印字节
      while ((data = fis.read()) != -1) {
        System.out.print((char) data);
      }
      // 3. 关闭
      fis.close();
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    }
  }
}

package main.java.com.mycode;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
 * Author: _LJaXi
 * @author ASUS
 */
class MyIo {
  public static void main(String[] args) throws IOException {
    try {
      FileInputStream fis = new FileInputStream("d:\\aaa.txt");
      // 一次读取多个字节,存到数组中
      // 创建一个长度为3的数组 / 字节类型
      byte[] buf = new byte[3];
      // 返回实例读取的个数
      int count = fis.read(buf);
      // 打印字符串 buf
      System.out.println(new String(buf));
      System.out.println(count);
      // 多次读取
      int count2 = fis.read(buf);
      System.out.println(new String(buf));
      System.out.println(count2);
      int count3 = fis.read(buf);
      System.out.println(new String(buf));
      System.out.println(count3);
      // 若文件内字符太短，可能会出现读取数组you多余元素问题，那是你的上次buf数组没有清空导致的
      // 可以使用
      // System.out.println(new String(buf, index(索引), count3)); 来清理多余的元素
      // new String(buf)参数：
      // 1. param1 是一个字节数组，用于构建新的字符串对象
      // 2. param2 是偏移量（offset），表示从 param1 的索引为 param2 的位置开始构建字符串
      // 3. param3 是长度（length），表示构建字符串的长度
      // 3. 关闭
      fis.close();
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    }
  }
}

package main.java.com.mycode;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
 * Author: _LJaXi
 * @author ASUS
 */
class MyIo {
  public static void main(String[] args) throws IOException {
    try {
      FileInputStream fis = new FileInputStream("d:\\aaa.txt");
      // 一次读取多个字节,存到数组中
      // 创建一个长度为3的数组 / 字节类型
      byte[] buf = new byte[3];
     int count = 0;
     // 条件判断循环
     while ((count = fis.read(buf)) != -1) {
         System.out.print(new String(buf,0,count));
     }
      // 3. 关闭
      fis.close();
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    }
  }
}

package main.java.com.mycode;
import java.io.FileOutputStream;
/**
 * Author: _LJaXi
 * @author ASUS
 */
public class FileOutput {
  public static void main (String[] args) throws Exception {
    // 1. 创建文件字节输出流对象
    // 若不想覆盖原本内容，将构造方法append，设置为true
    FileOutputStream fos = new FileOutputStream("d://aaa.txt", true);
    // 2. 写入文件
    // fos.write(97);
    // fos.write('b');
    // fos.write('c');
    String str = "helloworld";
    // 获取字符串所对应的字节数组
    fos.write(str.getBytes());
    // 3. 关闭
    fos.close();
    System.out.println("执行完毕");
  }
}

// 某个构造方法有个形参 append，这个构造方法的 append 若为true 表明不覆盖原本内容
public FileOutputStream(String name, boolean append)
        throws FileNotFoundException
    {
        this(name != null ? new File(name) : null, append);
    }

package CopyFile;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 使用文件字节流实现文件的复制
* */
public class CopyFile {
    public static void main(String[] args) throws IOException {
        // 1. 先用文件字节输入流读到内存中
        FileInputStream fis = new FileInputStream("C:\\Users\\ASUS\\Desktop\\凌波.png");
        // 2. 再用一个文件字节输出流写入到硬盘
        FileOutputStream fos = new FileOutputStream("C:\\Users\\ASUS\\Desktop\\凌波丽.jpg");
        // 3. 一边读 一边写
        byte[] buf = new byte[1024];
        int count = 0;
        while((count=fis.read(buf)) != -1) {
            fos.write(buf,0,count);
        }
        // 4. 关闭流
        fis.close();
        fos.close();
        System.out.print("复制完毕");
    }
}

package Buffered;
import java.io.FileInputStream;
import java.io.BufferedInputStream;
import java.io.IOException;
/*
* 使用字节缓冲流读取
* BufferedInputStream
* @author 符韬是谁？
* */
public class BufferedStream {
    public static void main(String[] args) throws IOException {
        // 1. 创建BufferedInputStream
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        // 增强底层流
        BufferedInputStream bis = new BufferedInputStream(fis);
        // 2. 读取 bis 读文件会放在缓冲区，提高效率
        int count = 0;
        // bis.read() 并不是读一个字节，先把一部分数据读到bis缓冲区内，调用已经读了8k了
        // private static int DEFAULT_BUFFER_SIZE = 8192;
        // 当然你也可以自己定义把一部分数据读取到缓冲区, 下方注释写法
        byte[] buf = new byte[6000];
        while ((count=bis.read(buf)) != -1) {
            System.out.print(new String(buf, 0, count));
        }
        // 3. 关闭
        bis.close(); // 缓冲流close之后, 会自动帮你关闭输入流 fis.close()
    }
}

package Buffered;
import java.io.FileInputStream;
import java.io.BufferedInputStream;
import java.io.IOException;
/*
* 使用字节缓冲流读取
* BufferedInputStream
* @author 符韬是谁？
* */
public class BufferedStream {
    public static void main(String[] args) throws IOException {
        // 1. 创建BufferedInputStream
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        // 增强底层流
        BufferedInputStream bis = new BufferedInputStream(fis);
        // 2. 读取 bis 读文件会放在缓冲区，提高效率
        int count = 0;
        // bis.read() 并不是读一个字节，先把一部分数据读到bis缓冲区内，调用已经读了8k了
        // private static int DEFAULT_BUFFER_SIZE = 8192;
        // 当然你也可以自己定义把一部分数据读取到缓冲区, 下方注释写法
        byte[] buf = new byte[6000];
        while ((count=bis.read(buf)) != -1) {
            System.out.print(new String(buf, 0, count));
        }
        // 3. 关闭
        bis.close(); // 缓冲流close之后, 会自动帮你关闭输入流 fis.close()
    }
}

package Buffered;
import java.io.*;
/*
 * 使用字节缓冲流写入
 * BufferedOutputStream
 * @time 2023年9月11日14:19:47
 * @author _LJaXi
 * @tip 想秀阿卡丽
 * */
public class OutputStream {
    public static void main(String[] args) {
        try {
            FileOutputStream fos = new FileOutputStream("d:\\aaa.txt", true);
            BufferedOutputStream bos = new BufferedOutputStream(fos);
            String data = "LOL";
            bos.write(data.getBytes()); // 写入 8k 到缓冲区
            fos.flush(); // 刷新到硬盘
            /*---------------------------------------------------------------
            * bos.flush()的作用是将缓冲区中的数据立即刷新（写入）到硬盘中
            * 当使用BufferedOutputStream写入数据时，数据通常会先被存储在内部的缓冲区中，直到缓冲区达到一定的容量或者手动调用flush()方法
            * ---------------------------------------------------------------
            * flush()方法的使用是为了确保数据被及时写入硬盘，而不是一直停留在缓冲区
            * 在调用flush()方法后，任何未写入的数据将被立即写入到硬盘中，这样可以避免数据丢失的风险
            * ---------------------------------------------------------------
            * 在流关闭之前或发生异常时，也会自动调用flush()方法，确保所有数据都被写入硬盘
            * ---------------------------------------------------------------*/
            bos.close(); // 内部也会调用 flush() 方法
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

package ObjectStream;
import java.io.Serializable;
// 要想序列化，类必须实现一个接口，为标记接口
public class Student implements Serializable {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    // this is 重写 toString 方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package ObjectStream;
import java.io.*;
/*
* 序列化类必须要实现 Serializable 接口(标记接口)
* ObjectOutputStream
* @time 2023年9月14日13:49:52
* @author _LJaXi
* @tip 阿卡丽5连败
* */
public class OutStream {
    public static void main(String[] args)throws IOException {
        // 1. 创建对象流
        FileOutputStream fos = new FileOutputStream("d:\\aaa.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        // 2. 序列化（写入操作）
        Student zs = new Student("张三", 20);
        oos.writeObject(zs);
        // 3. 关闭
        oos.close();
        System.out.println("序列化完毕");
    }
}

package ObjectStream;
import java.io.*;
/*
* ObjectInputStream 反序列化(读取重构成对象)
* @time 2023年9月14日23:31:23
* @author _LJaXi
* @tip 阿卡丽排位3连胜
* */
public class InputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 1. 创建对象流
        FileInputStream fis = new FileInputStream("d:\\aaa.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        // 2. 读取文件(反序列化)
        Student s = (Student)ois.readObject();
        // Student s2 = (Student)ois.readObject(); // 不能读取多次
        // 3. 关闭
        ois.close();
        System.out.println("执行完毕");
        System.out.println(s.toString());
    }
}

public class Student implements Serializable {
    private String name;
    private int age;
    private Class class; // Class类要实现 Serializable 接口
    // ... 其他内容
}

private static final long serialVersionUID = 100L;

// Student
package ObjectStream;
import java.io.Serializable;
public class Student implements Serializable {
    private String name;
    private transient int age; // age禁止被序列化
    public Student() {
    }
    // ....其他操作
}

// 序列化
public class OutStream {
    public static void main(String[] args)throws IOException {
        // 1. 创建对象流
        FileOutputStream fos = new FileOutputStream("d:\\aaa.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        // 2. 序列化（写入操作）
        Student zs = new Student("张三", 20);
        Student ls = new Student("李四", 20); // 定义ls对象 ⭕
        oos.writeObject(zs);
        oos.writeObject(ls); // 写入ls ⭕
        // 3. 关闭
        oos.close();
        System.out.println("序列化完毕");
    }
}
// 反序列化
public class InputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 1. 创建对象流
        FileInputStream fis = new FileInputStream("d:\\aaa.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        // 2. 读取文件(反序列化)
        Student s = (Student)ois.readObject();
        Student s2 = (Student)ois.readObject(); // 读取多次 ⭕
        // 3. 关闭
        ois.close();
        System.out.println("执行完毕");
        System.out.println(s.toString());
    }
}

// 序列化
public class OutStream {
    public static void main(String[] args)throws IOException {
        // 1. 创建对象流
        FileOutputStream fos = new FileOutputStream("d:\\aaa.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        ArrayList<Student> list = new ArrayList<>(); // ⭕定义集合
        // 2. 序列化（写入操作）
        Student zs = new Student("张三", 20);
        Student ls = new Student("李四", 20);
        // ⭕ 添加元素
        list.add(zs);
        list.add(ls);
        oos.writeObject(list); // ⭕写入
        // oos.writeObject(zs);
        // oos.writeObject(ls);
        // 3. 关闭
        oos.close();
        System.out.println("序列化完毕");
    }
}
// 反序列化
public class InputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 1. 创建对象流
        FileInputStream fis = new FileInputStream("d:\\aaa.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        // 2. 读取文件(反序列化)
        ArrayList<Student> l = (ArrayList<Student>) ois.readObject();  // ⭕强转
        // Student s = (Student)ois.readObject();
        // Student s2 = (Student)ois.readObject();
        // 3. 关闭
        ois.close();
        System.out.println("执行完毕");
        // System.out.println(s.toString());
        System.out.println(list.toString()); // ⭕打印
    }
}

package FileReaderAndWriter;
import java.io.FileReader;
public class FileRead {
    public static void main(String[] args)throws Exception {
        // 1. 创建 FileReader 文件字符输入流
        FileReader fr = new FileReader("d:\\aaa.txt");
        // 2. 读取
        // int data = 0;
        // while((data = fr.read()) != -1) {
        //     System.out.print((char) data);
        // }
        // 创建缓冲区
        char[] buf = new char[1024];
        int count = 0;
        while((count = fr.read(buf)) != -1) {
            System.out.print(new String(buf, 0, count));
        }
        // 3. 关闭
        fr.close();
    }
}

package FileReaderAndWriter;
import java.io.FileWriter;
public class FileWrite {
    public static void main(String[] args)throws Exception {
        // 1. 创建文件字符输出流
        FileWriter fw = new FileWriter("d:\\write.txt");
        // 2. 写入
        for (int i = 0; i < 10; i++) {
            fw.write("Java是世界上最好的语言\r\n"); // 换行写入 \r\n
            fw.flush();
        }
        // 3. 关闭
        fw.close();
    }
}

package FileReaderAndWriter;
import java.io.FileReader;
import java.io.FileWriter;
/*
* 使用 FileReader 和 FileWriter 复制文本文件，不能复制图片或者二进制文件
* =============== 使用字节流才可以复制任何文件 =================
* @author _LJaXi
* */
public class CopyFile {
    public static void main(String[] args)throws Exception {
        // 1. 创建 FileReader FileWriter
        FileReader fr = new FileReader("d://write.txt");
        FileWriter fw = new FileWriter("d://write2.txt");
        // 2. 读写
        int data = 0;
        while((data = fr.read()) != -1) {
            fw.write(data);
        }
        // 3. 关闭
        fr.close();
        fw.close();
        System.out.println("执行完毕");
    }
}

package FileReaderAndWriter;
import java.io.BufferedReader;
import java.io.FileReader;
/*
* 使用字符缓冲流读取文件
* 高效读取
* BufferedReader
* */
public class BufferedReaderStream {
    public static void main(String[] args)throws Exception {
        // 1. 创建缓冲流
        FileReader fr = new FileReader("d:\\write.txt");
        BufferedReader br = new BufferedReader(fr);
        // 2. 读取
        // char[] buf = new char[1024];
        // int count = 0;
        // while ((count = br.read(buf)) != -1) {
        //     System.out.println(new String(buf, 0, count));
        // }
        // 2.1 第二种方式 一行一行的读取
        // readLine() BufferedReader提供的API
        String line = null;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
        // 3. 关闭
        br.close();
    }
}

package FileReaderAndWriter;
import java.io.BufferedWriter;
import java.io.FileWriter;
/*
* 字符缓冲流
* BufferedWriter
* */
public class BufferedWriterStream {
    public static void main(String[] args)throws Exception {
        FileWriter fw = new FileWriter("d:\\buffer.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        // 2. 写入
        for (int i = 0; i < 10; i++) {
            bw.write("好好学习。");
            bw.newLine(); // 换行符，等同于 \r\n
            bw.flush();
        }
        // 3. 关闭
        bw.close();
    }
}

package PrintWriterStream;
import java.io.PrintWriter;
/*
* PrintWriter
* */
public class Print {
    public static void main(String[] args)throws Exception {
        // 1. 新建 打印流
        PrintWriter pw = new PrintWriter("d:\\print.txt");
        // 2. 打印
        pw.println(97);
        pw.println(true);
        pw.println(3.14);
        pw.println('a');
        // 3. 关闭
        pw.close();
    }
}

import java.io.*;
public class InputStreamReaderExample {
    public static void main(String[] args) {
        try {
            // 创建 InputStreamReader 指定编码读取文件
            FileInputStream fileInputStream = new FileInputStream("input.txt"); // 指定文件路径
            InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "UTF-8"); // 指定编码
            BufferedReader bufferedReader = new BufferedReader(inputStreamReader); // BufferedReader 字符缓冲流读取文件
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                System.out.println(line);
            }
            // 关闭资源
            bufferedReader.close();
            inputStreamReader.close();
            fileInputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        // e.printStackTrace()方法会将异常的堆栈跟踪信息打印到标准错误流（System.err）。堆栈跟踪信息包含了异常发生的位置、方法调用的轨迹以及导致异常的原因等详细信息，有助于开发者定位和解决问题。
    }
}

import java.*;
public class OutputStreamWriterExample {
  public static void main(String[] args) {
    // 输出流
    FileOutputSteam fps = new FileOutputSteam("output.txt");
    OutputStreamWriter osw = new OutputStreamWriter(fps, "UTF-8");
    // 写入
    for (int i = 0; i < 10; i++) {
      osw.write("OutputStreamWriterExample\r\n");
      osw.flush();
    }
    // 关闭流
    osw.close();
  }
}

import java.io.File;
public class GetSeparator {
  public static void main(String[] args) {
    separator();
  }
  public static void separator() {
    // 获取路径分隔符
    System.out.print("路径分隔符" + File.pathSeparator);
    // 获取名称分隔符
    System.out.print("路径分隔符" + File.separator);
  }
}

import java.io.File;
public class FileOpe {
  public static void main(String[] args) throw Exception {
    fileOp();
  }
  public static void fileOp() throw Exception {
    File file = new File("D:\\file.txt");
    // System.out.print(file.toString()); // d:\file.txt
    if(file.exists()) {
      boolean b = file.createNewFile();
      System.out.print("创建结果" + b);
    }
  }
}

import java.io.File;
public class FileOpe {
  public static void main(String[] args) throw Exception {
    fileOp();
  }
  public static void fileOp() throw Exception {
    File file = new File("D:\\file.txt");
    if(file.exists()) {
      boolean b = file.createNewFile();
      System.out.print("创建结果" + b);
    }
    // 删除文件
    // 1. 直接删除
    // file.delete();
    // 2. jvm退出时删除
    file.deleteOnExit();
    Thread.sleep(5000);
  }
}

import java.io.File;
public class FileOpe {
  public static void main(String[] args) throw Exception {
    fileOp();
  }
  public static void fileOp() throw Exception {
    File file = new File("D:\\file.txt");
    if(file.exists()) {
      boolean b = file.createNewFile();
      System.out.print("创建结果" + b);
    }
    // 获取文件信息
    System.out.print("文件名称" + file.getName());
    System.out.print("获取父目录" + file.getParent());
    System.out.print("获取长度" + file.length());
    System.out.print("获取文件绝对路径" + file.getAbsolutePath());
    System.out.print("获取路径" + file.getPath());
    System.out.print("获取文件创建时间" + new Date(file.lastModified()).toLocaleString());
  }
}

import java.io.File;
public class FileOpe {
  public static void main(String[] args) throw Exception {
    fileOp();
  }
  public static void fileOp() throw Exception {
    File file = new File("D:\\file.txt");
    if(file.exists()) {
      boolean b = file.createNewFile();
      System.out.print("创建结果" + b);
    }
    // 判断
    System.out.print("文件是否可写" + file.canWrite());
    System.out.print("是否为文件" + file.isFile());
    System.out.print("文件是否隐藏" + file.isHidden());
  }
}

import java.io.File;
public class FileOpe {
  public static void main(String[] args) throw Exception {
    directoryOpe();
  }
  public static void directoryOpe() throw Exception {
    File dir = new File("d:\\aaa\\bbb\\ccc");
    // System.out.print(dir.toString()); // d:\aaa\bbb\ccc
    if (!dir.exists()) {
      // dir.mkdir(); // 只能创建单级目录
      System.out.print("创建状态: " + dir.mkdirs()); // true
    }
  }
}

import java.io.File;
public class FileOpe {
  public static void main(String[] args) throw Exception {
    directoryOpe();
  }
  public static void directoryOpe() throw Exception {
    File dir = new File("d:\\aaa\\bbb\\ccc");
    // System.out.print(dir.toString()); // d:\aaa\bbb\ccc
    if (!dir.exists()) {
      // dir.mkdir(); // 只能创建单级目录
      System.out.print("创建状态: " + dir.mkdirs()); // true
    }
    // 1. 直接删除
    // System.out.print("删除结果" + dir.delete()); // 注意删除空目录
    // 2. 使用jvm删除
    dir.deleteOnExit();
    Thread.sleep(5000);
  }
}

import java.io.File;
public class FileOpe {
  public static void main(String[] args) throw Exception {
    directoryOpe();
  }
  public static void directoryOpe() throw Exception {
    File dir = new File("d:\\aaa\\bbb\\ccc");
    // System.out.print(dir.toString()); // d:\aaa\bbb\ccc
    if (!dir.exists()) {
      // dir.mkdir(); // 只能创建单级目录
      System.out.print("创建状态: " + dir.mkdirs()); // true
    }
    // 获取文件信息
    System.out.print("文件名称" + dir.getName());
    System.out.print("获取父目录" + dir.getParent());
    System.out.print("获取文件绝对路径" + dir.getAbsolutePath());
    System.out.print("获取路径" + dir.getPath());
    System.out.print("获取文件创建时间" + new Date(dir.lastModified()).toLocaleString());
  }
}

import java.io.File;
public class FileOpe {
  public static void main(String[] args) throw Exception {
    directoryOpe();
  }
  public static void directoryOpe() throw Exception {
    File dir = new File("d:\\aaa\\bbb\\ccc");
    // System.out.print(dir.toString()); // d:\aaa\bbb\ccc
    if (!dir.exists()) {
      // dir.mkdir(); // 只能创建单级目录
      System.out.print("创建状态: " + dir.mkdirs()); // true
    }
    // 判断
    System.out.print("是否为文件夹" + dir.isDirectory());
    System.out.print("文件夹是否隐藏" + dir.isHidden());
  }
}

import java.io.File;
public class FileOpe {
  public static void main(String[] args) throw Exception {
    directoryOpe();
  }
  public static void directoryOpe() throw Exception {
    File dir = new File("d:\\aaa\\bbb\\ccc");
    // System.out.print(dir.toString()); // d:\aaa\bbb\ccc
    if (!dir.exists()) {
      // dir.mkdir(); // 只能创建单级目录
      System.out.print("创建状态: " + dir.mkdirs()); // true
    }
    // 遍历文件夹
    File dir2 = new File("d:\\图片");
    String[] files = dir2.list();
    for(String item : files ) {
      System.out.println(item);
    }
  }
}

public interface FileFilter 
  - boolean accept(File pathname)

import java.io.File;
import java.io.FileFilter;
public class FileFilterExample {
    public static void main(String[] args) {
        File directory = new File("path/to/directory");
        // 创建一个 FileFilter 匿名内部类来筛选以 ".txt" 结尾的文件
        FileFilter txtFileFilter = new FileFilter() {
            @Override
            public boolean accept(File pathname) {
              // endsWith 字符串方法筛选文件是否以 txt 结尾 
                return pathname.isFile() && pathname.getName().endsWith(".txt");
            }
        };
        // 获取目录下所有满足筛选条件的文件
        File[] txtFiles = directory.listFiles(txtFileFilter);
        // 输出结果
        for (File file : txtFiles) {
            System.out.println(file.getName());
        }
    }
}

import java.*;
public class FileDemo {
  public static void main(String[] args) throw Exception {
    FileOpe(new File("d:\\demo"));
  }
  /**
  * @ File dir 接收一个 File 类型参数, 用于递归判断
  */
  public static void FileOpe(File dir) throw Exception {
    File[] files = dir.listFile();
    // 如果数组不为 null 并且 数组不为 []
    if (files != null && files.length > 0) {
      for(File file : files) {
        if (file.isDerectory()) {
          FileOpe(file); // 如果某一项为文件夹，那就对某个文件夹进行递归操作
        } else {
          System.out.print(file.getAbsolutePath());
        }
      }
    }
  }
}

import java.io.*;
public class FileDemo {
    public static void main(String[] args) throws Exception {
        FileOpe(new File("d:\\demo"));
    }
    /**
     * @param dir 接收一个 File 类型参数，用于递归判断
     */
    public static void FileOpe(File dir) throws Exception {
        File[] files = dir.listFiles();
        // 如果数组不为 null 并且数组不为空
        if (files != null && files.length > 0) {
            for (File file : files) {
                if (file.isDirectory()) {
                    FileOpe(file); // 如果某一项为文件夹，那就对该文件夹进行递归操作
                } else {
                    System.out.println(file.getAbsolutePath());
                    file.delete(); // 删除文件
                }
            }
        }
        dir.delete(); // 删除文件夹
    }
}

import java.*;
public class PropertiesDemo {
  public static void main(String[] args) {
    // 创建 Properties
    Proerties p = new Properties();
    // 添加key value 
    p.setProperty("name", "Jerry");
    p.setProperty("age", "3");
    // 遍历
    Set<String> propNames = p.stringPropertyNames();
    for(String pro : propNames) {
      System.out.println(pro + " === " + p.getProperty(pro));
    }
    // 和流有关的方法
    PrintWriter pw = new PrintWriter("d:\\a.txt");
    p.list(pw);
    pw.close();
    // store 方法
    // store() 是 Properties 类的一个方法，用于将属性列表存储到输出流中
    // 第一个参数是输出流对象，可以是 FileOutputStream、BufferedOutputStream 等
    // 第二个参数是一个字符串，表示对存储的属性列表进行注释
    FileOutputStream fos = new FileOutputStream("d:\\a.txt");
    p.store(fos, "注释");
    fos.close();
    // load 方法加载
    Properties p2 = new Properties();
    FileInputStream fis = new FileInputStream("d:\\config.properties");
    p2.load(fis);
    fis.close();
    System.out.println(p2.toString());
  }
}