数组的理解之使用-CSDN博客

本文链接：https://blog.csdn.net/H_Mani/article/details/115666477

本文详细介绍了Java中的数组，包括定义、声明、创建、访问、初始化、默认值、数组长度、边界检查以及如何使用数组。讲解了如何通过for-each循环遍历数组，以及如何进行数组元素的赋值、求和、查找最大值等操作。还涉及到了二维数组的概念，并给出了二维数组的示例。此外，文章还展示了冒泡排序算法的实现，以及一个数组排列组合的计数问题。

摘要由CSDN通过智能技术生成

数组

数组的定义

数组是想同类型数据的有序集合。
数组描述的是想同类型的若干个数据，按照一定的先后次序排列组合而成。
其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。

数组声明创建

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法

int[] sums;   //首选方法
或
int sums[];  //效果相同，但不是首选方法

java语言使用new操作符来创建数组，语法如下：

int[] sums = new int[10];

数组的元素是通过索引访问的，数组索引从0开始。

获取数组长度：变量名 .length

类名
    方法
    int[] nums;  //1.声明一个数组
    nums = new int[10];  //2.创建一个数组
     //int[] nums =new int[10];       边声明边创建

   //3.给数组元素中赋值
    nums[0] = 1;
    nums[1] = 2;
    nums[2] = 3;
    nums[3] = 4;
    nums[4] = 5;
    nums[5] = 6;
    nums[6] = 7;
    nums[7] = 8;
    nums[8] = 9;
    nums[9] = 10;

    System.out.println(nums[0]);   //  输出 1     没有赋值的数组就是默认值 0

   // 计算所有元素的和
    int sum = 0;
   //获取数组的长度； .length
   for(int a =0; a < nums.length;a++){
       sum = sum+nums[a];
   }
System.out.println("总和是："+sum)

三种初始化

静态初始化

int[] a ={1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};

动态初始化

int[] a =new int[2];
a[0]=1;
a[1]=2;

数组默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化.

数组边界

下标的合法区间： [0，length-1]，如果越界就会报错；

public static void main(String[]args){
    int[] a = new int[2];
    System.out.println(a[2]);   //如果输入a[3] 就会报错
}        
        //Array Index Out Of Bounds Exception  :  数组下标越界异常！

数组是相同数据类型（数据类型可以为任意类型）的有序集合
数组也是对象，数组元素相当于对象的成员变量

数组长度的确定的，不可变的，如果越界，则报错；Array Index Out Of Bounds

数组使用

For-Each 循环
数组作方法入参
数组作返回值
普通的For循环

类名
    方法
    int[] arrays={1,2,3,4,5};
   //打印全部的数组元素
 for(int a=0;a<arrays.length;a++){
     System.out.println(arrays[a]); //1  2  3  4  5
 }
  //计算所有变量元素的和
  int sum =0;
 for(int a =0; a<arrays.length;a++){
     sum+ = arrays[a];
 }
   System.out.println("总和是："+sum);    //15
   //查找最大元素
   int max = arrays[0];
   for(int a =1;a<arrays.length;a++){
       if(arrays[a]>max){
           max=arrays[a];
       }
   }
  System.out.println("最大元素是："+max);   //5

类名
    方法
    //反转数组
    int[] reverse =reverse(arrays);
    printArray(reverse);

  //反转数组
public static int[] reverse(int[]arrays){
    int[] result = new int[arrays.length];
    //反转操作
    for(int a =0,j=result.length-1; a<arrays.length; a++,j--){
        result[j] = arrays[a];
    }
    return result;
}   //5 4 3 2 1

=========================================================================
    //打印数组元素
    
    public static void prinArray(int[]arrays){
    for(int a=0;a<arrays.length;a++){
        System.out.print(arrays[a]+" ")
    }
}

二维数组

int a[][] = new int[2][5];

解析：以上二维数组a 可以看成一个两行五列的数组。

多维数组：可以看成是数组的数组，比如二维数组就是一个特殊的一堆数组，其每一个元素都是一个一堆数组。

类名
    方法
    //[4][2]
    /* 1,2   array[0]
       2,3   array[1]
       3,4   array[2]
       4,5   array[3]
    */
    int[][] array = {{1,2},{2,3},{3,4},{4,5}};
    printArray(array[0]);  // System.out.println(array[0][0]);   //   1
}                          //   System.out.println(array[0][1]);   // 2
public static void prinArray(int[]arrays){
    for(int a=0;a<arrays.length;a++){
        System.out.print(arrays[a]+" ")
    }   //1,2
}
  System.out.println(array.length);    //  4
  System.out.println(array[0].length); //  2
------------------------------------------------------------------------------
    +
   int[][] array = {{1,2},{2,3},{3,4},{4,5}};

  for(int i=0; i<array.length;i++){
      for(int j=0; j <array[i].length;j++){
          System.out.println(array[i][j]);
  }
      1
      2
      2
      3
      3
      4
      4
      5

拓展

冒泡排序笔试考题

冒泡排序无疑是最为出名的排序算法之一，总共有八大排序！

冒泡的代码还是相当简单的，两层循环，外层毛冒泡轮数，里层依次比较，江湖中人人皆知。
我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为零的n次方.

类名
   方法
    //冒泡排序
    // 1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
    //  2.每一次比较，都会产生出一个最大或者一个最小的数字
    //  3.下一轮则可以少一次排序
    //  4.一次循环，直到结束
          //定义一个数组
    	  int[] array ={1,4,6,55,35,24,885,6,5,12} ;
	 
		// 临时变量，因为后面需要交换位置
		int temp =0;
		
		//外层循环，判断我们这个要走多少次；
      //i可以理解为比较的两个数中的前面那个，不能是最后的
		for(int i=0;i<array.length-1;i++){
			//内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置
            //j 可以理解为比较中的两个数的 后面的那个数
			for(int j=0;j<array.length-1-i;j++){
				if(array[j+1]<array[j]){
					temp = array[j];
					array[j] = array[j+1];
					array[j+1] =temp;
				}
			}
		}
		System.out.print("排序后："+Arrays.toString(array));
	}

类名
   方法
   // 数组 1、2、3、4能够组成多少个不同的排列

int d=0;
for(int a =1;a<5;a++){
	for(int b =1;b<5;b++){
		for(int c =1;c<5;c++){
			if(a!=b && b!=c && a!=c){
				System.out.println(""+a+b+c);
				d++;
			}
		}
	}
}
      System.out.println("共计："+d);