Java基础之数组常见操作小结 - 黑马程序员技术交流社区

import java.util.Arrays;
public class ArraysApp {
/**
* 数组常见操作小结
* 数组常见操作:
A: 遍历: 普通for循环遍历增强for循环遍历
B: 获取最值: 获取最大值max 最小值min
C: 排序: 选择排序冒泡排序
D: 查找: 顺序查找拆装查找
E: 反转:
* @param args
*/
public static void main(String[] args) {
//数组的定义及初始化
int[] arr = new int[]{78,45,0,26,89,0,14,30,0,96,63,51};
//增强for循环遍历数组
printArr1(arr);
System.out.println(" 输出没有0元素的新数组: ");
//普通for循环遍历数组
printArr2(getNewArray(arr));
//选择排序1
selectSort1(arr);
//选择排序性能的优化2
selectSort2(arr);
//冒泡排序1
bubbleSort1(arr);
//冒泡排序1
bubbleSort2(arr);
//调用数组工具类排序
Arrays.sort(arr);
System.out.println(" 原数组排序后: ");
//普通for循环遍历数组
printArr2(arr);
//将数组中的元素作为字符串打印输出
arrToString(arr);
System.out.println(" 原数组元素倒置后: ");
//数组的反转1
reverseArr1(arr);
//数组的反转2
reverseArr1(arr);
//普通for循环遍历数组
printArr2(arr);
//数组的反转3
reverseArr3(arr);
printArr2(arr);
System.out.println("\n 查找数组中的某个元素: ");
//顺序查找
int index1 = getIndex(arr,63);
findElement(index1);
//折半查找1
int index3 = binarySearch(arr,63);
findElement(index3);
//折半查找2
int index2 = halfSearch(arr,63);
findElement(index2);
//折半查找3
int index4 = Arrays.binarySearch(arr, 77);
//如果元素不存在,返回这个元素负的插入位置再-1
findElement(index4);
System.out.println("\n 查找数组中元素的最值: ");
int maxValue1 = getMax1(arr);
int maxValue2 = arr[getMax2(arr)];
System.out.println(" 获取数组arr最大值1: "+maxValue1);
System.out.println(" 获取数组arr最大值2: "+maxValue2);
int minValue1 = arr[getMin1(arr)];
System.out.println(" 获取数组arr最小值1: "+minValue1);
int minValue2 = getMin2(arr);
System.out.println(" 获取数组arr最小值2: "+minValue2);
System.out.println(" 获取数组arr的平均值: "+getEverage(arr));
}
//返回没有0元素的新数组
public static int[] getNewArray(int[] arr) {
int len = getLen(arr);
int[] newArr = new int[len];
int index = 0;
for (int i = 0; i < arr.length; i++) {
if(0 != arr[i]){
newArr[index++] = arr[i];
}
}
return newArr;
}
//获取除0元素外的新数组的长度
public static int getLen(int[] arr) {
int newArrLen = 0;
for (int i = 0; i < arr.length; i++) {
if(0 != arr[i]){
newArrLen++;
}
}
return newArrLen;
}
//数组元素的倒置输出3
public static void reverseArr3(int[] arr) {
for (int i = 0,j=arr.length-1; i < arr.length; i++,j--) {
swap(arr, i, j);
}
}
//数组元素的倒置输出2
public static void reverseArr2(int[] arr) {
for (int i = 0; i < arr.length/2; i++) {
swap(arr, i, arr.length-1-i);
}
}
//数组元素的倒置输出1
public static void reverseArr1(int[] arr) {
System.out.print(" 数组元素的倒置输出: { ");
for (int i = arr.length-1; i >= 0; i--) {
if(i != 0)
System.out.print(arr[i]+",");
else
System.out.println(arr[i]+" }");
}
}
//将数组中的元素作为字符串打印输出
public static void arrToString(int[] arr) {
System.out.print(" 作为字符串打印输出: \"");
for (int i = 0; i < arr.length; i++) {
System.out.print(""+arr[i]);
}
System.out.println("\"");
}
//对数组元素求平均值
public static double getEverage(int[] arr) {
int sum = 0;
int len = arr.length;
double everage = 0.0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
everage = (double)(sum)/len;
return everage;
}
//折半查找1
public static int binarySearch(int[] arr, int key) {
int min,max,mid;
min = 0;
max = arr.length-1;
mid = (min+max)/2;
while(key != arr[mid]){
if(key < arr[mid]){
max = mid - 1;
}else{
min = mid + 1;
}
if(max < min){
return -1;
}
mid = (min+max)/2;
}
return mid;
}
//打印所要查找元素的结果
public static void findElement(int index){
if(-1 != index){
System.out.println(" 所要查找元素在数组中的下标为: "+index);
}else{
System.out.println(" 数组中不存在该元素! ");
}
}
//对排序后的元素进行折半查找的优化2
public static int halfSearch(int[] arr,int key) {
int low = 0;
int high = arr.length-1;
int mid;
while(low <= high){
mid = (low+high)>>1;
if(key > arr[mid]){
low = mid + 1;
}else if(key < arr[mid]){
high = mid - 1;
}else{
return mid;
}
}
return -1; //若返回min,则可以获得往这个有序的数组中新存入一个元素,
//并依然保持这个数组有序的下标
}
//查找数组中的元素
public static int getIndex(int[] arr, int key) {
for (int i = 0; i < arr.length; i++) {
if(key == arr[i]){
return i;
}
}
return -1;
}
//冒泡排序2
public static void bubbleSort2(int[] arr) {
for(int i=arr.length-1;i>0;i--){
for(int j=0;j<i;j++){
if(arr[j] > arr[j+1]){
swap(arr,j,j+1);
}
}
}
}
//冒泡排序1
public static void bubbleSort1(int[] arr) {
for (int i = 0; i < arr.length-1; i++) {
for (int j = 0; j < arr.length-1-i; j++) {
if(arr[j] >arr[j+1]){
swap(arr,j,j+1);
/*
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
*/
}
}
}
}
//选择排序1
public static void selectSort1(int[] arr) {
for (int i = 0; i < arr.length-1; i++) {
for (int j = i+1; j < arr.length; j++) {
if(arr[i] > arr[j]){
swap(arr, i, j);
}
}
}
}
//选择排序性能的优化2
public static void selectSort2(int[] arr){
for (int i = 0; i < arr.length-1; i++) {
int num = arr[i];
int index = i;
for (int j = i+1; j < arr.length; j++) {
if(num > arr[j]){
num = arr[j];
index = j;
}
}
if(index != i)
swap(arr, i, index);
}
}
//交换数组中两元素的位置
public static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//通过比较数组元素,获取数组最大值
public static int getMax1(int[] arr) {
int maxElement = arr[0];
for (int i = 1; i < arr.length; i++) {
if(maxElement < arr[i]){ //要得到最小值只要把'<'改成'>'
maxElement = arr[i];
}
}
return maxElement;
}
//通过比较数组元素,得到对应元素的下标,从而获取数组最大值
public static int getMax2(int[] arr) {
int maxIndex = 0;
for (int i = 1; i < arr.length; i++) {
if(arr[maxIndex] < arr[i]){
maxIndex = i;
}
}
return maxIndex;
}
//通过比较数组元素,获取数组最小值
public static int getMin2(int[] arr) {
int minElement = arr[0];
for (int i = 1; i < arr.length; i++) {
if(minElement > arr[i]){
minElement = arr[i];
}
}
return minElement;
}
//通过比较数组元素,得到对应元素的下标,从而获取数组最小值
public static int getMin1(int[] arr) {
int minIndex = 0;
for (int i = 1; i < arr.length; i++) {
if(arr[minIndex] > arr[i]){ //要得到最大值下标,只要把'>'改成'<'
minIndex = i;
}
}
return minIndex;
}
//普通for循环遍历数组arr
public static void printArr2(int[] arr) {
System.out.print(" 普通for循环遍历数组: { ");
for (int i = 0; i < arr.length; i++) {
if(i != arr.length-1){
System.out.print(arr[i]+",");
}else{
System.out.println(arr[i]+" }");
}
}
}
//增强for循环遍历数组arr
public static void printArr1(int[] arr) {
System.out.print(" 增强for循环遍历数组: { ");
for(int x : arr){
System.out.print(x+" ");
}
System.out.println("}");
}
}

复制代码