小白java数组题目整理（入门自用）

一、实现数组从大到小的排序（降序排序、选择排序）

思路：n个数组元素中，每一次从待排序的数据元素中选出最小的一个元素，存放在序列的起始位置，重复循环n-1次，直到全部待排序的数据元素排完。

import java.util.Arrays;
import java.util.Scanner;

public class HelloWorld {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int[] a = new int[sc.nextInt()];//输入几个数构成数组
		for(int i = 0; i< a.length; i++){
			a[i] = sc.nextInt();
		}
		
		for(int i = 0;i<a.length;i++)
            for(int j = i+1; j<a.length; j++)
                if(a[j]>a[i]){
                    int t = a[i];
                    a[i] = a[j];
                    a[j] = t;
                }
		System.out.println(Arrays.toString(a));//此公式可直接输出整个数组
	}
}

注意：交换a[i]和a[j]的值，需要引入第三个变量t,先将a[i]的值赋给t，再将a[i]和a[j]的值交换。

Arrays.toString()可将数组转化为字符串，直接输出整个一维数组；若为二维数组，则用Arrays.deepToString()。

二、使用冒泡排序实现数组的升序排序（从小到大）

冒泡排序原理：将序列当中的左右元素，依次比较，如果左边的元素大于右边元素则交换位置，保证右边的元素始终大于左边的元素;( 第一轮结束后，序列最后一个元素一定是当前序列的最大值;)对序列当中剩下的n-1个元素再次执行步骤1。对于长度为n的序列，一共需要执行n-1轮比较。

与选择排序的区别在于，冒泡排序是每次只比较左右两元素的大小，经过轮之后，保证序列最后的元素是最大值，需重复n-1轮；而选择排序是每轮选择所有元素中最小的元素，一轮之后可保证序列最前面的元素是最小值，重复n-1轮。两种排序方式从代码上看比较相近。

import java.util.Arrays;
import java.util.Scanner;
public class HelloWorld {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int[] arr = new int[sc.nextInt()];
		for(int i = 0; i< arr.length; i++){
			arr[i] = sc.nextInt();
		}
        for(int i = 0;i<arr.length;i++)
            for(int j = i+1;j<arr.length;j++)
                if(arr[j]<arr[i]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
        
        System.out.println(Arrays.toString(arr));
  
	}
}	

三、二维数组

（一）二维数组的初始化：

静态：

int[][] a={
            {92,85},
            {91,65},
            {90,33}//结尾不加逗号
};

动态：

//方式一：
int[][] a = new int[6][3];//生成六个一维数组，每个一维数组里有三个元素
//方式二（不规则数组的声明）：
int[][] a = new int[3][];//生成三个一维数组
a[0] = new int[3];//第一个数组里有三个元素
a[1] = new int[2];//第二个数组里有两个元素
a[2] = new int[5];//第三个数组里有五个元素

动态与静态初始化的区别在于：静态初始化指定了元素，明确数组的具体数据；动态初始化指定了数组的长度，明确数组中元素的个数。

（二）二维数组的遍历

for(int i = 0;i<a.length;i++) {
    for(int j = 0;j<a[i].length;j++) {
        System.out.println(a[i][j]);
    }
}

（三）修改二维数组的值

for(int i = 0;i<a.length;i++) {
    for(int j = 0;j<a[i].length;j++) {
        a[i][1] = 2;//表示将每个一维数组的第二个元素都改为2
        a[i][0] = 1;//表示将每个一维数组的第一个元素都改为1
    }
}    

以上方法可将二维数组中的元素全部改为{1,2}。

四、求数组中的最大元素

思路：定义变量max表示数组中的最大值，初值存为数组中的第一个元素，依次遍历数组中的元素，若比max值大则替换，循环结束后max值为数组的最大元素。

注意：i从1开始遍历数组，因为max的初值为数组的第一个元素，故从数组的第二个元素开始比较即可。

int[] arr = {23,45,766,76,9,0,88,7,22,7};
int max = arr[0];//定义变量max储存最大值
for(int i = 1;i<arr.length;i++){
    if(arr[i]>max)
        max = arr[i];
}

五、将n个整数逆序输出

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.next();
        int[] a = new int[n];//数组长度可以为变量
        for(int i = 0;i<n;i++)
            a[i] = sc.nextInt();
        for(int i = n-1;i>=0;i--)
            System.out.println(a[i]);
    }
}

六、找出数组中元素最小值和它的位置

输入一个整数 N和一个长度为 N的整数数组 ，找到数组中最小的元素，并输出它的值和下标。如果有多个最小值，则返回下标最小的那个。

输出格式

第一行输出 Minimum value: x，其中 x为数组元素最小值。

第二行输出 Position: y，其中 y为最小值元素的下标（下标从 00 开始计数）。

数据范围

1<N≤1000，−1000≤X[i]≤1000

思路：先初始化一个长度为n的数组并储存n个元素

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();//输入元素的个数

        int[] q = new int[n];//初始化一个长度为n的数组

        for(int i = 0; i < n; i ++)
            q[i] = sc.nextInt();//依次输入元素

所输入的元素范围在1到1000之间，故定义一个初值为1001的变量，若此变量的值大于数组中的元则将其值赋给变量，这样可以保证变量的值为数组中的元素，再遍历数组依此比较，循环结束后变量储存的值即为数组的最小值。

int value = 1001, p = 0;

        for(int i = 0; i < n; i ++){
            if (value > q[i]){
                value = q[i];//将数组中的值赋给变量
                p = i;
            }
        }
System.out.printf("Minimum value: %d\n", value);
System.out.printf("Position: %d", p);