用java获取当前时间 并可以存入数组

你好！可以使用Java中的Date类和SimpleDateFormat类获取当前时间，并将其格式化为字符串存入数组中。示例代码如下：

import java.util.Date;
import java.text.SimpleDateFormat;

public class GetCurrentTime {
    public static void main(String[] args) {
        Date currentTime = new Date();
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateString = formatter.format(currentTime);
        String[] timeArray = new String[] {dateString};
        System.out.println("当前时间为：" + dateString);
        System.out.println("存入数组中的时间为：" + timeArray[0]);
    }
}

运行结果如下：

当前时间为：2021-07-09 11:11:22
存入数组中的时间为：2021-07-09 11:11:22

相关问题

先初始化数组，然后用Scanner从文件中逐行读取数据并存入数组，数据是以逗号分隔的整数。根据所给的数据，对前100数据分别使用冒泡排序和Java的Qsort进行排序，并计时。

首先，让我们逐步完成这个任务：

1. **初始化数组**:
创建一个足够大的数组，用于存储从文件读取的整数。例如，如果你不确定文件中的数据大小，你可以创建一个固定大小的数组，如`int[] numbers = new int[100];`。

2. **读取文件**:
使用`java.util.Scanner`从文件中逐行读取数据。假设文件名为`data.txt`，你可以这样做：

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public void readDataFromFile(String fileName) {
    Scanner scanner = null;
    try {
        File file = new File(fileName);
        scanner = new Scanner(file);
        while (scanner.hasNextInt()) {
            numbers[scannedIndex++] = scanner.nextInt();
        }
    } catch (FileNotFoundException e) {
        System.out.println("File not found: " + fileName);
    } finally {
        if (scanner != null) {
            scanner.close();
        }
    }
}

这里的`scannedIndex`是你需要维护的一个变量，用来跟踪当前已经读取到数组的哪个位置。

3. **数据预处理（如果数据超过100）**:
如果文件中的数据超过100个，你需要决定如何截断或选择前100个。例如，你可以检查`scannedIndex`是否小于100再添加元素。

4. **冒泡排序**:
冒泡排序算法可以这样实现：

long startTime = System.nanoTime();
for (int i = 0; i < numbers.length - 1; i++) {
    for (int j = 0; j < numbers.length - 1 - i; j++) {
        if (numbers[j] > numbers[j + 1]) {
            // Swap elements
            int temp = numbers[j];
            numbers[j] = numbers[j + 1];
            numbers[j + 1] = temp;
        }
    }
}
long endTime = System.nanoTime();
System.out.println("Bubble sort time: " + (endTime - startTime) + " ns");

5. **Java内置快速排序**:
Java并没有直接提供快速排序的库，但我们可以使用第三方库如Google Guava的`SortedIntList`，或者自己实现。这里以自实现为例：

public class QuickSort {
    // 快速排序核心部分
    public static void quickSort(int[] array, int low, int high) {
        // ...
    }

    // 全局排序
    public static void mainSort(int[] array) {
        long startTime = System.nanoTime();
        quickSort(array, 0, numbers.length - 1);
        long endTime = System.nanoTime();
        System.out.println("Quicksort time: " + (endTime - startTime) + " ns");
    }
}

记得在`quickSort`方法里实现快速排序算法，这里省略了具体实现细节。

6. **计时**:
我们使用`System.nanoTime()`来获取开始和结束的时间戳，然后计算差值，单位通常是纳秒（ns）。

现在，你可以将这些步骤组合在一起，确保在每次运行时只处理前100个元素。别忘了在操作之前关闭`Scanner`，以释放资源。

实现从键盘上分布输入3个学生的5门课程成绩，存入数组，每输入一次，检查当前输入是否为有效输入，求学生的平均成绩并输出成绩最好的学生成绩。用java写出一个程序

在Java中，你可以创建一个学生类（Student），包含5门课程的成绩数组，并提供一个方法用于计算平均成绩。然后通过Scanner从键盘获取用户输入，验证输入的有效性。以下是简单的程序实现：

import java.util.Scanner;

class Student {
    private double[] scores = new double[5];
    // ... 其他学生属性

    public void setScore(int index, double score) {
        if (index >= 0 && index < 5) {
            scores[index] = score;
        } else {
            System.out.println("无效的索引");
        }
    }

    public double getAverageScore() {
        double sum = 0;
        for (double score : scores) {
            if (!Double.isNaN(score)) {
                sum += score;
            }
        }
        return sum / scores.length;
    }

    @Override
    public String toString() {
        // 返回学生姓名和成绩信息
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < scores.length; i++) {
            sb.append("课程 ").append(i + 1).append(": ").append(scores[i]).append("\n");
        }
        return "学生信息: 平均成绩: " + getAverageScore() + ", 最高分: " + findMaxScore();
    }

    private double findMaxScore() {
        double max = Double.MIN_VALUE;
        for (double score : scores) {
            if (score > max) {
                max = score;
            }
        }
        return max;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int studentIndex = 1; // 学生编号
        while (true) {
            System.out.println("请输入学生" + studentIndex + "的五门课程成绩（按顺序输入，输入q退出）:");
            for (int i = 0; i < 5; i++) {
                double score = scanner.nextDouble();
                if (score.equals(Double.parseDouble("q"))) break;
                ((Student) students[studentIndex - 1]).setScore(i, score);
            }
            System.out.println("学生" + studentIndex + "的平均成绩为: " + students[studentIndex - 1].getAverageScore());
            System.out.println("学生" + studentIndex + "的成绩最高的课程为: " + students[studentIndex - 1]);
            studentIndex++;
            if (studentIndex > 3) { // 假设最多有3个学生
                break;
            }
        }
        scanner.close();
    }

    private static Student[] students = new Student[3]; // 初始化三个学生对象
}

在这个程序中，我们首先创建了一个`Student`类，包含了设置成绩、计算平均成绩和找到最高分的方法。在`main`函数中，使用循环获取每个学生的成绩，存储到`students`数组中，并实时计算和输出结果。