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