java的第六天

最新推荐文章于 2023-02-26 13:25:00 发布
最新推荐文章于 2023-02-26 13:25:00 发布
阅读量680 收藏 1
点赞数
分类专栏： java笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40280217/article/details/95865678
版权

复习回顾

1、方法的定义格式？
    public static 数据类型 方法名(参数列表){
        方法体;
        return 数据值/变量;
    }

2、return关键字的作用？
	结束方法的调用, 并且返回方法的计算结果
	
3、有返回值方法的调用方式？无返回值方法调用方式？
	无返回值方法调用方式 
		定义:public static void sum(){}
		调用:sum();

	有返回值方法的调用方式
        public static int sum(int a, int b ){
            return a+b;
        }
		调用:
			直接调用 sum(10,20);  //丢失返回值 (一般情况下不用)
			输出调用 System.out.println( sum(10,20)  );
			赋值调用 int sum = sum(20,30);

4、方法参数为基本数据类型时的参数传递方式？
	值传递,形参的改变不影响实参

5、方法参数为引用数据类型时的参数传递方式？
	地址传递, 形参的改变直接影响实参.
	
6、方法重载的条件？
	同一个类中, 方法名相同, 参数列表不同(参数类型或者个数不同)

7、方法定义的两个明确?
	明确返回值(有无返回值,无返回值时void)
	明确参数(参数类型和个数)

1 Debug模式

什么是Debug模式？

debug是供程序员使用的程序调试工具，可以用于查看程序的执行流程，也可以用于追踪程序执行过程。

更多的时候是因为程序出问题了，所以使用Debug工具进行调试，找到程序出错的原因和位置。

1.1 Debug常用按钮介绍

[外链图片转存失败(img-mNNegnfJ-1563073290154)(assets/1560786161974.png)]

1.2 Debug工具使用

  • 如何加断点

    选择要设置断点的代码行，在行号的区域后面单击鼠标左键即可。

    注意：不要在注释上打断点，因为注释是不会被程序执行的。

    [外链图片转存失败(img-QibY6J9I-1563073290155)(assets/01.png)]

  • 如何运行加了断点的程序

    在代码区域右键Debug执行

    [外链图片转存失败(img-iRjERa5E-1563073290156)(assets/02.png)]

  • 看哪里

    看Debugger窗口

    [外链图片转存失败(img-GsaY3TIO-1563073290158)(assets/1560784809626.png)]

  • 点哪里

    Step Into：点击Step Into，或者按F7，表示步入代码，遇到当前行代码是方法调用时，直接进入方法内。

    Step Over：点击Step Over，或者按F8，表示步过代码，代码一行一行走，遇到方法调用，直接一行过。

    [外链图片转存失败(img-0dpd67ov-1563073290162)(assets/1560786793935.png)]

  • 如何删除断点

    选择要删除的断点，单击鼠标左键即可

    [外链图片转存失败(img-rm65qiEM-1563073290163)(assets/1560787206141.png)]

    如果是多个断点，可以每一个再点击一次。也可以一次性全部删除

    [外链图片转存失败(img-yfNv1kLU-1563073290164)(assets/1560787558942.png)]

查看方法文档注释：Ctrl + Q

2 基础练习

2.1 减肥计划if版本

需求：

​ 输入星期数，显示今天的减肥活动
​ 周一：跑步
​ 周二：游泳
​ 周三：慢走
​ 周四：动感单车
​ 周五：拳击
​ 周六：爬山
​ 周日：好好吃一顿

代码实现：

/*
    思路：
        1:键盘录入一个星期数，用一个变量接收
        2:对星期数进行判断，这里用 if 语句实现
        3:在对应的语句控制中输出对应的减肥活动
 */
public class Test01 {
    public static void main(String[] args) {
        //键盘录入一个星期数，用一个变量接收
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个星期数：");
        int week = sc.nextInt();

        //对星期数进行判断，这里用 if 语句实现
        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("好好吃一顿");
        }else {
            System.out.println("你输入的星期数有误");
        }
    }
}
2.2 减肥计划switch版本

需求：

​ 输入星期数，显示今天的减肥活动
​ 周一：跑步
​ 周二：游泳
​ 周三：慢走
​ 周四：动感单车
​ 周五：拳击
​ 周六：爬山
​ 周日：好好吃一顿

代码实现：

/*
    思路：
        1:键盘录入一个星期数，用一个变量接收
        2:对星期数进行判断，这里用 switch 语句实现
        3:在对应的语句控制中输出对应的减肥活动

    导包：
        1:手动导包  import java.util.Scanner;
        2:快捷键导包 Alt+Enter
        3:自动导包
 */
public class Test02 {
    public static void main(String[] args) {
        //键盘录入一个星期数，用一个变量接收
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个星期数：");
        int week = sc.nextInt();

        //对星期数进行判断，这里用 switch 语句实现
        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:
                System.out.println("你输入的星期数有误");
        }
    }
}
2.3 逢七打印

需求：

​ 打印1~100之间数字包含7或能被7整除的数字

步骤：

1、遍历1~100之间的每一个整数

for(int i=1; i<=100;++)

2、获取每个数的个位和十位

ge = i%10

shi=i/10%10

3、判断并打印包含7或者能被7整除的数

代码实现：

/*
    思路：
        1:数据在1-100之间，用for循环实现数据的获取
        2:根据规则，用if语句实现数据的判断：要么个位是7，要么十位是7，要么能够被7整除
        3:在控制台输出满足规则的数据
 */
public class Test03 {
    
    public static void main(String[] args) {
        
        //数据在1-100之间，用for循环实现数据的获取
        for(int i=1; i<=100; i++) {
            //个位
            int ge = i%10;
            //十位
            int shi = i/10%10;
            
            //根据规则，用if语句实现数据的判断：要么个位是7，要么十位是7，要么能够被7整除
            if(ge==7 || shi==7 || i%7==0) {
                //在控制台输出满足规则的数据
                System.out.println(i);
            }
        }
    }
}
2.4 数组元素求和

需求：

​ 有这样的一个数组，元素是{68,27,95,88,171,996,51,210}，求出该数组中满足要求的元素和。
​ 要求是：求和的元素个位和十位都不能是7，并且只能是偶数。

步骤:

1. 遍历数组
2. 获取每个元素的个位和十位 ,都不能为7 ,并且该元素只能是偶数
3. 定义求和变量,对满足条件的元素累加求和

代码实现：

/*
   思路：
        1:静态初始化数组
        2:定义一个求和变量，初始值是0
        3:遍历数组，获取到数组中的每一个元素
        4:判断该元素是否满足条件，如果满足条件就累加
        5:输出求和变量的值
 */
public class Test04 {
    public static void main(String[] args) {
        //静态初始化数组
        int[] arr = {68, 27, 95, 88, 171, 996, 51, 210};

        //定义一个求和变量，初始值是0
        int sum = 0;

        //遍历数组，获取到数组中的每一个元素
        for(int i=0; i<arr.length; i++) {
            
            //获取每个元素的个位
            int ge = arr[i]%10;
            int shi = arr[i]/10%10;
            
            //判断该元素是否满足条件
            if(ge!=7 && shi!=7 && arr[i]%2==0) {
                 System.out.println(arr[i]);
                //如果满足条件就累加
                sum += arr[i];
            }
        }

        //输出求和变量的值
        System.out.println("sum:" + sum);
    }
}
2.5 判断两个数组是否相同

需求：

​ 判断两个数组内容是否相同，如果两个数组长度一样，对应位置上的元素值也一样，则两个数组相同。

​ 比如：

​ {10,20,30}和{10,20,30}是两个相同的数组。

​ {10,20,30}和{20,10,30}不是两个相同是数组。

代码实现：

/*
    思路：
        1:定义两个数组，分别使用静态初始化完成数组元素的初始化
        2:定义一个方法，用于比较两个数组的内容是否相同
        3:比较两个数组的内容是否相同，按照下面的步骤实现就可以了
            首先比较数组长度，如果长度不相同，数组内容肯定不相同，返回false
            其次遍历，比较两个数组中的每一个元素，只要有元素不相同，返回false
            最后循环遍历结束后，返回true
        4:调用方法，用变量接收
        5:输出结果
 */
public class Test05 {
    public static void main(String[] args) {
        //分别静态初始化两个数组
        int[] arr = {11, 22, 33, 44, 55};
        //int[] arr2 = {11, 22, 33, 44, 55};
        int[] arr2 = {11, 22, 33, 44, 5};

        //调用方法，传递要判断的两个数组，并接收方法返回的结果
        boolean flag = compare(arr,arr2);
        
        //输出结果
        System.out.println(flag);
    }

    //定义一个方法，用于比较两个数组的内容是否相同
    /*
        两个明确：
            返回值类型：boolean
            参数：int[] arr, int[] arr2
     */
    public static boolean compare(int[] arr, int[] arr2) {
        
        // 1. 首先比较数组长度，如果长度不相同，直接返回false。
        if(arr.length != arr2.length) {
            return false;
        }

        // 2. 其次遍历，比较两个数组中的每一个元素，只要有元素不相同，直接返回false。
        for(int i=0; i<arr.length; i++) {
            if(arr[i] != arr2[i]) {
                return false;
            }
        }

        // 3. 程序如果能走到这里，说明两个数组长度一样，对应位置的元素也都相同，返回true
        return true;
    }
}
2.6 查找数组中元素位置

需求：

​ 已知一个数组 {19, 28, 37, 46, 50}

键盘录入一个数据，查找该数据在数组中的索引，并在控制台输出该索引值。

​ 如果数组没有该元素，则返回-1。

代码实现：

/*
    思路：
        1. 静态初始化一个数组
        2. 键盘录入要查找的数据，用一个变量接收
        3. 遍历数组，获取到数组中的每一个元素
        4. 拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，直接返回该元素索引，方法结束。
        5. 如果遍历结束，方法还没返回，说明数组中没有该元素，直接返回-1即可。
 */
public class Test06 {
    public static void main(String[] args) {
        // 1. 静态初始化一个数组
        int[] arr = {19, 28, 37, 46, 50};

        // 2. 键盘录入要查找的数据，用一个变量接收
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要查找的数据：");
        int number = sc.nextInt();

        // 3. 调用方法
        int index = getIndex(arr, number);

        // 4. 输出索引变量
        System.out.println("index: " + index);
    }

   
    /*
        需求：
        	 查找指定的数据在数组中的索引
        	 
        两个明确：
            返回值类型：int
            参数：int[] arr, int number
     */
    public static int getIndex(int[] arr, int number) {
		//int index = -1;
        // 1. 遍历数组，获取到数组中的每一个元素
        for(int i=0; i<arr.length; i++) {
            // 2. 参数传入的数number和数组每一个元素分别比较
            if(number == arr[i]) {
                // 3. 如果找到了相等的元素，直接返回索引
                return i;
                //index = i;
                //break;
            }
        }

        // 4. 如果方法能走到这里，说明数组中没有该元素，直接返回-1即可。
        return -1;
    }
}
2.7 数组元素反转

需求：

​ 将数组中的元素颠倒顺序，例如原始数组为1,2,3,4,5，反转后的数组为5,4,3,2,1。

​ 已知一个数组 {19, 28, 37, 46, 50}， 用程序实现数组反转，并打印反转后的数组元素。

​ 反转后数组应变为 {50, 46, 37, 28, 19}。

实现思路：

实现反转，需要将数组第一个元素和最后一个元素互换，第二个元素和倒数第二个交换，以此类推。

  • 定义两个变量，保存数组的最小索引和最大索引。
  • 两个索引上的元素交换位置。
  • 最小索引++，最大索引–，再次交换位置。
  • 最小索引超过了最大索引，数组反转操作结束。

如何实现两个数互换？

​ 实现两个数互换，可以采用临时变量。例如：

int a = 10;
int b = 20;

//交换a和b的值
int temp = a; //定义临时变量存a的值
a = b ; //将b的值赋给a
b = temp;  //将temp的值赋给b

原理图解：

[外链图片转存失败(img-ixnNdK03-1563073290166)(assets/1560809305691.png)]

代码实现：


public class Test07 {
    public static void main(String[] args) {
        //静态初始化数组
        int[] arr = {19, 28, 37, 46, 50};

        //调用反转的方法，方法执行完，数组就完成了反转。
        reverse(arr);

        //遍历数组
        printArray(arr);
    }

    /*
    	定义方法，实现数组元素反转
        两个明确：
            返回值类型：void
            参数：int[] arr
     */
    public static void reverse(int[] arr) {
        
        // 初始化变量记录小索引: start = 0
        // 初始化变量记录大索引: end = arr.length ‐ 1
        // 循环执行条件: start < end 才需要交换位置
        
        for (int start = 0, end = arr.length - 1; start < end; start++, end--) {
            //变量交换
            int temp=arr[start];
            arr[start]=arr[end];
            arr[end]=temp;
        }
    }

    /*
    	定义方法，格式化打印数组
    	数组{1，2，3，4}，格式化结果：[1, 2, 3, 4]
        两个明确：
            返回值类型：void
            参数：int[] arr
     */
    
    //格式化打印
    // String str = Arrays.toString(数组);
    // System.out.println(str);
    
    public static void printArray(int[] arr) {
        
        if(arr==null || arr.length==0){
            System.out.print("[]");
            return;
        }
        
        System.out.print("["+arr[0]);
        for (int i = 1; i < arr.length; i++) {
            System.out.print(", " + arr[i]);
        }
        System.out.println("]");
    }
}
2.8 评委打分

需求：

​ 在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
​ 选手的最后得分为：去掉一个最高分和一个最低分后的4个评委平均分 (不考虑小数部分)。

步骤:

​ 1 录入6个成绩,循环放到数组中

​ 2 定义方法求数组最大值并返回

​ 3 定义方法求数组最小值 并返回

​ 4 定义方法对数组累加求和并返回结果

​ 5 求去掉一个最高分和一个最低分后的平均值

代码实现：

/*
    步骤：
        1. 动态初始化长度为6的int数组，用于存储6个评委的打分
        2. 键盘循环录入6个评委的分数
        3. 定义方法获取数组最大值max。（打分的最高分）
        4. 定义方法获取数组最小值min。（打分的最低分）
        5. 定义方法对数组中所有元素累加求和sum。（所有打分的和）
        6. 计算平均分规则：(sum - max - min)/(arr.length-2)
 */
public class Test08 {
    public static void main(String[] args) {
        // 1. 动态初始化长度为6的int数组，用于存储6个评委的打分
        int[] arr = new int[6];

        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        // 2. 循环录入6个评委的分数
        for(int i=0; i<arr.length; i++) {
            System.out.println("请输入第" + (i + 1) + "个评委的打分：");
            arr[i] = sc.nextInt();
        }

        //使用Arrays工具类对数组进行格式化打印
         System.out.println( Arrays.toString(arr) );

        // 3. 调用方法获取最大分数
        int max = getMax(arr);

        // 4. 调用方法获取最小分数
        int min = getMin(arr);

        // 5. 调用方法获取评分总和
        int 4 = getSum(arr);

        // 6. 计算平均分规则：(sum - max - min)/4
        int avg = (sum - max - min) / (arr.length - 2);

        //输出平均分
        System.out.println("选手的最终得分是：" + avg);

    }

    /*
    	定义方法对数组中所有元素累加求和。
        两个明确：
            返回值类型：int
            参数：int[] arr
     */
    public static int getSum(int[] arr) {
        int sum = 0;

        for(int x=0; x<arr.length; x++) {
            sum += arr[x];
        }

        return sum;
    }

    /*
        定义方法获取数组最小值。
        两个明确：
            返回值类型：int
            参数：int[] arr
     */
    public static int getMin(int[] arr) {
        //假设第一个元素为最小值
        int min = arr[0];
		//遍历比较每一个元素
        for(int i=1; i<arr.length; i++) {
            if(arr[i] < min) {
                min = arr[i];
            }
        }
		//返回最小值
        return min;
    }

    /*
        定义方法获取数组最大值。
        两个明确：
            返回值类型：int
            参数：int[] arr
     */
    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;
    }
2.9 不死神兔

需求：

​ 有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，
​ 假如兔子都不死，问第二十个月的兔子对数为多少？

代码实现：

/*
 * 需求：
 * 	有一对兔子，从出生后第3月起每个月生一对兔子，小兔子从第3个月开始每个月又生一对兔子，
 * 	假如兔子都不死，第20个月的兔子对数为多少？
 * 
 * 分析：
 * 		第1个月： 1对
 * 		第2个月： 1对
 * 		第3个月： 2对
 * 		第4个月： 3对
 * 		第5个月： 5对
 * 规律：
 *		第3月开始，每月兔子对数等于前两个月的兔子对数相加
 * 实现：
 * 		使用数组索引0~19表示月份1~20，元素值代表兔子数量
 * 
 * 		第1个月： arr[0] = 1
 * 		第2个月： arr[1] = 1
 * 		第3个月： arr[2] = arr[1] + arr[0] =1+1=2
 * 		第4个月： arr[3] = arr[2] + arr[1] =2+1=3
 * 		第5个月： arr[4] = arr[3] + arr[2] =3+2=5
 * 		第6个月： arr[5] = arr[4] + arr[3] =5+3=8 		
 * 		...
 * 		第20个月：arr[19] = arr[18] + arr[17]
 */
public class Test09 {
	public static void main(String[] args) {
		//定义数组，长度20
		int[] arr = new int[20];
		//第一月兔子数
		arr[0] = 1;
		//第2月兔子数
		arr[1] = 1;
		//第3月开始，每月兔子对数等于前两个月的兔子对数相加
		for(int i=2; i<arr.length; i++){
			arr[i] = arr[i-1] + arr[i-2];
		}
		
		//循环结束后，arr[19]为第20个月兔子总对数
		System.out.println("20个月后兔子总对数：" + arr[19]);
	}
}
2.10 百钱买百鸡

需求：

​ 我国古代数学家张丘建在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。
​ 百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？

翻译：

​ 一只公鸡5块钱，一只母鸡3块钱，3只小鸡1块钱，拿100元，如何搭配能买到100只鸡？

​

思路：

百鸡条件：
    假设公鸡为 int x 只 ,一只公鸡5块钱, 范围在 0~20只
    假设母鸡为 int y 只 ,一只母鸡3块钱， 范围在 0~33只 
    小鸡应该是 int z = 100 - x - y; 并且 z%3==0
		

百钱条件:
	5*x + 3*y + z/3 = 100; 

穷举算法

代码实现：

/*
    思路：
        1. for循环遍历能买到公鸡的所有可能值。
        	for(int x=0; x<=20; x++)
        2. for循环遍历能买到母鸡的所有可能值。
        	for(int y=0; y<=33; y++)
        3. 根据公鸡和母鸡，得到小鸡的数量 int z = 100-x-y;
        4. 如果同时能满足 z%3==0 和 5*x + 3*y + z/3 ==100 ，则x,y,z的搭配就是百钱刚好买百鸡的搭配
 */
public class Test10 {
    public static void main(String[] args) {
        
        // 1. for循环遍历能买到公鸡的所有可能值。
        for(int x=0; x<=20; x++) {
            // 2. for循环遍历能买到母鸡的所有可能值。
            for(int y=0; y<=33; y++) {
                // 3. 根据公鸡和母鸡，得到小鸡的数量 int z = 100-x-y;
                int z = 100 - x - y;

                // 4. 如果同时满足 z%3==0 和 5*x + 3*y + z/3 ==100 ，
                //    则x,y,z的搭配就是百钱刚好买百鸡的搭配
                if(z%3==0 && 5*x+3*y+z/3==100) {
                    System.out.println(x + "," + y + "," + z);
                }
            }
        }
    }
}

（+）统计某个元素在数组中出现的次数。

（+）将数组中第一个元素和最大值元素互换位置。

（+）求 1-500 之内能同时被 3 和 5 整除的所有数及个数并 5 个一行打印。

课后作业

1. 请定义一个方法，该方法可以实现对int类型的数组进行遍历，在控制台打印所有元素。
	实现方法后，请在主方法中调用方法，查看结果。
	例如，数组为{11, 22, 33}，打印格式为：[11, 22, 33]
	
    
    

2. 请定义一个方法，该方法可以实现求两个整数之中的较大值，并将较大值返回。
    请以重载的方式再定义一个方法，实现求三个整数之中的最大值，并将最大值返回。
    在主方法中分别调用这两个方法，测试结果。
    
    

3. 请定义一个方法，实现交换整数数组中两个索引上的元素值。并调用方法，查看运行效果。
	例如，数组为{11, 22, 33, 44, 55, 66}，交换索引1和索引5位置上的元素，
	结果为{11, 66, 33, 44, 55, 22}



4. 通过键盘录入两个整数n和m。n代表行数，m代表列数，范围都是1-10 。
	定义一个方法，方法的功能是打印n行m列的@符号。执行效果如下：
	请输入行数：
    4
    请输入列数：
    5
    @@@@@
    @@@@@
    @@@@@
    @@@@@
    
    

5. 在主方法中通过键盘录入三个整数。定义一个方法，方法接收三个整数变量，在方法中从大到小依次打印三个变量。
    执行效果如下：
        请输入第一个整数：10
        请输入第二个整数：30
        请输入第三个整数：20
        从大到小的顺序是： 30 20 10 
        
        

6. 数字是有绝对值的，负数的绝对值是它本身取反，非负数的绝对值是它本身。
	请定义一个方法，方法能够得到小数类型数字的绝对值并返回。请定义方法并测试。

，在控制台打印所有元素。
实现方法后，请在主方法中调用方法，查看结果。
例如，数组为{11, 22, 33}，打印格式为：[11, 22, 33]


```java
2. 请定义一个方法，该方法可以实现求两个整数之中的较大值，并将较大值返回。
    请以重载的方式再定义一个方法，实现求三个整数之中的最大值，并将最大值返回。
    在主方法中分别调用这两个方法，测试结果。
    
    

3. 请定义一个方法，实现交换整数数组中两个索引上的元素值。并调用方法，查看运行效果。
	例如，数组为{11, 22, 33, 44, 55, 66}，交换索引1和索引5位置上的元素，
	结果为{11, 66, 33, 44, 55, 22}



4. 通过键盘录入两个整数n和m。n代表行数，m代表列数，范围都是1-10 。
	定义一个方法，方法的功能是打印n行m列的@符号。执行效果如下：
	请输入行数：
    4
    请输入列数：
    5
    @@@@@
    @@@@@
    @@@@@
    @@@@@
    
    

5. 在主方法中通过键盘录入三个整数。定义一个方法，方法接收三个整数变量，在方法中从大到小依次打印三个变量。
    执行效果如下：
        请输入第一个整数：10
        请输入第二个整数：30
        请输入第三个整数：20
        从大到小的顺序是： 30 20 10 
        
        

6. 数字是有绝对值的，负数的绝对值是它本身取反，非负数的绝对值是它本身。
	请定义一个方法，方法能够得到小数类型数字的绝对值并返回。请定义方法并测试。
码农(小宇哥)
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
请定义一个方法，该方法可以实现对int类型的数组进行遍历，在控制台打印所有元素。实现方法后，请在主方法中调用方法，查看结果。例如，数组为{11, 22, 33}，打印格式为：[11, 22, 33]
weixin_35756130的博客
12-18 111
定义方法： public void printIntArray(int[] array) { for (int i : array) { System.out.print(i + " "); } System.out.println(); } 在主方法中调用方法： int[] array = {11, 22, 33}; printIntArray(array); 输出结果：...
【2021-MOOC-浙江大学-陈越、何钦铭-数据结构】图
JavaAlenboy
03-11 1186
文章目录1.什么是图？2.抽象数据类型定义3.邻接矩阵4.邻接表5.图的遍历5.1 深度优先搜索 DFS5.2 广度优先搜索 BFS6.连通图7.最短路径问题7.1 无权图的单源最短路径算法7.2 有权图的单源最短路径算法7.3 多源最短路算法8.最小生成树问题9.拓扑排序 1.什么是图？ 2.抽象数据类型定义 3.邻接矩阵 思考题 1、有个顶点的无向完全图有多少条边？ 2、给定有向图的邻接矩阵如下： 顶点2（编号从0开始）的出度和入度分别是： 解析：出度看行，顶点2在第三行，第三行都
C语言数据结构-第七章、 图单元测试-电大同步进度
aiqq136的博客
05-11 1619
1单选(5分) 在一个图中，所有顶点的度之和是所有边数的 ( )倍。 A.2 B.3 C.1/2 D.1 2单选(5分) 在一个有向图中，所有顶点的入度之和等于所有顶点的出度之和的( )倍。 A.1 B.2 C.4 D.1/2 3单选(5分) 一个有n个顶点的无向图最多有( )条边。 A.n*(n-1) B.2*n ...
以邻接矩阵为存储结构，采用深度优先遍历或广度优先遍历，输出图的所有顶点的值（C语言）
Zhangguohao666的博客
12-06 1万+
题目： 以邻接矩阵为存储结构，采用深度优先遍历，输出图的所有顶点的值 测试数据 输入： 6 6 A B C D E F A B A C B E C E A D D F 输出：BACEDF #include&amp;amp;lt;iostream&amp;amp;gt; using namespace std; #define MAXNUM 100 char visited1[MAXNUM]; typedef st...
Linux shell中2>&1的含义解释 （全网最全，看完就懂）
热门推荐
业精于勤，荒于嬉；行成于思，毁于随
09-11 17万+
A.首先了解下1和2在Linux中代表什么 名称 代码 操作符 Java中表示 Linux 下文件描述符（Debian 为例) 标准输入(stdin) 0 &amp;amp;lt; 或 &amp;amp;lt;&amp;amp;lt; System.in /dev/stdin -&amp;amp;gt; /proc/self/fd/0 -&amp;amp;gt; /dev/pts/0 标准输出(stdout
21天学通JAVA第六天
05-21
21天学通Java是Java语言的入门教程，由浅入深，循序渐进地讲授如何使用Java语言进行程序开发
学习java第六天练习代码Day6.rar
02-10
学习Java第六天的练习代码，包含嵌套循环，课堂案例，函数的定义调用，实参和形参，单个函数和多个函数的使用
Java第6章完整.pptx
11-13
Java第6章完整.pptx
清华大学张思民Java第6章.ppt
11-13
清华大学张思民Java第6章.ppt
java第六章实验.docx
07-10
java第六章实验.docx
java数组遍历方式
Victor998的博客
02-26 242
数组元素下标的合法区间：[0,length-1] 我们可以通过下标来遍历数组中的元素，遍历时可以读取元素的值或者修改元素的值。for -each增强for循环在遍历数组过程中不能修改数组中某些元素的值。for-each 仅适用于遍历 不涉及有关索引(下标) 的操作。使用循环初始化和遍历数组。for -each循环。
矢量分析 关于∇一些矢量恒等式速记法
weixin_43890342的博客
04-13 1万+
20200413 最近在学电磁场与电磁波,那几个有∇\nabla∇的矢量恒等式真的够呛啊… 在B站上看到的矢量分析视频, 该大神UP的理解简直到位… ∇\nabla∇看成是有矢量性和微分性的东东 ∇⋅(∇×A)=0\nabla\cdot(\nabla\times\mathbf{A})=0∇⋅(∇×A)=0 ∇\nabla∇和自己垂直的∇\nabla∇(即∇×A\nabla\times\mathbf...
day1_leetcode1
乙壳虫的博客
02-26 2400
Leetcode第一题 1. 题目：           2. 我的第一思路是利用两次循环，将列表中的数两两相加，如果出现和为target，则返回。注意，由题目的意思，默认结果是只 有一对符合题意的，所以直接可以return的。所以下面是我的第一个解法： class Solution: def twoSum(self, nums, target):    ...
Java基础代码练习-大合集(2)-Array method String
道北無彦祖的博客
07-15 1250
分析并完成以下需求: 1.控制台提示并键盘录入，总共6个评委给1名选手打分，分数为[1-100]之间的int类型整数 2.对录入分数进行判断，超出范围给出提示，重新录入 4.将分数存储到合适的数组中 3.去除一个最高分、一个最低分，统计该选手的平均成绩，并在控制台打印 public static void main(String[] args) { //定义求和变量 int sum = 0; //动态初始数组，长度为6，...
泰文排版规则
山不在高，有金则名
08-09 5000
2009-06-03 11:46 1．字母编码 这里只介绍泰文的Unicode编码。Unicode编码为双字节，前面为高字节，后面为低字节，这里都用十六进制表示。如0E00表示一个空格，0E为高字节，00为低字节。泰文编码和字母的对照关系如下： 编码段： 0E00-0E16，0E17-0E2D，0E2E-0E30 泰文字符：กขฃคฅฆงจฉชซฌญฎฏฐฑฒณดตถทธนบปผฝพฟภม
冯诺依曼结构和现代计算机结构模型
weixin_39656575的博客
03-25 7011
控制器取出指令来执行
全藏字【藏文字】的生成算法设计
qq_41139540的博客
04-17 5342
藏文字符是拼音性文字，现代藏字由30个辅音字母和4个元音符号（简称为元音）拼写组合而成，既可以前后书写，还可以上下叠加，构成二维的平面文字。现代藏字均以一个称为“基字”的辅音字母为核心，其前后添加和上下叠加，组成一个完整的字符结构。
Java 实训5 编写一个窗体应用程序模拟交通信号灯
mcp3128
10-28 4269
题目描述： 在窗口的北面添加一个下拉列表，该下拉列表有“红灯”，“绿灯”，“黄灯”三个选项。在窗口的中心添加一个画布，当用户在下拉列表选择某项后，画布上绘制相应的信号灯。 参考结果： 代码： import java.awt.*; import java.awt.event.*; import javax.swing.*; import java.awt.Graphics; pu
vuex技术点
weixin_59127121的博客
09-28 610
mutations方法在actions中或组件中使用，使用$store.commit('mutations方法',payload)来触发。在组件中使用this.$store.dispatch('actions方法', payload)。原则1：只要使用Vuex一定要拆分store，拆分store后在根store上不要再使用state/mutations/actions。第二步：使用封装过的axios实例进行调接口。- 第三步：在组件中使用this.$store/四个map方法来使用store或走数据流程。
java第六章第七章
最新发布
11-28
很抱歉，您提供的引用内容中没有第六章的相关信息。以下是第七章的内容介绍： 第七章介绍了Java中的常用类，包括字符串、日期、时间、数字格式化、正则表达式等。具体内容如下： 1. 字符串类 Java中的字符串是不可...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值