2021.6.29-数组

## 复习

### java分区

(char  ‘\u0000’)(引用类型    null)
int [] arr = {1,2,3}
    SOP(arr);//数组内存地址值
char [] arr1 = {'a','b','c'}
    sout(arr1);/abc

### 应用

#### 遍历

(普通for循环、增强for循环、Arrays)

#### 最值

(参照)

#### 查找

(无序----依次比较    有序----折半查找)

----

#### 排序

对数组元素进行排列顺序

```java
package com.zjr.tedu.Day07;
/*
    冒泡排序
 */

public class MaoPaoDemo {
    public static void main(String[] args) {
        //无序数组
        int [] arr = {6,1,5,7,9,2};
        //嵌套循环实现冒泡排序
        //外层循环--控制轮数
        for (int i = 1 ; i < arr.length ; i++) {
            //内层循环--控制比较次数
            for (int j = 0 ; j < arr.length - i ; j++){
                if (arr[ j ] > arr[ j + 1 ] ){
                    int x = arr[j];
                    arr [ j ] =  arr[ j + 1 ];
                    arr [ j + 1] = x;
                }
            }
        }
        for (int i:arr){
            System.out.print(i + " ");
        }

    }
}
```

```java
package com.zjr.tedu.Day07;

import java.util.Arrays;

/*
    选择排序
 */
public class ChooseDemo {
    public static void main(String[] args) {
        //无序数组
        int [] arr = {6,1,5,7,9,2,8};
        //通过嵌套循环实现选择排序
        //外层循环--控制轮数
        for (int i = 1 ; i < arr.length ; i++) {
            //内层循环--控制比较元素的范围
            for (int j = i ; j < arr.length ; j++) {
                //选择一轮中不动的下标和后续所有的进行比较
                if (arr[ i - 1] > arr[ j ]){
                    int x = arr[ i - 1 ];
                    arr [ i - 1 ] = arr [ j ];
                    arr [ j ] = x ;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}
```

```java
package com.zjr.tedu.Day07;

import java.util.Arrays;
import java.util.Scanner;
import java.util.Vector;
/**
 * 键盘录入多个数据，以0结束，要求在控制台输出这多个数据中的最大值
 * @author lgt
 *
 */
public class MaoPaoPlus {
    public static void main(String[] args) {
        //输入
        System.out.println("请输入多个数据:");
        Scanner sc = new Scanner(System.in);
        //创建集合对象
        Vector<Integer> v = new Vector<Integer>();
        //控制输入数据，输入0表示结束
        while(true){
            int number = sc.nextInt();
            if(number != 0){
                v.add(number);
            }else{
                break;
            }
        }
        sc.close();
        System.out.println("---------排序前遍历输出数组---------");
        //把集合转成数组
        //创建数组对象
        Integer[] i = new Integer[v.size()];
        //转成数组
        v.toArray(i);
        //排序前遍历输出数组
        printArray(i);
        System.out.println("-------排序后遍历输出数组，并输出最大值--------");
        //排序
        Arrays.sort(i);
        //排序后遍历输出数组，并输出最大值
        printArray(i);
        System.out.println("最大值是：" + i[i.length-1]);
    }
    //遍历数组
    public static void printArray(Integer[] k){
        for(int i = 0; i < k.length; i++){
            if(i!= k.length -1){
                System.out.print(k[i] + ", ");
            }else{
                System.out.println(k[i]);
            }
        }
    }
}
```

#### 扩容

扩大/小数组 容器的容量（长度）--数组定义完成之后长度无法改变

```java
package com.zjr.tedu.Day07;
/*
    数组的扩容
 */

import java.util.Arrays;
public class KuoRongDemo {
    public static void main(String[] args) {
        //给定原数组
        int [] arr1 = {1,3,4,6,2};
        //目标数组：{1,3,4,6,2,0,0,0,0,0}
        //数组的扩容
        //新数组
        int [] arr2 = new int [arr1.length * 2 ] ;
        //数组的复制
        //System.arraycopy(原数组,拷贝的起始下标,目标数组,目标的起始下标,复制的个数)
        System.arraycopy(arr1,0,arr2,0,arr1.length);

        //数组地址值的复制
        arr1 = arr2 ;
        System.out.println(Arrays.toString(arr2));
    }
}
/*
    原数组:
    arr1 = {1,3,4,6,2}
    arr1 = Array.copyOf( arr1 , arr1.length * 2 )
    经过缩小后的数组:
    arr1 = {1,3}
*/ 
```

### 二维数组

#### 定义

存储的数据元素的一维数组的数组

#### 定义格式

1.数据类型[] [] 数组名 = new 数据类型 [二维数组长度] [一维数组长度];
        int [] [] arr = new int [3] [2]       定义了3个长度为2的一维数组，指定长度

```java
package com.zjr.tedu.Day07.ErWei;
/*
    二维数组定义格式
 */
public class Array2Demo {
    public static void main(String[] args) {
        //定义格式
        int [] [] arr = new int [3] [2] ;
        //数组名--二维数组的地址值：[[I@1540e19d
        System.out.println(arr);
        //第一个一维数组的地址值：[I@677327b6
        System.out.println(arr [0]);
        System.out.println(arr[0] [0]);
        //第一个一维数组的第三个元素，没有第三个元素
        //编译没错,运行错误，
        //ArrayIndexOutOfBoundsException
        //数组下标越界异常
        System.out.println(arr [0] [2]);
    }
}
```

2. 数据类型[] [] 数组名 = new 数据类型 [二维数组长度] [ ] ;

   ​    int [] [] arr = new int [2] [] ;
   代表声明了两个一维数组 
   给定初始值
   arr [ 0 ] = new int [ 3 ] ;
   arr [ 1 ] = new int [ ] [1,2,3,4
   arr [ 2 ] = {4,5,6}

```java
package com.zjr.tedu.Day07.ErWei;

public class ArrayMakeDemo2 {
    public static void main(String[] args) {
        //定义格式
        int [] [] arr1 = new int [ 2 ] [] ;
        //第一个一维数组地址值--null(不指向任何地址)
        //NullPointerException---空指针异常
        //地址值为null不指向任何内存区域集聚获取不到值，如果 强制执行就会报错
        System.out.println(arr1 [ 0 ]);
        //第一个一维数组的第一个元素
        System.out.println(arr1 [ 0 ] [0] );
    }
}
```

3. 数据类型 [] [] 数组名 = { {元素值1，元素值2··· } ，{元素值1，元素值2··· }，{元素值1，元素值2···}···}；
   int [] [] arr = {{1,2},{3,4,5}}；//指定值确定长度

```java
package com.zjr.tedu.Day07.ErWei;

public class ArrayMakeDemo3 {
    public static void main(String[] args) {
        //定义格式
        int [] [] arr = {{1,2,3},{4,5,6,},{7,8,9}};
    }
}
```

### 方法

#### 概念

把重复且有效的代码抽取的形式

#### 格式

​    修饰符、方法返回值类型、方法名（参数类型1    参数值1，参数类型2    参数值2，···）{
​        方法体；
​        return    返回值;
}
​    修饰符:public static 
​    方法返回值类型:根据方法的返回值类型提供对应的数据类型来接受方法返回值，可能没有返回值指定void来表示没有返回值
​    方法名:标识符
​    参数列表:由参数类型、参数个数、参数顺序共同决定
​    方法体:重复且有效的代码
​    return:把方法的返回值进行返回

#### 注意

1.方法一定要被调用才能执行
2.阿萨德
3.

#### 代码用例

```java
package com.zjr.tedu.Day07.TaiJiaoAnZhuang;
//IDEA边写边保存（自动编译）
public class MethodDemo1 {
    public static void main(String[] args) {
        System.out.println("12321364653");
        byte b = 127 ;
        System.out.println();
    }
}
```

```java
package com.zjr.tedu.Day07.TaiJiaoAnZhuang;

public class MethodDemo2 {
    public static void main(String[] args) {
        System.out.println("输出6行7列的*");
        for (int i = 0; i < 6 ; i++) {
            for (int j = 0 ; j < 7 ; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
        System.out.println("输出7行8列的*");
        for (int i = 0; i < 7 ; i++) {
            for (int j = 0 ; j < 8 ; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
        System.out.println("输出8行9列的*");
        for (int i = 0; i < 8 ; i++) {
            for (int j = 0 ; j < 9 ; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}
```

```java
package com.zjr.tedu.Day07.TaiJiaoAnZhuang;
/*
    方法调用
 */
public class MethodDemo3 {
    public static void main(String[] args) {
        //java规定方法不能嵌套(一个方法中不能定义另一个方法)
        printXing(6,7);
        printXing(7,8);
        printXing(8,9);
    }
    //定义一个可调用方法
    //方法返回值类型---直接打印，执行语句，不需要返回值
    //参数列表---int m ，int n 控制行和列
    public static void printXing(int m , int n ){
        System.out.println("输出" + m + "行" + n + "列的*");
        for (int i = 0; i < m ; i++) {
            for (int j = 0 ; j < n ; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}
```

####