Java 实现增强流布局（EnhanceFlowLayout）—— 兼具水平流布局和垂直流布局功能

于 2024-07-14 09:00:00 发布
阅读量597 收藏 9
点赞数 17
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Watermanda/article/details/140295944
版权

目录

1、背景概述

2、详细介绍

2.1  布置方向

2.2  布置锚点

2.3  对齐方式

2.4  组件间隔

2.5  组件填充

2.6  组件反转

2.7  行列反转

3、运行环境及实现代码

1、背景概述

在进行 Java 用户界面设计的时候，经常会用到各种布局管理器，Java 自带的 java.awt.FlowLayout 作为常用的布局管理器，功能有些局限，虽然借助 WindowBuilder 等可视化插件可以很方便的进行界面设计，但是对于运行时会产生变化的界面还是有些力有不逮。在对 java.awt.FlowLayout 的源码进行分析后，我对流布局进行了功能增强，基本上覆盖了流布局所有可能的布置情况，具体请看 EnhanceFlowLayout 详细介绍。

2、详细介绍

2.1  布置方向

EnhanceFlowLayout 使用 direct 属性控制组件的布置方向（水平或垂直），它可以是以下值之一：

public class EnhanceFlowLayout implements LayoutManager {
    ...
    private int direct;
    public static final int HORIZONTAL = 0;
	public static final int VERTICAL = 1;
    ...
}
  • 水平布置效果如 图 1 ：
图 1  水平布置
  • 垂直布置效果如 图 2 ：
图 2  垂直布置

2.2  布置锚点

EnhanceFlowLayout 使用 anchor 属性控制首个组件布置的起点（称锚点），其余组件再依次进行布置，所有组件都会向锚点靠拢。锚点可以是以下值之一：

public class EnhanceFlowLayout implements LayoutManager {
    ...
    private int anchor;
    public static final int TOP_LEFT = 0;
	public static final int TOP = 1;
	public static final int TOP_RIGHT = 2;
	public static final int LEFT = 3;
	public static final int CENTER = 4;
	public static final int RIGHT = 5;
	public static final int BOTTOM_LEFT = 6;
	public static final int BOTTOM = 7;
	public static final int BOTTOM_RIGHT = 8;
    ...
}

锚点示意如 图 3 ：

图 3  锚点示意

2.3  对齐方式

EnhanceFlowLayout 使用 align 属性控制组件在行或列内的对齐方式（与 java.awt.FlowLayout 的 align 不同），它可以是以下值之一：

public class EnhanceFlowLayout implements LayoutManager {
    ...
    private int align;
    public static final int LEFT_OR_TOP = 0;
	public static final int CENTER_OR_CENTER = 1;
	public static final int RIGHT_OR_BOTTOM = 2;
    ...
}
  • align 值为 EnhanceFlowLayout.LEFT_OR_TOP 时布置效果如 图 4 和 图 5 ：
图 4  顶对齐（水平布置）
图 5  左对齐（垂直布置）
  • align 值为 EnhanceFlowLayout.CENTER_OR_CENTER 时布置效果如 图 6 和 图 7：
图 6  居中对齐（水平布置）
图 7  居中对齐（垂直布置）
  • align 值为 EnhanceFlowLayout.RIGHT_OR_BOTTOM 时布置效果如 图 8 和 图 9：
图 8  底对齐（水平布置）
图 9  右对齐（垂直布置）

2.4  组件间隔

EnhanceFlowLayout 使用 hgap 和 vgap 属性控制组件之间的水平和垂直间距（与 java.awt.FlowLayout 相同），如果组件的大小不同，它控制的是整行或整列之间的间距。

2.5  组件填充

EnhanceFlowLayout 使用 fill 属性控制组件是否填满容器的高度（水平布置）或宽度（垂直布置），它是一个布尔值，如果为 true 则表示填满（这种情况下组件将按单行或单列进行布置）。布置效果如 图 10 和 图 11 ：

图 10  组件填满容器高度（水平布置）
图 11  组件填满容器宽度（垂直布置）

2.6  组件反转

EnhanceFlowLayout 使用 reverseComp 属性控制组件是否在行内或列内反向布置（默认情况下，行内组件按从左到右，列内组件按从上到下进行布置），它是一个布尔值，如果为 true 则表示反向布置。布置效果如 图 12 ~ 图 15 ：

图 12  反转前（水平布置）
图 13  反转后（水平布置）
图 14  反转前（垂直布置）
图 15  反转后（垂直布置）

2.7  行列反转

EnhanceFlowLayout 使用 reverseRC 属性控制整行或整列组件是否在容器内反向布置（默认情况下，每行组件按从上到下，每列组件按从左到右进行布置），它是一个布尔值，如果为 true 则表示反向布置。布置效果如 图 16 ~ 图 19 ：

图 16  反转前（水平布置）
图 17  反转后（水平布置）
图 18  反转前（垂直布置）
图 19  反转后（垂直布置）

3、运行环境及实现代码

操作系统：Windows 10

Java环境：JDK-17

部分实现代码如下：

// ...

public class EnhanceFlowLayout implements LayoutManager {

    // ...

	/**
	 * 布置容器中的组件。
	 * 
	 * @param parent 要布局的容器
	 */
	@Override
	public void layoutContainer(Container parent) {
		synchronized (parent.getTreeLock()) {
			Insets insets = parent.getInsets(); // 容器边框
			int maxWidth = parent.getWidth() - (insets.left + insets.right + hgap * 2); // 容器最大可布置宽度
			int maxHeight = parent.getHeight() - (insets.top + insets.bottom + vgap * 2); // 容器最大可布置高度
			int compCount = parent.getComponentCount(); // 容器中组件数量
			int x = 0;
			int y = 0;
			int start = 0;
			switch (direct) {
			case HORIZONTAL: // 水平布置情况
				if (fill) { // 组件填满容器高度，按单行进行布置
					for (int i = 0; i < compCount; i++) {
						Component comp = parent.getComponent(i);
						if (comp.isVisible()) {
							Dimension d = comp.getPreferredSize();
							d.height = maxHeight;
							comp.setSize(d);
							if ((x == 0) || ((x + d.width) <= maxWidth)) {
								if (x > 0) {
									x += hgap;
								}
								x += d.width;
							}
						}
					}
					arrangeComponentsHorizontal(parent, insets.left + hgap, insets.top + vgap, maxWidth - x, maxHeight,
							start, compCount);
				} else { // 组件不填满容器高度，按多行进行布置
					int rowHeight = 0;
					int arrangeHeight = getArrangeHeight(parent, maxWidth); // 布置所有组件所需高度
					int unuseHeight = maxHeight - arrangeHeight; // 未布置区域高度
					switch (anchor) { // 根据锚点计算首行的起始坐标
					case TOP_LEFT, TOP, TOP_RIGHT:
						y += 0;
						break;
					case LEFT, CENTER, RIGHT:
						y += unuseHeight / 2;
						break;
					case BOTTOM_LEFT, BOTTOM, BOTTOM_RIGHT:
						y += unuseHeight;
						break;
					}
					if (reverseRC) { // 按行进行反转，即首行靠下，其余行依次往上
						y += arrangeHeight;
						for (int i = 0; i < compCount; i++) {
							Component comp = parent.getComponent(i);
							if (comp.isVisible()) {
								Dimension d = comp.getPreferredSize();
								comp.setSize(d);
								if ((x == 0) || ((x + d.width) <= maxWidth)) {
									if (x > 0) {
										x += hgap;
									}
									x += d.width;
									rowHeight = Math.max(rowHeight, d.height);
								} else {
									y -= rowHeight;
									arrangeComponentsHorizontal(parent, insets.left + hgap, insets.top + vgap + y,
											maxWidth - x, rowHeight, start, i);
									y -= vgap;
									x = d.width;
									rowHeight = d.height;
									start = i;
								}
							}
						}
						y -= rowHeight;
						arrangeComponentsHorizontal(parent, insets.left + hgap, insets.top + vgap + y, maxWidth - x,
								rowHeight, start, compCount);
					} else { // 不按行反转，即首行靠上，其余行依次往下
						for (int i = 0; i < compCount; i++) {
							Component comp = parent.getComponent(i);
							if (comp.isVisible()) {
								Dimension d = comp.getPreferredSize();
								comp.setSize(d);
								if ((x == 0) || ((x + d.width) <= maxWidth)) {
									if (x > 0) {
										x += hgap;
									}
									x += d.width;
									rowHeight = Math.max(rowHeight, d.height);
								} else {
									arrangeComponentsHorizontal(parent, insets.left + hgap, insets.top + vgap + y,
											maxWidth - x, rowHeight, start, i);
									y += vgap + rowHeight;
									x = d.width;
									rowHeight = d.height;
									start = i;
								}
							}
						}
						arrangeComponentsHorizontal(parent, insets.left + hgap, insets.top + vgap + y, maxWidth - x,
								rowHeight, start, compCount);
					}
				}
				break;
			case VERTICAL: // 垂直布置情况
				if (fill) { // 组件填满容器宽度，按单列进行布置
					for (int i = 0; i < compCount; i++) {
						Component comp = parent.getComponent(i);
						if (comp.isVisible()) {
							Dimension d = comp.getPreferredSize();
							d.width = maxWidth;
							comp.setSize(d);
							if ((y == 0) || ((y + d.height) <= maxHeight)) {
								if (y > 0) {
									y += vgap;
								}
								y += d.height;
							}
						}
					}
					arrangeComponentsVertical(parent, insets.left + hgap, insets.top + vgap, maxWidth, maxHeight - y,
							start, compCount);
				} else { // 组件不填满容器宽度，按多列进行布置
					int colWidth = 0;
					int arrangeWidth = getArrangeWidth(parent, maxHeight); // 布置所有组件所需宽度
					int unuseWidth = maxWidth - arrangeWidth; // 未布置区域宽度
					switch (anchor) { // 根据锚点计算首列的起始坐标
					case TOP_LEFT, LEFT, BOTTOM_LEFT:
						x += 0;
						break;
					case TOP, CENTER, BOTTOM:
						x += unuseWidth / 2;
						break;
					case TOP_RIGHT, RIGHT, BOTTOM_RIGHT:
						x += unuseWidth;
						break;
					}
					if (reverseRC) { // 按列进行反转，即首列靠右，其余列依次往左
						x += arrangeWidth;
						for (int i = 0; i < compCount; i++) {
							Component comp = parent.getComponent(i);
							if (comp.isVisible()) {
								Dimension d = comp.getPreferredSize();
								comp.setSize(d);
								if ((y == 0) || ((y + d.height) <= maxHeight)) {
									if (y > 0) {
										y += vgap;
									}
									y += d.height;
									colWidth = Math.max(colWidth, d.width);
								} else {
									x -= colWidth;
									arrangeComponentsVertical(parent, insets.left + hgap + x, insets.top + vgap,
											colWidth, maxHeight - y, start, i);
									x -= hgap;
									y = d.height;
									colWidth = d.width;
									start = i;
								}
							}
						}
						x -= colWidth;
						arrangeComponentsVertical(parent, insets.left + hgap + x, insets.top + vgap, colWidth,
								maxHeight - y, start, compCount);
					} else { // 不按列反转，即首列靠左，其余列依次往右
						for (int i = 0; i < compCount; i++) {
							Component comp = parent.getComponent(i);
							if (comp.isVisible()) {
								Dimension d = comp.getPreferredSize();
								comp.setSize(d);
								if ((y == 0) || ((y + d.height) <= maxHeight)) {
									if (y > 0) {
										y += vgap;
									}
									y += d.height;
									colWidth = Math.max(colWidth, d.width);
								} else {
									arrangeComponentsVertical(parent, insets.left + hgap + x, insets.top + vgap,
											colWidth, maxHeight - y, start, i);
									x += hgap + colWidth;
									y = d.height;
									colWidth = d.width;
									start = i;
								}
							}
						}
						arrangeComponentsVertical(parent, insets.left + hgap + x, insets.top + vgap, colWidth,
								maxHeight - y, start, compCount);
					}
				}
				break;
			}
		}
	}

	/**
	 * 根据组件的首选尺寸计算所有组件按水平布置所需的容器高度。
	 * 
	 * @param parent   要布局的容器
	 * @param maxWidth 容器最大可布置宽度
	 * @return 所有组件按水平布置所需的容器高度
	 */
	private int getArrangeHeight(Container parent, int maxWidth) {
		int arrangeHeight = 0;
		int x = 0;
		int rowHeight = 0;
		int compCount = parent.getComponentCount();
		for (int i = 0; i < compCount; i++) {
			Component comp = parent.getComponent(i);
			if (comp.isVisible()) {
				Dimension d = comp.getPreferredSize();
				if ((x == 0) || ((x + d.width) <= maxWidth)) {
					if (x > 0) {
						x += hgap;
					}
					x += d.width;
					rowHeight = Math.max(rowHeight, d.height);
				} else {
					arrangeHeight += rowHeight + vgap;
					rowHeight = d.height;
					x = d.width;
				}
			}
		}
		arrangeHeight += rowHeight;
		return arrangeHeight;
	}

	/**
	 * 根据组件的首选尺寸计算所有组件按垂直布置所需的容器宽度。
	 * 
	 * @param parent    要布局的容器
	 * @param maxHeight 容器最大可布置高度
	 * @return 所有组件按垂直布置所需的容器宽度
	 */
	private int getArrangeWidth(Container parent, int maxHeight) {
		int arrangeWidth = 0;
		int y = 0;
		int colWidth = 0;
		int compCount = parent.getComponentCount();
		for (int i = 0; i < compCount; i++) {
			Component comp = parent.getComponent(i);
			if (comp.isVisible()) {
				Dimension d = comp.getPreferredSize();
				if ((y == 0) || ((y + d.height) <= maxHeight)) {
					if (y > 0) {
						y += vgap;
					}
					y += d.height;
					colWidth = Math.max(colWidth, d.width);
				} else {
					arrangeWidth += colWidth + hgap;
					colWidth = d.width;
					y = d.height;
				}
			}
		}
		arrangeWidth += colWidth;
		return arrangeWidth;
	}

	/**
	 * 按水平方式在行内布置组件。
	 * 
	 * @param parent 要布局的容器
	 * @param x      行的 x 坐标
	 * @param y      行的 y 坐标
	 * @param width  行的未布置区域宽度
	 * @param height 行的高度
	 * @param start  起始组件索引（包含）
	 * @param end    终止组件索引（不包含）
	 */
	private void arrangeComponentsHorizontal(Container parent, int x, int y, int width, int height, int start,
			int end) {
		switch (anchor) { // 根据锚点计算起始 x 坐标
		case TOP_LEFT, LEFT, BOTTOM_LEFT:
			x += 0;
			break;
		case TOP, CENTER, BOTTOM:
			x += width / 2;
			break;
		case TOP_RIGHT, RIGHT, BOTTOM_RIGHT:
			x += width;
			break;
		}
		if (reverseComp) { // 组件反转布置，即先布置的组件靠右，后布置的靠左
			for (int i = end - 1; i >= start; i--) {
				Component comp = parent.getComponent(i);
				if (comp.isVisible()) {
					Dimension d = comp.getSize();
					int cy = 0;
					switch (align) { // 根据对齐方式计算组件的 y 坐标
					case LEFT_OR_TOP:
						cy = y;
						break;
					case CENTER_OR_CENTER:
						cy = y + (height - d.height) / 2;
						break;
					case RIGHT_OR_BOTTOM:
						cy = y + (height - d.height);
						break;
					}
					comp.setLocation(x, cy);
					x += comp.getWidth() + hgap;
				}
			}
		} else { // 组件不反转布置，即先布置的组件靠左，后布置的靠右
			for (int i = start; i < end; i++) {
				Component comp = parent.getComponent(i);
				if (comp.isVisible()) {
					Dimension d = comp.getSize();
					int cy = 0;
					switch (align) { // 根据对齐方式计算组件的 y 坐标
					case LEFT_OR_TOP:
						cy = y;
						break;
					case CENTER_OR_CENTER:
						cy = y + (height - d.height) / 2;
						break;
					case RIGHT_OR_BOTTOM:
						cy = y + (height - d.height);
						break;
					}
					comp.setLocation(x, cy);
					x += comp.getWidth() + hgap;
				}
			}
		}
	}

	/**
	 * 按垂直方式在列内布置组件。
	 * 
	 * @param parent 要布局的容器
	 * @param x      列的 x 坐标
	 * @param y      列的 y 坐标
	 * @param width  列的宽度
	 * @param height 列的未布置区域高度
	 * @param start  起始组件索引（包含）
	 * @param end    终止组件索引（不包含）
	 */
	private void arrangeComponentsVertical(Container parent, int x, int y, int width, int height, int start, int end) {
		switch (anchor) { // 根据锚点计算起始 y 坐标
		case TOP_LEFT, TOP, TOP_RIGHT:
			y += 0;
			break;
		case LEFT, CENTER, RIGHT:
			y += height / 2;
			break;
		case BOTTOM_LEFT, BOTTOM, BOTTOM_RIGHT:
			y += height;
			break;
		}
		if (reverseComp) { // 组件反转布置，即先布置的组件靠下，后布置的靠上
			for (int i = end - 1; i >= start; i--) {
				Component comp = parent.getComponent(i);
				if (comp.isVisible()) {
					Dimension d = comp.getSize();
					int cx = 0;
					switch (align) { // 根据对齐方式计算组件的 x 坐标
					case LEFT_OR_TOP:
						cx = x;
						break;
					case CENTER_OR_CENTER:
						cx = x + (width - d.width) / 2;
						break;
					case RIGHT_OR_BOTTOM:
						cx = x + (width - d.width);
						break;
					}
					comp.setLocation(cx, y);
					y += comp.getHeight() + vgap;
				}
			}
		} else { // 组件不反转布置，即先布置的组件靠上，后布置的靠下
			for (int i = start; i < end; i++) {
				Component comp = parent.getComponent(i);
				if (comp.isVisible()) {
					Dimension d = comp.getSize();
					int cx = 0;
					switch (align) { // 根据对齐方式计算组件的 x 坐标
					case LEFT_OR_TOP:
						cx = x;
						break;
					case CENTER_OR_CENTER:
						cx = x + (width - d.width) / 2;
						break;
					case RIGHT_OR_BOTTOM:
						cx = x + (width - d.width);
						break;
					}
					comp.setLocation(cx, y);
					y += comp.getHeight() + vgap;
				}
			}
		}
	}
    
    // ...

}

沃特曼达
关注
  • 17
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
7、Flink 流计算处理和批处理平台
KamRoseLee的博客
11-15 6980
一、Flink 基本概念 Flink 是一个批处理和流处理结合的统一计算框架，其核心是一个提供了数据分发以及并行化计算的流数据处理引擎。它的最大亮点是流处理，是业界最顶级的开源流处理引擎。Flink 与 Storm 类似，属于事件驱动型实时流系统。 所谓说事件驱动型指的就是一个应用提交之后，除非明确的指定停止，否则，该业务会一直持续的运行，它的执行条件就是触发了某一个事件，比如在淘宝中，我...
CSS布局方式之流动布局、浮动布局、定位布局讲解
weixin_44860226的博客
07-20 4918
css三种常规的布局方式，流动布局、浮动布局、定位布局等讲解
CSS - 移动端布局（二）移动端适配
伏城之外的博客
08-24 1765
移动端适配布局、固定尺寸布局、网页设计稿概念、百分比尺寸布局、包含块概念、rem布局、vw布局
视频流媒体服务器的作用是什么？流媒体服务器功能介绍
EasyDSS官方技术博客
04-24 2661
入行这么多年，深深觉得流媒体服务器的未来也将伴随着宽带应用和网络发展的总趋势，毕竟科技改变生活，未来流媒体也将占据网络的主流，视频流媒体服务器的功能和作用也将越来越丰富。 在未来，流媒体服务器将转向高度分布式的系统结构，这种体系结构在地理上是分布的，但逻辑上是单一的系统映像。在未来，一方面会有高性能的网络存储设备，另一方面会有高度智能化的协议控制和处理设备。这将是未来流媒体服务器扩展的极好方向。...
径向水平钻孔直旋混合射流喷嘴流场特性分析
05-31
为解决高压水射流径向水平钻孔时孔径和孔深相互矛盾的问题,设计了一种兼具直射流和旋转射流特点的直旋混合射流喷嘴。运用数值模拟方法,采用RNG k-ε湍流模型对所设计喷嘴的内外流场进行了三维流动特性分析,运用高速...
Intersil推出兼具USB功能和低失真的开关
11-27
Intersil新推出的双单刀双掷开关在同类的低压器件中兼具了低音频失真和USB2.0数据全速率传输能力。  据称，ISL54400/01/02 2:1双路复用器件相对于其竞争方案提高了音频播放质量、消除了外部元件并大幅节省了电路...
电子镇流器的几种类型对比
01-20
现代日光灯越来越多的使用电子镇流器，轻便小巧，甚至可以将电子镇流器与灯管等集成在一起，同时，电子镇流器通常可以兼具起辉器功能，故此又可省去单独的起辉器。电子镇流器还可以具有更多功能，比如可以通过提高...
基于能量最优的室内可见光通信LED布局
02-07
LED兼具照明和数据通信功能, 在室内可见光通信(VLC)中, LED的布局对维持接收面上接收功率的稳定分布有重要作用。室内LED矩形布局下的接收功率分布并不能覆盖整个接收面, 存在接收功率中断区, 无法实现最优的VLC系统...
入门分享：电子镇流器的常识大全
01-20
导读：电子镇流器是采用电子...现代日光灯越来越多的使用电子镇流器，轻便小巧，甚至可以将电子镇流器与灯管等集成在一起，同时，电子镇流器通常可以兼具起辉器功能，故此又可省去单独的起辉器。电子镇流器还可以具有
Elsaticsearch java基本操作
qq_62383709的博客
07-13 430
索引 基本操作 package com.orchids.elasticsearch.web.controller; import cn.hutool.core.collection.CollUtil; import cn.hutool.json.JSONUtil; import com.orchids.elasticsearch.web.po.User; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperatio
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 385
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 449
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2441
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java Object 转 Integer
servepeople的博客
07-09 1452
在 Java 中，可以通过多种方法将一个Object转换为Integer。
elk部署springboot
Chihirozy的博客
07-11 292
elk部署springboot。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 3341
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
Java 线程池详解
最新发布
qq_41591215的博客
07-13 644
线程池是一组已经初始化并等待执行任务的线程集合。通过使用线程池，我们可以避免频繁地创建和销毁线程，从而节省资源和减少系统开销。线程池的核心思想是通过复用线程来提高性能。
JavaSE 面向对象程序设计进阶 IO流 字节流详解 抛出异常
牛马程序员的博客
07-10 765
存储和读取数据的解决方案内存中数据不能永久化存储 程序停止运行 数据消失File只能对文件本身进行操作 不能读写文件里存储的数据读写数据必须要有IO流可以把程序中的数据保存到文件当中还可以把本地文件中的数据读取到数据当中。
金融科技企业专利挖掘与布局
03-11
金融科技企业专利挖掘与布局

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值