1、 Java语言中的数组是一种引用数据类型，不属于基本数据类型。数组的父类是Object。
2、数组实际上是一个容器，可以同时容纳多个元素。（数组是一个数据的集合）数组：宇面意思是“一组数据”。
3、数组当中可以存储"基本数据类型"的数据，也可以存储"引用数据类型"的数据。
4、数组因为是引用类型，所以数组对象是堆内存当中。(数组是存储在堆当中的)
5、数组在内存方面是怎么样的一个图形?
6、数组当中如果存储的是"java对象”的话，实际上存储的是对象的“引用(内存地址)"。
7、数组一旦创建，在java中规定，数组长度不可变。
8、数组的分类：一维数组、二维数组、三维数组、多维救组... (一维数组较多，二维数组偶尔使用)
所有的数组对象都有Length属性(java自带的)，用来获取数组中元素的个数。
9、java中的数组要求数组中元素的类型统一。
比如int类型数组只能存储int类型，Person类型数组只能存储person类型。
10、数组在内存方面存储的时候，数组中的元素内存地址（存储的每一个元素都是有规剧的挨着排列的）是连续的。内存地址连续这是救组存储元素的特点(符色)。数组实际上是一种简单的教据结构。
11、所有的数组都是拿"第一个小方框的内存地址”作为整个数组对象的内存地址。数组中每一个元素都是有下标的，下标从0开始，以1递增。最后一个元素的下标是：Length - 1。下标非常重要，因为我们对数组中元素进行"存取"的时候，都需要通过下标来进行。
例图：
int [] arrayl;
double[] array2;
boolean[] array3;
String[] array4;
Object[] array5;
int[] array = {100, 2100, 300, 55};
动态切始化语法格式：
int[] array = new int[5];
/*这里的5表示数组的元素个数。初始化
一个5个长度的int类型数组，每个元素默认值0.
*/
String[] names = new String[6];
/*初化6个长度的string类型数组,
每个元素默认值null。*/
public class DemoTest{
public static void main(String[] args) {
//静态初始化方式
int[] a = {1, 2, 3, 4, 5, 6};
//所有的数组对象都有length属性
System.out.println("数组中的元素个数为：" + a.length);
//数组中每一个元素都有下标
// 通过下标对数组中的元素进行存和取。
// 取（读）
System.out.println("第一个元素是：" + a[0]);
System.out.println("最后一个元素是：" + a[5]);
System.out.println("最后一个元素是：" + a[a.length - 1]);
//存（改）
//把第一个元素改为111
a[0] = 111;
System.out.println("修改后的第一个元素是：" + a[0]);
//把最后一个元素改为666
a[a.length - 1] = 666;
System.out.println("修改后的最后一个元素是：" + a[a.length - 1]);
}
}
输出：
public class DemoTest{
public static void main(String[] args) {
int[] a = {1, 2, 3, 4, 5, 6};
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
for (int i = a.length; i > 0; i--) {
System.out.println("颠倒顺序输出：" + a[i - 1]);
}
//System.out.println(a[6]);
/*出现著名异常：
ArrayIndexOutOfBoundsException
也就是：下标越界异常
常见著名异常还有：
空指针异常、类型转换异常.
*/
}
}
public class DemoTest{
public static void main(String[] args) {
/*采用动态初始化的方式创建长度为4的int数组，
数组中每个元素的默认值是0*/
int[] a = new int[4];
for (int i = 0; i < a.length; i++) {
System.out.println("数组中下标为" + i + "的元素是：" + a[i]);
}
/*采用动态初始化的方式创建长度为3的Object数组，
数组中每个元素的默认值是null*/
Object[] ob = new Object[3];
for (int i = 0; i < ob.length; i++) {
System.out.println(ob[i]);
}
/*采用静态初始化的方式创建*/
Object object = new Object();
Object object1 = new Object();
Object object2 = new Object();
Object[] o = {object,object1,object2};
/*还可以采用以下方式：
* Object[] o = {new Object(), new Object(), new Object()};
* */
for (int i = 0; i < o.length; i++) {
System.out.println(o[i]);
}
}
}
当创建数组的时候，确定数组中存储那些具体的元素时，采用静态初始化方式。
当创建数组的时候，不确定将来教组中存储那些数据，你可以采用动态初始化的方式，预先分配内存空间。
public class DemoTest{
public static void main(String[] args) {
int[] x = {1,2,3};
String[] s = {"qqq","www","eee"};
printArray(x);
printArray(s);
}
/*
这里使用静态方法比较方便，
不需要new对象
*/
public static void printArray(int[] array){
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
public static void printArray(String[] args){
for (int i = 0; i < args.length; i++) {
System.out.println(args[i]);
}
}
}
输出：
2、 直接传递一个静态数组
printArray(new int[]{7,8,9});
public class DemoTest{
public static void main(String[] args) {
System.out.println(args.length);//输出：0
/*
* 经过测试，args不是null，而是默认为0.
* 这个数组什么时候里面会有值呢？
* 其实这个数组是留给用户的，
* 用户可以在控制台上输入参数，
* 这个参数自动会被转换为"string[] args"。
* */
for (int i = 0; i < args.length; i++) {
System.out.println(args[i]);
}
/*
* 用命令行这样运行程序: java DemoTest abc def
* 那么这个时候JVM会自动将"abc def"通过空格
* 的方式进行分离，分离完成之后,自动放到
* "String[] args"数组里面
* 在工具里面需要如下设置
* */
}
}
设置前输出：
在IDEA里面设置后：
输出：
public class DemoTest{
public static void main(String[] args) {
Demo a1 = new Demo();
Demo a2 = new Demo();
Demo[] demos1 = {a1,a2};
for (int i = 0; i < demos1.length; i++) {
Demo a = demos1[i];
a.move();
//也可以采用以下方法，更简洁。
demos1[i].move();
}
Demo[] demos = {new Cat(), new Bird()};
for (int i = 0; i < demos.length; i++) {
//demos[i].move();
if(demos[i] instanceof Cat){
Cat cat = (Cat)demos[i];
cat.catchM();
}else if(demos[i] instanceof Bird){
Bird bird = (Bird)demos[i];
bird.fly();
}
/*这里需要判断类型，然后向下强制转换
* 到相应的类型，才能调用其特有的方法*/
}
}
}
public class Demo{
public void move(){
System.out.println("animal move");
}
}
public class Cat extends Demo{
@Override
public void move() {
System.out.println("猫");
}
public void catchM(){
System.out.println("猫在抓老鼠");
}
}
public class Bird extends Demo{
@Override
public void move() {
System.out.println("鸟儿");
}
public void fly(){
System.out.println("flying");
}
}
public class DemoTest{
public static void main(String[] args) {
/*System.arraycopy(5个参数);
5个参数分别为：
（拷贝源数组名，
需要拷贝的起始位置（下标），
目标数组名，
需要拷贝到目标数组的起始位置（下标），
拷贝长度）
拷贝长度可以理解为：
将源数组上的一段剪下来，
覆盖在目标数组的一段相应位置。
*/
//拷贝源
int[] src = {1,2,3,4};
//拷贝到目标数组上
int[] dest = new int[7];
//调用arraycopy方法完成数组的拷贝
System.arraycopy(src, 1, dest, 3, 2);
//拷贝之后遍历目标数组
for (int i = 0; i < dest.length; i++) {
System.out.println(dest[i]);
}
}
}
输出：
public class Demo{
//数组中如果存储的元素是引用也可以拷贝。
public static void main(String[] args) {
Object[] object = {new Object(), new Object(), new Object()};
Object[] newobj = new Object[5];
System.arraycopy(object,0,newobj,0,object.length);
for (int i = 0; i < newobj.length; i++) {
System.out.println(newobj[i]);
}
}
}
输出：
4、相应的内存图：
a[二维数组中的一维教组的下标][一维数组的下标]
int[][] a = {
{1,2,3},
{4,5,6},
{7,8,9}
};
public class DemoTest{
public static void main(String[] args) {
int[][] a = {
{1,2,3},
{4,5,6},
{7,8,9}
};
/*length属性*/
System.out.println(a.length);
System.out.println("一：" + a[0].length
+ " 二：" + a[1].length + " 三：" + a[2].length);
System.out.println("=====================");
/*遍历*/
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
System.out.println(a[i][j]);
}
}
}
}
public class Demo{
public static void main(String[] args) {
int[][] a = new int[3][4];
a[0] = new int[]{1, 1, 1, 1};
a[1] = new int[]{2, 2, 2, 2};
a[2] = new int[]{3, 3, 3, 3};
printArray(a);
}
public static void printArray(int[][] array){
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j]);
}
System.out.println();
}
}
}
原文：https://www.cnblogs.com/yu011/p/12632747.html