这听起来类似于我刚刚完成的作业，所以如果它(并且你在我的 class ！)，我不会告诉你使用我们没有涉及的任何术语，因为我知道它可能是令人生畏的试图发现实用的新东西(超出我们的要求) .
首先，设置退出条件 . 正如您已经说过的那样，您必须从现有的ArrayList中创建一个新的ArrayList . 您将从现有ArrayList中删除项目，存储偶数(或奇数)索引的整数，直到列表为空 .
所以你的退出条件是：
if (evenList is Empty)
return evenList;
然后，按照自己的方式完成各个步骤 . 我建议确定你开始使用的数组是否有一个奇数步数，如下所示：
if (evenList has Even Elements)
int holderForIntsAtEvenElements = last evenList EVEN element
注意我们从最后一个元素开始，所以当你走出递归方法时，这将是添加到新ArrayList的最后一个，因此它将按数字顺序排列 . 您可能会发现这篇文章很有意思：What does this boolean return mean?
然后，我们想要从列表中删除最后一个元素，并再次递归调用该方法 .
最后，当我们达到退出条件并开始出现时，我们想要添加我们一直存储到它们的整数，例如：
evenList.add(holderForIntsAtEvenElements);
return evenList;
这并没有解决一个问题，如果列表没有偶数个元素，那么如何处理第一个元素 - 但是，我会让你试着解决它！这是代码和伪代码的良好组合，有望帮助您走上正确的轨道 .

如题， 快速找出数组中出现奇数次的元素。
 
思路： 遍历数组，把数组中的元素保存到hashmap中， key是element的值，value是element出现的次数，保存之前check这个element是否存在，若存在，则将其删除，并不再保存，若不存在，则保存。这样遍历完一次之后，hashmap中保存的都是出现奇数次的元素。
 
有时间再上代码。

记校招笔试大题
题目：创建一个ArrayList数组，数组元素大小范围[0，1024]，数组长度在50万之内。并且创建一个方法，该方法用于对数组中的偶数元素进行删除，保留奇数元素。
代码如下（示例）：
import java.util.Collections;
import java.util.Scanner;
import java.util.ArrayList;

public class Test1 {
	/**
	 * 方法TestArrayList是将传入的ArrayList数组的偶数元素进行删除，然后进行从大到小排序并输出。
	 *
	 * @param a 数组参数
	 */
	public void TestArrayList(ArrayList<Integer> a) {
		//删除数组中偶数的元素(此处有陷阱，进行remove()方法删除元素时，必须倒序删除数组元素)
		for(int i=0;i<a.size();i++){
			if(a.get(i)%2==0)
				a.remove(i--);
		}
		//进行数组从大到小排序
		a.sort(Collections.reverseOrder()); //降序  
		//a.sort(Comparator.naturalOrder()); //引用的是Comparator类，升序操作
		System.out.println(a);

	}

	public static void main(String[] args) throws Exception {
		Test1 t1 = new Test1();
		Scanner sa = new Scanner(System.in);
		ArrayList<Integer> arr = new ArrayList<Integer>();
		System.out.println("请输入数字，数字间用逗号隔开！"); //输入提示

		//1.获取用户输入的数字字符串
		String numlist = sa.nextLine();
		//2.将字符串通过分割字符串变成字符串数组
		String[] slist = numlist.split(",");
		//3.将字符串数组的元素转换类型后插入arr数组
		for (String a1 : slist) {
			int num2 = Integer.parseInt(a1);
			//判断数字大小，范围是[0,1024]
			if (num2 >= 0 && num2 <= 1024) {
				arr.add(num2);
			}

		}
		if (arr.size() > 500000) {
			System.out.println("很抱歉!该数组长度不能超过500000个！");
		} else {
			//执行输出数组
			t1.TestArrayList(arr);
		}

	}
}



总结
这个博客没有啥技术含量，而且也不是最优化代码，如果有更好的代码请大佬们可以给我参考参考。

加油！

算法题：给你一个整形数组，要求删除其中一个元素，使得剩余元素的乘积最大。如何找到这个待删除元素？
​	分析情况：当数组中有负数的情况 和 没有负数的情况


当数组中全是正整型的值 ，就取其中最小的值


当数组中有负数的情况时候

奇数个数的负数

个数为负数，取最小的负数


偶数个数的负数

取正整数最小的值





代码实现
思路： 判断数组中负数的个数
​	1.如果数组中负数的个数是奇数，那么就移除，最大的负数
​	2.如果数组中的负数的个数是全是偶数，那么就移除 最小的负数
​		2-1.  部分是偶数 + 0 也  是 偶数，所以，即还是移除最小的正整数


/**
     * 返回要删除的元素的下标
     *
     * @param nums
     * @return
     */
    public static int findRemoveIndex(int[] nums) {

        // 统计负数的个数
        int negativeCount = 0;

        for (int i = 0; i < nums.length; i++) {
            // 有负数就+1
            if (nums[i] < 0) {
                negativeCount++;
            }
        }

        //根据不同的情况，选择要删除的元素
        int tempIndex = 0;

        if ((negativeCount & 1) == 1) {
            //情况1： 负数个数是奇数,就移除最大的负数
            for (int i = 0; i < nums.length; i++) {

                if (nums[i] < 0) {
                    //解释： 因为是奇数个所以直接取值为负数的 num[i]，减少判断
                    // 如果 tempIndex 即第一个值是整数，那么毫无疑问，就将当前的index,赋给temIndex
                    //  nums[i]当前的负数 与 temPindex的负数比较 最大的负数，就重新复制给tempIndex
                    if (nums[tempIndex] >= 0 || nums[i] > nums[tempIndex]) {
                        tempIndex = i;
                    }

                }

            }
            return tempIndex;
        } else {
            //情况2： 负数个数是偶数
            if (nums.length == negativeCount) {
                // 子情况，所以的元素都是负数
                // 因为是偶数，所以，只需要找出 最小的值，
                for (int i = 0; i < nums.length; i++) {
                    if (nums[i] < nums[tempIndex]) {
                        tempIndex = i;
                    }
                }
                return tempIndex;
            };

            // 部分是偶数是负数 或者 没有负数的情况
            for (int i = 0; i < nums.length; i++) {

                if (nums[i] >= 0) {

                    if (nums[tempIndex] < 0 || nums[i] < nums[tempIndex]) {
                        tempIndex = i;
                    }

                }

            }
            return tempIndex;
        }
    }

3.1 测试方法
  /**
     * 测试下标的值
     */
    @Test
    public void testRemoveIndex(){

        int[] arrays1 = {12,-3,5,-6,7,8,-9,7}; // 应该移除 -3   
        int index = findRemoveIndex(arrays1);
        System.out.println("删除元素的下标：" + arrays1[index]);

        int[] arrays2 = {-12,-3,-5,-6,-7,-8,-9,8}; // 应该移除 -3

         index = findRemoveIndex(arrays2);
        System.out.println("删除元素的下标：" + arrays2[index]);


        int[] arrays3 = {-12,-3,-5,-6,7,8,9,3}; // 应该移除 3

         index = findRemoveIndex(arrays3);
        System.out.println("删除元素的下标：" + arrays3[index]);


    }

3.2 运行结果