蓝桥杯试题 基础练习 BASIC-10 十进制转十六进制 JAVA——冲刺蓝桥杯第五天

试题 基础练习 十进制转十六进制

资源限制
时间限制：1.0s 内存限制：512.0MB
问题描述
　　十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F共16个符号，分别表示十进制数的0至15。十六进制的计数方法是满16进1，所以十进制数16在十六进制中是10，而十进制的17在十六进制中是11，以此类推，十进制的30在十六进制中是1E。
　　给出一个非负整数，将它表示成十六进制的形式。
输入格式
　　输入包含一个非负整数a，表示要转换的数。0<=a<=2147483647
输出格式
　　输出这个整数的16进制表示
样例输入
30
样例输出
1E

要点：

1. 输入格式，数据类型一直是很重要的问题
   
   输入格式这里是0<=a<=2147483647，这里不是瞎写的，2147483647是java的int所能表示的最大的数，所以我们在本题还是可以继续用in来表示a，但是如果出题人鬼一点，这里不是214748364 7 而是214748364 8，那我们就得用long了

2. 这道题本意是让我们一步步取模来完成，但是我们能使用java自带的一些包和方法来很简单的完成，如果平时练习建议两种都会，但是比赛或考试怎样简单怎么来吧

思路一：本题考查的目的——循环 整除 求余 判断

1. Math.pow（double a，double b） (return)double
   该方法用来求指数，第一个参数为底数，第二个参数为指数，返回值为a的b次方

System.out.println(Math.pow(3,2));//输出9

2. array[max - i] = "" + a / (int) Math.pow(16, i);
""是为了将int型a / (int) Math.pow(16, i)转化为String类型，
   而 (int) Math.pow(16, i)前面加(int)是因为Math.pow（）的返回值为double，如果不转为int，那么 a / (int) Math.pow(16, i)将是double型，例如下面代码：

 System.out.println(5 / 2); //输出2 5和2都是int
 System.out.println(5 / 2.0); //输出2.5 5为int，2.0为double

3. a = a % (int) (Math.pow(16, i));
   原因同上

System.out.println(5 % 2); //输出2 5和2都是int
System.out.println(5 % 2.0); //输出1.0 5为int，2.0为double

4. Java switch case 语句
   因为篇幅太长，所以见文本末

本题代码

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        sc.close();
        //确定输入值能除开16的几次方,2147483647能除开16的7次方
        int max=0;
        for (int i = 0; i < 10; i++) {
            if (a >= Math.pow(16, i) && a < Math.pow(16, i + 1)) {
                max=i;
                break;
            }
        }
        String[] array = new String[max+1];
        for (int i = max; i >= 0; i--) {
            //这里记得i是从max到0，数组赋值如果仍然用 array[i]，则数组是颠倒的
            array[max - i] = "" + a / (int) Math.pow(16, i);
            a = a % (int) (Math.pow(16, i));
        }
        for (int i = max; i >= 0; i--) {
            switch (array[i]) {
                case "10":
                    array[i] = "A";
                    break;
                case "11":
                    array[i] = "B";
                    break;
                case "12":
                    array[i] = "C";
                    break;
                case "13":
                    array[i] = "D";
                    break;
                case "14":
                    array[i] = "E";
                    break;
                case "15":
                    array[i] = "F";
                    break;
            }
        }
        for (String i : array) {
            System.out.print(i);
        }
    }
}

思路二：简单方法——使用java自带的方法

使用java自带的方法
Integer.toHexString(a).toUpperCase()

1. Integer.toHexString(int i) (return)String
   该方法将int型转化为十六进制的String型

for (int i=10;i<16;i++){
            System.out.print(Integer.toHexString(i)+" "); //输出a b c d e f
        }

2. .toUpperCase()
   String类型的变量可以调用他，来将String内的字符由小写字母变为大写字母

String a="abc";
System.out.println(a.toUpperCase()); //输出ABC

本题代码

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int a=sc.nextInt();
        sc.close();
        System.out.println(Integer.toHexString(a).toUpperCase());
    }
}

Java switch case 语句

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

语法

switch case 语句语法格式如下：

switch(expression){
    case value :
       //语句
       break; //可选
    case value :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}

switch case 语句有如下规则：

• switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。

• switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。

• case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。

• 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。

• 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含break语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。

• switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

如果 case 语句块中没有 break 语句时，JVM 并不会顺序输出每一个 case 对应的返回值，而是继续匹配，匹配不成功则返回默认 case

public class Test {
    public static void main(String[] args) {
        int i = 5;
        switch (i) {
            case 0:
                System.out.println("0");
            case 1:
                System.out.println("1");
            case 2:
                System.out.println("2");
            default:
                System.out.println("default");
        }
    }
}

结果：

public class Test {
    public static void main(String[] args){
        int i = 1;
        switch(i){
            case 0:
                System.out.println("0");
            case 1:
                System.out.println("1");
            case 2:
                System.out.println("2");
            default:
                System.out.println("default");
        }
    }
}

结果

public class Test {
    public static void main(String[] args){
        int i = 1;
        switch(i){
            case 0:
                System.out.println("0");
            case 1:
                System.out.println("1");
            case 2:
                System.out.println("2");
            case 3:
                System.out.println("3"); 
                break;
            default:
                System.out.println("default");
        }
    }
}

结果：