题目一：

有字符串yujwedjhccdskdsewirewrwsadm,fnsdklwweqpq取出所有所有所有两个w之间的字符串并用归并排序进行排序 （字符串处理）。java语言实现。

import java.util.*;

public class MergeSortBetweenWW {
    public static void main(String[] args) {
        String str = "yujwedjhccdskdsewirewrwsadm,fnsdklwweqpq";
        String[] words = extractWords(str);

        System.out.println("Before sorting: " + Arrays.toString(words));
        mergeSort(words, 0, words.length-1);
        System.out.println("After sorting: " + Arrays.toString(words));
    }

    // Extracts all substrings between two 'w's and returns them in an array
    public static String[] extractWords(String str) {
        List<String> wordsList = new ArrayList<>();
        int startIndex = str.indexOf('w');

        while (startIndex != -1) {
            int endIndex = str.indexOf('w', startIndex+1);
            if (endIndex == -1) {
                break;
            }
            String word = str.substring(startIndex+1, endIndex);
            wordsList.add(word);
            startIndex = endIndex;
        }
        String[] wordsArr = new String[wordsList.size()];
        wordsArr = wordsList.toArray(wordsArr);
        return wordsArr;
    }

    // Sorts a given array using merge sort algorithm
    public static void mergeSort(String[] arr, int leftIndex, int rightIndex) {
        if (leftIndex < rightIndex) {
            int midIndex = (leftIndex + rightIndex) / 2;
            mergeSort(arr, leftIndex, midIndex);
            mergeSort(arr, midIndex+1, rightIndex);
            merge(arr, leftIndex, midIndex, rightIndex);
        }
    }

    // Merges two sorted sub-arrays into a single sorted array
    public static void merge(String[] arr, int leftIndex, int midIndex, int rightIndex) {
        String[] tempArr = new String[arr.length];
        for (int i = leftIndex; i <= rightIndex; i++) {
            tempArr[i] = arr[i];
        }
        int i = leftIndex;
        int j = midIndex + 1;
        int k = leftIndex;

        while (i <= midIndex && j <= rightIndex) {
            if (tempArr[i].compareTo(tempArr[j]) <= 0) {
                arr[k] = tempArr[i];
                i++;
            } else {
                arr[k] = tempArr[j];
                j++;
            }
            k++;
        }

        while (i <= midIndex) {
            arr[k] = tempArr[i];
            k++;
            i++;
        }
    }
	}
}

题目二：

有100个任务需要分成10批执行，每批执行有顺序（注意注意注意：即第一批执行完执行第二批）。10批任务有序执行，每批任务的10个任务要做到并发执行如果可以，写出多种不同原理或不同工具的实现方式 java语言实现

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class TaskBatchesExecutor {
    public static void main(String[] args) throws InterruptedException {
        int numTasks = 100;
        int batchSize = 10;
        int numBatches = numTasks / batchSize;

        ExecutorService executor = Executors.newFixedThreadPool(batchSize);
        for (int i = 0; i < numBatches; i++) {
            List<Runnable> tasks = new ArrayList<>();
            for (int j = 0; j < batchSize; j++) {
                int taskId = i * batchSize + j;
                tasks.add(() -> executeTask(taskId));
            }
            executor.invokeAll(tasks);
        }
        executor.shutdown();
        executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
    }

    private static void executeTask(int taskId) {
        System.out.println("Executing task #" + taskId + " on thread " + Thread.currentThread().getName());
        // Execute the task here
    }
}

		import java.util.concurrent.CountDownLatch;

		public class TaskBatchesExecutor {
		public static void main(String[] args) throws InterruptedException {
		int numTasks = 100;
		int batchSize = 10;
		int numBatches = numTasks / batchSize;
    CountDownLatch latch = new CountDownLatch(batchSize);

    for (int i = 0; i < numBatches; i++) {
        for (int j = 0; j < batchSize; j++) {
            int taskId = i * batchSize + j;
            new Thread(() -> {
                executeTask(taskId);
                latch.countDown();
            }).start();
        }
        latch.await();
        latch = new CountDownLatch(batchSize);
    }
}

private static void executeTask(int taskId) {
    System.out.println("Executing task #" + taskId + " on thread " + Thread.currentThread().getName());
    // Execute the task here
}
}

题目三：

有如下两张表，请统计各公司每天的营业额和各公司每天的累积营业额,说明：累积营业额是指：比如第一天是100，第二天是200，那么第二天累积营业额就是300 表： order表

表：shop 门店表

如何建索引能提高查询速度

SELECT
    o.trade_date,
    s.company_id,
    SUM(o.amount) AS daily_revenue,
    SUM(SUM(o.amount)) OVER (PARTITION BY s.company_id ORDER BY o.trade_date) AS cumulative_revenue
FROM
    order o
    INNER JOIN shop s ON o.shop_id = s.shop_id
GROUP BY
    o.trade_date,
    s.company_id;

• order 表中的 trade_date、amount 和 shop_id 列。

• shop 表中的 shop_id 和 company_id 列。

题目四：

请说说这段代码错误在哪里，如何修改（写出修改后的代码，java语言实现）说明：输入的list 中的str串都不为null，但可能是"".

public void sort(List<String> list) {
				Collections.sort(list, (o1, o2) -> {
						if ("".equals(o1) || "".equals(o2)){
								return 0;
								}
							return o1.compareTo(o2);
				});
		}

public void sort(List<String> list) {
    Collections.sort(list, (o1, o2) -> {
        if (o1.isEmpty() && o2.isEmpty()) {
            return 0;
        } else if (o1.isEmpty()) {
            return -1;
        } else if (o2.isEmpty()) {
            return 1;
        } else {
            return o1.compareTo(o2);
        }
    });
}