JavaBase两个复习小实例

   

请读试题：

由于受西方经济影响，全国房价最近很是不景气，所有城市房价现都呈大幅度下降趋势，武汉表达得尤为明显，以武汉万科城市花园为例：

之前是以每套单价70万元出售的商品房,通过一再降价处理,最后只剩下6套。由于春节在即，开发商想通过房交会对剩下的商品房进行拍卖处理,每套最终拍卖的成交价如下:

第一套: 65万元

第二套: 81万元

第三套: 98万元

第四套: 54万元

第五套: 53万元

第六套: 58万元

试题要求：

1,请将每套商品房的拍卖价格打印出来。

2，求最高的拍卖价格是哪套房，价格是多少，最低的是哪套房，价格是多少

3,请将每套商品房的拍卖价按由低到高的顺序打印出来，要求使用冒泡法对数据进行排序。

3,请计算拍卖出6套商品房的销售总金额。

4,请计算出此次拍卖会上所拍出商品房的平均价格。

5,请计算出此次拍卖会上盈利商品房的套数及亏损商品房的套数(所有商品房共6套)，

6,请算出该经销商在此次拍卖会中是盈利了还是亏损了，如果盈利了请算出盈利的金额，如果是亏损了,请算出亏损金额。

输出效果如下图所示：

推荐实现步骤：

1.使用数组来保存6套商品房的拍卖价格（注意数据类型的选择）,所有业务逻辑都要求在静态方法中实现。

2.使用冒泡排序法对数组中的元素进行排序。

  可封装一个方法用来排序，该方法接收一个数组作为参数。

public static void sortNum(double[] house){//对拍卖房进行冒泡排序  

 ………… 排序的具体业务逻辑及实现

}

3.最后将定义的所有方法在main()中调用，main()方法中应该只有定义数组和调用方法的代码，尽可能没有业务逻辑代码。

 

评分标准：

1、 代码规范，有缩进,缩进按照java代码编写规范,代码有足够的注释，方法声明要求注释清楚方法的用途(5分)

2、 打印出所有拍卖房排序之前的价格(5分)

3、 能求出最大值和最小值，并找出下标(10)

4、 完成冒泡排序并打印排序之后的价格(30分)

5、 用方法计算出所有商品房的拍卖总价(10分)

6、 完成平均价输出（10分）

7、 计算出盈利和亏损商品房套数(10分)

8、 完成销售盈亏计算(15分)

9、 程序能够运行，界面出现（5分）

 

 

public class HoursePrice {

 

/**

* @param args

*/

public static void main(String[] args) {

//定义售楼的房价

double[] price = {65.0,81.0,98.0,54.0,53.0,58.0};

System.out.print("售出的楼盘的房价是：");

printHousePrice(price);

System.out.println();//换行

//打印最高房价

int maxindex = getMax(price);

System.out.println("房价最高的是第：" + (maxindex+1)+"套房，其房价是：" + price[maxindex]+"万元。");

//打印最低房价

int minindex = getMin(price);

System.out.println("房价最高的是第：" + (minindex+1)+"套房，其房价是：" + price[minindex]+"万元。");

//打印排好序的房价

System.out.print("售出楼盘价格由低到高排序是：");

double[] arr = SortHouse(price);//接收排好序的房价

printHousePrice(arr);

System.out.println();//换行

//打印销售总额和平均价

double sum = getSum(price);

System.out.println("房子的销售总价为：" + sum +"万元");

double avg = getAvg(price);

System.out.println("销售房子的平均价格为：" + avg +"万元");

// 盈利和亏损的情况

GetOrLost(price);

 

}

//打印房价

public static void printHousePrice(double[] HousePrice){

for(int i = 0;i<HousePrice.length;i++){

System.out.print(HousePrice[i] + "  ");//打印出每个元素，且中间有间隔

}

}

//冒泡排序

public static double[] SortHouse(double[] arr){

double temp;

int N = arr.length;

for(int i = 0;i<N-1;i++){

for(int j = 0;j<N-1-i;i++){

if(arr[j]>arr[j+1]){

temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

}

}

}

return arr;

}

//寻找最大值

public static int getMax(double[] arr){

int maxIndex = 0;//记录最大值的下标，最大值永远为arr[maxIndex]

for(int i = 0;i<arr.length;i++){

if(arr[i]>arr[maxIndex]){

maxIndex = i;

}

}

return maxIndex;

}

//寻找最小值

public static int getMin(double[] arr){

int minIndex = 0;//记录最小值的下标，那么最小值为arr[minIndex]

for(int i = 0;i<arr.length;i++){

if(arr[i]<arr[minIndex]){

minIndex = i;

}

}

return minIndex;

}

//求销售总额

public static double getSum(double[] arr){

int sum = 0;

for(int i = 0;i<arr.length;i++){

sum += arr[i];

}

return sum;

}

/*

* 计算平均值

*/

public static double getAvg(double[] arr){

//平均值 = 销售总额/房子的套数

double sum = getSum(arr);//得到销售总额

double avg = sum/arr.length;//得到平均值

return avg;

}

/*

* 计算盈利和亏损的房子套数

*/

public static void GetOrLost(double[] arr){

double cost = 70.0 * arr.length;//成本价

int getCount = 0;//记录获利的房子套数

int lostCount = 0;//记录亏算房子的套数

for(int i = 0;i<arr.length;i++){

if(arr[i]>70.0){//价格高于成本价

getCount++;

}

if(arr[i]<70.0){//价格低于成本价

lostCount++;

}

}

System.out.println("拍卖会上盈利的商品房的套数为：" + getCount +"套");

System.out.println("拍卖会上亏损的商品房的套数为：" + lostCount + "套");

double sum = getSum(arr);//实际销售总额

if((sum-cost)>0){

System.out.print("该公司盈利了。" );

System.out.println("盈利金额为：" + (sum-cost)+"万元");

}

if((sum-cost)<0){

System.out.println("该公司亏损了。" );

System.out.println("亏损金额为：" + (cost-sum)+"万元");

}

if((sum-cost)==0){

         System.out.print("该公司不赚不赔。");

        }

}

}

需求：

某公司现准备对公司电脑进行升级换代，由于电脑购置时间不同，配置也不同，经过公司信息部门评估后，公司现在10台电脑的现值如下：（单位：台\元）

第一台	第二台	第三台	第四台	第五台	第六台	第七台	第八台	第九台	第十台
2500	3000	500	1500	400	1200	1600	800	1800	2600

 

经公司办公室研究决定，升级换代方法如下：

第一：对现值在1000元以下的电脑进行淘汰

第二：对现值在1000元以上2000元以下的电脑进行升级，升级费用为每台电脑现值的50%

 

要求：1、要求计算出公司有多少台电脑需要淘汰并输出

      2、要求计算公司有多多少台电脑需要升级并输出

      3、要求将不用淘汰并且不用升级的电脑按从低到高的顺序输出

        4、要求计算出此次换代升级一共需要多少费用并输出

 

 

推荐实现步骤：

      1、使用一维数组保存10台电脑的现值

      2、封装一个方法GetUpgradeNum方法来获得要升级的电脑总数

      3、封装一个方法GetWashNum 方法来获得要淘汰的电脑的总数

      4、使用方法Sort 来完成排序，注意排序后结果在输入时只需要输出不用淘汰并且不用升级的电脑的价格

      5、计算此次更新换代的费用应该是升级所需要的总费用减去淘汰电脑处理后的收入的差额

 

输出结果如下：

public class Demo {

 

/**

* @param args

*/

public static void main(String[] args) {

// TODO Auto-generated method stub

int computer[] = { 2500, 3000, 500, 1500, 400, 1200, 1600, 800, 1800,

2600 };

String d[] = { "第一台", "第二台", "第三台", "第四台", "第五台", "第六台", "第七台", "第八台",

"第九台", "第十台", };

int sum = getSum(computer);

System.out.println("10台电脑的总价值是：" + sum + "元");

 

int max_index = getMaxPrice(computer);

int max_price = computer[max_index];

System.out.println("最高价值的电脑是第" + (max_index + 1) + "台，其价值是："

+ max_price + "元");

 

int min_index = getMinPrice(computer);

int min_price = computer[min_index];

System.out.println("最低价值的电脑是第" + (min_index + 1) + "台，其价值是："

+ min_price + "元");

 

int count1 = getWashNum(computer);

System.out.println("共有" + count1 + "台电脑要淘汰");

 

System.out.println("以下电脑不需要升级也不需要淘汰");

sort(computer,d);

 

int cost = cost(computer);

System.out.println("此次更新换代总共需要费用" + cost + "元");

}

 

/**

* 获得10台电脑的总价值

* 

* @param c

* @return

*/

public static int getSum(int c[]) {

int sum = 0;

for (int i = 0; i < c.length; i++) {

sum = sum + c[i];

}

return sum;

}

 

/**

* 找出价值最高的电脑是哪台，价值是多少

* 

* @param c

* @return

*/

public static int getMaxPrice(int c[]) {

int index = 0;

int max = c[0];

for (int i = 1; i < c.length; i++) {

if (c[i] > max) {

max = c[i];

index = i;

}

}

return index;

}

 

/**

* 找出价值最低的电脑是哪台，价值是多少

* 

* @param c

* @return

*/

public static int getMinPrice(int c[]) {

int index = 0;

int min = c[0];

for (int i = 1; i < c.length; i++) {

if (c[i] < min) {

min = c[i];

index = i;

}

}

return index;

}

 

/**

* 获得要淘汰的电脑的总数

* 

* @param c

* @return

*/

public static int getWashNum(int c[]) {

int count = 0;

for (int i = 0; i < c.length; i++) {

if (c[i] < 1000) {

count = count + 1;

}

}

return count;

}

 

/**

* 排序,排序后只需要输出不用淘汰并且不用升级的电脑的价格

* 

* @param c

*/

public static void sort(int c[], String d[]) {

int temp;

String s;

for (int i = 0; i < c.length - 1; i++) {

for (int j = 0; j < c.length - 1 - i; j++) {

if (c[j] > c[j + 1]) {

temp = c[j];

c[j] = c[j + 1];

c[j + 1] = temp;

 

s = d[j];

d[j] = d[j + 1];

d[j + 1] = s;

 

}

}

}

for (int i = 0; i < c.length; i++) {

if (c[i] >= 2000) {

System.out.println("第" + (i + 1) + "台:" + c[i]);

}

}

}

 

/**

* 电脑升级的费用

* 

* @param c

* @return

*/

public static int cost(int c[]) {

int cost = 0;

int s1 = 0;// 升级费费用

int s2 = 0;// 处理淘汰电脑的收入

for (int i = 0; i < c.length; i++) {

if (c[i] >= 1000 && c[i] < 2000) {

s1 = s1 + c[i] / 2;

}

if (c[i] < 1000) {

s2 = s2 + c[i];

}

}

cost = s1 - s2;

return cost;

}

 

}

 

本文出自 “此刻打盹，你将做梦；..” 博客，谢绝转载！