(06)Java学习笔记——数组

来源：互联网发布：荣威erx5 知乎编辑：程序博客网时间：2024/05/21 08:36

数组：

同一种类型数据的集合，就是一个数据的容器。

多个变量的数据类型要一致。

数组可以存储基本数据类型，也可以存储引用数据类型。

数组初始化：（就是为数组开辟空间，并为每个数组元素赋值）

java中的数组必须先初始化才能使用。

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

数组的初始化方式：

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

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

数组的格式1（动态初始化）：（需要一个容器，但是不明确容器中的具体数据）

元素类型[ ] 数组名 = new 元素类型[元素个数或数组长度]; // 用关键字new来建立数组

示例：int [ ] array = new int [ 5 ]; // 数组一建立，必须明确数组长度！

数组的格式2（静态初始化）：（需要一个容器，存储已知的具体数据）

元素类型 [ ] 数组名 = new 元素类型 [ ] {元素1，元素2，元素3，……}

示例：

int [ ] array = new int [ ] {2,4,5,7}; //常规初始化方式

int [ ] array = {2,4,5,7}; //静态初始化方式

**//动给数组中的数据进行角标编号（从0开始），方便操作这些元素。

范例：

class ArrayDemo {public static void main(String[] args) {int [] array=new int[]{5,8,13,64,9};  //定义了一个数组，并在数组中给了元素。System.out.println(array[1]);    //打印数组中1角标对应的元素。}}

————————————————————————————————————————

栈内存：存储的都是局部变量。变量所属的作用一旦结束，该变量就自动释放。

堆内存：储存的是数组和对象（其实数组就是对象）凡是new就建立在堆中。

每个new出来的东西都有首地址值。

堆内存中的每个变量都有默认初始化值，根据类型的不同而不同。

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

————————————————————————————————————————————

练习01：

定义一个数组，输出该数组的名称和数组元素值
给数组元素赋值，再次输出该数组的名称和数组元素值。

/*定义一个数组，输出该数组的名称和数组元素值给数组元素赋值，再次输出该数组的名称和数组元素值。*/class  ArrayTest_01{public static void main(String[] args) {int [] array = new int[3];System.out.println(array);System.out.println(array[0]);System.out.println(array[1]);System.out.println(array[2]);System.out.println("----------------------");array[0] = 30;array[1] = 60;array[2] = 90;System.out.println(array[0]);System.out.println(array[1]);System.out.println(array[2]);}}

练习02：

定义一个数组，给数组元素赋值，输出数组名称和元素

定义第二个数组，给数组元素赋值，输出数组名称和元素

定义第三个数组，把第一个数组的地址值赋值给它（注意类型一致），通过第三个数组的名称去吧元素重新赋值，再一次输出第一个数组名称和元素。

栈内存的两个引用指向同一个堆空间

class ArrayTest_02 {public static void main(String[] args) {int [] array1 = new int [3];array1[0] = 33;array1[1] = 55;array1[2] = 88;System.out.println(array1);System.out.println(array1[0]);System.out.println(array1[1]);System.out.println(array1[2]);System.out.println("--------------------------");int [] array2 = new int [4];array2[0] = 13;array2[1] = 21;array2[2] = 89;array2[3] = 19;System.out.println(array2);System.out.println(array2[0]);System.out.println(array2[1]);System.out.println(array2[2]);System.out.println(array2[3]);System.out.println("---------------------------");int [] array3 = array1;//将array1数组的地址给了array3，array3依据地址指向堆内存中的array1内存空间array3[0] = 6;//array3[1] = 8;array3[2] = 5;System.out.println(array1);System.out.println(array1[0]);//因为array1的地址给了array3,array3的重新赋值改变了array1中的元素。System.out.println(array1[1]);System.out.println(array1[2]);}}

————————————————————————————————————————————————

数组常见的操作：

对数组的操作动作就是“存”和“取”。实际上就是对角标的操作。

1/数组的遍历

**数组长度的固定语句：数组名.length 例如：array.length

class ArrayTest01   {      public static void main(String[] args)       {          int[] array=new int[]{23,4,12,55,29};//定义一个数组，及初始化数组的元素        for (int x=0;x<array.length ;x++ )// 用数组的长度语句控制循环次数。array.length          {              System.out.println("array["+x+"]="+array[x]+";");//用循环语句遍历数组中的0开始的全部角标，并把相对应的值打印出来         }          System.out.println("length:"+array.length); //统计数组并打印出数组的长度值。    }  }

遍历数组的方法：

两个明确：

1 / 返回值类型：void

2/ 参数列表：int [ ] array

数组的一个属性，数组长度：数组名 . length

class ArrayTest_03 {public static void main(String[] args) {int [] array = new int[] { 3,6,88,33,12,5,66,47,29};//声明一个数组，并静态初始化赋值printArray(array);//调用打印数组的方法}public static void printArray(int[] array)//创建一个遍历打印数组的方法{for (int x=0;x<array.length ;x++ ){System.out.println(array[x]);}}}

2/数组取最值
思路：

1/1需要进行比较，并定义变量来记录每次比较厚较大的值。

2/对数组中的值遍历取出和变量中的值进行比较，取出较大值。

class ArrayTest02 {public static void main(String[] args) {int [] array=new int[]{34,55,22,7,98,12,67};  //定义一个数组并初始化了元素int getmax=max(array);     //调用名为max的方法，将最大值赋给getmaxSystem.out.print(getmax);   //打印数组中的最大值}public static int max(int[] array)   //定义了一个方法，用来遍历比较数组中的元素，取出最大值{int max=0;for (int x=0;x<array.length ;x++ ){if (array[x]>max){max=array[x];}}return max;}}

3/ 数组元素逆序

/*数组的逆序分析：把数组角标0的元素和array.length-1的数据交换把数组交表1的元素和array.length-2的数据交换。。。。。只要做到array.length/2的位置*/class  ArrayTest_05{public static void main(String[] args) {int [] array = new int[] {2,3,4,5,6,7,8,9,10,11,12};printArray(array);//调用打印方法，打印逆序前的数组System.out.println();reverce(array); //调用逆序方法printArray(array);//调用打印方法，打印逆序后的数组//System.out.println("["+array+"]");}public static void reverce(int[] array)//定义一个位置交换的方法{for (int x=0;x<=array.length/2 ;x++ ){int temp = array[x];array[x] = array[array.length-1-x];array[array.length-1-x] = temp;}}public static void printArray(int[] array)//定义一个遍历打印数组的方法{for (int x=0;x<array.length ;x++ ){System.out.print(array[x]+",");}return ;}}

4 / 数组查表法

根据键盘录入索引，查找对应星期

/*数组查表法根据键盘输入索引，查找对应星期*/import java.util.Scanner;class  ArrayTest_06{public static void main(String[] args) {String [] weekArray = new String[] {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"};Scanner sc = new Scanner(System.in);System.out.println("输入数据");int x = sc.nextInt();System.out.println("查找的是: "+weekArray[x]);//依据输入数值，查找数组中对应角标的元素并输出}}

5 / 查找数组元素对应角标

/*查找数组元素对应的角标*/class  ArrayTest_07{public static void main(String[] args) {int [] array = new int[] {4,65,23,77,1,5,88,13};int index = getIndex(array,77);System.out.println(index);}public static int getIndex(int[] array,int value)//定义一个方法遍历数组并与查询值进行比较。{for (int x =0;x<array.length ;x++ ){if (array[x]==value){return x;}}return -1;}}

4/ 数组的排序

A / 数组的冒泡排序

范例：

package cn.itcsat_01;/* * 数组的的冒泡排序 */public class ArrayDemo {public static void main(String[] args) {// 定义一个数组int[] arr = { 24, 69, 80, 57, 13 };System.out.println("排序前：");printArray(arr);System.out.println("冒泡排序后：");bublleSort(arr);/*// 第一次比较for (int x = 0; x < arr.length-1-0; x++) {if (arr[x] > arr[x + 1]) {int temp = arr[x];arr[x] = arr[x + 1];arr[x + 1] = temp;}}System.out.println("第一次比较：");//结果：[24, 69, 57, 13, 80]printArray(arr);// 第二次比较//arr.length-1  是为了防止越界//arr.length -1 -1 是为了减少比较的次数for (int x = 0; x < arr.length-1-1; x++) {if (arr[x] > arr[x + 1]) {int temp = arr[x];arr[x] = arr[x + 1];arr[x + 1] = temp;}}System.out.println("第二次比较：");//结果：[24, 57, 13, 69, 80]printArray(arr);// 第三次比较for (int x = 0; x < arr.length-1-2; x++) {if (arr[x] > arr[x + 1]) {int temp = arr[x];arr[x] = arr[x + 1];arr[x + 1] = temp;}}System.out.println("第三次比较：");//结果：[24, 13, 57, 69, 80]printArray(arr);// 第四次比较for (int x = 0; x < arr.length-1-3; x++) {if (arr[x] > arr[x + 1]) {int temp = arr[x];arr[x] = arr[x + 1];arr[x + 1] = temp;}}System.out.println("第四次比较：");//结果：[13, 24, 57, 69, 80]printArray(arr);System.out.println("-----------------------------------");*//*//上面的代码可以用循环改进for(int y=0;y<arr.length-1;y++){for (int x = 0; x < arr.length-1-y; x++) {if (arr[x] > arr[x + 1]) {int temp = arr[x];arr[x] = arr[x + 1];arr[x + 1] = temp;}}}System.out.println("冒泡排序结果：");printArray(arr);*/}// 遍历功能public static void printArray(int[] arr) {System.out.print("[");for (int x = 0; x < arr.length; x++) {if (x == arr.length - 1) {System.out.print(arr[x]);} else {System.out.print(arr[x] + ", ");}}System.out.println("]");}//定义一个数组冒泡排序的方法：public static void bublleSort(int[] arr){for(int y=0;y<arr.length-1;y++){for (int x = 0; x < arr.length-1-y; x++) {if (arr[x] > arr[x + 1]) {int temp = arr[x];arr[x] = arr[x + 1];arr[x + 1] = temp;}}}printArray(arr);}}

B / 数组的选择排序

思想：

分别用数组内的元素进行遍历。

用第三个临时变量来换位，将小的元素移动到前面。

范例：

package cn.itcsat_02;/* * 数组的选择排序 */public class ArrayDemo {public static void main(String[] args) {// 定义一个数组int[] arr = { 24, 69, 80, 57, 13 };System.out.println("排序前：");printArray(arr);System.out.println("选择排序后：");selectSort(arr);/*// 第一次排序int x = 0;for (int y = 1; y < arr.length; y++) {if (arr[y] < arr[x]) {int temp = arr[x];arr[x] = arr[y];arr[y] = temp;}}System.out.println("第一次排序后：");printArray(arr);// 第二次排序//经过第一次排序后，0角标元素不再参与比较x = 0+1;for (int y = 1+1; y < arr.length; y++) {if (arr[y] < arr[x]) {int temp = arr[x];arr[x] = arr[y];arr[y] = temp;}}System.out.println("第二次排序后：");printArray(arr);// 第三次排序//经过第二次排序后，1角标元素不再参与比较x = 0+2;for (int y = 1+2; y < arr.length; y++) {if (arr[y] < arr[x]) {int temp = arr[x];arr[x] = arr[y];arr[y] = temp;}}System.out.println("第三次排序后：");printArray(arr);// 第四次排序//经过第三次排序后，2角标元素不再参与比较x = 0+3;for (int y = 1+3; y < arr.length; y++) {if (arr[y] < arr[x]) {int temp = arr[x];arr[x] = arr[y];arr[y] = temp;}}System.out.println("第四次排序后：");printArray(arr);System.out.println("----------------------------");//上面的过程可以简化成下列代码：for (int z=0;z<arr.length-1;z++){x = 0+z;for (int y = 1+z; y < arr.length; y++) {if (arr[y] < arr[x]) {int temp = arr[x];arr[x] = arr[y];arr[y] = temp;}}}System.out.println("选择排序后：");printArray(arr);*/}// 遍历数组的功能public static void printArray(int[] arr) {System.out.print("[");for (int x = 0; x < arr.length; x++) {if (x == arr.length - 1) {System.out.print(arr[x]);} else {System.out.print(arr[x] + ", ");}}System.out.println("]");}//定义一个选择排序的方法public static void selectSort(int[] arr){for (int z=0;z<arr.length-1;z++){int x = 0+z;for (int y = 1+z; y < arr.length; y++) {if (arr[y] < arr[x]) {int temp = arr[x];arr[x] = arr[y];arr[y] = temp;}}}printArray(arr);}}

练习01：把字符串中的字符进行排序

举例：“dacgebf"

结果：”abcdefg"

package cn.itcast_03;/* * 把字符串中的字符进行排序 * 思路： * A/ 把字符串转换成字符数组 * B/ 通过对字符数组的排序后，得出符合顺序的字符数组 * C/ 将符合顺序的字符数组转成字符串 */public class ArrayTest_01 {public static void main(String[] args) {//定义一个字符串String s = "dacgebf";//把字符串转换成字符数组char[] chs =s.toCharArray();printArray(chs);bulleSort(chs);printArray(chs);//打印输出排序后的字符数组//将排序后的字符数组转成字符串String s1 = String.valueOf(chs);System.out.println(s1);}//定义一个遍历数组并打印数组的功能public static void printArray(char[] chs){System.out.print("[");for(int x=0;x<chs.length;x++){if(x==chs.length-1){System.out.print(chs[x]);}else{System.out.print(chs[x]+", ");}}System.out.println("]");}//定义一个数组排序的功能public static void bulleSort(char[] chs){for(int x=0;x<chs.length-1;x++){for(int y=0;y<chs.length-1-x;y++){if(chs[y]>chs[y+1]){char temp=chs[y];chs[y]=chs[y+1];chs[y+1]=temp;}}}}}

5/数组查找（查找数组中某个元素对应的角标）

思路：用遍历方式查找。

范例：

class ArrayTest05 {public static void main(String[] args) {int[] array=new int[] {45,33,7,89,32,14,55};int index=getIndex(array,14);  //给出需要寻找的元素System.out.print("index="+index);  //打印出所寻找元素的对应角标}public static int getIndex(int[] array,int element)  //定义一个方法，用于寻找某元素的角标{for (int x=0;x<array.length ;x++ ){if (array[x]==element){return x;}}return -1;}}

6/数组的二分查找（折半查找）

前提：数组元素是有序的

范例：

package cn.itcast_04;/* * 数组的折半查找 * 思路： * A/定义最大索引，最小索引 * B/ 计算中间索引 * C/ 拿中间索引的值和要查找的值进行比较 * 相等：就返回当前的中间索引 * 不相等：小：左边找 * 大：右边找 * D/ 重新计算出中间索引 * 大：左边找   max = mid-1; * 小：右边找   min = mid+1; * E/ 回到B *  */public class ArrayDemo {public static void main(String[] args) {// 定义一个数组int[] arr = { 11, 22, 33, 44, 55, 66, 77 };// 调用方法int index = getIndex(arr, 33);System.out.println(index);}// 写方法实现：/* * 两个明确： 1.返回值类型 2。参数列表 int[] arr, int value */public static int getIndex(int[] arr,int value){//定义最大索引，最小索引int max = arr.length-1;int min = 0;//计算中间索引int mid = (max+min)/2;//拿中间索引的值和要查找的值进行比较while (arr[mid]!=value){if(arr[mid]>value){max = mid-1;}else if(arr[mid]<value){min = mid+1;}//加入判断if(min>max){return -1;}mid =(max+min)/2;}return mid;}}

7/进制转换

8/查表法

————————————————————————————————————

二维数组（数组中的数组）

格式1：（动态初始化）

数据类型 [ ] [ ] 数组名 = new 数据类型 [m ] [n ]

m表示这个二维数组有多少个一维数组

n表示每个一维数组的元素个数

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

1/定义了一个名为array的二维数组

2/二维数组中有3个一位数组

3/每个一维数组中有2个元素

int [][] array=new int[3][2];  //定义一个二维数组。该数组中有3个一维数组，每个一维数组中有2个元素。System.out.println(array);//直接打印二维数组System.out.println(array[0]);//直接打印二维数组中的角标0的一维数组。System.out.println(array[0][0]);//直接打印二维数组中的角标0的一维数组中的角标为0的元素。

二维数组的内存图解

int[][] array=new int[3][2];System.out.println(array.length);//打印二维数组的长度，其实就是一维数组的个数System.out.println(array[1].length);//打印二维数组中角标为1的一维数组的长度。

格式2:（动态初始化）

数据类型 [ ] [ ] 数组名 = new 数据类型 [ m ] [ ]

m表示这个二维数组有多少个一维数组

没有给出一维数组的元素个数，可以动态给出。

int [ ] [ ] array = new int [ 3 ] [ ]

array[0]=new int [2 ];

array[1]=new int [1];

array[2]=new int [3];

格式3：

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

int[ ] [ ] array={{3,1,7},{4,6.2.9},{4,3,7}};

练习01：二维数组的遍历

用forfor循环嵌套方法遍历二维数组，

外循环控制的是二维数组的长度（一维数组的个数）

内循环控制的是一维数组的长度

/*二维数组的遍历分析：用forfor循环的思想*/class ArrayTest02_01 {public static void main(String[] args) {int [] [] array ={{2,6,11,54},{55,3,71,33,87},{23,17}};ergodic(array);//调用遍历方法}public static void ergodic(int [][] array)//定义一个用forfor循环遍历二维数组的方法{for (int x=0;x<array.length ;x++ ){for (int y=0;y<array[x].length ;y++ ){System.out.print(array[x][y]+", ");}System.out.println();}}}

练习02：公司年销售额求和

/*公司年销售额求和第一季度：22，66，44第二季度：77，33，88第三季度：25，45，65第四季度：11，66，99分析：定义二维数组int [季度数] [每季度销售额]定义一个统计方法forfor循环嵌套遍历数组将遍历出来的元素统计输出 */class  ArrayTest02_02{public static void main(String[] args) {int [][] array = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};int result = arraySum(array);System.out.println("年销售额是"+result);}public static int arraySum(int [][] array){int sum = 0;for (int x=0;x<array.length ;x++ ){for (int y=0;y<array[x].length ;y++ ){sum = sum+array[x][y];}}return sum;}}

练习03：打印杨辉三角形

1 1

1 2 1

1 3 3 1

1 4 6 4 1

1 5 10 10 5 1

分析：

任何一行的第一列和最后一列都是1

从第三行开始，每一个数据都是它上一行的前一列和它上一行的本列之和。最后一列除外。

练习04：数据转换成数组进行操作

如何把数据转换成数组？：

a/定义一个数据：