Java

基础语法

Byte

java.lang.Byte

byte 类型占 1 个字节（8 位），取值范围从-128（0b10000000）到 127（0b01111111），它在内存中以补码的形式存储整数。

new

Byte byteObj1 = new Byte((byte) 10);
Byte byteObj2 = Byte.valueOf((byte) 10);

byteValue()

用于将一个 Byte 对象中封装的值转换成基本数据类型 byte。

byte byteValue()

Boolean

java.lang.Boolean

Integer

parseInt()

用于将一个字符串转换成基本数据类型 int。

static int parseInt(String s)

// 输入：一个表示整数的字符串（例如："123"）。
// 输出：转换后的 int 类型值（例如，123）。
    
static int parseInt(String s, int radix)
    
// s：要解析的字符串，它表示一个数字。
// radix：基数，表示数字的进制 

Long

java.lang.long

new

long num = 123456789L

Long num = new Long(123456789L)

Long num = new Long("123456789L")

String

java.lang.String

new

String str = new String("Hello"); // 存在堆中，非字符串池

byte[] byteArray = {72, 101, 108, 108, 111};
String str = new String(byteArray, "UTF-8");
System.out.println(str);  // 输出: Hello

getBytes()

getBytes() 方法用于将字符串转换为一个字节数组。

它将字符串的每个字符按照指定的编码格式转换为字节。

byte[] getBytes()

replaceAll()

允许使用正则表达式替换字符串中的所有匹配项。

String replaceAll(String regex, String replacement)

// regex：用于匹配的正则表达式。
// replacement：用于替换匹配内容的字符串。
// return：返回一个新字符串，其中所有匹配 regex 的部分都被 replacement 替换。

substring()

String substring(int beginIndex)

String substring(int beginIndex, int endIndex)

// beginIndex：起始位置（索引从 0 开始）。返回的子字符串包括此位置的字符。
// endIndex：结束位置。返回的子字符串不包括此位置的字符。

split()

根据指定的分隔符将字符串分成数组。

String[] split(String regex)

String[] split(String regex, int limit)
    
// regex：分隔符，正则表达式形式。
// limit：限制数组的大小，表示分割的最大次数。

format()

用于创建格式化的字符串。

static String format(String format, Object... args)

static String format(Locale locale, String format, Object... args)

// format：格式字符串，用于描述输出格式，其中包含格式说明符（conversion specifiers）。
// args：与格式字符串中说明符相对应的参数，可变参数形式传入。
// locale：用于国际化格式化，比如小数点符号、货币符号、日期格式等

compareToIgnoreCase()

按字典顺序比较两个字符串，忽略大小写，并返回比较结果的整数值。

int compareToIgnoreCase(String anotherString)
    
// anotherString : 要比较的另一个字符串。
// 返回值：
    // 正数:当前字符串在字典顺序中位于 anotherString 之后（忽略大小写）。
    // 0	两个字符串在字典顺序中相等（忽略大小写）。
    // 负数	当前字符串在字典顺序中位于 anotherString 之前（忽略大小写）。

lastIndexOf()

返回指定字符（Unicode代码点）在字符串中最后一次出现的索引位置。

int lastIndexOf(int ch)

// ch : 要查找的字符（Unicode代码点，以 int 类型表示）。
// 返回值:
    // 字符最后一次出现的索引（从0开始）；若未找到，返回 -1。

equalsIgnoreCase()

比较当前字符串与目标字符串的内容是否相同（不区分大小写）。

boolean equalsIgnoreCase(String anotherString)
    
// anotherString 是要比较的另一个字符串。

• true：两个字符串内容相同（忽略大小写）。
• false：内容不同或 anotherString 为 null。

StringBuilder

java.lang.StringBuilder

StringBuilder 允许对字符串进行修改。

new

StringBuilder sb = new StringBuilder("Hello");

// 默认构造，初始容量 16
StringBuilder sb1 = new StringBuilder();

// 指定初始容量为50
StringBuilder sb2 = new StringBuilder(50);

append()

用于在 StringBuilder 末尾追加内容。

StringBuilder 提供了多个重载的 append() 方法，可以接收不同的数据类型。

public StringBuilder append(String str)
public StringBuilder append(int i)
public StringBuilder append(long l)
public StringBuilder append(float f)
public StringBuilder append(double d)
public StringBuilder append(boolean b)
public StringBuilder append(char c)
public StringBuilder append(char[] str)
public StringBuilder append(Object obj)
public StringBuilder append(CharSequence s)
public StringBuilder append(StringBuffer sb)
public StringBuilder append(CharSequence s, int start, int end)

insert()

toString()

用于将 StringBuilder 对象转换为 String对象。

String toString()

Arrays

java.util.Arrays，Java的数组类

asList()

<T> List<T> asList(T... a)

// a：数组，可以是任何类型的数组（原始类型数组和对象类型数组都支持）。
// return：返回一个由指定数组支持的固定大小的 List，该 List 视图是基于原数组的，因此修改该列表的元素也会影响原数组。

copyOf()

用于创建并返回指定数组的一个新数组，新数组包含了原数组的部分或全部元素。

<T> T[] copyOf(T[] original, int newLength)

// original：原始数组，表示要被拷贝的数组。
// newLength：新数组的长度。可以比原数组长度大，也可以相等，甚至小。

toString(array)

将数组转换为字符串表示形式。

int[] arr = {1, 2, 3};
String str = Arrays.toString(arr); // str = "[1, 2, 3]"

Collection

java.util.Collection

Collection 接口是所有集合类的根接口，它定义了一组通用的方法，如添加、删除、遍历元素等。

size()

int size(); // 获取集合中元素的个数

isEmpty()

boolean isEmpty(); // 判断集合是否为空

contains()

boolean contains(Object o); // 判断集合中是否包含指定元素

iterator();

返回一个迭代器对象，允许对集合进行遍历。

Iterator<E> iterator();

// return：返回一个 Iterator 对象，该对象能够遍历集合中的元素。

add()

boolean add(E e); // 如果集合中不存在该元素，则添加，返回 true；如果元素已存在，则不添加，返回 false

remove()

boolean remove(Object o); // 移除指定的元素，成功返回 true，失败返回 false

clear()

void clear(); // 移除所有元素

List

java.util.List

List是 Collection 的子接口，表示有序的元素集合，允许重复元素。

ArrayList

java.util.ArrayList

ArrayList是List的实现类，基于动态数组实现

new

Set

java.util.Set

Set 是 Collection 的子接口，存储的元素无序且不重复。

HashSet

java.util.HashSet

HashSet 是 Set 接口的实现类。

HashSet 使用 哈希表（HashMap）来存储元素，存储的元素无序且不重复。

Iterator

java.util.Iterator

Iterator提供了一种统一的方法来遍历集合中的元素

public interface Iterator<E> {
    boolean hasNext();        // 检查集合中是否有下一个元素
    E next();                 // 返回集合中的下一个元素
    void remove();            // 移除集合中最近一次返回的元素
}

Map

java.util.Map

Map 是一个用于存储键值对（Key-Value）的集合接口，每个Map 中的键是唯一的，值可以重复。

size()

int size();

isEmpty()

boolean isEmpty();

containsKey()

boolean containsKey(Object key);

containsValue

boolean containsValue(Object value);

get()

V get(Object key);

put()

V put(K key, V value);

remove()

V remove(Object key);

clear()

void clear();

keySet()

返回 Map 中所有键的集合

Set<K> keySet();

// return：Set<K>，表示 Map 中所有键的集合，K 是键的类型。

values()

返回 Map 中所有值的集合。

Collection<V> values();

// retuen：Collection<V>，表示 Map 中所有值的集合，V 是值的类型。

entrySet()

Set<Map.Entry<K, V>> entrySet();

// 返回一个包含所有键值对的集合（Set<Map.Entry<K, V>>）。

Map.Entry

Map.Entry 是 Map 接口中的一个内部接口，此接口为泛型，定义为Entry<K,V>，表示Map中的一个键值对。

Map.Entry 定义了方法来访问和操作键值对中的键和对应的值。

getKey()

返回 Map.Entry 对象中存储的键。

K getKey();

getValue()

返回 Map.Entry 对象中存储的值。

V getValue();

setValue(V value)

设置 Map.Entry 对象中存储的值。

V setValue(V value);

HashMap

java.util.HashMap

HashMap 实现了 Map 接口，继承于AbstractMap。

new

// 构造一个空的 HashMap，具有默认初始容量（16）和默认负载因子（0.75）。
// 负载因子表示在 HashMap 自动扩容前，可以填充的最大元素数占当前容量的比例。
HashMap<K, V> map = new HashMap<>();

// 构造一个具有指定初始容量的空 HashMap。
HashMap<K, V> map = new HashMap<>(int initialCapacity);

// 构造一个具有指定初始容量和负载因子的空 HashMap。
HashMap<K, V> map = new HashMap<>(int initialCapacity, float loadFactor);

// 构造一个包含指定映射中所有键值对的 HashMap，构造方法会将映射中的所有键值对复制到新创建的 HashMap 中。
HashMap<K, V> map = new HashMap<>(Map<? extends K, ? extends V> m);

SortedMap

java.util.SortedMap，SortedMap是Map的子接口。

TreeMap

java.util.TreeMap，TreeMap是SortedMap的实现类。

new

// 构造一个空的 TreeMap，使用键的自然顺序进行排序。
TreeMap<K, V> map = new TreeMap<>();

// 构造一个空的 TreeMap，使用指定的 Comparator 进行排序。
TreeMap<K, V> map = new TreeMap<>(Comparator<? super K> comparator);

// 构造一个包含指定映射中所有键值对的 TreeMap，使用键的自然顺序。
TreeMap<K, V> map = new TreeMap<>(Map<? extends K, ? extends V> m);

// 构造一个包含指定排序映射中所有键值对的 TreeMap，使用键的自然顺序。
TreeMap<K, V> map = new TreeMap<>(SortedMap<K, ? extends V> m);

File

java.io.File

exists()

boolean exists()

检查 File 对象表示的路径（文件或目录）在文件系统中是否存在。

存在则返回 true，否则返回 false。

System

java.lang.System

getenv()

获取操作系统的环境变量。

currentTimeMillis()

long currentTimeMillis();

// return：long 类型，表示自 1970年1月1日00:00:00 UTC 至当前时刻的毫秒数。

调用示例

System.out.println(System.currentTimeMillis());

// 1738742578052
// 1738744335058108240

Random

java.util.Random

nextInt()

生成随机整数

int nextInt(); // 生成任意整数（int 的完整范围）
int nextInt(int bound); // 生成 [0, bound) 之间的整数

nextFloat()

生成随机单精度浮点数

float nextFloat();

// 生成 [0.0, 1.0) 之间的 float 类型随机数（包含 0.0，不包含 1.0）。

nextDouble()

生成随机双精度浮点数

double nextDouble();

// 生成 [0.0, 1.0) 之间的 double 类型随机数（包含 0.0，但不包含 1.0）。

nextBoolean()

生成随机布尔值

boolean nextBoolean();

// 50% 概率返回 true，50% 概率返回 false。

nextBytes()

生成随机字节数组

void nextBytes(byte[] bytes);

// 该方法不返回值，而是 直接修改传入的 bytes 数组，将每个元素设置为随机 byte（即 -128 到 127 之间）。

面向对象

Interface（接口）

定义接口

接口的定义使用interface关键字。接口中的方法默认是public和abstract，不需要显式声明。

public interface Animal {
    void sound();  // 声明抽象方法
    void sleep();
}

接口的实现

通过implements关键字实现接口。实现接口的类必须提供接口中所有方法的具体实现。

public class Dog implements Animal {
    @Override
    public void sound() {
        System.out.println("Bark");
    }

    @Override
    public void sleep() {
        System.out.println("Dog is sleeping");
    }
}

接口的继承

接口也可以继承其他接口。一个接口可以扩展多个接口，这意味着一个类可以实现多个接口，从而实现多继承。

public interface Mammal extends Animal {
    void feed();
}

public class Cat implements Mammal {
    @Override
    public void sound() {
        System.out.println("Meow");
    }

    @Override
    public void sleep() {
        System.out.println("Cat is sleeping");
    }

    @Override
    public void feed() {
        System.out.println("Cat is feeding");
    }
}

InnerClass（内部类）

成员内部类

成员内部类是定义在外部类内部、方法外部的类。

成员内部类可以直接访问外部类的所有成员（包括私有成员）。

必须通过外部类对象来创建内部类对象。

内部类会隐式持有一个外部类对象的引用。

class Outer {
    private String message = "Hello from Outer class";

    class Inner {
        void display() {
            System.out.println(message); // 访问外部类的私有成员
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner(); // 创建内部类对象
        inner.display();
    }
}

静态内部类

使用 static 修饰的内部类称为静态内部类。

静态内部类不依赖于外部类的实例，因此无法访问外部类的非静态成员。

不需要外部类的实例即可创建静态内部类对象。

只能访问外部类的静态成员。

class Outer {
    private static String message = "Hello from static Outer class";

    static class StaticInner {
        void display() {
            System.out.println(message); // 访问外部类的静态成员
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Outer.StaticInner inner = new Outer.StaticInner(); // 直接创建静态内部类对象
        inner.display();
    }
}

局部内部类

局部内部类是在外部类的方法或作用域内定义的类。

它的作用范围仅限于定义它的方法或代码块中。

局部内部类可以访问所在方法的局部变量，但这些变量必须是 final 或 effectively final。

通常用于封装方法的实现细节。

class Outer {
    void display() {
        class LocalInner {
            void print() {
                System.out.println("Hello from LocalInner class");
            }
        }
        LocalInner inner = new LocalInner(); // 在方法内部使用局部内部类
        inner.print();
    }
}

public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.display();
    }
}

匿名内部类

匿名内部类是没有名字的类，通常用于简化代码实现。

常见于接口或抽象类的快速实现。

匿名内部类必须继承一个类或实现一个接口。

用于简化代码实现，无需单独定义类。

• 匿名内部类实现接口

  interface Greeting {
      void sayHello();
  }
  
  public class Main {
      public static void main(String[] args) {
          Greeting greeting = new Greeting() { // 创建匿名内部类
              @Override
              public void sayHello() {
                  System.out.println("Hello from Anonymous Inner Class");
              }
          };
          greeting.sayHello();
      }
  }

• 匿名内部类继承类

  class Animal {
      void makeSound() {
          System.out.println("Animal makes a sound.");
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          // 使用匿名内部类继承 Animal 类
          Animal dog = new Animal() {
              @Override
              void makeSound() {
                  System.out.println("Dog barks: Woof Woof!");
              }
          };
          dog.makeSound(); // 调用匿名内部类的重写方法
      }
  }

Java反射

示例类

public class Student {

    // 属性
    private String name;
    private int age;
    public static String school = "High School";

    // 构造方法
    public Student() {
        this.name = "Unknown";
        this.age = 0;
    }
    
    private Student(String name) {
        this.name = name;
        this.age = 18; // 默认年龄
    }

    public Student(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 void introduce() {
        System.out.println("Hi, my name is " + name + ", and I am " + age + " years old.");
    }

    // 私有方法
    private void printSecret() {
        System.out.println("This is a private method.");
    }

    // 静态方法
    public static String getSchool() {
        return school;
    }

    public static void setSchool(String schoolName) {
        school = schoolName;
    }
}

Class对象

获取Class对象

• 通过对象获取
  Class<?> clazz = object.getClass();

  public static void main(String[] args) {
      Student stu = new Student("Bileton",21);
      Class stuClass = stu.getClass();
      System.out.println(stuClass.getName()); // Student
  }

• 通过类获取
  Class<?> clazz = ClassName.class;

  public static void main(String[] args) {
      Class stuClass = Student.class;
      System.out.println(stuClass.getName()); // Student
  }

• 通过全类名获取
  Class<?> clazz = Class.forName(String className);

  public static void main(String[] args) throws ClassNotFoundException {
      Class strClass = Class.forName("java.lang.String");
      System.out.println(strClass.getName()); // java.lang.String
  }

  Class.forName()会在加载类的同时对类进行初始化。

构造方法对象

获取构造方法对象

• 获取公有构造方法对象的数组
  Constructor<?>[] getConstructors()

  public static void main(String[] args) {
      Class stuClass = Student.class;
      Constructor[] constructors = stuClass.getConstructors();
      for (Constructor constructor : constructors) {
          System.out.println(constructor);
      }
  }

• 获取所有构造方法对象的数组
  Constructor<?>[] getDeclaredConstructors()

  public static void main(String[] args) {
      Class stuClass = Student.class;
      Constructor[] constructors = stuClass.getDeclaredConstructors();
      for (Constructor constructor : constructors) {
          System.out.println(constructor);
      }
  }

• 获取单个公有构造方法对象
  Constructor<?> getConstructor()

  public static void main(String[] args) throws NoSuchMethodException {
      Class stuClass = Student.class;
      Constructor constructor1 = stuClass.getConstructor();
      Constructor constructor2 = stuClass.getConstructor(String.class,int.class);
      System.out.println(constructor1);
      System.out.println(constructor2);
  }

• 获取单个构造方法对象

  Constructor<?> getDeclaredConstructor()

  public static void main(String[] args) throws NoSuchMethodException {
      Class stuClass = Student.class;
      Constructor constructor = stuClass.getDeclaredConstructor(String.class);
      System.out.println(constructor);
  }

调用构造方法

newInstance()

Object obj = constructor.getDeclaredConstructor().newInstance(Object... initargs);

• 调用公有构造方法

  public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
      Class stuClass = Student.class;
      Constructor constructor = stuClass.getConstructor(String.class,int.class);
      Student stu = (Student) constructor.newInstance("Bileton",21);
      System.out.println(stu.getName()+" "+stu.getAge()); // Bileton 21
  }

• 调用私有构造方法
  使用setAccessible(true)突破 Java 的访问控制限制，使得私有成员（字段、方法或构造方法）可以被访问。

  public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
      Class stuClass = Student.class;
      Constructor constructor = stuClass.getDeclaredConstructor(String.class);
      constructor.setAccessible(true);
      Student stu = (Student) constructor.newInstance("Bileton");
      System.out.println(stu.getName()+" "+stu.getAge()); // Bileton 18
  }

Field属性对象

获取成员属性对象

• 获取公有成员属性对象的数组
  Field[] getFields()

  public static void main(String[] args) {
      Class stuClass = Student.class;
      Field[] fields = stuClass.getFields(); 
      for (Field field : fields) {
          System.out.println(field.getName()); // school
      }
  }

• 获取所有成员属性对象的数组
  Field[] getDeclaredFields()

  public static void main(String[] args) {
      Class stuClass = Student.class;
      Field[] fields = stuClass.getDeclaredFields();
      for (Field field : fields) {
          System.out.println(field);
      }
  }

• 获取单个公有成员属性对象
  Field[] getField(String name)

  public static void main(String[] args) throws NoSuchFieldException {
      Class stuClass = Student.class;
      Field fields = stuClass.getField("school");
      System.out.println(fields);
      // public static java.lang.String Student.school
  }

• 获取单个成员属性对象
  Field[] getDeclaredField(String name)

  public static void main(String[] args) throws NoSuchFieldException {
      Class stuClass = Student.class;
      Field fields = stuClass.getDeclaredField("name");
      System.out.println(fields);
      // private java.lang.String Student.name
  }

获取和设置属性的值

• get(Object obj)

  Object value = field.get(Object obj);
  Object value = field.get(null);  // 静态字段，obj 为 null

• set(Object obj, Object value)

  field.set(Object obj, Object value);
  field.set(null, newValue);  // 静态字段，obj 为 null

public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
    Class stuClass = Student.class;
    Constructor constructor = stuClass.getConstructor(String.class,int.class);
    Student Stu = (Student) constructor.newInstance("Bileton",21);
    Field name_field = stuClass.getDeclaredField("name");
    Field age_field = stuClass.getDeclaredField("age");
    name_field.setAccessible(true);
    age_field.setAccessible(true);
    String name = (String) name_field.get(Stu);
    int age = (int) age_field.get(Stu);
    System.out.println(name+" "+age); // Bileton 21
    name_field.set(Stu,"bileton");
    age_field.set(Stu,18);
    name = (String) name_field.get(Stu);
    age = (int) age_field.get(Stu);
    System.out.println(name+" "+age); // bileton 18
}

Method方法对象

获取方法对象

• 获取公有成员方法对象的数组，包括继承的
  Method[] getMethods()

  public static void main(String[] args) throws NoSuchFieldException {
      Class stuClass = Student.class;
      Method[] methods = stuClass.getMethods();
      for (Method method : methods) {
          System.out.println(method);
      }
  }

• 获取所有成员方法对象的数组，不包括继承的
  Method[] getDeclaredMethods()

   public static void main(String[] args) throws NoSuchFieldException {
      Class stuClass = Student.class;
      Method[] methods = stuClass.getDeclaredMethods();
      for (Method method : methods) {
          System.out.println(method);
      }
  }

• 获取单个公有成员方法对象
  Method getMethod(String name,Class<?>…parameterTypes)

  public static void main(String[] args) throws NoSuchMethodException {
      Class stuClass = Student.class;
      Method method = stuClass.getMethod("introduce");
      System.out.println(method);
  }

• 获取单个成员方法对象
  Method getDeclaredMethod(String name,Class<?>…parameterTypes)

  public static void main(String[] args) throws NoSuchMethodException {
      Class stuClass = Student.class;
      Method method = stuClass.getDeclaredMethod("printSecret");
      System.out.println(method);
  }

调用方法

Method.invoke()

Object returnValue = method.invoke(Object obj, Object... args);

// 	method 是通过反射获取的 Method 对象，表示某个类的方法。
//	obj 是调用方法的目标对象。对于实例方法，obj 是目标对象的实例；对于静态方法，obj 可以是 null。
//	args 是传递给方法的参数列表。方法的参数需要按顺序传递，并且类型要匹配。

调用公有方法和私有方法

public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
    Class stuClass = Student.class;
    Constructor constructor = stuClass.getConstructor(String.class,int.class);
    Student Stu = (Student) constructor.newInstance("Bileton",21);
    Method printSecret = stuClass.getDeclaredMethod("printSecret");
    printSecret.setAccessible(true);
    printSecret.invoke(Stu); // This is a private method.
}

获取方法参数信息

public Parameter[] getParameters();

ClassLoader类加载器对象

获取类加载器对象

getClassLoader()

public ClassLoader getClassLoader();

通过Class对象获取ClassLoader

ClassLoader classLoader = clazz.getClassLoader();

public static void main(String[] args) throws ClassNotFoundException {
    Class clazz = Class.forName(String className);
    ClassLoader classLoader = clazz.getClassLoader();
    System.out.println("ClassLoader:" + classLoader);  // 输出 null
}

通过类加载器对象加载类

loadClass(String name)

public Class<?> loadClass(String name) throws ClassNotFoundException;

通过ClassLoader对象加载类

Class<?> clazz = classLoader.loadClass(String className);

loadClass()用于加载类，但不会初始化类。

其他常用方法

• getName()

  用于获取类、构造方法、方法或字段的名称。

  public String getName();

• getModifiers()

  获取类、方法、字段或构造方法的访问修饰符。

  public int getModifiers();

  getModifiers() 返回一个 int 类型的值，这个整数值表示多个修饰符的位运算组合。

• setAccessible(true)

  用于修改类、方法、字段等成员的访问权限，以便访问被 private、protected 或 default（包内访问权限）修饰的成员。

HttpClient

简单同步get请求

public static void sync_http_get(){
    HttpClient httpClient = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://httpbin.org/get"))
            .build();
    HttpResponse<String> response;
    {
        try {
            response = httpClient.send(request,HttpResponse.BodyHandlers.ofString());
            System.out.println("Response Code: " + response.statusCode());
            System.out.println("Response Body: " + response.body());
        } catch (IOException e) {
            throw new RuntimeException(e);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

简单异步get请求

// 推荐使用共享的 HttpClient 实例
private static final HttpClient httpClient = HttpClient.newHttpClient();

public static void asyncHttp() {
    HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://httpbin.org/get"))
            .header("User-Agent", "Java-Async-HTTP/1.0") // 添加必要请求头
            .timeout(java.time.Duration.ofSeconds(10))    // 请求超时设置
            .build();

    // 发起异步请求
    CompletableFuture<HttpResponse<String>> futureResponse =
            httpClient.sendAsync(request, HttpResponse.BodyHandlers.ofString());

    // 处理异步响应（链式调用）
    futureResponse
            .thenApply(response -> {  // 转换响应结果
                System.out.println("【响应元数据】");
                System.out.println("状态码: " + response.statusCode());
                System.out.println("协议版本: " + response.version());
                return response.body(); // 传递 body 到下一环节
            })
            .thenAccept(body -> {     // 消费最终结果
                System.out.println("\n【响应内容】");
                System.out.println(body);
            })
            .exceptionally(ex -> {    // 统一异常处理
                System.err.println("\n【请求失败】");
                ex.printStackTrace();
                return null;
            });

    // 保持主线程运行（演示用）
    try {
        TimeUnit.SECONDS.sleep(3); // 等待异步操作完成
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

简单同步post请求

JSON

public static void sync_http_post(){
    HttpClient httpClient = HttpClient.newHttpClient();

    String jsonBody = "{\"name\":\"John\", \"age\":30}";

    HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://httpbin.org/post"))
            .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
            .build();

    try {
        HttpResponse<String> response = httpClient.send(request,HttpResponse.BodyHandlers.ofString());
        System.out.println("响应状态码: " + response.statusCode());
        System.out.println("响应内容:\n" + response.body());
    } catch (IOException e) {
        throw new RuntimeException(e);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
}

FORM

public static void sync_http_post(){
    HttpClient httpClient = HttpClient.newHttpClient();

    String formData = "username=admin&password=123456";

    HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://httpbin.org/post"))
            .POST(HttpRequest.BodyPublishers.ofString(formData))
            .build();

    try {
        HttpResponse<String> response = httpClient.send(request,HttpResponse.BodyHandlers.ofString());
        System.out.println("响应状态码: " + response.statusCode());
        System.out.println("响应内容:\n" + response.body());
    } catch (IOException e) {
        throw new RuntimeException(e);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
}