利用java编写的项目设备调配系统代码示例（内含5种设备调配的算法）

news2024/11/28 16:35:00

利用java编写的项目设备调配系统代码示例（内含5种设备调配的算法）

      • 一、设备调配方案
      • 二、设备匹配算法
      • 三、代码实现（java）

最近在做一个项目设备调配系统，分享一些干货！！！
在这里插入图片描述

一、设备调配方案

  1. 用户需求分析：仔细分析用户的设备需求，包括设备类型、数量、使用时间、地点等方面的要求。了解用户的具体需求是确定最佳设备调配方案的基础。

  2. 设备可用性评估：评估平台上可共享设备的可用性和状态。考虑设备的技术规格、运行状况、维护保养情况以及当前的可用时间段等因素。

  3. 设备匹配算法：开发或选择适当的设备匹配算法，以根据用户需求和设备可用性来匹配最佳的设备调配方案。算法可以基于距离、时间、设备规格等因素进行匹配和优化。

  4. 优化目标：明确设备调配的优化目标，例如最小化设备的闲置时间、最大化设备的利用率、最小化用户的等待时间等。根据优化目标来调整设备调配方案。

  5. 算法模拟与评估：利用模拟工具和数据，对设备调配算法进行模拟和评估。通过模拟运行设备调配算法，评估其性能和效果，如响应时间、匹配准确度等。

  6. 用户反馈与改进：收集用户的反馈意见和建议，根据用户的反馈来优化设备调配方案。关注用户的满意度和体验，不断改进调配算法和策略。

  7. 数据分析与迭代优化：收集和分析设备调配的数据，包括设备利用率、闲置时间、用户满意度等指标。根据数据分析的结果，进行迭代优化，调整算法和策略，以提高设备调配方案的效果和效率。

通过以上的流程和方法，结合用户需求、设备可用性和算法优化，可以得到最佳的设备调配方案，以满足用户需求，最大化设备利用率，提高平台的效益和用户满意度。

二、设备匹配算法

  1. 最短路径算法：适用于需要考虑设备到用户需求地点的距离的情况。根据设备所在位置和用户需求地点之间的距离，选择距离最短的设备进行匹配。

  2. 最佳时间窗口算法：针对设备有特定的可用时间段的情况。根据用户需求的时间窗口和设备的可用时间窗口，选择最佳的时间段进行匹配。

  3. 设备规格匹配算法：适用于用户对设备规格有特定要求的情况。根据设备的技术规格和用户需求的规格要求，进行匹配和筛选。

  4. 基于历史数据的协同过滤算法：利用用户历史设备选择和评价数据，推荐类似用户喜好的设备。根据用户的偏好和行为，预测和推荐适合用户的设备。

  5. 智能推荐算法：基于机器学习和数据挖掘技术，通过分析用户的需求和设备的特征，提供个性化的设备推荐。根据用户的历史行为和偏好，预测用户可能喜欢的设备，并进行推荐。

这些算法仅为示例，实际的设备匹配算法可以根据平台的需求和特定场景进行定制和优化。在设计设备匹配算法时，可以考虑多种因素，如设备属性、用户需求、地理位置、可用时间等，以确保匹配结果尽可能符合用户的要求。

三、代码实现（java）

  1. 距离最短算法的示例代码

假设有一组设备和用户需求，并使用欧几里德距离计算最短距离。

import java.util.ArrayList;
import java.util.List;

class Device {
    private String id;
    private double latitude;
    private double longitude;

    public Device(String id, double latitude, double longitude) {
        this.id = id;
        this.latitude = latitude;
        this.longitude = longitude;
    }

    public String getId() {
        return id;
    }

    public double getLatitude() {
        return latitude;
    }

    public double getLongitude() {
        return longitude;
    }
}

class UserDemand {
    private double latitude;
    private double longitude;

    public UserDemand(double latitude, double longitude) {
        this.latitude = latitude;
        this.longitude = longitude;
    }

    public double getLatitude() {
        return latitude;
    }

    public double getLongitude() {
        return longitude;
    }
}

public class ShortestDistanceAlgorithm {
    public static Device findShortestDistance(Device[] devices, UserDemand demand) {
        Device nearestDevice = null;
        double minDistance = Double.MAX_VALUE;

        for (Device device : devices) {
            double distance = calculateDistance(device, demand);
            if (distance < minDistance) {
                minDistance = distance;
                nearestDevice = device;
            }
        }

        return nearestDevice;
    }

    private static double calculateDistance(Device device, UserDemand demand) {
        double latitudeDiff = device.getLatitude() - demand.getLatitude();
        double longitudeDiff = device.getLongitude() - demand.getLongitude();
        return Math.sqrt(latitudeDiff * latitudeDiff + longitudeDiff * longitudeDiff);
    }

    public static void main(String[] args) {
        // 设备和用户需求的示例数据
        Device[] devices = {
                new Device("Device1", 10.0, 20.0),
                new Device("Device2", 15.0, 25.0),
                new Device("Device3", 5.0, 15.0)
        };
        UserDemand demand = new UserDemand(12.0, 22.0);

        // 查找最短距离的设备
        Device nearestDevice = findShortestDistance(devices, demand);

        // 输出结果
        if (nearestDevice != null) {
            System.out.println("Nearest Device: " + nearestDevice.getId());
        } else {
            System.out.println("No nearest device found.");
        }
    }
}

以上代码演示了使用欧几里德距离计算最短距离的示例，通过输入设备和用户需求的经纬度信息，找到距离最短的设备，并输出其设备ID。请注意，这只是一个简单的示例代码，实际应用中可能需要考虑更多的因素和数据处理逻辑。

  1. 实现最佳时间窗口算法的示例代码
    假设有一组设备和用户需求，并需要选择最佳的可用时间窗口进行匹配。
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.List;

class Device {
    private String id;
    private LocalTime startTime;
    private LocalTime endTime;

    public Device(String id, LocalTime startTime, LocalTime endTime) {
        this.id = id;
        this.startTime = startTime;
        this.endTime = endTime;
    }

    public String getId() {
        return id;
    }

    public LocalTime getStartTime() {
        return startTime;
    }

    public LocalTime getEndTime() {
        return endTime;
    }
}

class UserDemand {
    private LocalTime startTime;
    private LocalTime endTime;

    public UserDemand(LocalTime startTime, LocalTime endTime) {
        this.startTime = startTime;
        this.endTime = endTime;
    }

    public LocalTime getStartTime() {
        return startTime;
    }

    public LocalTime getEndTime() {
        return endTime;
    }
}

public class BestTimeWindowAlgorithm {
    public static Device findBestTimeWindow(Device[] devices, UserDemand demand) {
        Device bestDevice = null;
        long minTimeDiff = Long.MAX_VALUE;

        for (Device device : devices) {
            long timeDiff = calculateTimeDifference(device, demand);
            if (timeDiff < minTimeDiff) {
                minTimeDiff = timeDiff;
                bestDevice = device;
            }
        }

        return bestDevice;
    }

    private static long calculateTimeDifference(Device device, UserDemand demand) {
        long startTimeDiff = Math.abs(device.getStartTime().toSecondOfDay() - demand.getStartTime().toSecondOfDay());
        long endTimeDiff = Math.abs(device.getEndTime().toSecondOfDay() - demand.getEndTime().toSecondOfDay());
        return startTimeDiff + endTimeDiff;
    }

    public static void main(String[] args) {
        // 设备和用户需求的示例数据
        Device[] devices = {
                new Device("Device1", LocalTime.of(8, 0), LocalTime.of(17, 0)),
                new Device("Device2", LocalTime.of(9, 0), LocalTime.of(18, 0)),
                new Device("Device3", LocalTime.of(7, 0), LocalTime.of(16, 0))
        };
        UserDemand demand = new UserDemand(LocalTime.of(8, 30), LocalTime.of(17, 30));

        // 查找最佳时间窗口的设备
        Device bestDevice = findBestTimeWindow(devices, demand);

        // 输出结果
        if (bestDevice != null) {
            System.out.println("Best Device: " + bestDevice.getId());
        } else {
            System.out.println("No best device found.");
        }
    }
}

以上代码演示了使用最佳时间窗口算法进行设备匹配的示例。通过输入设备的起始和结束时间以及用户需求的起始和结束时间，找到最佳匹配的设备，并输出其设备ID。请注意，这只是一个简单的示例代码，实际应用中可能需要考虑更多的时间窗口规则和数据处理逻辑。

  1. 实现设备规格匹配算法的示例代码
    假设设备和用户需求都有一组规格属性，通过匹配规格属性进行设备选择。
import java.util.ArrayList;
import java.util.List;

class Device {
    private String id;
    private String brand;
    private String model;
    private int capacity;

    public Device(String id, String brand, String model, int capacity) {
        this.id = id;
        this.brand = brand;
        this.model = model;
        this.capacity = capacity;
    }

    public String getId() {
        return id;
    }

    public String getBrand() {
        return brand;
    }

    public String getModel() {
        return model;
    }

    public int getCapacity() {
        return capacity;
    }
}

class UserDemand {
    private String brand;
    private String model;
    private int requiredCapacity;

    public UserDemand(String brand, String model, int requiredCapacity) {
        this.brand = brand;
        this.model = model;
        this.requiredCapacity = requiredCapacity;
    }

    public String getBrand() {
        return brand;
    }

    public String getModel() {
        return model;
    }

    public int getRequiredCapacity() {
        return requiredCapacity;
    }
}

public class DeviceSpecMatchingAlgorithm {
    public static Device findMatchingDevice(Device[] devices, UserDemand demand) {
        for (Device device : devices) {
            if (device.getBrand().equals(demand.getBrand()) &&
                    device.getModel().equals(demand.getModel()) &&
                    device.getCapacity() >= demand.getRequiredCapacity()) {
                return device;
            }
        }
        return null;
    }

    public static void main(String[] args) {
        // 设备和用户需求的示例数据
        Device[] devices = {
                new Device("Device1", "Brand1", "Model1", 100),
                new Device("Device2", "Brand2", "Model2", 200),
                new Device("Device3", "Brand1", "Model1", 150)
        };
        UserDemand demand = new UserDemand("Brand1", "Model1", 120);

        // 查找匹配设备
        Device matchingDevice = findMatchingDevice(devices, demand);

        // 输出结果
        if (matchingDevice != null) {
            System.out.println("Matching Device: " + matchingDevice.getId());
        } else {
            System.out.println("No matching device found.");
        }
    }
}

以上代码演示了使用设备规格匹配算法进行设备选择的示例。通过输入设备的品牌、型号和容量要求，找到与用户需求匹配的设备，并输出其设备ID。请注意，这只是一个简单的示例代码，实际应用中可能需要考虑更多的规格属性和数据处理逻辑。

  1. 基于用户历史数据的协同过滤算法的示例代码
    协同过滤算法是一种常用的推荐系统算法，它基于用户历史行为数据和用户之间的相似性来进行推荐。以下是一个基于用户历史数据的协同过滤算法的示例代码，使用Java语言实现：
import java.util.*;

class User {
    private String id;
    private List<String> ratedItems;

    public User(String id, List<String> ratedItems) {
        this.id = id;
        this.ratedItems = ratedItems;
    }

    public String getId() {
        return id;
    }

    public List<String> getRatedItems() {
        return ratedItems;
    }
}

public class CollaborativeFiltering {
    private List<User> users;

    public CollaborativeFiltering(List<User> users) {
        this.users = users;
    }

    public List<String> recommendItems(String userId, int numRecommendations) {
        // 找出指定用户未评级的物品
        Set<String> unratedItems = getUnratedItems(userId);

        // 计算其他用户与指定用户的相似度
        Map<String, Double> userSimilarities = calculateUserSimilarities(userId);

        // 根据相似度对其他用户进行排序
        List<String> sortedUsers = sortUsersBySimilarity(userSimilarities);

        // 进行推荐
        List<String> recommendations = new ArrayList<>();
        for (String user : sortedUsers) {
            List<String> ratedItems = getUserRatedItems(user);
            for (String item : ratedItems) {
                if (unratedItems.contains(item) && !recommendations.contains(item)) {
                    recommendations.add(item);
                    if (recommendations.size() >= numRecommendations) {
                        return recommendations;
                    }
                }
            }
        }

        return recommendations;
    }

    private Set<String> getUnratedItems(String userId) {
        Set<String> unratedItems = new HashSet<>();
        for (User user : users) {
            if (user.getId().equals(userId)) {
                continue;
            }
            List<String> ratedItems = user.getRatedItems();
            unratedItems.addAll(ratedItems);
        }
        List<String> ratedItems = getUserRatedItems(userId);
        unratedItems.removeAll(ratedItems);
        return unratedItems;
    }

    private Map<String, Double> calculateUserSimilarities(String userId) {
        Map<String, Double> userSimilarities = new HashMap<>();
        List<String> ratedItems = getUserRatedItems(userId);

        for (User user : users) {
            if (user.getId().equals(userId)) {
                continue;
            }
            List<String> userRatedItems = user.getRatedItems();
            double similarity = calculateSimilarity(ratedItems, userRatedItems);
            userSimilarities.put(user.getId(), similarity);
        }

        return userSimilarities;
    }

    private double calculateSimilarity(List<String> list1, List<String> list2) {
        Set<String> set1 = new HashSet<>(list1);
        Set<String> set2 = new HashSet<>(list2);

        int intersection = 0;
        for (String item : set1) {
            if (set2.contains(item)) {
                intersection++;
            }
        }

        int union = set1.size() + set2.size() - intersection;
        return (double) intersection / union;
    }

    private List<String> sortUsersBySimilarity(Map<String, Double> userSimilarities) {
        List<Map.Entry<String, Double>> userList = new ArrayList<>(userSimilarities.entrySet());
        userList.sort(Map.Entry

上述代码中的输入和输出可以通过以下方式进行设置和获取：

输入：

创建User对象列表，其中每个User对象代表一个用户，包括用户的ID和已评级物品列表。
将上述用户列表作为参数创建CollaborativeFiltering对象。

输出：

调用recommendItems(userId,
numRecommendations)方法，传入要进行推荐的用户ID和需要推荐的物品数量。该方法将返回一个字符串列表，包含推荐的物品。
下面是一个示例的输入和输出过程：

public static void main(String[] args) {
    // 创建用户列表
    List<User> users = new ArrayList<>();
    users.add(new User("User1", Arrays.asList("Item1", "Item2", "Item3")));
    users.add(new User("User2", Arrays.asList("Item2", "Item3", "Item4")));
    users.add(new User("User3", Arrays.asList("Item1", "Item3", "Item5")));

    // 创建 CollaborativeFiltering 对象
    CollaborativeFiltering cf = new CollaborativeFiltering(users);

    // 进行推荐并输出结果
    String userId = "User1";
    int numRecommendations = 2;
    List<String> recommendations = cf.recommendItems(userId, numRecommendations);
    System.out.println("Recommendations for user " + userId + ":");
    for (String item : recommendations) {
        System.out.println(item);
    }
}

在上述示例中，我们创建了一个包含3个用户的用户列表，并创建了一个CollaborativeFiltering对象。然后，我们指定要进行推荐的用户ID为"User1"，需要推荐的物品数量为2。最后，打印出根据协同过滤算法得到的推荐结果。

  1. 智能推荐算法
    智能推荐算法是一类广泛应用于推荐系统中的算法，旨在根据用户的个人偏好、行为历史和其他相关数据，提供个性化、精准的推荐结果。下面是一个基于用户行为的智能推荐算法示例，使用Java语言实现。
import java.util.*;

class User {
    private String id;
    private Map<String, Integer> itemRatings;

    public User(String id, Map<String, Integer> itemRatings) {
        this.id = id;
        this.itemRatings = itemRatings;
    }

    public String getId() {
        return id;
    }

    public Map<String, Integer> getItemRatings() {
        return itemRatings;
    }
}

public class IntelligentRecommendation {
    private List<User> users;

    public IntelligentRecommendation(List<User> users) {
        this.users = users;
    }

    public List<String> recommendItems(String userId, int numRecommendations) {
        // 获取用户评分数据
        Map<String, Integer> userRatings = getUserRatings(userId);

        // 统计物品评分和出现次数
        Map<String, Double> itemScores = new HashMap<>();
        Map<String, Integer> itemOccurrences = new HashMap<>();

        for (User user : users) {
            if (user.getId().equals(userId)) {
                continue;
            }

            Map<String, Integer> ratings = user.getItemRatings();
            for (Map.Entry<String, Integer> entry : ratings.entrySet()) {
                String item = entry.getKey();
                int rating = entry.getValue();

                itemScores.put(item, itemScores.getOrDefault(item, 0.0) + rating);
                itemOccurrences.put(item, itemOccurrences.getOrDefault(item, 0) + 1);
            }
        }

        // 计算物品平均评分
        Map<String, Double> itemAverages = new HashMap<>();
        for (Map.Entry<String, Double> entry : itemScores.entrySet()) {
            String item = entry.getKey();
            double score = entry.getValue();
            int occurrences = itemOccurrences.get(item);
            double average = score / occurrences;
            itemAverages.put(item, average);
        }

        // 过滤已评级物品和用户已经交互过的物品
        Set<String> ratedItems = userRatings.keySet();
        itemAverages.keySet().removeAll(ratedItems);

        // 根据物品平均评分排序物品
        List<Map.Entry<String, Double>> itemList = new ArrayList<>(itemAverages.entrySet());
        itemList.sort(Map.Entry.comparingByValue(Comparator.reverseOrder()));

        // 获取推荐物品
        List<String> recommendations = new ArrayList<>();
        for (int i = 0; i < numRecommendations && i < itemList.size(); i++) {
            recommendations.add(itemList.get(i).getKey());
        }

        return recommendations;
    }

    private Map<String, Integer> getUserRatings(String userId) {
        for (User user : users) {
            if (user.getId().equals(userId)) {
                return user.getItemRatings();
            }
        }
        return Collections.emptyMap();
    }

    public static void main(String[] args) {
        // 创建用户列表
        List<User> users = new ArrayList<>();
        Map<String, Integer> user1Ratings = new HashMap<>();
        user1Ratings.put("Item1", 4);
        user1Ratings.put("Item2", 3);
        user1Ratings.put

以下是智能推荐算法的输入和输出示例：

输入：

创建User对象列表，其中每个User对象代表一个用户，包括用户的ID和物品评分数据。
将上述用户列表作为参数创建IntelligentRecommendation对象。

输出：

调用recommendItems(userId,
numRecommendations)方法，传入要进行推荐的用户ID和需要推荐的物品数量。该方法将返回一个字符串列表，包含推荐的物品。
下面是一个示例的输入和输出过程：

public static void main(String[] args) {
    // 创建用户列表
    List<User> users = new ArrayList<>();
    Map<String, Integer> user1Ratings = new HashMap<>();
    user1Ratings.put("Item1", 4);
    user1Ratings.put("Item2", 3);
    user1Ratings.put("Item3", 5);
    users.add(new User("User1", user1Ratings));

    Map<String, Integer> user2Ratings = new HashMap<>();
    user2Ratings.put("Item2", 5);
    user2Ratings.put("Item3", 4);
    user2Ratings.put("Item4", 3);
    users.add(new User("User2", user2Ratings));

    // 创建 IntelligentRecommendation 对象
    IntelligentRecommendation ir = new IntelligentRecommendation(users);

    // 进行推荐并输出结果
    String userId = "User1";
    int numRecommendations = 2;
    List<String> recommendations = ir.recommendItems(userId, numRecommendations);
    System.out.println("Recommendations for user " + userId + ":");
    for (String item : recommendations) {
        System.out.println(item);
    }
}

在上述示例中，我们创建了一个包含两个用户的用户列表，并创建了一个IntelligentRecommendation对象。然后，我们指定要进行推荐的用户ID为"User1"，需要推荐的物品数量为2。最后，打印出根据智能推荐算法得到的推荐结果。

注意：示例中的物品评分数据为示意，实际应用中需要根据实际情况提供准确的用户评分数据。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/550732.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Godot引擎 4.0 文档 - 入门介绍 - Godot 关键概念概述¶

Godot引擎 4.0 文档 - 入门介绍 - Godot 关键概念概述¶

本文为Google Translate英译中结果&#xff0c;DrGraph在此基础上加了一些校正。英文原版页面&#xff1a;Overview of Godots key concepts — Godot Engine (stable) documentation in English Godot 关键概念概述 每个游戏引擎都围绕您用来构建应用程序的抽象展开。在 Godo…
阅读更多...
【mysql】库的操作+表的操作

【mysql】库的操作+表的操作

文章目录 启动mysql登录mysql1.MySQL环境安装与基础认识修改端口号连接服务器服务器&#xff0c;数据库&#xff0c;表关系建表 第二讲_库与表的操作1.创建数据库2.创建数据库案例3.指明字符集和校验集校验规则对数据库的影响不区分大小写的查询以及结果&#xff1a;区分大小写…
阅读更多...
SQL Backup Master 6.3.6 Crack

SQL Backup Master 6.3.6 Crack

SQL Backup Master 能够为用户将 SQL Server 数据库备份到一些简单的云存储服务中&#xff0c;例如 Dropbox、OneDrive、Amazon S3、Microsoft Azure、box&#xff0c;最后是 Google Drive。它能够将数据库备份到用户和开发者的FTP服务器上&#xff0c;甚至本地机器甚至网络服务…
阅读更多...
速通二次型、二次型标准型、二次型规范型

速通二次型、二次型标准型、二次型规范型

浅过二次型 理解二次型可以从二次型的多项式入手&#xff1a; 显然&#xff0c;在系数都为实数的情况下&#xff0c;二次型矩阵即为一个实对称矩阵。 取一个代入值的例子就是&#xff1a; 二次型的标准型 OK&#xff0c;再从二次型的标准型的多项式入手&#xff0c;如下&…
阅读更多...
FPGA System Planner(FSP)使用手册

FPGA System Planner(FSP)使用手册

FSP工具是cadence公司为了FPGA/PCB协同设计而推出的一个解决方案工具包。它的主要工作是由软件来自动生成、优化FPGA芯片的管脚分配，提高FPGA/PCB设计的工作效率和连通性。FSP完成两顷重要工作：一、可以自动生成FPGA芯片的原理图符号（symbol）；二、自动生成、优化和更改FPG…
阅读更多...
C++模板（上）

C++模板（上）

文章目录 模板函数模板函数模板的实例化 类模板总结 模板 模板是C种为了方便用户对于一些场景的使用&#xff0c;引入的新概念&#xff0c;使得我们的代码不会冗余 template关键字 template关键字的意思就是模板&#xff0c;语法为&#xff1a;template<typename T1,type…
阅读更多...
内网渗透之Linux权限维持-OpenSSHPAM后门SSH软链接公私钥登录

内网渗透之Linux权限维持-OpenSSHPAM后门SSH软链接公私钥登录

0x01替换版本-OpenSSH后门 原理&#xff1a;替换本身操作系统的ssh协议支撑软件openssh&#xff0c;重新安装自定义的openssh,达到记录帐号密码&#xff0c;也可以采用万能密码连接的功能&#xff01; 可以修改软件版本和删除安装记录 1.环境准备&#xff1a; yum -y install…
阅读更多...
【Java EE 初阶】网络初识

【Java EE 初阶】网络初识

目录 1.网络互连 1.局域网&#xff1a; 2.广域网WAN 2.网络通信基础 3.IP地址&#xff1a;端口号 4.协议 1.五元组 2.协议分层 1.为什么要用网络分层&#xff1f; 3.OSI七层模型 4.TCP/IP五层&#xff08;或四层&#xff09;模型 5.封装和分用 1.应用层 2.传输层A…
阅读更多...
Oracle数据库中了locked1勒索病毒攻击后怎么办，什么是locked1勒索病毒

Oracle数据库中了locked1勒索病毒攻击后怎么办，什么是locked1勒索病毒

Oracle数据库是一种被集团企业广泛使用的关系型数据库管理系统&#xff0c;但是随着科学技术的不断发展&#xff0c;在现代互联网环境中数据库安全性成为了一个非常重要的问题。而其中主要的威胁就是勒索病毒攻击。一旦数据库被勒索病毒攻击入侵&#xff0c;许多重要的数据就会…
阅读更多...
【JVM】3. 运行时数据区及程序计数器

【JVM】3. 运行时数据区及程序计数器

文章目录 3.1. &#x1f379;运行时数据区3.1.1. &#x1f942;概述3.1.2. &#x1f942;线程3.1.3. &#x1f942;JVM系统线程 3.2. &#x1f379;程序计数器(PC寄存器) 3.1. &#x1f379;运行时数据区 3.1.1. &#x1f942;概述 本节主要讲的是运行时数据区&#xff0c;也就…
阅读更多...
跟我一起使用 compose 做一个跨平台的黑白棋游戏（2）界面布局

跟我一起使用 compose 做一个跨平台的黑白棋游戏（2）界面布局

前言 在上一篇文章中&#xff0c;我们讲解了实现这个游戏的总体思路&#xff0c;这篇文章我们将讲解如何实现游戏界面。 本文将涉及到 compose 的自定义绘制与触摸处理&#xff0c;这些内容都可以在我往期的文章中找到对应的教程&#xff0c;如果对这部分内容不太熟悉的话&am…
阅读更多...
论文阅读_语音合成_VALL-E

论文阅读_语音合成_VALL-E

论文阅读 number headings: auto, first-level 2, max 4, _.1.1 name_en: Neural Codec Language Models are Zero-Shot Text to Speech Synthesizers name_ch: 神经网络编解码器语言模型实现零样本TTS paper_addr: http://arxiv.org/abs/2301.02111 date_read: 2023-04-25 da…
阅读更多...
Docker代码环境打包进阶 - DockerHub分享镜像

Docker代码环境打包进阶 - DockerHub分享镜像

1. Docker Hub介绍 Docker Hub是一个广泛使用的容器镜像注册中心&#xff0c;为开发人员提供了方便的平台来存储、共享和分发Docker容器镜像。它支持版本控制、访问控制和自动化构建&#xff0c;并提供了丰富的公共镜像库&#xff0c;方便开发人员快速获取和使用各种开源应用和…
阅读更多...
Redis+Lua脚本防止超卖

Redis+Lua脚本防止超卖

超卖就是因为查询库存和扣减库存两个操作不是原子性操作&#xff0c;通过rua脚本执行这两个操作可以保证这两个操作原子性 判断库存量是不是大于等于1&#xff0c;如果大于等于1对库存减1&#xff0c;否则就不去减库存 StringBuilder sb new StringBuilder();sb.append("…
阅读更多...
【数据分享】我国地级市绿地利用现状数据（9个指标\Shp格式）

【数据分享】我国地级市绿地利用现状数据（9个指标\Shp格式）

绿地是城市生态的重要组成部分&#xff0c;在很多分析中都会用到绿地数据&#xff01;之前我们分享过Shp和Excel格式的全国地级市2003-2020年绿地面积数据&#xff08;可查看之前文章获悉详情&#xff09;&#xff0c;以及中国31个主要城市的绿地空间分布的栅格数据&#xff08…
阅读更多...
vue中使用colorthief获取图片的主色调成分

vue中使用colorthief获取图片的主色调成分

colorthief官网 https://lokeshdhakar.com/projects/color-thief/#examples 安装 npm i --save colorthief yarn add colorthief 使用案例 <template><div class"box app" :style"{ background: bodyBgColor }"><div class"img-item&…
阅读更多...
NSS LitCTF Web 部分wp

NSS LitCTF Web 部分wp

目录 1、PHP是世界上最好的语言&#xff01;&#xff01; 2、这是什么&#xff1f;SQL &#xff01;注一下 &#xff01; 3、Ping 4、作业管理系统 5、我Flag呢&#xff1f; 6、1zjs 7、Vim yyds 8、Http pro max plus 1、PHP是世界上最好的语言&#xff01;&#xff01…
阅读更多...
C++中vector的用法

C++中vector的用法

博主简介&#xff1a;Hello大家好呀&#xff0c;我是陈童学&#xff0c;一个与你一样正在慢慢前行的人。 博主主页&#xff1a;陈童学哦 所属专栏&#xff1a;CSTL 前言&#xff1a;Hello各位小伙伴们好&#xff01;欢迎来到本专栏CSTL的学习&#xff0c;本专栏旨在帮助大家了解…
阅读更多...
Compose太香了，不想再写传统 xml View？教你如何在已有View项目中混合使用Compose

Compose太香了，不想再写传统 xml View？教你如何在已有View项目中混合使用Compose

前言 在我的文章 记一次 kotlin 在 MutableList 中使用 remove 引发的问题 中&#xff0c;我提到有一个功能是将多张动图以N宫格的形式拼接&#xff0c;并且每个动图的宽保证一致&#xff0c;但是高不保证一致。 在原本项目中我使用的是传统 view 配合 RecyclerView 和 GridL…
阅读更多...
jenkins入门与安装

jenkins入门与安装

一、实验环境 selinux iptables off 主机名IP系统版本gitlab10.10.10.200rhel7.5jenkins10.10.10.10rhel7.5tomcat10.10.10.11rhel7.5 二、安装jenkins 1、解压安装包 下载地址&#xff1a;https://download.docker.com/linux/static/stable/x86_64/ [rootjenkins ~]# tar xf …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023