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;// 0
                    byteObject.put("initVal", b);
                    break;
                case 4:
                    baseDateType = "short";
                    defaultVal = s;// 0
                    shortObject.put("initVal", s);
                    break;
                case 5:
                    baseDateType = "int";
                    defaultVal = in;// 0
                    intObject.put("initVal", in);
                    break;
                case 6:
                    baseDateType = "long";
                    defaultVal = l;// 0
                    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 

 

 
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值