数组初始化及访问获取元素

  1. package com.besttest.class1;
  2. /*
  3. *数组的概念：是一种容器，可以同时存放多个数据值
  5. *数组的特点：
  6. 1.数组是一种引用数据类型
  7. 2.数组当中的多个数据，类型必须统一
  8. 3.数组长度在程序运行期间不可改变 
  10. *数组的初始化，在内存中创建一个数组，并且向其中赋予一些默认值
  11. 两种常见的初始化方式：
  12. 1.动态初始化（指定长度）
  13. 2.静态初始化（指定内容）
  15. 动态初始化数组的格式：
  16. 数据类型[] 数组名称 = new 数组名称[数组长度]
  18. 解析含义：
  19. 左侧数据类型，也就是数组中保存的数据，全部都是统一的类型
  20. 左侧的中括号，代表我是数组
  21. 左侧的数组名称，给数组取一个名字
  22. 右侧的new，代表创建数组的动作
  23. 右侧的数据类型，必须和左边的数据类型保持一致
  24. 右侧中括号的长度，也就是数组当中，到底可以保存多少个数据，是一个int数字
  26. 静态初始化数组的格式：
  27. 数据类型[] 数组名称 = new 数组名称[]{元素1,元素2,...}
  28. 【注意事项】：
  29. 1.虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，可以直接推算出长度
  30. 2.静态初始化标准格式可以拆分成两个步骤
  31. 3.动态初始化可以拆分成两个步骤
  32. 4.静态初始化一旦使用省略格式就不能拆分成两个步骤
  33. 静态初始化数组的省略格式：
  34. 数据类型[] 数组名称 = {元素1,元素2,...}
  36. * 访问数组元素进行获取
  37. 直接打印数据名称，得到的时候数组对应的内存地址哈希值  二进制：0,1；十进制：0123456789；十六进制：0123456789abcdef
  38. 访问数组元素的格式：数组名称[索引值]
  39. 【注意】：索引从0开始，直到“数组长度”-1为止
  41. * 访问数组元素进行赋值
  42. 访问动态初始化数组的时候，其中的元素将会主动拥有一个默认值。规则如下：
  43. 如果是整数类型，默认为0；
  44. 如果是浮点型，默认为0.0；
  45. 如果是字符类型，默认为”\ue0000“；
  46. 如果是布尔型，默认为false；
  47. 如果是引用类型，默认为null；
  48. 【注意事项】：静态初始化其实也有默认值，只不过系统马上将默认值替换为了当中的具体数值
  49.  */
  50. import java.util.Arrays;
  52. public class ArrayDemo {
  53.     public static void main(String[] args) {
  54.         //1、数组的声明
  55.         int[] arr;
  56.         //2、数组的初始化
  57.         int[] arr1={1,2,3};
  58.         //直接打印数组名称  ----[I@1b6d3586  （@后的是16进制）
  59.         System.out.println(arr1);
  60.         //创建一个空数组 长度为4 默认为0 0 0 0
  61.         int[] arr2=new int[4];
  62.         //3、数组的访问
  63.         int x=arr1[2];    //取出下标为2的元素
  64.         //4、长度
  65.         int[] arr3={1,3,2,5};
  66.         int count=arr3.length;
  67.         System.out.println(count);
  68.         //5、元素的初始化操作
  69.         int[] arr4 =new int[5];
  70.         for(int i=0;i<arr4.length;i++){
  71.             arr4[i]=i+1;
  72.         }
  73.         //6、打印数组    import java.util.Arrays;
  74.         System.out.println(Arrays.toString(arr4));
  75.     }
  76. }

数组长度在程序运行期间不可改变 

  1. package com.besttest.class1;
  3. public class Demo01Array {
  4.     public static void main(String[] args) {
  5.         int [] arr1 = new int[3];
  6.         System.out.println(arr1.length);  //3
  7.         arr1=new int[5];
  8.         System.out.println(arr1.length);  //5
  9.     }
  10. }

image.png

求数组中的最值

最大值：

  1. public class Demo01Array {
  2.     public static void main(String[] args) {
  3.         int[] arr1={1,2,3,32,34,55,1,2};
  4.         int max=arr1[0];
  5.         for (int i=1;i<arr1.length;i++){
  6.             if (arr1[i]>max){
  7.                 max=arr1[i];
  8.             }
  9.         }
  10.         //最后输出的最大值
  11.         System.out.println( max);
  12.     }
  13. }

最小值：

  1. public class Demo01Array {
  2.     public static void main(String[] args) {
  3.         int[] arr1={12,2,3,32,34,55,10,2};
  4.         int min=arr1[0];
  5.         for (int i=1;i<arr1.length;i++){
  6.             if (arr1[i]<min){
  7.                 min=arr1[i];
  8.             }
  9.         }
  10.         //最后输出的最大值
  11.         System.out.println( min);
  12.     }
  13. }

数组元素反转

image.png

  1. package com.besttest.class1;
  3. import java.util.Arrays;
  5. /*
  6. 数组[12,23,34,54,6]
  7. 翻转之后[6,54,34,23,12]
  8. 要求只能有一个数组
  10. 利用第三个值交换
  11.  */
  12. public class Demo01Array {
  13.     public static void main(String[] args) {
  14.         int[] arr1={12,23,34,54,6};
  15.         //遍历数组本来的样子
  16.         for (int i=1;i<arr1.length;i++){
  17.             //最后输出的最大值
  18.             System.out.println(arr1[i]);
  19.         }
  20.         /*
  21.         初始化语句：int min=0,max=arr1.length
  22.         条件判断：min<max
  23.         循环体：用三个变量倒手
  24.          */
  25.         for (int min=0,max=arr1.length-1;min<max;max--,min++){
  26.             int temp=arr1[min];
  27.             arr1[min]=arr1[max];
  28.             arr1[max]=temp;
  29.         }
  30.         System.out.println(Arrays.toString(arr1));
  31.     }
  32. }

数组作为方法参数_传递

  1. package com.besttest.class1;
  2. /*
  3. 数组可以作为方法的参数
  4. 当地调用方法的时候，向方法的小括号进行传参，传递进去的其实就是数组的地址值
  5.  */
  6. public class DemoArrayParm {
  7.     public static void main(String[] args) {
  8.         int[] arr1={1,2,3,4,5};
  9.         System.out.println(arr1);   //地址值
  10.         printarray(arr1);   //传递进去的就是数组当中保存的地址
  11.     }
  12.     /*
  13.     三要素：
  14.     返回类型：只是进行打印而已，不需要进行计算，也可以结果，用void
  15.     方法名称：printarray
  16.     参数列表：必须给我数组，我才能打印其中的元素，int[] array
  17.      */
  18.     public static void printarray(int[] array){
  19.         System.out.println(array);  //地址值
  20.         for (int i=0;i< array.length;i++){
  21.             System.out.println(array[i]);
  22.         }
  23.     }
  24. }

image.png

数组作为方法参数_返回

  1. package com.besttest.class1;
  2. /*
  3. 一个方法可以有0、1、多个参数，但只能有0或者1个返回值，不能有多个返回值
  4. 如果期望一个方法当中产生多个结果数据进行返回，怎么办？----解决方法：使用一个数组作为返回类型即可
  6. 任何数据类型都能作为方法的参数类型或者返回类型
  8. 数组作为方法的参数，传递进去的其实是数组的地址值；
  9. 数组违反方法的返回值，返回的其实也是数组的地址值。
  10.  */
  11. public class Demo01ArrayReturn {
  12.     public static void main(String[] args) {
  13.         int[] ar=caculate(5,8,10);
  14.         System.out.println("main方法返回的数组是："+ar);  //地址值
  15.         System.out.println("总和："+ar[0]);
  16.         System.out.println("平均值："+ar[1]);
  17.     }
  18.     public static int[] caculate(int a, int b,int c){
  19.         int sum=a+b+c;
  20.         int avg=sum/3;
  21.         //
  22.         int[] arr1= new int[2];
  23.         arr1[0]=sum;
  24.         arr1[1]=avg;
  25.         System.out.println("将要返回的数组值是："+arr1);//地址值
  26.         return arr1;
  27.     }
  28. }