java - 将元素快速加载到具有固定索引的数组/列表中而不会重复

Question

我的要求是将不在数组中的字符串输入到数组中。我还需要维护固定索引，因为这个数组将与其他数据结构一起使用，与每个索引具有一对一的关系。目前我正在使用 ArrayList类并使用 indexOf () 检查方法首先检查它是否存在，如果不存在则将其添加到带有 add () 的列表中一个参数的方法。我不熟悉 java 中的类，因此无法理解如何使用 HashMap 实现它或其他东西(trie 或其他)，这将使加载过程更快。

执行 indexOf ()在 ArrayList进行顺序搜索？我的观点是减少将单词加载到数组时的处理时间，不插入重复项，并保持元素的固定索引。如果一个被测试的单词已经在数组中，那么它已经插入的索引是必需的，因为需要这个索引来索引到其他结构并进行一些处理。有什么建议可以改进这个过程吗？

更新

有一个数组，我有一些文档，我需要从中扫描每个单词并在文档中找到唯一的单词。但我也需要计算重复的数量。换句话说，我需要计算文档中出现的唯一术语的术语频率。我正在维护一个 ArrayList<Integer[]>术语频率(术语数 x 文档数)。我正在获取一个单词，然后检查它是否在带有 indexOf () 的单词列表中方法。如果它不存在于单词列表中，那么我将单词插入到列表中，并在二维数组中分配一个新行(Array<Integer[]>)，然后将二维数组中的术语元素的计数设置为 1。如果单词已经在单词数组中，那么我使用数组中单词的索引在 Array<Integer[]> 的行中进行索引。矩阵，并使用当前正在处理的文档编号获取单元格并增加计数。

我的问题是减少 indexOf ()我当前使用的每个单词的处理时间。我需要获取单词在单词数组中的索引，如果它已经存在，如果它不在那里，那么我需要将它动态插入到数组中。

示例代码

import java.io.*;
import java.util.ArrayList;
import static java.lang.Math.log;


class DocumentRepresentation
{
  private String dirPath;
  private ArrayList<String> fileNameVector;
  private ArrayList<String> termVector;
  private ArrayList<Integer[]> tf; /* store it in natural 2d array */
  private Integer df[]; /* do normal 1d array */
  private Double idf[]; /* do normal 1d array */
  private Double tfIdf[][]; /* do normal 2d array */

  DocumentRepresentation (String dirPath)
  {
    this.dirPath = dirPath;
    fileNameVector = new ArrayList<String> ();
    termVector = new ArrayList<String> ();
    tf = new ArrayList<Integer[]> ();
  }

  /* Later sepatere the internal works */
  public int start ()
  {
    /* Load the files, and populate the fileNameVector string */
    File fileDir = new File (dirPath);
    int fileCount = 0;
    int index;

    if (fileDir.isDirectory () == false)
    {
      return -1;
    }

    File fileList[] = fileDir.listFiles ();

    for (int i=0; i<fileList.length; i++)
    {
      if (fileList[i].isFile () == true)
      {
        fileNameVector.add (fileList[i].getName ());
        //      System.out.print ("File Name " + (i + 1) + ": " + fileList[i].getName () + "\n");
      }
    }

    fileCount = fileNameVector.size ();
    for (int i=0;i<fileNameVector.size (); i++)
    {
      System.out.print ("Name " + (i+1) + ": " + fileNameVector.get (i) + "\n");
    }

    /* Bind the files with a buffered reader */
    BufferedReader fileReaderVector[] = new BufferedReader [fileCount];
    for (int i=0; i<fileCount; i++)
    {
      try
      {
        fileReaderVector[i] = new BufferedReader (new FileReader (fileList[i]));
      }
      /* Not handled */
      catch (FileNotFoundException e)
      {
        System.out.println (e);
      }
    }

    /* Scan the term frequencies in the tf 2d array */
    for (int i=0; i<fileCount; i++)
    {
      String line;

      try
      {
            /*** THIS IS THE PLACE OF MY QUESTION **/
        while ((line = fileReaderVector[i].readLine ()) != null)
        {
          String words[] = line.split ("[\\W]");

          for (int j=0;j<words.length;j++)
          { 
            if ((index = termVector.indexOf (words[j])) != -1)
            {
              tf.get (index)[i]++;
              /* increase the tf count */
            }
            else
            {
              termVector.add (words[j]);
              Integer temp[] = new Integer [fileCount];

              for (int k=0; k<fileCount; k++)
              {
                temp[k] = new Integer (0);
              }
              temp[i] = 1;
              tf.add (temp);
              index = termVector.indexOf (words[j]);
            }

            System.out.println (words[j]);
          }
        }
      }
      /* Not handled */
      catch (IOException e)
      {
        System.out.println (e);
      }
    }

    return 0;
  }
}

class DocumentRepresentationTest
{
  public static void main (String args[])
  {
    DocumentRepresentation docSet = new DocumentRepresentation (args[0]);
    docSet.start ();
    System.out.print ("\n");
  }
}

注意:代码被剪断以保持对问题的关注

Answer 1

LinkedHashMap可以一次满足您的所有要求，具有良好的性能特点。

键是您的项目，值是索引。如果您按递增索引的顺序插入元素，则遍历映射也会按递增索引的顺序返回元素。

下面是一些示例代码:

LinkedHashMap<Item,Integer> map = new LinkedHashMap<Item,Integer>();

获取项目的索引:

Integer index = map.get(item);
if (index != null) {
  // already in the map; use `index'
} else {
  // not in the map
}

用下一个索引添加item:

if (!map.containsKey(item)) {
  map.put(item, map.size());
}

按照索引递增的顺序遍历元素:

for (Entry<Item,Integer> e : map.entrySet()) {
  Item item = e.getKey();
  int index = e.getValue();
  ...
}

这不能有效地获取特定索引处的值，但我对你问题的阅读表明你实际上并不需要这个。