什么是数组
数组（Array）是有序的元素序列。 若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按有序的形式组织起来的一种形式。 这些有序排列的同类数据元素的集合称为数组。
数组的声明与创建
Java程序中的数组必须先进行初始化才可以使用，所谓初始化,就是为数组对象的元素分配内存空间,并为每个数组元素指定初始值，而在Java中，数组是静态的，数组一旦初始化，长度便已经确定，不能再随意更改。
首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：
dataType[] arrayRefVar; // 首选的方法
或
dataType arrayRefVar[]; // 效果相同，但不是首选方法 c++沿用public class Demo01 {
public static void main(String[] args) {
//静态初始化：由程序猿自己确定每个数组元素的初始值，而数组的长度则由系统自己决定，
int[] a = {1,2,3,4,5};
System.out.println(a.length);
// 第二行代码可以看出，数组拥有类的性质，可以用dot访问其变量
// 第一行代码静态初始化了数组整型数组a，赋予其固定的长度，系统可以为其分配空间
//动态初始化：初始化时由程序猿确定数组的长度，而没一个数组元素的值，则由系统来分配初始值，
int[] b=new int[5];
System.out.println(b[0]);//默认值是0
// 很明显，数组就是类
//所以对于数组变量来说，他并不需要初始化，我们常说的初始化其实是初始化数组对象而非数组变量，
// 有时候我们不进行初始化，而让数组变量指向一个有效的数组对象，数组也可以使用
int[] c = {0,1,2,3,4};
int[] d;
d = c;
System.out.println(d[1]);
// 输出结果为 1
d[1] = 99;
System.out.println(c[1]);
// 输出结果为 99
//利用增强型循环输出如下数组
int [] numbers = {10, 20, 30, 40, 50};
for(int x :numbers){
System.out.print(x+" ");
}
System.out.println();
System.out.println("===============");
String [] names ={"James", "Larry", "Tom", "Lacy"};
for (String string:names){
System.out.print(string+" ");
}
}
}java三种初始化和内存分析
1.静态初始化
除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。
例 int[] a={1,2,3};//静态初始化基本类型数组
Man[] mans={new Man(1,1),new Man(2,2)};//静态初始化引用类型数组2.动态初始化
数组定义与为数组元素分配空间并赋值的操作分开进行
int[] a1=new int[2];//动态初始化元素，先分配空间
a1[0]=1;//给数组元素赋值
a1[2]=2;3.数组的默认初始化
数组是引用类型，他的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化
实例：
int a2[]=new int[2];//默认值0，0
boolean[] b=new boolean[2];//默认值 false，false
String[] s=new String[2];//默认值nullpublic class Demo02 {
public static void main(String[] args) {
//数组的初始化方式
//1.静态初始化
int[] a = {10,20,30,40,50};
//创建之后a不可改变
System.out.println(a[2]);
//2.动态初始化
int[] b = new int[3];
b[0] = 10;
b[1] = 20;
b[2] = 30;
System.out.println(b[2]);
//3.数组的默认初始化
int a2[]=new int[2];//默认值0，0
boolean[] b2=new boolean[2];//默认值 false，false
String[] s=new String[2];//默认值null
}
}数组的特性
- 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。其元素必须是相同类型,不允许出现混合类型。
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
- 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
- 数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。
数组的使用
public class Demo03 {
public static void main(String[] args) {
//数组的基本使用
//静态定义一个数组
int[] a = {10,30,50,64,21,35};
//输出所有值
//for循环输出
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
System.out.println("==============");
//增强型循环输出
for (int x:a){
System.out.println(x);
}
System.out.println("==============");
//计算数组中所有元素的和
int sum = 0;
for (int i = 0; i < a.length; i++) {
sum += a[i];
}
System.out.println("sum="+sum);
System.out.println("==============");
//输出数组中的最大值
int max = a[0];
for (int i = 0; i < a.length; i++) {
if(a[i] > max){
max = a[i];
}
}
System.out.println("数组元素的最大值为："+max);
}
}public class Demo04 {
public static void main(String[] args) {
int[] a = {10,21,12,65,85} ;
printArray(a);
int[] ints = returnArray(a);
System.out.println();
printArray(ints);
}
//打印数组所有元素
public static void printArray(int[] array){
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]+" ");
}
}
//将数组反转
public static int[] returnArray(int[] array){
int[] result = new int[array.length];//定义一个数组，长度和需要反转的数组一样的
for (int i = 0,j=result.length-1; i < array.length; i++,j--) {
result[j] = array[i];
}
return result;//最终返回这个数组
}
}二维数组
public class Demo05 {
public static void main(String[] args) {
int [][] ar = {{4,5,6,8},{2,3,5,8},{1,6,9,5}};
System.out.println(ar.length);//输出行数
System.out.println(ar[0].length);//输出列数
//按照行列输出二维数组
/*
4 5 6 8
2 3 5 8
1 6 9 5
*/
for (int i = 0;i < ar.length;i++){
for(int j = 0;j<ar[i].length;j++){
System.out.print(ar[i][j]+" ");
}
System.out.println();
}
}
}Arrays类
数组的工具类java.util.Arrays
由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本的操作。
查看JDK帮助文档，Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用
(注意:是"不用”而不是"不能")
具有以下常用功能:
- 给数组赋值:通过fill方法。
- 对数组排序:通过sort方法,按升序。
- 比较数组:通过equals方法比较数组中元素值是否相等。
- 查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法操作。
import java.util.Arrays;
public class demo06 {
public static void main(String[] args) {
int [] nums = {10,30,8,52,21};
Arrays.sort(nums);
System.out.println("------升序-----");
for (int num : nums) {
System.out.print(num+"");
}
System.out.println("\n------降序-----");
for (int i = nums.length-1; i >=0 ; i--) {
System.out.print(nums[i]+"");
}
System.out.println("\n------字符串排序-----");
String [] mm = {"n","1","6","M","a","5"};
Arrays.sort(mm);
for (String s : mm) {
System.out.print(s);
}
System.out.println("\n------判断两个数组是否相等-----");
int [ ] num1 = {1,2,3};
int [ ] num2 = {1,2,4};
boolean b = Arrays.equals(num1, num2);
System.out.print(b);
System.out.println("\n------转换为字符串-----");
int [] num3 = {5,6,4,5,8};
String s = Arrays.toString(num3);
System.out.print(s);
System.out.println("\n------赋值相同数值-----");
int [ ] num4 = {1,2,4};
Arrays.fill(num4,66);
for (int i : num4) {
System.out.print(i+" ");
}
System.out.println("\n------复制为新数组-----");
int [ ] num5 = {1,2,4};
int[] num55 = Arrays.copyOf(num5, 5);
for (int i : num55) {
System.out.print(i);
}
System.out.println("\n------查询元素下标-----");
int [ ] num6 = {1,2,4};
int i = Arrays.binarySearch(num6, 4);
System.out.println(i);
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
