数组的排序、增删改查、自写方法
1.Jdk内置方法进行排序，Arrays.sort(....)方法
public class ArrayDemo3 {
public static void main(String[] args) {
Integer[] intArr = {2, 7, 3, 3, 2, 4};
String[] strArr = {"B", "c", "A", "D"};
String[] numberArr = {"13", "2", "25", "8", "11"};
//\u4f60\u6211\u4ed6\u5b83
String[] wordArr = {"你", "我", "他", "它"};
//JDK内置的数组排序方法
//从小到大排序(默认)
//默认按照字典顺序(0(48)-9,A(65)-Z,a(97)-z)
/*Arrays.sort(intArr);
Arrays.sort(strArr);
Arrays.sort(numberArr);
Arrays.sort(wordArr);*/
//从大到小排序
//注意: 基本类型需要提升为包装类才可以使用,即int->Integer,char->Character,其他都是首字母大写
Arrays.sort(intArr, Collections.reverseOrder());
Arrays.sort(strArr, Collections.reverseOrder());
Arrays.sort(numberArr, Collections.reverseOrder());
Arrays.sort(wordArr, Collections.reverseOrder());
//打印结果
System.out.println(Arrays.toString(intArr));
System.out.println(Arrays.toString(strArr));
System.out.println(Arrays.toString(numberArr));
System.out.println(Arrays.toString(wordArr));
}
}
2.数据元素增删
public class Aarraydemo02 {
public static void main(String[] args) {
//数组元素的增删，是通过创建新数组容器，然后拷贝原数组数据到新数组中来间接实现
//1.自己写代码实现，参见ArrayUtil类
//2.jdk内置功能,如下
//jdk方法一
/**
* System.arraycopy(Object,src,srcPos,dest,destPos,length)
* src 原数组
* srcPos 拷贝元素所在元素组的起始下标
* dest 目标数组
* destPos 元素复制到目标数组的下标
* length 拷贝一次一共复制多少元素
*/
//例如在数组1，2，3中2和3之间添加为8
//创建一个新数组，长度为原始组长度的+1
int[] arr={1,2,3};
int[] newArr=new int[arr.length+1];
//把1，2复制到新数组的前两个位置
System.arraycopy(arr,0,newArr,0,2);
//把3复制到新数组的最后一个位置
System.arraycopy(arr,2,newArr,3,1);
//把添加的元素赋值
newArr[2]=8;
System.out.println(Arrays.toString(newArr));
System.out.println("--------------------------------------");
//例如在数组1，2，3删除3
//创建一个新数组，长度为原始组长度的-1
int[] arr1={1,2,3};
int[] newArr1=new int[arr.length-1];
//把1，2复制到新数组的0，1位置
System.arraycopy(arr1,0,newArr1,0,2);
System.out.println(Arrays.toString(newArr1));
System.out.println("------------------------------------");
//jdk方法2
/**
* jdk1.6的数组拷贝
* Arrays.copyOf();
* 此方法适合在尾部扩容添加元素/减容删除使用，不像System.arraycopy灵活可以在任何位置。
*/
int[] arr3={1,2,3};
int[] newArr3=Arrays.copyOf(arr3,10);
System.out.println(Arrays.toString(newArr3));
}
}
3.自己通过算法实现，冒泡，选择，快速，插入.......
package com.JavaSE.util;
import java.util.Arrays;
/**
* description：数组工具类(默认都是int[]数组)
*
* @author Administrator
* @date 2022/3/10 16:08
*/
public class ArrUtil {
/**
* 获取数组中的最大值
*/
public static int maxElement(int[] arr) {
/**
* 关于方法的参数,一般都需要进行两种不同的判断:
* 1.非空判断,即判断是否为null,避免空指针异常: java.lang.NullPointerException(基本类型不需要判断非空)
* 2.参数有效性判断,即参数是否符合业务逻辑
*/
//假设第一个元素是最大的
int max = arr[0];
//循环从第二个元素开始依次和max比较
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
//覆盖max
max = arr[i];
}
}
return max;
}
/**
* 获取数组中的最小值
*/
public static int minElement(int[] arr) {
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] < min) {
min = arr[i];
}
}
return min;
}
/**
* 添加数组元素
*
* @param arr 原数组
* @param pos 添加元素的下标位置
* @param newElement 添加的元素
* @return 添加元素后的新数组
*/
public static int[] addElement(int[] arr, int pos, int newElement) {
//判断数组是否为空
if (arr == null) {
System.out.println("数组参数不能为空!");
return null;
}
//参数有效性判断
if (pos < 0 || pos > arr.length) {
//说明添加的下标不在合理范围之内,就返回原数组
System.out.println("添加元素的下标位置不合法!");
return arr;
}
//创建新数组,长度+1
int[] newArr = new int[arr.length + 1];
/**相比于自己写的方法，此方法的思路：分段法
.先假设已经插入那么先把插入点之前的元素输出
2.再将插入点的数输出
3.插入点之后的数输出
此时也包括了两种特殊情况，pos==0或者pos==arr.length都是可以正常输出的
*/
//分段法
//插入点之前
for (int i = 0; i < pos; i++) {
newArr[i] = arr[i];
}
//插入点
newArr[pos] = newElement;
//插入点之后
for (int i = pos; i < arr.length; i++) {
newArr[i + 1] = arr[i];
}
return newArr;
}
/**
* 根据下标删除数组中的元素(0,1个)
*
* @param arr 原数组
* @param index 被删除元素所在的下标
* @return 删除元素后的新数组
*/
public static int[] deleteElementByIndex(int[] arr, int index) {
//判断数组是否为空
if (arr == null) {
System.out.println("数组参数不能为空!");
return null;
}
//参数有效性判断
if (index < 0 || index >= arr.length) {
//说明添加的下标不在合理范围之内,就返回原数组
System.out.println("删除元素的下标不合法!");
return arr;
}
//创建一个新数组,长度为原数组长度-1
int[] newArr = new int[arr.length - 1];
//定义一个变量记录新数组的下标
int idx = 0;
//遍历原数组
for (int i = 0; i < arr.length; i++) {
if (i != index) {
newArr[idx++] = arr[i];
}
}
return newArr;
}
/**
* 根据元素删除数组中的元素(0,多个)
*
* @param arr 原数组
* @param target 删除的目标元素
* @return 删除元素后的新数组
*/
public static int[] deleteElementByTarget(int[] arr, int target) {
//判断数组是否为空
if (arr == null) {
System.out.println("数组参数不能为空!");
return null;
}
//判断数组中有多少个target元素要删除
int count = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[i] == target) {
count++;
}
}
//根据计算出要删除的元素个数来新建数组
int[] newArr = new int[arr.length - count];
//循环元素组,把不要删除的元素放入到新数组中
int idx = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[i] != target) {
newArr[idx++] = arr[i];
}
}
return newArr;
}
/**
* 数组元素排重
*
* @param arr 原数组
* @return 排重后的结果
*/
public static int[] noRepeatElement(int[] arr) {
//创建新数组,长度等于原数组
int[] newArr = new int[arr.length];
int idx = 0;
do {
//把原数组第一个元素放入到新数组中
newArr[idx++] = arr[0];
//删除原数组中所有该元素
arr = deleteElementByTarget(arr, arr[0]);
} while (arr.length != 0);
//处理新数组的长度
newArr = Arrays.copyOf(newArr, idx);
return newArr;
}
/**
* 冒泡排序
* 从小到大
*/
public static void bubbleSort(int[] arr) {
//外层控制循环的次数，n=arr.length-1
for (int i = 0; i < arr.length - 1; i++) {
//元素位置交换
//第一次循环 比较arr.length-0-1次
//第二次循环 比较arr.length-1-1次
//第三次循环 比较arr.length-2-1次
for (int j = 0; j < arr.length - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = temp;
}
}
}
}
/**
* 选择排序
*
*/
public static void selectionSort(int[] arr) {
for (int i = 0; i < arr.length; i++) {
int minIdx = i;
for (int j = i; j < arr.length; j++) {
if(arr[j] < arr[minIdx]){
minIdx = j;
}
}
if(minIdx != i){
int temp = arr[minIdx];
arr[minIdx] = arr[i];
arr[i] = temp;
}
}
}
/**
* 插入排序
* @param arr
*/
public static void sort(int[] arr){
int n = arr.length;
for( int i = 0 ; i < n ; i ++ ){
// 寻找[i, n)区间里的最小值的索引
int minIndex = i;
for( int j = i + 1 ; j < n ; j ++ ) {
if( arr[j] < arr[minIndex] ) {
minIndex = j;
}
}
//数据交换不同索引位置数据
swap( arr , i , minIndex);
}
}
private static void swap(int[] arr, int i, int j) {
int t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
}
浙公网安备 33010602011771号