1. 冒泡排序

冒泡排序是一种基础的排序算法，它的核心思想是通过两两比较相邻的元素，如果它们的顺序错误就交换位置。

代码实现：

```

public static void bubbleSort(int[] arr) {

int n = arr.length;

for (int i = 0; i < n - 1; i++) {

for (int j = 0; j < n - 1 - i; j++) {

if (arr[j] > arr[j+1]) {

int temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

}

}

}

}

```

2. 插入排序

插入排序是一种简单直观的排序算法，它的核心思想是将待排序元素按其大小逐个插入到已排序的序列中。

代码实现：

```

public static void insertSort(int[] arr) {

int n = arr.length;

for (int i = 1; i < n; i++) {

int val = arr[i];

int j = i - 1;

while (j >= 0 && arr[j] > val) {

arr[j+1] = arr[j];

j--;

}

arr[j+1] = val;

}

}

```

3. 归并排序

归并排序是一种基于分治思想的高效排序算法，它的核心思想是将待排序序列不断递归地分成更小的子序列，然后再将这些子序列合并成一个有序序列。

代码实现：

```

public static void mergeSort(int[] arr, int left, int right) {

if (left < right) {

int mid = (left + right) / 2;

mergeSort(arr, left, mid);

mergeSort(arr, mid+1, right);

merge(arr, left, mid, right);

}

}

private static void merge(int[] arr, int left, int mid, int right) {

int[] temp = new int[right - left + 1];

int i = left, j = mid+1, k = 0;

while (i <= mid && j <= right) {

if (arr[i] <= arr[j]) {

temp[k++] = arr[i++];

} else {

temp[k++] = arr[j++];

}

}

while (i <= mid) {

temp[k++] = arr[i++];

}

while (j <= right) {

temp[k++] = arr[j++];

}

for (int m = 0; m < temp.length; m++) {

arr[left + m] = temp[m];

}

}

```

4. 快速排序

快速排序是一种常用的排序算法，它的核心思想是通过分治思想，将待排序序列不断递归地分成更小的子序列，然后再对这些子序列进行排序。

代码实现：

```

public static void quickSort(int[] arr, int low, int high) {

if (low < high) {

int p = partition(arr, low, high);

quickSort(arr, low, p-1);

quickSort(arr, p+1, high);

}

}

private static int partition(int[] arr, int low, int high) {

int pivot = arr[low];

int i = low, j = high;

while (i < j) {

while (i < j && arr[j] >= pivot) {

j--;

}

arr[i] = arr[j];

while (i < j && arr[i] <= pivot) {

i++;

}

arr[j] = arr[i];

}

arr[i] = pivot;

return i;

}

```

5. 堆排序

堆排序是一种高效的排序算法，它的核心思想是将待排序序列构建成一个二叉堆，然后依次取出堆顶元素，并将剩余的元素重新构建成一个二叉堆。

代码实现：

```

public static void heapSort(int[] arr) {

int n = arr.length;

for (int i = n / 2 - 1; i >= 0; i--) {

heapify(arr, i, n);

}

for (int i = n - 1; i > 0; i--) {

swap(arr, 0, i);

heapify(arr, 0, i);

}

}

private static void heapify(int[] arr, int i, int n) {

int largest = i;

int left = 2 * i + 1;

int right = 2 * i + 2;

if (left < n && arr[left] > arr[largest]) {

largest = left;

}

if (right < n && arr[right] > arr[largest]) {

largest = right;

}

if (largest != i) {

swap(arr, i, largest);

heapify(arr, largest, n);

}

}

private static void swap(int[] arr, int i, int j) {

int temp = arr[i];

arr[i] = arr[j];

arr[j] = temp;

}

```

6. 线性查找

线性查找是一种基本的查找算法，它的核心思想是从待查找序列的第一个元素开始逐个查找，直到找到目标元素或者查找完整个序列。

代码实现：

```

public static int linearSearch(int[] arr, int key) {

int n = arr.length;

for (int i = 0; i < n; i++) {

if (arr[i] == key) {

return i;

}

}

return -1;

}

```

7. 二分查找

二分查找是一种常用的查找算法，它的核心思想是通过逐次缩小待查找序列的范围，快速地定位目标元素。

代码实现：

```

public static int binarySearch(int[] arr, int key) {

int left = 0, right = arr.length - 1;

while (left <= right) {

int mid = (left + right) / 2;

if (arr[mid] == key) {

return mid;

} else if (arr[mid] < key) {

left = mid + 1;

} else {

right = mid - 1;

}

}

return -1;

}

```

8. 最短路径算法

最短路径算法是一种用于计算图中两个顶点之间的最短路径的算法，常用的算法有Dijkstra算法和Bellman-Ford算法。

代码实现：

```

// Dijkstra算法

public static void dijkstra(int[][] graph, int src) {

int n = graph.length;

int[] dist = new int[n];

boolean[] visited = new boolean[n];

for (int i = 0; i < n; i++) {

dist[i] = Integer.MAX_VALUE;

visited[i] = false;

}

dist[src] = 0;

for (int count = 0; count < n-1; count++) {

int u = minDistance(dist, visited);

visited[u] = true;

for (int v = 0; v < n; v++) {

if (!visited[v] && graph[u][v] != 0 && dist[u] != Integer.MAX_VALUE && dist[u] + graph[u][v] < dist[v]) {

dist[v] = dist[u] + graph[u][v];

}

}

}

}

private static int minDistance(int[] dist, boolean[] visited) {

int minDist = Integer.MAX_VALUE, minIndex = -1;

for (int i = 0; i < dist.length; i++) {

if (!visited[i] && dist[i] < minDist) {

minDist = dist[i];

minIndex = i;

}

}

return minIndex;

}

```

9. 回归分析

回归分析是一种机器学习算法，它的核心思想是通过将已知数据集的特征与输出值之间的关系建模，来预测未知数据点的输出值。

代码实现：

```

public class Regression {

private double[] coefficients;

private double[] means;

private double[] stdDevs;

public Regression(double[][] data) {

int n = data.length;

int k = data[0].length;

double[] y = new double[n];

double[][] x = new double[n][k];

for (int i = 0; i < n; i++) {

y[i] = data[i][0];

for (int j = 1; j < k; j++) {

x[i][j] = data[i][j];

}

}

RegressionResult result = SimpleRegression.estimate(y, x);

this.coefficients = result.getCoefficients();

this.means = new double[k];

this.stdDevs = new double[k];

for (int i = 1; i < k; i++) {

this.means[i] = result.getInputMeans()[i-1];

this.stdDevs[i] = result.getInputStdDevs()[i-1];

}

}

public double[] predict(double[] x) {

int k = x.length;

double[] z = new double[k+1];

z[0] = 1.0;

for (int i = 1; i <= k; i++) {

z[i] = (x[i-1] - means[i]) / stdDevs[i];

}

double y = 0.0;

for (int i = 0; i <= k; i++) {

y += coefficients[i] * z[i];

}

return y;

}

}

```

以上仅仅是Java中一部分常用的算法代码实现，实际上Java中还包括各种图算法、奇异值分解算法等等实用的算法，总之 Java是一个应用广泛的语言，算法实现也得到了广泛的应用。