Java数组

数组属于引用数据类型

数组的声明

数组声明语法有

Java中推荐使用第一种方式。

	int[] arr1 ;
	float arr2[];

数组的初始化

初始化之后数组的长度就确定下来，不能再变化了。初始化分为两种，静态初始化和动态初始化。

静态初始化

就是将数组的元素放到大括号中，元素之间用逗号分隔。

package plus;
public class plus {
	public static void main(String[] args) {
	int[] arr1 = {12,34,56,67,89};
	String[] arr2 = {"张三","李四","王五","Mary","Tom"};
	}
}

动态初始化

静态初始化是在数组中每一个元素内容已知的情况下使用的。在很多情况下，不知道数组中元素的内容和多少，可以使用动态初始化方法。

语法格式为 new 元素数据类型[ 数组长度 ] ;

package plus;
public class plus {
	public static void main(String[] args) {
	int[] arr1 = new int[4];
	arr1[0] = 23;
	arr1[1] = 43;
	arr1[2] = 56;
	arr1[3] = 89;
	}
}

案例

package plus;
public class plus {
	public static void main(String[] args) {
	double[] arr1 = {3, 5, 1, 3.4, 2, 50};
	double sum = 0;
	for (int i = 0;  i<arr1.length; i++) {
		sum = sum + arr1[i];
	}
	double avg = 0;
	avg = sum/arr1.length;
    System.out.println(sum);
    System.out.println(avg);
	}
}

import java.util.Scanner;
public class array1 {
    //循环输入5个成绩，保存到double数组中并输出。
        public static void main(String[] args) {
            double[] arr1 = new double[5];
            Scanner myScanner= new Scanner(System.in);
            //循环输入
            for(int i = 0; i<arr1.length; i++ ) {
                System.out.println("请输入第" + (i + 1) + "个元素的值");
                arr1[i] = myScanner.nextDouble();
            }
            //循环输出
            for(int m = 0; m<arr1.length; m++){
                System.out.println(arr1[m]);
            }

        }
}

请输入第1个元素的值
1
请输入第2个元素的值
2
请输入第3个元素的值
3
请输入第4个元素的值
4
请输入第5个元素的值
5
1.0
2.0
3.0
4.0
5.0

Process finished with exit code 0

//创建一个包含26个英文字母的char类型的数组，输出出来
public class array2 {
    public static void main(String[] args) {
        char[] arr1 = new char[26];
        arr1[0] = 'A';
        for (int i = 0; i<26; i++){
            arr1[i] = (char)('A' + i);
            System.out.println(arr1[i]);
        }
    }
}

注意其中的强制类型转换。

//求一个int数组{4，-1，9，10，23} 并得到对应的下标
public class array3 {
    public static void main(String[] args) {
    int[] arr1 = {4, -1, 9, 10, 23};
    int max = 4;
    int maxIndex = 0;
    for(int i = 1; i<arr1.length; i++){
        if(arr1[i]>max){
            max = arr1[i];
            maxIndex = i;
        }
    }
        System.out.println(max);
        System.out.println(maxIndex);
    }
}

注意

• 数组里的元素应该是相同类型的。但有可能有自动类型转换(小范围的数据转化为大范围的数据类型)。
• 数组创建后，如果没有赋值，是有默认类型的。int、byte、short、long默认都是0；float、double都是0.0；char是\u0000；boolean是false；String是null。

数组赋值机制

public class array4 {
    public static void main(String[] args) {
        int n1 = 10;
        //赋值方式为值拷贝 ，n2的值改变，不会影响n1的值。
        int n2 = n1;
        n2 = 80;
        System.out.println("n1="+n1);
        System.out.println("n2="+n2);

        //数组在默认情况下是引用传递，赋的值是地址，赋值方式为引用传递，传递的是地址。arr2的变化会影响到arr1
        int[] arr1 = {1,2,3};
        int[] arr2 = arr1;
        arr2[0] = 4;
        for(int i = 0; i<arr2.length; i++){
            System.out.println(arr2[i]);
            System.out.println(arr1[i]);
        }

    }
}

n1=10
n2=80
4
4
2
2
3
3

Process finished with exit code 0

Java的内存分为三大部分 栈、堆、方法区。

数组拷贝

将arr1的内容拷贝到arr2数据里面，要求数据空间是独立的。

//将数组1的内容拷贝到数组2中，要求数据空间是独立的。
public class array5 {
    public static void main(String[] args) {
        int[] arr1 = {10,20,30};
        //先创建一个新的数组arr2，开辟新的数据空间
        int[] arr2 = new int[arr1.length];
        for(int i = 0; i<arr1.length; i++){
            arr2[i] = arr1[i];
        }
        for(int m = 0; m<arr2.length; m++) {
            System.out.println(arr2[m]);
        }
    }
}

数组翻转

要求把数字的元素内容反转

//要求把数组的元素内容反转
public class array6 {
    public static void main(String[] args) {
        int[] arr1 = {11,22,33,44,55,66};
        int[] arr2 = new int[arr1.length];
        for(int i = 0; i<arr1.length; i++){
            arr2[i] = arr1[arr1.length-i-1];
        }
        for(int m = 0;m< arr2.length;m++){
            System.out.println(arr2[m]);
        }
    }
}

66
55
44
33
22
11

Process finished with exit code 0

数组扩容

需求：实现动态的给数组添加元素效果
1）原始数组使用静态分配 int[] arr = {1,2,3}
2）增加的元素直接放在数组的最后
3）用户可以通过如下方法来决定是否继续添加 y/n

//需求：实现动态的给数组添加元素效果
//  1）原始数组使用静态分配 int[] arr = {1,2,3}
//  2）增加的元素直接放在数组的最后
//  3）用户可以通过如下方法来决定是否继续添加 y/n
import java.util.Scanner;
public class array7 {
    public static void main(String[] args) {
        int[] arr1 = {1,2,3};
        while(true){
            Scanner myscanner = new Scanner(System.in);
            System.out.println("是否继续添加 y/n");
            char str = myscanner.next().charAt(0);
            if (str =='n'){
                break;
            }else if (str == 'y'){
                System.out.println("请输入添加的元素");
                int num = myscanner.nextInt();
                int[] new_array = new int[arr1.length+1];
                for(int i = 0; i<arr1.length; i++){
                    new_array[i] = arr1[i];
                }
                new_array[new_array.length-1] = num;
                arr1 = new_array;
                for(int m = 0; m<new_array.length; m++){
                    System.out.println(new_array[m]);
                }
            }
        }
    }
}

是否继续添加 y/n
y
请输入添加的元素
2
1
2
3
2
是否继续添加 y/n
y
请输入添加的元素
6
1
2
3
2
6
是否继续添加 y/n
n

Process finished with exit code 0

数组缩减

有一个数组{1，2，3，4，5}，可以将该数组进行缩减，提示用户是否继续缩减，每次缩减最后一个元素，当只剩下最后一个元素时，提示不能再缩减。