Java程序员从笨鸟到菜鸟之（四）练习

最新推荐文章于 2021-03-16 02:39:40 发布

wzj_110

最新推荐文章于 2021-03-16 02:39:40 发布

阅读量443

点赞数

分类专栏： Java 文章标签： java 冒泡快速

本文链接：https://blog.csdn.net/wzj_110/article/details/78171359

版权

Java 专栏收录该内容

67 篇文章 1 订阅

订阅专栏

练习1：

/*
 * 题目：考试成绩已经保存在数组scores中，依次为 89,23,64,91,119,52,73,-23

   要求：

        1)根据通过自定义方法来找出其中前三名，将数组成绩作为参数传入

        2)判断成绩的有效性(0-100),如果成绩无效，则忽略此成绩          
              
   思路1： 利用的是选择排序（从大到小），比较有效成绩，每比较一次输出一个数据。  
        1）静态初始化保存数组scores
        2）设计一个方法[用选择排序进行从大到小的排序，用if判断成绩的有效性]
        3）在 main函数中调用方法  
   步骤： 
        1）用if判断成绩是否有效，若无效则对下一个数据进行判断;
        2）若有效则与后面所有的有效数据作比较（选择排序），得到最大的数据即为第1名
        3）以此类推找到第2,3...
        补充延伸：找到对应异常的索引，方便核对人员对录入的成绩进行核对，修改异常
          
     思路2：删除异常数字后，重新进行排序(用到相应的核心类库)                  
 */

public class Test01 {
	public static void main(String[] args) {
		int[] scores = new int[] { 89, 23, 64, 91, 119, 52, 73, -23 };// 成绩
		System.out.print("前三名的成绩：");
		sortMaxThree(scores);
	}

	// 方法
	public static void sortMaxThree(int[] arry1) {
		int time = 0;
		int temp = 0;
		final int MIN_NUM = 0;// 有效成绩上区间
		final int MAX_NUM = 100;// 有效成绩下区间
		final int TIME = 3;// 前三名
		for (int i = 0; i < (arry1.length - 1) && time < TIME; i++) {
			if (arry1[i] >= MIN_NUM && arry1[i] <= MAX_NUM) {
				for (int j = i + 1; j < arry1.length; j++) {
					if (arry1[j] >= MIN_NUM && arry1[j] <= MAX_NUM) {
						// 选择排序比较大小
						if (arry1[i] < arry1[j]) {
							temp = arry1[j];
							arry1[j] = arry1[i];
							arry1[i] = temp;
						} else {
							continue;
						}
					}
				}
				System.out.print(arry1[i] + " ");
				time++;
			}
		}
	}
}

输出结果：

练习2：

/* 考察知识点：数组引用

 * 2.题目： 
 *     用数组来实现， 定义并初始化一个（1--100）保存100个数的数组，
 *     从第一个元素开始，依次数(1,2,3 循环往复),每次数到3的元素淘汰掉.
 *     当到达数组末尾的时候再从头开始，直到最后剩余一个元素.
 *     写出算法，并输出最后保留的元素所在的最初的位置.
 *    //思路：一个数组保存元素，一个数组保存对应的索引
 *    功能扩展：每次循环后保存的对应元素 
 * 优化：定义方法：提高代码复用性,扩展了功能
 * 说明：end表示上一次循环到末尾时数到的数字所对应的数字。
 * 例如：末尾数到1时，end=1；数到2时，末尾为2；数到3时，end=0；
 *      程序主要分三个部分讨论end=1,2,0时的情况
 *    
 */
public class Test02 {
	public static void main(String[] args) {
		// 初始化数组中的元素
		int[] arry = new int[100];
		for (int i = 0; i < arry.length; i++) {
			arry[i] = i + 1;
		}
		// 初始化数组对应的索引
		int[] arry0 = new int[100];
		for (int i = 0; i < arry0.length; i++) {
			arry0[i] = i;
		}
		int index = circleThree(arry, arry0);//调用方法
		System.out.println("最后保留的元素所在的最初的位置:" + index);
		System.out.println("奶奶个熊的，终于做出来了，爽");// 抒发心情
	}

	public static int circleThree(int[] arry1, int[] arry4) {
		int[] arry2;// 保存数组对应的索引
		int[] arry3;// 保存部分元素删除后的数组元素
		int end = 0;// 初始时（未进行）
		int time=0;
		for (int i = 1;; i++) {
			// System.out.print("每次循环剩余元素索引:");
			//[]里面表示的是上一次循环末尾的数字与本次循环数组元素的个数与下一次循环元素个数的关系
			arry2 = new int[arry1.length - (arry1.length + end) / 3];// 此刻数组大小
			arry3 = new int[arry1.length - (arry1.length + end) / 3];
			//其实不要这个也能得到最终的结果
			if (end==0&&arry2.length==2){
				end=2;
				continue;
			}
			time++;//到数组尾部为一次循环
			System.out.print("第"+time+"次循环剩余元素:");
			//下一次循环开始时（从头开始前），上一次最后一个数字数到的数
			if (end == 0) {
				for (int j = 0, k = -1; j < arry1.length; j++) {
					if ((j + 1) % 3 != 0) {// 首先删第三个元素
						k++;
						arry2[k] = arry1[j];// 保存元素
						arry3[k] = arry4[j];// 保存索引
						System.out.print(arry2[k] + " ");// 输出每次循环剩余元素
						// System.out.print(arry3[k] + " ");//输出每次循环剩余索引
					}
				}
				end = (arry1.length + end) % 3;// 下一次余数
			} else if (end == 1) {
				for (int j = 0, k = -1; j < arry1.length; j++) {
					if ((j + 1) % 3 != 2) {// 首先删第二个元素
						k++;
						arry2[k] = arry1[j];// 保存元素
						arry3[k] = arry4[j];// 保存索引
						System.out.print(arry2[k] + " ");// 输出每次循环剩余元素
						// System.out.print(arry3[k] + " ");//输出每次循环剩余索引
					}
				}
				end = (arry1.length + end) % 3;// 下一次最后一个数字数到的数
			} else {
				for (int j = 0, k = -1; j < arry1.length; j++) {
					if ((j + 1) % 3 != 1) {// 首先删第一个元素
						k++;
						arry2[k] = arry1[j];// 保存元素
						arry3[k] = arry4[j];// 保存索引
						System.out.print(arry2[k] + " ");// 输出每次循环剩余元素
						// System.out.print(arry3[k] + " ");//输出每次循环剩余索引
					}
				}
				end = (arry1.length + end) % 3;// 下一次最后一个数字数到的数
			}
			arry1 = arry2;// 这个很重要(涉及到数组)
			arry4 = arry3;// 新添加的(类似上面的)
			System.out.println();
			System.out.println("下一次循环剩余的元素个数:" + arry1.length);
			if (arry3.length == 1) {
				// System.out.println("循环了"+i+"次");//循环了几次,一次循环为元素到末尾
				return arry3[0];// 原来的想法是最后一个元素时输出
			}
		}
	}
}

输出结果：

练习3：

输出结果：

练习4：

/*
 *  题目：
 * 
 *    判断101-200之间有多少个素数，并输出所有素数。
 * 
 * 考察的知识点：
 *    要了解素数（质数）定义
 *    for循环嵌套，break，continue的用法，if条件判断 
 *    思路：
 *    （1）笨办法：
 *        1）：对每一个数值（num）进行判断：由素数的特点，用当前数值（num）对[2,num-1]
 *            区间的整数(遍历)求余，在遍历的过程中，如果余数为0,则不是素数，跳出循环，
 *            对下一个数值进行判断；否则待遍历的数加1,继续进行判断，
 *            如果遍历完余数均不为0则为素数，跳出循环，判断下一个数据。
 *            (ps:优化：除以[1,num/2]即可)
 */
public class Test04 {
	public static void main(String[] args) {
		int time = 0;     // 记录素数个数
		int min_Num = 101;//元素下区间
		final int MAX_NUM = 200;//元素上区间
		System.out.println("101-200之间的素数:");
		// 两层for循环(循环嵌套)
		for (int i = min_Num; i < MAX_NUM; i++) {
			for (int j = 2; j <= i / 2; j++) {
				if (i % j == 0) {
					break;
				} else {
					if (j < i/2) {
						continue;
					} else {
						System.out.print(i + " ");
						time++;
					}
				}
			}
		}
	   System.out.println();
       System.out.print("素数个数："+time);
	}
}
知识点：
 *    要了解素数（质数）定义
 *    for循环嵌套，break，continue的用法，if条件判断 
 *    思路：
 *    （1）笨办法：
 *        1）：对每一个数值（num）进行判断：由素数的特点，用当前数值（num）对[2,num-1]
 *            区间的整数(遍历)求余，在遍历的过程中，如果余数为0,则不是素数，跳出循环，
 *            对下一个数值进行判断；否则待遍历的数加1,继续进行判断，
 *            如果遍历完余数均不为0则为素数，跳出循环，判断下一个数据。
 *            (ps:优化：除以[1,num/2]即可)
 */
public class Test04 {
	public static void main(String[] args) {
		int time = 0;     // 记录素数个数
		int min_Num = 101;//元素下区间
		final int MAX_NUM = 200;//元素上区间
		System.out.println("101-200之间的素数:");
		// 两层for循环(循环嵌套)
		for (int i = min_Num; i < MAX_NUM; i++) {
			for (int j = 2; j <= i / 2; j++) {
				if (i % j == 0) {
					break;
				} else {
					if (j < i/2) {
						continue;
					} else {
						System.out.print(i + " ");
						time++;
					}
				}
			}
		}
	   System.out.println();
       System.out.print("素数个数："+time);
	}
}

输出结果：

练习5：

/*
 * 3. 用数组来实现对于一个整形数组， 分别通过冒泡排序和快速排序，
 *    实现对于任意一个数组进行由小到大的排列。
 */

public class Test03 {
	public static void main(String[] args) {

		int[] arry = new int[] { 45, 23, 63, 1, 4, 7, 8, 9, 12 };
		// 特定的写法
		System.out.println("排序之前：");
		for (int element : arry) {
			System.out.print(element + " ");
		}
		/*
		// 冒泡排序调用方法
		bubbleSort(arry);
		System.out.println("\n冒泡排序： ");
		for (int i = 0; i < arry.length; i++) {
			System.out.print(arry[i] + " ");

		}
		*/
		// 快速排序调用方法
		quickSort(arry, 0, arry.length - 1);
		System.out.println("\n快速排序： ");
		for (int i = 0; i < arry.length; i++) {
			System.out.print(arry[i] + " ");
		}
	}

	// 冒泡排序(从小到大)
	/*
	 * 每次都是比较相邻的两个数，如果后面的数比前面的数大，则交换这两个数的位置。 一直比较下去直到最后两个数比较完毕后，最小的数就在最后一个了。
	 * 就如同是一个气泡，一步一步往后“翻滚”，直到最后一位。 所以这个排序的方法有一个很好听的名字“冒泡排序”。 总结：
	 * 如果有n个数进行排序，只需将n-1个数归位，也就是说要进行n-1趟操作。
	 * 而“每一趟”都需要从第1位开始进行相邻两个数的比较，将较小的一个数放在后面， 比较完毕后向后挪一位继续比较下面两个相邻数的大小，重复此步骤，
	 * 直到最后一个尚未归位的数，已经归位的数则无需再进行比较 （已经归位的数你还比较个啥，浪费表情）。
	 */

	public static void bubbleSort(int[] arry2) {
		for (int j = 0; j < arry2.length - 1; j++) {
			for (int i = 0; i < arry2.length - 1 - j; i++) {
				if (arry2[i] > arry2[i + 1]) {
					int temp = 0;
					temp = arry2[i];
					arry2[i] = arry2[i + 1];
					arry2[i + 1] = temp;
				}
			}
		}
	}

	/*
	 * 
	 * 思想:1.在待排序的元素任取一个元素作为基准
         * (通常选第一个元素，但最的选择方法是从待排序元素中随机选取一个作为基准)，称为基准元素；
                2.将待排序的元素进行分区，比基准元素大的元素放在它的右边，比其小的放在它的左边；
                3.对左右两个分区重复以上步骤直到所有元素都是有序的。
       
       
       主要方法步骤】如下：

                   将两个指针i，j分别指向表的起始和最后的位置。
                   
       反复操作以下两步：

              （1）j逐渐减小，并逐次比较j指向的元素和目标元素的大小，若p(j)<T则交换位置。
              
              （2）i逐渐增大，并逐次比较i指向的元素和目标元素的大小，若p(i)>T则交换位置。
                        直到i，j指向同一个值，循环结束。
	 * 
	 */
	// 快速排序
	public static void quickSort(int arr[],int _left,int _right){
        int left = _left;
        int right = _right;
        int temp = 0;
        if(left <= right){     //待排序的元素至少有两个的情况
            temp = arr[left];  //待排序的第一个元素作为基准元素
            while(left != right){   //从左右两边交替扫描，直到left = right
                while(right > left && arr[right] >= temp)  
                     right --;        //从右往左扫描，找到第一个比基准元素小的元素
                  arr[left] = arr[right];  //找到这种元素arr[right]后与arr[left]交换
                while(left < right && arr[left] <= temp)
                     left ++;         //从左往右扫描，找到第一个比基准元素大的元素
                  arr[right] = arr[left];  //找到这种元素arr[left]后，与arr[right]交换
            }
            arr[right] = temp;    //基准元素归位
            quickSort(arr,_left,left-1);  //对基准元素左边的元素进行递归排序
            quickSort(arr, right+1,_right);  //对基准元素右边的进行递归排序
        }        
    }
}
1.在待排序的元素任取一个元素作为基准
         * (通常选第一个元素，但最的选择方法是从待排序元素中随机选取一个作为基准)，称为基准元素；
                2.将待排序的元素进行分区，比基准元素大的元素放在它的右边，比其小的放在它的左边；
                3.对左右两个分区重复以上步骤直到所有元素都是有序的。
       
       
       主要方法步骤】如下：

                   将两个指针i，j分别指向表的起始和最后的位置。
                   
       反复操作以下两步：

              （1）j逐渐减小，并逐次比较j指向的元素和目标元素的大小，若p(j)<T则交换位置。
              
              （2）i逐渐增大，并逐次比较i指向的元素和目标元素的大小，若p(i)>T则交换位置。
                        直到i，j指向同一个值，循环结束。
	 * 
	 */
	// 快速排序
	public static void quickSort(int arr[],int _left,int _right){
        int left = _left;
        int right = _right;
        int temp = 0;
        if(left <= right){     //待排序的元素至少有两个的情况
            temp = arr[left];  //待排序的第一个元素作为基准元素
            while(left != right){   //从左右两边交替扫描，直到left = right
                while(right > left && arr[right] >= temp)  
                     right --;        //从右往左扫描，找到第一个比基准元素小的元素
                  arr[left] = arr[right];  //找到这种元素arr[right]后与arr[left]交换
                while(left < right && arr[left] <= temp)
                     left ++;         //从左往右扫描，找到第一个比基准元素大的元素
                  arr[right] = arr[left];  //找到这种元素arr[left]后，与arr[right]交换
            }
            arr[right] = temp;    //基准元素归位
            quickSort(arr,_left,left-1);  //对基准元素左边的元素进行递归排序
            quickSort(arr, right+1,_right);  //对基准元素右边的进行递归排序
        }        
    }
}

练习5.5

/*
 * 题目：
 *   输入一行字符(是不是字符串？)，分别统计出其中英文字母、空格、数字和其它字符的个数。
 *   
 *   思路：定义一个数组，保存字符，对各个字符的区间要有一个清晰的理解
 *   
 *   步骤：静态初始化字符，定义四个变量保存对应字符个数
 *   
 *   考察的知识点：
 *      主要：条件判断，逻辑运算符，对应字符的ASCII码
 */
public class Test05 {
	public static void main(String[] args) {
		char[] character = new char[] { 'q', ' ', '/', '4', '5', '$', '1', '!', 'A', 'a', 'Z', '5', 'h', 'K', '_', ' ',
				'M','8','*',']',' ','~' };
		int charNum = 0;
		int charAlphabet = 0;
		int charBlank = 0;
		int charOther=0;
		for (int i = 0; i < character.length; i++) {
			// 字母
			if (character[i] == 32) {
				charBlank++;
				continue;
			} else if (character[i] >= 48 && character[i] <= 57) {
				charNum++;
				continue;
			} else if ((character[i] >= 65 && character[i] <= 90)||(character[i] >= 97 && character[i] <= 122)) {
				charAlphabet++;
				continue;
			}else{
				charOther++;
				continue;
			}
		}
		System.out.println("字符总数:"+character.length);//验证结果是否正确
		System.out.println("英文字母个数："+charAlphabet);
		System.out.println("空格个数："+charBlank);
		System.out.println("数字个数："+charNum);
		System.out.println("其他字符个数："+charOther);
		
		
	}
}

输出结果：

练习6：

import java.util.Scanner;//引入类
/*
 *   就理解成保证公平，防止财富两极分化
 * 6.题目：企业发放的奖金根据利润提成。利润(I)低于或等于10万元时，奖金可提10%；
 *   利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可提成7.5%；
 *   20万到40万之间时，高于20万元的部分，可提成5%；
     40万到60万之间时高于40万元的部分，可提成3%；
     60万到100万之间时，高于60万元的部分，可提成1.5%；
              高于100万元时，超过100万元的部分按1%提成，
            从键盘输入当月利润，求应发放奖金总数？
 * 
 * 步骤：初步判断用if条件判断
 */

public class Test06 {
	public static void main(String[] args) {
		// 键盘读入一个数据
		Scanner sc = new Scanner(System.in);
		System.out.print("当月利润： ");
		//double profit = sc.nextInt(); //输入的是int
		double profit = sc.nextDouble();//输入为double
		double bonus = 0;// 保存奖金数
		// 应该是在原有的基础上继续累加奖金数,奖金分六档
		// if else一旦满足其中一个，下一个不再执行(不能用)
                // 输入1000万时，奖金为102.94999999999999，
		// 可能就是浮点数在计算机中不是精确表示的
		if (profit >= 100) {
			bonus = (profit - 100) * 0.01;
			profit = 100;
		}
		if (profit >= 60) {
			bonus += (profit - 60) * 0.015;
			profit = 60;
		}
		if (profit >= 40) {
			bonus += (profit - 40) * 0.03;
			profit = 40;
		}
		if (profit >= 20) {
			bonus += (profit - 20) * 0.05;
			profit = 20;
		}
		if (profit >= 10) {
			bonus += (profit - 10) * 0.075;
			profit = 10;
		}
		if (profit >= 0) {
			bonus += profit * 0.1;
			System.out.println("当月奖金数: " + bonus + "万");
		}
		if (profit < 0) {
			System.out.println("输入异常");
		}
	}
}

输出结果：

练习7：

import java.util.Scanner;
/*
 * 题目：分别定义用户类，订单类，产品类，其中订单类至少要具有下订单的行为(入参为一个产品名称)，
              产品类中至少有一个成员变量为产品名称，至少有一个方法用来获取产品的名称。
              用户类中持有一个产品类型的成员变量。
              用户类中持有一个订单类型的成员变量。         
   功能：
  在我们的用户类中定义main函数，当执行的时候，构造一个用户类的对象，
  并且通过手段可以拿到产品成员变量中的产品名称，并且调用成员变量订单的对象，进行下单。
  最后输出下单成功。
  
  整个流程 ：用户：
           1）属性：产品类型成员变量，订单类型成员变量
           //尚未涉及到颜色，价格，销量，地域，快递，是否保价，付款方式类型等的选择

 *  思路：用户和订单是关联关系，用户要使用商品中的方法和属性，使用继承
 *  对于不使用的方法可以（private）私有化
 *
 *
 *
 */
public class User extends Product {
	public static void main(String[] args) {
		// 成员变量
		String productStyle;// 产品类型
		String orderStyle; //  订单类型
		User user = new User();// 构造一个用户类的对象
		System.out.println("用户开始选择商品 ");
		System.out.println("--------------");
		// 并且通过手段可以拿到产品成员变量中的产品名称
		// 根据进入的链接得到对应产品的名字，设计只有三个链接
		// 链接可由用户选择，所以(可以)用键盘录入,用户进入对应链接选择商品
		Scanner sc=new Scanner(System.in);
		System.out.print("进入网页，选择对应商品的链接入口:");
		int entrance=sc.nextInt();
		System.out.println("--------------");
		productStyle = user.getProductName(entrance);
		System.out.print("选择的商品为: ");
		System.out.println(productStyle);
		System.out.println("--------------");
		System.out.print("下单情况:");
		/*异常处理机制(给用户一个提示)
		  * 
		  * 
		  * 
		  */
		if(productStyle=="空链接"){
		System.out.println("链接异常，请重新进入链接选择商品");
		}else{
			orderStyle=user.orders(productStyle);
			System.out.println(orderStyle);
		}
	}
}
class Order {
	// 订单类型：取消订单，付款，朋友代付
	// 订单类至少要具有下订单的行为(入参为一个产品名称)
	public String orders(String pName) {
		String orderSituation="尚未下单";
		if (pName == null) {
			orderSituation="取消下单";
			//return orderSituation;
		} else {
			orderSituation="下单成功";
			//return orderSituation;
		}
		return orderSituation;
	}
}
// 类是一类事物的集合(如果细分eg（颜色）：还可以分为白帽子，黑帽子)
// 产品类中至少有一个成员变量为产品名称，至少有一个方法用来获取产品的名称
class Product extends Order {
	/*
	 * String cat="帽子"; String tellphone="Iephone X"; String food="饼干"; public
	 * String getProductName(String Name){ return Name; }
	 */
	String name = "未选择商品";
	//根据用户进入的链接，选择对应的商品
	public String getProductName(int Link) {
		if (Link == 0) {
			name = "帽子";
			return name;
		} else if (Link == 1) {
			name = "饼干";
			return name;
		} else if (Link == 2) {
			name = "Iphone X";
			return name;
		} else if(Link==3){
			name = "其他商品";
			return name;
		}else{
			name = "空链接";
			return name;
		}
	}
	/*
	// 方法重载,暂时不用初始化
	Product() {
	
	}
	*/
//类之间的各种关系，通过修饰符加以控制
}

输出结果：