数组玩法（一）

本文主要以一个基本类型的数组为例子，展现数组的常用玩法。

第一种玩法：

找数组中的最大，最小值，顺便求和，算个平均数。

1.就找数组中的所有元素的最大，最小，求和算平均数（没有限制）

根据值的形式找最大，最小

方法：直接声明一个max变量，并将下标为0的数组元素的值copy给它，然后遍历，在遍历的时候进行判断，若比它大，修改它的值，否则不修改。 最小，类似

求和，算平均小case直接看代码

/**
int型数组，遍历，求和，最大值，最小值
*/
public class ArrayTest {

public static void main(String[] args) {

int[] arr = new int[8];
for (int i = 0; i < arr.length; i++) {
//0~20
arr[i] = (int)(Math.random() * 20);
}
// 遍历
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();

// 求和
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
// 求最大值
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
// 求最小值
int min = arr[0];
for (int i = 0; i < arr.length; i++) {
if (arr[i] < min) {
min = arr[i];
}
}
System.out.println("sum:" + sum + ",max:" + max + ",min:" + min);

// 遍历
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}

根据下标找最大，最小
方法：定义一个maxIdex变量并赋值为0，maxIdex[0]就可以表示下标为0的数组元素，然后遍历的时候判断，依旧是若是比它大修改maxIdex值，若是没有不做任何操作。要把握maxIdex是一个下标，而不是具体的值。

/**
利用下标找最大，最小
*/
class ArrayTest3 {

public static void main(String[] args) {
int[] arr = new int[8];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int)(Math.random() * 20);
}
//遍历
for (int var : arr) {
System.out.print(var + " ");
}
System.out.println();
//0 1 2 3 4 5  6  7
//2 6 9 0 5 11 18 0
// 最大值下标为6

int maxValueIndex = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[i] > arr[maxValueIndex]) {
maxValueIndex = i;
}
}
System.out.println("最大值:" + arr[maxValueIndex]);
int minValueIndex = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[i] < arr[minValueIndex]) {
minValueIndex = i;
}
}
System.out.println("最小值:" + arr[minValueIndex]);
}
}

2.有条件的情况下找最大，最小，求和，算平均

例如不知道数组是什么情况，也不能赋数组中第一个元素的值或者下标怎么解决？

直接给最大，最小赋极值

求最大，赋max最小

求最小，赋min最大

/**
在并不知道第一个数组元素值是什么的时候，找最大值，最小值
*/
class ArrayTest4 {

public static void main(String[] args) {
int[] arr = new int[8];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int)(Math.random() * 20 - 100);
}
//遍历
for (int var : arr) {
System.out.print(var + " ");
}
System.out.println();
//9 13 7 13 17 14 11 5
int max = 0x80000000;
for (int i = 0; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
System.out.println("max:" + max);
int min = 0x7fffffff;
for (int i = 0; i < arr.length; i++) {
if (arr[i] < min) {
min = arr[i];
}
}
System.out.println("min:" + min);
}
}

穿插个增强for循环和经典for循环

/**
增强型for循环，变量值和数组元素值关系，copy过去的，相互独立，互不影响
*/
class ArrayTest2 {

public static void main(String[] args) {

int[] arr = new int[8];

for (int i = 0; i < arr.length; i++) {
arr[i] = (int)(Math.random() * 20);
}

// 遍历
// 经典for循环
for (int i = 0; i < arr.length; i++) {
int var = arr[i];   //将值copy过去，不改变原数组元素的值
System.out.print(var + " ");
//var = 10000 * i; 赋值不会影响数组元素的值
}
System.out.println();

// 增强型for循环, 仅用于遍历数组, 对于数组的访问是只读的
/*
for (元素类型 变量 : 数组名) {
System.out.println(变量);
}*/

for (int var : arr) {
System.out.print(var + " ");
//var = 1000 * i;
}
}
}

第二种玩法 数组复制

利用数组复制，可以实现数组复制，找子数组，数组扩容

/**
数组复制
*/
class ArrayTest5 {

public static void main(String[] args) {
int[] arr = new int[8];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int)(Math.random() * 20);
}
//遍历
for (int var : arr) {
System.out.print(var + " ");
}
System.out.println();

//0 1 2 3 4 5 6  7
//2 1 0 6 9 2 12 3
//数组复制
//0 1 2 3 4 5 6  7
//0 0 0 0 0 0 0  0
//2 1 0 6 9 2 12 3
int[] arr2 = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
arr2[i] = arr[i];
}
//遍历
for (int var : arr2) {
System.out.print(var + " ");
}
System.out.println();
}
}

/**
获取子数组---> 1.创建一个容量小的数组
2.复制一定数目的数组元素
*/
class ArrayTest6 {

public static void main(String[] args) {
int[] arr = new int[8];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int)(Math.random() * 20);
}
//遍历
for (int var : arr) {
System.out.print(var + " ");
}
System.out.println();

//0 1 2 3 4 5 6  7
//2 1 0 6 9 2 12 3
//获取子数组
//0 1 2 3
//0 0 0 0
//2 1 0 6
int[] child = new int[arr.length / 2];
for (int i = 0; i < child.length; i++) { // 循环次数以容量小的为准
child[i] = arr[i];
}

for (int var : child) {
System.out.print(var + " ");
}
System.out.println();
}
}
/**
数组扩容 -->1创建一个容量的大数组
2复制原数组中的元素
3修改原数组名指向
*/
class ArrayTest7 {

public static void main(String[] args) {
int[] arr = new int[8];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int)(Math.random() * 20);
}
//遍历
for (int var : arr) {
System.out.print(var + " ");
}
System.out.println();

//0 1 2 3 4 5 6  7
//2 1 0 6 9 2 12 3
//扩容
//0 1 2 3 4 5 6  7 8 9          15
//0 0 0 0 0 0 0  0 0 0 0 0 0 0 0 0
//2 1 0 6 9 2 12 3 0 0 0 0 0 0 0 0
int[] bigger = new int[arr.length * 2];
for (int i = 0; i < arr.length; i++) {
bigger[i] = arr[i];
}
arr = bigger;

//遍历
for (int var : arr) {
System.out.print(var + " ");
}
System.out.println();
}
}

第三种玩法：

在满足一定条件下的情况下玩数组，输出符合含有符合要求的值的数组。

这里可以是任何具有可操作性的条件下，大体的做法都一致。

例如：将一个数组中的偶数提取出来保存，生成新的数组

关键点：count计数器记录原数组中有多少个偶数

常用方法：

1.先创建一个新数组，长度和原数组一致

2.遍历原数组，符合条件，将原数组的元素值copy写入新数组，特别注意新数组的下标有可能和原数组不一致。**使用count：newArr[count] = arr[i]; count++;**count只有在满足条件下才增加

3.利用count准确记录，设置最终数组，然后将新数组中的元素值copy写入最终数组

/**
输出满足一定值的数组
*/
class ArrayTest8 {

public static void main(String[] args) {
int[] arr = new int[8];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int)(Math.random() * 20);
}
//遍历
for (int var : arr) {
System.out.print(var + " ");
}
System.out.println();

//0 1 2 3 4 5 6  7
//2 1 0 6 9 2 12 3
//取出所有偶数,存入一个新数组
//0 1 2 3 4  5 6 7
//0 0 0 0 0  0 0 0
//2 0 6 2 12 0 0 0
//最终数组
//0 1 2 3 4
//0 0 0 0 0
//2 0 6 2 12
int[] newArr = new int[arr.length];
int count = 0; // 最关键变量, 用于指示新数组中赋值的下标
for (int i = 0; i < arr.length; i++) {
if (arr[i] % 2 == 0) {
newArr[count] = arr[i];
count++; // 赋完值后,自增,用于下一次再往数组中保存值时的新下标
}
}
int[] finalArr = new int[count]; // 最后count值就是新数组中的有效元素个数
for (int i = 0; i < count; i++) { // 依次把所有有效元素存入最终数组中即可
finalArr[i] = newArr[i];
}
//遍历
for (int var : finalArr) {
System.out.print(var + " ");
}
System.out.println();
// 把所有奇数提取成一个新的子数组
}
}

第四种玩法 数组反转

将数组元素顺序倒着来。

/**
数组的反转
*/
class ArrayTest9 {

public static void main(String[] args) {
int[] arr = new int[8];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int)(Math.random() * 20);
}
//遍历
for (int var : arr) {
System.out.print(var + " ");
}
System.out.println();

//0 1 2 3 4 5 6  7
//2 1 0 6 9 2 12 3
//反转
//3 12 2 9 6 0 1 2
for (int i = 0; i < arr.length / 2; i++) {
// 交换i位置和arr.length - 1 -i位置的元素
int tmp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = tmp;
}
//遍历
for (int var : arr) {
System.out.print(var + " ");
}
System.out.println();
}
}

第五种玩法

数组排序–>最简单，最慢的冒泡排序

/**
数组排序-冒泡排序
*/
class ArrayTest10 {

public static void main(String[] args) {
int[] arr = new int[8];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int)(Math.random() * 20);
}
//遍历
for (int var : arr) {
System.out.print(var + " ");
}
System.out.println();

// 外循环控制比较交换的趟数, 需要处理数组长度-1趟
for (int j = 0; j < arr.length - 1; j++) {
// 内循环处理每趟中比较交换的次数
for (int i = 0; i < arr.length - 1 - j; i++) { // 总是从最左边开始处理, 比较i位置和右边相邻位置的元素的值
if (arr[i] > arr[i + 1]) { // 如果左大右小, 进行交换
int tmp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = tmp;
}
}
}

//遍历
for (int var : arr) {
System.out.print(var + " ");
}
System.out.println();
}
}

最快的排序—>快速排序

java直接给我们提供了调用方法

/**
利用快速排序，注意在使用的时候要导util包
*/
class ArrayTest11 {

public static void main(String[] args) {
int[] arr = new int[8];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int)(Math.random() * 20);
}
//遍历
for (int var : arr) {
System.out.print(var + " ");
}
System.out.println();

Arrays.sort(arr); // 改良版快速排序

//遍历
for (int var : arr) {
System.out.print(var + " ");
}
System.out.println();

}
}

数组玩法（二）例子是引用型数组

大家还有什么玩法可以留言，共同学习，共同进步。