黑马程序员Java学习笔记（二）
数组概述
- 数组就是用来存储一批同种类型数据的内存区域（可以理解为容器）
int[] arr = {10, 20, 30, 40, 50, 60};
String[] names = {"张三", "李四", "王五"};数组定义方式一、访问、注意事项
- 静态初始化数组：定义数组的时候直接给数组赋值
//完整格式
数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3...};
double[] scores = new double[]{89.9, 99.5, 59.5, 88.0};
int[] ages = new int[]{12, 24, 36};
//简化格式
数据类型[] 数组名 = {元素1, 元素2, 元素3...};
int[] ages = {12, 24, 36};public class ArrayDemo1 {
public static void main(String[] args) {
// double[] scores = new double[]{88.9, 65.8, 94.3};
double[] scores = {88.9, 65.8, 94.3};
// int[] ages = new int[]{19, 22, 21};
int[] ages = {19, 22, 21};
// String[] names = new String[]{"张三", "李四", "王五"};
String[] names = {"张三", "李四", "王五"};
System.out.println(scores);
System.out.println(ages);
System.out.println(names);
}
}
/*
运行结果：
[D@43a25848
[I@3ac3fd8b
[Ljava.lang.String;@5594a1b5
*/[表示是数组格式D、I、Ljava.lang.String;表示的是数据类型- 十六进制字符串则是标识数据在内存中的地址
特别注意：数组变量名中存储的是数组在内存中的地址，数组是引用类型
数组的访问
int[] ages = {19, 22, 21};
// 访问
System.out.println(ages[0]);
// 赋值
ages[0] = 36;
System.out.println(ages[0]);
// 获取数组长度
System.out.println(ages.length);
// 访问数组最大索引
System.out.println(ages[ages.length - 1]);数组的几个注意事项
数据类型[] 数组名也可以写成数据类型 数组名[]- 什么类型的数组必须存放什么类型的数据，否则报错
- 数组一旦定义出来，程序执行的过程中，长度、类型就固定了
数组定义方式二，元素默认值规则
数组的动态初始化
- 定义数组的时候只确定元素的类型和数组的长度，之后再存入具体数据
// 先定义
数据类型[] 数组名 = new 数据类型[长度];
int[] arr = new int[3];
// 后赋值
arr[0] = 10;
System.out.println(arr[0]);动态数据中元素没有赋值，会有一个默认值，int类型为0，double类型为0.0，String类型为null
public class ArrayDemo1 {
public static void main(String[] args) {
double[] scores = new double[3];
System.out.println(scores[0]);
scores[0] = 99.9;
System.out.println(scores[0]);
String[] names = new String[3];
names[0] = "mochu7";
names[2] = "末初";
System.out.println(names[0]);
System.out.println(names[1]);
System.out.println(names[2]);
}
}
/*
运行结果：
0.0
99.9
mochu7
null
末初
*/注意：静态初始化数组和动态初始化数组不可以混用，如下这样是会报错的
int[] arrs = new int[3]{1, 2, 3}数组遍历、元素求和
public class ExampleCode {
public static void main(String[] args) {
double sum = 0;
double[] scores = {67.2, 52.5, 89.9, 92.3, 74.6};
for(int i=0; i<scores.length; i++){
System.out.println(scores[i]);
sum += scores[i];
}
System.out.println("总成绩为：" + sum);
}
}
/*
运行结果为：
67.2
52.5
89.9
92.3
74.6
总成绩为：376.5
*/数组案例：求最值、猜数字、随即排名、冒泡排序
求最大值
public class ExampleCode {
public static void main(String[] args) {
int[] faceScore = {15, 9000, 10000, 20000, 9500, -5};
int max = faceScore[0];
for(int i=0; i<faceScore.length; i++){
if(max < faceScore[i]){
max = faceScore[i];
}
}
System.out.println("最大值：" + max);
}
}
/*
运行结果：
最大值：20000
*/猜数字游戏
package com.example.code;
import java.util.Random;
import java.util.Scanner;
public class ExampleCode {
public static void main(String[] args) {
Random rd = new Random();
Scanner sc = new Scanner(System.in);
int[] nums = new int[5];
for(int i = 0; i < nums.length; i++) {
nums[i] = rd.nextInt(20) + 1;
}
OUT:
while(true) {
System.out.println("请输入你猜的数字(1-20)：");
int guessNumber = sc.nextInt();
for(int i = 0; i < nums.length; i++) {
if(guessNumber == nums[i]) {
System.out.println("恭喜你！答对了，你猜的数字是：" + guessNumber);
break OUT; // 结束外循环
}
}
System.out.println("当前猜测的数据，在数组中不存在，请重新猜测");
}
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i] + "\t");
}
}
}
/*
运行结果：
请输入你猜的数字(1-20)：
12
当前猜测的数据，在数组中不存在，请重新猜测
请输入你猜的数字(1-20)：
6
当前猜测的数据，在数组中不存在，请重新猜测
请输入你猜的数字(1-20)：
7
当前猜测的数据，在数组中不存在，请重新猜测
请输入你猜的数字(1-20)：
14
当前猜测的数据，在数组中不存在，请重新猜测
请输入你猜的数字(1-20)：
16
恭喜你！答对了，你猜的数字是：16
16 1 4 17 16
*/随机排名
package com.example.code;
import java.util.Random;
import java.util.Scanner;
public class ExampleCode {
public static void main(String[] args) {
int[] jobNumber = new int[5];
Random rd = new Random();
Scanner sc = new Scanner(System.in);
for (int i = 0; i < jobNumber.length; i++) {
System.out.println("请输入第" + (i + 1) + "员工的工号：");
jobNumber[i] = sc.nextInt();
}
System.out.print("你输入的工号为：" + " ");
for (int i = 0; i < jobNumber.length; i++) {
System.out.print(jobNumber[i] + "\t");
}
for (int i = 0; i < jobNumber.length; i++) {
int index = rd.nextInt(jobNumber.length);
int temp = jobNumber[index];
jobNumber[index] = jobNumber[i];
jobNumber[i] = temp;
}
System.out.println("\n");
for (int i = 0; i < jobNumber.length; i++) {
System.out.print(jobNumber[i] + "\t");
}
}
}
/*
运行结果：
请输入第1员工的工号：
1234
请输入第2员工的工号：
7479
请输入第3员工的工号：
5117
请输入第4员工的工号：
9876
请输入第5员工的工号：
2469
你输入的工号为： 1234 7479 5117 9876 2469
5117 2469 7479 9876 1234
*/数组排序的技术
- 冒泡排序
- 选择跑徐
- 插入排序
- …
数组搜索相关的技术
- 二分搜索
- 分块查找
- 哈希表查找
- …
public class ExampleCode {
public static void main(String[] args) {
int[] arr = {2, 5, 3, 1};
// 定义一个循环，控制比较轮数
for (int i = 0; i < arr.length - 1; i++) {
// 定一个循环，控制每轮比较次数
for (int j = 0; j < arr.length - i - 1; j++) {
// 判断j当前位置的元素值是否大于后一个位置，若大于则交换
if (arr[j] > arr[j + 1]) {
int temp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = temp;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
}
}数组内存图、常见使用问题
Java内存介绍：
- 栈
- 堆
- 方法区
- 本地方法栈
- 寄存器
方法区：放Class文件的
栈内存：运行的方法、main方法、定义的变量
堆内存：对象
Debug工具使用
- IDEA自带的断点调试(排错)工具，可以控制代码从断点开始一行一行的执行，然后详细观看程序执行的情况。
Debug工具基本使用步骤：
- 在需要控制的代码左侧，点击一下，形成断点
- 选择使用Debug方式启动程序，启动后程序会在断点暂停
- 控制代码一行一行的往下执行
多个断点直接的跳转如下，点击左侧的Resume Program
方法定义格式、常见问题
方法是一种语法结构，它可以把一段代码封装成一个功能，以方便重复调用，提高代码复用性。
public class Demo1 {
public static void main(String[] args) {
int res = sum(55, 45); // 调用方法
System.out.println(res);
}
public static int sum(int a, int b) {
int c = a + b;
return c;
}
}方法定义的完整格式：
修饰符 返回值类型 方法名(形参列表) {
方法体代码(需要执行的功能代码)
return 返回值;
}
public static int sum(int a, int b) {
int c = a + b;
return c;
}
修饰符： public static
返回值类型：int、double、String、void
方法名称：任意定义
形参列表：(参数1, 参数2)
返回值：return 需要返回的变量调用格式：方法名(...)
方法格式的注意事项：
- 方法声明了具体的返回值类型，内部必须使用return返回对应类型的数据
- 形参列表可以有很多个，甚至可以没有；如果有多个形参必须用”,“隔开，且不能给初始化值
- 如果方法不需要返回结果，返回值类型必须声明成
void()，此时方法内部不可以使用return返回数据。 - 方法的编写顺序无所谓(方法定义在调用位置的前后都可以)
- 方法与方法之间是平行关系，不能嵌套定义
- 方法的返回值类型为void(无返回值)，方法内则不能使用return返回数据，如果方法的返回值类型写了具体类型，方法内部则必须使用return返回对应类型的数据。
- return语句下面，不能编写代码，return之后的代码执行不到，属于无效代码
- 方法不调用就不执行，调用时必须严格匹配方法的参数情况
- 有返回值的方法调用时可以选择定义变量的接收结果，或者直接输出调用，甚至直接调用；无返回值方法的调用只能调用；
无参数无返回的方法
public class Demo1 {
public static void main(String[] args) {
print();
}
public static void print() {
System.out.println("Hello,World");
System.out.println("Hello,World");
System.out.println("Hello,World");
}
}方法案例：求和、判断奇偶数、求最值
求和
public class Demo1 {
public static void main(String[] args) {
System.out.println("1-50的和：" + sum(50));
System.out.println("1-100的和：" + sum(100));
}
public static int sum(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += i;
}
return sum;
}
}判断奇偶数
public class Demo1 {
public static void main(String[] args) {
check(11);
check(100);
}
public static void check(int n) {
if (n % 2 == 0) {
System.out.println(n + "是偶数");
}else {
System.out.println(n + "是奇数");
}
}
}求最值
public class Demo1 {
public static void main(String[] args) {
int[] examScore = {78, 99, 123, 143, 98, 86, 112, 127, 65};
int max = getArrayMaxNumber(examScore);
System.out.println("数组最大值是：" + max);
}
public static int getArrayMaxNumber(int[] arr) {
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
return max;
}
}方法的内存原理
方法的调用流程：
- 方法没有被调用的时候，在方法区中的字节码文件中存放
- 方法被调用的时候，需要进入到栈内存中运行
方法参数传递机制
值传递
- 在传输实参给方法的形参的时候，并不是传输实参变量本身，而是传输实参变量中存储的值，这就是值传递
– 实参：在方法内部定义的变量
– 形参：在定义方法时，”()“ 中所声明的参数
public class Demo1 {
public static void main(String[] args) {
int a = 10;
change(a);
System.out.println(a); // 10
}
public static void change(int a) {
System.out.println(a); // 10
a = 20;
System.out.println(a); // 20
}
}引用传递
public class Demo1 {
public static void main(String[] args) {
int[] arrs = {10, 20, 30};
change(arrs);
System.out.println(arrs[1]); // 222
}
public static void change(int[] arrs) {
System.out.println(arrs[1]); // 20
arrs[1] = 222;
System.out.println(arrs[1]); // 222
}
}通过地址传递，直接修改了该地址上的值
- 基本类型和引用类型的参数在传递的时候都是值传递
– 基本类型的参数传输存储的数据值
– 引用类型的参数传输存储的地址值
方法参数传递的案例
案例一：打印数组内容
public class Demo1 {
public static void main(String[] args) {
int[] ages = {10, 20, 30, 40};
printArray(ages);
int[] numbers = null;
printArray(numbers);
int[] numbers1 = {};
printArray(numbers1);
}
public static void printArray(int[] arr) {
System.out.print("[");
if (arr != null && arr.length != 0) {
for (int i = 0; i < arr.length; i++) {
System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ", ");
}
}
System.out.println("]");
}
}案例二：从数组中查询元素的索引返回
public class Demo1 {
public static void main(String[] args) {
// 从整型数组中查询某个索引返回，不存在返回-1
int[] arr = {12, 24, 36, 41, 59};
int index = searchIndex(arr, 40);
System.out.println("您查询的数据索引是：" + index);
}
public static int searchIndex(int[] arr, int data) {
for (int i = 0; i < arr.length; i++) {
if (data == arr[i]) {
return i;
}
}
return -1;
}
}案例三：比较两个数组内容是否相同
public class Demo1 {
public static void main(String[] args) {
int[] arr1 = {10, 20, 30, 40, 50};
int[] arr2 = {10, 20, 30, 41, 50};
System.out.println(compareArray(arr1, arr2));
}
public static boolean compareArray(int[] arr1, int[] arr2) {
if (arr1.length == arr2.length) {
for (int i = 0; i < arr1.length; i++) {
if(arr1[i] != arr2[i]) {
return false;
}
}
return true;
}else {
return false;
}
}
}方法重载、return关键字
方法重载：同一个类中，出现多个方法名称相同，但是形参列表是不同的，那么这些方法就是重载方法。
public class Demo1 {
public static void main(String[] args) {
fire();
fire("岛国");
fire("岛国", 100);
}
public static void fire() {
System.out.println("默认发射一枚武器给米国");
}
public static void fire(String location) {
System.out.println("默认发射一枚武器给" + location);
}
public static void fire(String location, int number) {
System.out.println("默认发射" + number + "枚武器给" + location);
}
}- 使用方法重载的好处：
对于相似功能的业务场景：可读性好，方法名称相同提示是同一类型的功能，通过形参不同实现功能差异化的选择，这是一种专业的代码设计。 - 方法重载的识别技巧：
只要是同一个类中，方法名称相同，形参列表不同，那么他们就是重载的方法，其他的不管！（如：修饰符，返回值类型都无所谓）
形参列表不同指的是：形参的个数、类型、顺序不同，不关心形参的名称
return关键字的单独使用
return; 可以立即跳出并结束当前方法的执行；return关键字单独使用可以放在任何方法中。
public class Demo1 {
public static void main(String[] args) {
chu(10, 0);
}
public static void chu(int a, int b) {
if (b == 0) {
System.out.println("除数不能为0");
return; //直接跳出当前方法
}else {
int c = a / b;
System.out.println("结果是：" + c);
}
}
}编程训练-案例1：买飞机票
package com.mochu.project1;
import java.util.Scanner;
public class BuyAirtTckets {
public static void main(String[] args) {
// 1、用户输入机票原价、月份、舱位类型
Scanner sc = new Scanner(System.in);
System.out.print("请输入机票原价：");
double price = sc.nextDouble();
System.out.print("请输入月份（1-12）：");
int month = sc.nextInt();
System.out.print("请输入舱位类型：");
String cabin = sc.next();
System.out.println("机票的价格是：" + calcPrice(price, month, cabin) + "￥");
}
// 定义方法接收信息，统计优惠后的价格返回
public static double calcPrice(double price, int month, String cabin) {
// 旺季5-10月，淡季11-12月、1-4月
if (month >= 5 && month <= 10) {
// 旺季
switch (cabin) {
case "头等舱":
price *= 0.9;
break;
case "经济舱":
price *= 0.85;
break;
default:
System.out.println("对不起，您输入的舱位类型有误~");
price = -1;
}
}else if (month == 11 || month == 12 || month >= 1 && month <= 4){
// 淡季
switch (cabin) {
case "头等舱":
price *= 0.7;
break;
case "经济舱":
price *= 0.65;
break;
default:
System.out.println("对不起，您输入的舱位类型有误~");
price = -1;
}
}else {
System.out.println("对不起，您输入的月份有误~");
return -1;
}
return price;
}
}
编程训练-案例2：找素数
判断101~200之间有多少个素数，并输出所有素数
素数：除了1和它本身以外，不能被其它正整数整除，这就叫素数
package com.mochu.project1;
public class SearchPrimeNumber {
public static void main(String[] args) {
// 定义一个循环，遍历101-200之间的全部数字
for (int i = 101; i <= 200 ; i++) {
// 判断遍历当前这个数是否是素数
boolean flag = true;
for (int j = 2; j < i / 2 ; j++) {
if(i % j == 0) {
flag = false;
break;
}
}
if(flag) {
System.out.print(i + "\t");
}
}
}
}编程训练-案例3：验证码
package com.mochu.project1;
import java.util.Random;
public class CreateVerifCode {
public static void main(String[] args) {
String code = createVerifCode(5);
System.out.println("验证码：" + code);
}
// 定义一个方法返回一个随机验证码，返回值类型为String，形参int n位数
public static String createVerifCode(int n) {
String verifcode = "";
Random rd = new Random();
for (int i = 0; i < n; i++) {
int type = rd.nextInt(3);
switch(type) {
case 0:
// 大写字符(ASCII 65-90)
char ch = (char) (rd.nextInt(26) + 65);
verifcode += ch;
break;
case 1:
// 小写字符(ASCII 97-122)
char ch1 = (char) (rd.nextInt(26) + 97);
verifcode += ch1;
break;
case 2:
// 数字(ASCII 48-57)
int num = rd.nextInt(10);
verifcode += num;
break;
}
}
return verifcode;
}
}
编程训练-案例4：数组的复制
package com.mochu.project1;
public class ArrayCopy {
public static void main(String[] args) {
int[] arr1 = {11, 22, 33, 44, 55};
int[] arr2 = new int[arr1.length];
arrayCopy(arr1, arr2);
printArray(arr1);
printArray(arr2);
}
public static void arrayCopy(int[] arr1, int[] arr2) {
for (int i = 0; i < arr1.length; i++) {
arr2[i] = arr1[i];
}
}
public static void printArray(int[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ", ");
}
System.out.println("]");
}
}
编程训练-案例5：评委打分
package com.mochu.project1;
import java.util.Scanner;
public class JudgeScore {
public static void main(String[] args) {
// 定义一个动态数组存储六位评委的分数
int[] scores = new int[6];
Scanner sc = new Scanner(System.in);
for (int i = 0; i < scores.length; i++) {
System.out.print("请输入第" + (i + 1) + "位评委的分数：");
int score = sc.nextInt();
scores[i] = score;
}
int max = scores[0];
int min = scores[0];
int sum = 0;
for (int i = 0; i < scores.length; i++) {
if(scores[i] > max) {
max = scores[i];
}
if(scores[i] < min) {
min = scores[i];
}
sum += scores[i];
}
double result = (sum - max - min) * 1.0 / (scores.length - 2);
System.out.println("选手最终得分是：" + result);
}
}
编程训练-案例6：数字加密
package com.mochu.project1;
import java.util.Scanner;
public class NumberEncrypt {
public static void main(String[] args) {
System.out.print("请输入需要加密的数字个数：");
Scanner sc = new Scanner(System.in);
int length = sc.nextInt();
int[] arr = new int[length];
// 录入数组元素
for (int i = 0; i < arr.length; i++) {
System.out.print("请输入第" + (i + 1) + "位数字：");
int number = sc.nextInt();
arr[i] = number;
}
printArray(arr); // 打印数组
// 数字加密
for (int i = 0; i < arr.length; i++) {
arr[i] = (arr[i] + 5) % 10;
}
// 数组反转（逆序）
for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
int temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
printArray(arr);
}
// 打印数组的方法
public static void printArray(int[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ", ");
}
System.out.println("]");
}
}
编程训练-案例7：模拟双色球
package com.mochu.project1;
import java.util.Random;
import java.util.Scanner;
public class DoubleColorBall {
public static void main(String[] args) {
// 随机生成6个红球号码(1-33，不能重复)，随机一个蓝球号码(1-16)，采用数组将中奖号码封装起来。
int[] lucknumbers = createLuckyNumber();
// 用户输入七个双色球号码，作为用户选号
int[] inputnumbers = userInputNumbers();
judge(lucknumbers, inputnumbers);
}
// 判断中奖，判断红球、蓝球分别中了多少个数
public static void judge(int[] lucknumbers, int[] inputnumbers){
int redballcount = 0;
int blueballcount = 0;
// 统计红球中了多少个
for (int i = 0; i < inputnumbers.length - 1; i++) {
for (int j = 0; j < lucknumbers.length - 1; j++) {
if(inputnumbers[i] == lucknumbers[j]) {
redballcount++;
break;
}
}
}
// 统计蓝球中了没中
blueballcount = inputnumbers[inputnumbers.length - 1] == lucknumbers[lucknumbers.length - 1] ? 1 : 0;
System.out.println("您的号码是：");
printArray(inputnumbers);
System.out.println("中奖号码是：");
printArray(lucknumbers);
System.out.println("您命中了" + redballcount + "个红球");
System.out.println("您" + (blueballcount == 1 ? "命中了" : "没有命中") + "蓝球");
// 判断奖励情况
if(blueballcount == 1 && redballcount < 3) {
System.out.println("恭喜您！，获得5元奖励~");
}else if(blueballcount == 1 && redballcount == 3 || blueballcount == 0 && redballcount == 4) {
System.out.println("恭喜您！获得10元奖励~");
}else if(blueballcount == 1 && redballcount == 4 || blueballcount == 0 && redballcount == 5) {
System.out.println("恭喜您！获得200元奖励~");
}else if(blueballcount == 1 && redballcount == 5) {
System.out.println("恭喜您！获得3000元奖励~");
}else if(blueballcount == 0 && redballcount == 6) {
System.out.println("恭喜您！获得500万奖励~");
}else if(blueballcount == 1 && redballcount == 6) {
System.out.println("恭喜您！获得1000万奖励~");
}else {
System.out.println("很遗憾，您没有获奖");
}
}
// 录入用户生成号码
public static int[] userInputNumbers() {
int[] inputNumbers = new int[7];
Scanner sc = new Scanner(System.in);
for (int i = 0; i < inputNumbers.length - 1; i++) {
System.out.print("请输入第" + (i + 1) + "个红球号码（1-33，要求不重复）：");
inputNumbers[i] = sc.nextInt();
}
System.out.print("请输入篮球号码（1-16，要求不重复）：");
inputNumbers[inputNumbers.length - 1] = sc.nextInt();
return inputNumbers;
}
// 生成中奖号码
public static int[] createLuckyNumber() {
int[] numbers = new int[7];
// 6个不重复的红球号码(1-33)
Random rd = new Random();
for (int i = 0; i < numbers.length - 1; i++) {
// 需要判断当前这个随即号码之前是否出现过，如果出现过则需要重新生成一个号码直到不重复为止。
while (true) {
int data = rd.nextInt(33) + 1;
boolean flag = true;
for (int j = 0; j < i; j++) {
if(numbers[j] == data) {
flag = false;
break;
}
}
if(flag) {
numbers[i] = data;
break;
}
}
}
// 生成蓝球号码(1-16)
numbers[numbers.length - 1] = rd.nextInt(16) + 1;
return numbers;
}
// 遍历数组
public static void printArray(int[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
System.out.print(i == arr.length -1 ? arr[i] : arr[i] + ", ");
}
System.out.println("]");
}
}
