Java常用API

qxl217

已于 2023-08-09 13:56:30 修改

阅读量117

点赞数 2

文章标签： java python 开发语言

于 2023-08-07 15:39:01 首次发布

本文链接：https://blog.csdn.net/qxl217/article/details/132144178

版权

什么是API

API（应用程序编程接口）指的是一组定义了软件组件或服务之间交互规则的接口。它定义了如何通过预定义的方法和数据结构与其他软件组件进行通信，以实现特定的功能。
API可以被看作是两个不同的软件系统之间进行通信的桥梁。它提供了一种标准化的方式，使得不同的系统能够互相访问和使用彼此的功能，而无需了解底层实现的细节。
通过API，一个应用程序可以向另一个应用程序发送请求，并获取相应的响应。API定义了请求的格式和参数，以及响应的数据格式。它可以用于访问远程服务器上的服务，与操作系统交互，或者与第三方库进行通信。

Web API：用于构建和访问Web服务，如RESTful API。
库API：提供了一组函数或类，供开发人员在自己的应用程序中使用。
操作系统API：允许应用程序与操作系统进行交互，访问底层功能和资源。
第三方API：由第三方开发的接口，用于与其提供的服务或功能进行集成。

API的好处包括提高代码的可重用性和模块化、简化系统集成和开发过程、促进团队合作和加速应用程序开发。通过使用API，开发人员能够专注于自己的核心业务逻辑，而无需从头开始构建所有功能。

常见的常用类

常用类是指在软件开发中经常被使用的类。这些类提供了各种常见的功能和工具，可以帮助开发人员快速实现特定的任务。常用类通常属于编程语言或者某个库的核心部分，被广泛应用于各种应用程序开发中。

特点：

提供了常见操作和功能：常用类通常封装了一些常见的操作和功能，如字符串处理、数学运算、文件和流操作、日期和时间处理等，供开发人员使用。
高度可重用性：常用类被广泛使用，具有高度的可重用性。它们经过充分的测试和优化，可以在不同的项目和场景中重复使用，提高代码的效率和可维护性。
提供了抽象和封装：常用类通常对底层的复杂性进行了抽象和封装，提供了简单易用的接口和方法，使开发人员可以轻松使用这些功能，无需关注底层实现细节。

java.lang

String

String类是Java编程语言中的一个类，用于表示字符串。字符串是一组字符的序列，可以包含字母、数字、符号等字符。在Java中，字符串是不可变的，即创建后不能修改。String类提供了许多方法来操作字符串，比如连接、截取、查找等。

方法	功能
length()	返回字符串的长度。
charAt(index)	返回指定索引位置的字符。
substring(beginIndex, endIndex)	返回从beginIndex到endIndex之间的子字符串。
indexOf(str)	返回字符串中第一次出现指定子字符串的位置。
toUpperCase()	将字符串转换为大写。
toLowerCase()	将字符串转换为小写。
String s=”Hello!”	用字符串常量自动创建 String 实例。
String s=new String(String s)	通过 String 对象或字符串常量传递给构造方法。
public String(char value[])	将整个字符数组赋给 String 构造方法。
public String(char value[], int offset, int count)	将字符数组的一部分赋给 String 构造方法，offset 为起始下标，count为子数组长度。

String类代码示例：

public class StringExample {
    public static void main(String[] args) {
        // 创建一个字符串
        String str = "Hello, World!";

        // 获取字符串长度
        int length = str.length();
        System.out.println("Length: " + length); // 输出: Length: 13

        // 提取子字符串
        String subStr = str.substring(7, 12);
        System.out.println("Substring: " + subStr); // 输出: Substring: World

        // 拼接字符串
        String newStr = str + " Welcome!";
        System.out.println("New String: " + newStr); // 输出: New String: Hello, World! Welcome!

        // 检查字符串包含
        boolean contains = str.contains("World");
        System.out.println("Contains 'World': " + contains); // 输出: Contains 'World': true

        // 检查字符串是否以指定前缀开始
        boolean startsWith = str.startsWith("Hello");
        System.out.println("Starts with 'Hello': " + startsWith); // 输出: Starts with 'Hello': true

        // 检查字符串是否以指定后缀结束
        boolean endsWith = str.endsWith("World");
        System.out.println("Ends with 'World': " + endsWith); // 输出: Ends with 'World': false
    }
}

StringBuilder

StringBuffer类是Java编程语言中的一个类，用于表示可变的字符串。与String类不同，StringBuffer类的对象可以被修改，即在原有的字符串上进行添加、插入、删除等操作

构造方法	说明
StringBuffer()	使用该无参数的构造方法创建的 StringBuffer 对象，初始容量为 16 个字符，当对象存放的字符序列大于 16 个字符时，对象的容量自动增加。该对象可以通过 length()方法获取实体中存放的字符序列的长度，通过 capacity()方法获取当前对象的实际容量。
StringBuffer(int length)	使用该构造方法创建的 StringBuffer 对象，其初始容量为参数 length 指定的字符个数，当对象存放的字符序列的长度大于 length 时，对象的容量自动增加，以便存放所增加的字符。
StringBuffer(Strin str)	使用该构造方法创建的 StringBuffer 对象，其初始容量为参数字符串 str 的长度再加上 16 个字符。

几种 StringBuffer 类常用的方法

方法	说明
append()	使用 append() 方法可以将其他 Java 类型数据转化为字符串后再追加到 StringBuffer 的对象中。
insert(int index, String str)	insert() 方法将一个字符串插入对象的字符序列中的某个位置。
setCharAt(int n, char ch)	将当前 StringBuffer 对象中的字符序列 n 处的字符用参数 ch 指定的字符替换，n 的值必须是非负的，并且小于当前对象中字符串序列的长度。
reverse()	使用 reverse()方法可以将对象中的字符序列翻转。
delete(int n, int m)	从当前 StringBuffer 对象中的字符序列删除一个子字符序列。这里的 n 指定了需要删除的第一个字符的下标，m 指定了需要删除的最后一个字符的下一个字符的下标，因此删除的子字符串从 n~m-1。
replace(int n, int m, String str)	用 str 替换对象中的字符序列，被替换的子字符序列由下标 n 和 m 指定。

StringBuilder代码示例：

public class StringBufferExample {
    public static void main(String[] args) {
        // 创建一个空的StringBuffer对象
        StringBuffer sb = new StringBuffer();

        // 在末尾追加字符串
        sb.append("Hello");
        sb.append(", ");
        sb.append("World!");

        System.out.println(sb.toString()); // 输出: Hello, World!

        // 在指定位置插入字符串
        sb.insert(5, " Beautiful");

        System.out.println(sb.toString()); // 输出: Hello Beautiful, World!

        // 删除指定范围的字符
        sb.delete(6, 16);

        System.out.println(sb.toString()); // 输出: Hello, World!

        // 反转字符串
        sb.reverse();

        System.out.println(sb.toString()); // 输出: !dlroW ,olleH

        // 替换字符串
        sb.replace(0, 5, "Hi");

        System.out.println(sb.toString()); // 输出: Hi, World!
    }
}

Math

Math类是Java语言中的一个内置类，属于java.lang包。它提供了一系列用于执行数学计算的静态方法。Math类中的方法包括数值计算、取整、取绝对值、计算三角函数、指数、对数等常见的数学运算。这些方法可以帮助开发者进行各种数学计算，并返回计算结果。
Math类的方法都是静态方法，因此可以直接通过类名调用，无需创建Math类的对象。这使得使用Math类的方法非常方便和简单。对于涉及数学计算的场景，开发者可以使用Math类提供的方法来执行各种数学运算，而无需自己编写相应的算法。

方法	功能
int abs(int i)	求整数的绝对值（另有针对long、float、double的方法）
double ceil(double d)	不小于d的最小整数（返回值为double型）
double floor(double d)	不大于d的最大整数（返回值为double型）
int max(int i1,int i2)	求两个整数中最大数（另有针对long、float、double的方法）
int min(int i1,int i2)	求两个整数中最小数（另有针对long、float、double的方法）
double random()	产生0~1之间的随机数
int round(float f)	求最靠近f的整数
long round(double d)	求最靠近d的长整数
double sqrt(double a)	求平方根
double sin(double d)	求d的sin值（另有求其他三角函数的方法如cos，tan，atan）
double log(double x)	求自然对数
double exp(double x)	求e的x次幂（ex）
double pow(double a, double b)	求a的b次幂

1.计算绝对值：

int num = -5;
int absoluteValue = Math.abs(num);
System.out.println(absoluteValue);  // 输出: 5

计算两个数中的最大值：

int a = 10;
int b = 5;
int max = Math.max(a, b);
System.out.println(max);  // 输出: 10

计算两个数中的最小值：

int a = 10;
int b = 5;
int min = Math.min(a, b);
System.out.println(min);  // 输出: 5

生成一个介于0和1之间的随机浮点数，并取两位小数：

double randomNum = Math.random();
double roundedNum = Math.round(randomNum * 100) / 100.0;
System.out.println(roundedNum);

计算指定数的平方根：

double num = 16;
double squareRoot = Math.sqrt(num);
System.out.println(squareRoot);  // 输出: 4.0

计算三角函数的值：

double angleInDegrees = 45;
double angleInRadians = Math.toRadians(angleInDegrees);
double sinValue = Math.sin(angleInRadians);
double cosValue = Math.cos(angleInRadians);
double tanValue = Math.tan(angleInRadians);
System.out.println("Sin: " + sinValue);
System.out.println("Cos: " + cosValue);
System.out.println("Tan: " + tanValue);

四舍五入取整：

double num = 4.6;
long rounded = Math.round(num);
System.out.println(rounded);  // 输出: 5

Object

Object类是Java语言中的一个根类，它位于java.lang包下。它是所有类的超类，也就是说所有其他类都默认直接或间接地继承了Object类。因此，Object类是Java对象模型的基础

方法	功能
equals(Object obj)	用于判断当前对象是否与另一个对象相等。
hashCode()	返回当前对象的哈希码值。
toString()	返回对象的字符串表示形式。
getClass()	返回当前对象的运行时类。
clone()	创建并返回当前对象的一个副本。
finalize()	在对象即将被垃圾回收时调用。
notify()	唤醒在当前对象上等待的单个线程。
notifyAll()	唤醒在当前对象上等待的所有线程。
wait()	导致当前线程等待，直到其他线程调用该对象的notify()或notifyAll()方法唤醒它。
wait(long timeout)	导致当前线程等待一段时间，直到其他线程调用该对象的notify()或notifyAll()方法唤醒它。

Object类的默认实现对于大多数类是适用的，但在需要特定行为的情况下，可以在子类中重写这些方法来提供更具体的实现。例如，子类可以重写equals方法来比较对象的特定属性，或者重写toString方法以提供更有意义的字符串表示。

需要注意的是，虽然所有类都继承自Object类，但是一些特殊类（如基本数据类型的包装类）可能会隐藏或覆盖Object类的方法。另外，Object类不能被实例化，也就是不能使用new Object()来创建Object对象。

Object类代码示例：

使用equals方法比较两个对象是否相等：

String str1 = "Hello";
String str2 = "Hello";
boolean equal = str1.equals(str2);
System.out.println(equal);  // 输出: true

使用hashCode方法获取对象的哈希码值：

String str = "Hello";
int hashCode = str.hashCode();
System.out.println(hashCode);  // 输出: 69609650

使用toString方法将对象转换成字符串表示：

String str = "Hello";
String strString = str.toString();
System.out.println(strString);  // 输出: Hello

使用getClass方法获取对象的运行时类：

String str = "Hello";
Class<?> strClass = str.getClass();
System.out.println(strClass.getName());  // 输出: java.lang.String

使用clone方法复制对象：

MyClass obj1 = new MyClass();
MyClass obj2 = obj1.clone();

使用wait和notify方法实现线程间通信：

public class Message {
    private String msg;
    private boolean isNewMessage = false;

    public synchronized void setMessage(String msg) {
        while (isNewMessage) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.msg = msg;
        isNewMessage = true;
        notify();
    }

    public synchronized String getMessage() {
        while (!isNewMessage) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        isNewMessage = false;
        notify();
        return msg;
    }
}

System

System类是Java中的一个包含一些有用静态方法和字段的类，位于java.lang包下。它提供了与系统和运行时环境交互的方法，以及与标准输入、输出和错误流进行交互的方法

方法	功能
public static void exit(int status)	终止当前正在运行的Java虚拟机，status参数指定了退出的状态码。
public static long currentTimeMillis()	返回当前时间（以毫秒为单位）。
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)	将数组中指定范围的元素从源数组复制到目标数组。
public static Properties getProperties()	获取系统的一些属性信息。
public static String getProperty(String key)	获取指定键的系统属性值。
public static String getenv(String name)	获取指定环境变量的值。
public static void gc()	运行垃圾回收器。
public static void setIn(InputStream in)	重新分配标准输入流。
public static void setOut(PrintStream out)	重新分配标准输出流。
public static void setErr(PrintStream err)	重新分配标准错误流。

System类还包含一些静态常量

方法	功能
public static final InputStream in	表示标准输入流。
public static final PrintStream out	表示标准输出流。
public static final PrintStream err	表示标准错误流。

System类的静态方法和字段提供了许多方便的功能，用于与底层系统、运行时环境和输入输出流进行交互。使用这些方法可以实现与操作系统的交互、性能分析、时间计算等功能。

System类代码示例：

public class SystemExample {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
        System.out.print("This is ");
        System.out.print("an example ");
        System.out.println("of output using System class.");
        
        int x = 10;
        double y = 3.14;
        System.out.printf("The value of x is %d and y is %.2f%n", x, y);
        
        String message = "Hello, System!";
        System.out.println(message);
    }
}
输出：
Hello, World!
This is an example of output using System class.
The value of x is 10 and y is 3.14
Hello, System!

Thread

Thread类是Java语言中的一个系统类，位于java.lang包下。它用于创建和操作线程，使得程序可以同时执行多个任务或操作，实现并发编程。
通过Thread类，可以创建新的线程对象，并通过继承Thread类或实现Runnable接口来定义线程的执行逻辑。线程可以执行独立的代码路径，具有自己的栈空间和程序计数器。

方法	功能
start()	启动线程，使其进入可执行状态，等待调度执行。
run()	线程的执行逻辑，需要在该方法中定义线程要执行的任务。
sleep(long millis)	让当前线程进入睡眠状态，暂停执行指定的毫秒数。
join()	等待该线程执行完毕。
interrupt()	中断当前线程。
isInterrupted()	检查线程是否被中断。
getName()和setName(String name)	获取和设置线程的名称。
getPriority()和setPriority(int priority)	获取和设置线程的优先级。

使用多线程可以提高程序的性能和响应性，例如在网络通信、并发处理、耗时操作等方面有很大的应用场景。但需要注意合理使用线程，避免多线程竞争引发的问题，如数据同步、死锁等。

Thread类创建和启动线程的示例：

public class ThreadExample extends Thread {
    public void run() {
        System.out.println("Thread is running.");
        for (int i = 0; i < 5; i++) {
            System.out.println("Thread: " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Thread is finished.");
    }

    public static void main(String[] args) {
        ThreadExample thread = new ThreadExample();
        thread.start(); // 启动线程

        System.out.println("Main Thread is running.");

        try {
            thread.join(); // 等待子线程执行完毕
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Main Thread is finished.");
    }
}

输出:
Main Thread is running.
Thread is running.
Thread: 0
Thread: 1
Thread: 2
Thread: 3
Thread: 4
Thread is finished.
Main Thread is finished.

Class< T >

Class是一个泛型类，用于表示特定类型（class）的类对象（class object）。它能够提供有关类的元信息，如类的名称、字段、方法、构造函数等。

获取构造方法：

方法	功能
Constructor<?>[] getConstructors()	获取所有public修饰的构造方法。
Constructor getConstructor(类<?>… parameterTypes)	获取指定名称的 public修饰的构造方法。
Constructor getDeclaredConstructor(类<?>… parameterTypes)	获取所有的构造方法，不考虑修饰符。
Constructor<?>[] getDeclaredConstructors()	获取指定名称的构造方法。

获取成员方法：

方法	功能
Method[] getMethods()	获取所有public修饰的成员方法。
Method getMethod(String name, 类<?>… parameterTypes)	获取指定名称的 public修饰的成员方法。
Method[] getDeclaredMethods()	获取所有的成员方法，不考虑修饰符。
Method getDeclaredMethod(String name, 类<?>… parameterTypes)	获取指定名称的成员方法。

通过Class，可以在运行时获取类的相关信息，并在需要时进行实例化、调用方法和操作字段。这对于反射、依赖注入和工厂模式等编程场景非常有用。

java.util

Scanner

Scanner类是Java标准库中的一个类，用于从不同类型的输入源（如控制台、文件、字符串等）获取用户输入或读取数据。它提供了一组方法用于解析和提取不同类型的数据。
使用Scanner类，可以方便地从输入源中读取数据，并将其转换为合适的数据类型。它支持读取各种基本数据类型（如整数、浮点数、布尔值等）、字符串以及定制的分隔符。

Scanner类的常用构造方法：

方法	功能
Scanner(File source)	根据文件对象创建Scanner对象，用于从文件中读取数据。
Scanner(InputStream source)	根据输入流对象创建Scanner对象，用于从输入流中读取数据。
Scanner(String source)	根据字符串创建Scanner对象，用于从字符串中读取数据。

Scanner类的常用方法：

方法	功能
next()	将输入解释为一个字符串，返回从输入中读取的下一个以空格为分隔符的字符串。
nextInt()	将输入解析为一个整数，返回从输入中读取的下一个整数。
nextDouble()	将输入解析为一个双精度浮点数，返回从输入中读取的下一个双精度浮点数。
nextLine()	将输入解释为一个字符串，返回从输入中读取的下一行字符串。
hasNext()	检查输入源是否还有下一个元素。
close()	关闭Scanner对象，释放相关资源。

Scanner类代码示例：

import java.util.Scanner;

public class Example {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入一个整数：");
        int number = scanner.nextInt();
        System.out.println("输入的整数是：" + number);

        System.out.print("请输入一个字符串：");
        String str = scanner.next();
        System.out.println("输入的字符串是：" + str);

        scanner.close();
    }
}

Scanner类提供了方便的方式来解析和读取各种类型的数据，使得处理用户输入和文件读取变得更加简单。

Objects

Objects类是Java标准库中提供的一个实用工具类，位于java.util包中。它提供了一系列静态方法，用于操作和处理对象。
Objects类的主要目的是提供一些常用的方法来处理对象，特别是针对对象的空值处理和对象比较。它在处理可能为空的对象时特别有用，可以避免出现NullPointerException异常。

Objects类常用方法：

方法	功能
equals(Object a, Object b)	用于比较两个对象是否相等。比较时会考虑到两个对象都为null的情况，以及调用对象的equals()方法。
deepEquals(Object[] a, Object[] b)	用于深度比较两个对象数组是否相等。会递归比较数组元素是否相等，也会考虑到数组元素为null的情况。
hashCode(Object o)	返回一个对象的哈希码。如果对象为null，则返回0。
toString(Object o)	返回对象的字符串表示。如果对象为null，则返回字符串"null"。

除了上述方法之外，Objects类还提供了其他一些有用的方法，如requireNonNull(T obj)，它用于检查对象是否为null，如果是null则抛出NullPointerException异常。

Objects类的示例：

import java.util.Objects;

public class Example {
    public static void main(String[] args) {
        String s1 = "Hello";
        String s2 = null;

        boolean isEqual = Objects.equals(s1, s2);
        System.out.println("s1和s2是否相等：" + isEqual);
    }
}

Date

java.util.Date类是Java标准库中提供的一个用于表示日期和时间的类。它位于java.util包中，被广泛用于处理日期和时间的计算、格式化和解析。
Date类可以存储自1970年1月1日 00:00:00 GMT以来的毫秒数。它提供了多个构造方法，可以根据给定的年、月、日、时、分、秒等参数创建日期对象。
尽管Date类是用来表示日期和时间的，但它本身不包含任何与时区相关的信息或任何日期操作的方法。它只是简单地存储了一个时间戳。因此，在进行日期和时间计算时，通常需要使用java.util.Calendar或更高级的日期和时间处理库，例如java.time包下的类

Date类常用的方法：

方法	功能
toString()	将日期对象转换为字符串表示的形式。
getTime()	返回日期对象的时间戳，以毫秒为单位。
equals(Object obj)	用于比较两个日期对象是否相等。
before(Date when)和after(Date when)	用于比较两个日期对象的先后顺序。
compareTo(Date anotherDate)	比较两个日期对象的顺序，返回一个整数值。

Date类的示例：

import java.util.Date;

public class Example {
    public static void main(String[] args) {
        Date currentDate = new Date();
        System.out.println("当前日期是：" + currentDate.toString());
    }
}

Calendar

java.util.Calendar类是Java标准库中提供的一个用于进行日期和时间计算的类。它用于操作日期、时间和日历字段，提供了一些实用的方法来处理日期和时间的计算、格式化和解析。

[1 ] 获取特定日期和时间的各个组成部分，如年、月、日、时、分、秒等。
[2 ]设置日期和时间的各个组成部分，或对已有的日期和时间进行修改。
[3 ]执行日期和时间的加减运算，包括年、月、日、时、分、秒等。
[4 ]格式化日期和时间为可读字符串的形式。
[5 ]解析字符串为日期和时间的形式。

Calendar类是一个抽象类，通过调用其静态工厂方法getInstance()来获取一个Calendar对象，根据当前时区和语言环境返回一个具体的子类实例。

尽管java.util.Date类在Java中仍然存在，但在处理日期和时间时，推荐使用更新的java.time包中的类（如LocalDate、LocalDateTime和ZonedDateTime），因为Calendar存在一些问题，如可变性和线程安全性等方面的限制。

Calendar类的示例：

import java.util.Calendar;

public class Example {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH) + 1; // 月份从 0 开始，因此需要加 1
        int day = calendar.get(Calendar.DAY_OF_MONTH);

        System.out.println("当前日期是：" + year + "-" + month + "-" + day);
    }
}

Random

java.util.Random类是Java标准库中提供的一个随机数生成器类。它允许生成各种类型的随机数，包括整数、浮点数和布尔值。

Random类使用一个48位种子（默认为当前时间的毫秒数）来生成伪随机数序列。通过提供不同的种子，可以得到不同的随机数序列。

Random类常用的方法：

方法	功能
nextInt()	返回一个随机的整数。
nextInt(int n)	返回一个范围在0（包括）到n（不包括）之间的随机整数。
nextLong()	返回一个随机的长整数。
nextDouble()	返回一个范围在0.0（包括）到1.0（不包括）之间的随机浮点数。
nextFloat()	返回一个范围在0.0（包括）到1.0（不包括）之间的随机浮点数。
nextBoolean()	返回一个随机的布尔值。

Random类生成随机数的示例：

import java.util.Random;

public class Example {
    public static void main(String[] args) {
        Random random = new Random();

        // 生成随机整数
        int randomNumber = random.nextInt();
        System.out.println("随机整数：" + randomNumber);

        // 生成0到100之间的随机整数
        int randomInRange = random.nextInt(101);
        System.out.println("0到100之间的随机整数：" + randomInRange);

        // 生成随机布尔值
        boolean randomBoolean = random.nextBoolean();
        System.out.println("随机布尔值：" + randomBoolean);
    }
}

注意，由于Random类是基于伪随机数生成器的，同一个种子将会生成相同的随机数序列。如果需要更强大和更安全的随机数生成器，可以考虑使用java.security.SecureRandom类。使用Socket类，可以在客户端与服务器之间建立网络连接，并通过该连接进行数据的发送和接收。它提供了一组方法来创建、连接和操作套接字（socket）。

java.net

Socket

Socket是Java标准库中提供的一个用于网络通信的类。它位于java.net包中，用于创建和操作网络连接。
Socket类有两种类型：客户端套接字（Client Socket）和服务器套接字（Server Socket）。

客户端套接字（Client Socket）用于与服务器建立连接，发送请求并接收响应。
服务器套接字（Server Socket）用于等待客户端的连接请求，并在连接建立后与客户端进行通信。

ServerSocket类是Java标准库中提供的一个用于创建服务器套接字（Server Socket）的类。它位于java.net包中，用于等待客户端连接，并在连接建立后与客户端进行通信。

Socket类常用的方法：

方法	功能
Socket(String host, int port)	创建一个新的套接字对象，并将其连接到指定的主机和端口。
getInputStream()	获取套接字的输入流，用于从套接字接收数据。
getOutputStream()	获取套接字的输出流，用于向套接字发送数据。
connect(SocketAddress endpoint)	连接到指定的套接字地址。
close()	关闭套接字连接。

Socket类进行简单网络通信的客户端示例：

import java.io.*;
import java.net.*;

public class Client {
    public static void main(String[] args) {
        try {
            // 创建Socket对象，指定服务器地址和端口号
            Socket socket = new Socket("localhost", 8080);

            // 获取输出流，向服务器发送数据
            OutputStream outputStream = socket.getOutputStream();
            PrintWriter writer = new PrintWriter(outputStream);
            writer.println("Hello, Server!");
            writer.flush();

            // 获取输入流，接收服务器的响应
            InputStream inputStream = socket.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
            String response = reader.readLine();
            System.out.println("服务器响应：" + response);

            // 关闭连接
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

java.sql

DriverManager

DriverManager类是Java标准库中提供的一个用于管理JDBC驱动程序的类。它位于java.sql包中，用于加载和注册JDBC驱动程序，并获取数据库连接。

操作：
加载并注册JDBC驱动程序。
获取数据库连接。
卸载已注册的JDBC驱动程序。

DriverManager类常用的方法：

方法	功能
registerDriver(Driver driver)	注册特定的JDBC驱动程序。
getConnection(String url, String user, String password)	根据提供的URL、用户名和密码获取数据库连接。
getDriver(String url)	获取与给定URL匹配的JDBC驱动程序。
deregisterDriver(Driver driver)	注销已注册的JDBC驱动程序。

DriverManager类获取数据库连接的示例：

import java.sql.*;

public class Example {
    public static void main(String[] args) {
        try {
            // 注册MySQL JDBC驱动程序
            Class.forName("com.mysql.cj.jdbc.Driver");

            // 创建数据库连接
            String url = "jdbc:mysql://localhost:3306/mydatabase";
            String user = "root";
            String password = "password";
            Connection connection = DriverManager.getConnection(url, user, password);

            // 执行数据库操作...

            // 关闭数据库连接
            connection.close();
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }
    }
}

需要注意的是，根据不同的数据库厂商和JDBC驱动程序，DriverManager.getConnection()方法的URL格式和参数可能会有所不同。具体的URL格式和连接参数需要根据所使用的数据库和JDBC驱动程序进行相应的配置。

Connection/接口

Connection接口是Java标准库中java.sql包中定义的一个接口，用于表示与数据库的连接对象。它代表了Java程序与数据库之间的通信通道，提供了执行SQL语句和事务管理等功能。

Connection接口的方法：

方法	功能
createStatement()	创建一个Statement对象，用于执行静态SQL语句。
prepareStatement(String sql)	创建一个PreparedStatement对象，用于执行预编译的SQL语句。
prepareCall(String sql)	创建一个CallableStatement对象，用于执行存储过程。
commit()	提交当前事务。
rollback()	回滚当前事务。
close()	关闭连接。

Connection接口示例代码：

import java.sql.*;

public class Example {
    public static void main(String[] args) {
        Connection connection = null;
        try {
            // 获取数据库连接
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydatabase", "root", "password");

            // 创建Statement对象并执行SQL查询
            Statement statement = connection.createStatement();
            ResultSet resultSet = statement.executeQuery("SELECT * FROM users");

            // 处理查询结果
            while (resultSet.next()) {
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                System.out.println("ID: " + id + ", Name: " + name);
            }

            // 关闭查询结果和Statement对象
            resultSet.close();
            statement.close();

            // 关闭连接
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

在实际的应用中，需要根据具体的需求和数据库类型选择适当的连接方式和相应的操作方法。此外，为了保证资源的正确释放，应使用try-catch-finally或try-with-resources语句块来处理连接对象和相关的资源。

Statement/接口

Statement接口是Java标准库中java.sql包中定义的一个接口，用于执行静态的SQL语句并返回结果。它是Connection接口的一部分，用于与数据库进行交互。Statement接口提供了执行各种SQL语句（如查询、更新、删除等）的方法，并返回相应的结果。

Statement接口的方法：

方法	功能
executeQuery(String sql)	执行给定的SQL查询，并返回一个ResultSet对象，该对象包含了查询结果集。
executeUpdate(String sql)	执行给定的SQL语句（如更新或删除），并返回更新的行数或0。
execute(String sql)	执行给定的SQL语句，如果结果是一个结果集，则返回true；否则，返回false。
close()	关闭此Statement对象。

Statement接口示例代码：

import java.sql.*;

public class Example {
    public static void main(String[] args) {
        Connection connection = null;
        try {
            // 获取数据库连接
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydatabase", "root", "password");

            // 创建Statement对象并执行SQL查询
            Statement statement = connection.createStatement();
            ResultSet resultSet = statement.executeQuery("SELECT * FROM users");

            // 处理查询结果
            while (resultSet.next()) {
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                System.out.println("ID: " + id + ", Name: " + name);
            }

            // 关闭查询结果和Statement对象
            resultSet.close();
            statement.close();

            // 关闭连接
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

需要注意的是，使用Statement接口执行SQL语句存在安全风险，因为它容易受到SQL注入攻击。为了避免SQL注入，应该使用PreparedStatement接口来执行带有参数的SQL语句。

ResultSet/接口

ResultSet接口是Java标准库中java.sql包中定义的一个接口，用于表示数据库查询结果集的对象。它提供了在Java程序中访问和处理数据库查询结果的方法。ResultSet接口提供了许多方法，用于遍历查询结果集、获取列的值、移动指针等操作。

ResultSet接口的方法：

方法	功能
next()	将光标移到下一行，如果有更多的行存在，则返回true；否则返回false。
getInt(String columnName)	按照列名获取整数类型的值。
getString(String columnName)	按照列名获取字符串类型的值。
getObject(String columnName)	按照列名获取通用对象类型的值。
close()	关闭此ResultSet对象。

需要注意的是，使用ResultSet对象时，必须确保在处理完数据后正确关闭ResultSet对象，以释放资源。

qxl217

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
Java常用API

API（应用程序编程接口）指的是一组定义了软件组件或服务之间交互规则的接口。它定义了如何通过预定义的方法和数据结构与其他软件组件进行通信，以实现特定的功能。API可以被看作是两个不同的软件系统之间进行通信的桥梁。它提供了一种标准化的方式，使得不同的系统能够互相访问和使用彼此的功能，而无需了解底层实现的细节。通过API，一个应用程序可以向另一个应用程序发送请求，并获取相应的响应。API定义了请求的格式和参数，以及响应的数据格式。它可以用于访问远程服务器上的服务，与操作系统交互，或者与第三方库进行通信。
复制链接

扫一扫