import java.util.*;
class acc1
{
         private String name;
         private int age;
         acc1(String name,int age)
         {
                 this.name=name;
                 this.age=age;
         }
         public boolean equals(Object obj)
         {
                 if(!(obj instanceof acc1))
                         return false;
                 acc1 p=(acc1)obj;
                 return this.name.equals(p.name) && this.age==p.age;
                 
          }
         public String getName()
         {
                 return name;
         }
         public int getAge()
         {
                 return age;
         }
         


}
public class acc
{
          public static void main(String argv[])
          {
                  ArrayList al=new ArrayList();
                  al.add(new acc1("zhangsan",19));
                  al.add(new acc1("lisi",20));
                  al.add(new acc1("wangwu",21));
                  al.add(new acc1("wangwu",21));
                  
                  al=singleElement(al);
                  //控制输出的部分
                  Iterator it=al.iterator();
                  while(it.hasNext())
                  {
                         acc1 p=(acc1)it.next();//在这里为什么要进行类型转换呢？
                          sop(p.getName()+"::"+p.getAge());
                  }
                 
          }
          public static ArrayList singleElement(ArrayList al)
          {
                  ArrayList newal=new ArrayList();
                  Iterator it=al.iterator();
                  while(it.hasNext())
                  {
                          Object obj=it.next();
                          if(!newal.contains(obj))//contains方法的所谓底层调用是怎么回事？
                                  newal.add(obj);
                  }
                 return newal;
          }
          public static void sop(Object obj)
          {
                          System.out.println(obj);
                  }
上面程序的两个问题该怎么理解？

第一个：因为ArrayList集合存储时没有指定泛型类型，默认是Object类型，迭代时next（）返回也是Object类型，向下转型所以要强转。
第二个：contains方法检测对象是否包含于集合中，在将对象与集合中的元素进行比较时，调用的是equals()方法，
        如果对象为自定义类的对象，而没有覆写Object中的equals方法时，equals比较的是两个对象的地址是否相等。
        要比较两个对象的内容是否相等时，必须覆写Object中的equals方法，

哦，原来Object类型可以兼容所有的类型，怪不得在参数中就默认他是Object类，所以需要转型呢，但是contains的底层调用如果仅仅理解成一种公式性质的东西，是不是太简单了，还有更好的解释吗？

一种公式性质的东西？没太懂你意思。能说清楚一些吗