3.0数组笔记

数组：多个相同数据类型的变量的组合

// 1.数组的声明：

int[] scores;

// 2.静态初始化：数组的声明、创建与数组元素的赋值一并完成。

scores = new int[] { 78, 76, 88, 99, 97 };

double[] arr = new double[] { 67.5, 87.6, 77.5 };

// 动态初始化:数组的声明、创建与数组元素的赋值分开进行。

String[] strs = new String[4];// 表明数组中只有4个元素

//错误的声明方式：

int[10] myInt;

int[] arr = new int[];

int[] arr = new int[4]{1,2,3,4};

// 3.数组元素的调用:通过下角标的方式进行调用。

// 角标从0开始，到 n - 1结束。其中，n为数组的长度

strs[0] = "刘德华";

strs[1] = "张学友";

strs[2] = "黎明";

strs[3] = "郭富城";

// 注：1.数组元素的类型，直接可以通过声明可以看出来

// 2.不管是静态初始化，还是动态初始化，都指明了数组的长度

// 4.数组的长度，即数组中元素的个数。可以使用属性“length”表示

System.out.println(strs.length);// 4

System.out.println(arr.length);// 3

// 5.如何遍历数组中的元素

for (int i = 0; i < strs.length; i++) {

     System.out.println(strs[i]);

}

6.不同类型元素的数组的默认初始化值

          //1）整型：byte short int long ==> 0

         

          //2）浮点型：float,double ==>0.0

         

          //3)布尔型：boolean==>false

         

          //4)字符型：char ==> \u0000 空

         

          //5）引用数据类型：以String为代表==> null

         

7.难点：数组的内存解析

1）内存的划分

栈的概念是弹压，就像子弹壳装弹，一粒一粒压进去，但是打出来的时候是从上面打出来的，最先压进去的最后弹出来，如果进去顺序是123，打出来顺序是321，这就是后进先出

队列的概念就是我们平时排队，按次序来，你排在第1个，那你就第一个轮到，就是先进先出，先到先来

2.数组的声明存放在栈空间，数组中的元素存放在堆空间

数组一旦创建，根据其数据类型，都有对应的默认初始化值。

如果再被赋予新的值，比如：arr1[0] = 10.就是将默认的0的值覆盖掉 

二维数组：将一维数组作为一个新的数组的元素，那么就构成了一个二维数组

//1.二维数组的声明与初始化

int[][] scores;

//静态初始化

scores = new int[][]{{1,2,4},{4,5},{7,9,0}};

//动态初始化

String[][] arr1 = new String[4][3];

boolean[] arr2[] = new boolean[3][];

//错误的初始化

//int[][] arr3 = new int[2][4]{{1,2,3,4},{3,4,5,6}};

//int[][] arr4 = new int[][3];

//2.数组元素的调用：通过下角标的方式调用

arr2[0] = new boolean[3];

//arr2[1] = new boolean[4];

arr2[2] = new boolean[5];

//3.调用具体的元素

System.out.println(scores[1][0]);//4

arr1[2][1] = "MM";

//....

//4.数组的长度

System.out.println(scores.length);//3

System.out.println(arr1.length);//4

System.out.println(scores[1].length);//2

System.out.println(arr2[2].length);//5

//5.如何遍历数组元素

for(int i = 0;i < scores.length;i++){//控制行数

     for(int j = 0;j < scores[i].length;j++){//控制列数

          System.out.print(scores[i][j] + " ");

     }

     System.out.println();

}

//6.数组元素的默认初始化值

for(int i = 0;i < arr1.length;i++){

     for(int j = 0;j < arr1[i].length;j++){

          System.out.print(arr1[i][j] + " ");

     }

     System.out.println();

}

System.out.println(arr2[1]);

//7.二维数组的内存解析（难点）

//1.ArrayIndexOutOfBoundsException:超出角标的范围，都属于越界

int[] arr = new int[10];//0-9

/*for(int i = 0;i <= arr.length;i++){

     System.out.println(arr[i]);

}*/

//System.out.println(arr[-1]);

//2.NullPointerException:   空指针异常

boolean[] arr1 = new boolean[10];

System.out.println(arr1[0]);

//情景1：

arr1 = null;//不注释掉的话，就会出现空指针异常

//System.out.println(arr1[1]);

//情景2：

String[] arr2 = new String[3];

//arr2[0] = "AA";//注释掉的话，就会出现空指针异常

//System.out.println(arr2[0].toString());

//情景3：

int[][] arr3 = new int[3][];

System.out.println(arr3[0]);//null

//arr3[0] = new int[3];//注释掉的话，就会出现空指针异常

System.out.println(arr3[0][1]);

1.求数值型数组的最大值、最小值、总和、平均数

int[] arr = new int[] { 4, 3, 6, 8, 2, -98, 0, -66, 76 };

// 求数组元素的最大值

int maxValue = arr[0];

for (int i = 1; i < arr.length; i++) {

     if (maxValue < arr[i]) {

          maxValue = arr[i];

     }

}

System.out.println("最大值为：" + maxValue);

// 求数组元素的最小值

int minValue = arr[0];

for (int i = 1; i < arr.length; i++) {

     if (minValue > arr[i]) {

          minValue = arr[i];

     }

}

System.out.println("最小值为：" + minValue);

// 求数组元素的总和

int sum = 0;

for (int i = 0; i < arr.length; i++) {

     sum += arr[i];

}

System.out.println("总和为：" + sum);

// 求数组元素的平均数

int avg = sum / arr.length;

System.out.println("平均数为：" + avg);

2.数组的反转  和  复制

//2.1数组的反转：

// 方式一：

// for(int x = 0,y = arr.length - 1;x < y;x++,y--){

// int temp = arr[x];

// arr[x] = arr[y];

// arr[y] = temp;

// }

// 方式二

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;

}

//Sring str = "abcdefg";-->"gfedcba"

//2.2数组的复制

// 数组的复制,得到新的数组：array

// 复制不同于赋值。赋值操作为：array = arr;

int[] array = new int[arr.length];

for (int i = 0; i < array.length; i++) {

     array[i] = arr[i];

}

//将array1的地址值赋给array2，并没有实现数组的复制！

//实现对array1数组的复制

3.数组的排序：

插入排序

直接插入排序、折半插入排序、Shell排序

交换排序

冒泡排序、快速排序（或分区交换排序）

选择排序

简单选择排序、堆排序

归并排序

基数排序

// 使用冒泡排序实现数组的从小到大排序

/*for (int i = 0; i < arr.length - 1; i++) {

     for (int j = 0; j < arr.length - 1 - i; j++) {

          if (arr[j] > arr[j + 1]) {

               int temp = arr[j];

               arr[j] = arr[j + 1];

               arr[j + 1] = temp;

          }

     }

}*/

//使用直接选择排序使数组元素从小到大排列

//        for(int i = 0; i < arr.length - 1; i++){

//            int t = i;//默认i处是最小的

//            for(int j = i;j < arr.length;j++){

//                //一旦在i后发现存在比其小的元素，就记录那个元素的下角标

//                if(arr[t] > arr[j]){

//                    t = j;

//                }

//            }

//            if(t != i){

//                int temp = arr[t];

//                arr[t] = arr[i];

//                arr[i] = temp;

//            }

//        }

//操作数组的工具类：Arrays

Arrays.sort(arr);//底层使用的实际是快速排序。

Arrays.toString(parameterValues)放回数组的值“[]”

Arrays.asList()数组转换为集合

//1.ArrayIndexOutOfBoundsException:超出角标的范围，都属于越界

int[] arr = new int[10];//0-9

/*for(int i = 0;i <= arr.length;i++){

     System.out.println(arr[i]);

}*/

//System.out.println(arr[-1]);

//2.NullPointerException:   空指针异常

boolean[] arr1 = new boolean[10];

System.out.println(arr1[0]);

//情景1：

arr1 = null;//不注释掉的话，就会出现空指针异常

//System.out.println(arr1[1]);

//情景2：

String[] arr2 = new String[3];

//arr2[0] = "AA";//注释掉的话，就会出现空指针异常

//System.out.println(arr2[0].toString());

//情景3：

int[][] arr3 = new int[3][];

System.out.println(arr3[0]);//null

//arr3[0] = new int[3];//注释掉的话，就会出现空指针异常

System.out.println(arr3[0][1]);

1.求数值型数组的最大值、最小值、总和、平均数

int[] arr = new int[] { 4, 3, 6, 8, 2, -98, 0, -66, 76 };

// 求数组元素的最大值

int maxValue = arr[0];

for (int i = 1; i < arr.length; i++) {

     if (maxValue < arr[i]) {

          maxValue = arr[i];

     }

}

System.out.println("最大值为：" + maxValue);

// 求数组元素的最小值

int minValue = arr[0];

for (int i = 1; i < arr.length; i++) {

     if (minValue > arr[i]) {

          minValue = arr[i];

     }

}

System.out.println("最小值为：" + minValue);

// 求数组元素的总和

int sum = 0;

for (int i = 0; i < arr.length; i++) {

     sum += arr[i];

}

System.out.println("总和为：" + sum);

// 求数组元素的平均数

int avg = sum / arr.length;

System.out.println("平均数为：" + avg);

2.数组的反转  和  复制

//2.1数组的反转：

// 方式一：

// for(int x = 0,y = arr.length - 1;x < y;x++,y--){

// int temp = arr[x];

// arr[x] = arr[y];

// arr[y] = temp;

// }

// 方式二

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;

}

//Sring str = "abcdefg";-->"gfedcba"

//2.2数组的复制

// 数组的复制,得到新的数组：array

// 复制不同于赋值。赋值操作为：array = arr;

int[] array = new int[arr.length];

for (int i = 0; i < array.length; i++) {

     array[i] = arr[i];

}

//将array1的地址值赋给array2，并没有实现数组的复制！

//实现对array1数组的复制

3.数组的排序：

插入排序

直接插入排序、折半插入排序、Shell排序

交换排序

冒泡排序、快速排序（或分区交换排序）

选择排序

简单选择排序、堆排序

归并排序

基数排序

// 使用冒泡排序实现数组的从小到大排序

/*for (int i = 0; i < arr.length - 1; i++) {

     for (int j = 0; j < arr.length - 1 - i; j++) {

          if (arr[j] > arr[j + 1]) {

               int temp = arr[j];

               arr[j] = arr[j + 1];

               arr[j + 1] = temp;

          }

     }

}*/

//使用直接选择排序使数组元素从小到大排列

//        for(int i = 0; i < arr.length - 1; i++){

//            int t = i;//默认i处是最小的

//            for(int j = i;j < arr.length;j++){

//                //一旦在i后发现存在比其小的元素，就记录那个元素的下角标

//                if(arr[t] > arr[j]){

//                    t = j;

//                }

//            }

//            if(t != i){

//                int temp = arr[t];

//                arr[t] = arr[i];

//                arr[i] = temp;

//            }

//        }

//操作数组的工具类：Arrays

Arrays.sort(arr);//底层使用的实际是快速排序。

Arrays.toString(parameterValues)放回数组的值“[]”

Arrays.asList()数组转换为集合

String.equalsIgnoreCase（String string）；

例子：

import java.util.Scanner;

Class StringTest{

    public static void main(String[] args){

        Scanner scanner=new Scanner(System.in);

        System.out.println("请输入Y或N判断对错");

        String  isTrue=scanner.next();

        if（isTrue.equalsIgnoreCase(" Y")）{

            System.out.println(“对”);

        }else if（isTrue.equalsIgnoreCase("N")）{

            System.out.println“错”);

        }else{

            System.out.println“输入有误！”);

        }

    }

}

//1.ArrayIndexOutOfBoundsException:超出角标的范围，都属于越界

int[] arr = new int[10];//0-9

/*for(int i = 0;i <= arr.length;i++){

     System.out.println(arr[i]);

}*/

//System.out.println(arr[-1]);

//2.NullPointerException:   空指针异常

boolean[] arr1 = new boolean[10];

System.out.println(arr1[0]);

//情景1：

arr1 = null;//不注释掉的话，就会出现空指针异常

//System.out.println(arr1[1]);

//情景2：

String[] arr2 = new String[3];

//arr2[0] = "AA";//注释掉的话，就会出现空指针异常

//System.out.println(arr2[0].toString());

//情景3：

int[][] arr3 = new int[3][];

System.out.println(arr3[0]);//null

//arr3[0] = new int[3];//注释掉的话，就会出现空指针异常

System.out.println(arr3[0][1]);

1.求数值型数组的最大值、最小值、总和、平均数

int[] arr = new int[] { 4, 3, 6, 8, 2, -98, 0, -66, 76 };

// 求数组元素的最大值

int maxValue = arr[0];

for (int i = 1; i < arr.length; i++) {

     if (maxValue < arr[i]) {

          maxValue = arr[i];

     }

}

System.out.println("最大值为：" + maxValue);

// 求数组元素的最小值

int minValue = arr[0];

for (int i = 1; i < arr.length; i++) {

     if (minValue > arr[i]) {

          minValue = arr[i];

     }

}

System.out.println("最小值为：" + minValue);

// 求数组元素的总和

int sum = 0;

for (int i = 0; i < arr.length; i++) {

     sum += arr[i];

}

System.out.println("总和为：" + sum);

// 求数组元素的平均数

int avg = sum / arr.length;

System.out.println("平均数为：" + avg);

2.数组的反转  和  复制

//2.1数组的反转：

// 方式一：

// for(int x = 0,y = arr.length - 1;x < y;x++,y--){

// int temp = arr[x];

// arr[x] = arr[y];

// arr[y] = temp;

// }

// 方式二

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;

}

//Sring str = "abcdefg";-->"gfedcba"

//2.2数组的复制

// 数组的复制,得到新的数组：array

// 复制不同于赋值。赋值操作为：array = arr;

int[] array = new int[arr.length];

for (int i = 0; i < array.length; i++) {

     array[i] = arr[i];

}

//将array1的地址值赋给array2，并没有实现数组的复制！

//实现对array1数组的复制

3.数组的排序：

插入排序

直接插入排序、折半插入排序、Shell排序

交换排序

冒泡排序、快速排序（或分区交换排序）

选择排序

简单选择排序、堆排序

归并排序

基数排序

// 使用冒泡排序实现数组的从小到大排序

/*for (int i = 0; i < arr.length - 1; i++) {

     for (int j = 0; j < arr.length - 1 - i; j++) {

          if (arr[j] > arr[j + 1]) {

               int temp = arr[j];

               arr[j] = arr[j + 1];

               arr[j + 1] = temp;

          }

     }

}*/

//使用直接选择排序使数组元素从小到大排列

//        for(int i = 0; i < arr.length - 1; i++){

//            int t = i;//默认i处是最小的

//            for(int j = i;j < arr.length;j++){

//                //一旦在i后发现存在比其小的元素，就记录那个元素的下角标

//                if(arr[t] > arr[j]){

//                    t = j;

//                }

//            }

//            if(t != i){

//                int temp = arr[t];

//                arr[t] = arr[i];

//                arr[i] = temp;

//            }

//        }

//操作数组的工具类：Arrays

Arrays.sort(arr);//底层使用的实际是快速排序。

Arrays.toString(parameterValues)放回数组的值“[]”

Arrays.asList()数组转换为集合