1.数组(Array),

多个相同类型的数据,按照一定的顺序排列的集合

并使用一个名字命名,并通过编号的方式对这些数据进行统一管理

2.数组的组成:

数组名

下标或索引

元素

数组的长度-->元素的个数

3.数组的特点:

数组是有序排列的

数组本身是引用数据类型,数组内的元素可以使任何数据类型(基本数据类型,引用数据类型)

创建数组对象会在内存中开辟一整块连续的空间.

数组的长度一旦确定,就不可以修改

4.数组的分类

按照维数: 1维数组,2维数组....

按照元素类型: 基本数据类型元素的数组.引用数据类型元素的数组

5.一维数组的使用

5.1. 一维数组的声明和初始化

// 一维数组的声明和初始化

int num;//声明

num = 10;//初始化

int id =1001;//声明+初始化

int[] ids; //声明

//1.1静态初始化:数组的初始化和数组元素的赋值操作同时进行

ids = new int[] {1001,1002,1003,1004};

//1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行

String[] names = new String[5];

5. 2. 如何调用数组指定位置的元素

//2.如何调用数组指定位置的元素:通过角标(索引)的方式调用

//数组的索引从0开始,到数组的长度-1结束

names[0] = "张0";

names[1] = "张1";

names[2] = "张2";

names[3] = "张3";

names[4] = "张4";

// names[5] = "张5";

5. 3. 如何获取数组的长度

//3.如何获取数组的长度. 使用length属性

System.out.println(names.length);

5. 4. 如何遍历数组

for(int i = 0; i < names.length; i ++) {

System.out.println(names[i]);

5. 5. 数组元素的默认初始化值

数组元素是整形: 默认值是 0

浮点型: 0.0

char类型: 看上去是个空格 ,实际值是0 char型都会有对应的ASCII 码, 所以默认值是asc码为0的字符,

boolean : false

数组元素是引用数据类型时: 默认值是null

6.二维数组的使用

数组本身是引用数据类型,可以看成是一维数组作为另一个数组的元素而存在

6.1二维数组的声明和初始化

//静态初始化

int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};

//动态初始化

String[][] arr2 = new String[3][2];

String[][] arr3 = new String[3][];

//特别的写法

int[][] arr = {{1,2,3},{4,5},{6,7,8}};

int[] arr4[] =new int[][]{{1,2,3},{4,5},{6,7,8}};

int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};

6.2如何调用数组指定位置的元素

System.out.println(arr1[0][1]);//2

System.out.println(arr2[1][1]);//由于未赋值String类型,是null

//System.out.println(arr3[1][0]); java.lang.NullPointerException

6.3 获取数组的长度

System.out.println(arr4.length);//3

System.out.println(arr4[0].length);//3

System.out.println(arr4[1].length);//2

6.4如何遍历二维数组

for(int i=0 ; i < arr4.length; i++) {

    for(int j = 0; j
        System.out.print(arr4[i][j]);

        }

    System.out.println();

}

6.5数组元素的默认初始化值

在数组 int[][] arr = new int[4][3]中,

//外层元素为,arr[0],arr[1]等

//内层元素为,arr[0][0],arr[1][2]等;

类型1:

外层元素的初始化值为地址值

内层元素的初始化值,与一维数组初始化情况相同

int[][] arr = new int[4][3];

System.out.println(arr[0]); //[I@7f63425a,是地址值

System.out.println(arr[0][0]); //0 内层元素是int类型,

System.out.println(arr); //[[I@36d64342

int型默认值为: 0

float : 0.0

Stirng : null

类型2:

double[][] arr3 = new double[4][];

System.out.println(arr3[1]); //null,因为未赋值

System.out.println(arr3[1][0]); //报错空指针,因为还未初始化

外层元素的初始化值为 null

内层元素的初始化值, 不能调用,否则会报空指针

7.数组使用中常用的算法

7.1数组元素的赋值(杨辉三角,回形数等)

Scanner scan = new Scanner(System.in);

//练习1，求二维数组所有元素的和

int[][] array = new int[][] {{3,-5,6},{2,8},{9,-2,5,7}};

int sum = 0;

for (int i = 0; i < array.length; i++) {

for (int j = 0; j < array[i].length; j++) {

sum += array[i][j];

}

}

System.out.println("二维数组的所有元素和是" + sum);

/*练习2，

* int[] x,y [];//此时表示声明x为一维数组，y为二维数组

* 因为 int[] a,b = int[] a 与 int[] b ,也就是 int[] x, int[] y[]

* 在给x与y赋值后，以下选项可以编译通过的是

* 1，x[0] = y; // no

* 2,y[0] = x; // yes

* 3,y[0][0] = x;// no

* 4,x[0][0] = y,// no

* 5,y[0][0] = x[0];// yes

* 6,x = y//no

* 数组赋值需要满足相同类型或者可以自动类型提升

*/

//练习三，使用二维数组打印一个指定行数杨辉三角

/*

* 1，第一行一个元素，第n行n个元素

* 2，每一行的第一个和最后一个是1

* 3，从第三行开始，对于非第一个元素和最后一个元素有

* yanghui[i][j]=yanghui[i-1][j-1] + yanghui[i-1][j]

*/

//思路，对二维数组声明赋值后打印

//输入行数

System.out.println("请输入要打印的杨辉三角行数");

int line = scan.nextInt();

int[][] array1 = new int[line][];//动态声明二维数组行数

//声明赋值二维数组

for (int i = 0; i < array1.length; i++) {

array1[i] = new int[i+1];//声明每行列数

array1[i][0] = 1;//每行第一个元素是1

array1[i][i] = 1;//每行最后一个元素是1

//可以写成连续赋值的形式array1[i][0] = array[i][i] = 1;

//

for (int j = 0; j < array1[i].length; j++) {

if(j > 0 && j < i) {

array1[i][j]=array1[i-1][j-1] + array1[i-1][j];//每行其他元素满足杨辉三角要求

}

}

/*第二种写法，if在外层

* if(i > 1){

* for(j = 1;j < array[i].length - 1;j++){

* array1[i][j]=array1[i-1][j-1] + array1[i-1][j];

* }

* }

*/

}

//遍历输出杨辉三角

for (int i = 0; i < array1.length; i++) {

for (int j = 0; j < array1[i].length; j++) {

System.out.print(array1[i][j] + " ");

}

System.out.println();

}

7.2求数值型数组中元素的最大值,最小值,平均数,总和

（要求所有元素都是两位数）

int[] arr = new int[10];

for(int i = 0; i
arr[i]=(int)(Math.random()*(99-10+1)+10);

}

//遍历

for(int i =0; i
System.out.println(arr[i]+"\t");

}

//求数组的最大值

int maxValue = arr[0]; //

for(int i= 0; i< arr.length;i++) {

if(maxValue < arr[i]) {

maxValue = arr[i];

}

}

System.out.println("最大值为" + maxValue + "\t");

//求数组的最小值

int minValue = arr[0];

for(int i= 0; i< arr.length;i++) {

if(minValue > arr[i]) {

minValue = arr[i];

}

}

System.out.println("最小值为" + minValue + "\t");

//求数组的总和

int sum = 0;

for(int i= 0; i< arr.length;i++) {

sum += arr[i];

}

System.out.println("总和最小值为" + sum + "\t");

//求数组的平均数

int avgValue = sum / arr.length;

System.out.println("平均数为" + avgValue );

7.3数组的复制,反转,查找(线性查找,二分法查找)

String[] arr = new String[]{"AA","BB","CC","DD","EE","FF","GG"};

//数组的复制(区别于数组的赋值, arr=arr1)

String[] arr1 = new String[arr.length];

for(int i = 0;i
arr1[i] = arr[i];

//System.out.println(arr[i]);

//System.out.println(arr1[i]);

}

//数组的反转,利用一个临时变量

for(int i = 0; i < arr1.length / 2; i++){

String temp = arr[i];

arr[i] = arr[arr.length -i - 1];

arr[arr.length - i -1] =temp;

}

//遍历

for(int i = 0; i < arr1.length; i++){

System.out.println(arr[i] + "\t");

}

}

//查找

//线性查找:

String dest = "BB";

boolean isFlag = true;

for(int i = 0; i < arr1.length; i++){

if(dest.equals(arr[i])){

System.out.println("找到了指定的元素,位置为:" + i);

isFlag = false;

break;

}

}

if(isFlag){

System.out.println("很遗憾,没找到");

}

注:

若有2个数组,array1,array2.

array1 = array2;

并不是复制,而是将array1指向堆中array2所指向的地址.所以修改array1,array2也会变化

所以数组的复制,需要new一个新的数组,然后进行元素的赋值array1[i]=array2[i]

12.数组