文章目录
本博客配套黑马的教学视频,B战可以搜索到,教学视频链接,从第53个视频IDEA的安装开始,前52个视频的配套CSDN请查看我的另外一篇博客,博客链接
8 数组
8.1 数组定义格式
数组的定义格式有两种:
格式一:数据类型[] 变量名
范例:int[] arr
定义了一个int类型的数组,数组名是arr
格式二:数据类型 变量名[]
范例:int arr[]
定义了一个int类型的变量,变量是arr数组
推荐使用格式一
例:注意,定义数组会默认给数组赋初始值,值为0
public class ArrayTest4 {
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]);
}
}
8.2 静态、动态初始化
Java中的数组必须先初始化,然后才能使用
所谓初始化:就是为数组中的数组元素分配内存空间,并为每个数组元素赋值
数组初始化有两种方法:动态初始化、静态初始化
-
动态初始化:初始化时只指定数组长度,由系统为数组分配初始值
格式:数据类型[] 变量名 = new 数据类型[数组长度];
范例:int[] arr = new int[3];
-
静态初始化:初始化时指定每个数组元素的初始值,由系统确定数组长度
格式:数组类型[] 变量名 = new 数据类型[] {数据1,数据2,数据3,...};
范例:int[] arr = new int[] {1,2,3};
简化格式:数据类型[] 变量名 = {数据1,数据2,数据3,...}
范例:int[] arr = {1,2,3};
推荐简化格式
public class ArrayDemo02 {
public static void main(String[] args) {
//静态初始化
int[] arr1 = new int[] {1,2,3}; //一样可以
int[] arr = {1,2,3};
//输出数组名
System.out.println(arr);
//输出数组中的元素
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
例2:
public class ArrayInRam {
public static void main(String[] args) {
//静态初始化
int[] a = {5, 7, 20};
//动态初始化
int[] b = new int[4];
}
}
8.3 数组元素访问
数组变量访问方式
格式:数组名
数组内部保存的数据的访问方式
格式:数组名[索引]
索引是数组中数据的编号方式
作用:索引用于访问数组中的数据使用,**数组名[索引]**等同于变量名,是一种特殊的变量名
特征1:索引是从0开始的
特征2:索引是连续的
特征3:索引是逐一增加的,每次加1
package com.itheima;
/*
数组:是一种用于存储多个相同类型数据的存储模型
定义格式:(推荐方式)
数据类型[] 数组名;
举例: int[] arr;
数组初始化:
动态初始化
int[] arr = new int[3];
静态初始化
*/
public class ArrayDemo {
public static void main(String[] args) {
//int[] int类型数组
//arr 数组名称
//new 为数组申请内存空间
//int[3] 数组,元素类型为整型,3个元素
int[] arr = new int[3];
//赋值
arr[0] = 100;
arr[2] = 200;
//输出数组名
System.out.println(arr); //[I@58ceff1
//输出数组中的元素
System.out.println(arr[0]); //0是由系统分配的
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
8.4 内存分配
Java程序在运行时,需要在内存中分配空间。为了提高运算效率,就对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据方式和内存管理方式。
单个数组内存图如下
代码实现如下
package com.itheima;
public class ArrayTest1 {
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[1] = 200;
//再次输出
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
多个数组的内存图如下
代码实现如下
package com.itheima;
public class ArrayTest2 {
public static void main(String[] args) {
//定义一个数组
int[] arr = new int[3];
int[] arr2 = new int[3];
//输出数组名及元素
System.out.println("arr----");
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println("arr2-------");
System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
System.out.println("赋值后----------");
//给数组中元素赋值
arr[0] = 100;
arr2[0] = 200;
arr2[2] = 300;
//再次输出
System.out.println("arr----");
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println("arr2-------");
System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
}
}
多个数组指向相同时
代码实现如下
package com.itheima;
public class ArrayTest3 {
//多个数组指向相同时
public static void main(String[] args) {
//定义一个数组
int[] arr = new int[3];
arr[0] = 100;
arr[1] = 200;
arr[2] = 300;
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
//定义第二个数组,并指向第一个数组
int[] arr2 = arr;
arr2[0] = 111;
arr2[1] = 222;
arr2[2] = 333;
System.out.println("arr---------");
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println("arr2---------");
System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
}
}
8.5 数组常见问题
1.索引越界:访问了数组中不存在的索引对应的元素
代码演示如下
package com.itheima;
/*
索引越界:访问的元素超出索引
*/
public class ArrayDemo04 {
public static void main(String[] args) {
int[] arr = new int[3];
System.out.println(arr[3]);
}
}
2.空指针异常:访问的数组已经不再指向堆内存的数据
null是空值,引用数据类型的默认值,表示不指向任何有效对象
代码演示如下
package com.itheima;
/*
空指针异常
null:空值
*/
public class ArrayDemo04 {
public static void main(String[] args) {
int[] arr = new int[3];
//空指针异常
//null赋值给数组
arr = null;
System.out.println(arr[0]);
}
}
8.6 数组常见操作
1.遍历
public class ArrayTest01 {
public static void main(String[] args) {
//定义数组
int[] arr = {11,22,33,44,55};
//遍历
for(int x=0; x<arr.length; x++) {
System.out.println(arr[x]);
}
}
}
2.获取最值
public class ArrayTest02 {
public static void main(String[] args) {
int[] arr = {12,45,98,73,60};
int max = arr[0];
int min = arr[0];
for (int i=1; i<arr.length; i++){
if (max < arr[i]){
max = arr[i];
}
if(min > arr[i]){
min = arr[i];
}
}
System.out.println("最大值:" + max);
System.out.println("最小值:" + min);
}
}
9 方法
9.1 方法概述
什么是方法?:是将具有独立功能的代码块组织成为一个整体,使其具有特殊功能的代码集
注意事项:
- 方法必须先创建才可以使用,该过程称为方法定义
- 方法创建后并不是直接运行的,需要手动使用后才执行,该过程称为方法调用
9.2 方法的定义和调用
例1:无参无返回值的方法定义与调用
public class MethodDemo {
public static void main(String[] args) {
//调用方法
isEvenNumber();
}
//需求:定义一个方法,在方法中定义一个变量,判断该数据是否为偶数
public static void isEvenNumber(){
//定义变量
int number = 20;
//判断是否为偶数
if (number%2==0){
System.out.println(true);
}
else{
System.out.println(false);
}
}
}
案例1:打印两个数中的最大值
public class MethodDemo02 {
public static void main(String[] args) {
getMax();
}
public static void getMax(){
int a = 10;
int b = 20;
if (a>b){
System.out.println(a);
}
else{
System.out.println(b);
}
}
}
例2:有参数无返回值的方法定义与调用
public class MethodDemo03 {
public static void main(String[] args) {
isEvenNumber(19);
}
public static void isEvenNumber(int number){ //带参数
if(number%2==0){
System.out.println(true);
}
else{
System.out.println(false);
}
}
}
例3:有参有返回值的方法定义与调用
public class MethodDemo05 {
public static void main(String[] args) {
boolean target = isEvenNumber(20);
System.out.println(target);
}
//需求:定义一个方法,该方法接收一个参数,判断该数据是否为偶数,并返回真假值
public static boolean isEvenNumber(int number){
if(number%2==0){
return true;
}
else{
return false;
}
}
}
案例:设计一个方法可以获取两个数的较大值,数据来自于参数
public class MethodDemo06 {
public static void main(String[] args) {
int max = getMax(10,20);
//两种输出方法
System.out.println(max);
System.out.println(getMax(10,20));
}
//定义一个方法,用于获取两个数字的较大数
public static int getMax(int a, int b){
if (a>b){
return a;
}
else{
return b;
}
}
}
9.3 形参、实参
形参:方法定义中的参数,等同于变量定义格式,例如:int number
实参:方法调用中的参数,等同于使用变量或常量,例如:10, number
例:
package myMethod;
/*
参数个数对应
*/
public class MethodDemo04 {
public static void main(String[] args) {
getMax(10,20);
}
public static void getMax(int a, int b){
if (a>b){
System.out.println(a);
}
else{
System.out.println(b);
}
}
}
9.4 方法的注意事项
1.方法不能嵌套定义
2.void表示无返回值,可以省略return,也可以单独的书写return,后面不加数据
package myMethod;
public class MethodDemo07 {
public static void main(String[] args) {
}
public static void methodOne(){
} //可以省略return,或者只写return不返回数
public static void methodTwo(){
return;
}
}
9.5 方法重载
方法重载:指同一个类中定义的多个方法之间的关系,满足下列条件的多个方法可以构成重载
- 多个方法在同一个类中
- 多个方法具有相同的方法名
- 多个方法的参数不相同,参数类型不同或者参数数量不同
重载仅对应方法的定义,与方法的调用无关,调用方法参照标准格式
重载仅针对同一个类中方法的名称与参数进行识别,与返回值无关,换句话说不能通过返回值来判定两个方法是否构成重载
代码实现如下:
package myMethod;
/*
方法重载:
多个方法在同一个类中
多个方法具有相同的方法名
多个方法的参数不相同,类型不同或者数量不同
与返回值无关
在调用的时候Java虚拟机会根据参数的不同调用相同名字的不同方法
*/
public class MethodDemo08 {
public static void main(String[] args) {
int result = sum(1,2);
System.out.println(result);
double result1 = sum(1.1, 2.1);
System.out.println(result1);
int result2 = sum(1,2,3);
System.out.println(result2);
}
//需求1:求两个int类型数据和的方法
public static int sum(int a, int b){
return a+b;
}
//需求2:求连那个歌double类型数据和的方法
public static double sum(double a, double b){
return a+b;
}
//需求3:求三个int类型数据和的方法
public static int sum(int a, int b, int c){
return a+b+c;
}
}
练习:判断两个数是否相等
package myMethod;
public class MethodDemo09 {
public static void main(String[] args) {
System.out.println(compare(1,2));
System.out.println(compare((short)1,(short)2)); //强转
System.out.println(compare(1L,2L));
System.out.println(compare((byte)1,(byte)2));
}
//int
public static boolean compare(int a, int b){
System.out.println("int");
return a==b;
}
//long
public static boolean compare(long a, long b){
System.out.println("long");
return a==b;
}
//short
public static boolean compare(short a, short b){
System.out.println("short");
return a==b;
}
//byte
public static boolean compare(byte a, byte b){
System.out.println("byte");
return a==b;
}
}
9.6 方法的参数传递
对于基本数据类型的参数,形式参数的改变,不影响实际参数的值
package myMethod;
/*
对于基本数据类型的参数,形式参数的改变,不影响实际参数的值
*/
public class ArgsDemo01 {
public static void main(String[] args) {
int number = 100;
System.out.println("调用change方法前:" + number);
change(number);
System.out.println("调用change方法后:" + number);
System.out.println("----------------------------");
System.out.println("调用change1方法前:" + number);
number = change1(number);
System.out.println("调用change1方法后:" + number);
}
public static void change(int number){
number = 200;
}
public static int change1(int number){
number = 200;
return number;
}
}
例2:对于引用类型的参数,形式参数的改变,影响实际参数的值
package myMethod;
/*
对于引用类型的参数,形式参数的改变,影响实际参数的值
*/
public class ArgsDemo02 {
public static void main(String[] args) {
int[] arr = {10,20,30};
System.out.println("调用change方法前:" + arr[1]);
change(arr);
System.out.println("调用change方法后:" + arr[1]);
}
public static void change(int[] arr){
arr[1] = 200;
}
}
调用change方法前:20
调用change方法后:200
10 Debug
本章节对应黑马的第86个视频,视频链接
Debug:是供程序员使用的程序调试工具,它可以用于查看程序的执行流程,也可以用于追踪程序执行过程来调试程序。
Debug调试:又称为断点调试,断点其实是一个标记,告诉我们从哪里开始查看
Debug调试内容如下:
- 如何加断点
- 如何运行加了断点的程序
- 看哪里
- 点哪里
- 如何删除断点
具体操作使用流程看视频比看博客更容易理解,请查看本章节上面的视频链接,本章节使用到的代码如下:
package Debug;
/*
1.如何加断点
2.如何运行加了断点的程序
3.看哪里
4.点哪里
5.如何删除断点
*/
public class DebugDemo {
public static void main(String[] args) {
//定义两个变量
int i = 10;
int j = 20;
//求和
int sum = i + j;
//输出结果
System.out.println("sum:" + sum);
}
}
例2:视频87的代码
package Debug;
/*
查看循环求偶数和的执行流程
*/
public class DebugTest01 {
public static void main(String[] args) {
//定义求和变量
int sum = 0;
//循环求偶数和
for (int i = 1; i <= 10; i++) {
if (i % 2 == 0) {
sum += i;
}
}
//输出结果
System.out.println(sum);
}
}
总结
首先介绍一下导包的三种方法:
1.手动导包
2.Alt+Enter
3.自动导包,回车导包
案例1:减肥计划
package myTest;
/*
需求:输入星期数,输出今天的减肥活动
周一:跑步
周二;游泳
周三:慢走
周四:动感单车
周五:拳击
周六:爬山
周日:好好吃一顿
*/
//1.导包
import java.util.Scanner;
public class Test01 {
public static void main(String[] args) {
//调用方法
int week = Input();
while(week<1 || week>7)
{
System.out.println("你输入的星期数有误!请重新输入!");
week = Input();
}
if (week==1)
{
System.out.println("跑步");
}
else if (week==2)
{
System.out.println("游泳");
}
else if (week==3)
{
System.out.println("慢走");
}
else if (week==4)
{
System.out.println("动感单车");
}
else if (week==5)
{
System.out.println("拳击");
}
else if (week==6)
{
System.out.println("爬山");
}
else if (week==7)
{
System.out.println("好好吃一顿");
}
}
public static int Input()
{
//2.创建对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入星期:");
//3.接收数据
int week = sc.nextInt();
return week;
}
}
案例2:Switch实现上面功能
package myTest;
/*
需求:输入星期数,输出今天的减肥活动
周一:跑步
周二;游泳
周三:慢走
周四:动感单车
周五:拳击
周六:爬山
周日:好好吃一顿
*/
//1.导包
import java.util.Scanner;
public class Test02 {
public static void main(String[] args) {
//调用方法
int week = Input();
while(week<1 || week>7)
{
System.out.println("你输入的星期数有误!请重新输入!");
week = Input();
}
switch(week)
{
case 1:
System.out.println("跑步");
break;
case 2:
System.out.println("游泳");
break;
case 3:
System.out.println("慢走");
break;
case 4:
System.out.println("动感单车");
break;
case 5:
System.out.println("拳击");
break;
case 6:
System.out.println("爬山");
break;
case 7:
System.out.println("好好吃一顿");
break;
//default:
}
}
public static int Input()
{
//2.创建对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入星期:");
//3.接收数据
int week = sc.nextInt();
return week;
}
}
案例3:逢7过
package myTest;
/*
逢7过
个位是7,或者十位是7,或者被7整除,就输出过
*/
public class Test03 {
public static void main(String[] args) {
for(int x=1; x<=100; x++)
{
if(x%10==7 || x/10%10==7 || x/7==0)
{
System.out.println("过");
}
else
{
System.out.println(x);
}
}
}
}
案例4:不是神兔(递归)
package myTest;
/*
需求:
有一对兔子,三个月起每个月生一对兔子
20个月后有多少对
*/
public class Test04 {
public static void main(String[] args) {
int[] arr = new int[20];
arr[0] = arr[1] = 1;
for(int i=2; i<20; i++){
arr[i] = arr[i-1] + arr[i-2];
}
System.out.println(arr[19]);
System.out.println("-------------------");
System.out.println(Add(arr, 19));
}
public static int Add(int[] arr, int i){
arr[0] = arr[1] = 1;
arr[i] = arr[i-1] + arr[i-2];
return arr[i];
}
}
案例5:百钱白鸡
package myTest;
/*
百钱白鸡
*/
public class Test05 {
public static void main(String[] args) {
for (int x = 0; x <= 20; x++) {
for (int y = 0; y <= 33; y++) {
int z = 100 - x - y;
if (z % 3 == 0 && 5 * x + 3 * y + z / 3 == 100) {
System.out.println("x:" + x);
System.out.println("y:" + y);
System.out.println("z:" + z);
System.out.println("--------------------");
}
}
}
}
}
案例6:数组元素求和
求和的元素个位和十位不能是7,且只能是偶数
package myTest;
public class Test06 {
public static void main(String[] args) {
int[] arr = {68,27,95,88,171,996,51,210};
int sum = 0;
for (int i=0; i<arr.length; i++){
if(arr[i]%2==0 && arr[i]%10!=7 && arr[i]/10%10!=7){
sum += arr[i];
}
}
System.out.println(sum);
}
}
案例7:数组内容相同比较
package myTest;
/*
比较两个数组是否相同
*/
public class Test07 {
public static void main(String[] args) {
int[] arr = {11,22,33,44,55};
int[] arr1 = {11,22,33,44,55};
System.out.println(compare(arr,arr1));
}
public static boolean compare(int[] arr, int[] arr1) {
if (arr.length != arr1.length) {
return false;
}
for (int x=0; x< arr.length; x++){
if(arr[x] != arr1[x]){
return false;
}
}
return true;
}
}
案例8:查找索引值
package myTest;
import java.util.Scanner;
public class Test08 {
public static void main(String[] args) {
//定义一个数组
int[] arr = {19,28,37,46,50};
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个数字:");
int number = sc.nextInt();
int index = getIndex(arr, number);
//输出索引变量
System.out.println(index);
}
public static int getIndex(int[] arr, int number){
//定义索引
int index = -1;
//遍历数组
for (int x=0; x< arr.length; x++){
if(arr[x] == number){
index = x;
break;
}
}
return index;
}
}
案例9:反转
package myTest;
public class Test09 {
public static void main(String[] args) {
//定义一个数组,用静态初始化完成数组元素的初始化
int[] arr = {19, 28, 37, 46, 50};
reverse(arr);
//遍历输出数组
printArray(arr);
}
//反转
public static void reverse(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.print(arr[x]);
} else {
System.out.print(arr[x] + ",");
}
}
System.out.print("]");
}
}
案例10:评委打分
去掉最高分最低分,求平均值
package myTest;
import java.util.Scanner;
public class Test10 {
public static void main(String[] args) {
//定义一个数组,用动态初始化完成数组元素的初始化,长度为6
int[] arr = new int[6];
//键盘录入评委分数
Scanner sc = new Scanner(System.in);
for(int x=0; x<arr.length; x++){
System.out.println("请输入第" + (x+1) + "个评委的打分:");
arr[x] = sc.nextInt();
}
printArray(arr);
int max = getMax(arr);
int min = getMin(arr);
int sum = getSum(arr);
int avg = (sum-max-min)/(arr.length-2);
System.out.println("avg:" + avg);
}
//遍历数组
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 int getMax(int[] arr){
int max = arr[0];
for (int i=0; i<arr.length; i++){
if(max<arr[i]){
max = arr[i];
}
}
return max;
}
public static int getMin(int[] arr){
int min = arr[0];
for (int i=0; i<arr.length; i++){
if(min>arr[i]){
min = arr[i];
}
}
return min;
}
public static int getSum(int[] arr){
int sum = 0;
for (int i=0; i< arr.length; i++){
sum += arr[i];
}
return sum;
}
}