如何在java中检测整数数组中的重复值并用它们创建一个新值？_Java_Arrays

如何在java中检测整数数组中的重复值并用它们创建一个新值？

java arrays

如何在java中检测整数数组中的重复值并用它们创建一个新值？,java,arrays,Java,Arrays,各位，如果你们能在这个问题上帮助我，我将非常感激。关键是我有一个初始数组“a”，里面有一堆数字，其中一些可以重复很多次，一些可以重复一次。任务是创建一个由重复数字组成的新数组“b”。如果数组“a”中的任何数字重复多次-在数组“b”中必须只反射一次。新数组中的元素顺序应与初始数组中的元素顺序相同。例如： *initial array "a": 2 3 3 4 5 6 9 2 7 3 3 new array "b": 2 3* 我决定每次都随机生成数组“a”，这没有任何困难，但在定义重复方

各位，如果你们能在这个问题上帮助我，我将非常感激。关键是我有一个初始数组“a”，里面有一堆数字，其中一些可以重复很多次，一些可以重复一次。任务是创建一个由重复数字组成的新数组“b”。如果数组“a”中的任何数字重复多次-在数组“b”中必须只反射一次。新数组中的元素顺序应与初始数组中的元素顺序相同。例如：

*initial array "a": 2 3 3 4 5 6 9 2 7 3 3  
new array "b": 2 3*

我决定每次都随机生成数组“a”，这没有任何困难，但在定义重复方面有一些问题。我所做的唯一一件事就是找到所有重复的数字，我现在得到的结果是

*initial array "a": 2 3 3 4 5 6 9 2 7 3 3        
new array "b": 2 3 3 3*

我的代码：

import java.util.*;

public class ProcessingTool  {

public static int[] arrayCreatingMethod(){

    Random rand = new Random();

    int myArrayDim = rand.nextInt(50);

    int [] myArray  = new int [myArrayDim]; 

    for (int i=0; i<myArray.length;i++){

        myArray[i] = (int)(Math.random()*(100)); 

    }

return myArray;

}

public static int[] newArrayCreatingMethod(int[] a) {

    int[] d = new int [a.length];

    int k = 0;
    int repetitions = 0;


    for (int i = 0; i<a.length;i++){

         int j = i;
         int current = a[i];             

         while (j<a.length-1) { 


             if (current == a[j+1]) {

                 d[k] = current;    
                 k++;
                 repetitions++;
                 break;

             }


             else {

                 k=k-1+1;

             }

             j++;

         }

    }

    System.out.print("\n"+repetitions+"\n");

   System.out.println("\nArray d: ");

   for (int ww = 0; ww<d.length; ww++){

        System.out.print(d[ww]+" ");

    }

import java.util.*；
公共类处理工具{
公共静态int[]arrayCreatingMethod（）{
Random rand=新的Random（）；
int myArrayDim=rand.nextInt（50）；
int[]myArray=新int[myArrayDim]；
对于（int i=0；i，使用适当的类可以简化这一过程：
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

import org.junit.Assert;

public class Reducing {

  public int[] reduce(int[] input) {
    Set<Integer> vals = new LinkedHashSet<Integer>();
    Set<Integer> recurrences = new LinkedHashSet<Integer>();
    for (Integer i : input) {
      if (vals.contains(i)) {
        recurrences.add(i);
      }
      vals.add(i);
    }
    vals.retainAll(recurrences);
    int index = 0;
    Integer[] recurs = new Integer[vals.size()];
    for (Integer i : vals)  {
      recurs[index++] = i;
    }
    return recurs;
  }

  @org.junit.Test
  public void test() {
    Integer[] input = {2, 3, 3, 4, 5, 6, 9, 2, 7, 3, 3};
    System.out.println(Arrays.toString(reduce(input)));
  }
}

导入java.util.array；
导入java.util.LinkedHashSet；
导入java.util.Set；
导入java.util.TreeSet；
导入org.junit.Assert；
减少公共阶级{
公共整数[]减少（整数[]输入）{
Set vals=new LinkedHashSet（）；
Set recurrences=new LinkedHashSet（）；
for（整数i：输入）{
如果（VAL.contains（i））{
再次发生。添加（i）；
}
添加（i）段；
}
保留期（复发）；
int指数=0；
整数[]递归=新整数[vals.size（）]；
用于（整数i:VAL）{
递归[index++]=i；
}
返回递归；
}
@org.junit.Test
公开无效测试（）{
整数[]输入={2,3,3,4,5,6,9,2,7,3,3}；
System.out.println（Arrays.toString（reduce（input））；
}
}
使用适当的类可以简化这一过程：
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

import org.junit.Assert;

public class Reducing {

  public int[] reduce(int[] input) {
    Set<Integer> vals = new LinkedHashSet<Integer>();
    Set<Integer> recurrences = new LinkedHashSet<Integer>();
    for (Integer i : input) {
      if (vals.contains(i)) {
        recurrences.add(i);
      }
      vals.add(i);
    }
    vals.retainAll(recurrences);
    int index = 0;
    Integer[] recurs = new Integer[vals.size()];
    for (Integer i : vals)  {
      recurs[index++] = i;
    }
    return recurs;
  }

  @org.junit.Test
  public void test() {
    Integer[] input = {2, 3, 3, 4, 5, 6, 9, 2, 7, 3, 3};
    System.out.println(Arrays.toString(reduce(input)));
  }
}

导入java.util.array；
导入java.util.LinkedHashSet；
导入java.util.Set；
导入java.util.TreeSet；
导入org.junit.Assert；
减少公共阶级{
公共整数[]减少（整数[]输入）{
Set vals=new LinkedHashSet（）；
Set recurrences=new LinkedHashSet（）；
for（整数i：输入）{
如果（VAL.contains（i））{
再次发生。添加（i）；
}
添加（i）段；
}
保留期（复发）；
int指数=0；
整数[]递归=新整数[vals.size（）]；
用于（整数i:VAL）{
递归[index++]=i；
}
返回递归；
}
@org.junit.Test
公开无效测试（）{
整数[]输入={2,3,3,4,5,6,9,2,7,3,3}；
System.out.println（Arrays.toString（reduce（input））；
}
}
使用适当的类可以简化这一过程：
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

import org.junit.Assert;

public class Reducing {

  public int[] reduce(int[] input) {
    Set<Integer> vals = new LinkedHashSet<Integer>();
    Set<Integer> recurrences = new LinkedHashSet<Integer>();
    for (Integer i : input) {
      if (vals.contains(i)) {
        recurrences.add(i);
      }
      vals.add(i);
    }
    vals.retainAll(recurrences);
    int index = 0;
    Integer[] recurs = new Integer[vals.size()];
    for (Integer i : vals)  {
      recurs[index++] = i;
    }
    return recurs;
  }

  @org.junit.Test
  public void test() {
    Integer[] input = {2, 3, 3, 4, 5, 6, 9, 2, 7, 3, 3};
    System.out.println(Arrays.toString(reduce(input)));
  }
}

导入java.util.array；
导入java.util.LinkedHashSet；
导入java.util.Set；
导入java.util.TreeSet；
导入org.junit.Assert；
减少公共阶级{
公共整数[]减少（整数[]输入）{
Set vals=new LinkedHashSet（）；
Set recurrences=new LinkedHashSet（）；
for（整数i：输入）{
如果（VAL.contains（i））{
再次发生。添加（i）；
}
添加（i）段；
}
保留期（复发）；
int指数=0；
整数[]递归=新整数[vals.size（）]；
用于（整数i:VAL）{
递归[index++]=i；
}
返回递归；
}
@org.junit.Test
公开无效测试（）{
整数[]输入={2,3,3,4,5,6,9,2,7,3,3}；
System.out.println（Arrays.toString（reduce（input））；
}
}
使用适当的类可以简化这一过程：
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

import org.junit.Assert;

public class Reducing {

  public int[] reduce(int[] input) {
    Set<Integer> vals = new LinkedHashSet<Integer>();
    Set<Integer> recurrences = new LinkedHashSet<Integer>();
    for (Integer i : input) {
      if (vals.contains(i)) {
        recurrences.add(i);
      }
      vals.add(i);
    }
    vals.retainAll(recurrences);
    int index = 0;
    Integer[] recurs = new Integer[vals.size()];
    for (Integer i : vals)  {
      recurs[index++] = i;
    }
    return recurs;
  }

  @org.junit.Test
  public void test() {
    Integer[] input = {2, 3, 3, 4, 5, 6, 9, 2, 7, 3, 3};
    System.out.println(Arrays.toString(reduce(input)));
  }
}

导入java.util.array；
导入java.util.LinkedHashSet；
导入java.util.Set；
导入java.util.TreeSet；
导入org.junit.Assert；
减少公共阶级{
公共整数[]减少（整数[]输入）{
Set vals=new LinkedHashSet（）；
Set recurrences=new LinkedHashSet（）；
for（整数i：输入）{
如果（VAL.contains（i））{
再次发生。添加（i）；
}
添加（i）段；
}
保留期（复发）；
int指数=0；
整数[]递归=新整数[vals.size（）]；
用于（整数i:VAL）{
递归[index++]=i；
}
返回递归；
}
@org.junit.Test
公开无效测试（）{
整数[]输入={2,3,3,4,5,6,9,2,7,3,3}；
System.out.println（Arrays.toString（reduce（input））；
}
}
公共静态void main（字符串[]args）{
//此处的TODO代码应用程序逻辑
int[]a={1,2,3,4,2,2,3,3,1,2}；
int[]b=新的int[a.长度]；
int bcount=0；
对于（int i=0；ipublicstaticvoidmain（String[]args）{
//此处的TODO代码应用程序逻辑
int[]a={1,2,3,4,2,2,3,3,1,2}；
int[]b=新的int[a.长度]；
int bcount=0；
对于（int i=0；ipublicstaticvoidmain（String[]args）{
//此处的TODO代码应用程序逻辑
int[]a={1,2,3,4,2,2,3,3,1,2}；
int[]b=新的int[a.长度]；
int bcount=0；
对于（int i=0；ipublicstaticvoidmain（String[]args）{
//此处的TODO代码应用程序逻辑
int[]a={1,2,3,4,2,2,3,3,1,2}；
int[]b=新的int[a.长度]；
int bcount=0；
对于（int i=0；i这里有一个快速的解决方案。它浏览数组a
中的每个元素，检查它是否出现多次，如果出现，则将其添加到哈希集
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;


public class IntCount {

    int [] a = new int [] {2,3,3,4,5,6,9,2,7,3,3};

    public IntCount()
    {
        Set<Integer> b = new HashSet<Integer>();
        for (int i : a)
        {
            if (containsTwice(i))
                b.add(i);
        }
        System.out.println(Arrays.toString(b.toArray()));
    }

    boolean containsTwice(int i)
    {
        int count = 0;
        for (int j : a)
        {
            if (j == i)
                count++;
        }
        return (count > 1);
    }

    public static void main(String [] args)
    {
        new IntCount();
    }
}

导入java.util.array；
导入java.util.HashSet；
导入java.util.Set；
公共类整数{
int[]a=新的int[]{2,3,3,4,5,6,9,2,7,3,3}；
公共IntCount（）
{
Set b=新的HashSet（）；
对于（int i:a）
{
if（包含（i））
b、 加（i）；
}
System.out.println（Arrays.toString（b.toArray（））；
}
布尔包含结构（int i）
{
整数计数=0；
对于（int j:a）
{
如果（j==i）
计数++；
}
返回（计数>1）；
}
公共静态void main（字符串[]args）
{
新的IntCount（）；
}
}

输出：[2,3]
这里有一个快速解决方案。它浏览数组a中的每个元素，查看它是否
public static int[] findRecurringNumbers(int[] array){
    Map<Integer, Boolean> map = new HashMap<>();

    for(Integer i : array){

        Boolean recurred = map.get(i);
        //if current number is unknown ==> recurred = null
        //if current number occurred once ==> recurred = false
        //if current number occurred more than once ==> recurred = true

        map.put(i, recurred != null);
    }
    // as result, filter all entries' keys, where the corresponding value is TRUE
    return map.entrySet().stream()
              .filter(entry->entry.getValue())
              .mapToInt(entry->entry.getKey()).toArray();
}