标签 java 下的文章

2024-08-23

在Java中，我们可以使用java.util.Random类来生成随机数。以下是一些常见的用法：

生成一个随机整数：




int randomInt = new Random().nextInt();

生成一个0到指定上限（不含）的随机整数：




int randomIntUpTo100 = new Random().nextInt(100);

生成一个随机浮点数：




float randomFloat = new Random().nextFloat();

生成一个随机布尔值：




boolean randomBoolean = new Random().nextBoolean();

生成一个随机字符：




char randomChar = (char)('a' + new Random().nextInt(26));

生成一个随机字符串（例如，长度为10的随机字符串）：




String randomString = String.valueOf(new Random().ints(10, 'a', 'z' + 1).distinct().limit(10).collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append).toString());

使用随机数进行排序：




List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Collections.shuffle(numbers, new Random());

以上都是java.util.Random的常见用法，每种方法都有其特定的使用场景。

- 阅读更多 -

Java 8 中的 Stream API - map() 方法详解

System

2024-08-23

所有,python

map() 方法是 Java 8 的 Stream API 中的一个重要方法，它用于将输入的元素转换为另一种形式的元素。map() 方法接受一个函数作为参数，这个函数会应用到每个元素上，并且将其映射成一个新的元素。

以下是 map() 方法的一个示例，它将一个整数列表转换为其各个元素的平方：




import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
 
public class StreamMapExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> squares = numbers.stream()
                                        .map(number -> number * number)
                                        .collect(Collectors.toList());
 
        System.out.println(squares); // 输出: [1, 4, 9, 16, 25]
    }
}

在这个例子中，map() 方法接受了一个 lambda 表达式 number -> number * number，这个表达式将输入的每个整数值进行平方操作。然后，使用 collect(Collectors.toList()) 收集转换后的流元素到一个新的列表中。

- 阅读更多 -

Java语言程序设计——篇三

System

2024-08-23

所有,python

题目中的“Java语言程序设计—篇三(1)”不是一个具体的代码问题，而是一个教学篇章的标题。因此，我无法提供针对某个代码的解决方案。不过，我可以提供一个简单的Java程序示例，该程序展示了如何使用for循环来计算一个数字的阶乘。




public class FactorialCalculator {
    public static void main(String[] args) {
        int number = 5; // 可以修改这个值来计算其他数的阶乘
        int factorial = 1;
 
        for (int i = 2; i <= number; i++) {
            factorial *= i;
        }
 
        System.out.println(number + "! = " + factorial);
    }
}

在这个程序中，我们定义了一个名为FactorialCalculator的类，它有一个名为main的方法。在main方法中，我们使用了一个for循环来迭代从2到指定的number，并在每次迭代中将当前的i乘以factorial变量。最后，我们打印出number的阶乘结果。这个程序是学习Java循环结构的一个很好的起点。

System

2024-08-23

所有,python

Java语言每次版本更新都会带来新的语法特性，JDK 17也不例外。以下是JDK 17中一些主要的新特性：

模式匹配（Pattern Matching for instanceof）: 使得对 instanceof 的判断更为清晰和强大。




if (obj instanceof String s) {
    // 在这个代码块里, s已经被强转为String类型
    System.out.println(s.length());
}

文本块（Text Blocks）: 提供了一种更为简洁的方式来写多行字符串。




String html = """
    <html>
        <body>
            <p>Hello, World</p>
        </body>
    </html>
    """;

密封类（Sealed Classes）: 限制某个类的子类必须位于特定的命名空间中。




public sealed class Vehicle permits Car, Bike {
    // ...
}
 
public non-sealed class Car extends Vehicle {
    // ...
}
 
public final class Bike extends Vehicle {
    // ...
}

隐藏类（Hidden Classes）: 允许动态生成一个只在JVM上可见，对Java源代码不可见的类。
向量API（Vector API）: 提供了一套新的API来进行向量计算，可以提高CPU的数学运算速度。




Vector<Double> v1 = Vector.of(1.0, 2.0, 3.0);
Vector<Double> v2 = Vector.of(4.0, 5.0, 6.0);
Vector<Double> result = v1.add(v2); // 进行向量相加

开放式默认方法（Open Default Methods）: 允许在接口中添加默认实现的方法。




public interface MyInterface {
    default void newMethod() {
        System.out.println("New method");
    }
}

改进的JFR（Java Flight Recorder）: 提供了更为强大的诊断和性能分析工具。
外部存储器访问 API（External Storage Access API）: 提供了一种安全的方式来访问外部存储设备上的文件。
数据类型规范化（Value-Based Numeric Types）: 为整数类型（比如Byte, Short, Integer, Long）等提供了值比较的能力。
删除CMS（Concurrent Mark Sweep）垃圾收集器: CMS垃圾收集器在JDK 17中被彻底移除。

这些新特性为Java开发者提供了更多的工具和方法来编写更加现代和高效的代码。

- 阅读更多 -

Java | 一分钟掌握定时任务 | 8 - XXL-Job分布式定时任务

System

2024-08-23

所有,分布式




import com.xxl.job.core.handler.annotation.XxlJob;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
 
@Component
public class SampleXxlJob {
    private static final Logger logger = LoggerFactory.getLogger(SampleXxlJob.class);
 
    @XxlJob("demoJobHandler")
    public void execute() throws Exception {
        // 任务逻辑
        logger.info("执行分布式定时任务...");
        // 任务代码
        // ...
    }
}

这段代码展示了如何在Spring环境中使用@XxlJob注解来创建一个分布式定时任务。execute方法是定时任务的执行逻辑，可以在这里编写你的业务逻辑。这个例子中，任务的名称是通过注解@XxlJob("demoJobHandler")指定的。在XXL-JOB的管理界面中，你需要配置相应的任务名称和其他参数，以便XXL-JOB能正确地调度这个任务。

- 阅读更多 -

Java | 一分钟掌握定时任务 | 9 - PowerJob分布式定时任务

System

2024-08-23

所有,分布式




import com.github.kfcfans.powerjob.common.PowerJobException;
import com.github.kfcfans.powerjob.common.RemoteJobService;
import com.github.kfcfans.powerjob.common.response.ResultDTO;
import com.github.kfcfans.powerjob.worker.core.processor.TaskContext;
import com.github.kfcfans.powerjob.worker.log.OmsLogger;
 
public class MyDistributedTimedTaskProcessor implements com.github.kfcfans.powerjob.worker.core.processor.Processor {
 
    private RemoteJobService jobService;
    private OmsLogger omsLogger;
 
    @Override
    public ProcessResult process(TaskContext context) throws Exception {
        // 获取参数
        String param = context.getJobParams();
 
        // 执行任务逻辑
        boolean success = executeTask(param);
 
        // 记录日志
        omsLogger.info("执行分布式定时任务，参数：" + param + "，结果：" + (success ? "成功" : "失败"));
 
        // 返回处理结果
        return new ProcessResult(success ? ResultDTO.SUCCESS : ResultDTO.FAIL);
    }
 
    private boolean executeTask(String param) {
        // 这里执行具体的任务逻辑
        // 返回任务执行结果，true 表示成功，false 表示失败
        return true;
    }
 
    // 省略其他方法的实现...
}

这个代码示例展示了如何实现一个分布式定时任务处理器。它定义了一个MyDistributedTimedTaskProcessor类，实现了Processor接口，并且提供了一个process方法来执行任务。在process方法中，它调用了executeTask方法来执行具体的任务逻辑，并记录了日志。这个示例简单明了地展示了如何使用PowerJob框架来实现定时任务的处理。

- 阅读更多 -

Java的Zookeeper与分布式协调

System

2024-08-23

所有,分布式

Zookeeper是一个分布式服务协调框架，常用于实现分布式锁服务、配置管理、名字服务等。以下是一个简单的Java程序，使用Zookeeper API创建一个临时节点：




import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.CreateMode;
 
public class ZookeeperExample {
    private static final String CONNECTION_STRING = "localhost:2181";
    private static final int SESSION_TIMEOUT = 2000;
    private static final String ZNODE_PATH = "/my_temp_node";
 
    public static void main(String[] args) {
        ZooKeeper zookeeper = null;
        try {
            zookeeper = new ZooKeeper(CONNECTION_STRING, SESSION_TIMEOUT, event -> {});
            
            // 创建临时节点
            String result = zookeeper.create(ZNODE_PATH, "my_data".getBytes(),
                                             ZooDefs.Ids.OPEN_ACL_UNSAFE,
                                             CreateMode.EPHEMERAL);
            System.out.println("Temporary node created with path: " + result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (zookeeper != null) {
                    zookeeper.close();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

这段代码展示了如何使用Zookeeper API在Zookeeper服务中创建一个临时节点。它首先建立与Zookeeper服务的连接，然后创建一个临时节点，并在控制台输出创建结果。在结束时，它关闭了Zookeeper会话。这个例子简单明了地展示了Zookeeper在Java分布式应用中的基本使用方法。

System

2024-08-23

所有,分布式




// 单例模式示例
// 使用闭包创建一个私有变量和一个公共接口
function createSingleton(name) {
    let instance = null; // 私有变量，用于存储单例实例
 
    // 单例构造函数
    function Singleton(name) {
        this.name = name;
    }
 
    // 公共接口
    return {
        getInstance: function(name) {
            if (!instance) {
                instance = new Singleton(name);
            }
            return instance;
        }
    };
}
 
// 获取单例实例
const singleton1 = createSingleton('SingletonA').getInstance();
const singleton2 = createSingleton('SingletonB').getInstance();
 
// 检查singleton1和singleton2是否相同
console.log(singleton1 === singleton2); // 输出: true

这个代码示例展示了如何使用闭包和单例模式创建一个工厂函数，该工厂函数可以创建全局唯一的对象实例。每次调用getInstance方法时，都会检查是否已经创建了实例。如果没有，则创建一个新的实例，并将其存储在私有变量中。这确保了无论调用多少次getInstance，都只会返回同一个实例。

System

2024-08-23

所有,html5




# Python版本的简单游戏代码示例
import pygame
import sys
import random
 
# 初始化pygame
pygame.init()
 
# 设置屏幕大小
screen_width = 800
screen_height = 600
screen = pygame.display.set_mode((screen_width, screen_height))
 
# 设置游戏时钟
clock = pygame.time.Clock()
 
# 定义颜色常量
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
RED = (255, 0, 0)
 
# 定义游戏中的一个简单的'球'类
class Ball:
    def __init__(self, x, y, radius, color):
        self.x = x
        self.y = y
        self.radius = radius
        self.color = color
        self.vel_x = random.randint(1, 5)
        self.vel_y = random.randint(1, 5)
 
    def draw(self, screen):
        pygame.draw.circle(screen, self.color, (int(self.x), int(self.y)), self.radius)
 
# 创建一个球实例
ball = Ball(screen_width/2, screen_height/2, 10, WHITE)
 
# 游戏循环标志
running = True
 
# 游戏循环
while running:
    # 设置背景颜色
    screen.fill(BLACK)
 
    # 事件处理
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
 
    # 更新球位置
    ball.x += ball.vel_x
    ball.y += ball.vel_y
 
    # 如果球碰到边界，反弹
    if ball.x > screen_width - ball.radius or ball.x < ball.radius:
        ball.vel_x = -ball.vel_x
    if ball.y > screen_height - ball.radius or ball.y < ball.radius:
        ball.vel_y = -ball.vel_y
 
    # 绘制球
    ball.draw(screen)
 
    # 更新屏幕显示
    pygame.display.flip()
 
    # 控制游戏循环的速度
    clock.tick(60)
 
# 退出游戏
pygame.quit()
sys.exit()

这段代码创建了一个简单的圆形球，它在屏幕上反弹，模拟了物理的碰撞效果。通过这个例子，开发者可以学习如何使用Python和pygame库创建简单的2D游戏。

- 阅读更多 -

实现高性能分布式 ID 生成器：Java 雪花算法详解

System

2024-08-23

所有,分布式




public class SnowflakeIdGenerator {
    // 64位的时间偏移量
    private final static long TWEPOCH = 1288834974657L;
    // 机器id所占的位数
    private final static long WORKER_ID_BITS = 5L;
    // 数据标识id所占的位数
    private final static long DATA_CENTER_ID_BITS = 5L;
    // 序列在id中所占的位数
    private final static long SEQUENCE_BITS = 12L;
 
    // 机器ID最大值
    private final static long MAX_WORKER_ID = ~(-1L << WORKER_ID_BITS);
    // 数据标识id最大值
    private final static long MAX_DATA_CENTER_ID = ~(-1L << DATA_CENTER_ID_BITS);
 
    // 序列号的掩码，这里为4095 (0b111111111111=0xfff=4095)
    private final static long SEQUENCE_MASK = ~(-1L << SEQUENCE_BITS);
 
    // 工作机器ID(0~31)
    private long workerId;
    // 数据中心ID(0~31)
    private long dataCenterId;
    // 毫秒内序列(0~4095)
    private long sequence = 0L;
    // 上次生成ID的时间戳
    private long lastTimestamp = -1L;
 
    // 构造函数
    public SnowflakeIdGenerator(long workerId, long dataCenterId) {
        if (workerId > MAX_WORKER_ID || workerId < 0) {
            throw new IllegalArgumentException("worker Id can't be greater than %d or less than 0");
        }
        if (dataCenterId > MAX_DATA_CENTER_ID || dataCenterId < 0) {
            throw new IllegalArgumentException("dataCenter Id can't be greater than %d or less than 0");
        }
        this.workerId = workerId;
        this.dataCenterId = dataCenterId;
    }
 
    // 获得下一个ID
    public synchronized long nextId() {
        long timestamp = timeGen();
 
        // 如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退了，这是不允许的。
        if (timestamp < lastTimestamp) {
            throw new RuntimeException(String.format(
                    "Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
        }
 
        // 如果是同一毫秒内重新生成ID，则进行序列号自增
        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & SEQUENCE_MASK;
            // 序列号溢出
            if (sequence == 0) {
                timestamp = tilNextMillis(lastTimestamp);
            }
        } else {
            // 如果是新的一毫秒，则序列号重置
            sequence = 0L;
        }
 
        // 记录最后一次生成ID的时间戳
        lastTimestamp = timestamp;
 
        // 移位并通过按位或运算生成ID
        return ((timestamp - TWEPOCH) << (DATA_CENTER_ID_BITS + WORKER_ID_BITS)) |
                (dataCenterId << WORKER_ID_BITS) |
                (workerId << SEQUENCE_BITS) |
                sequence;
    }
 
    // 获取当前时间戳

- 阅读更多 -