数组
数组的定义
数组声明创建
首先必须声明数组变量,才能在程序中使用数组。下面是声明数组变量的语法
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);