编程语言
首页 > 编程语言> > JAVA笔记--编程基础(第四篇)

JAVA笔记--编程基础(第四篇)

作者:互联网

目录

一、方法与数组

1、方法

i、方法的定义

ii、方法的格式

 iii、参数

iv、返回值

v、方法重载overloading method

2、数组

i、数组的定义

ii、定义数组

iii、数组的遍历

iv、数组注意问题

v、示例

3、算法

i、冒泡排序算法

ii、选择排序算法 

iii、直接插入排序算法

iv、二分查找算法 

v、Arrays类

4、方法与数组双色球案例 


一、方法与数组

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