【Java笔记】数组的处理方法（详细整理，含注释）

数组是一种数据结构，用来存储同一类型值的集合，通过一个整型下标可以访问数组中的每一个值
如果a是一个整型数组，a

创建一个数组

int[] a =new int[10];
这条语句创建了一个可以存储10个整数的数组

//有三种方法可以声明一个数组
String[] aArray = new String[5];
String[] bArray = {"a","b","c", "d", "e"};   
String[] cArray = new String[]{"a","b","c","d","e"};

给数组元素赋值

int[] a =new int[10];
for(int i=0;i<10;i++){
	a[i]=i;
}
//这里也可以用i < a.length代替i < 10

创建一个数字数组时，所有元素都初始化为0。boolean数组的元素会初始化为false。表示这些元素还没有存放任何对象。

打印一个数组

//单行代码直接打印
package test.ArrayDemo;
import java.util.Arrays;
public class ArrayDemo2 {
    public static void main(String[] args) {
        int[] i =  {1,2,3,4,5};
        String s = Arrays.toString(i);
        System.out.println(i); //打印数组的地址值
        System.out.println(s); //打印数组元素值
        //System.out.println(Arrays.toString(i))；
    }
}

结果为

//循环打印
int[] aa = {1,2,3};
for(int i=0;i<aa.length;i++){
	System.out.println(aa[i]);
}

结果为

for each循环

int[] arr ={0,1,2,3,4};
for(int i=0;i<arr.length;i++){
	System.out.println(arr[i]);
}
for(int a1:arr){
	System.out.println(a1);
}

这两个循环的结果是一样的，都是打印从0到4的数值

数组复制（复制地址）

在Java中，允许将一个数组变量拷贝给另一个数组变量。这时，两个变量将引用同一个数组

package test;
public class ArrayDemo1 {
    public static void main(String[] args) {
        //定义第二个数组的时候把第一个数组的地址赋值给第二个数组
        int[] arr1 = new int[2];
        int[] arr2 = arr1;
        //对arr1进行赋值并打印
        arr1[0] = 1;
        arr1[1] = 2;
        System.out.println(arr1[0]+" "+arr1[1]);
        //修改arr2[0]中的值为3，打印arr1和arr2
        arr2[0] = 3;
        System.out.println(arr1[0]+" "+arr1[1]);
        System.out.println(arr2[0]+" "+arr2[1]);
    }
}

结果为

可以发现，arr1和arr2指向的是同一个地址，所以修改arr2中的值，
arr1中的值也会被改变

数组复制（复制值）

如果希望将一个数组的所有值拷贝到一个新的数组中去，就要使用Arrays类的copyOf()方法与copyOfRange()方法

copyOf()方法是复制旧数组里面的值到指定长度的新数组中。
copyOfRange()方法是将指定数组的指定长度复制到一个新数组中。

1、copyOf()方法 —— copyOf(arr,int newlength)

package test.ArrayDemo;
import java.util.Arrays;
public class ArrayDemo3 {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
//旧数组arr中的值被复制到了指定长度为5的新数组中
        int[] new_arr = Arrays.copyOf(arr,5);
        for(int i : new_arr){
            System.out.println(i);
        }
    }
}
/*
如果数组元素是数值型，那么多余的元素将被赋值为0；如果数组元素是布尔型，则将赋值为false。
相反，如果长度小于原始数组的长度，则只拷贝最前面的数据元素。
*/

结果为

其实像下面这样输出更好看一些
System.out.println(Arrays.toString(new_arr));

2、copyOfRange()方法 —— copyOfRange(arr, int start, int stop); 后面两个参数定义从旧数组中截取从哪到哪的数值

package test.ArrayDemo;
import java.util.Arrays;
public class ArrayDemo3 {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        int[] new_arr = Arrays.copyOfRange(arr,0,2);
        System.out.println(Arrays.toString(new_arr));
    }
}

结果为

数组元素查找(查找指定元素第一次在数组中出现的索引)

package test1;
import java.util.Scanner;
public class ArrayDemo1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int input = sc.nextInt();
        int[] a = {12,34,25,31,15};
        for(int i=0;i<a.length;i++){
            if(a[i]==input){
                System.out.println("索引是"+i);
                break;
            }
            if(i==a.length-1 && a[i]!=input){
                System.out.println("not found!");
            }
        }
    }
}

结果为

反转数组

//方法一

package test.ArrayDemo;
import java.util.Arrays;
public class ArrayDemo2 {
    public static void main(String[] args) {
        int[] i =  {1,2,3,4,5};
        System.out.println(Arrays.toString(i));
        int l = i.length;
        int[] m = new int[l];
        int count = 0;
        for(int n=l-1;n>=0;n--){
            m[count] = i[n];
            count++;
        }
        System.out.println(Arrays.toString(m));
    }
}

结果为

上面的代码可以简化为

int[] arr= {6,7,8,9,10};
for(int s=0,e=arr.length-1; s<=e; s++,e--) {
	int temp = arr[s];
	arr[s] = arr[e];
	arr[e] = temp;
	}
System.out.println(Arrays.toString(arr));

结果是一样的

//方法二

int[] arr= {6,7,8,9,10};
for(int x=0; x<arr.length/2; x++) {
    int temp = arr[x];
    arr[x] = arr[arr.length-1-x];
    arr[arr.length-1-x] = temp;
    }
System.out.println(Arrays.toString(arr));

结果为

数组排序

int[] a = {12,5,16,53,42};
Arrays.sort(a);
System.out.println(Arrays.toString(a));

结果为

冒泡排序

package test1;

import java.util.Arrays;

public class BubbleSort1 {
    public static void main(String[] args) {
        int[] a = {12,5,16,53,42};
        int temp;
        for(int i=0;i<a.length-1;i++){
            for(int j=0;j<a.length-1-i;j++){
                if(a[j+1]>a[j]){
                    temp = a[j+1];
                    a[j+1] = a[j];
                    a[j] = temp;
                }
            }
        }
        for(int n:a){
            System.out.println(n);
        }

    }
}

这里详细的解释一下，首先创建一个一维数组，里面的值为12,5,16,53,42，要想让数组按从大到小的顺序排列，就让数组之间的元素两两比较，先让最小的那个数字换到数组的最后面，就跟冒泡一样让最小数浮上去。然后以此类推，最小的数字到最后面后，剩下的几个数字再次两两比较，让最小的数字到倒数第二个位置。

具体的实现方法是双重for循环，外层for循环决定了两两对比几次，因为每一轮外循环结束后，都要有一个最小数到后面，剩下的数字再两两比较。而内层for循环则决定着具体比较的是哪两个数。如果下一个数字a[j+1]大于当前数字a[j]，那么两者交换位置。

关于循环里面的条件，外层for循环的条件是i 内层for循环的条件是j

最后的结果为

二维数组

二维数组就是元素为一维数组的数组
语句格式为：
数据类型[][] 变量名 = new 变量名[m][n] ;

m表示的是这个二维数组有多少个元素，其中每一个元素都是一个一维数组
n表示的是这个二维数组中每个元素，也就是每个一维数组的长度

遍历二维数组的值

package test1;
public class ArrayDemo4 {
    public static void main(String[] args) {
        int[][] a = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
        for(int i=0;i<a.length;i++){
            for(int j=0;j<a[i].length;j++){
                System.out.println(a[i][j]);
            }
        }
    }
}

结果为

二维数组输出杨辉三角

package test1;
import java.util.Scanner;
public class ArrayDemo5 {
    public static void main(String[] args) {
        //获取你想打印多少行杨辉三角
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        //规律一，n行等于n列
        int[][] arr = new int[num][num];
        //规律二，每一行的第一列和最后一列的元素是1
        for(int i=0;i<arr.length;i++){
            arr[i][0] = 1;
            arr[i][i] = 1;
        }
        //规律三，这一行的数据等于上一行的上一列+上一行的同一列
        for(int i=2;i<arr.length;i++){
            for(int j=1;j<i;j++){
                arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
            }
        }
        //打印二维数组，输出最后的结果
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<=i;j++){
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

结果为

杨辉三角的规律是

1. 如果是n行，那么最后一行是n列。
2. 每一行的第一列和最后一列的元素是1。
3. 每一行的第二列开始数据是：上一行的上一列+上一行的同一列