2.数组的练习
2.1数组概述和定义格式说明及数组的动态初始化
数组:存储同一数据类型多个元素的容器。
定义格式:
A:数据类型[] 数组名;
B:数据类型 数组名[];
举例:
A:int[] a; 定义一个int类型的数组a变量
B:int a[]; 定义一个int类型的a数组变量
注意:效果可以认为是一样的,都是定义一个int数组,但是念法上有些小区别。推荐使用第一种。
如何对数组进行初始化呢?
A:何谓初始化呢? 就是为数组开辟内存空间,并为每个数组元素赋予值
B:有几种方式呢?
a:动态初始化只指定长度,由系统给出初始化值给0作为初始值
b:静态初始化给出初始化值,由系统决定长度
动态初始化的格式:
数据类型[] 数组名 = new 数据类型[数组长度];
举例:
int[] arr = new int[3];
如何获取数组中的元素呢?
通过:
数组名[索引]
索引其实就是每个元素的编号,从0开始,最大索引是数组的长度-1。
*/
class ArrayDemo {
public static void main(String[] args) {
//定义一个数组
//int[] a;
//可能尚未初始化变量a
//System.out.println(a);
//注意:这里的a为数组变量,是一个变量,变量的使用必须先初始化
int[] arr = new int[3];
/*
左边:
int:说明数组中的元素的数据类型是int类型
[]:说明这是一个数组
arr:是数组的名称
右边:
new:为数组分配内存空间。
int:说明数组中的元素的数据类型是int类型
[]:说明这是一个数组
3:数组长度,其实也就是数组中元素的个数
*/
System.out.println(arr); //[I@175078b 地址值。
//我要地址值没有意义啊,我就要数据值,怎么办呢?
//不用担心,java为你考虑到了。
//其实数组中的每个元素都是有编号的,并且是从0开始。最大编号是数组的长度-1。
//用数组名和编号的配合就可以获取数组中的指定编号的元素。这个编号的专业叫法:索引
//通过数组名访问数据的格式是:数组名[索引];
System.out.println(arr[0]);0
System.out.println(arr[1]); 0
System.out.println(arr[2]);0
}
}
/*
数组的静态初始化:
格式:数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
简化格式:
数据类型[] 数组名 = {元素1,元素2,…};
举例:
int[] arr = new int[]{1,2,3};
简化后:
int[] arr = {1,2,3};
注意事项:
不要同时动态和静态进行。
如下格式:
int[] arr = new int[3]{1,2,3}; //错误
数组操作的两个常见小问题:
ArrayIndexOutOfBoundsException:数组索引越界异常
原因:你访问了不存在的索引。
NullPointerException:空指针异常
原因:数组已经不在指向堆内存了。而你还用数组名去访问元素。
作用:请自己把所有的场景Exception结尾的问题总结一下。以后遇到就记录下来。
现象,原因,解决方案。
2.2数组定义
/*
定义一个数组,输出该数组的名称和数组元素值。
给数组元素赋值,再次输出该数组的名称和数组元素值。
*/
自己写：
package cn.plsite.day04.demo02;
public class ArrayDefine {
/*
定义一个数组,输出该数组的名称和数组元素值。
给数组元素赋值,再次输出该数组的名称和数组元素值。
*/
public static void main(String[] args) {
int[] arr1 = new int[2];
System.out.println(arr1);
System.out.println(arr1[0]);
System.out.println(arr1[1]);
//赋值
arr1[0] = 10;
arr1[1] = 30;
System.out.println(arr1);
System.out.println(arr1[0]);
System.out.println(arr1[1]);
}
}
运行结果：
[I@61bbe9ba
0
0
[I@61bbe9ba
10
30
答案：
class ArrayDemo2 {
public static void main(String[] args) {
//定义一个数组
int[] arr = new int[3];
//输出数组名称
System.out.println(arr);
//输出数组元素值
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println("----");
//给数组元素赋值
arr[0] = 100;
arr[2] = 200;
//输出数组名称
System.out.println(arr);
//输出数组元素值
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
2.3 多数赋值操作图解
2.4数组遍历
package cn.plsite.day04.demo02;
public class ArrayErgodic {
public static void main(String[] args) {
int[] arr1 = new int[]{1,2,3,4,5};
//for循环遍历
for (int i = 0; i < arr1.length; i++) {
System.out.println(arr1[i]);
}
}
}
注意：数组的length属性使用。
2.5数组中获取最值
数组获取最值(获取数组中的最大值最小值)
分析:
A:定义一个数组,并对数组的元素进行静态初始化。
B:从数组中任意的找一个元素作为参照物(一般取第一个),默认它就是最大值。
C:然后遍历其他的元素,依次获取和参照物进行比较,如果大就留下来,如果小,就离开。
D:最后参照物里面保存的就是最大值。
做一件事就是一个功能
package cn.plsite.day04.demo02;
public class ArrayMaxMin {
public static void main(String[] args) {
int[] arr = new int[]{-21,23,45,656,76,2,34,11,24,95,-67,41,-57};
System.out.println("最大值是："+max(arr));
System.out.println("最小值是："+min(arr));
}
//获取最大值
public static int max(int[] arr){
int max = 0;
for (int i = 0; i < arr.length; i++) {
max = (arr[i]>max)?arr[i]:max;
}
return max;
}
//获取最小值
public static int min(int[] arr){
int max = 0;
for (int i = 0; i < arr.length; i++) {
max = (arr[i]<max)?arr[i]:max;
}
return max;
}
}
答案：
class ArrayTest2 {
public static void main(String[] args) {
//定义一个数组
int[] arr = {34,98,10,25,67};
//请获取数组中的最大值
/*
//从数组中任意的找一个元素作为参照物
int max = arr[0];
//然后遍历其他的元素
for(int x=1; x<arr.length; x++) {
//依次获取和参照物进行比较,如果大就留下来,如果小,就离开。
if(arr[x] > max) {
max = arr[x];
}
}
//最后参照物里面保存的就是最大值。
System.out.println("max:"+max);
*/
//把这个代码用方法改进
//调用方法
int max = getMax(arr);
System.out.println("max:"+max);
//请获取数组中的最小值
int min = getMin(arr);
System.out.println("min:"+min);
}
/*写方法的思路
需求:获取数组中的最大值
两个明确:
返回值类型:int
参数列表:int[] arr
*/
public static int getMax(int[] arr) {
//从数组中任意的找一个元素作为参照物
int max = arr[0];
//然后遍历其他的元素
for(int x=1; x<arr.length; x++) {
//依次获取和参照物进行比较,如果大就留下来,如果小,就离开。
if(arr[x] > max) {
max = arr[x];
}
}
//最后参照物里面保存的就是最大值。
return max;
}
public static int getMin(int[] arr) {
//从数组中任意的找一个元素作为参照物
int min = arr[0];
//然后遍历其他的元素
for(int x=1; x<arr.length; x++) {
//依次获取和参照物进行比较,如果小就留下来,如果大,就离开。
if(arr[x] < min) {
min = arr[x];
}
}
//最后参照物里面保存的就是最小值。
return min;
}
}
2.6数组元素逆序 (就是把元素对调)
分析:
A:定义一个数组,并进行静态初始化。
B:思路
把0索引和arr.length-1的数据交换
把1索引和arr.length-2的数据交换
...
只要做到arr.length/2的时候即可。
*/
package cn.plsite.day04.demo02;
public class ArrayReverseOrder {
public static void main(String[] arg){
int[] arr = new int[]{-21,23,45,656,76,2,34,11,24,95,-67,41,-57,89};
for (int i = 0; i < arr.length/2; i++) {
int temp = arr[i];
arr[i] = arr[arr.length - i - 1];
arr[arr.length - i - 1] = temp;
}
//遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
答案：
class ArrayTest3 {
public static void main(String[] args) {
//定义一个数组,并进行静态初始化。
int[] arr = {12,98,50,34,76};
//逆序前
System.out.println("逆序前:");
printArray(arr);
//逆序后
System.out.println("逆序后:");
//reverse(arr);
reverse2(arr);
printArray(arr);
}
/*
需求:数组逆序
两个明确:
返回值类型:void (有人会想到应该返回的是逆序后的数组,但是没必要,因为这两个数组其实是同一个数组)
参数列表:int[] arr
*/
public static void reverse(int[] arr) {
/*
//第一次交换
int temp = arr[0];
arr[0] = arr[arr.length-1-0];
arr[arr.length-1-0] = temp;
//第二次交换
int temp = arr[1];
arr[1] = arr[arr.length-1-1];
arr[arr.length-1-1] = temp;
//第三次交换
int temp = arr[2];
arr[2] = arr[arr.length-1-2];
arr[arr.length-1-2] = temp;
*/
//用循环改进
//思路1
for(int x=0; x<arr.length/2; x++) {
int temp = arr[x];
arr[x] = arr[arr.length-1-x];
arr[arr.length-1-x] = temp;
}
}
//思路2
public static void reverse2(int[] arr) {
for(int start=0,end=arr.length-1; start<=end; start++,end--) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
}
//遍历数组
public static void printArray(int[] arr) {
System.out.print("[");
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) { //这是最后一个元素
System.out.println(arr[x]+"]");
}else {
System.out.print(arr[x]+", ");
}
}
}
}
注意：思路二的可取之处
2.7 二维数组
二维数组:就是元素为一维数组的一个数组。
格式1:
数据类型[][] 数组名 = new 数据类型[m][n];
m:表示这个二维数组有多少个一维数组。
n:表示每一个一维数组的元素有多少个。
注意:
A:以下格式也可以表示二维数组
a:数据类型[][] 数组名= new 数据类型[m][n];
b:数据类型[] 数组名[] = new 数据类型[m][n];
B:注意下面定义的区别
int x;
int y;
int x,y;
int[] x;
int[] y[];
int[] x,y[];
class Array2Demo {
public static void main(String[] args) {
//定义一个二维数组
int[][] arr = new int[3][2];
//定义了一个二维数组arr
//这个二维数组有3个一维数组的元素
//每一个一维数组有2个元素
//输出二维数组名称
System.out.println(arr); //地址值 [[I@175078b
//输出二维数组的第一个元素一维数组的名称
System.out.println(arr[0]); //地址值 [I@42552c
System.out.println(arr[1]); //地址值 [I@e5bbd6
System.out.println(arr[2]); //地址值 [I@8ee016
//输出二维数组的元素
System.out.println(arr[0][0]); //0
System.out.println(arr[0][1]); //0
}
}
格式3:
基本格式:
数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
简化版格式:
数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
举例:
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
int[][] arr = {{1,2,3},{4,5},{6}};
class Array2Demo3 {
public static void main(String[] args) {
//定义数组
int[][] arr = {{1,2,3},{4,5},{6}};
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[0][0]); //1
System.out.println(arr[1][0]); //4
System.out.println(arr[2][0]); //6
System.out.println(arr[0][1]); //2
System.out.println(arr[1][1]); //5
//越界
System.out.println(arr[2][1]); //错误
}
}
2.8 二维数组遍历
需求:二维数组遍历
外循环控制的是二维数组的长度,其实就是一维数组的个数。
内循环控制的是一维数组的长度。
自己写：
package cn.plsite.day04.demo02;
public class ArrayErgodic2 {
public static void main(String[] args) {
int[][] arr = new int[][]{{23,45,24},{33,4},{2,9,30,44}};
//遍历
for (int i = 0; i < arr.length; i++) {
for(int j = 0; j< arr[i].length; j++){
System.out.println(arr[i][j]);
}
}
}
}
答案：
class Array2Test {
public static void main(String[] args) {
//定义一个二维数组
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
//请问谁代表{1,2,3}
//arr[0]就是第一个数组
//arr[0] = {1,2,3};
for(int x=0; x<arr[0].length; x++) {
System.out.println(arr[0][x]);
}
System.out.println("--------------");
for(int x=0; x<arr[1].length; x++) {
System.out.println(arr[1][x]);
}
System.out.println("--------------");
for(int x=0; x<arr[2].length; x++) {
System.out.println(arr[2][x]);
}
System.out.println("--------------");
//用循环改进
for(int x=0; x<3; x++) {
for(int y=0; y<arr[x].length; y++) {
System.out.print(arr[x][y]+" ");
}
System.out.println();
}
System.out.println("--------------");
//这个时候,注意了,3是我们根据上面的代码得出来的
//但是,它不能针对任何的数组都可以这样
//所以,我们应该想办法改进
//其实,外面的这个循环的长度就是二维数组的长度
for(int x=0; x<arr.length; x++) {
for(int y=0; y<arr[x].length; y++) {
System.out.print(arr[x][y]+" ");
}
System.out.println();
}
System.out.println("--------------");
//用方法改进
//调用方法
printArray2(arr);
System.out.println("--------------");
//我们再来一个列数是变化的
int[][] arr2 = {{1,2,3},{4,5},{6}};
printArray2(arr2);
}
/*
需求:遍历二维数组
两个明确:
返回值类型:void
参数列表:int[][] arr
*/
public static void printArray2(int[][] arr) {
for(int x=0; x<arr.length; x++) {
for(int y=0; y<arr[x].length; y++) {
System.out.print(arr[x][y]+" ");
}
System.out.println();
}
}
}
2.9 二维数组练习-求和
公司年销售额求和
某公司按照季度和月份统计的数据如下:单位(万元)
第一季度:22,66,44
第二季度:77,33,88
第三季度:25,45,65
第四季度:11,66,99
分析:
A:把题目的数据用二维数组来表示
int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
B:如何求和呢?
求和其实就是获取到每一个元素,然后累加即可。
C:定义一个求和变量sum,初始化值是0。
D:通过遍历就可以得到每一个二维数组的元素。
E:把元素累加即可。
F:最后输出sum,就是结果。
自己写：
package cn.plsite.day04.demo02;
public class ArraySum {
public static void main(String[] args) {
int[][] arr = new int[][]{{12,23,13},{11,45,52},{24,55,66},{22,53,98}};
System.out.println(sum(arr));
}
public static int sum(int[][] arr){
int sum = 0;
for (int i = 0; i < arr.length; i++) {
for(int j = 0; j < arr[i].length; j++){
sum = sum + arr[i][j];
}
}
return sum;
}
}
答案：
class Array2Test2 {
public static void main(String[] args) {
//把题目的数据用二维数组来表示
int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
//定义一个求和变量sum,初始化值是0。
int sum = 0;
//通过遍历就可以得到每一个二维数组的元素。
for(int x=0; x<arr.length; x++) {
for(int y=0; y<arr[x].length; y++) {
//把元素累加即可。
sum += arr[x][y];
}
}
//最后输出sum,就是结果。
System.out.println("一年的销售额为:"+sum+"万元");
}
}
注意：自增自减的写法。
2.10 二维数组练习3杨辉三角
需求:打印杨辉三角形(行数可以键盘录入)
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:遍历这个二维数组。
自己写的
package cn.plsite.day04.demo02;
import java.util.Scanner;
public class YangHuiTangel {
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];
for (int i = 0; i < n; i++) {
for(int j = 0;j < i; j++){
if(i < 3){
arr[i][j] = 1;
}
if(i >= 3){
arr[i][0] = 1;
arr[i][i - 1] = 1;
if( j > 0 && j < i-1){
arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
}
}
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
}
}
结果：
请输入数字：
9
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
Process finished with exit code 0
答案：
import java.util.Scanner;
class Array2Test3 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
//这个n的数据来自于键盘录入。
System.out.println("请输入一个数据:");
int n = sc.nextInt();
//定义二维数组
int[][] arr = new int[n][n];
//给这个二维数组任何一行的第一列和最后一列赋值为1
for(int x=0; x<arr.length; x++) {
arr[x][0] = 1; //任何一行第1列
arr[x][x] = 1; //任何一行的最后1列
}
//按照规律给其他元素赋值
//从第三行开始,每一个数据是它上一行的前一列和它上一行的本列之和。
for(int x=2; x<arr.length; x++) {
//这里如果y<=x是有个小问题的,就是最后一列的问题
//所以这里要减去1
//并且y也应该从1开始,因为第一列也是有值了
for(int y=1; y<=x-1; y++) {
//每一个数据是它上一行的前一列和它上一行的本列之和。
arr[x][y] = arr[x-1][y-1] + arr[x-1][y];
}
}
//遍历这个二维数组。
/*
for(int x=0; x<arr.length; x++) {
for(int y=0; y<arr[x].length; y++) {
System.out.print(arr[x][y]+"\t");
}
System.out.println();
}
*/
//这个时候,要注意了,内循环的变化必须和曾经讲过的九九乘法表类似
for(int x=0; x<arr.length; x++) {
for(int y=0; y<=x; y++) {
System.out.print(arr[x][y]+"\t");
}
System.out.println();
}
}
}
注意：答案给的思路更有层次清晰。
2.10思考题1 Java中的参数传递问题及图解
思考题1:看程序写结果,然后分析为什么是这个样子的。并画图讲解。最后总结Java中参数传递规律。
Java中的参数传递问题:Java中都是传递的值
基本类型:形式参数的改变对实际参数没有影响,因为调用后就会弹栈,局部变量 随之消失。
引用类型:形式参数的改变直接 影响实际参数。因为它俩拿的是同一个内存地址。
当形参改变属性值时,实际参数也会改变。
class ArgsDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("a:"+a+",b:"+b); //a:10,b:20
change(a,b);
System.out.println("a:"+a+",b:"+b); //??? a:10,b:20
int[] arr = {1,2,3,4,5};
change(arr);
System.out.println(arr[1]); //??? 4
}
public static void change(int a,int b) { //a=10,b=20
System.out.println("a:"+a+",b:"+b); //a:10,b:20
a = b; //a=20
b = a + b; //b=40
System.out.println("a:"+a+",b:"+b); //a:20,b:40
}
public static void change(int[] arr) { //arr={1,2,3,4,5};
for(int x=0; x<arr.length; x++) {
if(arr[x]%2==0) {
arr[x]*=2;
}
}
//arr={1,4,3,8,5};
}
}
2.12 思考题2加密问题的代码的实现
某个公司采用公用电话传递数据信息,数据是小于8位的整数,为了确保安全,
在传递过程中需要加密,加密规则如下:
首先将数据倒序,然后将每位数字都加上5,再用和除以10的余数代替该数字,
最后将第一位和最后一位数字交换。请任意给定一个小于8位的整数,
然后,把加密后的结果在控制台打印出来。
自己：
package cn.plsite.day04.demo02;
/*
某个公司采用公用电话传递数据信息,数据是小于8位的整数,为了确保安全,
在传递过程中需要加密,加密规则如下:
首先将数据倒序,然后将每位数字都加上5,再用和除以10的余数代替该数字,
最后将第一位和最后一位数字交换。请任意给定一个小于8位的整数,
然后,把加密后的结果在控制台打印出来。
*/
import java.util.Scanner;
public class Encryption {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] arr = new int[8];
System.out.println("请输入小于8位非零整数");
int num = sc.nextInt();
//拆分、倒序
int index = 0;
while (num != 0) {
arr[index] = num % 10;
System.out.println(arr[index]);
num = num / 10;
index++;
}
printArr(arr);
//算数
for (int i = 0; i < index; i++) {
arr[i] += 5;
arr[i] %= 10;
}
printArr(arr);
//第一和最后交换位置
int temp = 0;
temp = arr[0];
arr[0] = arr[index - 1];//这时的索引是多加1了
arr[index - 1] = temp;
printArr(arr);
}
public static void printArr(int[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]);
}
System.out.println();
}
}
答案：
/*通过简单的分析,我们知道如果我们有办法把这个数据变成数组就好了。
不是直接写成这个样子的:
int[] arr = {1,2,3,4,5,6};
如何把数据转成数组呢?
A:定义一个数据
int number = 123456;
B:定义一个数组,这个时候问题就来了,数组的长度是多少呢?
int[] arr = new int[8]; //不可能超过8
在赋值的时候,我用一个变量记录索引的变化。
定义一个索引值是0
int index = 0;
C:获取每一个数据
int ge = number%10
int shi = number/10%10
int bai = number/10/10%10
arr[index] = ge;
index++;
arr[index] = shi;
index++;
arr[index] = bai;
...
*/
class JiaMiDemo {
public static void main(String[] args) {
//定义一个数据
int number = 123456;
//定义一个数组
int[] arr = new int[8];
//把数据中每一位上的数据获取到后存储到数组中
/*
int index = 0;
arr[index] = number%10; //arr[0]=6;
index++;
arr[index] = number/10%10; //arr[1]=5;
index++;
arr[index] = mumber/10/10%10; //arr[2]=4;
*/
//通过观察这个代码,我们发现应该是可以通过循环改进的
int index = 0;
while(number > 0) { //number=123456,number=12345,number=1234,number=123,number=12,number=1,number=0
arr[index] = number%10; //arr[0]=6,arr[1]=5,arr[2]=4,arr[3]=3,arr[4]=2,arr[5]=1
index++;//index=1,index=2,index=3,index=4,index=5,index=6
number/=10;//number=12345,number=1234,number=123,number=12,number=1,number=0
}
//然后将每位数字都加上5,再用和除以10的余数代替该数字
for(int x=0; x<index; x++) {
arr[x] += 5;
arr[x] %= 10;
}
//最后将第一位和最后一位数字交换
int temp = arr[0];
arr[0] = arr[index-1];
arr[index-1] = temp;
//输出数据
for(int x=0; x<index; x++) {
System.out.print(arr[x]);
}
System.out.println();
}
}
643
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
