java知识简要总结（四）---java数组

java知识简要总结（四）—java一维数组

1.什么是数组

​ 数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。

2.数组定义格式

1.数据类型[] 数组名

int[] arr;    

2. 数据类型 数组名[]

int arr[];

3.数组动态初始化

1.定义

数组动态初始化就是只给定数组的长度，由系统给出默认初始化值

2.动态初始化格式

// 数据类型[] 数组名 = new 数据类型[数组长度];
int[] arr = new int[3];

3.动态初始化格式详解

• 等号左边：

  • int:数组的数据类型

  • []:代表这是一个数组

  • arr:代表数组的名称

• 等号右边：

  • new:为数组开辟内存空间

  • int:数组的数据类型

  • []:代表这是一个数组

  • 5:代表数组的长度

    4.数组静态初始化

    4.1数组静态初始化定义

    在创建数组时，直接将元素确定

    4.2静态初始化格式

    • 完整版格式

      数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
      

    • 简化版格式

      数据类型[] 数组名 = {元素1,元素2,...};
      

  示例代码：

public class ArrayDemo {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {1, 2, 3};

        //输出数组名
        System.out.println(arr);

        //输出数组中的元素
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

5.数组元素访问

5.1索引

每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。

这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。

5.2访问数组元素格式

数组名[索引];

6.内存分配

6.1内存概述

内存是计算机中的重要原件，临时存储区域，作用是运行程序。

我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的。

必须放进内存中才能运行，运行完毕后会清空内存。

Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

6.2 Java中的内存分配

• 目前我们只需要记住两个内存，分别是：栈内存和堆内存

区域名称	作用
寄存器	给CPU使用，和我们开发无关。
本地方法栈	JVM在使用操作系统功能的时候使用，和我们开发无关。
方法区	存储可以运行的class文件。
堆内存	存储对象或者数组，new来创建的，都存储在堆内存。
方法栈	方法运行时使用的内存，比如main方法运行，进入方法栈中执行。

7.数组操作的两个常见小问题

7.1索引越界异常

• 出现原因

  public class ArrayDemo {
      public static void main(String[] args) {
          int[] arr = new int[3];
          System.out.println(arr[3]);
      }
  }
  

  数组长度为3，索引范围是0~2，但是我们却访问了一个3的索引。

  程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

• 解决方案

  将错误的索引修改为正确的索引范围即可！

7.2空指针异常

• 出现原因

  public class ArrayDemo {
      public static void main(String[] args) {
          int[] arr = new int[3];
  
          //把null赋值给数组  变量arr将不会在保存数组的内存地址，也就不允许再操作数组了   会报空指针异常
          arr = null;
          System.out.println(arr[0]);
      }
  }
  

  arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

• 解决方案

  给数组一个真正的堆内存空间引用即可！

8.一维数组遍历

数组遍历：就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。

数组的索引是 0 到 lenght-1 ，可以作为循环的条件出现

public class ArrayTest01 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {11, 22, 33, 44, 55};

        //使用通用的遍历格式
        for(int x=0; x<arr.length; x++) {
            System.out.println(arr[x]);
        }
    }
}

9.获取数组最大值

• 最大值获取：从数组的所有元素中找出最大值。

• 实现思路：

  • 定义变量，保存数组0索引上的元素
  • 遍历数组，获取出数组中的每个元素
  • 将遍历到的元素和保存数组0索引上值的变量进行比较
  • 如果数组元素的值大于了变量的值，变量记录住新的值
  • 数组循环遍历结束，变量保存的就是数组中的最大值

代码实现：

public class ArrayTest02 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {12, 45, 98, 73, 60};

        //定义一个变量，用于保存最大值
        //取数组中第一个数据作为变量的初始值
        int max = arr[0];

        //与数组中剩余的数据逐个比对，每次比对将最大值保存到变量中
        for(int x=1; x<arr.length; x++) {
            if(arr[x] > max) {
                max = arr[x];
            }
        }

        //循环结束后打印变量的值
        System.out.println("max:" + max);

    }
}

10.填充替换数组元素

数组中的元素定义完成之后，可以通过Arrays类的静态方法fill()对数组中的元素进行替换。

该方法通过各种重载形式可完成对任意类型的数组元素的替换。

1. fill(int[] a,int value)

该方法可以将指定的int值value分配给a数组中的每个元素。

2. fill(int[] a, int fromIndex,int toIndex, int value)

   该方法将指定的int值分配给数组a中指定索引范围内的每个元素，范围从fromIndex(包括)到toIndex(不包括)，

   如果起始索引值等于终止索引值，填充范围为空。

代码演示：

package test;

import java.util.Arrays;

public class FillArrayTest {
    public static void main(String[] args) {
        int[] a = {0,1,2,2,4,74,78,65,45};
        Arrays.fill(a,0,5,6);
        for (int i = 0; i < a.length; i++) {
            System.out.println("a数组中得1第"+ i +"个元素是："+ a[i]);
        }
    }
}

/**
a数组中得1第0个元素是：6
a数组中得1第1个元素是：6
a数组中得1第2个元素是：6
a数组中得1第3个元素是：6
a数组中得1第4个元素是：6
a数组中得1第5个元素是：74
a数组中得1第6个元素是：78
a数组中得1第7个元素是：65
a数组中得1第8个元素是：45

Process finished with exit code 0
*/

11.对数组进行排序

Arrays类的sort()方法提供了多种重载形式，可以对任意类型的数组进行升序排序。

注意：Java中的String类型数组的排序算法是根据字典编排顺序排序的，因此数字排在字母前面，大写字母排在小写字母前面

语法：

Arrays.sort(object)
// object  表示需要进行排序的数组名称

代码：

package test;

import java.util.Arrays;

// 对int型数组进行升序排序
public void sortArrayTest(){
        int[] a = {0,1,2,2,4,74,78,65,45};
        Arrays.sort(a);
        for (int i : a) {
            System.out.print(i + ",");
        }
    }
// 0,1,2,2,4,45,65,74,78


// 对汉字String字符串数组进行排序（一般不用，没有深入）
    public void sortStringArrayTest1(){
        String [] a = {"赵","钱","孙","李","周","吴"};
        Arrays.sort(a);
        for (String i : a) {
            System.out.print(i + ",");
        }
    }
// 吴,周,孙,李,赵,钱

// 对使用数字，大小写字母的String字符串数组进行升序排序
public void sortStringArrayTest2(){
        String [] a = {"a赵","A钱","b孙","C李","D周","1吴"};
        Arrays.sort(a);
        for (String i : a) {
            System.out.print(i + ",");
        }
    }
// 1吴,A钱,C李,D周,a赵,b孙,

12.复制数组

Arrays类的copyOf()方法是复制数组到指定长度，

copyOfRange()方法则将指定数组的指定长度复制到一个新数组中。

1. copyOf()方法

   该方法提供多种重载形式，满足不同类型数组的复制

   语法：

   copyOf(arr,int newlength);
   // arr: 要进行复制的数组名称
   // newlength: 复制后的新数组的长度  
   

   注意：如果newarr.length > arr.length,需要填充的值由数据类型决定，如果是整型，用0，char型用null，

   ​ 如果newarr.length < arr.length,则从就数组的第一个元素开始进行填充，满足新数组的长度即可。

   代码演示：

   package test;
   
   import java.util.Arrays;
    
      public void copyOfArrayTest(){
           String[] a = {"a赵","A钱","b孙","C李","D周","1吴"};
           String[] strings = Arrays.copyOf(a, 3);
           for (String i : strings) {
               System.out.print(i + ",");
           }
       }
   // a赵,A钱,b孙,
   

   2. copyOfRange()方法

      语法：

      copyOfRange(arr,int fromIndex，int toIndex);
      // arr: 要进行复制的数组名称
      // fromIndex ： 起始索引位置，在0与旧数组长度之间，复制时包括此索引的值
      // toIndex： 终止索引位置，可以大于旧数组长度，新数组复制时不包括此索引的值
      

      代码演示：

      package test;
      
      import java.util.Arrays;
      public void copyOfRangeArrayTest() {
              int[] a = {0,1,2,3,4,5,6,};
              int[] arr = Arrays.copyOfRange(a, 0,3);
              for (int i : arr) {
                  System.out.print(i + ",");
              }
          }
          // 0,1,2,
      

13.数组查询

Arrays类的binarySearch()方法，可以使用二分搜索法搜索指定数组，获得指定对象，方法返回要搜索的元素的索引值。

该方法提供多种重载形式，满足各种类型数组的查找需要。

1. binarySearch()方法

   语法：

   binarySearch(Objerct[] a,Object key);
   // a:要搜索的数组名称
   // key： 要搜索的值
   

**注意：**如果key包含在数组中，则返回搜索值得索引；否则返回-1或者“-” 插入点

​ 插入点是搜索值将要插入数组的那一点，即第一个大于这个搜索值的元素索引。

**务必注意：**数组必须经过排序才可以使用此方法，否则返回下标显示不准。

代码演示：

import java.util.Arrays;
 
public class ArraysBinarySearch {
    public static void main(String[] args) {
        int arr[] = new int[]{3, 5, 7, 9, 11, 13};
 
        Arrays.sort(arr);
 
        for (int i = 0; i < 17; i++) {
            System.out.println("数字【" + i + "】：" + Arrays.binarySearch(arr, i));
        }
    }
}
结果：
数字【0】：-1
数字【1】：-1
数字【2】：-1
数字【3】：0
数字【4】：-2
数字【5】：1
数字【6】：-3
数字【7】：2
数字【8】：-4
数字【9】：3
数字【10】：-5
数字【11】：4
数字【12】：-6
数字【13】：5
数字【14】：-7
数字【15】：-7
数字【16】：-7

技巧：

[1] 搜索值不是数组元素，且在数组范围内，从1开始计数，得“ - 插入点索引值”；

[2] 搜索值是数组元素，从0开始计数，得搜索值的索引值；

[3] 搜索值不是数组元素，且小于数组内元素，索引值为 – 1；

[4] 搜索值不是数组元素，且大于数组内元素，索引值为 – (length + 1);

2. binarySearch(Object[] a, int fromIndex, int toIndex, Object key)

   语法：

a：要搜索的数组

fromIndex：指定范围的开始处索引（包含）

toIndex：指定范围的结束处索引（不包含）

key：要搜索的值

如果要搜索的元素key在指定的范围内，则返回搜索值的索引；否则返回-1或“-”（插入点）。

技巧：

[1] 该搜索键在范围内，但不是数组元素，由1开始计数，得“ - 插入点索引值”；

[2] 该搜索键在范围内，且是数组元素，由0开始计数，得搜索值的索引值；

[3] 该搜索键不在范围内，且小于范围（数组）内元素，返回–(fromIndex + 1)；

[4] 该搜索键不在范围内，且大于范围（数组）内元素，返回 –(toIndex + 1)。
示例：

代码演示：

   import java.util.Arrays;

public class ArraysBinarySearch2 {
    public static void main(String[] args) {
        int arr[] = new int[]{3, 5, 7, 9, 11, 13};
   Arrays.sort(arr);
 
    for (int i = 0; i < 17; i++) {
        System.out.println("数字【" + i + "】：" + Arrays.binarySearch(arr, 1, 4, i));
    }
}

}
结果：

数字【0】：-2
数字【1】：-2
数字【2】：-2
数字【3】：-2
数字【4】：-2
数字【5】：1
数字【6】：-3
数字【7】：2
数字【8】：-4
数字【9】：3
数字【10】：-5
数字【11】：-5
数字【12】：-5
数字【13】：-5
数字【14】：-5
数字【15】：-5
数字【16】：-5
分析：

fromIndex是1，toIndex是4，即范围内的数字是 5,7,9

比5小的数字，= –(fromIndex + 1) = -2

比9大的数字，= -(toIndex + 1) = -5

其实在范围内的数字，规律与不带索引的方法一样的处理方式，比如：

1）数字8不属于数组，但在范围内，且在插入索引4，所以索引从1开始计数，应该为-4。

2）数字7属于数组，所以索引从0开始计数，应该为2

版权声明：13小节大部分内容为CSDN博主「AllenLeungX」的原创文章内容，遵循CC 4.0 BY-SA版权协议，
原文链接：https://blog.csdn.net/londa/article/details/119296502

14.数组排序算法

常用的排序算法发包括冒泡排序、直接选择排序和反转排序。

14.1冒泡排序

14.1.1.名称由来

排序数组的过程总是将小数往前放，大数往后放，类似于水中气泡往上升的动作，所以称为冒泡排序。

14.1.2.基本思想

对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动的前面，较大的元素移动到后面。

14.1.3.算法实现

双层循环实现:

外层循环控制排序轮数，一般为数组长度-1，即arr[].length-1;因为最后一次循环只剩最后一个元素，不需要进行对比，此时已经完成排序了。

内层循环主要对比相邻元素的对比，确认是否交换位置，对比交换次数随着排序轮数减少。

    // 冒泡排序
   public void  bubbleSortArrayTest(){
        int[] a = {45,78,954,4,6,7,63};

       for (int i = 1; i < a.length; i++) {   // 控制循环轮数   数组长度-1
           for (int m = 0; m< a.length- i;m++){  // 控制比较交换次数  随着排序轮数减少
                if (a[m] > a[m+1]){
                    int temp = a[m];
                    a[m] = a[m+1];
                    a[m+1] = temp;
                }
           }
       }
       for (int i : a) {
           System.out.println(i + "<");
       }
   }

14.2 直接选择排序

直接选择排序比冒泡排序速度要快一些。

14.2.1.基本思想

将指定排序位置元素与其他数组元素分别对比，如果满足条件就交换元素值，这里是把满足条件的元素与指定的排序位置进行交换，使得排序好的位置逐渐扩大，最后整个数组排序好。

这样做彼冒泡排序交换次数少，速度会快些。

14.2.2.代码实现

   // 直接选择排序
    public void selectSortArrayTest(){
        int[] a = {45,78,954,4,6,7,63};

        int index;  // 初始化索引值对象
        for (int i = 1; i < a.length; i++) {   //外层循环控制排序轮数   等于数组长度减1
            index= 0 ;
            for (int j = 1; j <= a.length-i ; j++) {
                if (a[j] > a[index]){   // 从0索引处开始，其他索引处的值与其比较，获取最大值的索引
                    index = j;
                }
            }
            // 每轮循环完之后，交换正在a.length-i与index索引处的两个值
            int temp = a[a.length-i];
            a[a.length-i] = a[index];
            a[index] = temp;
        }   // 循环完成  排序完毕
        for (int i : a) {
            System.out.println(i + "<");
        }

    }

14.3反转排序

14.3.1 定义

反转排序就是以相反的顺序将原有数组的内容重新排序。

14.3.2基本思想

将数组中的最后一个元素与第一个元素替换，倒数第二个元素与正数第二个元素进行交换。。。

即对数组两边的元素进行交换，所以只需要循环数组长度的半数次即可。

14.3.3代码实现

    // 反转排序
    public void reverseSortArrayTest(){
        int[] arr = {0,1,2,3,4,5,6,7,8,9};

        int temp;
        int length = arr.length;
        for (int i = 0; i < length/2; i++) {
            temp = arr[i];   // 临时值等于索引值小的值
            arr[i] = arr[length-1-i]; // 索引值小处的值等于索引值大处的值
            arr[length - 1 -i] = temp; // 索引值大处的值等于临时值，完成数组对称索引处的值的交换
        }
        for (int i : arr) {  // 遍历数组
            System.out.print(i + ",");
        }
    }