JAVA萌新学习day7

JAVA萌新学习day7

//导入一个随机数的包
import java.util.Random;

import java.util.Arrays;

public class CustomArray {
    public static void main(String[] args) {
        System.out.println("自定义的数组模拟类，演示数组和方法参数的使用");

        //创建一个可以保存10个元素的数组
        int[] dataArray = new int[10];

        //创建一个可以产生随机数的对象(某种类型变量)
        Random random = new Random();

        //向数组中保存一些随机数据，用来测试
        for (int i = 0; i < dataArray.length; i++) {
            //给数组中元素随记赋值1-100之间的数
            dataArray[i] = random.nextInt(10)+1;
            //打印数组中每一个元素的值
            System.out.print(dataArray[i] + " ");
        }
        System.out.println();

        //使用系统的数组类的排序方法,对dataArray数组进行排序
        Arrays.sort(dataArray);
        System.out.println("**************************************************************");
        printArray(dataArray);
        System.out.println("**************************************************************");

        //使用系统查找数组类的查找方法,从dataArray数组中查找指定元素.
        int index = Arrays.binarySearch(dataArray , 2);
        if(index >= 0){
            System.out.println("找到了,位置是:" + index);
        }
        else{
            System.out.println("找到了,返回值是:" + index);
        }


        //copyOf
        int[] newArray = Arrays.copyOf(dataArray , 5);
        printArray(newArray);
        System.out.println("**************************************************************");


        //toString
        String str = Arrays.toString(dataArray);
        System.out.println("str:" + str);
        System.out.println("**************************************************************");


        //如何产生指定范围内不重复的随机数
        //比如产生6个1-10之间的随机数，但不能有重复
        //只调六次产生六次不同的随机数

        //打印数组dataArray
        printArray(dataArray);
        printArray(dataArray);
        System.out.println(dataArray[0]);

        //
        int number1 = 10;
        singleTest(number1);
        System.out.println(number1);

        /*
        1.当8种基本类型数据作为方法的参数时,在方法内部对形参的任何修改,不会影响实参的值.
        2.当字符串类型类型数据作为方法的参数时,在方法内部对形参的任何修改,不会影响实参的值.
        3.除这两类情况外的其他类型(即引用类型),在方法内部的对形参的任何修改,会影响实参的值.
        4.我们的数据类型分两大类:一类是基本类型，另一类是引用类型(字符串是引用类型中的特例).
        5.形参:在方法声明时小括号中定义的变量就是形式参数.
        6.实参:在方法调用时传的变量叫实参.
        7.如果方法的形参是引用类型(字符串除外),不要再重新new新对象,对形参赋值,但是可以重新声明
        新对象，作为返回值返回.
        */

        /*
        输出每个元素出现的次数
        比如 1 2 4 2 2 4 1 4 4 2
        输出1出现2次，2出现4次，4出现4次
        */

        //测试:将数组中最大元素和最后一个元素交换位置
        maxNumberToLast(dataArray);
        //调用数组的打印方法将数组内容输出
        printArray(dataArray);


        //调用
        subArray(dataArray);

        //调用
        randomArray();

        testMethod(10,5,6,7,8,9,10);
    }

    //如何产生指定范围内不重复的随机数
    //比如产生6个1-10之间的随机数，但不能有重复

    //功能:产生指定范围内的n个不重复的随机数,保存到数组中
    public static void randomArray() {
        /*
        1.产生的随机数范围是什么
        2.最后需要有n个数产生
        3.n个数之间不能重复
        4.把结果保存到数组中
        */
        //用来保存结果的数组，需要产生6个不重复的随机数
        int[] dataArray = new int[6];
        //易产生的不重复的随机数个数
        int len = 0;

        Random random = new Random();

        while(true){
            //产生1-33的随机数
            int randomNumber = random.nextInt(33)+1;
            //用来标记产生的随机是否有效
            boolean isNormal = true;
            //用刚产生的随机数和数组中每一个元素比较，如果没有像等的，那么这个随机数就是有效的，需要保存到数组中.
            for (int i = 0; i < len; i++) {
                if(randomNumber == dataArray[i]){
                    isNormal = false;
                    //跳出循环
                    break;
                }
            }

            if(isNormal){
                //将随机数保存到数组最后的有效位置
                dataArray[len++] = randomNumber;
            }
            //如果len和数组大小相等,索命所有需要的随机数已经产生,结束循环.
            if (len == dataArray.length){
                break;
            }
        }
        //测试:
        printArray(dataArray);
    }


    //获得指定数组中不重复的元素,并返回这些元素,即返回一个数组类型变量
    public static int[] subArray(int[] array) {
        //定义一个新的数组，用来保存所有不重复的值
        int[] subArray = new int[array.length];//新数组最大长度就是原数组大小
        //subArray数组的真实长度
        int len = 0;
        //对数组array进行遍历
        for (int i = 0; i < array.length; i++) {
            /*
            用当前位置的元素和新数组的每一个元素比较,如果都不相等,说明
            这个元素第一次出现，需要保存到新数组中
            */
            boolean isExist = true;//假设存在
            for (int j = 0; j < len; j++) {
                if (array[i] == subArray[j]){
                    isExist = false;
                }
            }
            //说明这个元素第一次出现，需要保存到新数组中
            if(isExist){
                subArray[len++] = array[i];

            }
        }
        //将不重复元素的数组内容打印.
        printArray(subArray);
        //返回不重复元素所在的数组.
        return subArray;
    }

    //测试基本数型参数传递，在方法内部对参数值修改
    public static void singleTest(int number) {
        number = 100;
    }

    //将数组中元素的最大值和最后一个元素交换位置
    public static void maxNumberToLast(int[] array) {
        
        //如果数组大小小于2
        if (array.length < 2){
            //什么都不做
            return;
        }
        
        int maxNumber = array[0];
        //最大值在原数组中的下标
        int maxIndex = 0;
        for (int i = 0; i < array.length; i++) {
            if (maxNumber < array[i]){
                maxNumber = array[i];
                //保存最大值所在的下标
                maxIndex = i;
            }
        }
        //完成最大值和最后一个元素的交换
        int tempNumber = array[array.length-1];
        array[array.length-1] = maxNumber;
        array[maxIndex] = tempNumber;
    }

    //打印指定数组的内容
    public static void printArray(int[] array) {

        for (int i = 0; i < array.length; i++) {

            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

    //声明一个变参的方法,声明语法为:类型后面加三个点 ... 后面是正常的变量名
    /*
    1.一个方法只能有一个变参.
    2. 变参需要是方法的最后一个参数.
    */
    public static void testMethod(int a, int...arr){
        System.out.println("a=" + a);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(i + "=" + arr[i]);
        }
    }


}