Java 字符串的重复

我试图从给定的数组列表中获取字符串的所有重复。我通过使用以下代码实现了这一点：

public static void howmany (ArrayList <String> list)
{
    for (int i=0; i<list.size();i++)
    {
        System.out.println(list.get(i)+ ": " + Collections.frequency(list, list.get(i)));
    }
}

publicstaticvoid多少（ArrayList列表）
{
对于（inti=0；i我可以给你两个简单的方法

您可以使用集合来检查重复项。创建一个hashset并添加列表。get（i）在if条件中使用返回值。hashset的add方法只有在尚未添加到集合中时才会重新运行true，否则将返回false

或者，您可以从列表中创建一个哈希集，并在哈希集上迭代以消除任何重复项

快乐编程！
我可以给你两个简单的方法

您可以使用集合来检查重复项。创建一个hashset并添加列表。get（i）在if条件中使用返回值。hashset的add方法只有在尚未添加到集合中时才会重新运行true，否则将返回false

或者，您可以从列表中创建一个哈希集，并在哈希集上迭代以消除任何重复项

快乐编程！
您可以存储已打印的值，然后在每次打印值时进行检查，以便消除重复项

例如，您可以这样做：

public static void howmany (ArrayList <String> list)
{
    Set<String> processed = new HashSet<>();
    for (int i=0; i<list.size();i++)
    {
        if(!processed.contains(list.get(i))) {
            System.out.println(list.get(i) + ": " + Collections.frequency(list, list.get(i)));
            processed.add(list.get(i));
        }
    }
}

publicstaticvoid多少（ArrayList列表）
{
Set processed=新的HashSet（）；
对于（int i=0；i，您可以存储已打印的值，然后每次打印值时检查，以便消除重复项

例如，您可以这样做：

public static void howmany (ArrayList <String> list)
{
    Set<String> processed = new HashSet<>();
    for (int i=0; i<list.size();i++)
    {
        if(!processed.contains(list.get(i))) {
            System.out.println(list.get(i) + ": " + Collections.frequency(list, list.get(i)));
            processed.add(list.get(i));
        }
    }
}

publicstaticvoid多少（ArrayList列表）
{
Set processed=新的HashSet（）；
对于（inti=0；i只需使用hashmap，如下所示

String[] toys1 = {"sorry", "bat", "sorry", "sorry", "sorry", "train", "train", "teddy", "teddy", "ball", "ball"};
Map<String,Integer> toyMap = new HashMap<String,Integer>();
for(String str:toys1){
    if(toyMap.containsKey(str)){
        toyMap.put(str, toyMap.get(str)+1);
    }else{
        toyMap.put(str, 1);
    }
}
for (Map.Entry<String, Integer> entry : toyMap.entrySet()) {
    System.out.println(entry.getKey()+"  : "+entry.getValue());
}

String[]toys1={“对不起”、“蝙蝠”、“对不起”、“对不起”、“火车”、“火车”、“泰迪”、“泰迪”、“球”、“球”}；
Map toyMap=newhashmap（）；
用于（字符串str:toys1）{
if（玩具地图集装箱（str））{
toyMap.put（str，toyMap.get（str）+1）；
}否则{
玩具地图（str，1）；
}
}
for（Map.Entry:toyMap.entrySet（））{
System.out.println（entry.getKey（）+“：”+entry.getValue（））；
}
只需使用hashmap，如下所示

String[] toys1 = {"sorry", "bat", "sorry", "sorry", "sorry", "train", "train", "teddy", "teddy", "ball", "ball"};
Map<String,Integer> toyMap = new HashMap<String,Integer>();
for(String str:toys1){
    if(toyMap.containsKey(str)){
        toyMap.put(str, toyMap.get(str)+1);
    }else{
        toyMap.put(str, 1);
    }
}
for (Map.Entry<String, Integer> entry : toyMap.entrySet()) {
    System.out.println(entry.getKey()+"  : "+entry.getValue());
}

String[]toys1={“对不起”、“蝙蝠”、“对不起”、“对不起”、“火车”、“火车”、“泰迪”、“泰迪”、“球”、“球”}；
Map toyMap=newhashmap（）；
用于（字符串str:toys1）{
if（玩具地图集装箱（str））{
toyMap.put（str，toyMap.get（str）+1）；
}否则{
玩具地图（str，1）；
}
}
for（Map.Entry:toyMap.entrySet（））{
System.out.println（entry.getKey（）+“：”+entry.getValue（））；
}
下面是一个使用hashmap的O（n）解决方案：

 public static void howmany (List <String> list)
  {
        Map<String,Integer> counts = new HashMap<>();

        for (String item:list)
        {
            counts.put(item, counts.getOrDefault(item,0)+1);          

        }
    System.out.println(counts);
  }



  public static void main(String []args){

     String[] toys1 = {"sorry", "bat", "sorry", "sorry", "sorry", "train", "train", "teddy", "teddy", "ball", "ball"};


    howmany(Arrays.<String>asList(toys1));
  }

公共静态无效数量（列表）
{
映射计数=新的HashMap（）；
用于（字符串项：列表）
{
counts.put（项，counts.getOrDefault（项，0）+1）；
}
系统输出打印项次（计数）；
}
公共静态void main（字符串[]args）{
字符串[]玩具1={“对不起”、“蝙蝠”、“对不起”、“对不起”、“对不起”、“火车”、“火车”、“泰迪”、“泰迪”、“球”、“球”}；
有多少（Arrays.asList（toys1））；
}
下面是一个使用hashmap的O（n）解决方案：

 public static void howmany (List <String> list)
  {
        Map<String,Integer> counts = new HashMap<>();

        for (String item:list)
        {
            counts.put(item, counts.getOrDefault(item,0)+1);          

        }
    System.out.println(counts);
  }



  public static void main(String []args){

     String[] toys1 = {"sorry", "bat", "sorry", "sorry", "sorry", "train", "train", "teddy", "teddy", "ball", "ball"};


    howmany(Arrays.<String>asList(toys1));
  }

公共静态无效数量（列表）
{
映射计数=新的HashMap（）；
用于（字符串项：列表）
{
counts.put（项，counts.getOrDefault（项，0）+1）；
}
系统输出打印项次（计数）；
}
公共静态void main（字符串[]args）{
字符串[]玩具1={“对不起”、“蝙蝠”、“对不起”、“对不起”、“对不起”、“火车”、“火车”、“泰迪”、“泰迪”、“球”、“球”}；
有多少（Arrays.asList（toys1））；
}
为此，请使用
HashMap
。首先，遍历整个
ArrayList
并将这些字符串添加为键，如果发现新字符串或增加相应键的值，则将其值设置为
1

if(myMap.contains("foo"))
    myMap.put("foo",myMap.get("foo")++);
else
    myMap.put("foo",1);

我希望这可能会有所帮助。
为此使用
HashMap
。首先，遍历整个
ArrayList
并将这些字符串添加为键，如果发现新字符串或增加相应键的值，则将其值设置为
1

if(myMap.contains("foo"))
    myMap.put("foo",myMap.get("foo")++);
else
    myMap.put("foo",1);

我希望这会有所帮助