学习JAVA的笔记

最新推荐文章于 2023-06-21 21:55:50 发布
最新推荐文章于 2023-06-21 21:55:50 发布
阅读量210 收藏
点赞数
文章标签： java 学习 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sunxt_T/article/details/127705332
版权

一、方法

1.什么是方法？

什么是方法

方法是程序中最小的执行单元。

实际开发当中，什么时候会用到方法呢？

重复的代码、具有独立功能的代码可以抽取到方法中。

实际开发当中，方法有什么好处？

可以提高代码的复用率；可以提高代码的可维护性；

2.方法的格式

方法的定义：

把一些代码打包在一起，该过程称之为方法定义。

public static 返回值类型 方法名(参数){

    方法体;
    return 返回值;
}

方法的调用：

方法定义后并不能直接调用，而是需要手动调用才能执行，该过程称为方法调用。

方法名();
package Excise;

public class test1{
    public static void main(String []args){
        //调用方法
        playGame();
    }
    //定义一个方法
    public static void playGame(){
        System.out.println("nnn");
        System.out.println("nnn");
        System.out.println("nnn");
    }

}

带参数的方法定义和调用：

package Excise;

public class test1{
    public static void main(String []args){
        //调用方法
        getSum(50,20);
    }
    //定义一个方法
    public static void getSum(int num1,int num2){
        int sum = num1 + num2;
        System.out.println(sum);
    }

}

形参和实参：

形参：全称形式参数，是指方法定义中的参数。（上个例子中的……getSum（int num1，int num2）就是形参）

实参：全称实际参数，方法调用中的参数。（上个例子中的getSum（50，20）的值叫做实参）

！！！方法调用时，形参和实参必须一一对应，否则程序将报错。

带返回值方法的定义和调用：

方法的返回值其实就是方法运行的最终结果。

如果在调用处要根据方法的结果，去编写另一段代码逻辑；为了在调用处拿到方法产生的结果，就需要定义带有返回值的方法。

package Excise;

public class test1{
    public static void main(String[] args) {
        //目标：掌握带返回值方法的定义和调用格式
        //直接调用
        getSum(10,20,30);
        //赋值调用
        int sum = getSum(10,20,30);
        System.out.println(sum);
        //输出调用
        System.out.println(getSum(10,20,30));
        
    }
    public static int getSum(int num1, int num2, int num3){
        int result = num1 + num2 + num3;
        return result;//返回给方法的调用处
    }
}

小结：方法不调用就不执行；方法与方法之间时平级关系，不能互相嵌套；方法的编写顺序和执行顺序无关；方法的返回值类型为void，表示该方法没有返回值，没有返回值的方法可以省略return语句不写。如果要编写return，后面不能跟具体的数据；return下面不能编写代码，因为永远执行不到，属于无效代码。

return关键字：

方法没有返回值：可以省略不写。如果书写，表示结束方法。

方法有返回值：必须要写。表示结束方法和返回结果。

3.方法的重载

在同一个类中，定义了多个同名的方法，这些同名的方法具有同种的功能。

每个方法具有不同的参数类型或参数个数，这些同名的方法，就构成了重载关系。

简单来说：就会在同一个类中，方法名相同，参数不同的方法。与返回值无关

                    参数不同：个数不同，类型不同，顺序不同。（顺序不同可以构成，但不建议使用）

                  Java虚拟机会通过参数的不同来区分同名的方法。

方法重载的练习

package Excise;

public class test1{
    public static void main(String[] args) {
        //调用
        //保证实参和形参一一对应
        //compare((byte) 10,(byte) 20);    强转
        compare(10,20);
    }
    //相同功能的方法名起成一样的名字
    //好处1：定义方法的时候可以不用那么多的单词
    //好处2：调用方法的似乎也不需要那么麻烦。
        public static void compare(byte b1 , byte b2){
            System.out.println(b1==b2);
        }
        public static void compare(short s1,short s2){
            System.out.println(s1==s2);
        }
        public static void compare(int i1,int i2){
            System.out.println(i1==i2);
        }
        public static void compare(long n1,long n2){
            System.out.println(n1==n2);
        }
        }

数组遍历练习：

package Excise;

public class test1{
    public static void main(String[] args) {
        int [] arr = {1,2,3,4,5};
        printArr(arr);

    }
    //定义方法用于数组的遍历
    //1。我要干什么？ ---遍历数组
    //2。需要怎么样才能完成 ---数组
    //3.方法的调用处是否需要继续使用结果？  ---不需要返回值
    public static void printArr(int[] arr){
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length-1){
                System.out.print(arr[i]);
            }else {
                System.out.print(arr[i] + ", ");
            }

        }System.out.println("]");
    }
}

数组最大值：

package Excise;

public class test1{
    public static void main(String[] args) {
       //1.定义数组
        int [] arr = {1,2,3,4,5};
        int max = getMax(arr);
        System.out.println(max);

    }
    //1.我要干什么？ ---求最大值
    //2.我干这件事，需要怎么样完成？ ---数组
    //3.是否返回？ ---返回
    public static int getMax(int [] arr){
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
            max = arr[i];
            }
        }
        return max;
    }

}

判断数据是否存在：定义一个方法判断数组是否存在，将结果返回给调用处。

！！！return和break关键字的区别：

return：其实和循环没有什么关系，跟方法有关系，表示1结束方法，2返回结果。

             如果方法执行到了return，那么整个方法全部结束，里面的循环也会随之结束了。

break：其实和方法没什么关系，结束循环或者swith的。

package Excise;

public class test1{
    public static void main(String[] args) {
       //1.定义数组
        int [] arr = {1,2,3,4,5};
        //2.判断一个数字在数组中是否存在。
       boolean flag  =contains(arr,1);
        System.out.println(flag);
    }
    //1.我要干什么？ --
    //2.需要什么才能完成？---
    //3.调用处是否需要继续使用结果？  --返回true/false
    public static boolean contains(int[] arr, int number){
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == number){
                return true;
            }
        }
        return false;
    }
}

复制数组的练习 

package Excise;

public class test1{
    public static void main(String[] args) {
       //1.定义数组
        int [] arr = {1,2,3,4,5,6,7,8,9};
        //2.调用方法拷贝数据
        int[] copyArr = copyOfRange(arr,3,7);
        //3.遍历copyArr
        for (int i = 0; i < copyArr.length; i++) {
            System.out.println(copyArr[i]);
        }
    }
    //将数组arr中从索引from（包含from）开始，到索引to结束（不包含to）的元素赋值到新数组中
    public static int[] copyOfRange(int[] arr, int from, int to) {
       //1.定义数组
       int []newArr = new int[to - from] ;
       //2.把原始数组arr中的from到to上对应的元素，直接拷贝到newArr中
        //伪造索引的思想：
        int index = 0;
        for (int i = from;i<to;i++){
            newArr[index] = arr[i];
            index++;
        }
        return newArr;
    }
}

4.方法的内存（黑马视频P73）

1.方法调用的基本内存原理

和数据类型里面的压栈差不多

2.方法传递基本数据类型的内存原理

数据值是存储在自己的空间中   特点：赋值给其他变量，也是赋的真实的值。

3.方法传递引用数据类型的内存原理

数据值存储在其他空间中，自己空间存储的是地址值。例如：数组。    特点：赋值给其他变量，赋的地址值。

new出来的都是引用数据类型    存储的时地址值

5.综合练习

5.1卖飞机票

需求：机票价格按照淡季、旺季、头等舱和经济舱收费，输入机票原价、月份和头等舱、经济舱。按照如下规则计算机票价格：旺季（5-10月）头等舱9折，经济舱8.5折，淡季（11月到来年4月）头等舱7折，经济舱6.5折。

package Excise;

import java.util.Scanner;

public class test1{
    public static void main(String[] args) {
       /*机票价格按照淡季、旺季、头等舱和经济舱收费，输入机票原价、月份和头等舱、经济舱
       按照如下规则计算机票价格：旺季（5-10月）头等舱9折，经济舱8.5折，淡季（11月到来年4月）头等舱7折，经济舱6.5折
        */
        //分析：
        //1.键盘录入 机票原价，月份，头等舱，经济舱。
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入机票的原价");
        int ticket = sc.nextInt();
        System.out.println("请输入当前月份");
        int month = sc.nextInt();
        System.out.println("请输入当前购买的舱位：0头等舱，1经济舱");
        int seat = sc.nextInt();
        //2.先判断月份是旺季还是淡季
        if(month >= 5 && month <=10 ){
            //旺季
            //3.判断经济舱还是头等舱
            if (seat == 0){
                //头等舱
                ticket = (int)(ticket * 0.9);
            }else if (seat == 1){
                //经济舱
                ticket =(int)(ticket * 0.85);
            }else {
                System.out.println("您输入的舱位不存在");
            }

        }else if ((month >= 1 && month <= 4) || (month >= 11 && month <= 12)){
            //淡季
            //3.判断经济舱还是头等舱
            if (seat == 0){
                //头等舱
                ticket = (int)(ticket * 0.7);
            }else if (seat == 1){
                //经济舱
                ticket =(int)(ticket * 0.65);
            }else {
                System.out.println("您输入的舱位不存在");
            }

        }else{
            //录入不合法
            System.out.println("您录入的月份不合法");
        }
        //4.计算出对应的价格
        System.out.println("您机票的价格为：" + ticket);
    }
}

优化代码后：

！！！！！！快捷键抽取方法：ctrl + alt + M

package Excise;

import java.util.Scanner;

public class test1{
    public static void main(String[] args) {
       /*机票价格按照淡季、旺季、头等舱和经济舱收费，输入机票原价、月份和头等舱、经济舱
       按照如下规则计算机票价格：旺季（5-10月）头等舱9折，经济舱8.5折，淡季（11月到来年4月）头等舱7折，经济舱6.5折
        */
        //分析：
        //1.键盘录入 机票原价，月份，头等舱，经济舱。
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入机票的原价");
        int ticket = sc.nextInt();
        System.out.println("请输入当前月份");
        int month = sc.nextInt();
        System.out.println("请输入当前购买的舱位：0头等舱，1经济舱");
        int seat = sc.nextInt();
        //2.先判断月份是旺季还是淡季
        if(month >= 5 && month <=10 ){
            //旺季
            ticket = getPrice(ticket,seat,0.9,0.85);

        }else if ((month >= 1 && month <= 4) || (month >= 11 && month <= 12)){
            //淡季
            ticket = getPrice(ticket,seat,0.7,0.65);
        }else{
            //录入不合法
            System.out.println("您录入的月份不合法");
        }
        //4.计算出对应的价格
        System.out.println("您机票的价格为：" + ticket);
    }

    //1.我要干嘛？ ---根据舱位和折扣来计算最终的票价
    //2.我干这件事，需要什么才能去完成？  ---原价，舱位，头等舱的折扣，经济舱的折扣
    //3.方法调用处是否需要继续使用这个结果？ ---需要
    public static int getPrice(int ticket,int seat,double v0,double v1){
        if (seat == 0){
            //头等舱
            ticket = (int)(ticket * v0);
        }else if (seat == 1){
            //经济舱
            ticket =(int)(ticket * v1);
        }else {
            System.out.println("您输入的舱位不存在");
        }return ticket;
    }
}

5.2找质数

需求：判断101~200之间有多少个质数，并打印所有质数。

package Excise;

public class test2 {
    public static void main(String[] args) {
        //判断101~200之间有多少个质数，并打印所有质数。
        //思路一：2~99
        //定义变量i，赋值100
        //判断i是否为质数
        int count = 0;
        //外循环，遍历101-200这个范围内的数字
        for (int i = 101; i <= 200; i++) {
            //i表示循环中的每一个数字
            //继续判断i是否是一个质数
            boolean flag = true;
            //判断当前数字是否为一个质数
            for (int j = 2; j < i; j++){
                //j表示2-99之间的每一个数字
                if (i % j ==0){
                    flag = false;
                    break;//跳出单层循环，内循环
                }
            }
            if (flag){
//                System.out.println("当前数字为" +i+ "是质数");
                count++;
            }
        }
        System.out.println("一共有" + count +"个质数");
    }

}

5.3开发验证码

需求：定义方法实现随机产生一个5位的验证码（格式：长度为5；前四位是大写字母或者小写字母；最后一位是数字；

package Excise;

import java.util.Random;

public class test3 {
    /*需求：定义方法实现随机产生一个5位的验证码
    （格式：长度为5；前四位是大写字母或者小写字母；最后一位是数字；*/
    public static void main(String[] args){
        //分析：
        //随机A~Z a~z
        //方法：在以后如果我们要在一堆没有什么规律的数据中随机抽取
        //可以先把这些数据放到数组当中
        //再随机抽一个索引

        //1.把大写字母和小写的字母都放到数组当中
        char[] chs = new char[52];
        for (int i = 0; i < chs.length; i++) {
            //ASCII码表
            if (i <= 25){
                //添加小写字母
                chs[i] = (char)(97 + i);
            }
            else {
                //添加大写字母
                //A ---65
                chs[i] = (char)(65 + i - 26);
            }
        }
        //定义一个字符串类型的变量，用来记录最终的结果
        String result = "";

        //2.随机抽取数组中的索引 4次
        Random r = new Random();
        for (int i = 0; i < 4; i++) {
            int randomIndex = r.nextInt(chs.length);
            //利用随机索引，获取对应的元素
//            System.out.print(chs[randomIndex]);
            result = result + chs[randomIndex];
        }
//        System.out.println(result);

        //3.随机抽取一个数字0-9
        int number = r.nextInt(10);
        result =  result + number ;
        System.out.println(result);

    }
}

5.4数组元素的复制

需求：把一个数组中的元素复制到另一个新数组中去

package Excise;

public class test4 {
    //需求：把一个数组中的元素复制到另一个新数组中去
    public static void main(String[] args) {
        //分析
        //1.定义一个老数组并存储一些元素
        int[] arr = {1,2,3,4,5};
        //2.定义一个新数组的长度跟老数组的一致
        int[] newArr = new int[arr.length];
        //3.遍历老数组可以得到老数组中的每一个元素，依次存入到新数组中
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
            //i是老数组中的索引----新数组中的每一个索引
            //arr[i] 表示老数组中的元素
            newArr[i] = arr[i];
        }
        //4.新数组中已经存满元素了
        for (int i = 0; i < newArr.length; i++) {
            System.out.print(newArr[i]);
        }
    }
}

5.5评委打分

需求：六个评委；评分0-100之间的整数范围；最后得分：去掉最高分，去掉最低分后四个评委的平均分，请计算选手得分

package Excise;

import java.util.Scanner;

public class test5 {
    public static void main(String[] args) {
        //六个评委；
        // 评分0-100之间的整数范围；
        // 最后得分：去掉最高分，去掉最低分后四个评委的平均分，
        // 请计算选手得分

        //分析
        //1.定义一个数组，用来存储六个评委的评分（0-100）
        int[] scoreArr = getScores();
        for (int i = 0; i < scoreArr.length; i++) {
            System.out.println(scoreArr[i]);
        }

        //2.求出数组中的最大值
        int max = getMax(scoreArr);

        //3.求出数组中的最小值
        int min = getMin(scoreArr);

        //4.求出数组中六个分数的总和
        int sum  = getSum(scoreArr);

        //5.总和-最大值-最小值 / 4
        int avg = (sum - max - min)/(scoreArr.length-2);
        System.out.println("选手的最终得分为："+avg);

    }
    //求数组的最大值
    public static int getMax(int[] scoreArr){
        int max = scoreArr[0];
        for (int i = 0;i < scoreArr.length;i++){
            if (scoreArr[i] > max){
                max = scoreArr[i];
            }
        }return max;
    }
    //求数组的最小值 shift+f6可以批量修改
    public static int getMin(int[] scoreArr){
        int min = scoreArr[0];
        for (int i = 0;i < scoreArr.length;i++){
            if (scoreArr[i] < min){
                min = scoreArr[i];
            }
        }return min;
    }
    //求六个数的和
    public static int getSum(int[] scoreArr){
        int sum = 0;
        for (int i = 0; i < scoreArr.length; i++) {
            sum = sum + scoreArr[i];
        }return sum;
    }


    //1.我要干啥？ 定义一个数组，用来存储6位评委的打分0-100
    //2.我需要干什么？ 都不需要
    //3.干完了这些事情，结果是否需要返回？ 必须返回
    public  static  int[] getScores(){
        //定义数组
        int[] scores = new int[6];
        //键盘录入分数
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < scores.length;) {
            System.out.println("请输入评委的打分：");
            int score = sc.nextInt();
            if (score >=0 && score<100){
            scores[i] = score;
            i++;
            }else {
                System.out.println("当前成绩不合法，请重新输入");
            }
        }
        return scores;
         }
}

5.6数字加密

需求：采用加密的方式进行传输；规则为：先得到每位数，然后每位数都加上5，再对10求余数，最后将所有数字反转，得到一串新数。

package Excise;

public class test6 {
    public static void main(String[] args) {
        /*需求：采用加密的方式进行传输；
        规则为：先得到每位数，
        然后每位数都加上5，
        再对10求余数，
        最后将所有数字反转，得到一串新数。
         */
        //分析：
        //1.把整数里面的每一位数放到数组中

        int[] arr = {1,9,8,3};
        //2.加密
        //每一个数字加上5
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] + 5;
//            System.out.print(arr[i] + " ");
        }
        //对10取余
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] % 10;
//            System.out.println(arr[i]);
        }
        //将所有的数字都进行反转
        for (int i = 0,j = arr.length-1 ; i < j; i++,j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        for(int i = 0; i<arr.length;i++){

//            System.out.println(arr[i]);
        }
        //3.把数组里面的每一个数字进行拼接，变成加密之后的结果
        int number = 0;
        for (int i = 0; i < arr.length; i++) {
            number = number * 10 + arr[i];
        }System.out.println(number);
    }
}

package Excise;

public class test7 {
    public static void main(String[] args) {
        //需求：
        //把整数上的每一位都添加到数组当中
        //反向推导

        //1.计算出数组的长度
        int number = 12345;
        int temp = number;
        //定义一个变量进行统计
        int count = 0;
        while (number != 0){
            number = number / 10;
            count++;
        }
        System.out.println(count);
        //2.定义数组
        //动态初始化
        int arr[] = new int[count];

        //3.把整数上的每一位都添加到数组当中
        int index = arr.length - 1;
        while(temp !=0 ){
            int ge = temp % 10;
            temp = temp /10;
            arr[index] = ge;
            index--;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }

    }
}

5.7数字解密

package Excise;

public class test7 {
    public static void main(String[] args) {
        //需求：
        //把整数上的每一位都添加到数组当中
        //反向推导

        //1.计算出数组的长度
        int number = 12345;
        int temp = number;
        //定义一个变量进行统计
        int count = 0;
        while (number != 0){
            number = number / 10;
            count++;
        }
        System.out.println(count);
        //2.定义数组
        //动态初始化
        int arr[] = new int[count];

        //3.把整数上的每一位都添加到数组当中
        int index = arr.length - 1;
        while(temp !=0 ){
            int ge = temp % 10;
            temp = temp /10;
            arr[index] = ge;
            index--;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }

    }
}

5.8抢红包

package Excise;

import java.util.Random;

public class test8 {
    public static void main(String[] args) {
        //抢红包
        //分析：
        //1.定义奖池
        int[] arr = {2, 588, 888, 1000, 10000};
        //2.定义新数组，用于存储新的数组
        int[] newArr = new int[arr.length];
        //3.抽奖   有五个奖项
        Random r = new Random();
        for (int i = 0; i < 5; ) {
            int randomIndex = r.nextInt(arr.length);
            //获取奖项
            int prize = arr[randomIndex];
            //判断当前奖项是否存在，如果存在就重新抽取，如果不存在，就表示为有效奖项
            if (!contains(newArr,prize)){
                newArr[i] = prize;
                i++;//添加完毕之后，移动索引
            }
        }
        //4.遍历newArr
        for (int i = 0; i < newArr.length; i++) {
            System.out.println(newArr[i]);
        }
    }

    //判断prize在数组当中是否存在  存在：true 不存在：false
    public static boolean contains(int[] arr,int prize){
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == prize){
                return true;
            }
        }return false;
    }
}

5.9模拟双色球【拓展】

package Excise;

import java.util.Random;
import java.util.Scanner;

public class test9 {
    public static void main(String[] args) {
        //1.生成中奖号码
        int[] arr = createNumber();
//        for (int i = 0; i < arr.length; i++) {
//            System.out.print(arr[i] + " ");
//        }
        System.out.println("============================");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");

        }
        System.out.println("双色球");
        System.out.println("=============================");

        //2.用户输入号码
        int[] userInputArr = userInputNumber();
//        for (int i = 0; i < userInputArr.length; i++) {
//            System.out.print(userInputArr[i] + " ");
//        }

        //3.判断中奖情况
        //红球 蓝球
        int redCount = 0;
        int blueCount = 0;
        for (int i = 0; i < userInputArr.length - 1; i++) {
            int redNumber = userInputArr[i];
            for (int i1 = 0; i1 < arr.length; i1++) {
                if (redNumber == arr[i1]){
                    redCount++;
                    //如果找到了，那么后面的数字就没有必要继续比较了
                    //跳出内循环，继续判断下一个红球号码是否中奖
                    break;
                }
            }
        }
        //判断蓝球
        int blueNumber = userInputArr[userInputArr.length-1];
        if (blueNumber == arr[arr.length-1]){
            blueCount++;
        }
        //根据红球个数以及蓝球的个数来判断中奖情况
        if(redCount == 6 && blueCount ==1){
            System.out.println("恭喜你，中奖1000万");
        }else if (redCount == 6 && blueCount==0){
            System.out.println("恭喜你，中奖500万");
        }else if (redCount == 5 && blueCount==1){
            System.out.println("恭喜你，中奖3000");
        }else if ((redCount == 5 && blueCount==0) ||(redCount == 4 && blueCount==1)){
            System.out.println("恭喜你，中奖200");
        }else if ((redCount == 4 && blueCount==0) ||(redCount == 3 && blueCount==1)){
            System.out.println("恭喜你，中奖10");
        }else if ((redCount == 2 && blueCount==1) ||(redCount == 1 && blueCount==1)||(redCount == 0 && blueCount==1)){
            System.out.println("恭喜你，中奖5");
        }else {
            System.out.println("谢谢参与");
        }
    }
    public static int[] userInputNumber(){
        //1.创建数组用于添加用户购买的号码
        //6个红球1~33 1个蓝球1~16 数组长度为7
        int[] arr = new int[7];
        //2.利用键盘让用户输入
        Scanner sc = new Scanner(System.in);
        //输入红球的
        for (int i = 0; i < 6; ) {
            System.out.println("请输入第" + (i+1) + "个红球号码");
            int redNumber = sc.nextInt();
            //范围在1~33 不能重复
            if (redNumber >= 1 && redNumber <= 33){
                boolean flag = contains(arr,redNumber);
                if (!flag){
                    arr[i] = redNumber;
                    i++;
                }else {
                    //重复
                    System.out.println("当前号码已经存在，请重新输入！");
                }
            }else {
                System.out.println("当前输入号码不符合范围！");
            }
        }
        //输入蓝球号码
        System.out.println("请输入蓝球号码：");
        while (true) {
            int blueNumber = sc.nextInt();
            if (blueNumber >= 1 && blueNumber <= 16){
                arr[arr.length-1] = blueNumber;
                break;
            }else {
                System.out.println("当前蓝球号码超出范围");
            }
        }
        return arr;
    }
    public static int[] createNumber(){
        //1.创建数组用于添加中奖号码
        //6个红球1~33 1个蓝球1~16 数组长度为7
        int[] arr = new int[7];
        //2.随机生成号码并且添加到数组当中去
        //红球：不可重复 0 1 2 3 4 5
        //蓝球：可以跟红球号码重复 6

        //生成红球号码
        Random r = new Random();
        for (int i = 0; i < 6; ) {
            int redNumber = r.nextInt(33)+1;
            boolean flag = contains(arr,redNumber);
            if (!flag){
                //将数字存入数组
                arr[i] = redNumber;
                i++;
            }
        }
        //生成蓝球号码
        int blueNumber = r.nextInt(16)+1;
        arr[6] = blueNumber;
        return arr;
    }
    public static boolean contains(int[] arr, int number){
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == number){
                return true;
            }
        }
        return false;
    }
}

Sunxt_T
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
深入理解Java特性
小S的博客
11-04 378
对Java基础编程那些特性的深入理解
编写工具类：ArrayList 提供工具类方法printArr，用于返回整数数组的内容 返回的字符串格式如：[1,2,3,4](只考虑浮点型数组，且为一维数组)//定义测试类ArrayTest
Z_Yule的博客
02-22 162
编写工具类：ArrayList //提供工具类方法printArr，用于返回整数数组的内容 //返回的字符串格式如：[1,2,3,4](只考虑浮点型数组，且为一维数组) //定义测试类ArrayTest，调用该工具类的工具方法，并返回结果
C和指针 第七章 函数递归与迭代
weixin_30650039的博客
08-17 81
C语言通过运行时堆栈支持递归函数的实现，递归函数时直接或者间接调用自身的函数，经常有人拿斐波那契实现当做递归的实现，然后这样做效率并不高。 n < 1; Fib(1) =1 n = 2; Fib(2) = 1 n > 2; Fib(n) = Fib(n - 1) + Fib(n - 2); 由于每个递归调用都会触发另外两个递归调用，而这两个调用还将继续触...
指针学习之函数
zjjaibc的博客
09-16 210
1.（形参与实参）：，b在自定义函数里生命周期结束，不会再传给实参。故在main的ab值不会交换。 解决方法：用指针作为参数传递。 2.函数返回值也可返回指针。（但不能返回数组） 3.函数传递数组既然已经变成指针，可写成void printArr(int arr[])即可。 main中的arr占20个字节，printArr中arr占4个字节（一个地址）（传的数组的首地址） 那么我们也可以写作void printArr(int *arr); ...
C++实现 快速排序
weixin_59043381的博客
06-21 8435
函数定义了两个指针 left 和 right，分别初始化为 strat 和 end。接下来，左右指针开始分别从左侧和右侧遍历数组arr，找到需要交换的元素并将其交换位置。left++;right--;第一个while循环，left指针一直往右移动，直到找到大于pivot与arr[right]应该交换的元素。第二个while循环，right指针一直往左移动，直到找到小于pivot与arr[left]应该交换的元素。
博主的自主学习java笔记
04-24
博主的自主学习java笔记
java超强笔记
12-03
"Java超强笔记"正是一份专为新手准备的学习资源，它全面涵盖了从Java环境的搭建到软件设计的各种概念，旨在提供一个易读且系统的学习路径。 首先，笔记可能会从Java的起源和发展开始介绍，让你了解这门语言的历史...
学习Java笔记（重点）内容丰富.pdf
最新发布
10-06
学习Java笔记（重点）内容丰富
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
java学习笔记.zip
11-16
java学习笔记java学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记...
C语言—指针
zhudong10的博客
10-24 422
计算机程序运行时，在内存中存在大量的存储空间，就像一栋酒店大楼可以让旅客用来住宿。不同的存储空间用地址来标示，恰若酒店大楼各个房间的门牌号。C语言中用指针来表示地址。通过指针来操作变量，具有很过优点： 1 在被调函数中通过指针可以改变主调函数中的变量； 2 在被调函数中可以有多个返回值； 指针变量的修饰符为 * ，通过*可以定义一维指针和二维指针。一维指针的格式：类型说明符 * 变量名[数组
Java初级-复习题
aidrv.com
04-04 4156
复习题： 基础测试题 1、下面的语句哪行在编译时没有警告和编译错误 a)float f=1.3; b)char c=”a”; c)byte b=257; d)boolean b=null;e)int i=10;2、下面的代码编译后会出现什么问题 public class MyClass{ public static void main(String arguments[])
调用方法打印数组
m0_60643800的博客
03-17 656
利用方法实现数组的的输入打印
java 实现快速排序
m0_46306264的博客
05-30 1万+
1.介绍 快速排序是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一 部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序 过程可以递归进行，以此达到整个数据变成有序序列。 2.切分原理 切分原理： 把一个数组切分成两个子数组的基本思想： 1.找一个基准值，用两个指针分别指向数组的头部和尾部； 2.先从尾部向头部开始搜索一个比基准值小或等于的元素，搜索到即停止，并记录指针的位置； 3.再从头部向尾..
把一个数组中的元素复制到另一个新数组中去 #java
小库里的学习记录
06-24 957
把一个数组中的元素复制到另一个新数组中去 #java
C++结构体嵌套循环赋值打印
TianKelly的博客
08-15 1716
1. 学生结构体：姓名，分数 2. 老师结构体：姓名，学生数组（长度为5） 3. 功能：创建老师结构体数组，每个老师单元有一个学生数组，每个学生数组包括姓名和分数，函数1实现对老师和其学生信息的赋值，函数2实现对所有信息的打印 #include<iostream> #include<string> #include<ctime> using namespace std; struct Student { string name; int score; };
java中 for (int i : arr) 这个语句的意思
热门推荐
jingtian678的博客
11-02 1万+
int[] arr = new int{1,2,3,4}; for{int i ; i { ......... }
CoreJava笔记.pdf
05-24
"CoreJava笔记.pdf，内容涵盖Java发展史、Java优势、运行机制以及环境搭建等基础知识" 在Java的学习过程中，首先要了解的是它的历史。Java起源于1995年，由Sun公司发布，最初的设计目标是简洁且跨平台。随着版本的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Sunxt_T

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值