Java复习（5）数据类型、数组

数据类型

Java 数据类型分为：基本数据类型 与 引用数据类型

1.基本数据类型

基本数据类型包括 6种数字类型 和 字符类型、布尔类型，其中6种数字类型又可以分为 4个整数类型和两个浮点型。

2.引用数据类型

1. 数组 []
2. 类class（抽象类 abstract class）
3. 接口（interface）
4. 枚举（enum）
5. 注解（@interface）

3. 类型转化

1. 同种类型可以直接进行赋值操作
2. 数据类型不同
   1. 基本数据类型与引用类型不可以直接进行转化，但是间接可以，通过封装类/包装类
   2. 基本类型之间可以直接转化（自动 强制）
      1. 如果类型相同，直接转化
      2. 如果是小的转大的，自动转化
      3. 如果是大的转小的，可以强制类转换，但是有精度缺失
      4. 如果是整数向浮点数转化，可以
      5. 如果是浮点数向整数转化，可以强制类转换，但是有精度缺失
      6. char 与 int 之间的转化：字符对应的Unicode码
      7. int 与 char 之间的转化，可以强制类转换
      8. 布尔类型很特殊，不可以与其他基本类型转化
3. 引用类型之间可以直接转化（自动 强制）
4. 注意：数据进行计算的时候，byte short char 会自动提升到int类型

例子：

---

数组

数组：可以储存多个 同种类型元素 的集合，既可以存储基本数据类型，也可以存贮引用数据类型

一维数组

1. 语法：
   

2. 数组的初始化：

   1. 动态初始化：只指定长度，由系统给出初始化值
      
   2. 静态初始化 ：给出初始化值，由系统决定长度

3. 数组名的含义：
   
   

4. 数组在内存中是如何分布的？
   首先说说内存的分布？

   • 栈：存储局部变量（局部变量：定义在方法生声明上和方法中的变量）
   • 堆：存储new出来的数组或者对象
   • 方法区
   • 本地方法区：和系统相关
   • 寄存器：给CPU使用

5. 使用数组常见的错误

   1. ArrayIndexOutOfBoundsException：数组索引越界异常，原因：访问了不存在的索引
      
   2. NullPointerException：空指针异常，原因：数组已经不存在堆内存了，你还去用数组名访问元素
      

6. 一维数组的遍历

public static void ARRAY3( ){
    int[] arr = {11,22,33,44,55};
    System.out.println(arr.length);

    for(int i =0; i<arr.length;i++){
        System.out.println(arr[i]);
    }
}

//最好弄成一个方法
public static void ARRAY3(){
    int[] arr = {11,22,33,44,55};
    ArrayBianli( arr);
}

/*
数组的遍历
1，返回值类型void
2，参数列表<u>int</u>[] <u>arr</u>
*/
public static void ArrayBianli(int[] arr){
    for(int i =0; i<arr.length;i++){
        System.out.println(arr[i]);
    }
}


/*
获取数组的最大值
1，返回值类型<u>int</u>
2，参数列表<u>int</u>[] <u>arr</u>
*/
public static int ArrayMax(int[] arr){
    int max = arr[0];
    for(int i =1; i<arr.length;i++){
        if (arr[i] >= max) {
            max=arr[i] ;
        }
    }
    return max;
}

/*
数组的反转
1，返回值类型void
2, 参数列表int[] arr
*/

public static void ArrayInvert(int[] arr){
    int[] arr1 = arr;
    for(int i =0; i<(arr.length/2);i++){

    //交换 首尾
    //<u>arr</u>[0] 与 <u>arr</u>[arr.length-1-0]
    //<u>arr</u>[1] 与 <u>arr</u>[arr.length-1-1]
    //<u>arr</u>[2] 与 <u>arr</u>[arr.length-1-2]
    //<u>arr</u>[i] 与 <u>arr</u>[arr.length-1-i]

    //结束条件？i<(arr.length/2)
    int temp = arr[i];
    arr[i] = arr[arr.length-1-i];
    arr[arr.length-1-i] = temp;
    }
}

二维数组

1. 语法

数据类型[][] name = new 数据类型[][];

//例子
int[][] arr = new int[3][2];  //这是一个二维数组，包含三个一维数组，每个一位数组中有两个元素
int[] arr1[] = new int[3][2];  //还可以这么写
int arr2[][] = new int[3][2];   //还可以这么写

int[] x,y[];   //x是一维数组，y是二维数组

2. 初始化

//不进行初始化
public static void Demo_Array1(){
	int[][] arr = new int[3][];
	
	System.out.println(arr[0]);  //null  数组的默认初始化值为null
	System.out.println(arr[1]);  //null
	System.out.println(arr[2]);  //null
	
	arr[0] = new int[3];
	arr[1] = new int[5];
	
	System.out.println(arr[0]);  //[I@15db9742
	System.out.println(arr[1]);  //[I@6d06d69c
	System.out.println(arr[2]);  //null
}

//进行初始化
public static void Demo_Array2(){
	int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
	
	System.out.println(arr);  //[[I@7852e922  
	System.out.println(arr[0]);  //[I@4e25154f
	System.out.println(arr[1]);  //[I@70dea4e
	System.out.println(arr[2]);  //[I@5c647e05
	System.out.println(arr[0][0]);  //1
	System.out.println(arr[0][1]);  //2
	System.out.println(arr[0][2]);  //3
	System.out.println(arr[1][0]);  //4
	System.out.println(arr[1][1]);  //5
	System.out.println(arr[2][0]);  //6
	System.out.println(arr[2][1]);  //7
	System.out.println(arr[2][2]);  //8
	System.out.println(arr[2][3]);  //9
}

3. 二维数组在内存中的分布
   

4. 二维数组的遍历

public static void Demo2() {
         int[][] arr = {{1,2,3},{4,5},{6,7,8,9,}};
         for(int i = 0; i < arr.length; i++) {
             for(int j =0;j<arr[i].length;j++) {
                 System.out.println(arr[i][j]);
             }
         }
    }

二维数组在 Java 与 C 中的区别

• Java中的二维数组可以不定义列数，但必须定义行数 int[][] arr = new int[3][];
• C中的二维数组可以不写行数，但是得写列数 int arr[][4] = {{1,2},{3,4}};
• 这样的差别是因为java与C的二维数组在底层存储方式的不同，c中虽然是二维数组，但是底层是连在一起的：

数组传值与传地址问题

在C++中，存在传值与传地址的问题，在java中也存在，但是java中是这样的，如果是普通数据类型，传递的就是值，如果是引用数据类型，传递的就是地址。什么意思呢？看下面的代码

1. 基本数据类型的值传递，不改变原值，因为调用后就会弹出栈，局部变量随之消失。

public static void Demo3() {
         int a= 10;
         int b=20;
         System.out.println("a:"+a+"b:"+b);
         change(a,b);
         System.out.println("a:"+a+"b:"+b);    //a:10b:20
    }
    public static void change(int a, int b) {
         System.out.println("a:"+a+"b:"+b);
         a = b;
         b = a+b;
         System.out.println("a:"+a+"b:"+b);
    }

2. 引用数据类型的值传递，改变原值，因为即使方法弹栈，但是堆内存数组对象还在，可以通过地址继续访问

public static void Demo4() {
         int[] arr = {1,2,3,4,5};
         for(int i =0; i<arr.length;i++) {
             System.out.println(arr[i]);    //1,2,3,4,5
         }
         System.out.println("------------------");
         change(arr);
         for(int i =0; i<arr.length;i++) {
             System.out.println(arr[i]);     //2,4,6,8,10
         }
    }
    public static void change(int[] arr) {
         for(int i =0; i<arr.length;i++) {
             arr[i] *= 2;
         }
    }

所以问题:Java中到底是传值还是传址？
1，即是传值，也是传址，基本数据类型传递的是数值，引用数据类型传递的是地址
2，标准答案是：Java中只有传值，因为地址值也是值（Java之父说的）