Java_学习笔记_004(数组)

数组

在Java中数组是引用数据类型，意味着要用new来开辟内存空间

数组的初始化：

• 动态初始化（初始化后每个数组元素的内容为该数据类型的默认值）
  • 格式1：
    • 数据类型 [] 数组名称 = new 数据类型[长度];      // 两种申明方式都可以，没区别
  • 格式2：
    • 数据类型 数组名称 [] = new 数据类型[长度];
• 静态初始化
  •  简化格式：
    • 数据类型 数组名称[] = {数据1，数据2，数据3，.......}；
  • 完整格式：
    • 数据类型 数组名称[] = new 数据类型[] {数据1，数据2，数据3，.......}

数组的使用与大多变成语言差别不大，都是通过下标来访问，默认从0开始。常用的方式也是通过循环来对数组进行处理

如果使用的时候超过了数组下标则会出现“ArrayIndexOutBoundsException”错误，下标越界。

数组长度可以使用： array.length 获取

JDK 1.5 之后为了减轻下标对程序的影响，借鉴了 .NET 的增强型for循环（foreach）

foreach 的语法结构可以直接自动获取数组中的每一个元素，避免下标访问。

• foreach 语法格式：
  • for （数据类型 变量 ：数组 | 集合）{ }

 

二维数组

二维数组初始化：

• 动态初始化
  • 数据类型[][] 数组名称 = new 数据类型[行个数][列个数];
• 静态初始化
  • 数据类型[][] 数组名称 = new 数据类型[][] {{数据1，数据2，数据3}{数据4，数据5，数据6}{数据7，数据8，数据9}..............};

for循环操作二维数组案例：

public class ArrayDemo {
    public static void main(String[] args) {
        int[][] data = new int[][]{{1,2,3},{4,5,6},{7,8,9}};  // 二维数组静态初始化
        for(int i = 0; i<data.length; i++){
            System.out.println();
            for (int j = 0; j<data[i].length; j++){
                System.out.print("data[" + i + "][" + j + "] = " + data[i][j] + "\t");
            }
        }
    }
}

// 运行结果:

data[0][0] = 1	data[0][1] = 2	data[0][2] = 3	
data[1][0] = 4	data[1][1] = 5	data[1][2] = 6	
data[2][0] = 7	data[2][1] = 8	data[2][2] = 9	

foreach循环操作二维数组案例：

public class ArrayDemo {
    public static void main(String[] args) {
        int[][] data = new int[][]{{1,2,3},{4,5,6},{7,8,9}};  // 二维数组静态初始化
        for(int temp[] : data){   // 将二维数组data每个元素依次传递给 temp[]（就是数组的每一行）
            for (int num : temp){  // 再将行拿来处理
                System.out.print(num + "\t");
            }
            System.out.println();
        }
    }
}

// 运行结果
1	2	3	
4	5	6	
7	8	9

数组排序

在进行类设计的时候，如果在类中没有属性存在的意义，那么定义的方法就没有必要需要在有实例化对象产生的情况下才可以调用，我们可以使用static 关键字申明静态方法，直接使用类名调用，如下：

class ArrayUtil {
    public static void sort(int data[]){
        for (int i = 0; i < data.length ; i++){
            for (int j = 0 ; j< data.length -i -1 ;j++){ 
                if(data[j] > data[j+1]){  // 交换元素 
                    int temp = data[j];
                    data[j] = data[j+1];
                    data[j+1] = temp;
                }
            }
        }
    }
    public static void getInfo(int data[]){
        for (int i = 0;i<data.length;i++){
            System.out.print(data[i] + "\t");
        }
    }
}

public class ArrayDemo {
    public static void main(String[] args) {
        int[] data = new int[] {55,23,12,5,1,0,77,26,35,48};
        ArrayUtil.sort(data);  // 因为类ArrayUtil中没有属性存在，因此可以直接定义静态方法，用类名调用。就可以避免实例化对象。
        ArrayUtil.getInfo(data);
    }
}

// 运行结果

0	1	5	12	23	26	35	48	55	77	

数组转置

class ArrayUtil {
    public static void reverse(int data[]){
        int len = data.length;int temp;
        for (int i=0;i<(len / 2);i++){
            temp = data[i];
            data[i] = data[len-i-1];
            data[len-i-1] = temp;
        }
    }
    public static void getInfo(int data[]){
        for (int i = 0;i<data.length;i++){
            System.out.print(data[i] + "\t");
        }
    }
}

public class ArrayDemo {
    public static void main(String[] args) {
        int[] data = new int[] {10,11,12,13,14,15};
        ArrayUtil.reverse(data);
        ArrayUtil.getInfo(data);
    }
}

// 运行结果

15	14	13	12	11	10

数组相关类库

数组排序：

java.util.Arrays.sort(数组名称)；

class ArrayUtil {
    public static void getInfo(int data[]){
        for (int i = 0;i<data.length;i++){
            System.out.print(data[i] + "\t");
        }
    }
}

public class ArrayDemo {
    public static void main(String[] args) {
        int[] data = new int[] {10,11,12,13,14,15};
        java.util.Arrays.sort(data);
        ArrayUtil.getInfo(data);
    }
}

数组拷贝

System.arraycopy(源数组,源数组起始点,目标数组开始点,拷贝长度);

package com.itheima;

class ArrayUtil {
    public static void getInfo(int data[]){
        for (int i = 0;i<data.length;i++){
            System.out.print(data[i] + "\t");
        }
    }
}

public class ArrayDemo {
    public static void main(String[] args) {
        int[] dataA = new int[] {10,11,12,13,14,15};
        int[] dataB = new int[] {1,2,3,4,5,6,7,8};
        System.arraycopy(dataA,0,dataB,0,3);
        ArrayUtil.getInfo(dataB);
    }

}

方法可变参数

传统解决方式（用数组解决）

package com.itheima;

class ArrayUtil {
    public static int sum(int [] data){
        int sum = 0;
        for(int temp : data){
            sum += temp ;
        }
        return sum;
    }
}

public class ArrayDemo {
    public static void main(String[] args) {
        System.out.println(ArrayUtil.sum(new int[] {1,2,3}));
    }
}

// 运行结果

6

可变参：

class ArrayUtil {
    public static int sum(int ... data){   // 方法可变参数，实际上就是变相的一种数组应用
        int sum = 0;
        for(int temp : data){
            sum += temp ;
        }
        return sum;
    }
}

public class ArrayDemo {
    public static void main(String[] args) {
        System.out.println(ArrayUtil.sum(new int[] {1,2,3}));
        System.out.println(ArrayUtil.sum(4,5,6));
    }
}

对象数组

定义格式：
动态初始化
类 对象数组名称 [] = new 类 [长度]；   每一个元素内容都是null
静态初始化
类 对想数组名称[] = new 类 [] {实例化对象,实例化对象.......}；

使用动态初始化定义对象数组

class Person{
    private String name;
    private int age;

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    public String getInfo(){
        return "姓名:" + this.name + "\t年龄:" + this.age;
    }

    // setter getter 省略
}
public class ArrayDemo {
    public static void main(String[] args) {
        Person[]  per = new Person[2];
        per[0] = new Person("张三",14);
        per[1] = new Person("李四",20);
        for (int i = 0;i < per.length ;i++){
            System.out.println(per[i].getInfo());
        }
    }
}

// 运行结果


姓名:张三	年龄:14
姓名:李四	年龄:20