如何在Java中添加向量作为值

在第28行中，我想用

ch

数组替换

值。如果运行该程序，直方图的值将显示在文件的开头。.arff文件打印正确，但带有
@data
字段中的
值。显然，
ch
是一种不兼容的类型。Java中这种结构的修饰符是什么

public static void main(String[] args) throws Exception 
{
    int i;
    int[][][] ch = new int[4][4][4];
    FastVector attributes;
    Instances dataSet;
    double[] values;
    attributes = new FastVector();
    for (i = 0; i < 512; i++) 
    attributes.addElement(new Attribute("bin" +(i+1)))  ; 

        dataSet = new Instances("NormalizedHistogram_512bins", attributes, 3);

/*28*/  values = new double[dataSet.numAttributes()]; 
        values[0] = 3;
        values[1] =7;
        values[3] = 1;
        dataSet.add(new Instance(1.0, values));

        values = new double[dataSet.numAttributes()]; 
        values[2] = 2;
        values[3] = 8;
/*37*/  dataSet.add(new Instance(1.0, values));

    BufferedImage Image = ImageIO.read(new File("airplane_training1.jpg"));
    for(int x = 0; x < Image.getWidth(); x++)
        for(int y = 0; y < Image.getHeight(); y++) {
            int color = Image.getRGB(x, y);
            int alpha = (color & 0xff000000) >> 24;
            int red = (color & 0x00ff0000) >> 16;
            int green = (color & 0x0000ff00) >> 8;
            int blue = color & 0x000000ff ;
            ch[red / 64][green / 64][blue / 64]++;
        }
    for(int k = 0; k < ch.length; k++)
        for(int j = 0; j < ch[k].length; j++)
            for(int p = 0; p < ch[k][j].length; p++)
                System.out.println( ch[k][j][p]);
    NonSparseToSparse nonSparseToSparseInstance = new NonSparseToSparse(); 
    nonSparseToSparseInstance.setInputFormat(dataSet); 
    Instances sparseImage = Filter.useFilter(dataSet, nonSparseToSparseInstance);
    System.out.println(sparseImage);

    ArffSaver arffSaverInstance = new ArffSaver(); 
    arffSaverInstance.setInstances(sparseImage); 
    arffSaverInstance.setFile(new File("ESDN.arff")); 
    arffSaverInstance.writeBatch();
 }
}

publicstaticvoidmain（字符串[]args）引发异常
{
int i；
int[]ch=新int[4][4][4]；
快速向量属性；
实例数据集；
双[]值；
属性=新的FastVector（）；
对于（i=0；i<512；i++）
addElement（新属性（“bin”+（i+1））；
数据集=新实例（“标准化直方图_512bins”，属性，3）；
/*28*/values=new double[dataSet.numAttributes（）]；
数值[0]=3；
数值[1]=7；
数值[3]=1；
add（新实例（1.0，值））；
values=new double[dataSet.numAttributes（）]；
数值[2]=2；
数值[3]=8；
/*37*/dataSet.add（新实例（1.0，值））；
BufferedImage Image=ImageIO.read（新文件（“飞机训练1.jpg”）；
对于（int x=0；x>24；
内部红色=（颜色&0x00ff0000）>>16；
绿色=（颜色&0x0000ff00）>>8；
int blue=color&0x000000ff；
ch[red/64][green/64][blue/64]++；
}
for（int k=0；k
导入java.io.File；
导入weka.core.Attribute；
导入weka.core.FastVector；
导入weka.core.Instance；
导入weka.core.Instances；
导入weka.core.converters.ArffSaver；
导入weka.filters.Filter；
导入weka.filters.unsupervised.instance.NonSparseToSparse；
导入java.awt.image.buffereImage；
导入java.io.File；
导入java.io.IOException；
导入javax.imageio.imageio；
公开课测验{
公共静态void main（字符串[]args）引发异常
{
int i；
快速向量属性；
实例数据集；
双[]值；
属性=新的FastVector（）；
对于（i=0；i<64；i++）
addElement（新属性（“bin”+（i+1））；
数据集=新实例（“规格化直方图_512bins”，属性，0）；
//values=new double[dataSet.numAttributes（）]；
//数值[0]=3；
//数值[1]=7；
//数值[3]=1；
//add（新实例（1.0，值））；
//values=new double[dataSet.numAttributes（）]；
//数值[2]=2；
//数值[3]=8；
//add（新实例（1.0，值））；
NonSparseToSparse nonSparseToSparseInstance=新的NonSparseToSparse（）；
nonSparseToSparseInstance.setInputFormat（数据集）；
实例SPARSTASET=Filter.useFilter（数据集，非ParseToParseInstance）；
System.out.println（SPARSET）；
ArffSaver arffSaverInstance=新的ArffSaver（）；
arffSaverInstance.setInstances（SPARStatSet）；
setFile（新文件（“ESDN.arff”）；
arffSaverInstance.writeBatch（）；
直方图（）；
}
私有静态void Histogram（）引发IOException{
int[]ch=新int[4][4][4]；
BuffereImage image=ImageIO.read（新文件（“Airport_training3.jpg”）；
对于（int x=0；x>24；
内部红色=（颜色&0x00ff0000）>>16；
绿色=（颜色&0x0000ff00）>>8；
int blue=color&0x000000ff；
ch[red/64][green/64][blue/64]++；
}
for（int i=0；i
包com.test；
导入java.util.Vector；
公共类矢量演示{
公共静态void main（字符串[]args）{
//创建一个初始容量为4的空向量向量向量
向量vec=新向量（4）；
//使用add（）方法在向量中添加元素
向量加（0,4）；
向量加上（1,3）；
向量加（2,2）；
向量加上（3,1）；
//让我们以矢量打印所有可用元素
System.out.println（“添加的数字为：-”）；
对于（整数：vec）{
System.out.println（“索引：+vec.indexOf（number）+”number:+number）；
}
//在第3个位置/索引处添加了新的编号10
向量加上（3,10）；
//让我们在插入后打印矢量中可用的所有元素
System.out.println（“插入后添加的数字为：-”）；
对于（整数：vec）{
System.out.println（“索引：+vec.indexOf（number）+”number:+number）；
}
}  
}
已解决。我在IDreamInCode上发布了这个问题，没有得到回应，我自己设法解决了这个问题。
import java.io.File;
import weka.core.Attribute;
import weka.core.FastVector;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.converters.ArffSaver;
import weka.filters.Filter;
import weka.filters.unsupervised.instance.NonSparseToSparse;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;

public class AttTest {

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


    int i;
    FastVector attributes;
    Instances dataSet;
    double[] values;
    attributes = new FastVector();
    for (i = 0; i < 64; i++) 
    attributes.addElement(new Attribute("bin" +(i+1)))  ; 


        dataSet = new Instances("NormalizedHistogram_512bins", attributes, 0);

    //values = new double[dataSet.numAttributes()]; 
    //values[0] = 3;
    //values[1] =7;
    //values[3] = 1;
    //dataSet.add(new Instance(1.0, values));

    //values = new double[dataSet.numAttributes()]; 
    //values[2] = 2;
    //values[3] = 8;
    //dataSet.add(new Instance(1.0, values));

    NonSparseToSparse nonSparseToSparseInstance = new NonSparseToSparse(); 
    nonSparseToSparseInstance.setInputFormat(dataSet); 
    Instances sparseDataset = Filter.useFilter(dataSet, nonSparseToSparseInstance);

    System.out.println(sparseDataset);

    ArffSaver arffSaverInstance = new ArffSaver(); 
    arffSaverInstance.setInstances(sparseDataset); 
    arffSaverInstance.setFile(new File("ESDN.arff")); 
    arffSaverInstance.writeBatch();

    Histogram();


 }

private static void Histogram() throws IOException {
    int[][][] ch = new int[4][4][4];
    BufferedImage image = ImageIO.read(new File("airplane_training3.jpg"));
    for(int x = 0; x < image.getWidth(); x++)
        for(int y = 0; y < image.getHeight(); y++) {
            int color = image.getRGB(x, y);
            int alpha = (color & 0xff000000) >> 24;
            int red = (color & 0x00ff0000) >> 16;
            int green = (color & 0x0000ff00) >> 8;
            int blue = color & 0x000000ff;
            ch[red / 64][green / 64][blue / 64]++;
        }
    for(int i = 0; i < ch.length; i++)
        for(int j = 0; j < ch[i].length; j++)
            for(int p = 0; p < ch[i][j].length; p++)
                System.out.print( ch[i][j][p] + ",");
}

}

package com.test;

import java.util.Vector;

public class VectorDemo {

   public static void main(String[] args) {
   // create an empty Vector vec with an initial capacity of 4      
   Vector<Integer> vec = new Vector<Integer>(4);

   // use add() method to add elements in the vector
   vec.add(0,4);
   vec.add(1,3);
   vec.add(2,2);
   vec.add(3,1);

   // let us print all the elements available in vector
   System.out.println("Added numbers are :- "); 
   for (Integer number : vec) {         
   System.out.println("Index :"+vec.indexOf(number) +" Number: " + number);
   }

   // added new number 10 at 3rd position/index
   vec.add(3,10);

   // let us print all the elements available in vector after insertion
   System.out.println("Added numbers after insertion are :- "); 
   for (Integer number : vec) {         
   System.out.println("Index :"+vec.indexOf(number) +" Number: " + number);
   }
   }  
}