第五节、数组

2021年11月24日 阅读数:6
这篇文章主要向大家介绍第五节、数组,主要内容包括基础应用、实用技巧、原理机制等方面,希望对大家有所帮助。

5.1数组的概念

数组:是一种容器,能够同时存放多个数据值。java

数组的特色:数组

  1. 数组是一种引用数据类型ide

  2. 数组当中的多个数据,类型必须统一。spa

  3. 数组的长度再程序运行期间不可改变code

5.2数组的定义格式

两种常见的初始化方式:对象

  1. 动态初始化(指定长度blog

  2. 静态初始化(指定内容索引

1、动态初始化数组的格式:字符串

数据类型[] 数组名称 = new 数据类型[数组长度];it

解析含义:

  • 左侧数据类型,也就是数组当中保存的数据,全都是统一的什么类型。

  • 左侧的中括号,表明我是一个数组

  • 左侧的数组名称,给数组取一个名字

  • 右侧的new:表明建立数组的动做

  • 右侧的数据类型:必须和左边的数据类型保持一致。

  • 右侧中括号的长度:也就是数组当中,到底能够保存多少个数据,是一个 int 数字。

 1 public class Demo01Array{
 2         public static void main(String[] args){
 3             //建立一个数组,里面能够存放300个 int 数据
 4             //格式:数据类型[] 数组名称 = new 数据类型 [数组长度];
 5             int [] arrayA = new int[300];
 6             
 7             //建立一个数组,能存放10个double类型的数据
 8             double[] arrayB = new double[10];
 9             //建立一个数组,能存放5个字符串
10             String[] str = new String[5];
11         }
12     }
13 /*
14 动态初始化(指定长度):在建立数组的时候,直接指定数组当中的数据元素个数。
15 静态初始化(指定内容):在建立数组的对象,不直接指定数据个数多少,而是直接将具体的数据内容进行指定。
16 17 静态初始化基本格式:
18 数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,....};
19 */
20 21 public class Demo02Array{
22     public static void main(String[] args){
23         //直接建立一个数组,里面装的全都是int数字,具体为五、1五、25
24         int[] arrayA = new int[]{5,15,25};//静态初始化
25         
26         //建立一个数组,用来装字符串,“Hello”、“world”、“java”
27         String[] arrayB = new String[]{"Hello","World","Java"};
28     }
29 }

 

2、省略的静态初始化

数据类型[] 数组名称 ={元素1,元素2,。。。};

注意事项

  1. 静态初始化没有直接指定长度,可是仍然会自动推算获得长度。

  2. 静态初始化标准格式能够拆分红为两个步骤。

  3. 动态初始化也能够拆分红为两个步骤。

  4. 静态初始化一旦使用省略格式,就不能拆分红为两个步骤了。

使用建议:

若是不肯定数组当中的具体内容,用动态初始化,不然,已经肯定了具体的内容,用静态初始化。

 1 public class Demo03Array{
 2     public static void main(String[] args){
 3         //省略格式的静态初始化
 4         int[] arrayA = {10,20,30};
 5         
 6         //静态初始化的标准格式,能够拆分红为两个步骤
 7         int[] array8;
 8         array8 = new int[]{11,21,31};
 9         
10         //动态初始化也能够拆分红为两个步骤
11         int[] arrayC;
12         arrayC = new int[5];
13         
14     }
15 }

 

3、动态初始化数组的默认值

规则以下

若是是整数类型,那么默认为0;

若是是浮点类型:那么默认值为0.0;

若是是字符类型,那么默认值为‘\u0000’;

若是是布尔类型,那么默认为false;

若是是引用类型,那么默认为null;

注意事项

静态初始化其实也有默认值的过程,只不过系统自动立刻将默认值替换成为了大括号当中的具体值。

5.3获取数组的长度

 1 /*
 2 * 如何获取数组的长度,格式:
 3 * 数组名称 .length
 4 *
 5 * 这将会获得一个 int 数字,表明数字的长度。
 6 * 数组一旦建立,程序运行期间,长度不可改变。
 7 * */
 8 public class Demo03ArrayLength {
 9     public static void main(String[] args) {
10         int[] arrayA = new int[3];//动态初始化
11 12         int[] arrayB = {10,20,30};//静态初始化
13         int len = arrayB.length;
14         System.out.println("arrayB 的数组长度是:"+len);
15         System.out.println("===========");
16 17         int[] arrayC = new int[3];
18         System.out.println(arrayC.length);//3
19         arrayC = new int[5];
20         System.out.println(arrayC.length);//5
21     }
22 }

 

5.4遍历数组

 1 public class Demo04Array {
 2     public static void main(String[] args){
 3         int[] array = {15,25,30,40,50};
 4  5         //首先使用原始方式
 6         System.out.println(array[0]);//15
 7         System.out.println(array[1]);//25
 8         System.out.println(array[2]);//30
 9         System.out.println(array[3]);//40
10         System.out.println(array[4]);//50
11         System.out.println("===============");
12 13 14         //使用循环,次数其实就是数组的长度
15         for (int i = 0; i < array.length; i++) {
16             System.out.println(array[i]);
17         }
18 19 20         //使用加强for循环
21         System.out.println("===============");
22         for(int i:array){
23             System.out.println(i);
24         }
25     }
26 }

 

5.5求出数组中的最大值

 1 public class Demo05ArrayMax {
 2     public static void main(String[] args){
 3         int[] array = {5,15,30,20,10000};
 4         int max = array[0];
 5         for (int i = 1; i < array.length; i++) {
 6             //若是当前元素大于max,则将该数赋值给max
 7             if(array[i] > max)
 8                 max = array[i];
 9         }
10         System.out.println("array数组中最大的数是:"+max);
11     }
12 }

 

5.6数组元素反转练习

  1. 数组元素反转,其实就是对称位置的元素交换。

  2. 一般便利数组用的是一个索引;

    int i = 0;

    如今表示对称位置须要两个索引;

    int min = 0;

    int max = array.length-1;

  3. 如何交换两个变量的值?

    int a = 10;

    int b = 20;

    第五节、数组_数据类型

     

    若是是两个水杯,都是满的,如何交换?借助第三个空杯子

    int temp = a;

    a = b;

    b = temp;

    第三个变量手。

    第五节、数组_数据类型_02

     

     

  4. 何时中止交换?

    1. min == max;

    2. min > max;

    3. max>min时交换

 1 /*
 2 * 数组元素的反转
 3 * 原本的样子:[1,2,3,4]
 4 * 以后的样子:[4,3,2,1]
 5 *
 6 * 要求不能使用新数组,就用原来的惟一一个数组
 7 * */
 8 public class Demo07ArrayReverse {
 9     public static void main(String[] args){
10         int[] array ={10,20,30,40,50};
11 12         //遍历打印数组原本的样子
13         for (int i = 0; i < array.length; i++) {
14             System.out.println(array[i]);
15         }
16         System.out.println("=================");
17 18         /*
19         * 初始化语句:int min = 0, max = array.length-1
20         * 条件判断:min < max
21         * 步进条件:min++,max--
22         * 循环体:用第三个变量到手*/
23         for(int min=0,max=array.length-1;min<max;min++,max--){
24             int temp = array[min];
25             array[min] = array[max];
26             array[max] = temp;
27         }
28         for (int i = 0; i < array.length; i++) {
29             System.out.println(array[i]);
30         }
31     }
32 }

 

5.7数组做为方法参数

 1 /*
 2 * 数组能够做为方法的参数。
 3 * 当调用方法的时候,向方法的小括号进行出传参,传递进去的实际上是数组的地址值。
 4 * */
 5 public class Demo01ArrayParam {
 6     public static void main(String[] args) {
 7         int[] array = {10, 20, 30, 40, 50};
 8         System.out.println(array); //地址值
 9 10         printArray(array);//传递进去的就是array当中保存的地址值
11         System.out.println("================AAA================");
12         printArray(array);
13         System.out.println("================BBB================");
14         printArray(array);
15     }
16 17     /*
18     * 三要素
19     * 返回值类型:只是进行打印而已,不须要进行计算,也没有结果,用void
20     * 方法名称:printArray
21     * 参数列表:必须给我数组,我才能打印其中的元素。int[] array*/
22     public static void printArray(int[] array){
23         System.out.println("printArray方法接收到的参数是:"+array);
24         for(int i:array){
25             System.out.println(i);
26         }
27     }
28 }

 

5.8数组做为方法的返回值

 1 import java.util.Scanner;
 2  3 /*
 4 一个方法能够有 0、一、多个参数,可是只能有0或1个返回值,不能有多个返回值。
 5 若是但愿一个方法当中产生了多个结果数据进行返回,怎么办?
 6 解决方案,使用一个数组做为返回值类型便可。
 7  8 任何数据类型都能做为方法的参数类型,或者返回值类型。
 9 10 数组做为方法的参数,传递进去的实际上是数据的地址值。
11 数组做为方法的返回值,返回的其实也是地址值。
12  */public class Demo02ArrayReturn {
13     public static void main(String[] args) {
14         int a,b,c;
15         Scanner sc = new Scanner(System.in);
16         System.out.println("请输入三个整数:");
17         a = sc.nextInt();
18         b = sc.nextInt();
19         c = sc.nextInt();
20         int[] result = calculate(a, b, c);
21 22         System.out.println("main方法收到的返回值数组是:");
23         System.out.println(result); //地址值
24         for(int i: result){
25             System.out.println(i);
26         }
27     }
28     public static int[] calculate(int a,int b, int c){
29         int sum = a+b+c; //总和
30         int avg = sum/3; //平均数
31         /*int[] array = new int[2];
32         array[0] = sum;
33         array[1] = avg;*/
34         int[] array = {sum,avg};
35         System.out.println("caculate方法内部数组是:");
36         System.out.println(array);//地址值
37         return array;
38     }
39 }

 

 

上一篇: 第五节
下一篇: JS学习-第五节