java生成随机vector

以下是Java生成随机Vector的示例代码：

import java.util.Vector;
import java.util.Random;

public class RandomVectorGenerator {
    public static void main(String[] args) {
        Vector<Integer> vector = new Vector<>();
        Random random = new Random();

        // 生成随机Vector
        for (int i = 0; i < 10; i++) {
            vector.add(random.nextInt(100));
        }

        // 打印随机Vector
        System.out.println("随机Vector: " + vector);
    }
}

这段代码使用了Java的`Vector`类和`Random`类。首先创建一个`Vector`对象，然后使用`Random`类生成随机数，并将随机数添加到`Vector`中。最后打印出生成的随机`Vector`。

相关问题

java 克里金插值并生成空间热力图

克里金插值是一种空间内插方法，可以用于通过已知数据点的空间位置和对应数值，推断未知位置处的数值。在生成空间热力图时，可以使用克里金插值来估算每个网格点的数值，然后使用颜色渐变来表示不同数值的大小。

以下是用Java实现克里金插值并生成空间热力图的简单步骤：

1. 获取已知数据点的空间位置和对应数值，存储在一个列表中。
2. 定义网格的大小和分辨率，并将空间范围划分成网格。
3. 对于每个网格点，使用克里金插值算法来估算其数值。
4. 根据估算的数值，使用颜色渐变来表示不同数值的大小，生成空间热力图。

以下是一个简单的示例代码，其中使用了Apache Commons Math库来实现克里金插值算法和颜色渐变：

import org.apache.commons.math3.analysis.interpolation.KrigingInterpolator;
import org.apache.commons.math3.analysis.interpolation.LinearInterpolator;
import org.apache.commons.math3.analysis.interpolation.SplineInterpolator;
import org.apache.commons.math3.analysis.interpolation.TriangulatedInterpolatingFunction;
import org.apache.commons.math3.analysis.interpolation.Triangulator;
import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
import org.apache.commons.math3.util.FastMath;
import org.apache.commons.math3.util.MathArrays;

import javax.swing.*;
import java.awt.*;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.List;

public class HeatmapPanel extends JPanel {

    private static final int GRID_SIZE = 50;
    private static final int GRID_RESOLUTION = 10;
    private static final double RADIUS = 0.2;

    private List<Vector3D> dataPoints;
    private double[][] gridValues;
    private BufferedImage heatmapImage;

    public HeatmapPanel() {
        setPreferredSize(new Dimension(800, 600));
        setBackground(Color.WHITE);

        // Generate random data points
        dataPoints = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            double x = Math.random() * 10;
            double y = Math.random() * 10;
            double z = Math.random() * 100;
            dataPoints.add(new Vector3D(x, y, z));
        }

        // Compute grid values using Kriging interpolation
        KrigingInterpolator interpolator = new KrigingInterpolator();
        Triangulator triangulator = new Triangulator();
        TriangulatedInterpolatingFunction triangulatedInterpolation = new TriangulatedInterpolatingFunction(dataPoints, triangulator, interpolator);
        gridValues = new double[GRID_SIZE][GRID_SIZE];
        for (int i = 0; i < GRID_SIZE; i++) {
            for (int j = 0; j < GRID_SIZE; j++) {
                double x = i * 1.0 / GRID_RESOLUTION;
                double y = j * 1.0 / GRID_RESOLUTION;
                double z = triangulatedInterpolation.value(new Vector3D(x, y, 0));
                gridValues[i][j] = z;
            }
        }

        // Generate heatmap image
        heatmapImage = new BufferedImage(GRID_SIZE, GRID_SIZE, BufferedImage.TYPE_INT_RGB);
        double[] values = MathArrays.flatten(gridValues);
        double minValue = MathArrays.min(values);
        double maxValue = MathArrays.max(values);
        for (int i = 0; i < GRID_SIZE; i++) {
            for (int j = 0; j < GRID_SIZE; j++) {
                double value = gridValues[i][j];
                int colorValue = (int) FastMath.round(255 * (value - minValue) / (maxValue - minValue));
                Color color = new Color(colorValue, 0, 255 - colorValue);
                heatmapImage.setRGB(i, GRID_SIZE - j - 1, color.getRGB());
            }
        }
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);

        // Draw heatmap image
        Graphics2D g2d = (Graphics2D) g;
        AffineTransform transform = new AffineTransform();
        transform.scale(getWidth() * 1.0 / GRID_SIZE, getHeight() * 1.0 / GRID_SIZE);
        g2d.drawImage(heatmapImage, transform, null);

        // Draw data points
        for (Vector3D point : dataPoints) {
            int x = (int) FastMath.round(point.getX() * GRID_RESOLUTION);
            int y = (int) FastMath.round((1 - point.getY()) * GRID_RESOLUTION);
            int radius = (int) FastMath.round(RADIUS * GRID_RESOLUTION);
            g2d.setColor(Color.BLACK);
            g2d.drawOval(x - radius, y - radius, 2 * radius, 2 * radius);
        }
    }

    public static void main(String[] args) {
        JFrame frame = new JFrame("Heatmap");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.getContentPane().add(new HeatmapPanel());
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }
}

运行该代码将会生成一个随机数据点的空间热力图，其中使用了Kriging插值算法来估算每个网格点的数值。在绘制热力图时，使用了颜色渐变来表示不同数值的大小，并且在数据点周围绘制了黑色圆圈以便于观察。你可以根据自己的需求，修改代码来适应不同的数据点或插值算法。

aes 256 OFB java实现

下面是AES 256 OFB模式的Java实现示例：

import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

public class AESOFBExample {

    public static void main(String[] args) throws Exception {
        String plainText = "This is a secret message";
        System.out.println("Plain Text: " + plainText);

        // Generate a 256-bit AES key
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        keyGen.init(256);
        SecretKey secretKey = keyGen.generateKey();
        byte[] keyBytes = secretKey.getEncoded();

        // Generate a random initialization vector
        SecureRandom random = new SecureRandom();
        byte[] ivBytes = new byte[16];
        random.nextBytes(ivBytes);

        // Create the Cipher object and configure it for OFB mode with AES encryption
        Cipher cipher = Cipher.getInstance("AES/OFB/PKCS5Padding");
        SecretKeySpec keySpec = new SecretKeySpec(keyBytes, "AES");
        IvParameterSpec ivSpec = new IvParameterSpec(ivBytes);
        cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivSpec);

        // Encrypt the plain text
        byte[] encryptedBytes = cipher.doFinal(plainText.getBytes());
        System.out.println("Encrypted Text: " + new String(encryptedBytes));

        // Decrypt the encrypted text
        cipher.init(Cipher.DECRYPT_MODE, keySpec, ivSpec);
        byte[] decryptedBytes = cipher.doFinal(encryptedBytes);
        System.out.println("Decrypted Text: " + new String(decryptedBytes));
    }

}

上述代码中，我们首先使用Java的`KeyGenerator`类生成一个256位的AES密钥。然后，我们使用`SecureRandom`类生成一个随机的16字节的初始化向量。

接下来，我们创建一个`Cipher`对象，并将其配置为使用AES加密的OFB模式。然后，我们使用生成的密钥和初始化向量初始化`Cipher`对象，并使用`doFinal`方法对明文进行加密。

最后，我们再次使用相同的密钥和初始化向量初始化`Cipher`对象，并使用`doFinal`方法对密文进行解密。