JAVA笔记--编程基础（第四篇）
作者：互联网
目录
一、方法与数组
1、方法
i、方法的定义
方法就是一段特定功能的代码块，也叫函数，提高程序的复用性和可读性。
ii、方法的格式
语法：
访问权限修饰符[其他的修饰符 如static] 返回值类型 方法名(参数类型1 形参1，参数类型2 形参2...){
// 形参列表
// 方法体
return 返回值；
}
返回值类型，也就是功能的数据类型，后面我们可以定义实体；
方法名：见名知意，首字母小写，驼峰命名；
public class Test{
public static void main(String[] args){
getMenu(); //调用方法，此时方法才会运行。
printStar(1);
}
// public 访问权限修饰符
// static 静态修饰符，描述的方法可以直接调用
// void(无返回值)
public static void getMenu(){
System.out.println("这是一个方法！");
}
// 带参数的方法
// 在方法定义时的参数称为形参，调用时为实参
public static void printStar(int line){
System.out.println("这是一个方法！");
}
}iii、参数
实际参数：就是实际参与运算的参数；
形式参数：就是方法定义上的，用于接收实际参数的；
参数类型：就是参数的数据类型；
参数名：就是变量名；
方法体语句：就是完成功能的代码
注意：若当前方法中不要使用形参，那么形参列表中可以为空；
实参和形参的类型要相互兼容，实参范围小于等于形参的范围。
iv、返回值
return： 用于结束方法的。
返回值：就是功能的结果，或者方法运行的最终结果，由return带给调用者。
注意：若当前方法没有返回值类型，即返回值为void，那么当前方法中可以不写return；
return即表示结束一个方法，也可以将返回值返回给调用当前方法的调用者
return返回值时一次只能返回一个值，不可以返回多个值；
一个方法中可以有多个return，但被执行的只能由一个，所以需要判断；
v、方法重载overloading method
在类中可以创建多个方法，他们具有相同的名字，但具有不同的参数和不同的定义；
返回值不能作为重载的条件。
public class Test{
public static void main(String[] args){
int result = add(10,20);
System.out.println(result)
}
public static int add(int a,int b){
return a+b
}
public static int add(float a,float b){
return a+b
}
}2、数组
i、数组的定义
一组能够存储相同数据类型的变量的集合。
数组是一种线性数据存储的结构，具有存取效率高，内存空间连续的特点，数组必须具有固定长期，常用的数据结构。
ii、定义数组
使用默认的初始值来初始化数组中的每一个元素
数组元素类型[] 数组名 = new 数组元素类型[数组中元素的个数（数组的长度）]；
int [] scores = new int[3];
先声明，然后在赋予数组默认的初始值
数组元素类型[] 数组名；
数组名 = new 数组元素类型[数组中元素的个数（数组的长度）];
int [] scores;
scores = new int[3];
先声明，然后再使用指定的值进行初始化。
数组元素类型[] 数组名 = new 数组元素类型[]{元素1，元素2，....}；
int[] scores = new int[]{56,78,98};
简化写法：
int [] scores = {56,78,98};
public class Test{
public static void main(String[] args){
int[] nums = new int[5];
nums[0]=1;
nums[1]=2;
nums[2]=3;
nums[3]=4;
nums[4]=5;
int[] num;
num = new int[5];
for(int i=0;i<num.length;i++){
num[i]=i+1;
}
int[] num1={1,2,3,4,5};
}
}iii、数组的遍历
求数组的长度用x.length
通过下标来访问数组中的元素。
下标：从0开始，到数组长度-1
遍历：依次取出数组中的每一个元素。
遍历方式：普通的for循环
for(int i =0;i<数组长度;i++){
// i ：循环变量，也是数组的下标
数组中元素的类型 变量 = 数组名[i]；
}
jdk1.5新增：forearch遍历
for(int x:scores){
Systen.out.println(x)
}
注意：可变参数可以作为数组使用，可变参数必须是参数列表最后一个参数，在数据类型后跟三个点...；在方法调用时，直接传值，不需要再定义数组。
iv、数组注意问题
空指针异常（NullPointerException）
当一个变量为null（没有赋值时），我们调用了该变量的属性和方法
数组越界异常（ArrayIndexOutOfBoundsException）
也就是超过了数组长度；
数组内存数据结构分析：
数组是引用类型，会存放再堆中；
v、示例
import java.util.Scanner
public class Test{
public static void main(String[] args){
int[] nums={12,13,15,34,23};
Scanner input = new Scanner(System.in);
System.out.println("请输入你要猜的数：");
int userNum = input.nextInt();
boolean flag = false;
for(int x:nums){
if(userNum==x){
flag = true;
break;
}
}
if(flag){
System.out.println("恭喜你猜对了！");
}else{
System.out.println("没猜中");
}
}
}二维数组：java中没有真正的多维数组，多维数组的表示方式是数组中的元素还是数组。
题：有三个班级各三名学员参赛，记录每个学员的成绩，并计算每个班的平均分
public class Test{
public static void main(String[] args){
int[][] scores = {{78,98,88},{87,99,89},{67,87,89}};
int classLen = scores.length;
for(int i=0;i<classLen;i++){
int sum = 0;
int count = scores[i].length;
for(int j=0;j<count;j++){
sum+=scores[i][j];
}
int avg = sum/count;
System.out.println("第"+(i+1)+"班的平均成绩是："+ avg);
}
}
}3、算法
i、冒泡排序算法
比较相邻的元素，如果第一个比第二个大，就交换他们两个。
对每一队相邻元素做同样的工作，从开始第一对到结尾的最后一对，在这一点，最后的元素应该会是最大的数。
针对所有的元素重复上面的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。
public class Test{
public static void main(String[] args){
int[] nums = {1,45,32,24,26,56,78,23};
//外循环控制轮数
for(int i=0;i<nums.length-1;i++){ //比较轮数等于数列长度-1
for(int j=0;j<nums.length-1-i;j++){
if(nums[j]>nums[j+1]){
nums[j]=nums[j]+nums[j+1];
nums[j+1]= nums[j]-nums[j+1];
nums[j] = nums[j]-nums[j+1];
}
}
}
for(int n: nums){
System.out.println(n)
}
}
}
/**
* 1 45 32 24 26 56 78 23
* 1 32 34 26 45 56 23 78 7次
* 1 32 26 34 45 23 56 6次
* 1 26 32 34 23 45 5次
* 1 26 32 23 34 4次
* 1 26 23 32 3次
* 1 23 26 2次
* 1 23 1次
*/
//交换数据 a = a+b;b=a-b;a=a-b;ii、选择排序算法
每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好的数列的最后，知道全部待排序数据元素排完，选择排序是不稳定的排序方法。
public class Test{
public static void main(String[] args){
int[] nums = {1,45,32,24,26,56,78,23};
int minIndex = 0;// 用于记录每次比较的最小值下标
//外循环控制轮数
for(int i=0;i<nums.length-1;i++){ //比较轮数等于数列长度-1
minIndex = i;// 每轮假设一个最小值下标
for(int j=i+1;j<nums.length;j++){
if(nums[minIndex]>nums[j]){
minIndex=j;
}
}
//判断需要交换的数下标是否为自己
if(minIndex != i){
nums[minIndex] = nums[minIndex] + nums[i];
nums[i] = nums[minIndex]-nums[i];
nums[minIndex]=nums[minIndex]-nums[i];
}
}
for(int n: nums){
System.out.println(n)
}
}
}
/**
* 1 45 32 24 26 56 78 23
* 1 45 32 24 26 56 78 23 7次
* 1 23 32 24 26 56 78 45 6次
* 1 23 24 32 26 56 78 45 5次
* 1 23 24 26 32 56 78 45 4次
* 1 23 24 26 32 56 78 45 3次
* 1 23 24 26 32 45 78 56 2次
* 1 23 24 26 32 56 56 78 1次
*/
iii、直接插入排序算法
从后向前找到合适的位置后插入，每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的字序列的合适位置，知道全部插入排序完为止；
public class Test{
public static void main(String[] args){
int[] nums = {1,45,32,24,26,56,78,23};
int minIndex = 0;// 用于记录每次比较的最小值下标
//外循环控制轮数
for(int i=1;i<nums.length;i++){ //比较轮数等于数列长度
int temp = nums[i];// 记录操作数
int j = 0;
for(int j=i-1;j>=0;j--){
if(nums[j]>nums[temp]){
nums[j+1]=nums[j]
}else{
break;
}
}
//判断需要交换的数下标是否为自己
if(nums[j+1] != temp){
nums[j+1]=temp
}
}
for(int n: nums){
System.out.println(n)
}
}
}
/**
* 1 45 32 24 26 56 78 23
* 第一轮 i=1 1 45 32 24 26 56 78 23
* 1 45 32 24 26 56 78 23
*
* 第二轮 i=2 1 45 45 24 26 56 78 23
* 1 32 45 24 26 56 78 23
*
* 第三轮 i=3 1 32 45 45 26 56 78 23
* 1 32 24 45 26 56 78 23
1 24 32 45 26 56 78 23
*
* 第四轮 i=4 1 24 32 45 45 56 78 23
* 1 24 32 26 45 56 78 23
* 1 24 26 32 45 56 78 23
*
* 第五轮 i=5 1 24 26 32 45 56 78 23
*
* 第六轮 i=6 1 24 26 32 45 56 78 23
*
* 第七轮 i=7 1 24 26 32 45 56 78 78
* 1 24 26 32 45 56 23 78
* 1 24 26 32 45 23 56 78
* 1 24 26 32 23 45 56 78
* 1 24 26 23 32 45 56 78
* 1 24 23 26 32 45 56 78
* 1 23 24 26 32 45 56 78
*/
iv、二分查找算法
二分查找（折半查找）：前提是在已经排好序的数组中，通过将待查找的元素与中间索引值对应的元素进行比较，若大于中间索引值对应的元素，去右半部分查找，否则，去左半部分查找，直到找到位置没找不到返回一个负数。
public class Test{
public static void main(String[] args){
//必须保证数列是有序的
int[] num ={10,20,50,65,88,90}
int index = binarySearch(num,88)
}
public static int binarySearch(int[] num,int key){
int start =0;
int end = num.length-1;
while(start<=end){
int middle =(start+end)/2;
if(num[middle]>key){
end=middle-1;
}else if(num[middle]<key){
start = middle+1;
}else{
return middle;
}
}
return -1;
}
}
v、Arrays类
Arrays工具类：用来操作数组的各种方法
常用方法：
使用二分查找法
Arrays.binarySearch(int[] array,int value);
数组内容转成字符串的形式输出
Arrays.toString(int[] array);
数组排序
Arrays.sort(int[] array);
复制指定的数组
Arrays.copyOf(int[] array,int length);
Arrays.copyOf(int[] array,int from,int to);
System,arraycopy(Object src,int srcPos,Object dest,int desPos,int length)
判断两个数组是否相等
Arrays.equels();
使用指定元素填充数组
Arrays.fill();
public class Test{
public static void main(String[] args){
int[] nums = {1,45,32,24,26,56,78,23};
//二分查找
int index = Array.binarySearch(nums,88);
System.out.println(index);
}
}
4、方法与数组双色球案例
步骤：
用户选择是机选还是手选号码；
接收用户选号（6红，1蓝）；
生成系统号码（6红，1蓝）；
比较系统号码和用户号码，记录个数；
验证是否中奖；
系统号码排序；
公布结果；
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
//定义相关的变量
int[] userRedBall = new int[6];//用户选择的红球号码
int[] sysRedBall = new int[6];//系统生成的红球号码
int userBlueBall = 0;//用户选择的蓝球
int sysBlueBall = 0;//系统生成的蓝球
int redCount = 0;//记录用户选择正确的红球数
int blueCount = 0;//记录用户选择正确的蓝球数
int[] redBall = new int[33];//用于存储1-33的红球号码
//需要随机生成6个在1-33之间不重复的数（算法）
for(int i = 0;i<redBall.length;i++){
redBall[i] = i+1;
}
//游戏开始，系统提示
System.out.println("双色球游戏开始，good luck！");
System.out.println("请问你是要机选还是手选号码（1：机选，2：手选）：");
Scanner input = new Scanner(System.in);
Random r = new Random();
boolean flag = true;
while (flag){
int isAuto = input.nextInt();
switch (isAuto){
case 1:
//机选
computerSelection(redBall,userRedBall);//机选红球
userBlueBall=r.nextInt(16)+1;//机选蓝球
flag=false;
break;
case 2:
//手选
System.out.println("请选择六个红球号码（1-33）：");
for (int i=0;i<userRedBall.length;i++){
userRedBall[i] = input.nextInt();
}
System.out.println("请选择一个蓝球号码（1-16）：");
userBlueBall = input.nextInt();
flag=false;
break;
default:
System.out.println("请请问你是要机选还是手选号码（1：机选，2：手选）：");
break;
}
}
//系统随机生成号码
//红球
computerSelection(redBall,sysRedBall);
//蓝球
sysBlueBall=r.nextInt(16)+1;
//统计结果：
//统计红球
for (int i=0;i<userRedBall.length;i++){
for(int j=0;j<sysRedBall.length;j++){
if(userRedBall[i]==sysRedBall[j]){
int temp = sysRedBall[j];
sysRedBall[j] = sysRedBall[sysRedBall.length-1-redCount];
sysRedBall[sysRedBall.length-1-redCount]=temp;
redCount++;
}
}
}
//统计蓝球
if(userBlueBall==sysBlueBall){
blueCount=1;
}
//验证是否中奖
if (blueCount==0 && redCount<=3){
System.out.println("革命尚未成功，同志还需努力！");
}else if(blueCount==1 && redCount<3){
System.out.println("中了六等奖，5块钱！");
}else if((blueCount==1 && redCount==3)||(blueCount==0 && redCount==4)){
System.out.println("中了五等奖，10块钱！");
}else if((blueCount==1 && redCount==4)||(blueCount==0 && redCount==5)){
System.out.println("中了四等奖，200块钱！");
}else if(blueCount==1 && redCount==5){
System.out.println("中了三等奖，3000块钱！");
}else if(blueCount==0 && redCount==6){
System.out.println("中了二等奖，150W！");
}else if(blueCount==1 && redCount==6){
System.out.println("中了一等奖，500W！");
}else{
System.out.println("系统有误，中奖无效！");
}
//公布系统号码
System.out.println("本期中奖红球号码为：");
sort(sysRedBall);
System.out.println(Arrays.toString(sysRedBall));
System.out.println("本期中奖的蓝球号码为："+sysBlueBall);
//公布用户号码
System.out.println("您选择的红球号码为：");
sort(userRedBall);
System.out.println(Arrays.toString(userRedBall));
System.out.println("您选择的蓝球号码为："+userBlueBall);
System.out.println("买双色球，造福你我他，谢谢！");
}
//冒泡排序
public static void sort(int[] ball){
for(int i=0;i<ball.length-1;i++){
for(int j=0;j<ball.length-1-i;j++){
if(ball[j]>ball[j+1]){
ball[j]=ball[j]+ball[j+1];
ball[j+1]=ball[j]-ball[j+1];
ball[j]=ball[j]-ball[j+1];
}
}
}
}
//用于在指定数列中，随机生成多个不重复的数的算法
public static void computerSelection(int[] redBall,int[] userRedBall){
Random r = new Random();
int index=-1;
for(int i =0;i<userRedBall.length;i++){
index=r.nextInt(redBall.length-i);
userRedBall[i] = redBall[index];
int temp = redBall[index];
redBall[index]=redBall[redBall.length-1-i];
redBall[redBall.length-1-i]=temp;
}
}
}
标签：26,56,JAVA,23,--,nums,int,第四篇,78 来源： https://blog.csdn.net/weixin_45895096/article/details/122653080