Java数组

最新推荐文章于 2024-11-04 22:26:34 发布

qq_35209542

最新推荐文章于 2024-11-04 22:26:34 发布

阅读量265

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_35209542/article/details/121545307

版权

数组介绍

数组可以存放多个同一类型的数据，数组也是一种数据类型，是引用类型。

即：数组就是一组数据。

 //1.double[]表示 double类型的数组，数组名 hens
 //2.{3, 5, 1, 3.4, 2, 50}表示数组的值、元素，依次表示数组的第几个元素   
 //double[] hens = {3, 5, 1, 3.4, 2, 50};
 //遍历数组得到的数组所有元素的和，使用for
 //我们可以通过 hens[下标] 来访问数组的元素
 // 下标是从0开始编号的 比如第一个元素就是 hens[0]
 //数组名.length 表示有多少个元素
 
 public class Test {
     public static void main(String[] args) {
         double[] hens = {3, 5, 1 ,3.4 ,2, 50 ,66.6};
         double totalWeight = 0;
         for (int i = 0; i < hens.length; i++){
             totalWeight += hens[i];
         }
         System.out.println("总体重=" + totalWeight + "平均体重=" + (totalWeight / hens.length));
     }
 }

使用方式1-动态初始化

 
 //循环输入5个成绩，保存到double数组，并输出
 import java.util.Scanner;
 public class Test {
     public static void main(String[] args) {
         double scores[] = new double[5];        //创建一个数组 大小为5
         Scanner input = new Scanner(System.in);
         for (int i = 0; i < scores.length ; i++){                   //循环输入   scores.length表示数组大小
             System.out.println("请输入第"+ (i + 1) +"个元素的值");
             scores[i] = input.nextDouble();
         }
         for (int i = 0; i < scores.length ; i++) {                   //循环输出
             System.out.println("第" + (i + 1) + "个元素的值=" + scores[i]);
         }
     }
 }

使用方式2-动态初始化

先声明后分配

 
 //循环输入5个成绩，保存到double数组，并输出
 import java.util.Scanner;
 public class Test {
     public static void main(String[] args) {
         double scores[]  ;     //声明数组
         scores = new double[5];  //分配内存空间，存放数据
         Scanner input = new Scanner(System.in);
         for (int i = 0; i < scores.length ; i++){                   //循环输入   scores.length表示数组大小
             System.out.println("请输入第"+ (i + 1) +"个元素的值");
             scores[i] = input.nextDouble();
         }
         for (int i = 0; i < scores.length ; i++) {                   //循环输出
             System.out.println("第" + (i + 1) + "个元素的值=" + scores[i]);
         }
     }
 }

使用方式3-静态初始化

语法：数组类型数组名[] = {元素值.............}

int a[] = {2 ,5 ,8 ,9};

相当于:

int a[] = new int[4];

a[0] = 2;

a[1] =5 ;

a[2] = 8;

a[3] = 9;

数组使用注意事项

数组是多个相同类型数据的组合，实现对这些数据的统一管理
数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。
数组创建后，如果没有赋值，有默认值

int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null

使用数组的步骤 1. 声明数组并开辟空间 2 给数组各个元素赋值 3 使用数组
数组的下标是从 0 开始的。
数组下标必须在指定范围内使用，否则报：下标越界异常，比如 int [] arr=new int[5]; 则有效下标为 arr[4] arr[3] arr[2] arr[1] arr[0]
数组属于引用类型，数组型数据是对象

数组赋值机制

 
 public class Test {
     public static void main(String[] args) {
         int n1 = 15;        //基本数据类型赋值，赋值方式为值拷贝
         int n2 = n1;
         n2 = 50;
         System.out.println(n1);
         System.out.println(n2);
         //数组在默认情况下是引用传递，赋的值是地址，赋值方式为引用赋值
         int[] arr1 = {1 , 2 , 3};
         int[] arr2 = arr1;
         arr2[0] = 10;
         System.out.println("==================");
         System.out.println(arr1[0]);
     }
 }

 
 public class Test {
     public static void main(String[] args) {
         int arr1[] = {1 , 2 , 30};
         int arr2[] = new int[arr1.length];       //创建一个新的数组arr2，开辟新的数据空间
         for (int i = 0 ;i < arr1.length ; i++){
             arr2[i] = arr1[i];                     //拷贝元素的值
         }
         
         
     }
 }

数组反转

 //把数组的元素内容反转   方法一
 public class Test {
     public static void main(String[] args) {
         int arr[] = {1 , 2 , 3 , 4 , 5 , 6};
         int temp = 0;
         for (int i = 0; i < arr.length / 2 ; i++){
             temp = arr[i];
             arr[i] = arr[arr.length - 1 - i];
             arr[arr.length - 1 - i] = temp;
         }
         for (int i =0 ; i < 6 ;i++){
             System.out.print(arr[i] + " ");  //输出为  6 5 4 3 2 1
         }
     }
 }

 //方法二
 public class Test {
     public static void main(String[] args) {
         int arr1[] = {1 , 2 , 3 ,4 ,5 ,6 };
         int arr2[] = new int[arr1.length];
         for (int i = arr1.length - 1 ; i >= 0 ; i--){
            arr2[arr1.length - 1 - i] = arr1[i];
         }
         arr1 = arr2;
         for (int i = 0; i < arr1.length ; i++){
             System.out.print(arr1[i] + " ");
         }
     }
 }

数组添加

 /*
 实现动态的给数组添加元素效果，实现对数组扩容。原始数组使用静态分配 int[] arr = {1,2,3} 2) 增加的元素 4，直接放在数组的最后 arr = {1,2,3,4}
 */
 public class Test {
     public static void main(String[] args) {
         int arr[] = {1 , 2 , 3};
         int arr1[] = new int[arr.length + 1];
         for (int i = 0 ; i < arr.length ; i++){
             arr1[i] = arr[i];
         }
         arr1[arr1.length - 1] = 4;
         arr = arr1;
         for (int i = 0 ; i < arr.length ; i++){
             System.out.print(arr[i] + " ");     //1 2 3 4
         }
     }
 }

数组缩减

 
 import java.util.Scanner;
 public class Test {
     public static void main(String[] args) {
         Scanner input = new Scanner(System.in);
         int arr[] = {1 , 2 , 3 , 4 , 5};
         do {
 
             int arr1[] = new int[arr.length - 1];
             for (int i = 0; i < arr.length - 1; i++) {
                 arr1[i] = arr[i];
             }
             arr = arr1;
             System.out.println("===数组缩减情况===");
             for (int i = 0; i < arr.length; i++) {
                 System.out.print(arr[i] + "    ");
             }
             System.out.println("是否继续缩减 Y/N");
             char key = input.next().charAt(0);
             if (key == 'N' ){
                 System.out.println("缩减结束");
                 break;
             }else if (arr.length == 1){
                 System.out.println("无法继续缩减");
                 break;
             }
 
         }while(true);
     }
 }