数组

数组的基本概念

数组就是一组相同类型元素的集合，在内存中是存放在连续的空间，每个空间都有自己的编号，最开始的编号默认是为 0 的

数组的创建

Java的数组创建语法：

数组元素类型【】 + 数组名 = new 数组元素类型【元素的个数】

例如：

整形数组
int[] arr = new int[10];
创建一个可以容纳 10 个 int 类型元素的数组

浮点型数组
double[] arr2 = new double[6];
创建一个可以容纳 6 个 double 类型元素的数组

字符串数组
String[] arr3 = new String[8];
创建一个可以容纳 8 个 String 类型元素的数组

数组的初始化

Java 的数组有二种初始化方式：

1.动态开辟数组,不初始化
在创建数组时，直接指定元素的个数，并且默认初始化为0
int []arr2 = new int[10];
这是只分配了空间，没有进行赋值，只有默认值 0

2.静态初始化
在创建数组时不指定元素的个数，而直接将数据内容赋值进去
int[] arr = {1,2,3};

1.动态初始化
int []arr2 = new int[]{1,2，3,4};
在创建数组时同时初始化,和静态初始化都是一样的，没有本质的区别

例如：

int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};
double[] array2 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = new String[]{"hell", "Word", "China"};

• 静态初始化虽然没有指定数组的长度，但是编译器会根据数组的元素个数来确认数组的长度

• 数组初始化时，{ } 里的元素必须和数组类型一样

• 静态初始可以省略掉 new int[ ]，动态初始化不能

• 如果在定义数组时没有初始化，之后要按照格式书写
  例如：

静态初始化
int[] array1;
array1 = new int[10];

动态初始化
int[] array2;
array2 = new int[]{10, 20, 30};

数组没有初始化的默认值

如果没有对数组进行初始化，数组中元素会有其默认值
比如：

如果数组存储元素类型为引用类型，默认值为 null

数组的使用

数组在内存中是一段连续的空间，数组可以通过下标访问其任意位置的元素
例如：
打印数组的所以元素，可以用历遍数组进行打印

 public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        for (int i = 0; i < 6; i++) {
            System.out.println(arr[i]);
        }
    }

方法二：
也可以通过数组名.lebght来获取数组的长度进行循环打印
数组名.lebght到专门计算数组的长度的

public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        for (int i = 0; i < arr.lenght; i++) {
            System.out.print(arr[i] + " ");
        }
         System.out.println(); // 换行
    }

方法三：
可以用for each，也叫做 增强 for 循环

public static void main(String[] args) {
         int arr[] = {1,2,3,4,5};
         for(int n : arr) {
             System.out.print( n + " ");
         }
           System.out.println(); // 换行
}

• for each 的参数
  第一个参数：自定义变量，类型要和数组类型一样
  第二个参数：数组的数组名
• for each是从数组里获取内容，再把内容赋值给左边的变量，然后输出
• 和上面的区别是，用for each 是拿不到数组的下标的
  如果是只要打印数组，就可以用for each

方法四：
在 Java 中有一个专门用来操作数组的，叫 Arrays.toString
Arrays.toString 的功能是：把数组转变成字符串，然后返回输出

public static void main(String[] args) {
         int[] arr = {1,2,3,4}; 
         String ret = Arrays.toString(arr);
         System.out.println(ret);
}

• 是把数组的内容转变成字符串的形式输出

数组是引用类型

JVM的内存分布

JVM对所使用的内存按照功能的不同进行了划分:

• 方法区(Method Area)
  用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数
  据. 方法编译出的的字节码就是保存在这个区域
• 堆(Heap)
  JVM所管理的最大内存区域. 使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2,3} )
  堆是随着程序开始运行时而创建，随着程序的退出而销毁，堆中的数据只要还有在使用，就不会被销毁
• 虚拟机栈(JVM Stack)
  与方法调用相关的一些信息，每个方法在执行时，都会先创建一个栈帧
  栈帧中包含有：局部变量表、操作数栈、动态链接、返回地址以及其他的一些信息保存的都是与方法执行时相的一些信息
  比如：局部变量。当方法运行结束后，栈帧就被销毁了，即栈帧中保存的数据也被销毁了
• 本地方法栈(Native Method Stack)
  本地方法栈与虚拟机栈的作用类似. 只不过保存的内容是Native方法的局部变量
  在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是一起的
• 程序计数器 (PC Register)
  只是一个很小的空间, 保存下一条执行的指令的地址

现在我们只简单的介绍堆 和 虚拟机栈这两块空间，后序JVM中还会更详细介绍

基本类型变量与引用类型变量的区别

基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的数值
而引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址
例如：

public static void func() {
int a = 10;
int b = 20;
int[] arr = new int[]{1,2,3};
}

上面代码在内存的分部

• 从上面的图片可以看出，a 和 b 是基本数据类型创建的变量，所以是直接存放的是对应的数值
• arr 数组由于是引用类型，它的数据内容存放在 堆区 中，而 arr 是数组类型的引用变量,存放的内容可以理解成是数组在堆空间中的首地址
• 引用变量并不直接存储对象本身，可以简单理解成存储的是对象在堆中空间的起始地址。通过该地址，引用变量便可以去操作对象。有点类似C语言中的指针，但是Java中引用要比指针的操作更简单。

引用变量

我们通过画图的方式更好理解引用变量

例如：

图解：

例题2：

图解：

总结：

1. 一个引用变量不能同时指向多个对象，引用变量就是存放数组的地址的变量
2. 对象如果没有引用变量指向它，那么会被 JVM 给自动回收

认识 null

null 在 Java 中表示 “空引用”
如果创建一个数组指向 null，它就是一个不指向对象的引用
null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置. 因此不能对这个内存进行任何读写操
作. 一旦尝试读写, 就会出现错误 （NullPointerException）
例如：

• 注意：
  Java 的 null 和 0 号地址的内存没有任何关联，和C语言不一样

方法的参数

参数传基本数据类型

例如：

• 这里的
• 如果方法的参数传的是基本数据类型，在 fukd方法中修改形参 a 的值, 不影响实参的 n值

参数传数据类型（引用数据类型）

例如：

• 这里是改变了数组的内容，并没有改变指向，所以方法里的n 数组和 arr 是指向同一个对象
• 如果方法的参数传的是数据类型，发现在 fukd 方法中对数组的内容进行修改，实参的内容也会更这进行更改
  这是因为数组是引用类型，按照引用类型来进行传递，是可以修改其中存放的内容的

例题二：

 // 方法一的结果是什么
    public static void fac1(int[] n) {
        n = new int[10];
    }
    // 方法二的结果是什么
    public static void fac2 (int[] str) {
        str[0] = 86;
    }
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        int[] arr2 = {1,2,3};
        fac1(arr);
        fac2(arr2);
        System.out.println(arr);
        System.out.println(arr2);
    }

• 题解：
  方法一：虽然传的是引用类型，但是 fac1方法里的n是指向了新的数组，同时改变了它的指向的对象
  
  方法二：
  
  结果：

总结：

• 数组的数值是放在堆上的，数组的名字只是个变量名（引用变量），用来存放地址的
• 引用变量目前是在 main 函数里面的，它属于局部变量，当函数结束就会被回收内存
  所谓的 “引用” 本质上只是存了一个地址，Java 将数组设定成引用类型，这样的话后续进行数组参数传参
  其实只是将数组的地址传入到函数形参中，这样可以避免对整个数组的拷贝
  数组可能比较长, 那么拷贝开销就会很大

数组作为函数的返回值

在Java 里是允许数组作为返回值的

• 需要注意：

1. 如果数组作为函数的返回值，那么方法的参数必须是 int[] 类型的
2. 接收方法的返回值必须和返回的类型一样

数组练习

数组转字符串

数组转字符串会用到一个工具，叫 Arrays.toString
Arrays.toString 的功能是：把数组转变成字符串，然后返回输出

public static void main(String[] args) {
         int[] arr = {1,2,3,4}; 
         String ret = Arrays.toString(arr);
         System.out.println(ret);
}

• Arrays.toString是把数组的内容转变成字符串的形式输出
  所以接收的类型必须是 String

模拟实现一个Arrays.toString

 public static String toString(int[] n) {
        if(n == null) {
            return "null";
        }
        String ret = "[";
        for (int i = 0; i < n.length; i++) {
            ret += n[i];
            if(i < n.length-1) {
                ret += ",";
            }
        }
        ret += "]";
        return ret;
    }
    public static void main(String[] args) {
        int[] arr = null;
        String ret = toString(arr);
        System.out.println(ret);

    }

• 注意：

1. 方法的返回值和接收值是 String 类型
2. 接下来就是拼接，需要注意的是 ， 是数组长度-1 个

数组的拷贝

数组拷贝会用到 Java 中的 Arrays.copyOf
Arrays.copyOf 是拷贝数组的

public static void main(String[] args) {
        int[] arr = {1,3,5,7,9};
        //把arr的内容拷贝到 str 中
        int[] str = Arrays.copyOf(arr,arr.length);
        //打印
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(str));
    }

• Arrays.copyOf的参数：
  第一个参数：拷贝内容的地址（引用变量）
  第二个参数：拷贝内容的长度

结果：

如果想把数组进行扩容并且拷贝那么，数组的大小乘个2就行
之后返回的数组就是原来大小的一倍
例如：

• 乘于数组大小的数字必须是整数，因为它的返回值是 int ,不能是浮点数

拷贝方法二：
这种支持局部的拷贝

System.arraycopy 的参数：
第一个参数：拷贝数组的地址
第二个参数：从下标为多少开始拷贝
第三个参数：拷贝的数据存放到哪里
第四个参数：拷贝的数据从哪里开始存放
第五个参数：拷贝数组的长度

拷贝方法三：
使用的是Arrays.copyOfRange

public static void main(String[] args) {
        int[] arr = {1,3,5,7,9};
        // 创建一个和arr数组一样大小的数组
        int[] str = Arrays.copyOfRange(arr,2,5);
        
        //打印
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(str));
    }

Arrays.copyOfRange 的参数：
第一个参数：拷贝数组的地址
第二个参数：从下标为多少开始拷贝
第三个参数：拷贝到下标为多少停止

结果：

注意：拷贝的是第三个参数-1的数字

拷贝方法四：
使用的是数组名.clone()
功能：产生一个镜像

以上的方法用的比较多的是 方法一的 Arrays.copyOf

求数组中元素的平均值

public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        double ret = avg(arr);
        System.out.println(ret);
    }
    public static double avg(int[] arr) {
        double sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        sum /= arr.length;
        return  sum;
    }

• 这很简单，把所有的元素加起来，再除以数组的元素个数
• 注意的点：方法返回值和接收是 double类型
  还有就是数组的大小是有lenght计算，不要自己去数

查找数组中指定元素(顺序查找)

public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        int k = 6;
        int ret = fer(arr,k);
        System.out.println(ret);
    }
    public static int fer(int[] n,int k) {
        for (int i = 0; i < n.length; i++) {
            if(n[i] == k){
                return i;
            }
        }
        return -1;// -1 表示没有找到
    }

• 用循环进行判断，找到返回i下标，没找到返回-1

二分查找

Java 的二分查找思路和C语言都是一样的

public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        int k = 6;
        int ret = binarySearch(arr,k);
        System.out.println(ret);
    }
    public static int binarySearch(int[] array,int k) {
        int left = 0;
        int right = array.length-1;
        while(left < right) {
            int mid = (right+left) / 2;
            if(array[mid] < k) {
                left = mid+1;
            } else if (array[mid] > k) {
                right = mid-1;
            } else {
                return mid;
            }
        }
        return -1;
    }

• 以上是我们自己写的二分查找
• 在 Java 里也是有提供封装好的二分查找，叫Arrays.binarySearch
  下面使用Java封装好的二分查找
  

排序数组

对一个无序数组进行排序
会使用到Java 的Arrays.sort，它是默认是升序

public static void main(String[] args) {
        int[] arr = {1,10,9,4,8,6,7,5,3,2};
        
        Arrays.sort(arr);
        
        System.out.println(Arrays.toString(arr));
    }

结果：

如果想要排成降序，就要增加比较器
例如：

 public static void main(String[] args) {
        Integer[] arr = {1,10,9,4,8,6,7,5,3,2};
        Arrays.sort(arr,new Comparator<Integer>(){
            public int compare(Integer o1,Integer o2) {
                return o2 -o1;
            }
        });
        System.out.println(Arrays.toString(arr));
    }

结果：

• 这个看不懂没关系，后面在接口时会讲到

数组逆序

public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9};
        reverse(arr);
        System.out.println(Arrays.toString(arr));

    }
    public static void reverse(int[] str) {
        int left = 0;
        int right = str.length-1;
        while(left<right) {
            int tmp = str[left];
            str[left] = str[right];
            str[right] = tmp;
            left++;
            right--;
        }
    }

总结

Arrays 里常用的工具
Arrays.toString 是把数组的内容转换成字符串打印
Arrays.sort 是对数组进行排序
Arrays.copyOf 是对数组进行拷贝
Arrays.copyOfRange 是对数组的局部进行拷贝
Arrays.equals 是用来判断二个数组是否相等，返回值是 boolean 类型
Arrays.fill 是用来对数组的所有元素进行初始化，也可以局部初始化

二维数组

二维数组的创建和初始化

二维数组的创建有三种，有点类型一维数组写法
例如：

1. 创建二维数组，没有初始化
int[][] arr = new int[2][3];

2.动态创建二维数组并且初始化
int[][] arr = new int[][] { {1,2,3},{4,5,6} };

3.静态创建二维数组并且初始化
int[][] arr = { {1,2,3},{4,5,6}};

二维数组的打印

方法一：和C语言一样的方式

C语言方式：
public static void main(String[] args) {
            int[][] arr = {{1,2,3},{4,5,6}};
            for (int i = 0; i < 2; i++) {
                for (int j = 0; j < 3; j++) {
                    System.out.print(arr[i][j] + " ");
                }
                System.out.println();
            }
        }
Java的方式：
public class Test {
    public static void main(String[] args) {
        int[][] arr = {{1,2,3},{4,5,6}};
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(Arrays.toString(arr[i]));
            }
            System.out.println();
        }
    }
}

结果：
最后的结果都是一样的

方法二：
使用 Java 中的工具 Arrays.deepToString
例如：

 public static void main(String[] args) {
        int[][] arr = {{1,2,3},{4,5,6}};
        System.out.println(Arrays.deepToString(arr));
    }

结果：

二维数组其实是特殊的一维数组

方法三：
使用 foreach来打印

public static void main(String[] args) {
        int[][] arr = {{1,2,3},{4,5,6}};
        for (int[] n: arr) {
            for (int x: n) {
                System.out.print(x + " ");
            }
            System.out.println();
        }
    }

结果：

不规则二维数组

在 Java 可以不写列，列的元素是可以自己指定

public static void main(String[] args) {
        int[][] arr = new int[2][];
        arr[0] = new int[3];
        arr[1] = new int[4];
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j] + " ");
            }
            System.out.println();
        }
    }

结果：

活动地址：CSDN21天学习挑战赛