Java map.size（）不使用静态映射

嘿，我正在尝试从其他类获取静态贴图的大小

我在一个类中定义静态映射…如下

tasklet.class

  package com.hcsc.ccsp.nonadj.subrogation.integration;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.springframework.batch.core.StepContribution;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;

import org.springframework.batch.repeat.RepeatStatus;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.core.io.Resource;
import org.springframework.util.Assert;

import com.hcsc.ccsp.nonadj.subrogation.batch.Subrogation;

import com.hcsc.ccsp.nonadj.subrogation.common.SubrogationConstants;

/**
 * @author Manan Shah
 * 
 */

public class SubrogationFileTransferTasklet implements Tasklet,
        InitializingBean {
    private Logger logger = LogManager
            .getLogger(SubrogationFileTransferTasklet.class);
    private Resource inputfile;
    private Resource outputfile;
    public static String fileLastName;

    public static String header = null;
    public static String trailer = null;
    public static List<Subrogation> fileDataListSubro = new ArrayList<Subrogation>();
    public List<String> fileDataListS = new ArrayList<String>();
    public static TreeMap<String, Subrogation> map = new TreeMap<String, Subrogation>();
    public int counter = 0;
    public String value;

    @Override
    public void afterPropertiesSet() throws Exception {
        Assert.notNull(inputfile, "inputfile must be set");

    }

    public void setTrailer(String trailer) {
        this.trailer = trailer;
    }

    public void setHeader(String header) {
        this.header = header;
    }

    public String getTrailer() {
        return trailer;
    }

    public String getHeader() {
        return header;
    }

    public Resource getInputfile() {
        return inputfile;
    }

    public void setInputfile(Resource inputfile) {
        this.inputfile = inputfile;
    }

    public Resource getOutputfile() {
        return outputfile;
    }

    public void setOutputfile(Resource outputfile) {
        this.outputfile = outputfile;
    }

    public static void setFileDataListSubro(List<Subrogation> fileDataListSubro) {
        SubrogationFileTransferTasklet.fileDataListSubro = fileDataListSubro;
    }

    public static List<Subrogation> getFileDataListSubro() {
        return fileDataListSubro;
    }

    public static void setMap(TreeMap<String, Subrogation> map) {
        SubrogationFileTransferTasklet.map = map;
    }

    public static TreeMap<String, Subrogation> getMap() {
        return map;
    }

    @Override
    public RepeatStatus execute(StepContribution contribution,
            ChunkContext chunkContext) throws Exception {

        value = (String) chunkContext.getStepContext().getStepExecution()
                .getJobExecution().getExecutionContext().get("outputFile");

        readFromFile();

        return RepeatStatus.FINISHED;
    }

    public void readFromFile() {
        BufferedReader br = null;

        try {

            String sCurrentLine;

            br = new BufferedReader(new FileReader(inputfile.getFile()));
            fileLastName = inputfile.getFile().getName();
            while ((sCurrentLine = br.readLine()) != null) {

                if (sCurrentLine.indexOf("TRAILER") != -1) {
                    setTrailer(sCurrentLine);
                } else if (sCurrentLine.indexOf("HEADER") != -1) {
                    setHeader(sCurrentLine);
                } else if (sCurrentLine.equalsIgnoreCase("")) {

                } else {
                    fileDataListS.add(sCurrentLine);
                }

            }

            convertListOfStringToListOfSubrogaion(fileDataListS);
            writeDataToFile();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (br != null)
                    br.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }

    }

    public void convertListOfStringToListOfSubrogaion(List<String> list) {

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            Subrogation subrogration = new Subrogation();
            String s = iterator.next();
            subrogration.setGRP_NBR(StringUtils.substring(s, 0, 6));
            subrogration.setSECT_NBR(StringUtils.substring(s, 6, 10));
            subrogration.setAFP_VAL(StringUtils.substring(s, 10, 13));
            subrogration.setDOL_MIN_VAL(StringUtils.substring(s, 13, 20));
            subrogration
                    .setCORP_ENT_CD(StringUtils.substring(s, 20, s.length()));

            map.put(subrogration.getGRP_NBR() + subrogration.getSECT_NBR(),
                    subrogration);
            fileDataListSubro.add(subrogration);

        }

    }

    public void writeDataToFile() {
        try {

            File file = new File(value);

            if (!file.exists()) {

                logger.info("output file is:-" + file.getAbsolutePath());

                file.createNewFile();

            }

            FileWriter fw = new FileWriter(file.getAbsoluteFile());

            BufferedWriter bw = new BufferedWriter(fw);

            Iterator it = map.entrySet().iterator();
            while (it.hasNext()) {
                Map.Entry subrogation = (Map.Entry) it.next();
                // System.out.println(subrogation.getKey() + " = " +
                // subrogation.getValue());
                // it.remove(); // avoids a ConcurrentModificationException

                bw.append(subrogation.getValue().toString()
                        + SubrogationConstants.filler58);

            }
            bw.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
        logger.info("subrogationFileTransferTasklet Step completes");

    }
}

包com.hcsc.ccsp.nonadj.subrogation.integration；
导入java.io.BufferedReader；
导入java.io.BufferedWriter；
导入java.io.File；
导入java.io.FileReader；
导入java.io.FileWriter；
导入java.io.IOException；
导入java.util.ArrayList；
导入java.util.Iterator；
导入java.util.List；
导入java.util.Map；
导入java.util.TreeMap；
导入org.apache.commons.lang3.StringUtils；
导入org.apache.log4j.LogManager；
导入org.apache.log4j.Logger；
导入org.springframework.batch.core.StepContribution；
导入org.springframework.batch.core.scope.context.ChunkContext；
导入org.springframework.batch.core.step.tasklet.tasklet；
导入org.springframework.batch.repeat.RepeatStatus；
导入org.springframework.beans.factory.initializebean；
导入org.springframework.core.io.Resource；
导入org.springframework.util.Assert；
导入com.hcsc.ccsp.nonadj.subrogation.batch.subrogation；
导入com.hcsc.ccsp.nonadj.subrogation.common.SubrogationConstants；
/**
*@作者Manan Shah
* 
*/
公共类SubrogationFileTransferTasklet实现Tasklet，
初始化bean{
专用记录器=日志管理器
.getLogger（SubrogationFileTransferTasklet.class）；
私有资源输入文件；
私有资源输出文件；
公共静态字符串fileLastName；
公共静态字符串头=null；
公共静态字符串尾部=null；
public static List fileDataListSubro=new ArrayList（）；
public List filedatalist=new ArrayList（）；
公共静态树映射=新树映射（）；
公共整数计数器=0；
公共字符串值；
@凌驾
public void afterPropertieSet（）引发异常{
Assert.notNull（inputfile，“必须设置inputfile”）；
}
公共拖车（字符串拖车）{
this.trail=拖车；
}
公共void setHeader（字符串头）{
this.header=头；
}
公共字符串getTrailer（）{
返回拖车；
}
公共字符串getHeader（）{
返回头；
}
公共资源getInputfile（）{
返回输入文件；
}
公共void setInputfile（资源inputfile）{
this.inputfile=inputfile；
}
公共资源getOutputfile（）{
返回输出文件；
}
公共void setOutputfile（资源输出文件）{
this.outputfile=outputfile；
}
公共静态无效setFileDataListSubro（列表fileDataListSubro）{
SubrogationFileTransferTasklet.fileDataListSubro=fileDataListSubro；
}
公共静态列表getFileDataListSubco（）{
返回fileDataListSubro；
}
公共静态void集合映射（树映射）{
SubrogationFileTransferTasklet.map=map；
}
公共静态树映射getMap（）{
返回图；
}
@凌驾
公共重复状态执行（STEP供款，
ChunkContext（ChunkContext）引发异常{
值=（字符串）chunkContext.getStepContext（）.getStepExecution（）
.getJobExecution（）.getExecutionContext（）.get（“outputFile”）；
readFromFile（）；
返回RepeatStatus.FINISHED；
}
public void readFromFile（）{
BufferedReader br=null；
试一试{
弦电流线；
br=新的BufferedReader（新的文件读取器（inputfile.getFile（））；
fileLastName=inputfile.getFile（）.getName（）；
而（（sCurrentLine=br.readLine（））！=null）{
如果（sCurrentLine.indexOf（“拖车”）！=-1）{
设置拖车（sCurrentLine）；
}else if（sCurrentLine.indexOf（“标题”）！=-1）{
setHeader（sCurrentLine）；
}else if（sCurrentLine.equalsIgnoreCase（“”）{
}否则{
filedatalist.add（sCurrentLine）；
}
}
convertListOfStringToListOfSubrogaion（文件数据列表）；
writeDataofile（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}最后{
试一试{
如果（br！=null）
br.close（）；
}捕获（IOEX异常）{
例如printStackTrace（）；
}
}
}
public void convertListOfStringToListOfSubrogaion（列表）{
迭代器迭代器=list.Iterator（）；
while（iterator.hasNext（））{
代位权代位权=新代位权（）；
字符串s=迭代器.next（）；
次网格。setGRP_NBR（StringUtils。子字符串（s，0，6））；
次网格设置项（StringUtils子字符串（s、6、10））；
副gration.setAFP_VAL（StringUtils.substring（s，10，13））；
副gration.setDOL_MIN_VAL（StringUtils.substring（s，13，20））；
代偿
.setCORP_ENT_CD（StringUtils.substring（s，20，s.length（））；
map.put（subgration.getGRP_NBR（）+subgration.getSECT_NBR（），
代偿）；
fileDataListSubro.add（subgration）；
}
}
公共无效写入状态文件（）{
试一试{
文件=新文件（值）；
如果（！file.exists（））{
logger.info（“输出文件为：-“+file.getAbsolutePath（））；
createNewFile（）；
}
FileWriter fw=新的FileWriter（file.getAbsoluteFile（））；
BufferedWriter bw=新的BufferedWriter（fw）；
迭代器it=map.entrySet（）.Iterator（）；
while（it.hasNext（））{
Map.Entry subrogation=（Map.Entry）it.next（）；
//System.out.println（subrogation.getKey（）+“=”+
//代位权。getValue（））；
//it.remove（）；//避免ConcurrentModificationException
append（subrogation.getValue（）.toString（））
+SubrogationConstants.fill
   package com.hcsc.ccsp.nonadj.subrogation.processor;



import org.apache.commons.lang3.StringUtils;
import org.springframework.batch.item.ItemProcessor;

import com.hcsc.ccsp.nonadj.subrogation.Utils.SubrogationUtils;
import com.hcsc.ccsp.nonadj.subrogation.batch.Subrogation;
import com.hcsc.ccsp.nonadj.subrogation.common.SubrogationConstants;
import com.hcsc.ccsp.nonadj.subrogation.integration.SubrogationFileTransferTasklet;

public class SubrogationProcessor implements
        ItemProcessor<Subrogation, Subrogation> {



    public SubrogationFileTransferTasklet fileTransferTasklet = new SubrogationFileTransferTasklet();

    SubrogationUtils subrogationUtils = new SubrogationUtils();

    public int countFromFile=SubrogationFileTransferTasklet.map.size();

    public static int totalRecords = 0;

    public static int duplicate = 0;

    @Override
    public Subrogation process(Subrogation subrogration) throws Exception {
        // TODO Auto-generated method stub


        if (subrogationUtils.validateData(subrogration)) {
            Subrogation newSubro = new Subrogation();

            newSubro.setGRP_NBR(StringUtils.leftPad(subrogration.getGRP_NBR()
                    .trim(), SubrogationConstants.length6, "0"));

            if (subrogration.getSECT_NBR().trim().length() < 5) {
                newSubro.setSECT_NBR(StringUtils.leftPad(subrogration
                        .getSECT_NBR().trim(), SubrogationConstants.length4,
                        "0"));

            } else if (subrogration.getSECT_NBR().trim().length() == 5) {
                newSubro.setSECT_NBR(StringUtils.substring(subrogration.getSECT_NBR().trim(), 1));

            } else {
                return null;
            }

            newSubro.setAFP_VAL(StringUtils.leftPad(subrogration.getAFP_VAL()
                    .trim(), SubrogationConstants.length3, "0"));

            if (subrogration.getDOL_MIN_VAL().trim().contains(".")) {

                newSubro.setDOL_MIN_VAL(StringUtils.leftPad(StringUtils.substring(subrogration.getDOL_MIN_VAL(),0,subrogration.getDOL_MIN_VAL().indexOf(".")), SubrogationConstants.length7,
                        "0"));
            } else {
                newSubro.setDOL_MIN_VAL(StringUtils.leftPad(subrogration
                        .getDOL_MIN_VAL().trim(), SubrogationConstants.length7,
                        "0"));
            }

            newSubro.setCORP_ENT_CD(StringUtils.substring(
                    subrogration.getCORP_ENT_CD(), 0, 2));

            if (SubrogationFileTransferTasklet.map.containsKey(newSubro
                    .getGRP_NBR() + newSubro.getSECT_NBR())) {


                duplicate++;

                return null;
            } else {
                    if(SubrogationFileTransferTasklet.fileLastName.contains("TX")){
                        if(newSubro.getCORP_ENT_CD().equalsIgnoreCase("TX")){

                            SubrogationFileTransferTasklet.map.put(newSubro
                                    .getGRP_NBR() + newSubro.getSECT_NBR(), newSubro);
                        totalRecords++;
                        return newSubro;
                        }
                    }

                    else{
                        if(SubrogationFileTransferTasklet.fileLastName.contains("IL")){
                            if(!newSubro.getCORP_ENT_CD().equalsIgnoreCase("TX"))
                            {
                            newSubro.setCORP_ENT_CD("IL");
                            SubrogationFileTransferTasklet.map.put(newSubro
                                    .getGRP_NBR() + newSubro.getSECT_NBR(), newSubro);
                            totalRecords++;
                            return newSubro;
                            }
                        }
                        else{
                            return null;
                        }

                    }

                    return null;

            }

        }

        else {

            return null;
        }

    }


}

class SubrogrationException extends RuntimeException {

    private static final long serialVersionUID = -8971030257905108630L;

    public SubrogrationException(String message) {
        super(message);
    }
}

  package com.hcsc.ccsp.nonadj.subrogation.writer;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.LineNumberReader;
import java.io.Writer;
import java.util.Date;
import java.util.List;


import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;

import org.springframework.batch.item.ItemStreamException;
import org.springframework.batch.item.ItemWriter;
import org.springframework.batch.item.file.FlatFileFooterCallback;
import org.springframework.batch.item.file.FlatFileHeaderCallback;

import com.hcsc.ccsp.nonadj.subrogation.Utils.SubrogationUtils;
import com.hcsc.ccsp.nonadj.subrogation.batch.Subrogation;
import com.hcsc.ccsp.nonadj.subrogation.common.SubrogationConstants;
import com.hcsc.ccsp.nonadj.subrogation.integration.SubrogationFileTransferTasklet;
import com.hcsc.ccsp.nonadj.subrogation.processor.SubrogationProcessor;

public class SubrogationHeaderFooterWriter implements FlatFileFooterCallback,FlatFileHeaderCallback{


    private Logger logger = LogManager
    .getLogger(SubrogationHeaderFooterWriter.class);

    SubrogationFileTransferTasklet fileTransferTasklet = new SubrogationFileTransferTasklet();

    SubrogationUtils subrogationUtils=new SubrogationUtils();

    SubrogationProcessor processor=new SubrogationProcessor();

    private ItemWriter<Subrogation> delegate;



    public void setDelegate(ItemWriter<Subrogation> delegate) {
        this.delegate = delegate;
    }

    public ItemWriter<Subrogation> getDelegate() {
        return delegate;
    }




    @Override
    public void writeHeader(Writer writer) throws IOException {

        //writer.write(SubrogationFileTransferTasklet.header);

    }

    @Override
    public void writeFooter(Writer writer) throws IOException {


        String trailer = SubrogationFileTransferTasklet.trailer;
        String s1 = StringUtils.substring(trailer, 0, 23);

        logger.info(" Data from input file size is---- "+new SubrogationProcessor().countFromFile);
        int trailerCounter=new SubrogationProcessor().countFromFile+SubrogationProcessor.totalRecords;
        logger.info(" Data comming from database is"+SubrogationProcessor.totalRecords);

        logger.info(" Duplicate data From DataBase is " +SubrogationProcessor.duplicate);

        logger.info(" Traileer is " + s1+ trailerCounter);

        writer.write(s1 + trailerCounter);


        SubrogationFileTransferTasklet.map.clear();
        SubrogationFileTransferTasklet.fileDataListSubro.clear();
        SubrogationProcessor.totalRecords=0;
        SubrogationProcessor.duplicate=0;

    }

    public void writeErrorDataToFile(List<String> errorDataList,String errorfile){
        File file;
        try {
            file = new File(errorfile);

            logger.info("error file is "+errorfile);   

                FileWriter fileWriter = new FileWriter(file,true);

                BufferedWriter bufferWritter = new BufferedWriter(fileWriter);

                for(String data:errorDataList){

                bufferWritter.write(new Date()+" "+data);

                bufferWritter.write(SubrogationConstants.LINE_SEPARATOR);
                }
                bufferWritter.close();
            }

        catch (IOException e) {

            throw new ItemStreamException("Could not convert resource to file: [" + errorfile + "]", e);
        }
    }
    /*
    public void write(List<? extends Subrogation> subrogation) throws Exception {
        System.out.println("inside writer");

        delegate.write(subrogation);

    }*/


}

class SubrogationProcessor{

   public int countFromFile;

   public SubrogationProcessor(){
       countFromFile=SubrogationFileTransferTasklet.map.size();
   }
}

public static TreeMap<String, Subrogation> map = new TreeMap<String, Subrogation>();

static{
    map.put(subrogration.getGRP_NBR() + subrogration.getSECT_NBR(), subrogration);
}