java 八种基本数据类型之初始值、取值范围、对应的封装类

 

CreateTime--2017年12月6日10:03:53

Author:Marydon

一、java数据类型之基本数据类型

　　（二）八种基本数据类型的特征

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

/**
 * 八种基本数据类型的特征
 * @author Marydon
 * @createTime 2017年12月1日下午5:14:37
 * @description 初始值、取值范围、按容量大小排序、对应的封装类
 * @Email:Marydon20170307@163.com
 * @version:1.0.0
 */
public class BaseDataTypeCharacteristic {
    // 为什么要声明static属性？因为main方法（静态方法）调用类的变量（成员变量），则被调用的变量也必须是静态的
    // 布尔类型
    static boolean bl;
    // 字符型
    static char c;
    // 整型
    static byte b;
    static short s;
    static int in;
    static long l;
    // 浮点型
    static float f;
    static double d;

    private static JSONObject byteObject = new JSONObject();
    private static JSONObject shortObject = new JSONObject();
    private static JSONObject charObject = new JSONObject();
    private static JSONObject intObject = new JSONObject();
    private static JSONObject longObject = new JSONObject();
    private static JSONObject floatObject = new JSONObject();
    private static JSONObject doubleObject = new JSONObject();
    // 数据类型数组
    private static JSONArray dataTypeArray = new JSONArray();
    static List<BigDecimal> maxValList = new ArrayList<BigDecimal>();
    static List<String> maxValType = new ArrayList<String>();

    public static void main(String[] args) {
        // 1.初始化验证
        initValue();
        // 2.取值范围验证
        baseTypeRange();
        // 3.将基本数据类型对象添加到json数组中
        addDataToArray();
        // 4.输出八种基本数据类型的特征并往maxValList、maxValType集合中填充内容
        printCharacters();
        // 5.排序
        capacitySortByAsc();

    }

    /**
     * 按容量大小升序排列
     */
    static void capacitySortByAsc() {
        BigDecimal bg1 = null;
        BigDecimal bg2 = null;
        int compareResult = 0;
        String str1 = "";
        String str2 = "";
        // 冒泡排序
        for (int i = 0; i < (maxValList.size() - 1); i++) {// 最后一个也不再需要与其它数比较，因为它之前的数都已经和它做过比较了，所以i<(maxValList.size() - 1)
            // 如果-1无法理解，自己可以在此处打个断点进行调试；当然，不减1也不影响最终结果
            for (int j = (i + 1); j < maxValList.size(); j++) {// 每一个元素都不再需要与自己、自己前面的元素比较，所以j的最小值为i+1；
                // 每个元素都需要自己身后的元素[自己身后第一个元素,最后一个元素]进行比较，所以j<maxValList.size()
                bg1 = maxValList.get(i);
                bg2 = maxValList.get(j);
                compareResult = bg1.compareTo(bg2);
                // bg1=bg2-->返回0;bg1>bg2-->返回1;bg1<bg2-->返回-1
                if (1 == compareResult) {// 较大值放在后面
                    maxValList.set(i, bg2);// 错误用法：调用add方法
                    maxValList.set(j, bg1);
                    str1 = maxValType.get(i);
                    str2 = maxValType.get(j);
                    maxValType.set(i, str2);
                    maxValType.set(j, str1);
                }

            }
        }

        StringBuffer sb = new StringBuffer("八种基本数据类型按容量大小升序排列结果为：");
        // 大小比较
        for (int i = 0; i < maxValList.size(); i++) {
            if (i == (maxValList.size() - 1)) {// 最后一次拼接去掉"<"
                sb.append(maxValType.get(i));
            } else {
                sb.append(maxValType.get(i)).append("<");
            }
        }

        System.out.println(sb.toString());
    }

    /**
     * 输出八种基本数据类型的特征
     */
    static void printCharacters() {
     // 迭代输出
        for (Iterator iterator = dataTypeArray.iterator(); iterator.hasNext();) {
            JSONObject object = (JSONObject) iterator.next();
            System.out.println(
                    "java八种基本数据类型之\"" + object.get("baseType") + "\"在作为类的成员变量时，其初始值为：" + object.get("initVal")
                            + "；取值范围为：[" + object.get("minVal") + "," + object.get("maxVal") + "]；对应的封装类为："
                            + object.get("packageType"));
            // 说明：char类型的取值范围无法打印出来，通过转化测试取得结果为[0,65535]
            if ("char".equals(object.get("baseType"))) {
                object.put("minVal", 0);
                object.put("maxVal", 65535);
            }
            // 将八种基本数据类型的最大值添加到maxValList集合中
            maxValList.add(new BigDecimal(String.valueOf(object.get("maxVal"))));
            // 将八种基本数据类型添加到maxValType集合中
            maxValType.add((String)object.get("baseType"));
        }
    }

    /**
     * 将八种基本数据类型对应的JSONObject添加到JSONArray中
     */
    static void addDataToArray() {
        dataTypeArray.add(doubleObject);
        dataTypeArray.add(floatObject);
        dataTypeArray.add(longObject);
        dataTypeArray.add(intObject);
        dataTypeArray.add(charObject);
        dataTypeArray.add(shortObject);
        dataTypeArray.add(byteObject);
    }

    /**
     * 八种基本数据类型作为成员变量时的初始值
     */
    static void initValue() {
        // 数据类型
        String baseDateType = "";
        // 默认值
        Object defaultVal = "";
        for (int i = 1; i <= 8; i++) {
            for (int j = i; j <= i; j++) {
                switch (j) {
                case 1:
                    baseDateType = "boolean";
                    defaultVal = bl;// false
                    break;
                case 2:
                    baseDateType = "char";
                    defaultVal = c;// ""
                    charObject.put("initVal", c);
                    break;
                case 3:
                    baseDateType = "byte";
                    defaultVal = b;//
                    byteObject.put("initVal", b);
                    break;
                case 4:
                    baseDateType = "short";
                    defaultVal = s;//
                    shortObject.put("initVal", s);
                    break;
                case 5:
                    baseDateType = "int";
                    defaultVal = in;//
                    intObject.put("initVal", in);
                    break;
                case 6:
                    baseDateType = "long";
                    defaultVal = l;//
                    longObject.put("initVal", l);
                    break;
                case 7:
                    baseDateType = "float";
                    defaultVal = f;// 0.0
                    floatObject.put("initVal", f);
                    break;
                case 8:
                    baseDateType = "double";
                    defaultVal = d;// 0.0
                    doubleObject.put("initVal", d);
                    break;
                default:
                    break;
                }
            }
            System.out.println("java八种基本数据类型之" + baseDateType + "在作为类的成员变量时，其初始值为：" + defaultVal);
        }

    }

    /**
     * 八种基本数据类型作为局部变量时，是否有初始值测试
     */
    void localVar() {
        // 局部变量只声明，未赋值
        boolean bl2;
        char c2;
        byte b2;
        short s2;
        int in2;
        long l2;
        float f2;
        double d2;
        // 编译报错：局部变量没有初始值，要想调用必须先初始化
        System.out.println(bl2);
        System.out.println(c2);
        System.out.println(b2);
        System.out.println(s2);
        System.out.println(in2);
        System.out.println(l2);
        System.out.println(f2);
        System.out.println(d2);

    }

    /**
     * 基本数据类型的最大值与最小值
     */
    static void baseTypeRange() {
        // 7种基本数据类型
        String [] baseType = {"byte","short","char","int","long","float","double"};
        // 7种封装数据类型
        String [] packageType = {"Byte","Short","Character","Integer","Long","Float","Double"};
        // 最小值
        String minValue = "";
        // 最大值
        String maxValue = "";

        for (int i = 0; i < baseType.length; i++) {
            int j;
            // 将j声明在外面的原因是：该层for循还体外可以共享变量j
            for (j = i;j <= i;j++) {// int j = i;
                switch (j) {
                case 0:
                    minValue = String.valueOf(Byte.MIN_VALUE);
                    maxValue = String.valueOf(Byte.MAX_VALUE);
                    byteObject.put("minVal", minValue);
                    byteObject.put("maxVal", maxValue);
                    byteObject.put("baseType", baseType[j]);
                    byteObject.put("packageType", packageType[j]);
                    break;
                case 1:
                    minValue = String.valueOf(Short.MIN_VALUE);
                    maxValue = String.valueOf(Short.MAX_VALUE);
                    shortObject.put("minVal", minValue);
                    shortObject.put("maxVal", maxValue);
                    shortObject.put("baseType", baseType[j]);
                    shortObject.put("packageType", packageType[j]);
                    break;
                case 2:
                    minValue = String.valueOf(Character.MIN_VALUE);
                    maxValue = String.valueOf(Character.MAX_VALUE);
                    charObject.put("minVal", minValue);
                    charObject.put("maxVal", maxValue);
                    charObject.put("baseType", baseType[j]);
                    charObject.put("packageType", packageType[j]);
                    break;
                case 3:
                    minValue = String.valueOf(Integer.MIN_VALUE);
                    maxValue = String.valueOf(Integer.MAX_VALUE);
                    intObject.put("minVal", minValue);
                    intObject.put("maxVal", maxValue);
                    intObject.put("baseType", baseType[j]);
                    intObject.put("packageType", packageType[j]);
                    break;
                case 4:
                    minValue = String.valueOf(Long.MIN_VALUE);
                    maxValue = String.valueOf(Long.MAX_VALUE);
                    longObject.put("minVal", minValue);
                    longObject.put("maxVal", maxValue);
                    longObject.put("baseType", baseType[j]);
                    longObject.put("packageType", packageType[j]);
                    break;
                case 5:
                    minValue = String.valueOf(Float.MIN_VALUE);
                    maxValue = String.valueOf(Float.MAX_VALUE);
                    floatObject.put("minVal", minValue);
                    floatObject.put("maxVal", maxValue);
                    floatObject.put("baseType", baseType[j]);
                    floatObject.put("packageType", packageType[j]);
                    break;
                case 6:
                    minValue = String.valueOf(Double.MIN_VALUE);
                    maxValue = String.valueOf(Double.MAX_VALUE);
                    doubleObject.put("minVal", minValue);
                    doubleObject.put("maxVal", maxValue);
                    doubleObject.put("baseType", baseType[j]);
                    doubleObject.put("packageType", packageType[j]);
                    break;
                default:
                    break;
                }
            }
            // 为什么j-1？因为在j++在跳出for循环这个动作之前完成
            System.out.println("java八种基本数据类型之" + baseType[j-1] + "的作用区间为：[" + minValue + "," + maxValue + "]");
        }

    }

}

　　效果展示：　

　　文字展示：

// java八种基本数据类型之"double"在作为类的成员变量时，其初始值为：0.0；取值范围为：[4.9E-324,1.7976931348623157E308]；对应的封装类为：Double
// java八种基本数据类型之"float"在作为类的成员变量时，其初始值为：0.0；取值范围为：[1.4E-45,3.4028235E38]；对应的封装类为：Float
// java八种基本数据类型之"long"在作为类的成员变量时，其初始值为：0；取值范围为：[-9223372036854775808,9223372036854775807]；对应的封装类为：Long
// java八种基本数据类型之"int"在作为类的成员变量时，其初始值为：0；取值范围为：[-2147483648,2147483647]；对应的封装类为：Integer
// java八种基本数据类型之"char"在作为类的成员变量时，其初始值为：''；取值范围为：['','和汉字的口字很相似，无法打印出来']；转换成数字后为：[0,65535]；对应的封装类为：Character
// java八种基本数据类型之"short"在作为类的成员变量时，其初始值为：0；取值范围为：[-32768,32767]；对应的封装类为：Short
// java八种基本数据类型之"byte"在作为类的成员变量时，其初始值为：0；取值范围为：[-128,127]；对应的封装类为：Byte
// 八种基本数据类型按容量大小升序排列结果为：byte<short<char<int<long<float<double 

相关推荐：

　      java 八种基本数据类型之与对应的封装类之间的相互转化