JAVA初步学习——第四章 数组

一、数组概述

1. 数组，是一组数据的集合，数组中的每个数据被称为元素。
2. 在java中，数组也是对象。数组中的元素可以是任意类型（基本类型或引用类类型），但同一个数组里只能存放类型相同的元素。（main方法的参数，就是一个String类型的数组）
   数组中可以存放一组数据，要求这一组数据的类型是一样（或者兼容的，兼容就表示可以自动转换）
3. 注意：
   （1） args.length 是获取这个数组对象中的元素个数
   （2）args[0] 是获取这个数组中，第一个元素的值
   （3）Integer.parseInt()方法是将一个字符串转换为int数字，例如，“109” ==> 109

//有五个数据1 2 3 4 5，需要去接收、保存、操作这些数据
1.需要五个变量
int a1 = 1; 
int a2 = 2; 
int a3 = 3; 
int a4 = 4; 
int a5 = 5;

2.使用一个组数来保存这五个数据
int[] arr = {1,2,3,4,5};

二、数组类型

数组和类不同，数组是使用当前已经存在的某一个类型（任意类型都可以），然后再这个类型后面加上一对中括号（[]），这时就组成一个了新的类型：数组类型。
任意类型 + [] = 相应的数组类型———— byte + [] ---> byte[]

三、 数组变量

先使用一个已有的类型，然后加上中括号，组合成一个数组类型，然后再声明这个数组类型的变量

声明一个数组类型的变量：

• int[] a;
• int a[];

数组类型的变量，也是引用类型变量，简称引用，它是可以指向对象的（数组对象）

四、数组对象

使用new关键字，来创建数组对象，中括号里面的数字，就是数组的长度。
int[] a = new int[4];

数组对象，在内存中，就是一块连续的内存空间，在这个连续的空间中，可以存放多个类型相同的数据。

数组对象中可以使用的属性和方法:

• 数组对象中只有一个属性（length），表示数组的长度。
• 数组对象中的方法，只有从父类型Object中继承过来的方法。

五、数组长度

数组对象的长度：

1. 数组长度，是指在一个数组对象中，最多可以存放多少个同一类型的数据
2. 数组长度，必须在创建数组对象的时候就明确指定
3. 数组长度，一旦确定，就无法再改变
4. 数组长度，可以为0，但是不能为负数

使用length属性，获取数组对象的长度：

int[] a = new int[4]; 
System.out.println(a.length);

六、数组下标

数组对象在JVM的堆区中是一块连续的内存空间，并允许使用下标，设置或获取每一个内存空间的值

1. 数组的下标的区间为：[0,arr.length-1]
2. 如果使用下标访问数组中元素的时候，下标的值超出了其可用范围，那么运行就会报错

int[] a = new int[4];//数组长度为4，那么其下标就是0~3 
a[4] = 359;//这句代码运行时报错，下标超出了最大范围

3. 可以通过数组下标，给数组某个下标位置上赋值：

int[] a = new int[4]; 
a[0] = 337;

4. 可以通过数组下标，获取数组某个下标位置上的值：

int[] a = new int[4]; 
System.out.println(a[0]): 
int num = a[0]+a[1]+a[2]+a[3]; 
System.out.println(num);

5. 可以结合循环来进行赋值或者取值

int[] a = new int[4]; 

//i从0开始，到a.lenght-1,那么i的取值刚好是数组a的下标可用范围
for(int i=0;i<a.length;i++){ 
    a[i] = 10+i; 
}
//获取数组中每个下标的值，并且输出
for(int i=0;i<a.length;i++){ 
    System.out.println(a[i]); 
}

七、默认值

一个数组对象在创建的时候，需要指定数组长度，表示数组中最多存放的元素个数，并且在数组对象创建完成之后，数组中每一个元素位置上，就已经有了相应的默认值，这个默认值和数组的类型有关。

1.byte、short、int、long类型数组中的默认值为 0 
//例如， 
int[] a = new int[4];//默认4个数据全是0 

2.float、double类型数组中的默认值为 0.0 
//例如， 
double[] d = new double[4];//默认4个数据全是0.0 

3.boolean类型数组中的默认值为 false 
//例如， 
boolean[] d = new boolean[4];//默认4个数据全是false 

4.char类型数组中的默认值为 '\u0000' 
//例如， 
char[] d = new char[4];//默认4个数据全是'\u0000' 

5.引用类型数组中的默认值为 null 
//例如， 
String[] d = new String[4];//默认4个数据全是null

八、创建方式

1. int[] arr = new int[5];
   创建数组对象，没有还没有给其赋值
2. int[] arr = new int[]{1,3,5,7,9};
   创建数组对象的同时，并赋值
3. int[] arr = {1,3,5,7,9};
   java提供了创建数组对象的简便形式
4. int[] arr;
   arr = new int[]{1,3,5,7,9};
   显示声明数组类型变量，然后创建对象，并赋值

九、数组拷贝

数组对象的长度确定之后便不能修改，但可以通过复制数组的内容变通实现改变数组长度

1. 在java.lang.System类中提供一个名为arraycopy的方法可以实现复制数组中元素的功能

public static void arraycopy(Object src,         //参数1,需要被复制的目标数组
                             int srcPos,        //参数2,从目标数组的哪一个位置开始复制
                             Object dest,       //参数3,需要把数据复制到另外一个新的数组中
                             int destPos,      //参数4,把数据复制到新数组的时候，需要把数据从什么位置开始复制进去
                             int length)      //参数5,复制的目标数组的长度

2. 写一个方法,接收一个数组对象,把这个数组对象的长度扩大到原来的2倍并返回。

public int[] test(int[] a){ 
    int[] b = new int[a.length*2]; 
    System.arraycopy(a, 0, b, 0, a.length); 
    return b; 
}

十、工具类

java.util.Arrays类，是JAVASE API中提供给我们使用的一个工具类，
这个类的作用就是在代码中辅助我们对数组对象进行操作的。里面有很多静态方法可以直接调用，主要的功能就是对数组对象进行操作，例如：排序、查询、复制、填充数据等等。

Arrays中的常用方法：

• toString方法
  可以把一个数组变为对应的String形式
• copyOf方法
  可以把一个数组进行复制
  该方法中也是采用了arraycopy方法来实现的功能
• copyOfRange方法
  也是复制数组的方法，但是可以指定从哪一个下标位置开始复制
  该方法中也是采用了arraycopy方法来实现的功能
• sort方法
  可以对数组进行排序
• binarySearch方法
  在数组中，查找指定的值，返回这个指定的值在数组中的下标，但是查找之前需要在数组中先进行排序，可以使用sort方法先进行排序
• equals方法
  可以比较俩个数组是否相等,但是要求俩个数组中的值一一相等并且顺序也要一致才行，所以在比较之前，我们最好是用sort方法对俩个数组先进行排序
  第一个要求，俩个数组的元素个数相同
  第二个要求，俩个数组的每个下标对应的数据相同
• fill
  可以使用一个特定的值，把数组中的空间全都赋成这个值
• asList
  可以把一组数据，封装到一个List集合中，并且把list集合对象返回。

//注意，数组长度一旦确定，就不能再修改了。 
//我们只是创建了一个新的数组，并且把老数组中的数据复制到了新数组中，并且把新数组返回给用户，这个 效果让人感觉上像是老的数组的长度变长了，但其实并没有。 
int[] a = {1,3,5,2,6,8}; 
System.out.println(Arrays.toString(a)); 

a = Arrays.copyOf(a,10); 
System.out.println(Arrays.toString(a)); 

Arrays.sort(a); 
System.out.println(Arrays.toString(a)); 

int index = Arrays.binarySearch(a,5); 
System.out.println(index); 

int[] arr1 = {1,2,3}; 
int[] arr2 = {3,2,1}; 
Arrays.sort(arr1); 
Arrays.sort(arr2); 
System.out.println(Arrays.equals(arr1,arr2)); 

Arrays.fill(a,100); 
System.out.println(Arrays.toString(a));

十一、二维数组

1.理解二维数组

（1）一维数组中存放的是普通数据
（2）二维数组中存放的是一维数组对象（二维数组里面存放的是一维数组（array Of array））
（3）任何一个一维数组，再加一对中括号[]，就变成了二维数组

//三个一维数组 
int[] a1 = {1,2,3}; 
int[] a2 = {2,3,4}; 
int[] a3 = {3,4,5}; 

//1.二维数组中，存放三个一维数组对象 
int[][] arr = { 
    a1, 
    a2, 
    a3 
};

//2.等价于上面的代码 
int[][] arr = { 
     {1,2,3}, 
     {2,3,4}, 
     {3,4,5} 
 };

2.声明和创建

//第一个中括号中的4，代表这个二维数组对象里面，最多可以存放4个一维数组 
//第二个中括号中的3，代表这个二维数组中，每个存放的一维数组对象，都可以存放存放3个int数据
int[][] a = new int[4][]; 

//这句代码等价于以下代码
a[0] = new int[3]; 
a[1] = new int[5]; 
a[2] = new int[2]; 
a[3] = new int[4]; 

//这句代码等价于以下代码 
int[][] a = { 
    {1,2,3}, 
    {1,2,3,4,5}, 
    {1,2}, 
    {1,2,3,4} 
};

3.赋值

int[][] a = new int[3][];//三层楼 
a[0] = new int[1];//第一层楼，1间房 
a[1] = new int[2];//第二层楼，2间房 
a[2] = new int[3];//第三层楼，3间房 

a[0][0] = 10; //第一层楼，第一间房，存放数据 
a[1][0] = 20; //第二层楼，第一间房，存放数据 
a[1][1] = 20; //第二层楼，第二间房，存放数据 
a[2][0] = 30; //第三层楼，第一间房，存放数据 
a[2][1] = 30; //第三层楼，第二间房，存放数据 
a[2][2] = 30; //第三层楼，第三间房，存放数据

4.取值

String[][] str = { 
    {"test1"}, 
    {"hello1","hello2"}, 
    {"world1","world2","world3"} 
};

//循环三次,因为str中有三个元素 
//只不过这三个元素每一个都是个一维数组
for(int i=0;i<str.length;i++){ 
    //第一个一维数组中有1个元素,元素是String类型的 
    //第二个一维数组中有2个元素,元素是String类型的 
    //第三个一维数组中有3个元素,元素是String类型的 
    //所以内层循环每次打印的次数是不一样的
    for(int j=0;j<str[i].length;j++){ 
        System.out.println(str[i][j]); 
    } 
}

十二、可变参数

1. 在test方法中，这个可变参数a，其实就是一个int类型的数组，在方法中可以直接把a当做数组来使用。
   （1）如果没有传任何参数，那么这个数组a的长度就是0
   （2）如果传1个参数，那么数组a的长度是1，数组里面的数据就是所传的参数。
   （3）依次类推，传多个参数的情况也是类似的。
   （4）额外的，还可以把一个数组当做参数传进来，因为这个可变参数a，本来就是一个数组。

public void test(int... a){ 

}

//在调用这种方法的时候，我们所传的参数情况就可以有多种选择了 
int[] arr = {1,2,3}; 
t.test(); 
t.test(1); 
t.test(1,2,3,4); 
t.test(arr);

2. 方法中有一个可变参数同时，还可以有其他普通的参数
   可变参数和普通参数共存的时候，可边参数必须放到最后一个参数的位置

public void test(String str,int... a){ 

}