java核心day04

已于 2022-12-26 16:35:21 修改
阅读量44 收藏
点赞数
文章标签： java 开发语言
于 2022-12-26 16:00:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57469302/article/details/128445502
版权

多线程

程序(**program**)：为了完成特定任务、用某种语言编写的一组指令集合。指一段静态的代码，静态队形

进程 (process)：程序的一次执行过程，或是正在运行的一个程序。 是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期。

线程 (thread)：进程可进一步细化为线程，是一个程序内部的一条执 行路径。 ·

  • 并行：多个 CPU 同时执行多个任务。比如：多个人同时做不同的事。

  • 并发：一个 CPU（采用时间片）同时执行多个任务。比如：秒杀、多 个人做同一件事

优点

  • 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。

  • 提高计算机系统 CPU 的利用率。

    • 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利 于理解和修改

Thread 类的特性：

每个线程都是通过某个特定 Thread 对象的 run() 方法来完成操作的， 经常把 run() 方法的主体称为线程体。 通过该 Thread 对象的 start() 方法来启动这个线程，而非直接调用 run()

常用方法：

  • Thread()：创建新的 Thread 对象。

  • Thread(String threadname)：创建线程并指定线程实例名。 Thread(Runnabletarget)：指定创建线程的目标对象，它实现了 Runnable 接口中的 run 方法。

  • Thread(Runnable target, String name)：创建新的 Thread 对象。

线程创建的两种方式

继承 Thread 类的方式。

实现 Runnable 接口的方式。

  • 继承Thread类的方式

    • . 创建一个继承于 Thread 类的子类；

    • 重写 Thread 类的 run() 方法 ---> 将此线程的方法声明在 run() 中；

    • 创建 Thread 类的子对象；

    • 通过此对象调用 start()。

 // 例子 : 遍历 100 以内的所有的偶数
 // 1. 创建一个继承于 Thread 类的子类
         class MyThread extends Thread{
 // 2. 重写 Thread 类的 run()
         @Override
         public void run() {
         for(int i = 1;i < 100;i++){
         if(i % 2 == 0){
         System.out.println(i);
          }
          }
         }
         }
 public class ThreadTest {
 public static void main(String[] args) {
 ​
 ​
 // 3. 创建 Thread 类的子对象
 ​
 MyThread t1 = new MyThread();
 ​
 // 4. 通过此对象调用 start():
 // ①启动当前线程 ②调用当前线程的 run()
 t1.start();
 ​
 // 如下操作仍在 main 线程中执行的
 for(int i = 1;i < 100;i++){
 if(i % 2 == 0){
 System.out.println(i + "***main()***");
  }
  }
 ​

测试 Thread 类有关方法：

  • start()：启动当前线程，执行当前线程的 run()。

  • run()：通常需要重写 Thread 类中的此方法，将创建的线程要执行的 操作声明在此方法中。

  • currentThread()：静态方法，返回当前代码执行的线程。

  • getName()：获取当前线程的名字。

  • setName()：设置当前线程的名字。

  • yield()：释放当前 CPU 的执行权。

  • join()：在线程 a 中调用线程 b 的 join(), 此时线程 a 就进入阻塞状态， 直到线程 b 完全执行完以后，线程 a 才结束阻塞状态。

  • stop()：已过时。当执行此方法时，强制结束当前线程。

  • sleep(long millitime)：让当前线程“睡眠”指定时间的 millitime 毫秒。 在指定的 millitime 毫秒时间内，当前线程是阻塞状态的。

  • isAlive()：返回 boolean，判断线程是否还活着

线程的调度

  • 线程的优先级 调度策略： 时间片。

  • 抢占式：高优先级的线程抢占 CPU。

Java 的调度方法： 同优先级线程组成先进先出队列（先到先服务），使用时间片策略； 对高优先级，使用优先调度的抢占式策略

线程的优先级

线程的优先级等级： - MAX_PRIORITY：10

  • MIN _PRIORITY：1 - NORM_PRIORITY：5 --->

  • 默认优先级 涉及的方法： - getPriority() ：返回线程优先值。

  • setPriority(intnewPriority) ：改变线程的优先级。

    说明 : 高优先级的线程要抢占低优先级线程 cpu 的执行权。但是只是从 概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优 先级的线程执行完以后，低优先级的线程才会被执行

实现 Runnable 接口

  • 创建多线程的方式二：实现 Runnable 接口 1. 创建一个实现了 Runnable 接口的类

  • .实现类去实现 Runnable 中的抽象方法 :run()；

  • 创建实现类的对象；

  • 将此对象作为参数传递到 Thread 类的构造器中，创建 Thread 类的对 象；

  • 通过 Thread 类的对象调用 start()

继承方式和实现方式的联系

比较创建线程的两种方式。 开发中：优先选择：实现 Runnable 接口的方式。

原因：

  • 实现的方式没有类的单继承性的局限性。

  • 实现的方式更适合来处理多个线程有共享数据的情况。 联系：public class Thread implements Runnable。

  • 相同点：两种方式都需要重写 run(), 将线程要执行的逻辑声明在 run() 中。

线程的生命周期

新建---就绪---运行---阻塞---死亡

阻塞：没有抢夺到cup资源，或者被人零时挂起，终止自己的操作

线程状态导致状态发生条件
NEW(新建)线程刚被创建，但是并未启动。还没调用start方法。
Runnable(可运行)线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。
Blocked(锁阻塞)当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting(无限等待)一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
Timed Waiting(计时等待)同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。
Teminated(被终止)因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

线程同步：

解决多个线程执行的不确定性引起执行结果的不稳定。 多个线程对账本的共享，会造成操作的不完整性，会 破坏数据

同步的方式

  • 使用synchronized修饰同步监视器

    • 操作共享数据的代码，即为需要同步的代码---》不能包含代码多了，也不能少

    • 共享数据：多个线程共同操作的变量

    • 同步监视器：俗称：锁。任意一个类的对象都可以来充当锁

    • 多个线程必须要共用一把锁

 synchronized( 同步监视器 ){
 // 需要被同步的代码
 }

  • 声明在一个方法上（同步方法）

    • 好处：解决了线程的安全问题

    • 操作代码时，只能有一个线程参与，其他线程等待，相当于是一个单线程的过程，效率低---局限

 synchronized (dog)

补充：

实现Runnable接口创建多线程的方式中，我们可以使用this充当同步监视器

 class Windows1 implements Runnable {
 private int ticket = 100;
 // Object obj = new Object();
 // Dog dog = new Dog();
 282 283
 @Override
 public void run() {
 while (true) {
 synchronized (this) {
 // 此时的 this: 唯一的 windows1 的对象 // 方式二 :synchronized (dog) {
 if (ticket > 0) {
 try {
 Thread.sleep(100);
 } catch (InterruptedException e) {
 e.printStackTrace();
  }
 System.out.println(Thread.currentThread().
 getName() + ": 卖票，票号为 : " + ticket);
 ticket--;
 } else {
 break;
  }
  }
  }
 }
 }
 public class WindowsTest1 {
 public static void main(String[] args) {
 Windows1 w = new Windows1();
 Thread t1 = new Thread(w);
 Thread t2 = new Thread(w);
 Thread t3 = new Thread(w);
 t1.setName(" 窗口 1");
 t2.setName(" 窗口 2");
 t3.setName(" 窗口 3");
 t1.start();
 t2.start();
 t3.start();
 }
 }
 class Dog {
 }

同步代码块处理继承 Thread 类 的线程安全问题

 class Windows extends Thread {
 private static int ticket = 100;
 private static Object obj = new Object();
 @Override
 public void run() {
 while (true) {
  // 正确的
 // synchronized (obj) {
 synchronized (Windows.class) { 
  // Class clazz = Windows.class
  // 错误的，因为此时 this 表示的是 t1,t2,t3 三个对象
 // synchronized (this) {
 if (ticket > 0) {
 try {
 Thread.sleep(100);
 } catch (InterruptedException e) {
 e.printStackTrace();
  }
 System.out.println(getName() + ": 卖 票， 票
 号为 : " + ticket);
 ticket--;
 } else {
 break;
  }
  }
  }
 }
 }
 同步代码块处理继承 Thread 类
 的线程安全问题
 使用同步代码块解决继承 Thread 类的方式的线程安全问题。
 例子：创建三个 c 窗口卖票，总票数为 100 张。
 284 285
 public class WindowsTest2 {
 public static void main(String[] args) {
 Windows t1 = new Windows();
 Windows t2 = new Windows();
 Windows t3 = new Windows();
 t1.setName(" 窗口 1");
 t2.setName(" 窗口 2");
 t3.setName(" 窗口 3");
 t1.start();
 t2.start();
 t3.start();
 }
 ​

同步方法处理实现Runnable的线程安全问题

  • 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。

  • 非静态的同步方法，同步监视器是：this； 静态的同步方法，同步监视器是：当前类本身。

 class Windows3 implements Runnable {
 private int ticket = 100;
 @Override
 public void run() {
 while (true) {
 show();
  
 }
 }
 public synchronized void show() { // 同步监视器：this
 // synchronized (this){
 if (ticket > 0) {
 try {
 Thread.sleep(100);
 } catch (InterruptedException e) {
 e.printStackTrace();
  
 }
 System.out.println(Thread.currentThread().getName() 
 + ": 卖票，票号为 : " + ticket);
 ticket--;
  
 }
 //
 }}
 }
 public class WindowsTest3 {
 public static void main(String[] args) {
 Windows3 w3 = new Windows3();
 同步方法处理实现 Runnable
  的线程安全问题
 使用同步方法解决实现 Runnable 接口的线程安全问题
 关于同步方法的总结：
 1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
 2. 非静态的同步方法，同步监视器是：this；
  静态的同步方法，同步监视器是：当前类本身。
 286 287
 Thread t1 = new Thread(w3);
 Thread t2 = new Thread(w3);
 Thread t3 = new Thread(w3);
 t1.setName(" 窗口 1");
 t2.setName(" 窗口 2");
 t3.setName(" 窗口 3");
 t1.start();
 t2.start();
 t3.start();
 }
 ​

线程安全的单例模式之懒汉式

使用同步机制将单例模式中的懒汉式改写为线程安全的。

 public class BankTest {
 }
 class Bank {
 private Bank() {
 }
 private static Bank instance = null;
 public static Bank getInstance() {
 // 方式一：效率稍差
 // 快捷键 :Alt+Shift+Z
 // synchronized (Bank.class) {
 // if(instance == null){
 // instance = new Bank();
 / }
 // return instance;
 // }
 // 方式二：效率较高
 if (instance == null) {
 synchronized (Bank.class) {
 if (instance == null) {
 instance = new Bank();
  }
  }
  }
 return instance;
 }
 }

死锁问题

死锁的理解：

不同的线程分别占用对方需要同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了死锁

说明：

死锁形成后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，我们使用同步时，要避免出现死锁

 public class ThreadTest {
 public static void main(String[] args) {
 StringBuffer s1 = new StringBuffer();
 StringBuffer s2 = new StringBuffer();
 new Thread() {
 @Override
 public void run() {
 synchronized (s1) {
 s1.append("a");
 s2.append("1");
 try {
 Thread.sleep(100);
 } catch (InterruptedException e) {
 e.printStackTrace();
  
 }
 synchronized (s2) {
 s1.append("b");
 s2.append("2");
 System.out.println(s1);
 System.out.println(s2);
  
 }
  
 }
  
 }
 }.start();
 new Thread(new Runnable() {
 @Override
 public void run() {
 synchronized (s2) {
 s1.append("c");
 s2.append("3");
 try {
 Thread.sleep(100);
 } catch (InterruptedException e) {
 e.printStackTrace();
  
 }
 synchronized (s1) {
 s1.append("d");
 s2.append("4");
 System.out.println(s1);
 System.out.println(s2);
  
 }
  
 }
  
 }
 }).start();
 }
 ​

Lock 锁方式解决线程安全问题

java.util.concurrent.locks.Lock 接口是控制多个线程对 共享资源进行访问的工具。锁提供了对共享资源的独占 访问，每次只能有一个线程对 Lock 对象加锁，线程开始 访问共享资源之前应先获得 Lock 对象。

ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中， 比较常用的是 ReentrantLock，可以显式加锁、释放锁

synchronized 与 Lock 的异同？

  • 相同：二者都可以解决线程安全问题；

  • 不同：synchronized 机制在执行完相应的同步代码以后，自动的 释放同步监视器。 Lock 需要手动的启动同步（lock()），同时结束同步也需要手动 的实现（unlock()）。 2. 优先使用顺序： Lock ·同步代码块（已经进入了方法体，分配了相应资源） ·同步方法（在方法体之外）

线程的通信

涉及到的三个方法：

  • wait()：一旦执行此方法，当前线程就进入阻塞状态， 并释放同步监视器。

  • notify()：一旦执行此方法，就会唤醒被 wait 的一个 线程。如果有多个线程被 wait，就唤醒优先级高的那个。

  • notifyAll()：一旦执行此方法，就会唤醒所有被 wait 的线程。

说明：

wait()，notify()，notifyAll() 三个方法必须使用在同 步代码块或同步方法中。

wait()，notify()，notifyAll() 三个方法的调用者必须 是同步代码块或同步方法中的同步监视器。否则，会出 现 IllegalMonitorStateException 异常。

wait()，notify()，notifyAll() 三个方法是定义在 java. lang.Object 类中。

sleep() 和 wait() 的异同

相同点：

  • 一旦执行方法，都可以使得当前的线程进入 阻塞状态。

不同点：

  • 两个方法声明的位置不同： Thread 类中声明 sleep() Object 类中声明 wait()

  • 调用的要求不同： sleep() 可以在任何需要的场景下调用。 wait() 必须使用在同步代码块或同步方法中。

  • 关于是否释放同步监视器：如果两个方法都使用在 同步代码块或同步方法中，sleep() 不会释放锁，wait() 会 释放锁

创建多线程的方式三：实现 Callable 接口

如何理解实现 Callable 接口的方式创建多线程比实现 Runnable 接口创建多线程方式强大？

  • call() 可以有返回值的。

  • call() 可以抛出异常，被外面的操作捕获，获取异 常的信息。

  • Callable 是支持泛型的。

  • . 需要借助 FutureTask 类，比如获取返回结果

Future 接口

  • 可以对具体 Runnable、Callable 任务的执行结果进行 取消、查询是否完成、获取结果等。

    • FutrueTask 是 Futrue 接口的唯一的实现类。

  • FutureTask 同时实现了 Runnable, Future 接口。它既 可以作为 Runnable 被线程执行，又可以作为 Future 得到 Callable 的返回值

 //1. 创建一个实现 Callable 的实现类
 class NumThread implements Callable {
 // 2. 实现 call 方法，将此线程需要执行的操作声明在 call() 中
 @Override
 public Object call() throws Exception {
 int sum = 0;
 for (int i = 1; i <= 100; i++) {
 if (i % 2 == 0) {
 System.out.println(i);
 sum += i;
  }
  }
 return sum;
 }
 }
 public class ThreadNew {
 public static void main(String[] args) {
 // 3. 创建 Callable 接口实现类的对象
 NumThread numThread = new NumThread();
  // 4. 将此 Callable 接口实现类的对象作为传递到 FutureTask 构
 造器中，创建 FutureTask 的对象
 FutureTask futureTask = new FutureTask(numThread);
  // 5. 将 FutureTask 的对象作为参数传递到 Thread 类的构造器
 中，创建 Thread 对象，并调用 start()
 new Thread(futureTask).start();
 try {
  // 6. 获取 Callable 中 call 方法的返回值
 // get() 返回值即为 FutureTask 构造器参数 Callable 实现
 类重写的 call() 的返回值。
 Object sum = futureTask.get();
 System.out.println(" 总和为 :" + sum);
 } catch (InterruptedException e) {
 e.printStackTrace();
 } catch (ExecutionException e) {
 e.printStackTrace();
  }
 }
 }
 ​

创建多线程的方式四：使用线程池

经常创建和销毁、使用量特别大的资源，比如并发情 况下的线程，对性能影响很大。

思路： 提前创建好多个线程，放入线程池中，使用时直接获 取，使用完放回池中。可以避免频繁创建销毁、实现重 复利用。类似生活中的公共交通工具

好处：

提高响应速度（减少了创建新线程的时间） 降低资源消耗（重复利用线程池中线程，不需要每次 都创建） 便于线程管理 corePoolSize：核心池的大小 maximumPoolSize：最大线程数 keepAliveTime：线程没有任务时最多保持多长时 间后会终止

 class NumberThread implements Runnable {
 @Override
 public void run() {
 for (int i = 0; i <= 100; i++) {
 if (i % 2 == 0) {
 System.out.println(Thread.currentThread().
 getName() + ":" + i);
  }
  }
 }
 }
 class NumberThread1 implements Runnable {
 @Override
 public void run() {
 for (int i = 0; i <= 100; i++) {
 if (i % 2 != 0) {
 System.out.println(Thread.currentThread().
 getName() + ":" + i);
  }
  }
 }
 }
 public class ThreadPool {
 public static void main(String[] args) {
 // 1. 提供指定线程数量的线程池
 ExecutorService service = Executors.
 newFixedThreadPool(10);
 ThreadPoolExecutor service1 = (ThreadPoolExecutor) 
 service;
 // 设置线程池的属性
 // System.out.println(service.getClass());
 // service1.setCorePoolSize(15);
 // service1.setKeepAliveTime();
  // 2. 执行指定的线程的操作。需要提供实现 Runnable 接口或
 Callable 接口实现类的对象
 service.execute(new NumberThread()); 
 // 适合适用于 Runable
 service.execute(new NumberThread1()); 
 // 适合适用于 Runable
 // service.submit(Callable callable); // 适合适用于 Callable
 // 3. 关闭连接池
 service.shutdown();
 }
 }
 ​

线程池相关 API JDK 5.0 起提供了线程池相关 API：ExecutorService 和 Executors。 ExecutorService：真正的线程池接口。

常见子类 ThreadPoolExecutor。

  • ·void execute(Runnable command) ：执行任务 / 命令，没有返回值， 一般用来执行 Runnable。

  • ·Future submit(Callable task)：执行任务，有返回值，一般又来执行 Callable。 ·void shutdown()：关闭连接池。

  • Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线 程池。

  • ·Executors.newCachedThreadPool()：创建一个可根据需要创建新线程 的线程池。 ·

  • Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程 池。

  • ·Executors.newSingleThreadExecutor()：创建一个只有一个线程的线程 池。

  • ·Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在 给定延迟后运行命令或者定期地执行

weixin_57469302
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JAVA-核心类库
分享，学习，专注，努力，向上。
06-30 1444
Java核心类库是指Java语言提供的一组基础类和接口，用于处理常见的任务和操作，包括字符串处理、集合操作、IO操作、多线程等。熟练掌握Java核心类库的使用，可以提高开发效率和编写高质量的Java应用程序的能力。
Java核心API
白菜小皮艇的博客
12-10 1910
1 Java核心API API（Application Programming Interface，应用程序接口）是一些预先定义的函数，或指软件系统不同组成部分衔接的约定。 目的是提供应用程序与开发人员基于某软件或硬件得以访问一组例程的能力，而又无需访问原码，或理解内部工作机制的细节。 1.1 Object public class Object Class Object是类Object结构的根。 每个类都有Object作为超类。 所有对象（包括数组）都实现了这个类的方法。 1.2 包装类： Java
【JAVA-Day39】Java Math类解析
热门推荐
沉淀、分享、成长，让自己和他人都能有所收获！
09-21 3万+
作为博主，我将带领大家一起探索Java中的Math类，揭开它的神秘面纱。我们将详细研究它的各种方法，以及如何在实际应用中使用它。让我们一起深入了解这个强大的数学工具！首先，让我们来深入了解一下Math类是什么。Math类是Java标准库中的一个非常重要的工具类，它提供了各种用于执行基本数学运算的静态方法。这些方法通常用于处理数字数据，执行各种常见的数学计算，包括但不限于算术运算、取绝对值、取整数、指数计算、三角函数、随机数生成等等。不同于许多其他Java类，你无需创建Math。
【JAVA-Day55】Java集合类HashTable解析
沉淀、分享、成长，让自己和他人都能有所收获！
10-30 2万+
在本篇技术博客中，作为博主，我将深入探讨Java中的Hashtable集合类，为你提供全面的了解。我们将从Hashtable的基本概念开始，逐步深入，讨论其内部工作原理、性能、线程安全性，以及在现代Java框架中的应用。还将探讨Hashtable的未来发展趋势和替代选择，以帮助你更好地应用这一重要工具。通过本文，我们对Java中的Hashtable集合类有了深入的了解。我们介绍了其基本概念、与HashMap的比较、内部工作原理、性能、线程安全性以及最佳实践。
【JAVA-Day53】Java集合类HashMap详解
沉淀、分享、成长，让自己和他人都能有所收获！
10-26 2万+
作为一名Java开发者，熟练掌握集合类是至关重要的。其中，HashMap作为Java中常用的集合类之一，具有重要的地位。本篇博客将带您深入了解HashMap的各种操作技巧、实际应用场景以及面试可能涉及的问题，同时深度探讨其实现原理与性能优化，让您全面掌握HashMap的精髓。HashMap是Java中的一种数据结构，它提供了一种键值对的映射关系，允许使用键来查找值。在实际开发中，它能够高效地进行数据存储和检索，是Java编程中常用的集合类之一。
【JAVA-Day52】深度解析 Java TreeSet 集合
沉淀、分享、成长，让自己和他人都能有所收获！
10-23 2万+
博主在本篇文章中将深入解析Java中的TreeSet集合，探讨其特性、应用场景以及性能优化。通过多级标题结构，将引领读者从初步认识TreeSet到最佳实践，最终挑战高质量的面试题，全方位、深度解析TreeSet在Java中的应用。
【JAVA-Day49】Java LinkedList集合详解
沉淀、分享、成长，让自己和他人都能有所收获！
10-22 2万+
欢迎来到我的技术博客，本篇文章将深入探讨Java中的LinkedList集合。我们将首先介绍LinkedList的基本概念和结构，然后逐一讨论其用法、应用场景以及性能比较。通过本文，您将全面了解Java中LinkedList的内部实现和工作原理，以及如何优化其性能。最后，我们将回顾所学内容并提供实际应用案例，帮助您成为Java LinkedList的高级用户。LinkedList是一种双向链表实现的集合，它以节点相互连接的方式存储数据，具有动态大小和高度灵活的特性。
【JAVA-Day45】Java常用类StringBuffer解析
沉淀、分享、成长，让自己和他人都能有所收获！
10-16 2万+
在Java中，StringBuffer是一个用于处理字符串的类，它允许我们对字符串进行动态操作，如拼接、插入、删除等。通过本篇文章的学习，我们深入了解了Java中常用类StringBuffer的各种方法及其应用场景。同时，我们也比较了StringBuffer与String的不同之处，并分享了一些在实际开发中的最佳实践。希望本文能够对你在Java字符串处理中提供有价值的指导。
【JAVA-Day51】探秘 Java HashSet 集合
沉淀、分享、成长，让自己和他人都能有所收获！
10-22 2万+
在 Java 中，HashSet 是一种基于哈希表的集合实现，继承自 Set 接口。它被设计用于存储无序且唯一的元素，即不允许重复元素存在。HashSet 的独特之处在于其内部使用哈希表来实现高效的元素存储和检索。在日常开发中，我们经常会面对需要存储一系列独一无二元素的情况，这时候 HashSet 就成为了一个强大的选择。它提供了快速的查找、插入和删除操作，使其在很多场景下都表现优异。要在 HashSet 中自定义对象的比较规则，需要重写对象的equals和hashCode方法。
JAVA学习记录day3
string_s1的博客
06-26 1630
Java API（Application Programming Interface，应用程序编程接口）是Java开发者用来访问Java运行环境的接口。Java API包含了Java运行环境提供的各种功能，包括基础类库、核心类库、扩展类库、第三方类库等。Java API的设计目标是提供一套统一的、易于使用的API，使得开发者可以快速、方便地开发出功能丰富、可靠的Java程序。Java API的设计理念是面向对象、可扩展性、健壮性、安全性、可移植性和可靠性。
J031_使用TCP协议支持与多个客户端同时通信
lzn20161229的博客
08-03 418
使用TCP协议支持与多个客户端同时通信。
C++ - 函数重载
最新发布
jiaowenjie的专栏
08-06 178
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
枚举工具类
qq_43049583的博客
08-04 407
java枚举工具类
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 1253
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
等待唤醒机制两种实现方法-阻塞队列
泰勒今天想展开的博客
08-04 493
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
深入理解Java注解
weixin_55745942的博客
08-01 725
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
社区养老服务小程序的设计
Karen198的博客
07-31 754
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 714
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
Servlet(2)
xjdkxnhcoskxbco的博客
08-04 742
这个注解可以用来修饰一个Servlet类，可以简化配置，替代Web.xml中 的servlet配置。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值