你有很多问题。
1.如果你读了一个long，你的“它不适合任何东西”怎么能触发呢？输入是213333333333333333333333333333333333，您将其读取为long，这会立即失败并引发异常。解决这个问题并不容易-基本上需要完全重写。你不能把你的输入作为一个数字（因为没有比long更大的东西了）。它必须是一个字符串，因此，要检查“它是否适合”，你不能做>=-128，你必须尝试将任何字符串解析成一个字节，看看它是否有效。

1. Math.pow用于double（即不准确的）数学，并且不能正确完成工作。如果你想要“最小的整数”，那应该是Integer.MIN_VALUE和Integer.MAX_VALUE，而不是Math.pow(2,31)，这实际上不是你想要的。因为复杂的-double是不准确的，这是过于简单的原因，而Math.pow做的是双重数学。
   大多数情况下，第2点是无关紧要的，因为第1点说，这整个方法不可能首先工作。
   这个问题比乍看上去要难一些。提示：你想要.next()（不是.nextLong()），你想知道如何捕获异常，你想 * 尝试 * 使用例如解析字符串。Byte.parseByte、Long.parseLong等等。如果它工作，打印该数据类型。如果它失败了（发生了一个异常，你必须捕获它），不要打印它。它看起来一点也不像你写的。这不是你的错--这种方法很好，直到你遇到一个讨厌的问题，你应该能够阅读如此之大的数字，他们甚至不适合在一个长。

让JDK通过让Java的Number类尝试解析输入来完成繁重的工作：

String x = sc.nextLine();
System.out.println(x + " can be fitted in:");
if (canFit(x, Byte::parseByte)) System.out.println("* byte");
if (canFit(x, Short::parseShort)) System.out.println("* short");
if (canFit(x, Integer::parseInt)) System.out.println("* int");
if (canFit(x, Long::parseLong)) System.out.println("* long");
if (!canFit(x, Byte::parseByte) &&
    !canFit(x, Short::parseShort) &&
    !canFit(x, Integer::parseInt) &&
    !canFit(x, Long::parseLong)) System.out.println("can't be fitted anywhere.");

并定义此方法：

static boolean canFit(String input, Consumer<String> parser) {
    try {
        parser.accept(input);
        return true;
    } catch (NumberFormatException e) {
        return false;
    }
}

你让你的生活变得不必要的困难。您已经在使用Scanner，它可以为您执行所有必要的检查。你只需要问：

int t = sc.nextInt();
for(int i = 0; i < t; i++) {

    boolean fitsByte = sc.hasNextByte(), fitsShort = sc.hasNextShort(),
        fitsInt = sc.hasNextInt(), fitsLong = sc.hasNextLong();

    System.out.print(sc.next());

    if(!fitsLong) System.out.println(" can't be fitted anywhere.");
    else {
        System.out.println(" can be fitted in:");
        if(fitsByte) System.out.println("* byte");
        if(fitsShort) System.out.println("* short");
        if(fitsInt) System.out.println("* int");
        System.out.println("* long");
    }
}

请记住，您必须在next()之前调用hasNext…()，以查询下一个元素的属性。
请注意，扩展到其他类型是多么容易：

int t = sc.nextInt();
for(int i = 0; i < t; i++) {

    boolean fitsByte = sc.hasNextByte(), fitsShort = sc.hasNextShort(),
        fitsInt = sc.hasNextInt(), fitsLong = sc.hasNextLong(),
        fitsBig = sc.hasNextBigInteger();

    System.out.print(sc.next());

    if(!fitsBig) System.out.println(" can't be fitted anywhere.");
    else {
        System.out.println(" can be fitted in:");
        if(fitsByte) System.out.println("* byte");
        if(fitsShort) System.out.println("* short");
        if(fitsInt) System.out.println("* int");
        if(fitsLong) System.out.println("* long");
        System.out.println("* BigInteger");
    }
}

(An如果输入包含分数或根本不是数字，则它将不适合BigInteger）

import java.util.*;
import java.io.*;
 
class Solution{
    public static void main(String []argh){
        
        Scanner sc = new Scanner(System.in);
        int t=sc.nextInt();

        for(int i=0;i<t;i++)
        { 
           try{
              long x= sc.nextLong();
                System.out.println(x+" can be fitted in:");

                if(x>=-128 && x<=127)System.out.println("* byte");

                if(x>=-32768 && x<=32767)System.out.println("* short");

                if(x>=-Integer.MIN_VALUE&& x<= 
                       Integer.MAX_VALUE)System.out.println("* int");

                if(x>=-Long.MIN_VALUE&& x<= 
                       Long.MAX_VALUE)System.out.println("* long");

            }
            catch(Exception e){
                System.out.println(sc.next()+" can't be fitted anywhere.");
            }    
        }           
    }
}

谢谢你们所有人的帮助我，你的答案教了我很多新的东西.谢谢你们所有人对我的青睐，现在我得到了满足我的条件的代码，你们所有人也给了我一个代码相同的输出，代码也是正确的，但我想告诉你我的答案，

使用 BigInteger 类来计算数字。
此外，利用 * 静态数据结构 * 为每个 * 原始数据类型 * 提供范围值。

import static java.lang.String.valueOf;

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

public class Util {
    static List<Class<?>> fit(BigInteger i) {
        List<Class<?>> l = new ArrayList<>();
        for (Map.Entry<Class<?>, Range> e : Range.map.entrySet())
            if (e.getValue().withinBounds(i)) l.add(e.getKey());
        return l;
    }

    static class Range {
        static Map<Class<?>, Range> map = new LinkedHashMap<>() {{
            put(byte.class, Range.of(byte.class));
            put(short.class, Range.of(short.class));
            put(char.class, Range.of(char.class));
            put(int.class, Range.of(int.class));
            put(long.class, Range.of(long.class));
        }};
        BigInteger minimum, maximum;

        private Range(BigInteger minimum, BigInteger maximum) {
            this.minimum = minimum;
            this.maximum = maximum;
        }

        boolean withinBounds(BigInteger x) {
            return x.compareTo(minimum) >= 0 && x.compareTo(maximum) <= 0;
        }

        static Range of(Class<?> c) {
            return new Range(min(c), max(c));
        }

        private static BigInteger min(Class<?> c) {
            String s = null;
            if (c == byte.class) s = valueOf(Byte.MIN_VALUE);
            else if (c == short.class) s = valueOf(Short.MIN_VALUE);
            else if (c == char.class) s = valueOf((int) Character.MIN_VALUE);
            else if (c == int.class) s = valueOf(Integer.MIN_VALUE);
            else if (c == long.class) s = valueOf(Long.MIN_VALUE);
            return s != null ? new BigInteger(s) : null;
        }

        private static BigInteger max(Class<?> c) {
            String s = null;
            if (c == byte.class) s = valueOf(Byte.MAX_VALUE);
            else if (c == short.class) s = valueOf(Short.MAX_VALUE);
            else if (c == char.class) s = valueOf((int) Character.MAX_VALUE);
            else if (c == int.class) s = valueOf(Integer.MAX_VALUE);
            else if (c == long.class) s = valueOf(Long.MAX_VALUE);
            return s != null ? new BigInteger(s) : null;
        }
    }
}

下面是一个示例用法。

String s = "5 -150 150000 1500000000 213333333333333333333333333333333333 -100000000000000";
Scanner sc = new Scanner(s);
BigInteger x;
while (sc.hasNextBigInteger())
    System.out.printf("%s%n%s%n%n", x = sc.nextBigInteger(), Util.fit(x));

输出

5
[byte, short, char, int, long]

-150
[short, int, long]

150000
[int, long]

1500000000
[int, long]

213333333333333333333333333333333333
[]

-100000000000000
[long]