Java 从原始ArrayList获取值

我有一个数组列表，它没有指定为double/float，但它包含双浮点值，如

22.33

，

12.56

，

34

，

21

实际上，当我从文件中读取数据时，我使用了两种方法来保存数据。 它们看起来像这样

static List<MySample> data = new ArrayList<MySample>();
static ArrayList list = new ArrayList();

public void deserialize(List <MySample>listan, String path) {
   double sum=0;
   int count=0;
   double average=0;
    try {
        File file = new File(path);
        ObjectInputStream in = new ObjectInputStream(new   
        FileInputStream(file));
        listan = (ArrayList<MySample>) in.readObject();

        for (Object o:listan){

            sum += Double.parseDouble((String) o);
            count ++;
            average = sum/count;

}

         System.out.printf("The average on %s är %.2f ", item, average);

        in.close();
    } catch (IOException e) {
        System.out.println(e.getMessage());
    } catch (ClassNotFoundException ex) {
        System.out.println(ex.getMessage());
    }

}

但当我使用：

for (Object o : list) {
    // How can I do the same with some code here?
}

如何对

对象

循环执行相同的操作？ 我希望你能理解我的问题

好的，这是我的方法，在这里我取消序列化一个文件，并从中获取值

public void deserialize(List<MySample>listan, String path) {
   double sum=0;
   int count=0;
try {File file = new File(path);ObjectInputStream in = new 
   ObjectInputStream(newFileInputStream(file));             
   listan = (ArrayList<MySample>) in.readObject();


        for(Object obj: listan){

            //here I need the code
}
         System.out.println("Good work!");
        in.close();
    } catch (IOException e) {
        System.out.println(e.getMessage());
    } catch (ClassNotFoundException ex) {
        System.out.println(ex.getMessage());
    }

}

public void反序列化（listan，字符串路径）{
双和=0；
整数计数=0；
尝试{File File=new File（path）；ObjectInputStream in=new
ObjectInputStream（newFileInputStream（文件））；
.readObject（）中的listan=（ArrayList）；
对于（对象对象对象：listan）{
//这里我需要密码
}
System.out.println（“干得好！”）；
in.close（）；
}捕获（IOE异常）{
System.out.println（e.getMessage（））；
}捕获（ClassNotFoundException ex）{
System.out.println（例如getMessage（））；
}
}

您可以施放：

for (Object o:list){
    sum += (double) o;
    count++;
}

---

您可以将对象强制转换为Double，至少如果您确定对象的类型为

Double

。这基本上是Java5之前的老方法

for (Object o:list){
     total += ((Double)o).doubleValue();
}

---

如果您确保

列表

包含所有双精度值，则将其强制转换为

双精度

（为了不中断整个循环，必须将

try/catch

放入循环中…可能性能不高）：

---

但建议不要使用原始类型列表，如

ArrayList list=new ArrayList（）

，更好的方法是

List List=new ArrayList（）
，以下内容适用于您：

        Double sum = (double) 0;
        int count =0;
        for (Object o: list){
            sum= sum+ (Double)o;
            count++;
        }
        System.out.println("Average is   " + sum / count);

您应该做的是使用提供编译时类型安全性的

        ArrayList<Double> list = new ArrayList<Double>();
        list.add(22.33);
        list.add(12.56);
        list.add(34.21);

        Double sum = (double) 0;
        int count =0;
        for (Double o: list){
            sum= sum+ o;
            count++;
        }
        System.out.println("Average is   " + sum / count);

ArrayList list=new ArrayList（）；
列表。添加（22.33）；
增加（12.56）；
增加（34.21）；
双和=（双）0；
整数计数=0；
用于（双o:列表）{
sum=sum+o；
计数++；
}
系统输出打印项次（“平均值为”+总和/计数）；
您至少应该使用：
静态列表
，因为
Double
和
Float
扩展
Number

然后求和，就可以得到双倍值。这是泛型的正确用法

import java.util.ArrayList;
import java.util.List;

public class NumberList {
    public static void main(String[] args) {
        List<Number> list = new ArrayList<Number>();

        list.add(1.4142135623730950);
        list.add(2.71828f);
        list.add(3.14159265359d);

        // Average is: 2.4246954309812287
        System.out.println("Average is: " + avg(list));
    }

    public static double avg(List<Number> list) {
        double sum = 0;
        double count = 0;

        for (Number a : list) {
            sum += a.doubleValue();
            count++;
        }

        return sum / count;
    }
}

import java.util.ArrayList；
导入java.util.List；
公共类数学家{
公共静态void main（字符串[]args）{
列表=新的ArrayList（）；
列表.添加（1.4142135623730950）；
增加（2.71828f）；
列表。添加（3.14159265359d）；
//平均值为：2.4246954309812287
系统输出打印项次（“平均值为：“+avg（列表））；
}
公共静态双平均值（列表）{
双和=0；
重复计数=0；
对于（编号a：列表）{
sum+=a.doubleValue（）；
计数++；
}
返回和/计数；
}
}
我尝试了以上所有方法，但都没有成功，但我找到了答案

我的方法是这样的

static List<MySample> data = new ArrayList<MySample>();
static ArrayList list = new ArrayList();

public void deserialize(List <MySample>listan, String path) {
   double sum=0;
   int count=0;
   double average=0;
    try {
        File file = new File(path);
        ObjectInputStream in = new ObjectInputStream(new   
        FileInputStream(file));
        listan = (ArrayList<MySample>) in.readObject();

        for (Object o:listan){

            sum += Double.parseDouble((String) o);
            count ++;
            average = sum/count;

}

         System.out.printf("The average on %s är %.2f ", item, average);

        in.close();
    } catch (IOException e) {
        System.out.println(e.getMessage());
    } catch (ClassNotFoundException ex) {
        System.out.println(ex.getMessage());
    }

}

Theese不起作用，但该代码为我起作用

 sum += Double.parseDouble((String) o);

强制列表接受或强制转换它。为什么
List
是原始类型？首选的方法是将列表类型指定为
Double
或
Float
您应该始终使用泛型集合。请参阅此答案以获得快速介绍：您至少应该使用：
static List
，因为
Double
和
Float
extend
Number
。这给了我这个错误java.lang.String不能转换为java.lang。Double@TapaniYrjölä这就是为什么不应该使用原始类型。您的列表中有一个
字符串
，该字符串本应只包含
Double
。是的，这样更好：（（Double）o）。doubleValue（）此外，您不需要跟踪计数，除非跳过列表中的值。只需在return语句中使用
list.size（）
作为分母。如果它不是Double，则添加/执行什么操作？；）@dbf如果
列表
不能确保所有元素都是双精度的，我必须在循环中添加
try/catch
，因为如果一个元素不能转换为双精度的，它不应该破坏整个循环。只有在没有异常发生时，计数才应增加1。
 sum += Double.parseDouble((String) o);