Java数组的基本使用(超详细)

数组的基本使用

  • 为什么需要数组

    • 一个养猫场有 6 只鸡，它们的体重分别是 3kg,5kg,1kg,3.4kg,2kg,50kg 。请问这六只猫的总体重是多少?平均体重是多少?
    • 思路分析：定义 6 个变量 , 加起来 总体重,求出平均体重.引出 -> 数组

  • 数组介绍

    • 数组可以存放多个同一类型的数据。可以存储基本数据类型，引用数据类型（对象）. 数组本身也是一种数据类型，是引用类型。数据类型可以是任意类型
      即：数(数据)组(一组)就是一组数据
    • int[] 表示引用数据类型
    • 数组是一个容器，容器都是存取数据，容器容量固定
    • 数组有length属性
    • 数组内存是连续的，有索引，查询是快, 增删比较慢

  • 数组快速入门

    • 比如，我们可以用数组来解决上一个问题。思路分析：
      1. 我们可以通过 cats[下标] 来访问数组的元素，下标是从 0 开始编号的比如第一个元素就是 cats[0]，第2个元素就是 cats[1] , 依次类推
      2. 通过for就可以循环的访问 数组的元素/值
      3. 使用一个变量 totalWeight 将各个元素累积
          double[] cats = {3, 5, 1, 3.4, 2, 50};
	double totalWeight = 0;
	for (int i = 0; i < cats.length; i++) {
	    System.out.println("第" + (i+1) + "个元素的值=" + cats[i]);
	    totalWeight +=cats[i];
	}
	System.out.println("总体重=" + totalWeight + "平均体重=" + (totalWeight / cats.length));
	如果需要增加 鸡的个数时，只要改动数组就行，其他变量都不需要改动。

  • 数组的定义

    1. 数据类型 数组名[]=new 数据类型[数组的长度]
    2. 数据类型 【】 变量名称 = new 数据类型【数组的长度】；
    3. 数据类型 【】 变量名称 = {字面值1，字面值2，字面值3…}；
    4. 第一种创建数组，只是说数组能放入几个数据，没有给具体的值,第二种创建数组就给了值.第一种更有优势，更灵活
    5. int[] arr1={ }; //表示数组没有存放任何元素
    6. int a=new int[5]; //创建一个数组,名字为a,存放5个int
    7. int[] arr2={1,2,3,4,45,}; //最后一个元素是可以多写一个逗号，但是不写更好
    8. int arr3 [] ={1,2,3,4,45}; //【】是可以放在不同位置的，建议跟main中的String 【】 args保持一致
    9. 数组的下标从0开始
    10. 建议int[]中间不加空格

  • 数组的使用

    循环输入5个成绩,保存到double数组,并输出
double[] scores = new double[5];
	Scanner sc = new Scanner(System.in);
	for (int i = 0; i < scores.length; i++) 
	{
	    System.out.println("请输入第" + (i + 1) + "个元素的值");
	    scores[i] = sc.nextDouble();
	}
	System.out.println("==数组元素的输出情况：==");
	for (int i = 0; i < 5; i++) 
	{
	    System.out.println("请输入第" + (i + 1) + "个元素的值" + scores[i]);
	}

  • 动态初始化数组

    • 数组的定义

      先声明数组   语法:数据类型 数组名[]; 也可以 数据类型[] 数组名;
int a[]; 或者 int[] a;
创建数组     语法: 数组名=new 数据类型[大小];
a=new int[10];

double scores[] =new double[5] ;  ==>double a[]; a=double int[5];

  • 细节

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

      int[] arr1 = {1, 2, 3, 60,"hello"};         //String ->int 类型不匹配
double[] arr2 = {1.1, 2.2, 3.3, 60.6, 100}; //int ->doubl 可以通过，满足自动类型转换

    • 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。

          String[] arr3 = {"北京","jack","milan}

    • 数组创建后，如果没有赋值，只是声明了数组的长度,有默认值

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

      • 举例

            short[] arr4 = new short[3];
    System.out.println("==数组arr4==");
    for (int i = 0; i < arr4.length; i++) {
        System.out.println(arr4[i]);
    }

    • 使用数组的步骤： 1. 声明数组并开辟空间 2. 给数组各个元素赋值 3. 使用数组

    • 数组下标必须在指定范围内使用，否则报：下标越界异常，比如

      int [] arr=new int[5]; 则有效下标为 0-4，即数组的的下标最小为 0，最大为 数组长度-1 （5-1=4）

    • 数组属引用类型，数组型数据是对象(object)

  • 数组的应用案例

    • 创建一个 char 类型的 26 个元素的数组，分别 放置’A’-‘Z’。使用 for 循环访问所有元素并打印出来。

      • 提示：char 类型数据运算 ‘A’+2 -> ‘C’
      • 思路分析
      1. 定义一个 数组 char[] chars = new char[26]
      2. 因为 ‘A’ + 1 = ‘B’ 类推，所以使用for来赋值
      3. 使用for循环访问所有元素
       char[] chars = new char[26];
        for( int i = 0; i < chars.length; i++) 
        {//循环26次
            //chars 是 char[]
            //chars[i] 是 char
            chars[i] = (char)('A' + i); //'A' + i 是int , 需要强制转换
        }

        //循环输出
        System.out.println("===chars数组===");
        for( int i = 0; i < chars.length; i++) {//循环26次
            System.out.print(chars[i] + " ");
        }

    • 请求出一个数组 int[]的最大值 {4,-1,9, 10,23}，并得到对应的下标。

       思路分析:
    定义一个int数组 int[] arr = {4,-1,9, 10,23};
    假定 max = arr[0] 是最大值 , maxIndex=0;
    从下标 1 开始遍历arr， 如果max < 当前元素，说明max 不是真正的最大值, 我们就
    max=当前元素; maxIndex=当前元素下标
    当我们遍历这个数组arr后 , max就是真正的最大值，maxIndex最大值对应的下标

      int[] arr = {4,-1,9,10,23};
int max = arr[0];//假定第一个元素就是最大值
int maxIndex = 0; //

for(int i = 1; i < arr.length; i++) {//从下标 1 开始遍历arr

	if(max < arr[i]) {//如果max < 当前元素
		max = arr[i]; //把 max 设置成 当前元素
		maxIndex = i; 
	}
} 
//当我们遍历这个数组arr后 , max就是真正的最大值，maxIndex最大值下标
System.out.println("max=" + max + " " + "maxIndex=" + maxIndex);

    • 数组遍历输出：一次性把数组中所有的元素输出

      public class TestArray02 {

    public static void main(String[] args) {
        String[] arr=new String[5];
        arr[0]="刘备";
        arr[1]="孙权";
        arr[2]="曹操";
        arr[3]="关羽";
        arr[4]="宋江";
 //数组中的元素一个一个输出：
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);
        System.out.println("================================");
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}
    • 数组中存放的数据类型是自定义的类型（引用数据类型）

    • 有一个学生类，学生类有一些属性，创建5个学生存放到数组中

      public class Student {
    private String name;//名字
    private String stuID;//学号
    private String hobby;//爱好

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getStuID() {
        return stuID;
    }

    public void setStuID(String stuID) {
        this.stuID = stuID;
    }

    public String getHobby() {
        return hobby;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }

    public Student(String name, String stuID, String hobby) {
        this.name = name;
        this.stuID = stuID;
        this.hobby = hobby;
    }

    public Student() {
    }

    //toString()方法

//    @Override
//    public String toString() {
//        return "Student{" +
//                "名字='" + name + '\'' +
//                ", 学号='" + stuID + '\'' +
//                ", 爱好='" + hobby + '\'' +
//                '}';
//    }

}
public class TestStudent {
    public static void main(String[] args) {
        Student s1=new Student("曹操","0x115","打仗");
        Student s2=new Student("曹植","0x117","写诗");
        Student s3=new Student("李白","0x118","喝酒");
        Student s4=new Student("刘备","0x111","关羽");
        Student s5=new Student("孙权","0x110","篮球");

        //数据类型【】  数组名={值1，值2，值3};
       Student[] stus={s1,s2,s3,s4,s5};

        //遍历
        //for循环，循环的都是下标
        //最后一位的下标 是 length-1
        System.out.println("----------------------");
        System.out.println("|名字|\t|学号|\t|爱好|");
        System.out.println("----------------------");
        for(int i=0;i<stus.length;i++){
            Student stu=stus[i];
            System.out.println("|"+stu.getName()+"|\t"+"|"+stu.getStuID()+"|\t"+"|"+stu.getHobby()+"|");
            System.out.println("----------------------");
        }
    }
}

  • 数组的可变长参数-----引用数据类型 ---- 数据类型【】

    package arrayd1;
public class Demo01 {
    //方法
    public String[] fun(String[] args){
        //System.out.println(args);
      //  System.out.println(args[0]);
        for(int i=0;i<args.length;i++){
            args[i]=args[i]+"--范冰冰";
        }
        return args;
    }

    public static void main(String[] args) {
        Demo01 demo01 = new Demo01();
       // demo01.fun(new String[10]);
        String[] arr={"小明","肖坤","小刚"};
        String[] fun = demo01.fun(arr);
        for(int i=0;i<fun.length;i++){
            System.out.println(fun[i]);
        }
    }
}
    • 可变参数注意：
      1. 在参数类型与参数名中间使用 … 三个小点表示它是可变长参数
      2. 可变长参数可以接收任意个数据
      3. 一个方法最多只能 有一个变长参数
      4. 变长参数只能放在参数列表的最后
      5. 在方法体中,可以简单的把变长参数当作数组使用
    package d1;
public class Demo02 {
    //... 省略号
    public static void fun(int ... a){
    //地址  a是一个数组类型的
      //  System.out.println(a);
       // int[] a1 = a;
        int sum=0;
        for(int i=0;i<a.length;i++){
            sum+=a[i];
        }
        System.out.println(sum);
    }
    public static void main(String[] args) {
        fun(1,2,3,4,5);
    }
}
版权声明：本文为qq_52330730原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。