数组编码题

1.数组查找操作：定义一个长度为10 的一维字符串数组，在每一个元素存放一个单词；然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个单词就打印出“Yes”，不包含就打印出“No”。

import java.util.Scanner;

public class Test1 {
    // 思路：遍历数组时当有值与输入字符串相同时使用一个boolean记录状态
    public static void main(String[] args) {
        String[] strArr = new String[10];
        strArr[0] = "java";		strArr[1] = "html";
        strArr[2] = "sql";		strArr[3] = "android";
        strArr[4] = "javascript";		strArr[5] = "ruby";
        strArr[6] = "c";
        strArr[7] = "c++";
        strArr[8] = ".net";
        strArr[9] = "ios";
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入需要查找的计算机编程语言:");
        String inputStr = scanner.next();
        boolean flag = false;
        for (String string : strArr) {
            if (string.equals(inputStr)) {
                flag = true;
            }
        }
        if (flag) {
            System.out.println("YES");
        } else {
            System.out.println("NO");
        }
    }
}

2.利用Java的Math类的random()方法，编写函数得到0到n之间的随机数，n是参数。
提示： int num=(int)(n*Math.random());
并找出产生50个这样的随机数中最大的、最小的数，并统计其中大于等于60的有多少个。

public class Test2 {
    public static void main(String[] args) {
        //创建一个长度为50的，每个元素在0-100之间的数组
        int[] arr = getArray(100);
        //遍历数组
        printArr(arr);
        //获取最大值和最小值
        int min = getMin(arr);
        int max = getMax(arr);
        System.out.println("数组中最大值：" + max + "\t数组中最小值：" + min);
        //统计其中大于等于60的元素个数
        int count = count(arr, 60);
        System.out.println("数组中大于或等于60的数有:" + count + " 个");
    }

    //遍历数组
    private static void printArr(int[] arr) {
        System.out.println("输出数组元素");
        for (int i = 0; i < arr.length; i++) {
            if (i % 10 == 0) {
                System.out.println();
            }
            System.out.print(arr[i] + "\t");
        }
    }

    //获取数组最大值
    private static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        return max;
    }

    //获取数组最小值
    private static int getMin(int[] arr) {
        int min = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (min > arr[i]) {
                min = arr[i];
            }
        }
        return min;

    }
    public static int[] getArray(int n) {
        int arr[] = new int[50];
        for (int i = 0; i < 50; i++) {
            arr[i] = (int) (n * Math.random());
        }
        return arr;
    }
    // 统计数组中大于等于60的数量的方法 思路：使用一个int值计数
    public static int count(int[] arr,int elem) {
        int count = 0;
        for (int i : arr) {
            if (i >= elem) {
                count++;
            }
        }
        return count;
    }
}

3.数组逆序操作：定义长度为10的数组，将数组元素对调，并输出对调前后的结果。

public class Test4{
    public static void main(String[] args) {
        //定义一个数组，并进行静态初始化。
        int[] arr = {12,98,50,34,76,87,90,34,67,80};
        //逆序前
        System.out.println("逆序前：");
        printArr(arr);
        //逆序后
        System.out.println("逆序后：");
        reverseArr(arr);
        printArr(arr);
    }
    public static void reverseArr(int[] arr) {
        for(int x=0; x<arr.length/2; x++) {
            int temp = arr[x];
            arr[x] = arr[arr.length-1-x];
            arr[arr.length-1-x] = temp;
        }
    }
    //遍历数组
    public static void printArr(int[] arr) {
        System.out.print("[");
        for(int x=0; x<arr.length; x++) {
            if(x == arr.length-1) { //这是最后一个元素
                System.out.println(arr[x]+"]");
            }else {
                System.out.print(arr[x]+", ");
            }
        }
    }
}

4.合并数组操作：现有如下一个数组：   int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5}   要求将以上数组中值为0的项去掉，将不为0的值存入一个新的数组，生成的新数组为： int newArr [] ={1,3,4,5,6,6,5,4,7,6,7,5}  

public class Test5 {
    public static void main(String[] args) {
        int oldArr[] = { 1, 3, 4, 5, 0, 0, 6, 6, 0, 5, 4, 7, 6, 7, 0, 5 };
        int newArr[] = selectArr(oldArr);
        for (int i : newArr) {
            System.out.print(i+" ");
        }
    }
    // 去掉数组中值为0的元素的方法
    public static int[] selectArr(int[] arr) {
        // 1.计算数组中元素不为0的个数
        int count = 0;
        for (int i : arr) {
            if (i != 0) {
                count++;
            }
        }
        // 2.创建一个新数组,长度为count
        int newArr[] = new int[count];
        // 3.复制不为0的元素到新数组中
        int size = 0;
        for (int i : arr) {
            if (i != 0) {
                newArr[size++] = i;
            }
        }
        return newArr;
    }
}

5.二分法查找操作：使用二分法查找有序数组中元素。找到返回索引，不存在输出-1。

分析：二分法查找的前提是数组有序。

public class BinarySearch {
    public static void main(String[] args) {
        int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        System.out.println(searchLoop(array, 9));
    }
    /**
     * 循环二分查找，返回第一次出现该值的位置
     * @param array 已排序的数组
     * @param findValue   需要找的值
     * @return 值在数组中的位置，从0开始。找不到返回-1
     */
    public static int searchLoop(int[] array, int findValue) {
        // 如果数组为空，直接返回-1，即查找失败
        if (array == null) {
            return -1;
        }
        // 起始位置
        int start = 0;
        // 结束位置
        int end = array.length - 1;
        while (start <= end) {
            // 中间位置
            int middle = (start + end) / 2;
            // 中值
            int middleValue = array[middle];
            if (findValue == middleValue) {
                // 等于中值直接返回
                return middle;
            } else if (findValue < middleValue) {
                // 小于中值时在中值前面找
                end = middle - 1;
            } else {
                // 大于中值在中值后面找
                start = middle + 1;
            }
        }
        // 返回-1，即查找失败
        return -1;
    }
}

6.二维数组遍历求和操作：用二重循环求出二维数组b所有元素的和：
 int[][] b={{11},{21,22},{31,32,33}}

public class Test6 {
    public static void main(String[] args) {
        int sum=0;
        int[][] b={{11},{21,22},{31,32,33}};
        for(int i=0;i<b.length;i++){
            for(int j=0;j<b[i].length;j++){
                sum += b[i][j];
            }
        }
        System.out.println(sum);
    }
}

7. 数组A：1，7，9，11，13，15，17，19；数组b：2，4，6，8，10   

 两个数组合并为数组c，按升序排列。 要求：使用Arrays类的方法快速实现。

import java.util.Arrays;

public class Test7 {
    public static void main(String[] args) {
        int data1[] = new int[] { 1, 7, 9, 11, 13, 17, 19 };
        int data2[] = new int[] { 2, 4, 6, 8, 10 };
        int newArr[] = concat(data1, data2);
        print(newArr);
        Arrays.sort(newArr);
        print(newArr);
    }
    public static int[] concat(int src1[], int src2[]) {
        int len = src1.length + src2.length; // 新数组的大小
        int arr[] = new int[len]; // 新数组
//		int count = 0;
//		for (int i : src1) {
//			arr[count++] = i;
//		}
//		for (int i : src2) {
//			arr[count++] = i;
//		}
        // 还可以通过系统的方法拷贝数组
        System.arraycopy(src1, 0, arr, 0, src1.length); // 拷贝第一个数组
        System.arraycopy(src2,0,arr,src1.length, src2.length); //拷贝第二个数组
        return arr;
    }
    public static void print(int[] temp) {
        for (int x = 0; x < temp.length; x++) {
            System.out.print(temp[x] + "、");
        }
        System.out.println();
    }
}