`

基本数据类型和封装类数组初始化值的研究

阅读更多
准备数据:

package test1;

import java.util.HashMap;
import java.util.Map;

public class MyArray {
	//8种基本数据类型
	static byte bytes[] = new byte[5];
	static char chars[] = new char[5];
	static int ints[] = new int[5];
	static short shorts[] = new short[5];
	static long longs[] = new long[5];
	static float floats[] = new float[5];
	static double doubles[] = new double[5];
	static boolean booleans[] = new boolean[5];
	
	//10种封装类
	static Byte[] Bytes = new Byte[5];
	static Character[] Characters = new Character[5];
	static Short[] Shorts = new Short[5];
	static Integer[] Integers = new Integer[5];
	static Long[] Longs = new Long[5];
	static Float[] Floats = new Float[5];
	static Double[] Doubles = new Double[5];
	static Boolean[] Booleans = new Boolean[5];
	static String[] Strings = new String[5];
	static Object[] Objects = new Object[5];
	
	static Map<String,Object> arrayMap = new HashMap<String,Object>();
	
    public static Map<String, Object> initMap(){
    	//8种基本数据类型
		arrayMap.put("byte", bytes);
		arrayMap.put("char", chars);
		arrayMap.put("int", ints);
		arrayMap.put("short", shorts);
		arrayMap.put("long", longs);
		arrayMap.put("float", floats);
		arrayMap.put("double", doubles);
		arrayMap.put("boolean", booleans);
		//10种封装类
		arrayMap.put("Byte", Bytes);
		arrayMap.put("Character", Characters);
		arrayMap.put("Short", Shorts);
		arrayMap.put("Integer", Integers);
		arrayMap.put("Long", Longs);
		arrayMap.put("Float", Floats);
		arrayMap.put("Double", Doubles);
		arrayMap.put("Boolean", Booleans);
		arrayMap.put("String", Strings);
		arrayMap.put("Object", Objects);
		return arrayMap;
	}
}




============================================================

package test1;

import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class ArrayDefaultValue {


	public static void main(String[] args) throws Exception {

		Map<String, Object> arrayMap = MyArray.initMap();
		ArrayDefaultValue adf = new ArrayDefaultValue();
		adf.setArguments(arrayMap);

	}

	//该方法只能对封装类有效!基本数据类型的数组无法使用
	public static void printArrayDefaultValues(String key, Object[] arr) {

		for (int i = 0; i < arr.length; i++) {
		System.out.print(key + "s[" + i + "] = " + arr[i] + "; ");
		}
		System.out.println();
	}

数据类型匹配
private void setArguments(Map<String, Object> arrayMap) throws Exception {

		Set<String> mapkey = arrayMap.keySet();
		Iterator<String> it = mapkey.iterator();
		while (it.hasNext()) {
			String key = it.next();
			Object value = arrayMap.get(key);
			// System.out.println(key + "------"+value);
			System.out.println("\n" + key + ":");

			if (key.intern() == "byte") {
				byte[] arr = (byte[]) value;
				for (int i = 0; i < arr.length; i++) {
					System.out.print(key + "s[" + i + "] = " + arr[i] + "; ");
				}
				System.out.println();
//Cannot cast from byte[] to Object[],无法调用下面这个方法
				// printArrayDefaultValues(key,arr);

			} else if (key.intern() == "Byte") {
				Byte[] arr = (Byte[]) value;
				printArrayDefaultValues(key, arr);
			} else if (key.intern() == "char") {
				char[] arr = (char[]) value;
				for (int i = 0; i < arr.length; i++) {
					System.out.print(key + "s[" + i + "] = " + arr[i] + "; ");
				}
				System.out.println();
			} else if (key.intern() == "Character") {
				Character[] arr = (Character[]) value;
				printArrayDefaultValues(key, arr);
			} else if (key.intern() == "int") {
				int[] arr = (int[]) value;
				for (int i = 0; i < arr.length; i++) {
					System.out.print(key + "s[" + i + "] = " + arr[i] + "; ");
				}
				System.out.println();
			} else if (key.intern() == "Integer") {
				Integer[] arr = (Integer[]) value;
				printArrayDefaultValues(key, arr);
			} else if (key.intern() == "short") {
				short[] arr = (short[]) value;
				for (int i = 0; i < arr.length; i++) {
					System.out.print(key + "s[" + i + "] = " + arr[i] + "; ");
				}
				System.out.println();
			} else if (key.intern() == "Short") {
				Short[] arr = (Short[]) value;
				printArrayDefaultValues(key, arr);
			} else if (key.intern() == "long") {
				long[] arr = (long[]) value;
				for (int i = 0; i < arr.length; i++) {
					System.out.print(key + "s[" + i + "] = " + arr[i] + "; ");
				}
				System.out.println();
			} else if (key.intern() == "Long") {
				Long[] arr = (Long[]) value;
				printArrayDefaultValues(key, arr);
			} else if (key.intern() == "float") {
				float[] arr = (float[]) value;
				for (int i = 0; i < arr.length; i++) {
					System.out.print(key + "s[" + i + "] = " + arr[i] + "; ");
				}
				System.out.println();
			} else if (key.intern() == "Float") {
				Float[] arr = (Float[]) value;
				printArrayDefaultValues(key, arr);
			} else if (key.intern() == "double") {
				double[] arr = (double[]) value;
				for (int i = 0; i < arr.length; i++) {
					System.out.print(key + "s[" + i + "] = " + arr[i] + "; ");
				}
				System.out.println();
			} else if (key.intern() == "Double") {
				Double[] arr = (Double[]) value;
				printArrayDefaultValues(key, arr);
			} else if (key.intern() == "boolean") {
				boolean[] arr = (boolean[]) value;
				for (int i = 0; i < arr.length; i++) {
					System.out.print(key + "s[" + i + "] = " + arr[i] + "; ");
				}
				System.out.println();
			} else if (key.intern() == "Boolean") {
				Boolean[] arr = (Boolean[]) value;
				printArrayDefaultValues(key, arr);
			} else if (key.intern() == "String") {
				String[] arr = (String[]) value;
				printArrayDefaultValues(key, arr);
			} else if (key.intern() == "Object") {
				Object[] arr = (Object[]) value;
				printArrayDefaultValues(key, arr);
			} else {
				throw new RuntimeException("unkown arguments type");
			}
		}
	}


}


======================================
输出结果:
Double:
Doubles[0] = null; Doubles[1] = null; Doubles[2] = null; Doubles[3] = null; Doubles[4] = null;
Float:
Floats[0] = null; Floats[1] = null; Floats[2] = null; Floats[3] = null; Floats[4] = null;
Long:
Longs[0] = null; Longs[1] = null; Longs[2] = null; Longs[3] = null; Longs[4] = null;
char:
chars[0] = ; chars[1] = ; chars[2] = ; chars[3] = ; chars[4] = ;
int:
ints[0] = 0; ints[1] = 0; ints[2] = 0; ints[3] = 0; ints[4] = 0;
Short:
Shorts[0] = null; Shorts[1] = null; Shorts[2] = null; Shorts[3] = null; Shorts[4] = null;
Boolean:
Booleans[0] = null; Booleans[1] = null; Booleans[2] = null; Booleans[3] = null; Booleans[4] = null;
long:
longs[0] = 0; longs[1] = 0; longs[2] = 0; longs[3] = 0; longs[4] = 0;
double:
doubles[0] = 0.0; doubles[1] = 0.0; doubles[2] = 0.0; doubles[3] = 0.0; doubles[4] = 0.0;
float:
floats[0] = 0.0; floats[1] = 0.0; floats[2] = 0.0; floats[3] = 0.0; floats[4] = 0.0;
Character:
Characters[0] = null; Characters[1] = null; Characters[2] = null; Characters[3] = null; Characters[4] = null;
short:
shorts[0] = 0; shorts[1] = 0; shorts[2] = 0; shorts[3] = 0; shorts[4] = 0;
Byte:
Bytes[0] = null; Bytes[1] = null; Bytes[2] = null; Bytes[3] = null; Bytes[4] = null;
byte:
bytes[0] = 0; bytes[1] = 0; bytes[2] = 0; bytes[3] = 0; bytes[4] = 0;
String:
Strings[0] = null; Strings[1] = null; Strings[2] = null; Strings[3] = null; Strings[4] = null;
boolean:
booleans[0] = false; booleans[1] = false; booleans[2] = false; booleans[3] = false; booleans[4] = false;
Integer:
Integers[0] = null; Integers[1] = null; Integers[2] = null; Integers[3] = null; Integers[4] = null;
Object:
Objects[0] = null; Objects[1] = null; Objects[2] = null; Objects[3] = null; Objects[4] = null;
如果有好的方法请回个帖!!
0
1
分享到:
评论

相关推荐

    计算机软件-商业源码-09 初始化数组和记录.zip

    或者在C#中的类数组初始化: ```csharp int[] arr = new int[] {1, 2, 3, 4, 5}; ``` 数组初始化也扩展到了多维数组,如二维数组,用于表示表格或矩阵。例如,C++中的二维数组初始化: ```c++ int matrix[3][3] =...

    C++_MFC_类数组

    类数组提供了一种更灵活的方式来管理和操作数据集合,相比原始的C++数组,它提供了更多的封装和抽象能力。 在MFC中,我们可能会遇到一种名为`CArray`的类,它是MFC容器类之一,用于创建和管理动态数组。`CArray`...

    基于C#开发的找两个数组的不同值

    1. **声明和初始化数组**:首先,你需要声明两个相同类型的数组,并为它们分配初始值。例如,对于数值型数组,你可以这样做: ```csharp int[] array1 = { 1, 2, 3, 4, 5 }; int[] array2 = { 4, 5, 6, 7, 8 }; ...

    FFMPEG C++封装库使用示例之初始化

    总之,FFmpeg C++ 封装库的初始化是使用 FFmpeg 进行音频和视频处理的第一步。了解如何打印支持的格式不仅有助于调试和验证配置,也为后续的编码、解码、过滤和流媒体操作奠定了基础。通过深入学习和实践这个示例,...

    C++实现数组类

    数组类的实现是将数组的功能封装在一个类中,提供更方便、更安全的访问和操作方式。以下是对`C++实现数组类`这一主题的详细解释。 首先,我们来了解C++中的原始数组。在C++中,数组定义了一段连续的内存空间,用于...

    简单的数组封装C++代码

    在C++中,我们可以创建一个类(如`Array`),来封装数组的常用操作,包括初始化、插入、删除、访问和遍历等。这个类可以提供一个私有的成员变量来存储数组,然后通过公有成员函数来暴露必要的操作。下面是一个简化的...

    Java基础教程:从基本数据类型到数组操作与面向对象实现

    理解private修饰符的意义,学习如何通过生成构造函数和访问方法来实现类的初始化。 额外信息:本文不仅教授语法糖(即便捷开发技巧),同时也重视基础理论的理解。对于初入编程领域的学习者来说,这是一个很好的开端...

    数据类 在VC中新建一个数据类,用于对已知数组进行操作

    在VC++(Visual C++)开发环境中,创建一个数据类是为了更好地组织和管理代码,特别是当处理特定类型的数据,如数组时。数据类通常包含与数据相关的操作,如初始化、读取、写入、排序、查找等。在这个场景中,我们...

    函数、内存、一维数组、二维数组

     实体中的变量都有默认初始化值  实体不在被使用,会在不确定的时间内被垃圾回收器回收 方法区,本地方法区,寄存器 数组操作常见问题  数组脚标越界异常(ArrayIndexOutOfBoundsException) int[] ...

    C程序设计基础数据类型枚举结构数组实用PPT课件.pptx

    在C编程语言中,数据类型是程序设计的基础,它们决定了变量可以存储的值的种类和范围。本PPT课件主要介绍了三种基本的数据结构:结构(struct)、枚举(enum)以及数组,这些都是C程序设计中的重要概念。 1. 结构...

    C++ 类数组指针教学PPT以及示例代码

    示例代码可能包括如何声明和初始化类,如何在类中使用数组,如何通过指针操作数组,以及如何使用动态内存分配创建大小不固定的数组。通过实践这些示例,学习者能够更好地掌握C++中的类、数组和指针的用法,从而提升...

    模板类实现数组类封装模板类实现数组类封装

    构造函数用于初始化数组,析构函数负责释放分配的内存。 `getSize()`返回数组的当前大小,而`operator[]`重载了索引访问操作符,使得我们可以像操作普通数组一样使用`Array`对象。`append()`在数组末尾添加元素,`...

    Java基础复习day03数组

    Java数组是一种数据类型,引用类型,用于存放一组数据的数据结构。数组的定义、创建、访问、长度属性、遍历、常用Arrays类、二维数组、方法递归调用经典案例、变量源码教程等。 一、数组的定义 数组是一种数据类型...

    设计并模拟实现整型多维数组类型

    可以考虑使用面向对象的设计,将数组类设计为封装内存管理和操作的实体。 通过这个课程设计,学生不仅能够掌握多维数组的基本概念,还能深入了解数据结构的实现细节,提高编程和问题解决能力。源程序文件应该包含了...

    数组类模版及调用 arraylist

    1. 初始化:构造函数可以指定数组的大小,初始化为特定值或默认值。 2. 插入和删除元素:提供在指定位置插入和删除元素的方法。 3. 访问元素:通过下标运算符`[]`提供访问元素的能力。 4. 大小调整:增加或减少数组...

    java掌握Java语言的基本组成、基本数据类型、变量

    要熟练掌握Java,首先要了解它的基本组成、基本数据类型以及变量的使用。这些是编程的基础,也是构建复杂程序的基石。 一、Java语言的基本组成 1. **语法结构**:Java的语法基于C++和C,但进行了许多简化,使其更...

    CNewArr C++写的动态数组类

    CNewArr 是一个自定义的C++类,它为动态数组提供了一种方便的抽象,支持多种数据类型,如整型(int)、字符型(char)、浮点型(float)以及字符串等。下面我们将详细讨论CNewArr类的设计原理、功能以及其可能实现的...

    初学者的数组基础课件

    声明仅定义了数组的类型和名称,而初始化则是为数组分配内存空间并可能赋予初始值。在Java中,创建数组使用`new`关键字。例如,创建一个包含10个整数的数组`int[] s = new int[10]`。一旦数组被创建,其元素会被自动...

    c++课件(函数,输入输出流,数组,指针,数据类型于表达式)

    5. 数据类型与表达式:C++支持多种基本数据类型,如整型(int)、浮点型(float、double)、字符型(char)等,以及自定义数据类型(如结构体和类)。表达式则是计算和操纵这些数据的组合,如算术表达式(`x + y`)...

    类模板案例--数组类封装

    此构造函数用于初始化数组的容量,同时会在堆区开辟相应大小的空间,并初始化 `m_Capacity` 和 `m_size` 的值。 - **拷贝构造**: ```cpp MyArray(const MyArray& arr) ``` 拷贝构造函数主要用于复制另一个 `...

Global site tag (gtag.js) - Google Analytics