(1)Arrays.fill(int a[],int value); 将value值赋给数组a的每一个元素
(2)Arrays.fill(int a[],int fromIndex,int toIndex,int value);//{包括fromIndex,但不包括toIndex}
(3)Arrays.sort(Object obj);//根据comparable的接口实现比较
Java中的String数组类型的排序是根据字典的编排顺序排序的,所以数字在字母之前。大写字母在小写字母之前。
(4)Arrays.copyOf(T[] arr,int newLength);//数组的复制,newLength代表返回的数组的长度,当新数组的长度大于原来数组的长度,多余的部分则用0初始化(int 为0,char用null);
(5)Arrays.copyOfRange(T[] arr,int fromIndex,int toIndex);//(包括fromIndex但不包括toIndex)
(6)Arrays,binarySearch(Object[] obj,Object key);//二分法查找,
(7)Arrays.binarySearch(Object[] obj,int fromIndex,int toIndex,Object key);//使用此方法之前要先对数组进行排序，来获得准确的索引值，如果搜索的元素key在指定的范围内，则返回索引的值，否则返回-1或者-(fromIndex+1)
(8)数组排序:
冒泡排序:
冒泡排序——排序数组元素的过程：将小数往前放，将大数往后放。类似水中的气泡往上冒。
0x01 基本思想
冒泡排序就是对比相邻的元素值，如果满足条件就交换元素值。把较小的元素移到数组的前面，把大的元素移动到数组的后面。这样小的元素就像气泡一样移到了元素的顶部。
0x02 算法示例
冒泡算法由双层循环实现，外层循环用于控制排序轮数(轮数一般是要排序的元素的长度减一)，而内层循环主要用于对比数组中每个邻近元素的大小，以确定是否交换位置。对比和交换次数随排序轮数而减少。
第一轮:第一个元素63和后面的一个元素4比较,63比4大,则63与4交换。交换后，63成为第二个元素，第二个元素和第三个元素比较，63比24大，则继续交换。继续比较下去，直至最后一个元素。
第二轮，第一个元素开始，与后面的比较，相同的操作直到倒数第二个元素。
……继续操作直到排序任务完成。
0x03 算法实现
public static void sort(int[] arr)
{
for(int i=1;i<arr.length;i++)
{
//比较两个相邻的元素,较大的则往后冒泡
for(int j=0;j<arr.length-i;j++)
{
if(arr[j]>arr[j+1])
{
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
直接选择排序
0x01 基本思想
直接选择排序的基本思想是将指定排序位置与其他元素分别对比，如果满足条件就交换元素值。与冒泡排序相比，直接排序交换的次数更加的少，所以其速度也会更加的快。
0x02 算法示例
每一次从待排序列中选择一个最小的数，将其排列在已经排好序列的最后。
0x03 算法实现
public void chooseSort(int[] arr)
{
int index;
for(int i=0;i<arr.length;i++)
{
index=i;
for(int j=i+1;j<arr.length;j++)
{
if(arr[j]<arr[index])
{
index=j;
}
}
int temp=arr[i];
arr[i]=arr[index];
arr[index]=temp;
}
}
快速排序
0x01 基本思想
快速排序是一种既不浪费空间并且计算速度还很快的排序算法。采用分治法,找出一个基准数，然后将以这个基准数，分为比基准数小的左侧序列和比基准数大的右侧序列。递归执行直到无法再找出基准数。排序完成
0x02 算法示例
假设用户输入了如下数组：
| 下标 | 0 | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|---|
| 数据 | 6 | 2 | 7 | 3 | 8 | 9 |
创建变量i=0（指向第一个数据）, j=5(指向最后一个数据), k=6(赋值为第一个数据的值)。
我们要把所有比k小的数移动到k的左面，所以我们可以开始寻找比6小的数，从j开始，从右往左找，不断递减变量j的值，我们找到第一个下标3的数据比6小，于是把数据3移到下标0的位置，把下标0的数据6移到下标3，完成第一次比较：
| 下标 | 0 | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|---|
| 数据 | 3 | 2 | 7 | 6 | 8 | 9 |
i=0 j=3 k=6
接着，开始第二次比较，这次要变成找比k大的了，而且要从前往后找了。递加变量i，发现下标2的数据是第一个比k大的，于是用下标2的数据7和j指向的下标3的数据的6做交换，数据状态变成下表：
| 下标 | 0 | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|---|
| 数据 | 3 | 2 | 6 | 7 | 8 | 9 |
i=2 j=3 k=6
称上面两次比较为一个循环。
接着，再递减变量j，不断重复进行上面的循环比较。
在本例中，我们进行一次循环，就发现i和j“碰头”了：他们都指向了下标2。于是，第一遍比较结束。得到结果如下，凡是k(=6)左边的数都比它小，凡是k右边的数都比它大：
| 下标 | 0 | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|---|
| 数据 | 3 | 2 | 7 | 6 | 8 | 9 |
如果i和j没有碰头的话，就递加i找大的，还没有，就再递减j找小的，如此反复，不断循环。注意判断和寻找是同时进行的。
然后，对k两边的数据，再分组分别进行上述的过程，直到不能再分组为止。
注意：第一遍快速排序不会直接得到最终结果，只会把比k大和比k小的数分到k的两边。为了得到最后结果，需要再次对下标2两边的数组分别执行此步骤，然后再分解数组，直到数组不能再分解为止（只有一个数据），才能得到正确结果。
下面，我们用一个动图
原文链接：https://blog.csdn.net/qq_36186690/article/details/82470451
0x03 算法实现
/**
* 快速排序
* @param array
*/
public static void quickSort(int[] array) {
int len;
if(array == null
|| (len = array.length) == 0
|| len == 1) {
return ;
}
sort(array, 0, len - 1);
}
/**
* 快排核心算法，递归实现
* @param array
* @param left
* @param right
*/
public static void sort(int[] array, int left, int right) {
if(left > right) {
return;
}
// base中存放基准数
int base = array[left];
int i = left, j = right;
while(i != j) {
// 顺序很重要，先从右边开始往左找，直到找到比base值小的数
while(array[j] >= base && i < j) {
j--;
}
// 再从左往右边找，直到找到比base值大的数
while(array[i] <= base && i < j) {
i++;
}
// 上面的循环结束表示找到了位置或者(i>=j)了，交换两个数在数组中的位置
if(i < j) {
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
}
// 将基准数放到中间的位置（基准数归位）
array[left] = array[i];
array[i] = base;
// 递归，继续向基准的左右两边执行和上面同样的操作
// i的索引处为上面已确定好的基准值的位置，无需再处理
sort(array, left, i - 1);
sort(array, i + 1, right);
}
网友评论