java中两个数组的并集？

我的代码

class Union {

    //Search Function
    static boolean search(int A[], int i) {

        for (int k = 0; k < A.length; k++) {
            if (A[k] == i) {
                return true;
            }
        }
        return false;
    }

    //union
    static void union(int A[][], int B[][]) {

        int i = 0;
        int count = 0;
        int C[] = new int[A.length + B.length];

        for (; i < A.length; i++) {
            if (!(search(B, A[i]))) {
                C[count] = A[i];
                count++;
            }
        }

        for (; i < (A.length + B.length); i++) {
            C[count] = B[i - A.length];
            count++;
        }

        System.out.println("This is Union Of 2 D Array ");
        System.out.println();

        for (int k = 0; k < count; k++) {
            System.out.println(C[k]);
        }
        System.out.println();

    }

    public static void main(String... s) {
        union(new int[]{1, 1, 1, 4,}, new int[]{1, 4, 4, 4, 1, 2});
    }
}

---

没有具体回答您的问题，但是如果您实际上只是想获得一个联合，那么您可能应该使用java接口。有关详细信息，请参阅。

您发布的代码处理的是1d数组，而不是2d=）代码似乎试图将两个数组的内容连接到另一个数组中。为此，只需执行以下操作：

public static int[] joinArrays(int[] a, int[] b) {
    if (a == null || b == null)
        throw new IllegalArgumentException("Both arrays must be non-null");
    int c[] = new int[a.length + b.length];
    System.arraycopy(a, 0, c, 0, a.length);
    System.arraycopy(b, 0, c, a.length, b.length);
    return c;
}

---

A={1,1,1,4}B={1,4,4,1,2}

从数学上讲，集合A和B的并集是C={1,4,2}

或者你想要重复，比如，C={1,1,1,1,2,4,4,4}

您期望的输出是哪一个？第一个还是第二个

public class Union_2{
static int size;

public static void main(String [] args){
int [] a = {1,1,1,4};
int [] b = {1,4,4,4,1,2};
int [] c = Union_finder(a,b);
for(int i = 0 ; i< size ; i++){
  System.out.print(c[i]+" ");
}
}
public static int[] Union_finder(int [] a,int [] b){
int [] c = new int[a.length+b.length];
int i=0,j=0,k=0;
for(;i<a.length;i++){
  boolean bool = check(a[i],c);
  if( bool == false){
    c[k] = a[i];
    size++;
    k++;
  }
}
for(;j<b.length;j++){
  boolean bool = check(b[j],c);
  if( bool== false){
    c[k] = b[j];
    size++;
    k++;
  }
}
return c ;
}
public static boolean check(int x,int [] c){
if(size == 0){
  return false;
}
else{
  for(int i = size - 1 ; i >= 0 ; i--){
    if( c[i] == x){
      return true ;
    }
  }
}
return false ;
}
}

公共类联合2{
静态整数大小；
公共静态void main（字符串[]args）{
int[]a={1,1,1,4}；
int[]b={1,4,4,1,2}；
int[]c=联合查找器（a，b）；
对于（int i=0；i对于（；i这就是您要寻找的：

import java.util.Arrays;

public class Union
{

    public static void main(String[] args)
    {
        int[] A = {1, 2, 3, 3};
        int[] B = {2, 3, 1, 1};
        System.out.println(Arrays.toString(unionArrays(A, B)));
    }

    /* Union of multiple arrays */
    public static int[] unionArrays(int[]... arrays)
    {
        int maxSize = 0;
        int counter = 0;

        for(int[] array : arrays) maxSize += array.length;
        int[] accumulator = new int[maxSize];

        for(int[] array : arrays)
            for(int i : array)
                if(!isDuplicated(accumulator, counter, i))
                    accumulator[counter++] = i;

        int[] result = new int[counter];
        for(int i = 0; i < counter; i++) result[i] = accumulator[i];

        return result;
    }

    public static boolean isDuplicated(int[] array, int counter, int value)
    {
        for(int i = 0; i < counter; i++) if(array[i] == value) return true;
        return false;
    }
}

当您想要唯一性时，设置是一个自然选择。为了避免大量转换，您可以从
int[]
更改为
Integer[]
，并获得一个非常简短且干净的并集方法

下面是一个完整的工作示例：

import java.util.*;

public class Union {
  // Search Function
  public boolean search(Integer a[], Integer i) {
    for(int k = 0; k < a.length; k++) {
      if(a[k] == i) {
        return true;
      }
    }
    return false;               
  }

  // Union
  public void union(Integer[] a, Integer[] b) {
    Set<Integer> set = new HashSet<Integer>(Arrays.asList(a));
    set.addAll(Arrays.asList(b));
    Integer[] unionArray = set.toArray(new Integer[set.size()]); 
    System.out.println(Arrays.toString(unionArray));
  }

  public static void main(String...s) {
    Integer[] array1 = new Integer[]{1,1,1,4,};
    Integer[] array2 = new Integer[]{1,4,4,4,1,2};
    new Union().union(array1, array2);
  }
}

import java.util.*；
公共阶级联盟{
//搜索功能
公共布尔搜索（整数a[]，整数i）{
for（int k=0；k

显然，从数组到列表，再从列表到集合，再从集合到数组，都会有开销。然而，通常不值得使用速度更快的卷积代码——只有当您发现这部分代码中存在性能瓶颈时，才有必要使用更直接、更长的（代码方面的）代码解决方案

使用Set还可以避免一个常见的错误，即迭代数组以搜索元素以确认添加的元素不是重复的元素。通常，此类解决方案的时间复杂度为O（n^2）（请参阅）

当数组有10个元素时，这不会成为问题，但如果有两个数组，比如说，每个数组有1000个唯一元素，则会进行大量不必要的遍历，使代码速度非常慢。在这种情况下，在基于数组的解决方案中，通过遍历数组进行重复检查，则必须执行1000*1000/2=500K操作，而基于集合的操作将接近5k：


1000将第一个数组转换为列表
1000将列表转换为集合
1000将第二个数组转换为列表
1000将第二个数组添加到集合中，然后
1000将其从集合（数组）转换回）

因为基于集合的解决方案是O（n）。如果假设这些操作大致相同（虽然不是真的，但近似值也不错），则速度要快100倍

此外，随着唯一元素数量的增加，这会快速增加-对于每个阵列中的10K元素，基于阵列的漫游解决方案将执行50000000次操作，而基于集合的漫游解决方案将执行15000次操作

希望这有帮助。
//我希望这个例子很简单。
//通过两个数组，您肯定会得到数组的并集，而不会出现重复项


公共类数组
{

public int[]getUnion（int[]arr1，int[]arr2）
{
int[]array=MergeSort.mergeArray（arr1，arr2）；
int[]arrrurn=getunique（数组）；
回归与回归；
}   
public int[]getunique（int[]数组）
{
int[]arrTemp=newint[array.length]；
int[]返回；
int指数=0；
for（int i=0；i
公共静态int[]阵列（int a1[]，int a2[]）{
int[]resultArray={}；
ArrayList ArrayList=新的ArrayList（）；
如果（a1.长度>a2.长度）{
resultArray=新整数[a1.长度]；
}else resultArray=新整数[a2.长度]；
for（int元素：a1）{
add（Integer.valueOf（element））；
}
for（int元素：a2）{
如果（！arrayList.contains（元素））{
add（Integer.valueOf（element））；
}
}
resultArray=arrayList.stream（）.mapToInt（i->i.toArray（）；//仅在Java8中
返回结果数组；
}
Set Set=newhashset（列表1）；
set.addAll（列表2）；
列表联合=新数组列表（集合）；
我希望这个示例将是一个简单的示例。通过两个数组，您肯定会得到数组的并集，而不会出现重复项

private static int[] FindUnionOfTwoArray(int[] array1, int[] array2) {
        Map<Integer,Integer> map=new HashMap<>();
        for (int element : array1) {
            map.put(element, element);
        }
        for (int element : array2) {
            map.put(element, element);
        }
        int[] newArray=new int[map.size()];
        int con=0;
        for(Map.Entry<Integer, Integer> lst:map.entrySet()) {
            newArray[con]=lst.getValue();
            con++;
        }
        return newArray;
    }

私有静态int[]findunionoftwarray（int[]array1，int[]array2）{
Map Map=newhashmap（）；
for（int元素：array1）{
map.put（元素，元素）；
}
for（int元素：array2）{
map.put（元素，元素）；
}
int[]newArray=newint[map.size（）]；
int con=0；
对于（Map.Entry lst:Map.entrySet（））{
newArray[con]=lst.getValue（）；
con++；
}
返回纽瓦拉
import java.util.*;

public class Union {
  // Search Function
  public boolean search(Integer a[], Integer i) {
    for(int k = 0; k < a.length; k++) {
      if(a[k] == i) {
        return true;
      }
    }
    return false;               
  }

  // Union
  public void union(Integer[] a, Integer[] b) {
    Set<Integer> set = new HashSet<Integer>(Arrays.asList(a));
    set.addAll(Arrays.asList(b));
    Integer[] unionArray = set.toArray(new Integer[set.size()]); 
    System.out.println(Arrays.toString(unionArray));
  }

  public static void main(String...s) {
    Integer[] array1 = new Integer[]{1,1,1,4,};
    Integer[] array2 = new Integer[]{1,4,4,4,1,2};
    new Union().union(array1, array2);
  }
}

public class UnionOfArrays 
{


public int[] getUnion(int[] arr1, int[] arr2)
{
    int[] array = MergeSort.mergeArray(arr1, arr2);
    int[] arrReturn = getunique(array);
    return arrReturn;
}   
public int[] getunique(int[] array)
{
    int[] arrTemp = new int[array.length];
    int[] arrReturn;
    int index = 0;
    for (int i = 0; i < array.length; i++)
    {
        Boolean found = false;
        for (int j = 0; j < i; j++)
        {
            if (array[i] == array[j])
            {
                found = true;
                break;
            }
        }
        if (!found)
        {
            arrTemp[index++] = array[i];
        }
    }
    arrReturn = new int[index];
    for (int i = 0; i < index; i++)
    {
        arrReturn[i] = arrTemp[i];
    }
    return arrReturn;
}}

 public static int[] arrayUnion(int a1[], int a2[]){
        int[] resultArray={};
        ArrayList<Integer> arrayList = new ArrayList<Integer>();

        if(a1.length>a2.length){
            resultArray=new int[a1.length];
        }else resultArray=new int[a2.length];

        for(int element : a1){
            arrayList.add(Integer.valueOf(element));

        }
        for(int element:a2){
            if(! arrayList.contains(element)){
                arrayList.add(Integer.valueOf(element));
            }
        }

        resultArray = arrayList.stream().mapToInt(i->i).toArray(); // only in java 8
       return  resultArray;

    }

    Set<String> set = new HashSet<>(list1);
    set.addAll(list2);
    List<String> union = new ArrayList<>(set);

private static int[] FindUnionOfTwoArray(int[] array1, int[] array2) {
        Map<Integer,Integer> map=new HashMap<>();
        for (int element : array1) {
            map.put(element, element);
        }
        for (int element : array2) {
            map.put(element, element);
        }
        int[] newArray=new int[map.size()];
        int con=0;
        for(Map.Entry<Integer, Integer> lst:map.entrySet()) {
            newArray[con]=lst.getValue();
            con++;
        }
        return newArray;
    }

public static int doUnion(int a[], int n, int b[], int m) 
{
        HashSet<Integer> hs = new HashSet<Integer>(); 
          
        for (int i = 0; i < n; i++)  
            hs.add(a[i]);         
        for (int i = 0; i < m; i++)  
            hs.add(b[i]); 
        return hs.size();
}