Java 将两个数组合并到第三个数组中，并按升序对第三个数组进行排序

我想编写java程序，将两个数组合并到第三个数组中。还要按升序对第三个数组进行排序。但是数字的复制是不允许的1.我怎样才能写这个程序呢。这就是我到目前为止所做的

public class combine {
  public static void main(String[]args){

  int[]a = {1, 2, 3};
  int[]b = {4, 5, 6};
//  int[]c = new int[10];
  int[]c = new int[a.length+b.length];
  int i;
  for(i=0; i<a.length; i++)
     c[i] = a[i];

     for(int j=0; j<b.length; j++)
        c[i++]=b[j];

  for(int k=0; k<c.length; k++)
  System.out.print(c[k]+" ");
}

}   

公共类合并{
公共静态void main（字符串[]args）{
int[]a={1,2,3}；
int[]b={4,5,6}；
//int[]c=新的int[10]；
int[]c=新的int[a.length+b.length]；
int i；
对于（i=0；i您可以将两个数组中的所有数字（或数字）添加到一个树集，然后继续调用
mySet.first（）
并将其添加到结果数组，然后
mySet.remove（mySet.first（））
，直到集为空。因为它是一个树集，所以重复获取并删除第一个（又称最低的）集合中的元素将产生升序

您可以做的另一件事是对两个数组进行排序，然后使用一轮合并排序来组合数组，并检查之前插入的数字是否等于要插入的数字，不做任何操作并跳过该数字。
您可以添加所有数字（或数字）在树集的两个数组中，只需继续调用
mySet.first（）
并将其添加到结果数组中，然后
mySet.remove（mySet.first（））
，直到集为空。因为它是树集，重复获取并移除集中的第一个（又称最低）元素将产生升序

您可以做的另一件事是对两个数组进行排序，然后使用一轮合并排序来组合数组，并检查之前插入的数字是否等于要插入的数字，不做任何操作并跳过该数字。
您可以添加所有数字（或数字）在树集的两个数组中，只需继续调用
mySet.first（）
并将其添加到结果数组中，然后
mySet.remove（mySet.first（））
，直到集为空。因为它是树集，重复获取并移除集中的第一个（又称最低）元素将产生升序

您可以做的另一件事是对两个数组进行排序，然后使用一轮合并排序来组合数组，并检查之前插入的数字是否等于要插入的数字，不做任何操作并跳过该数字。
您可以添加所有数字（或数字）在树集的两个数组中，只需继续调用
mySet.first（）
并将其添加到结果数组中，然后
mySet.remove（mySet.first（））
，直到集为空。因为它是树集，重复获取并移除集中的第一个（又称最低）元素将产生升序

您可以做的另一件事是对两个数组进行排序，然后使用一轮合并排序来组合数组，并检查之前插入的数字是否等于要插入的数字，不要做任何事情并跳过该数字。
首先创建数组：

Integer[] a = new Integer[]{8, 7, 6, 5, 4, 3, 2, 1, 0};
Integer[] b = new Integer[]{0, 1, 1, 2, 3, 5, 8, 13, 21};

将阵列转换为列表以简化处理：

List<Integer> aList = new ArrayList<>(Arrays.asList(a));
List<Integer> bList = Arrays.asList(b);

按升序对列表进行排序：

aList.sort(new Comparator<Integer>() {
    @Override
    public int compare(Integer integer, Integer t1) {
        return integer.compareTo(t1);
    }
});

雷乌斯尔特：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 13, 21]

首先创建阵列：

Integer[] a = new Integer[]{8, 7, 6, 5, 4, 3, 2, 1, 0};
Integer[] b = new Integer[]{0, 1, 1, 2, 3, 5, 8, 13, 21};

将阵列转换为列表以简化处理：

List<Integer> aList = new ArrayList<>(Arrays.asList(a));
List<Integer> bList = Arrays.asList(b);

按升序对列表进行排序：

aList.sort(new Comparator<Integer>() {
    @Override
    public int compare(Integer integer, Integer t1) {
        return integer.compareTo(t1);
    }
});

雷乌斯尔特：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 13, 21]

首先创建阵列：

Integer[] a = new Integer[]{8, 7, 6, 5, 4, 3, 2, 1, 0};
Integer[] b = new Integer[]{0, 1, 1, 2, 3, 5, 8, 13, 21};

将阵列转换为列表以简化处理：

List<Integer> aList = new ArrayList<>(Arrays.asList(a));
List<Integer> bList = Arrays.asList(b);

按升序对列表进行排序：

aList.sort(new Comparator<Integer>() {
    @Override
    public int compare(Integer integer, Integer t1) {
        return integer.compareTo(t1);
    }
});

雷乌斯尔特：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 13, 21]

首先创建阵列：

Integer[] a = new Integer[]{8, 7, 6, 5, 4, 3, 2, 1, 0};
Integer[] b = new Integer[]{0, 1, 1, 2, 3, 5, 8, 13, 21};

将阵列转换为列表以简化处理：

List<Integer> aList = new ArrayList<>(Arrays.asList(a));
List<Integer> bList = Arrays.asList(b);

按升序对列表进行排序：

aList.sort(new Comparator<Integer>() {
    @Override
    public int compare(Integer integer, Integer t1) {
        return integer.compareTo(t1);
    }
});

雷乌斯尔特：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 13, 21]

您可以将a和b合并到临时数组中，然后使用Arrays.sort（temp）；并在temp中执行线性搜索以仅复制c中的唯一项。您可以将a和b合并到临时数组中，然后使用Arrays.sort（temp）；并在temp中执行线性搜索以仅复制c中的唯一项。您可以将a和b合并到临时数组中，然后使用Arrays.sort（temp）；并在temp中进行线性搜索，以仅复制c中的唯一条目。您可以将a和b合并到temp数组中，然后使用数组。排序（temp）；并在temp中进行线性搜索，以仅复制c中的唯一项。请尝试以下代码，在两个数组中添加要设置的值以删除重复项，并使用树集可以获得顺序，然后根据需要填充任何ds

    public static void main(String args[]) {
    Set<Integer> mySet = new TreeSet<Integer>();
    int[] a = { 1, 2, 3, 4 };
    int[] b = { 3, 5, 4, 6 };
    for (int i : a) {
        mySet.add(i);
    }
    for (int i : b) {
        mySet.add(i);
    }
    System.out.println(mySet);
}

publicstaticvoidmain（字符串参数[]）{
设置mySet=newtreeset（）；
int[]a={1,2,3,4}；
int[]b={3,5,4,6}；
对于（int i:a）{
添加（i）；
}
对于（int i:b）{
添加（i）；
}
System.out.println（mySet）；
}

输出：[1,2,3,4,5,6]
尝试以下代码，将两个数组中的值添加到集合中以删除重复项，使用树集合可以获得顺序，然后根据需要填充任何ds

    public static void main(String args[]) {
    Set<Integer> mySet = new TreeSet<Integer>();
    int[] a = { 1, 2, 3, 4 };
    int[] b = { 3, 5, 4, 6 };
    for (int i : a) {
        mySet.add(i);
    }
    for (int i : b) {
        mySet.add(i);
    }
    System.out.println(mySet);
}

publicstaticvoidmain（字符串参数[]）{
设置mySet=newtreeset（）；
int[]a={1,2,3,4}；
int[]b={3,5,4,6}；
对于（int i:a）{
添加（i）；
}
对于（int i:b）{
添加（i）；
}
System.out.println（mySet）；
}

输出：[1,2,3,4,5,6]
尝试以下代码，将两个数组中的值添加到集合中以删除重复项，使用树集合可以获得顺序，然后根据需要填充任何ds

    public static void main(String args[]) {
    Set<Integer> mySet = new TreeSet<Integer>();
    int[] a = { 1, 2, 3, 4 };
    int[] b = { 3, 5, 4, 6 };
    for (int i : a) {
        mySet.add(i);
    }
    for (int i : b) {
        mySet.add(i);
    }
    System.out.println(mySet);
}

publicstaticvoidmain（字符串参数[]）{
设置mySet=newtreeset（）；
int[]a={1,2,3,4}；
int[]b={3,5,4,6}；
对于（int i:a）{
添加（i）；
}
对于（int i:b）{
添加（i）；
}
System.out.println（mySet）；
}

输出：[1,2,3,4,5,6]
尝试以下代码，将两个数组中的值添加到集合中以删除重复项，使用树集合可以获得顺序，然后根据需要填充任何ds

    public static void main(String args[]) {
    Set<Integer> mySet = new TreeSet<Integer>();
    int[] a = { 1, 2, 3, 4 };
    int[] b = { 3, 5, 4, 6 };
    for (int i : a) {
        mySet.add(i);
    }
    for (int i : b) {
        mySet.add(i);
    }
    System.out.println(mySet);
}

publicstaticvoidmain（字符串参数[]）{
设置mySet=newtreeset（）；
int[]a={1,2,3,4}；
int[]b={3,5,4,6}；
对于（int i:a）{
添加（i）；
}
对于