java数组使用的好处_java数组的使用

[TOC]

本单元目标

1、数组的特点和好处

2、数组的使用步骤 ★

3、数组的基本使用 ★

求和、求最值、查找、排序

4、数组的复杂使用 ★

赋值、反转

5、数组的高级使用

增删改查

6、二维数组

1、数组的特点和好处

1.1、概念

数组：其实就是一个容器，和变量很像。变量只能保存一个数，而数组可以保存一组数.

1.2、好处

1、同时开辟多个空间，语句更加简洁，且提高效率

2、分类存储，而且数组中的空间都是连续的，所以查找比较方便

1.3、特点

1、数组是多个相同类型数据的组合，实现对这些数据的统一管理

2、数组中的元素可以是任何数据类型，包括基本类型和引用类型(定义)

3、数组属引用类型，数组型数据是对象(object)，数组中的每个元素相当于该对象的成员变量

数组名又称为对象名或引用名

注意：引用类型的变量名(也叫对象名)存放在栈中，值(也叫对象)存放在堆中！

基本类型的变量名和值都存放在栈中

image

1.4、数组的四要素

1、数组类型

2、数组名(对象名或引用)

3、数组元素(多个)

4、下标(从0开始，到数组的长度-1)

访问数组的元素，不是仅仅通过数组名,而是通过数组名+下标

语法：score[下标]

2、数组的使用步骤

2.1、数组的动态初始化

class ArrayDemo1

{

public static void main(String[] args)

{

//步骤1：声明(仅仅告诉jvm要开辟房间保存多个元素)

//语法：数据类型[] 数组名;或 数据类型 数组名[];

int[] arr;

//步骤2：开辟空间(在堆中开辟指定长度的空间,并且系统自动为每个成员赋予初始值)

//语法：数组名 = new 数据类型[长度];

/*

int 0

double 0.0

char \u0000

boolean false

String null

*/

arr = new int[5];

//可以合二为一

int[] arr2 = new int[5];

//步骤3：手动赋值

arr[0] = 100;//为数组中的第一个成员赋值

arr[1] = 300;//为数组中的第二个成员赋值

arr[2] = 900;//为数组中的第三个成员赋值

//arr[5] = 10000; ArrayIndexOutOfBoundsException

//arr={1,2,3};错误

//步骤4：使用

System.out.println(arr);//[I@7852e922 相当于 地址号

System.out.println(arr[0]);

System.out.println(arr[1]);

System.out.println(arr[1]);

}

}

//此类用于演示数组的动态初始化——赋的值有规律

class Test_

{

public static void main(String[] args)

{

//1.声明并开辟空间

int[] arr = new int[5];

//2.赋值

for(int i=0;i

arr[i] = (int)(Math.random()*100+1);

}

//3.使用

for(int i=0;i

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

}

}

}

1、声明

数据类型[] 数组名;或

数据类型 数组名[];

2、开辟空间

数组名 = new 数据类型[长度];//长度必不可少

3、手动赋值

数组名[下标] = 值;

4、使用(打印、运算、判断等)

System.out.println(数组名[下标]);

注意事项：

①数组的元素如果不赋值，也有默认值

int 0

double 0.0

char \u0000

boolean false

引用类型 null

②访问数组的元素时，下标必须在0——长度-1 的范围内，否则报数组下标越界的异常

③数组的长度，可以通过 数组名.length表示，提高代码的维护性

④数组的赋值和使用，往往可以通过搭配for循环一起操作

for(int i=0;i

//每一个元素表示为：数组名[i]

}

案例：

​ 求一个班级10名同学的平均分

import java.util.Scanner;

//此类用于演示数组的动态初始化——赋的值有规律

class Test_

{

public static void main(String[] args)

{

Scanner intput = new Scanner(System.in);

double[] scores = new double[10];

for(int i=0; i

scores[i] = intput.nextDouble();

}

double sum=0;

for(int i=0;i

sum += scores[i];

}

double mean = sum /scores.length;

System.out.println(mean);

}

}

2.2、数组的静态初始化

步骤1：声明并初始化

语法：数据类型[] 数组名 = new 数据类型[]{值，值，值};

或 数据类型[] 数组名 = {值，值，值};

int[] arr = {3,4,5,6,100};

//int[] arr2 = new int[] {3,4,5,6,100};

‘A’+1 转换为66

(char)('A'+1) 转为B

步骤2：使用

for(int i=0;i

//每一个元素表示为：数组名[i]

}

3、数组的基本使用

3.1、数组的最值

class ArrayUtils1

{

public static void main(String[] args)

{

//1.声明并初始化

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

//2.使用：求最大值

//①定义一个max，初始化为第一个元素

int max = arr[0];

int maxIndex = 0;//记录最大值的下标

//②车轮战术，进行和max的pk

for(int i=1;i

if(arr[i]>=max){

max=arr[i];

maxIndex = i;

}

}

//③获取max

System.out.println("最大值："+max+"，下标："+maxIndex);

}

}

3.2、数组的查找

class ArrayUtils1_2

{

public static void main(String[] args)

{

Scanner input = new Scanner(System.in);

//1.声明并初始化

String[] names = {"白眉鹰王","青易斧王","金毛狮王","紫衫龙王"};

//2.查找

System.out.println("请输入你要查找的名:");

String search = input.next();

//----------------核心的查找------------

/*

查找：线性查找、二分查找

线性查找：依次将数组中的元素提取出来和要查找进行匹配

二分查找：要求待查找的数组已经排好序，查找效率较高

*/

boolean flag = false;

for(int i=0;i

if(names[i].equals(search)){//找到了

System.out.println("找到了，下标是："+i);

flag = true;

break;

}

}

if(!flag){

System.out.println("没找到");

}

}

}

3.3、数组的排序

image

//冒泡排序：每次比较相邻两个数 小的交换到前面 每轮结束后最大的数交换到最后

class ArrayUtils1_3

{

public static void main(String[] args)

{

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

//排序

/*

i j

0 0 arr[0] vs arr[1]

1 arr[1] vs arr[2]

2 arr[2] vs arr[3]

3 arr[3] vs arr[4]

*/

for(int i=0;i

//循环操作：每一轮发生的事情

for(int j=0;j

//循环操作：每一次发生的事情(比较)

if(arr[j]

//交换两个相邻元素

int temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

}

}

}

//打印

for(int i=0;i

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

}

System.out.println();

}

}

4、数组的复杂使用

4.1、数组的赋值

image

基本类型的赋值：

int a = 10;

int b = a;//赋值

引用类型的赋值：

int[] arr1={1,2,3};

int[] arr2=arr1;//赋值

特点：

基本类型的赋值，赋的是值(内容)，其中一个变量对其更改不影响另外一个

引用类型的赋值，赋的是地址，两个引用共同指向一个地址(对象)，所以其中一个引用对其更改影响另外一个

//注意：如果希望引用类型赋值时，只赋内容，则可以使用循环赋值的方式，语法：

int[] array2 = new int[array1.length];

for(int i=0;i

array2[i] = array1[i];

}

4.2、数组的反转

方式一：

for(int i=0;i

//交换两个数 i vs arr.length-1-i

int temp = arr[i];

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

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

}

方式二：

//①创建一个新数组，长度=arr.length

int[] newArr = new int[arr.length];

//②逆序赋值

/*

i

0 arr.length-1

1 arr.length-2

*/

for(int i=0,j=arr.length-1;i

newArr[j]=arr[i];

}

//③将新数组的地址赋值给arr

arr=newArr;

5、数组的高级使用

5.1、数组的添加

//----------------具体的添加业务----------

//①新建一个数组，长度=arr.length+1

int[] newArr = new int[arr.length+1];

//②依次为新数组的元素赋值

for(int i=0;i

newArr[i] = arr[i];

}

//③将add赋值到新数组的空位上

newArr[newArr.length-1] = add;

//④将newArr的地址赋值给arr

arr = newArr;

System.out.println("添加成功！");

5.2、数组的插入

class Test_

{

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

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

for(int i=0;i

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

}

int add = input.nextInt();

int index = input.nextInt();

//1 创建一个新数组 长度 = arr.length+1

int[] new_arr = new int [arr.length+1];

//2 循环赋值

for(int i=0;i

new_arr[i] = arr[i];

}

//3 循环后移

for(int i=new_arr.length-1;i>index;i--) {

new_arr[i] = new_arr[i-1];

}

//4 将新元素赋值到index位置上

new_arr[index] = add;

// 5 将new的数组赋值给arr

arr = new_arr;

for(int i=0;i

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

}

}

}

6、二维数组

6.1、理解

二维数组其实就是 一维数组的组合,也就是一维数组的定义类型又为一维数组

​

int[][] num;

int[] num[];

int num[][];

6.2、使用步骤

方式一：动态初始化

​

​ 1.声明

​

数据类型[][] 数组名;或

数据类型 数组名[][];

数据类型[] 数组名[];

2.开辟空间

情况1：固定列数

数组名 = new 数据类型[行数][列数];

情况2：不固定列数

数组名 = new 数类型[行数][];

3.赋值

情况1：固定列数

for(int i=0;i

for(int j=0;j

nums[i][j]=值;

}

}

情况2：不固定列数

for(int i=0;i

nums[i]=new 数据类型[长度]; //开辟空间

for(int j=0;j

nums[i][j]=值;

}

}

方式二：静态初始化

1.声明并初始化

数据类型[][] 数组名={{},{},{}};

或

数据类型[][] 数组名=new 数据类型[][]{{},{},{}};

2.使用(打印、求和、最值)

for(int i=0;i

for(int j=0;j

System.out.print(nums[i][j])；

}

}

​