是否在java上更新arraylist中的属性a元素？

我有一节课

Class TextChunks extends Token {
    ArrayList<Token> arrt = new ArrayList<Token>();
}

现在在token中我有了arraylist token，当有多个相同的token时，我想更新TexChunk中token的属性频率

对于一个明确的例子，请给出一个例子：

Texchunks：“特别是在某些领域和范围内”

所以有8个标记：特别是，in，domain，and，range，in，some

我想要更新令牌的属性频率：在本例中，当我获取令牌“in”的属性频率时，必须返回3

这意味着当我调用时：在dislay时获取texchunk的频率：

in 3
particular 1
in 3
domain 1 
and 1
range 1
in 3
some 1

这是我的代码：

public TextChunks updateFrequencyOfTokenInTextChunks (TextChunks tc) throws CloneNotSupportedException {
        TextChunks result = (TextChunks) tc.clone();

        for (int i =0 ; i< result.arrt.size() ; i++ ){
            int j=i+1;
            if (result.arrt.get(i).compareTwoToken(result.arrt.get(j))== true )
            {
                // help here how to update attribute result.arrt.get(i) 
                            // and result.arrt.get(J) = ++ and 
            }
            
        }
        return tc;
        
    }

---

首先，你的循环被微妙地打破了。您使用：

for (int i =0 ; i< result.arrt.size() ; i++ )

---

但是请注意，由于字段

frequency

尚未声明为public，因此需要由对令牌类具有包访问权限的代码执行。另外，您引用了

compareTwoToken

，但在您发布的代码片段中，您没有提供这样的函数。

首先，您的循环被巧妙地打断了。您使用：

for (int i =0 ; i< result.arrt.size() ; i++ )

但是请注意，由于字段

frequency

尚未声明为public，因此需要由对令牌类具有包访问权限的代码执行。此外，您还引用了

compareTwoToken

，但是在您发布的代码段中，您没有提供这样的函数。

您可以使用此代码

import java.util.ArrayList;

import java.util.Arrays;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Set;

import java.util.regex.Matcher;

import java.util.regex.Pattern;


public class TokenFrequency {

    public static void main(String[] args) {
        String text = "in particular in domain and range in some";
        String[] tokens = text.split(" ");
        System.out.println(Arrays.toString(tokens));
        Set<String> uniqueTokens = new LinkedHashSet<String>(Arrays.asList(tokens)) ;
        List<Token> list = new ArrayList<Token>();


        for(String uniqueToken : uniqueTokens){
            String regex = "\\b" + uniqueToken + "\\b";
            Pattern pattern = Pattern.compile(regex);
            Matcher matcher = pattern.matcher(text);
            int frequency = 0;
            while (matcher.find()) {
               frequency++;
            }
            Token token = new Token();
            token.frequency = frequency;
            token.s = uniqueToken;
            list.add(token);
        }

        System.out.println(list);

    }



}

import java.util.ArrayList；
导入java.util.array；
导入java.util.LinkedHashSet；
导入java.util.List；
导入java.util.Set；
导入java.util.regex.Matcher；
导入java.util.regex.Pattern；
公共类令牌频率{
公共静态void main（字符串[]args）{
String text=“尤其是在某些领域和范围内”；
String[]标记=text.split（“”）；
System.out.println（数组.toString（令牌））；
Set uniqueTokens=newlinkedhashset（Arrays.asList（tokens））；
列表=新的ArrayList（）；
for（字符串uniqueToken:uniqueTokens）{
字符串regex=“\\b”+uniqueToken+“\\b”；
Pattern=Pattern.compile（regex）；
Matcher Matcher=pattern.Matcher（文本）；
整数频率=0；
while（matcher.find（））{
频率++；
}
令牌=新令牌（）；
token.frequency=频率；
token.s=唯一令牌；
列表。添加（令牌）；
}
系统输出打印项次（列表）；
}
}

您可以使用此代码

import java.util.ArrayList;

import java.util.Arrays;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Set;

import java.util.regex.Matcher;

import java.util.regex.Pattern;


public class TokenFrequency {

    public static void main(String[] args) {
        String text = "in particular in domain and range in some";
        String[] tokens = text.split(" ");
        System.out.println(Arrays.toString(tokens));
        Set<String> uniqueTokens = new LinkedHashSet<String>(Arrays.asList(tokens)) ;
        List<Token> list = new ArrayList<Token>();


        for(String uniqueToken : uniqueTokens){
            String regex = "\\b" + uniqueToken + "\\b";
            Pattern pattern = Pattern.compile(regex);
            Matcher matcher = pattern.matcher(text);
            int frequency = 0;
            while (matcher.find()) {
               frequency++;
            }
            Token token = new Token();
            token.frequency = frequency;
            token.s = uniqueToken;
            list.add(token);
        }

        System.out.println(list);

    }



}

import java.util.ArrayList；
导入java.util.array；
导入java.util.LinkedHashSet；
导入java.util.List；
导入java.util.Set；
导入java.util.regex.Matcher；
导入java.util.regex.Pattern；
公共类令牌频率{
公共静态void main（字符串[]args）{
String text=“尤其是在某些领域和范围内”；
String[]标记=text.split（“”）；
System.out.println（数组.toString（令牌））；
Set uniqueTokens=newlinkedhashset（Arrays.asList（tokens））；
列表=新的ArrayList（）；
for（字符串uniqueToken:uniqueTokens）{
字符串regex=“\\b”+uniqueToken+“\\b”；
Pattern=Pattern.compile（regex）；
Matcher Matcher=pattern.Matcher（文本）；
整数频率=0；
while（matcher.find（））{
频率++；
}
令牌=新令牌（）；
token.frequency=频率；
token.s=唯一令牌；
列表。添加（令牌）；
}
系统输出打印项次（列表）；
}
}

由于

j

在

i

的前一个位置找不到，您的不完整算法无法工作。 可行的解决方案可以是：

• updateFrequencyOfTokenTextChunks

  方法：

  public static void updateFrequencyOfTokenInTextChunks (TextChunks tc) {
    Hashtable<String,Integer> visited = new Hashtable<String,Integer>();
  
    for (Token token : tc.arrt){
      if (visited.containsKey(token.s)) {
          token.frequency = visited.get(token.s);
      } else {
          int n = count(token, tc);
          visited.put(token.s, n);
          token.frequency = n;
      }
    }
  }
  

---

祝你好运

您的不完整算法不起作用，因为

j

在

i

的前一个位置找不到。 可行的解决方案可以是：

• updateFrequencyOfTokenTextChunks

  方法：

  public static void updateFrequencyOfTokenInTextChunks (TextChunks tc) {
    Hashtable<String,Integer> visited = new Hashtable<String,Integer>();
  
    for (Token token : tc.arrt){
      if (visited.containsKey(token.s)) {
          token.frequency = visited.get(token.s);
      } else {
          int n = count(token, tc);
          visited.put(token.s, n);
          token.frequency = n;
      }
    }
  }
  

---

祝你好运

这里单词的频率是它在句子中出现的次数。 您可以使用一个小代码来实现这一点

     String sent ="in particular in domain and range in some";
    StringTokenizer str = new StringTokenizer(sent, " ");
    ArrayList<String> list = new ArrayList<String>();
    while(str.hasMoreTokens()){
        //System.out.println(str.nextToken());
        list.add(str.nextToken());
    }

String sent=“尤其是在某些领域和范围内”；
StringTokenizer str=新的StringTokenizer（已发送“”）；
ArrayList=新建ArrayList（）；
while（str.hasMoreTokens（））{
//System.out.println（str.nextToken（））；
list.add（str.nextToken（））；
}

上面的代码只是为了获取您以自己的方式完成的特定单词。 以下代码有助于查找频率：

HashSet<String> st = new HashSet<String>();
        st.addAll(list);
        ArrayList<Token> arrt = new ArrayList<Token>();
        for(String s:st){
            Token token = new Token();
            token.s=s;
        token.frequency=Collections.frequency(list, s);
        arrt.add(token);
        }

HashSet st=newhashset（）；
圣阿德尔（名单）；
ArrayList arrt=新的ArrayList（）；
for（字符串s:st）{
令牌=新令牌（）；
token.s=s；
token.frequency=Collections.frequency（列表，s）；
arrt.add（令牌）；
}

---

因此Collections.frequency（）方法将给出集合中每个单词的频率。

这里单词的频率是它在句子中出现的次数。 您可以使用一个小代码来实现这一点

     String sent ="in particular in domain and range in some";
    StringTokenizer str = new StringTokenizer(sent, " ");
    ArrayList<String> list = new ArrayList<String>();
    while(str.hasMoreTokens()){
        //System.out.println(str.nextToken());
        list.add(str.nextToken());
    }

String sent=“尤其是在某些领域和范围内”；
StringTokenizer str=新的StringTokenizer（已发送“”）；
ArrayList=新建ArrayList（）；
while（str.hasMoreTokens（））{
//System.out.println（str.nextToken（））；
list.add（str.nextToken（））；
}

上面的代码只是为了获取您以自己的方式完成的特定单词。 以下代码有助于查找频率：

HashSet<String> st = new HashSet<String>();
        st.addAll(list);
        ArrayList<Token> arrt = new ArrayList<Token>();
        for(String s:st){
            Token token = new Token();
            token.s=s;
        token.frequency=Collections.frequency(list, s);
        arrt.add(token);
        }

HashSet st=newhashset（）；
圣阿德尔（名单）；
ArrayList arrt=新的ArrayList（）；
for（字符串s:st）{
令牌=新令牌（）；
token.s=s；
token.frequency=Collections.frequency（列表，s）；
arrt.add（令牌）；
}

---

因此Collections.frequency（）方法将为您提供集合中每个单词的频率。

谢谢您的信赖：我一直在添加方法或比较两个标记！谢谢你的信赖：我一直在添加方法比较