【JAVA_SE】10.1作业

10.1作业

第一题

考试成绩已经保存在数组scores中，依次为 89,23,64,91,119,52,73,-23
要求根据通过自定义方法来找出其中前三名，将数组成绩作为参数传入
要求判断成绩的有效性(0-100),如果成绩无效，则忽略此成绩.

package homework;

import java.util.Arrays;

public class Subject01 {
    public static void main(String[] args){
        int [] scores=new int[]{89,23,64,91,119,52,73,-23};
        int [] arr=new int [8];
        //剔除掉无效成绩
        for(int i=0;i<scores.length;i++){
            if(scores[i]>0){
                arr[i]=scores[i];
            }else{
                //遇到无效成绩以后一成绩覆盖前一成绩
                for(int j=i;j<scores.length-1;j++){
                    arr[j]=arr[j+1];
                }
                //缩容
                arr=Arrays.copyOf(arr,arr.length-1);
            }
        }

        System.out.println("去除无效成绩后为："+Arrays.toString(arr));
        //对成绩进行选择排序
        for(int h=0;h<arr.length-1;h++){
            for(int j=h+1;j<arr.length;j++){
                if(arr[j]>arr[h]){
                    int temp=arr[j];
                    arr[j]=arr[h];
                    arr[h]=temp;
                }
            }
        }
        System.out.println("成绩排名为："+Arrays.toString(arr));
        System.out.println("第一名成绩为："+arr[0]);
        System.out.println("第二名成绩为："+arr[1]);
        System.out.println("第三名成绩为："+arr[2]);
    }

}

结果：

去除无效成绩后为：[89, 23, 64, 91, 119, 52, 73]
成绩排名为：[119, 91, 89, 73, 64, 52, 23]
第一名成绩为：119
第二名成绩为：91

第二题

用数组来实现， 定义并初始化一个（1–100）保存100个数的数组，从第一个元素开始，依次数(1,2,3 循环往复),每次数到到3的元素淘汰掉.当到达数组末尾的时候再从头开始，直到最后剩余一个元素，写出算法，并输出最后保留的元素所在的最初的位置.

package homework;

import java.util.Arrays;

public class Subject02 {
    public static void main(String[] args){
        int [] arr=new int [100];
        for (int i=0;i<arr.length;i++){
            arr[i]=i+1;
        }
        System.out.println("初始化："+Arrays.toString(arr));
        int count=1;
        while(arr.length!=1){
            for (int i=0;i<arr.length;i++,count++){
                //当计数器为3时，以后边的数覆盖前边的数，同时缩容
                while (count==3){
                    for (int h=i;h<arr.length-1;h++){
                        arr[h]=arr[h+1];
                    }
                    arr=Arrays.copyOf(arr, arr.length-1);
                    count=1;
                    //System.out.println(Arrays.toString(arr));
                }
            }
        }
        System.out.println("最后的数初始位置为："+(arr[0]-1));
    }

}

结果：

初始化：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
最后的数初始位置为：57

第三题

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

package homework;

import java.util.Arrays;

public class Subject03 {
    public static void main(String[] args){
        //冒泡排序
        int [] arr1=new int []{15,3,64,6,23};
        for(int j=0;j<arr1.length-1;j++){
            for(int i=j;i<arr1.length-1-j;i++){
                if(arr1[i]>arr1[i+1]){
                    int temp=arr1[i+1];
                    arr1[i+1]=arr1[i];
                    arr1[i]=temp;
                }
            }
        }
        System.out.println("冒泡排序的结果："+Arrays.toString(arr1));
        //快速排序
        int [] arr2=new int[]{54,34,75,12,23};
        int start = 0;
        int end = arr2.length-1;
        quickSort(arr2,start,end);
             System.out.println("快速排序的结果："+Arrays.toString(arr2));
    }
    //快速排序
    public static  void quickSort(int[] a,int low,int high){
        int start = low;
        int end = high;
        int key = a[low];
        while(end>start){
            //从后往前比较
            while(end>start&&a[end]>=key)  //如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
                end--;
            if(a[end]<=key){
                int temp = a[end];
                a[end] = a[start];
                a[start] = temp;
            }
            //从前往后比较
            while(end>start&&a[start]<=key)//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
                start++;
            if(a[start]>=key){
                int temp = a[start];
                a[start] = a[end];
                a[end] = temp;
            }
        //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
        }
        //递归
        if(start>low) quickSort(a,low,start-1);//左边序列。第一个索引位置到关键值索引-1
        if(end<high) quickSort(a,end+1,high);//右边序列。从关键值索引+1到最后一个
         }
}

结果：

冒泡排序的结果：[3, 6, 15, 23, 64]
快速排序的结果：[12, 23, 34, 54, 75]

第四题

判断101-200之间有多少个素数，并输出所有素数。

package homework;

public class Subject04 {
    public static void main(String[] args){
        int count=0;
        for(int j=101;j<=200;j++){
            for(int i=2;i<=j;i++){
                //排除所有在j=i前，能被i整除的数
                if(j%i==0&&j!=i){
                    break;
                }

                //输出所有在j=i时能被i整除的数
                if(j%i==0&&j==i){
                    System.out.print(i+" ");
                    count++;
                }
            }
        }
        System.out.println("\r"+"101到200间的素数个数为："+count);
    }

}

结果：

101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199 
101到200间的素数个数为：21

第五题

输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。

package homework;

public class Subject05 {
    public static void main(String[] args){
        String word="name:admin, passcode:8888";
        int countNumber=0;
        int countLetter=0;
        int countSpace=0;
        int countOther=0;
        //构造一个字符型数组
        char [] chars=word.toCharArray();
        for(int i=0;i<chars.length;i++){
            //通过强制类型转换将字符转换为Ascii码
            byte Ascii=(byte) chars[i];
            if(Ascii>=48&&Ascii<=57){
                countNumber++;
            }else if(Ascii>=65&&Ascii<=90){
                countLetter++;
            }else if(Ascii>=97&&Ascii<=122){
                countLetter++;
            }else if(Ascii==32){
                countSpace++;
            }else{

                countOther++;
            }
        }
        System.out.println("数字个数："+countNumber);
        System.out.println("字母个数："+countLetter);
        System.out.println("空格个数："+countSpace);
        System.out.println("其他字符个数："+countOther);
    }
}

结果：

数字个数：4
字母个数：17
空格个数：1
其他字符个数：3

第六题

题目：企业发放的奖金根据利润提成。利润(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%提成，从键盘输入当月利润，求应发放奖金总数？

package homework;

import java.util.Scanner;

public class Subject06 {
    public static void main(String[] args){
        System.out.println("请输入本月利润为多少万元！");
        Scanner sc=new Scanner(System.in);
        int profit=sc.nextInt();
        double bonus=0;
        if(profit>=0&&profit<=10){
            bonus=profit*0.1;
        }else if(profit>10&&profit<=20){
            bonus=10*0.1+(profit-10)*0.07;
        }else if(profit>20&&profit<=40){
            bonus=10*0.1+10*0.07+(profit-20)*0.05;
        }else if(profit>40&&profit<=60){
            bonus=10*0.1+10*0.07+20*0.05+(profit-40)*0.03;
        }else if(profit>60&&profit<=100){
            bonus=10*0.1+10*0.07+20*0.05+20*0.03+(profit-60)*0.015;
        }else if(profit>100){
            bonus=10*0.1+10*0.07+20*0.05+20*0.03+40*0.015+(profit-100)*0.01;
        }else{
            System.out.println("输入无效利润！请重新输入");
        }
        System.out.println("发放奖金总数为："+bonus);
    }

}

结果：

请输入本月利润为多少万元！
45
发放奖金总数为：2.85

第七题

分别定义用户类，订单类，产品类，其中订单类至少要具有下订单的行为(入参为一个产品名称)，
产品类中至少有一个成员变量为产品名称，至少有一个方法用来获取产品的名称。
用户类中持有一个产品类型的成员变量。
用户类中持有一个订单类型的成员变量。

在我们的用户类中定义main函数，当执行的时候，构造一个用户类的对象，
并且通过手段可以拿到产品成员变量中的产品名称，并且调用成员变量订单的对象，进行下单。
最后输出下单成功。

package homework;

public class Subject07 {
    public static void main(String[] args){
        User user=new User();
        user.productName="橘子";
        user.productNumber=15;
        user.getProductName();
        user.getProductNumber();
        user.getAddress();
        user.order.getOrder();
    }
}
 class Product{ 
    String productName;
    int productNumber;
    String productType;
    public void getProductName(){
        System.out.println("产品名称为："+productName);
    }
    public void getProductNumber(){
        System.out.println("产品数量为："+productNumber);
    }
}
 class Order extends Product{
     String orderName;
     String orderTime;
    public void getOrder(){
        System.out.println("下单成功");
    }
}
 class User extends Order{
    String userName;
    String address="西斜七路";
    Order order=new Order();
    public void getAddress(){
        System.out.println("地址为："+address);
    }
}

结果：

产品名称为：橘子
产品数量为：15
地址为：西斜七路
下单成功