image.png
封装的工具类
//表示数组的工具类,涵盖了很多操作数组的方法
class ArrayUtil
{
//交换元素
static void swap(int[] arr,int index1,int index2)
{
int temp = arr[index1];
arr[index1] = arr[index2];
arr[index2] = temp;
}
//获取数组中最大元素
static int getMax(int[] nums)
{
int j = nums[0];//假设数组第一个值为最大值
for (int i = 1;i < nums.length ;i ++ )
{
if (nums[i] > j)
{
j = nums[i];//就把最大值存储在j变量中
}
}
return j;
}
//获取数组中最小元素
static int getMin(int[] nums)
{
int k = nums[0];//假设数组第一个值为最小值
for (int i = 1;i < nums.length ;i ++ )
{
if (nums[i] < k)
{
k = nums[i];//就把最大值存储在k变量中
}
}
return k;
}
//打印数组
static void print(int[] arr)
{
//思路:先打印数组"[]",再获取arr数组里面的元素,然后再做if判断,判断如果当前i的值不是最后一个索引,则拼接
if (arr == null)
{
System.out.println("null");
return;
}
String ret = "[";
for (int i = 0;i < arr.length ;i ++ )
{
ret = ret + arr[i];
//如果当前i不是最后一个索引,则拼接", "
if (i != arr.length - 1)
{
ret = ret + ", ";
}
}
ret = ret + "]";
System.out.println(ret);
}
//逆序排序
static String[] reverse(String[] oldArr)
{
//创建一个新的数组,存储颠倒之后的元素
String[] newArr = new String [oldArr.length];
for (int i = oldArr.length - 1;i >= 0 ;i -- )
{
//i = 4 newArr[0]
//i = 3 newArr[1]
newArr[oldArr.length - 1 - i] = oldArr[i];
}
return newArr;
}
//二分搜索法/二分查找法/折半查找
static int binarySearch(int[] arr,int key)
{
int low = 0;//最小的索引
int high = arr.length - 1;//最大的索引
while (low <= high)
{
System.out.println(low+"----------"+high);
int mid = (low + high) >> 1 ;//中间索引
int midVal = arr[mid];//将中间索引的元素赋值给变量midVal
if(midVal > key)//猜大了
{
high = mid - 1;//最大的索引=中间索引-1(缩小搜索范围)
}
else if(midVal < key)//猜小了
{
low = mid + 1;//最小的索引=中间索引+1(缩小搜索范围)
}
else
{
return mid;//如果中间索引刚好=key值,就直接返回mid
}
}
return -1;//假如说传入的元素没有在数组中,直接返回-1,表示不在该数组范围内,越界了.
}
//选择排序
static void selectinonSort(int[] arr)
{
/*
//第一轮
for (int i = 1;i <= arr.length - 1 ;i ++ )
{
if (arr[0] > arr[i])
{
swap(arr,0,i);
}
}
//第二轮
for (int i = 2;i <= arr.length - 1 ;i ++ )
{
if (arr[1] > arr[i])
{
swap(arr,1,i);
}
}
//第三轮
for (int i = 3;i <= arr.length - 1 ;i ++ )
{
if (arr[2] > arr[i])
{
swap(arr,2,i);
}
}
*/
//代码加强
for (int j = 1;j <= arr.length - 1;j ++ )
{
for (int i = j;i <= arr.length - 1 ;i ++ )
{
if (arr[j - 1] > arr[i])
{
swap(arr,j - 1,i);
}
}
}
}
//冒泡排序
static void sort(int[] arr)
{
//代码加强
for (int i = 1;i <= arr.length - 1 ;i ++ )
{
for (int j = 1;j <= arr.length - i ;j ++ )
{
if (arr[j - 1] > arr[j])
{
swap(arr,j-1,j);
}
}
}
/*
//第一轮
for (int i = 1;i <= arr.length - 1 ;i ++ )
{
if (arr[i - 1] > arr[i])
{
swap(arr,i-1,i);
}
}
//第二轮
for (int i = 1;i <= arr.length - 2 ;i ++ )
{
if (arr[i - 1] > arr[i])
{
swap(arr,i-1,i);
}
}
//第三轮
for (int i = 1;i <= arr.length - 3 ;i ++ )
{
if (arr[i - 1] > arr[i])
{
swap(arr,i-1,i);
}
}
*/
}
static void copy(int[] src,int srcPos,int[] dest,int destPos,int length)
{
/*
//拷贝3
dest[destPos]=src[srcPos];
//拷贝4
srcPos++; destPos++;
dest[destPos]=src[srcPos];
//拷贝5
srcPos++; destPos++;
dest[destPos]=src[srcPos];
//拷贝6
srcPos++; destPos++;
dest[destPos]=src[srcPos];
*/
//优化后的代码
//i等于每次需要拷贝元素的索引
for (int i = srcPos;i < srcPos + length;i ++ )
{
dest[destPos] = src[i];
destPos++;
}
}
//元素第一次索引
static int indexOf(int[] arr,int key)
{
for (int index = 0;index < arr.length ;index ++ )
{
if (arr[index] == key)
{
return index;
}
}
return -1;
}
//最后一次
static int lastIndexOf(int[] arr,int key)
{
for (int index = arr.length-1;index >=0 ;index -- )
{
if (arr[index] == key)
{
return index;
}
}
return -1;
}
}
调用工具类中的方法
image.png
class ArrayUtilDemo
{
public static void main(String[] args)
{
int[] arr = {2,8,1,9,14,58,69,42};
ArrayUtil.print(arr);
//搜索6的索引
ArrayUtil.sort(arr);//排序
ArrayUtil.print(arr);//打印
int index = ArrayUtil.binarySearch(arr,42);//搜索42的索引
System.out.println(index);//打印返回对应的索引值
}
}
JAVA自带数组工具类Arrays
image.png
//演示数组的工具类,Arrays类
class ArraysDemo
{
public static void main(String[] args)
{
int[] arr = {2,8,1,9,14,58,69,42};
String ret = java.util.Arrays.toString(arr);//打印数组元素
System.out.println(ret);
java.util.Arrays.sort(arr);//排序数组
String ret1 = java.util.Arrays.toString(arr);
System.out.println(ret1);
java.util.Arrays.sort(arr);//二分搜索
int index = java.util.Arrays.binarySearch(arr,8);
System.out.println(index);
}
}
网友评论