leetcode 350 给定两个数组，编写一个函数来计算它们的交集。

package leetcode.sort;

import java.util.*;
/**
* @Description: 两个数组的交集
 * 给定两个数组，编写一个函数来计算它们的交集。

示例 1:

输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2,2]
示例 2:

输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [4,9]
说明：

输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。
我们可以不考虑输出结果的顺序。
进阶:

1.如果给定的数组已经排好序呢？你将如何优化你的算法？
可以从头开始比较，相同放在交集内，不同比较大小，前后移动指针

2.如果 nums1 的大小比 nums2 小很多，哪种方法更优？
可以使用第一种，将nums1的值当做比较基准，可以减少比较次数

3.如果 nums2 的元素存储在磁盘上，磁盘内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？
将nums1的值当做比较基准，去nums2内的值，取到某处做记录，比较完取交集之后取剩下的值
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/intersection-of-two-arrays-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
* @Param:
* @return:
* @Author: lvhong
* @Date:
* @E-mail lvhong282@163.com
*/
public class lab350 {
    public static void main(String[] args) {
        int[] input1 = { 1,2,2,1};
        int[] input2 = { 2,2};
        System.out.println(merge(input1, input2));

    }
/**
* @Description:时间复杂度为O(n)，空间复杂度为O(n)
* @Param:
* @return:
* @Author: lvhong
* @Date:
* @E-mail lvhong282@163.com
*/
    public static int[] merge(int[] in1, int[] in2) {//方法1：HahsMap依次put每一个num1的值，相同的值value加一   ,最后 LinkedList里面加入判定得到最后的输出，再转化为数组输出
        //HahsMap依次put每一个num1的值，相同的值value加一
        HashMap<Integer, Integer> hashMap = new HashMap<Integer, Integer>();
        for (int number1 : in1) {
            if (hashMap.containsKey(number1)) {
                hashMap.put(number1, hashMap.get(number1) + 1);
            } else {
                hashMap.put(number1, 1);
            }
        }
        //如果第二个数组内的元素出现在第一个数组内，，则为交集元素，放在LinkedList里面，同时将其value减一
        LinkedList<Integer> linkedList = new LinkedList<Integer>();
        for (int number2 : in2) {
            if (hashMap.containsKey(number2) && hashMap.get(number2) > 0) {
                linkedList.add(number2);
                hashMap.put(number2, hashMap.get(number2) - 1);
            }
        }

            //最后将LinkedLst里面的值输出到数组
        int length = linkedList.size();
        int[] out = new int[length];
        for (int i = 0; i < length; i++) {
            out[i] = linkedList.poll();
        }

        return out;
    }
	
    /** 
    * @Description: 时间复杂度为O(nlogn)，额外空间复杂度为O(1) 
    * @Param:  
    * @return:  
    * @Author: lvhong
    * @Date:  
    * @E-mail lvhong282@163.com
    */ 
	public int[] intersect(int[] nums1, int[] nums2) {  //先对数组内的元素排序，可以从头开始比较，相同放在交集内，不同比较大小，前后移动指针
        Arrays.sort(nums1);
        Arrays.sort(nums2);
        List<Integer> list = new ArrayList<Integer>(nums1.length);
        int i=0;
        int j=0;
       for (;i<nums1.length&&j<nums2.length;){
            if(nums1[i]==nums2[j]){
                list.add(nums1[i]);
                i++;
                j++;
            }
            else if (nums1[i]<nums2[j]){
                i++;
            }
            else{
                j++;
            }
        }
        
        int [] out = new int[list.size()];
        int n=0;
        for(Integer number : list){
            out[n++]=number;
        }
        
        
    return out;
    }
}