案例1：定义一个方法，找出int类型的数组中的最大值的索引
package com.wyx.a_array;
public class Demo6 {
public static void main(String[] args) {
maxIndex();
}
public static void maxIndex () {
//初始数组
int arr[] = {5, 6, 4, 8, 3};
//index：用来存储最大值的索引
int index = 0;
//遍历整个数组
for (int i = 0; i < arr.length; i++) {
//把最大值的索引赋值给index
if (arr[i] > arr[index]) {
index = i;
}
}
System.out.println(index);
}
}
案例2:在指定索引位置插入数据，索引之后的数向后移
package com.baidu.a_array;
import java.util.Arrays;
public class Demo7 {
public static void main(String[] args) {
int arr[] = {1, 2, 3, 4, 0};
for (int i = arr.length - 1; i > 1; i--) {
arr[i] = arr[i-1];
}
arr[1] = 5;
System.out.println(Arrays.toString(arr));
}
}
案例3：找出数组中所有的指定数据的下标，存到一个数组中
package com.baidu.a_array;
import java.util.Arrays;
//找出数组中所有的指定数据的下标，存到一个数组中
public class Demo2 {
public static void main(String[] args) {
int arr[] = {2, 3, 2, 4, 5, 2};//查找2
int arr1[] = findAllIndexes(arr, 2);
System.out.println(Arrays.toString(arr1));
}
public static int[] findAllIndexes (int arr[], int find) {
//定义一个空数组用来接收查找值得索引
int indexes[] = new int[arr.length];
//计数器
int count = 0;
//利用for循环遍历数组查找需要查找的数值索引
for (int i =0; i < arr.length; i++) {
if (find == arr[i]) {
indexes[count++] = i;
}
}
//剔除掉空值
int newindexes[] = new int[count];
for (int i = 0; i < newindexes.length; i++) {
newindexes[i] = indexes[i];
}
return newindexes;
}
}
案例4：将数组中最大的值和第一个值调换
package com.baidu.a_array;
import java.util.Arrays;
public class Demo3 {
public static void main(String[] args) {
int arr[] = {5, 4, 3, 2, 1};
System.out.println(Arrays.toString(replace(arr)));
}
//获取数组中的最小值，并把最小值位置与第一个位置交换
/**
*
* @param arr 原数组
* @return 替换过之后数组
*/
public static int[] replace (int arr[]) {
int minIndex = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[minIndex] > arr[i]) {
minIndex = i;
}
}
int a = arr[0];
arr[0] = arr[minIndex];
arr[minIndex] = a;
return arr;
}
}
排序
选择排序（根据索引）
从小到大排序
原理：找到最小值的索引，然后和第1个数据进行交换。再找除了第一个数据以外的最小值的索引。然后和第二个数据交换
案例5：数组排序（利用案例4原理）
自己写的(代码臃肿)
package com.baidu.a_array;
import java.util.Arrays;
public class Demo4 {
public static void main(String[] args) {
//需要排序的数组
int arr[] = {6, 2, 3, 8, 4};
System.out.println(Arrays.toString(sort1(arr)));
}
//数组排序
public static int[] sort1 (int arr[]) {
//用来存储从第count这个位置来查找最小值，同时也用来初始化minindex和i这两个变量
int count = 0;
//存储查找到的最小值的索引
int minindex = 0;
//把在数组中查找到的最小值放在arr[b]这个位置
int b = 0;
//外层循环用来把查找到的最小值放在arr[b]这个位置
for (int i = 0; i < arr.length; count++, b++ ) {
//内层循环用来查找最小值
for (; i < arr.length; i++) {
if (arr[minindex] > arr[i]) {
minindex = i;
}
}
int a = arr[b];
arr[b] = arr[minindex];
arr[minindex] = a;
i = minindex = count + 1;
}
return arr;
}
}
别人写的
package com.baidu.a_array;
import java.util.Arrays;
public class Demo5 {
public static void main(String[] args) {
int arr[] = {5, 4, 3, 2, 1};
System.out.println(Arrays.toString(sort1(arr)));
}
// 选择排序
public static int[] sort1(int arr[]) {
//五个数比较四次就可以得到结果，外层循环控制轮数
for (int i = 0; i < arr.length - 1; i++) {
int minindex = i;
//内层循环查找最小值索引
for (int j = i; j < arr.length; j++) {
if (arr[minindex] > arr[j]) {
minindex = j;
}
}
// 数据交换
int temp = arr[i];
arr[i] = arr[minindex];
arr[minindex] = temp;
}
return arr;
}
}
冒泡排序（根据数值）
从小到大排序
原理:比较两个相邻的数据，如果左边比右边元素大就交换位置。如果左边比右边小，就不变（相当于找大数依次从右往左排）
package com.baidu.a_array;
import java.util.Arrays;
public class Demo6 {
public static void main(String[] args) {
int arr[] = { 5, 4, 3, 2, 1, 6, 3 };
System.out.println(Arrays.toString(sort1(arr)));
}
// 冒泡排序
public static int[] sort1 (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]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
return arr;
}
}
