具体不多说,见刚写的源文件,注释都有说明.

1.   
   
2. package array;
   
3. 
   
4. /*
   
5. * 需求： 定义一个没有固定长度的数组， 并且可以输入任意类型的数据， 比如int boolean char float混杂起来，
   
6. * 然后按类型分类输出。
   
7. * 解决思路:
   
8. * 可以先分类,也可以全部输完再分类. 因为已经有了不限制长度的输入的数组方法,我们统一采用输入完再分类输出.
   
9. * 判断数组数据的数据类型 判断类型方法( instanceof )返回布尔类型.(是否可以用方法的重载?直接根据不同输入数据调用不同方法)
   
10. *                 但是,instanceof只能判断引用类型,无法判读基本类型,可以找他们的包装类,比如Integer
    
11. * 另一种判断类型的方法是 getClass();
    
12. *                 输出结果是:java.lang.Integer,java.lang.String....
    
13. * 定义所有类型的数组,默认为长度为0;
    
14. * 定义一个循环输出,将输出值依次和所有类型判断,如果符合就在那个类型的数组上加.
    
15. */
    
16. public class Array {
    
17. 
    
18.         /** Object数组,等下所有的操作都是对他 */
    
19.         Object[] objArray = new Object[0];
    
20.         /** int数组 */
    
21.         int[] iArray = new int[0];
    
22.         /** double数组 */
    
23.         double[] dArray = new double[0];
    
24.         /** float数组 */
    
25.         float[] fArray = new float[0];
    
26.         /** boolean数组 */
    
27.         boolean[] bArray = new boolean[0];
    
28.         /** char数组 */
    
29.         char[] cArray = new char[0];
    
30.         /** string数组 */
    
31.         String[] sArray = new String[0];
    
32. 
    
33.         /** 分类输出数组 */
    
34.         void classfiyOutArray() {
    
35.                 for (int i = 0; i < objArray.length; i++) {
    
36.                         /* 判断数据类型,数组赋值应该可以用重载写个方法 */
    
37.                         if (objArray[i] instanceof Integer) {
    
38.                                 int temp = iArray.length;
    
39.                                 int[] tempArray = new int[temp + 1];
    
40.                                 copyArray(iArray, tempArray);
    
41.                                 tempArray[temp] = (int) objArray[i];
    
42.                                 iArray = tempArray;
    
43. 
    
44.                         } else if (objArray[i] instanceof Double) {
    
45.                                 int temp = dArray.length;
    
46.                                 double[] tempArray = new double[temp + 1];
    
47.                                 copyArray(dArray, tempArray);
    
48.                                 tempArray[temp] = (double) objArray[i];
    
49.                                 dArray = tempArray;
    
50.                         } else if (objArray[i] instanceof Float) {
    
51.                                 int temp = fArray.length;
    
52.                                 float[] tempArray = new float[temp + 1];
    
53.                                 copyArray(fArray, tempArray);
    
54.                                 tempArray[temp] = (float) objArray[i];
    
55.                                 fArray = tempArray;
    
56.                         } else if (objArray[i] instanceof Boolean) {
    
57.                                 int temp = bArray.length;
    
58.                                 boolean[] tempArray = new boolean[temp + 1];
    
59.                                 copyArray(bArray, tempArray);
    
60.                                 tempArray[temp] = (boolean) objArray[i];
    
61.                                 bArray = tempArray;
    
62.                         } else if (objArray[i] instanceof Character) {
    
63.                                 int temp = cArray.length;
    
64.                                 char[] tempArray = new char[temp + 1];
    
65.                                 copyArray(cArray, tempArray);
    
66.                                 tempArray[temp] = (char) objArray[i];
    
67.                                 cArray = tempArray;
    
68.                         } else if (objArray[i] instanceof String) {
    
69.                                 int temp = sArray.length;
    
70.                                 String[] tempArray = new String[temp + 1];
    
71.                                 copyArray(sArray, tempArray);
    
72.                                 tempArray[temp] = (String) objArray[i];
    
73.                                 sArray = tempArray;
    
74.                         }
    
75.                 }
    
76.                 /* 遍历输出各个数组 */
    
77.                 /* 先判断是否有数据,如果有就输出 */
    
78.                 if (iArray.length > 0) {
    
79.                         System.out.println("int类型的数组有:");
    
80.                         printArray(iArray);
    
81.                 }
    
82.                 if (dArray.length > 0) {
    
83.                         System.out.println("double类型的数组有:");
    
84.                         printArray(dArray);
    
85.                 }
    
86.                 if (fArray.length > 0) {
    
87.                         System.out.println("float类型的数组有:");
    
88.                         printArray(fArray);
    
89.                 }
    
90.                 if (bArray.length > 0) {
    
91.                         System.out.println("boolean类型的数组有:");
    
92.                         printArray(bArray);
    
93.                 }
    
94.                 if (cArray.length > 0) {
    
95.                         System.out.println("char类型的数组有:");
    
96.                         printArray(cArray);
    
97.                 }
    
98.                 if (sArray.length > 0) {
    
99.                         System.out.println("String类型的数组有:");
    
100.                         printArray(sArray);
     
101.                 }
     
102.         }
     
103. 
     
104.         /** 不限长度往数组输入任意数据 */
     
105.         void inputArray(Object obj) {
     
106.                 /*
     
107.                  * 传进来的数据要存储在Object数组中,可以直接建另一个数组把原先Object的数据和传进来的数据一起拷进去.
     
108.                  * (当然,也可以直接建个大点的数组,然后判断数组是否装满,然后进行扩充)
     
109.                  */
     
110.                 /* 定义一个临时数组Temp,将原先数组加当前传入的数组放进去 */
     
111.                 Object[] temp = new Object[objArray.length + 1];
     
112.                 for (int i = 0; i < temp.length; i++) {
     
113.                         /* 如果为数组的最后一个数值的话(说明就是我们传进来的那个数值),放到临时数组 */
     
114.                         if (i == temp.length - 1) {
     
115.                                 temp[i] = obj;
     
116.                         } else {
     
117.                                 temp[i] = objArray[i];
     
118. 
     
119.                         }
     
120.                 }
     
121.                 objArray = temp;
     
122. 
     
123.         }
     
124. }
     

复制代码

源代码超出几百个字符,删除了一些不重要的,具体可以看附件。
另有个问题，就是在测试文件中，如何在控制台中，批量输入数据，然后自动识别成相对应的类型？如我输入123，可以自动识别为int？

1. 
   
2. package array;
   
3. 
   
4. import java.util.Scanner;
   
5. 
   
6. public class Test {
   
7.         public static void main(String[] args) {
   
8.                 Array a = new Array();
   
9.                 a.inputArray("A");
   
10.                 a.inputArray(true);
    
11.                 a.inputArray('c');
    
12.                 a.inputArray(1);
    
13.                 a.inputArray(12.3);
    
14.                 a.inputArray(12.3F);
    
15.         }
    
16. }
    
17. 
    

复制代码

不错赞一个