第六课：数组和字符串

一、数组的定义与格式

1、定义：存储同一种数据类型的多个元素的容器

2、格式：

• 数据类型[ ] 数组名； eg. int [] a; 定义一个int类型的数组a变量
• 数据类型 数组名[ ]； eg. int a [ ] ; 定义一个int类型的a数组变量

二、数组的初始化

1、动态初始化

• 初始化时只指定数组长度，由系统为数组分配初始值

• 格式：数据类型[ ] 数组名= new 数据类型[数组长度]

  int []arr = new int[3];
  //定义了一个int类型的数组，这个数组中可以存放3个int类型的值
  

*补充知识 ——Java中的内存分配

Java程序在运行的时候，需要在内存中分配空间，为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理方式和内存管理方式

局部变量：在方法定义中或者方法声明上的变量都称为局部变量

堆内存的特点：

• ①每一个new出来的东西都有地址值

• ②每个变量都有默认值：

  byte，short，int，long默认为0；

  float，double默认为0.0；

  char默认为\u0000；

  booean默认为false；

  除此之外的引用类型默认null

• ③堆内存使用完毕就变成垃圾，但是并没有立即回收，会在垃圾回收器空闲的时候回收（栈内存的数据是用完就释放掉）

2、静态初始化

• 初始化时只给出初始值，由系统决定数组长度

• 格式：数据类型 [] 数组名 = new 数据类型 [ ] {元素1，元素2…}；

  int[] arr = new int[] {1,2,3};
  //定义了一个int类型的数组，这个数组中可以存放三个int类型的值，并且值分别是1，2，3
  int[] arr = {1，2，3};   //简化的写法
  

三、数组操作的常见问题

1、下标越界

数组下标由0开始，n个元素的数组下标最大是array[n-1]，很容易写成array[n]，这样就会下标越界。

2、空指针异常

//引用类型的常量，空常量，null
arr = null;
System.out,println(arr[0]);

此时数组为空常量，相当于数组名是个空指针，已经不再指向堆内存了，而我们依旧用了数组名去访问元素，就会导致空指针异常。

3、待补充。。。

四、数组的相关算法

1、数组的遍历

Java提供了数组长度属性，直接数组名.length就可以获取数组长度，常用作循环遍历数组的结束控制条件

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

2、获取数组的最大值

//求数组最大值的方法
public static int getMax(int[] arr)
{
    int max;
    for(int i=0;i<arr.length;i++)
    {
        if(arr[i]>max)
        {
            max=arr[i];
        }
    }
    System.out.println("max = "+max);
}

3、数组的逆置

public static void reverse(int[] arr)
{
    for(int i=0;i<arr.length/2;i++)
    {
        int temp = arr[i];
        arr[i] = arr[arr.length-1-i];
        arr[arr.length-1-i] = temp;
    }
}

4、数组的查找算法

pubic static void getIndex(int[] arr,int e)
{
    for(int i=0;i<arr.length;i++)
    {
        if(e==arr[i])
        {
            System.out.println("你要找的元素位于数组arr["+i+"]中");
            //如果要返回索引值i，加return i;返回类型改为int就行
        }
        else
            System.out.println("你要找的元素不在数组内");
            //如果要返回索引值i，没找到这个元素就返回-1 不要没有返回值
    }
}

五、二维数组

1、二维数组的定义格式

（1）数据类型[ ] [ ] 变量名 = new 数据类型[m] [n]

int [][] arr = new int[2][3];

（2） 数据类型[ ] [ ] 变量名 = new 数据类型[m] []

int [][] arr = new int[2][];

（3） 数据类型[ ] [ ] 变量名 = new 数据类型[] [] {{元素…} ，{元素…} , {元素…} , …}

int [][] arr = new int[][]{{1,2,3},{4,5},{6}};
//简化成如下也可以
int [][] arr = {{1,2,3},{4,5},{6}};

2、二维数组的相关算法

（1）二维数组的遍历

二维数组遍历的外循环控制的是二维数组的长度，其实就是一维数组的个数，内循环控制的是一维数组的长度

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

/*需求：用二维数组打印输出杨辉三角(行数可以键盘录入)
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
...

分析：
A：任何一行的第一列和最后一列都是1
B：从第三行开始，每一个数据是它上一行的前一列与它上一行的本列之和

步骤
A：定义一个二维数组，行数如果是n，我们把列数也先定义为n (n来自键盘输入)
B：给这个二维数组任何一行的第一列和最后一列赋值为1
C：按照规律给其他元素赋值：从第三行开始，每个数据是它上一行的前一列与它上一行的本列之和
D：遍历这个二维数组

*/

import java.util.Scanner;
class PascalTriangle
{
    public static void main(string[] args)
    {
        //键盘录入获取行数
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你想要输出的杨辉三角的行数：")
        int n = sc.nextInt();
        
        //定义二维数组
        int [] arr = new int[n][n];
        
        //给这个二维数组任何一行的第一列和最后一列赋值为1
        for(int i=0;i<arr.length;i++)
        {
            arr[i][0] = 1;//任何一行的第一列
            arr[i][i] = 1;//任何一行的最后一列
        }
        
        //按照规律给其他元素赋值
        for(int i=2;i<arr.length;i++)
        //从第三行开始，所以i从2开始
        {
            for(int j=1;j<i-1;j++)
            //从第二列开始，所以j从2开始，到倒数第二列结束
            {
                //每个数据是它上一行的前一列与它上一行的本列之和
                arr[x][y] = arr[x-1][y-1] + arr[x-1][y];
                
            }
         }
        
        //遍历这个二维数组
        for(int i=0;i<arr.length;i++)
        {
            for(int j=0;j<i;j++)
            //将内循环的结束条件变为j<i就可以三角输出
            {
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
         }   
    }
}