Java基础编程500题——阶段练习2

已于 2024-07-23 22:49:08 修改
阅读量1k 收藏 22
点赞数 10
分类专栏： Java基础编程500题 文章标签： java 开发语言 网络 数据结构 spring
于 2024-07-23 22:18:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53140426/article/details/140638174
版权

💥 该系列属于【Java基础编程500题】专栏，如您需查看Java基础的其他相关题目，请您点击左边的连接

目录

1. 【正则表达式，日期API，异常】编写一个程序，使用正则表达式验证输入的字符串是否为合法的日期格式（如：yyyy-MM-dd），如果是，将其转换为日期对象并输出。

2. 【面向对象，注解，反射】定义一个注解@MethodInfo，包含一个String类型的字段description。使用反射获取一个类的所有方法，并输出带有@MethodInfo注解的方法描述。

3. 【文件，IO流，异常】在当前目录下创建一个"example.txt"文件，里面有5行，每行一个数字。然后编写一个程序，读取"example.txt"，并将文件内容输出到控制台。如果文件不存在或读取过程中发生异常，请捕获异常并输出相应的错误信息。

4. 【多线程，动态代理】使用动态代理创建一个简单的线程安全的计数器代理，使用完一次计数器处理器要输出"计数器+1"，并使用两个线程进行测试，每个线程增加计数器100次，最后输出计数器的最终值。

5. 【网络编程】编写一个简单的网络客户端程序，连接到本地服务器（例如，使用localhost和指定端口），并发送当前系统时间和用户输入的消息。服务器应回显消息，客户端打印服务器回显的消息。

6. 【线程，异常】编写一个程序，使用一个线程计算一个整数数组中所有元素的和。如果数组中包含负数，则抛出自定义异常NegativeNumberException，并在主线程中捕获该异常。

7. 【String，正则表达式】给定一个字符串数组，使用正则表达式找出所有包含手机号码的字符串，并将手机号码提取出来。

8. 【集合，Stream，String，正则表达式】给定一个字符串集合，使用Stream API和正则表达式过滤出所有包含电子邮箱地址的字符串。

9. 【Stream，正则表达式，动态代理】创建一个动态代理对象，该对象对字符串数组进行遍历，使用Stream API找出所有包含数字的字符串。

10. 【泛型，反射】编写一个泛型方法，该方法接受任意类的对象和一个字段名作为参数。方法应使用反射API来获取并输出该对象指定字段的值。

11. 【反射，注解，动态代理，日期和时间API】定义一个名为@TimeOrLog的注解，用于标记需要统计执行时间或者记录日志的方法。使用动态代理来拦截被注解标记的方法，并计算其执行时间或者记录日志。

12. 【面向对象，枚举类，多线程】请你使用枚举类实现一个基于角色（管理员、用户、访客）的并发访问控制，三个角色线程需要访问一个资源，资源只能被一个角色的线程访问。

✨✨  返回题目目录 ✨ ✨ 

Java基础编程500题

1. 【正则表达式，日期API，异常】编写一个程序，使用正则表达式验证输入的字符串是否为合法的日期格式（如：yyyy-MM-dd），如果是，将其转换为日期对象并输出。

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        if (str.matches("^\\d{4}-\\d{2}-\\d{2}$")) {
            try {
                DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
                LocalDate localDate = LocalDate.parse(str, dateTimeFormatter);
                System.out.println("输入的日期符合格式要求");
                System.out.println(localDate);
            } catch (DateTimeParseException e) {
                System.out.println("输入的日期不符合格式要求");
            }
        } else {
            System.out.println("输入的日期不符合格式要求");
        }
    }
}

2. 【面向对象，注解，反射】定义一个注解@MethodInfo，包含一个String类型的字段description。使用反射获取一个类的所有方法，并输出带有@MethodInfo注解的方法描述。

import java.lang.annotation.*;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface MethodInfo {
    String description() default "";
}

class MyClass {
    @MethodInfo(description = "这是第一个方法")
    void method1() {
        System.out.println("method1有注解");
    }

    @MethodInfo(description = "这是第二个方法")
    void method2() {
        System.out.println("method2有注解");
    }

    void method3() {
        System.out.println("method3没有注解");
    }
}

public class Main {
    public static void main(String[] args) {
        //获取一个类的所有信息
        Class<MyClass> myClassClass = MyClass.class;
        //获取这个类的所有方法信息
        Method[] declaredMethods = myClassClass.getDeclaredMethods();

        for (Method method : declaredMethods) {
            // 获取这个方法上的注解
            MethodInfo annotation = method.getAnnotation(MethodInfo.class);
            if (annotation != null) {
                System.out.println("方法名:" + method.getName() + "，描述:" + annotation.description());
            }
        }

    }
}

3. 【文件，IO流，异常】在当前目录下创建一个"example.txt"文件，里面有5行，每行一个数字。然后编写一个程序，读取"example.txt"，并将文件内容输出到控制台。如果文件不存在或读取过程中发生异常，请捕获异常并输出相应的错误信息。

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        // 使用 try-with-resources 语句自动关闭资源，避免了显示关闭资源
        try (FileReader fileReader = new FileReader("example.txt");
             BufferedReader bufferedReader = new BufferedReader(fileReader)) {
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (FileNotFoundException e) {
            System.out.println("文件未找到：" + e.getMessage());
        } catch (IOException e) {
            System.out.println("读取文件时发生错误：" + e.getMessage());
        }
    }
}

4. 【多线程，动态代理】使用动态代理创建一个简单的线程安全的计数器代理，使用完一次计数器处理器要输出"计数器+1"，并使用两个线程进行测试，每个线程增加计数器100次，最后输出计数器的最终值。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface Counter {
    void increment();
    int getValue();
}

class CounterImpl implements Counter {
    private int value = 0;
    public synchronized void increment() {
        value++;
    }
    public int getValue() {
        return value;
    }
}

class CounterProxy implements InvocationHandler {
    private Counter counter; // 要代理的接口

    public CounterProxy(Counter counter) {
        this.counter = counter;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object invoke = method.invoke(counter, args);
        System.out.println("计数器+1");
        return invoke;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter counter = new CounterImpl();
        Counter proxyCounter = (Counter) Proxy.newProxyInstance(
                Counter.class.getClassLoader(),
                new Class[]{Counter.class},
                new CounterProxy(counter)
        );

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                proxyCounter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                proxyCounter.increment();
            }
        });

        t1.start();
        t2.start();

        try { // 等待两个线程执行完毕
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            System.out.println("线程被中断：" + e.getMessage());
        }

        System.out.println("计数器的最终值为：" + proxyCounter.getValue());
    }
}

5. 【网络编程】编写一个简单的网络客户端程序，连接到本地服务器（例如，使用localhost和指定端口），并发送当前系统时间和用户输入的消息。服务器应回显消息，客户端打印服务器回显的消息。

Server:

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) throws IOException {
        int port = 12345;
        try (ServerSocket serverSocket = new ServerSocket(port);
             Socket clientSocket = serverSocket.accept();
             PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
             BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()))) {

            String inputLine;
            while ((inputLine = in.readLine()) != null) {
                System.out.println("客户端发送的消息：" + inputLine);
                out.println(inputLine); // Echo back to the client
            }
        }
    }
}

Client：

import java.io.*;
import java.net.Socket;
import java.time.LocalDateTime;

public class Client {
    public static void main(String[] args) {
        String host = "localhost";
        int port = 12345;
        try (Socket socket = new Socket(host, port);
             PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
             BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
             BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in))) {

            String userInput;
            System.out.println("请输入消息：");
            while ((userInput = stdIn.readLine()) != null) {
                out.println("当前时间：" + LocalDateTime.now() + "，用户输入：" + userInput);
                System.out.println("服务器回显：" + in.readLine());
            }
        } catch (IOException e) {
            System.out.println("网络通信发生异常：" + e.getMessage());
        }
    }
}

6. 【线程，异常】编写一个程序，使用一个线程计算一个整数数组中所有元素的和。如果数组中包含负数，则抛出自定义异常NegativeNumberException，并在主线程中捕获该异常。

import java.util.Arrays;

class NegativeNumberException extends Exception {
    NegativeNumberException(String message) {
        super(message);
    }
}

public class Main {
    public static void main(String[] args) {

        int[] a = new int[100];
        Arrays.fill(a, 100);

        Thread thread = new Thread(() -> {
            int sum = 0;
            for (int i = 0; i < a.length; i++) {
                try {
                    if (a[i] < 0) {
                        throw new NegativeNumberException("数组中有负数");
                    } else {
                        sum += a[i];
                    }
                } catch (NegativeNumberException e) {
                    System.out.println("捕获到自定义异常：" + e.getMessage());
                } catch (Exception e) {
                    System.out.println("捕获到其他异常：" + e.getMessage());
                }
            }
            System.out.println(sum);

        });

        thread.start();

    }
}

7. 【String，正则表达式】给定一个字符串数组，使用正则表达式找出所有包含手机号码的字符串，并将手机号码提取出来。

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        String[] strs = {
                "我的电话不告诉你!",
                "我的电话是13888888888",
                "有空拨打我电话:13666666666"
        };

        Pattern pattern = Pattern.compile("(\\d{11})");
        //方法一
        for (String str : strs) {
            Matcher matcher = pattern.matcher(str);
            if (matcher.find()) {
                System.out.println("找到电话号码:" + matcher.group(1));
            }
        }

        //方法二
        Arrays.stream(strs)
                .map(pattern::matcher)
                .filter(Matcher::find)
                .map(matcher -> matcher.group(1))
                .forEach(phoneNumber -> System.out.println("找到电话号码:" +
phoneNumber));
    }
}

8. 【集合，Stream，String，正则表达式】给定一个字符串集合，使用Stream API和正则表达式过滤出所有包含电子邮箱地址的字符串。

import java.util.List;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> emails = List.of(
                "邮箱：example@qq.com",
                "这是一个测试字符串",
                "联系邮箱：test@163.com"
        );
        Pattern pattern = Pattern.compile("\\w+@\\w+\\.\\w+");
        List<String> collect = emails.stream()
                .filter(s -> pattern.matcher(s).find())
                .collect(Collectors.toList());
        System.out.println(collect);

    }
}

9. 【Stream，正则表达式，动态代理】创建一个动态代理对象，该对象对字符串数组进行遍历，使用Stream API找出所有包含数字的字符串。

import java.lang.reflect.*;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

interface StringFilter {
    List<String> filter(String[] strs, Pattern pattern);
}

class StringFilterImpl implements StringFilter {
    @Override
    public List<String> filter(String[] strs, Pattern pattern) {
        List<String> collect = Arrays.stream(strs)
                .filter(s -> pattern.matcher(s).find())
                .collect(Collectors.toList());
        return collect;
    }
}

class StringProxy implements InvocationHandler {
    private StringFilter filter;
    public StringProxy(StringFilter filter) {
        this.filter = filter;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (method.getName().equals("filter")) {
            // 为filter进行代理
            Object invoke = method.invoke(filter, args);
            return invoke;
        }
        return null;
    }
}

public class Main {
    public static void main(String[] args) {
        StringFilter stringFilter = new StringFilterImpl();
        StringFilter proxyStringFilter = (StringFilter) Proxy.newProxyInstance(
                StringFilter.class.getClassLoader(),
                new Class[]{StringFilter.class},
                new StringProxy(stringFilter)
        );
        Pattern pattern = Pattern.compile(".*\\d.*");
        String[] strings = {"abc", "123", "def456", "ghi"};
        List<String> filter = proxyStringFilter.filter(strings, pattern);
        System.out.println(filter);
    }
}

10. 【泛型，反射】编写一个泛型方法，该方法接受任意类的对象和一个字段名作为参数。方法应使用反射API来获取并输出该对象指定字段的值。

import java.lang.reflect.Field;

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("张三", 20);
        show(person, "name");
        show(person, "age");
    }

    public static <T> void show(T object, String fieldName) {
        Class<?> clz = object.getClass();
        try {
            Field field = clz.getDeclaredField(fieldName);
            field.setAccessible(true);
            System.out.println(fieldName + "字段的值是" + field.get(object));
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

11. 【反射，注解，动态代理，日期和时间API】定义一个名为@TimeOrLog的注解，用于标记需要统计执行时间或者记录日志的方法。使用动态代理来拦截被注解标记的方法，并计算其执行时间或者记录日志。

import java.lang.annotation.*;
import java.lang.reflect.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface TimeOrLog {
    String value() default "";
}

interface Service {
    @TimeOrLog(value = "计算时间")
    public void sayHello();

    @TimeOrLog(value = "记录日志")
    public void sayBye();
}

class ServiceImpl implements Service {
    @Override
    @TimeOrLog(value = "计算时间")
    public void sayHello() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("Hello");
    }

    @Override
    @TimeOrLog(value = "记录日志")
    public void sayBye() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("Bye");
    }
}

class timeLogProxy implements InvocationHandler {
    private Service service;

    timeLogProxy(Service service) {
        this.service = service;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        TimeOrLog annotation = method.getAnnotation(TimeOrLog.class);
        if (annotation != null || !annotation.value().isEmpty()) {
            String value = annotation.value();
            String methodName = method.getName();
            if ("记录日志".equals(value)) {
                System.out.println("方法" + methodName + "开始执行");
                Object invoke = method.invoke(service, args);
                System.out.println("方法" + methodName + "执行结束");
                return invoke;
            } else if ("计算时间".equals(value)) {
                DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yy-MM-dd HH:mm:ss");
                LocalDateTime now = LocalDateTime.now();
                System.out.println(methodName + "执行于" + dateTimeFormatter.format(now));
                Object invoke = method.invoke(service, args);
                return invoke;
            }
        }
        return null;
    }
}


public class Main {
    public static void main(String[] args) {
        Service service = new ServiceImpl();
        Service serviceProxy = (Service) Proxy.newProxyInstance(
                Service.class.getClassLoader(),
                new Class[]{Service.class},
                new timeLogProxy(service)
        );
        System.out.println("==========================================");
        serviceProxy.sayHello();
        System.out.println("==========================================");
        serviceProxy.sayBye();
        System.out.println("==========================================");
    }
}

12. 【面向对象，枚举类，多线程】请你使用枚举类实现一个基于角色（管理员、用户、访客）的并发访问控制，三个角色线程需要访问一个资源，资源只能被一个角色的线程访问。

// 定义角色枚举
enum Role {
    ROLE_ADMIN("管理员"), ROLE_USER("用户"), ROLE_GUEST("访客");
    String name;

    Role(String name) {
        this.name = name;
    }

    String getName() {
        return name;
    }
}

// 资源类
class Resource {
    private final String name;

    public Resource(String name) {
        this.name = name; //资源的名字
    }

    public synchronized void access(Role role) {
        System.out.println(role.getName() + "正在访问" + name); //某个角色抢到了资源
    }
}

class GetResource implements Runnable {
    private Resource resource;
    private final Role role;

    GetResource(Resource resource, Role role) {
        this.resource = resource;
        this.role = role;
    }

    @Override
    public void run() {
        resource.access(role);
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建资源
        Resource resource = new Resource("敏感数据");

        GetResource adminGetResource = new GetResource(resource, Role.ROLE_ADMIN);
        GetResource userGetResource = new GetResource(resource, Role.ROLE_USER);
        GetResource guestGetResource = new GetResource(resource, Role.ROLE_GUEST);

        Thread adminThread = new Thread(adminGetResource);
        Thread userThread = new Thread(userGetResource);
        Thread guestThread = new Thread(guestGetResource);

        adminThread.start();
        userThread.start();
        guestThread.start();
    }
}

安晴晚风
关注
  • 10
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA 基础编程练习500题
码农研习社
05-12 1586
【程序 1】 题目： 古典问题： 有一对兔子， 从出生后第 3 个月 起每个月 都生一对兔子， 小兔子长到第三个月 后每个月又生一对兔子， 假如兔子都不死， 问每个月 的兔子对数为多少？ 程序分析： 兔子的规律为数列1,1,2,3,5,8, 13, 21....做这种题目， 最好的做法就是找出规律， 跟高中的数列一样 本题有： a[n]=a[n-1]+a[n-1],而第一第二项都知道了， 后面的值也可以求得 public class Programme1 { public st...
50道JAVA基础编程练习题3
gj55678的博客
04-10 213
【程序21】题目：求1+2!+3!+…+20!的和 public class Prog21{        public static void main(String[] args){             &nbs...
Java基础编程500题——面向对象
安晴晚风的博客
07-20 1196
Java基础编程500题——面向对象
JAVA小白 编程练习500题 超详细!!!带答案!!!持续更新中~
热门推荐
程序媛泡泡的博客
05-09 44万+
JAVA小白编程题练习 可能有很多刚入门的小白不知道自己如何能快速提升编程技巧与熟练度 其实大佬进阶之路只有一个~ 那就是疯狂码代码!!!实践出真知!!! 所以为了大家能够想练习的时候有素材,泡泡给大家整理了一些练习题 由于平时比较忙,所以我在不定时努力更新中,欢迎监督~ 500是立的Flag啊哈哈哈哈,我们共同努力吧,先出个100道,希望能给大家带来帮助~ ???????????? 练习题1:接收用户输入的3个整数,并将它们的最大值作为结果输出 package cn.cxy.exec; import j
Java基础编程500题——System
安晴晚风的博客
07-23 353
Java基础编程500题——System
Java自学之路——超仔细含练习项目及源码 Java知识体系最强总结————含各个阶段的面试题
08-06
### Java自学之路——超详细含练习项目及源码 #### Java知识体系最强总结 本篇文章旨在根据提供的文件信息，深入解读Java自学之路的关键知识点，并针对其中提到的学习资源进行详细的解析，帮助初学者更好地掌握...
JAVA编程题全集（100题及答案）——直接打印
09-30
本资源提供了一个完整的 JAVA 编程题全集，涵盖了大量的题目和经典的解法，非常适合刷学完基础、刷题前的知识总结与开拓。以下是从资源中提取的重要知识点： 1. JAVA 基础知识：资源中提到了 JAVA 程序设计总复习题...
50道JAVA基础编程练习题全面解答
11-24
### 知识点总结 #### 1. 斐波那契数列与兔子繁殖问题 - **背景**：本题目探讨了一个经典的数学问题...这些题目不仅涉及基本的Java编程技巧，还涵盖了数学概念的应用，有助于提高学习者的逻辑思维能力和编程实践能力。
java关于多态的题_Java基础之：OOP——多态练习题
weixin_34849898的博客
02-25 848
Java基础之：OOP——多态练习题应用案例1：编写教师类要求有属性“姓名name”，“年龄age”，“职称post”，“基本工资salary”编写业务方法， introduce()，实现输出一个教师的信息。编写教师类的三个子类：教授类(professor)、副教授类(vice professor)、讲师类(lecturer)。工资级别分别为：教授为1.3、副教授为1.2、讲师类1.1。在三个子类...
50道Java基础编程题（一）——新解2021（配有超详细注释）（1到10题）
huigun的博客
11-18 1536
文章目录前言1.古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子对数为多少？2.判断101-200之间有多少个素数，并输出所有素数。3.打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。4.将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。5.学习成绩>=90分的同学用A表示，60-8.
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 124
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 590
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
Yolov8：模型部署到安卓端
m0_70694811的博客
08-21 821
下载安装jdk-8u202-windows-x64.exe，这篇文章有百度网盘资源链接，直接下载，并按照这篇文章的JDK步骤进行安装和环境变量配置。C:\Program Files\Java\jdk-1.8\bin和C:\Program Files\Java\jdk-1.8\jre\bin。比如因为我的jdk路径是C:\Program Files\Java\jdk-1.8，所以这两个相对路径就改成。参考这边文章的USB驱动设置和手机端设置。同意协议后，下载相应版本的JDK。
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 973
linux上datax 安装以及使用
基于jenkins部署maven项目
静水深流
08-26 288
如上所示，构建后，我们处于项目的根目录之下，可以进行后续的操作，如启动target目录下的jar包、将jar包传输到需要部署的服务器上、打docker镜像bing上传等等，需要根据实际情况进行选择，而这些都可以在“Add post-build step”选项中进行选择。我们主要关注上述几个部分，在General部分，可以对项目进行一个简单的描述，源码管理部分，需要配置对应的源码url，如下图所示。如上所示，选择“构建一个maven项目”，如果没有改选项，则需要安装maven构建的插件，请参考之前的文章。
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 806
@Transactional中使用线程锁导致了锁失效与解决方案
Java学习_18_Stream流
qq_41136689的博客
08-23 1225
博客仅记录个人学习进度和一些查缺补漏。学习内容：BV17F411T7Ao流的出现让数据处理从几十行代码缩减到一两行就能实现，简化了很多集合数组的操作。
JavaScript 错误 - Throw 和 Try to Catch的使用
逆风优雅的博客
08-23 181
trycatchthrow上面的代码 因为 try中 没有adddlert这个方法，或者这个方法有误，这时，代码会执行catch部分。JavaScript 实际上会创建带有两个属性的Error 对象name和message。
Java 入门指南：Java IO 模型
最新发布
Zachyy的博客
08-26 799
Java中的 IO（Input/Output）模型是管理计算机与外部设备（如磁盘、网络等）之间数据交换的重要机制。它定义了数据如何在应用程序和操作系统之间流动，以及如何处理这些流动过程中的阻塞、非阻塞、同步和异步等问题。Java中常见的IO模型包括 BIO（Blocking I/O，阻塞IO）、NIO（Non-Blocking I/O，非阻塞IO）、AIO（Asynchronous I/O，异步IO）等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值