小码笔记7：数组

一、概念

数组:一种容器，可以同时存放多个数据值

特征

- 引用数据类型
- 多个数据类型必须一致
- 程序运行期间长度不可改变

二、一维数组

数组初始化:就是为数组中的数组元素分配内存空间，并为每个数组元素赋值

1. 静态初始化（声明+创建）

静态初始化（指定内容）：不直接指定数据个数多少，视数据内容而定

标准格式：数据类型 [] 数组名 = new 数据类型[]{元素1,元素2,...}
常用格式：数据类型 [] 数组名 = {元素1,元素2,...}
int [] arr  = {1,2,3};

2.动态初始化

动态初始化（指定长度）：初始化时只指定数组长度，由系统为数组分配初始值

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

三、数组的操作

• 索引（index）:int数字，0-(数组长度-1)，代表数组元素的位置
• 取值格式：数组名[索引]
• 赋值格式：数组名[索引]=元素值

1.使用动态初始化，元素会自动拥有一个默认值:

• 整型默认0
• 浮点型默认0.0
• 字符型默认’\u0000’
• boolean型默认false
• 引用类型默认null

public static void main(String[] args) {
  int[] arr = new int[3];
  arr[0]=1;
  arr[1]=2;
  arr[2]=3;
  // 输出数组名
  System.out.println(arr); // [I@880ec60
  // 输出数组中的元素
  System.out.println(arr[0]);
  System.out.println(arr[1]);
  System.out.println(arr[2]);
}

2.异常

• 数组下标越界异常：
  数组arr的索引编号从0开始，一直到arr.length为止
  访问数组元素时，索引编号并不存在，将会发生数组越界异常

 ArrayIndexOutOfBoundsException

• 空指针异常：
  所有的引用数据类型变量，都可以赋值为null，代表什么都没有
  数组必须进行new初始化才能使用
  值为null的变量进行操作将会发生空指针异常
  NullPointerException

3.获取数组长度

• 数组名称.length 返回int,数组长度

//数组一旦创建，程序运行期间，数组长度不可改变
int[] arr=new int[3];
int a = arr.length

4.遍历数组

遍历：对数组每一个元素进行逐一输出

• for循环遍历

public static void main(String[] args) {
  int[] arr = { 11, 22, 33, 44, 55 };// 定义数组
  for (int i = 0; i < arr.length; i++) {// 使用通用的遍历格式
      System.out.println(arr[i]);
  }
}

• foreach遍历

for(type element: array){
  System.out.println(element);
}

5.求最值

找出元素最大值

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);
}

6.数组内存–Java内存

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

• 栈内存：
  存储局部变量
  定义在方法中的变量，例如：arr
  使用完毕，立即消失

• 堆内存：

  • 堆内存：存储new出来的内容(实体，对象)
  • 数组在初始化时，会为存储空间添加默认值:

整数：0
浮点数：0.0
布尔：false
字符：空字符
引用数据类型：null 

• 每一个new出来的东西都有一个地址值
• 使用完毕，会在垃圾回收器空闲时被回收

四、二维数组

1.声明创建

• 静态声明

int [][]arr={{1,3,4}{2,5,8,7}{1,9}};

• 动态声明

int arr[][]=new int[3][4];
//[4]可以不写 即二维数组元素可以不定长度

2.遍历

二维数组打印arr[0] 输出地址 一维数组打印arr输出地址
二维数组遍历得到一维数组，再遍历一维数组

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

五、冒泡排序

1.原理

一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所
有的数据进行操作，直至所有数据按要求完成排序
如果有n个数据进行排序，总共需要比较n-1次
每一次比较完毕，下一次的比较就会少一个数据参与

2.代码实现

/*
冒泡排序：
一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，
依次对所有的数据进行操作，直至所有数据按要求完成排序
*/
public class ArrayDemo {
    public static void main(String[] args) {
    //定义一个数组
    int[] arr = {24, 69, 80, 57, 13};
    System.out.println("排序前：" + arrayToString(arr));
    // 这里减1，是控制每轮比较的次数
    for (int x = 0; x < arr.length ­ 1; x++) {
    // ­1是为了避免索引越界，­x是为了调高比较效率
        for (int i = 0; i < arr.length ­ 1 ­ x; i++) {
              if (arr[i] > arr[i + 1]) {
                  int temp = arr[i];
                  arr[i] = arr[i + 1];
                  arr[i + 1] = temp;
                }
        }
    }
    System.out.println("排序后：" + arrayToString(arr));
}
//把数组中的元素按照指定的规则组成一个字符串：[元素1, 元素2, ...]
public static String arrayToString(int[] arr) {
      StringBuilder sb = new StringBuilder();
      sb.append("[");
      for (int i = 0; i < arr.length; i++) {
            if (i == arr.length ­ 1) {
              sb.append(arr[i]);
            } else {
              sb.append(arr[i]).append(", ");
              }
            }
            sb.append("]");
            String s = sb.toString();
      return s;
      }
}

3.常见的排序算法

• 冒泡排序

冒泡排序
    for(int i=0;i<a.length-1;i++){//控制外循环的次数
        for(int j=0;j<a.length-1-i;j++){//控制内循环次数，比外循环少一次，与下一个比较
            if(a[j]>a[j+1]){
                int temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
           }
        }
    }

• 选择排序

选择排序
    for (int i = 0; i < a.length-1; i++) {
        int k=i;
        for (int j = i; j < a.length-1; j++) {
            if (a[k]>a[j+1]) {
                k=j+1;
            }
        }
        if(i!=k){
            int temp=a[i];
            a[i]=a[k];
            a[k]=temp;
        }
    }

• 顺序查找

顺序查找
    public static int find(int []b,int a){
    for (int i = 0; i < b.length; i++) {
        if (a==b[i]) {
            return i;
        }
    }
    return -1;
    }

• 二分查找

二分查找
    public static int find(int b[],int a){
    int max=b.length-1;
    int min=0;
    for (int i = 0; i < b.length; i++) {
        int midle=(max+min)/2;
        if(a==b[midle]){
            return midle;
        }else if(a>b[midle]){
           min=midle+1;
        }else if(a<b[midle]){
            max=midle-1;
        }
    }  
return -1;
}