请教Java中的一个强制转换小问题？

Question

你说的toArray()我没有用过，期待解答，但我以前都是这么用的：） Iterator it = c.iterator();
 while (it.hasNext()) {
    String s = (String)it.next();
    System.out.println(s);
    
}

Answer 1

找到解决方法了!
 try {
   String[] str = (String[])c.toArray(new String[0]);
   
   for (int i = 0; i < str.length; i++)
     System.out.println(str[i] + " ==> " + str[i].getClass().getName());
 }
 catch (Exception e) {
   e.printStackTrace();
 }

Answer 2

String[] x = (String[]) v.toArray(new String[0]);

Answer 3

String类型的数组转换，不然也可以数据封装，构造函数啊

Answer 4

to: iamsoloist(Soloist)
Object[] 能这样转成String[] 吗，我以前这样转总是出现java.lang.ClassCastException()，我想还是在取用的时候一个个转吧，就像String s = (String)it.next();一样，或者这样：
Object[] objArr = col.toArray();
for（int i = 0,..
    String str (String)objArr[i];
...

Answer 5

to:fct0906(书生舞剑) 
String[] str = (String[])c.toArray(new String[0]);
这样转可以呀，sun的help上写的呀，你可以查toArray的构造函数就明白了：）

Answer 6

感谢各位大虾的指点。其实，这个问题也反映出一类情况下Java的强制转换问题。
代码片段如下：
public static void main(String[] args) {
   try {
     Object[] m = new String[2];
     m[0] = "one";
     m[1] = "two";
     String[] n = (String[]) m;
     for (int i = 0; i < n.length; i++)
       System.out.println(n[i]);
   }
   catch (Exception e) {
     e.printStackTrace();
   }
 }
 以上从Console台上输出的结果为：
 one
 two
 
 由上可见，通过强制类型转换是没问题的。但是假如把前面的三句：
     Object[] m = new String[2];
     m[0] = "one";
     m[1] = "two";
 删掉，改为Object[] m = {"one","two"};
 再运行程序后，立刻会引来下面的报错：
 java.lang.ClassCastException
 java.lang.Throwable()
 java.lang.Exception()
 java.lang.RuntimeException()
 java.lang.ClassCastException()
 void newpackagesix.MyClass.main(java.lang.String [])
 void newpackagesix.MyClass.main(java.lang.String [])
 呵呵，搞不懂这又是为什么呢？  

Answer 7

用下面的代码看一下就知道了
Object[] om = {"one","two"};
for (int i = 0; i < om.length; i++)
    System.out.println(om[i].getClass()):Object[] sm = new String[2];
sm[0] = "one";
sm[1] = "two";
for (int i = 0; i < sm.length; i++)
    System.out.println(sm[i].getClass()):

Answer 8

应该这样
Object[] sm = new String[2];
//将会打印
//class [Ljava.lang.String;
System.out.println(sm.getClass());Object[] om = {"one","two"};
//将会打印
//class [Ljava.lang.Object;
System.out.println(om.getClass());

Answer 9

String[] wo_lai_ye = new String[ArrayList.size()];
ArrayList.toArray(wo_lai_ye);
这样做比较好，效率高，
String[] x = (String[]) v.toArray(new String[0]);
这种做法要用到递归构造，呵呵效率太差！呵呵，代码看上去也很别扭!

Answer 10

to rubyz(左思右想)：
　　你的代码我测试了一下，确实如此。但是，我不太明白，这跟强制类型转换有什么关系呢？
    Object[] om = {"one","two"};
    //将会打印
    //class [Ljava.lang.Object;
    确实不错，可是数组om里面的元素确实是String类型的。直接赋值：String[] n = om;肯定不可以。但是我将om通过强制类型转换成：String[] n = (String[])om;又有何不可呢？但为什么这里要报错呢？
 
to hello_wyq(半瓶墨水)：
　　您提到：String[] x = (String[]) v.toArray(new String[0]);这种做法要用到递归构造，呵呵效率太差！
　　不知道递归构造在这里是如何用到的呢？
　　我查阅了ArrayList的public Object[] toArray(Object a[]);方法的源代码，如下：
    public Object[] toArray(Object a[]) {
  if (a.length < size)
  a = (Object[])java.lang.reflect.Array.newInstance(
       a.getClass().getComponentType(), size);
    System.arraycopy(elementData, 0, a, 0, size);
  if (a.length > size)
   a[size] = null;
  return a;
  }
  如我们所看到的，这里返回的a其实就是toArray中的参数Object a[]，不知道如何会像您所述用到递归构造函数呢？

Answer 11

getClass()得到的是对象真实的实现类
强制类型转换与它真实的实现类有关
例如一个对象.getClass() --> java.io.OutputStream
java.lang.Object
  |
  +-java.io.OutputStream
        |
        +-java.io.ObjectOutputStream
All Implemented Interfaces: 
DataOutput, ObjectOutput, ObjectStreamConstants 
那它可以转换成Object，OutputStream， OutputStream， DataOutput， ObjectOutput， ObjectStreamConstants
而它的子类ObjectOutputStream就无法转换至于class [Ljava.lang.Object;它的元素是String,但是它不是
你可以取出来一个一个转换，不能整个转换
换成ArrayList可能比较好理解
它的元素也是String的话，你会这样吗？
(String[])ArrayList