java学习-Day2

数组：一种容器，可以存储同种数据类型的多个值

数据类型 [] 数组名
数据类型  数组名[]

数组的静态初始化

初始化：在内存中，为数组开辟空间，并将数据存入容器中
完整格式: 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};    
简写格式:数据类型[] 数组名={元素1,元素2,元素3...};

        //存五个学生年龄
        int[] ages = {10,11,12,13,14};
        //存五个学生姓名
        String[] names = {"xt","xy","xz","as","yy"};
        //存五个学生身高
        double[] height = {121,181,124.5,175,183};

索引：下标，从0开始不间断

//获取索引数据
int[] array1 = {1,2,3,4,5};
System.out.println(array1[0]);

//改变索引数据
array1[0] = 100;
System.out.println(array1[0]);     
数组名.length ---数组长度  【遍历数组       数组名.fori】

        //定义1-10的数组，遍历数组得到每一个元素
        //是奇数，将当前数字扩大两倍。是偶数，将当前数字变成1/2
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]%2==0){
                arr[i] = arr[i]/2;
            }else{
                arr[i] = 2*arr[i];
            }
            System.out.println(arr[i]);
        }

数组的动态初始化

动态初始化:初始化时只指定数组长度，由系统为数组分配初始值
格式:数据类型[] 数组名 = new 数据类型[数组长度];

区别

动态初始化：明确元素个数，不明确具体数值

静态初始化：手动指定数组元素，计算数组长度

        //生成10个1-100之间的随机数存入到数组中
        Random r = new Random();
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            int num = r.nextInt(101)+1;
            arr[i] = num;
        }
        //求出所有数据之和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        //统计平均数
        double meanNum = sum/arr.length;
        System.out.println("平均数 "+meanNum);
        //统计有多少数据比平均数小
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]<meanNum){
                count+=1;
            }
            System.out.print(arr[i]+" ");
        }
        System.out.println();
        System.out.println("统计个数 "+count);

        //交换数组 12345--54321
        int[] arr = {1,2,3,4,5};
        System.out.println("交换前");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
        int left = 0;
        int right = arr.length-1;
        while (left<right){
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left+=1;
            right-=1;
        }
        System.out.println();
        System.out.println("交换后");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }

栈和堆

栈内存：程序的主入口（main方法）开始执行时会进栈，代码执行完毕后出栈

堆内存：new出来的东西会在内存中开辟空间并产生地址

方法：程序中最小的执行单元

实际开发中，重复代码和具有独立功能的代码可以抽取到方法中。方法可以提高代码的复用性和代码的可维护性。

最简单的方法定义和调用
public static void 方法名(){
    方法体(打包的代码);
}
调用
方法名()

带参数的方法
public static void 方法名(参数1,参数2,参数3,参数4...){
    方法体(打包的代码);
}

带返回值的方法
public static 返回值类型 方法名(参数1,参数2,参数3,参数4...){
    方法体(打包的代码);
    return 返回值
}

• 方法不调用就不执行
• 方法与方法之间是平级关系，不能互相嵌套
• 方法的编写顺序和执行顺序无关
• 没有返回值的方法可以不写return 语句
• return 语句下面不能编写代码，永远执行不到

方法的重载

在同一个类中，定义了多个同名方法，这些同名方法具有同种功能；每个方法具有不同的参数类型或者参数个数，这些同名方法构成重载关系。

同一个类中，方法名相同，参数不同的方法

return ：和循环无关，和方法有关。表示1结束方法  2返回结果

break：和方法无关，结束循环或者switch

传递基本数据类型时，传递的是真实数据，形参的改变不影响实际参数的值

传递引用数据类型时，传递的时地址值，形参的改变会影响实际参数的值

package Day02;

public class PracticesPrimeNumbers {
    //找算术平方根
    public static int square(int number){
        int root = 0;
        for (int i = 0; i <= number; i++) {
            if(i*i==number){
                root = i;
                break;
            }else if(i*i>number){
                root = i-1;
                break;
            }
        }
        return root;
    }
    //找质数
    public static boolean flag(int number){
        int root = square(number);
        boolean flag = true;
        for (int i = 2; i <= root; i++) {
            if(number%i==0){
                flag = false;
            }
        }

        return flag;
    }
    //判断101-200之间有多少质数，打印出来
    public static void main(String[] args){
        int count = 0;
        for (int i = 101; i < 201; i++) {
            boolean res = flag(i);
            if(res){
                count+=1;
                System.out.println(i+"是质数!");
            }
        }
        System.out.println("一共由有"+count+"个质数");

    }
}

package Day02;

import java.util.Random;

public class PracticesVerificationCode {
    public static void main(String[] args){
        //定义方法产生一个五位验证码
        //验证码大小为5位，前四位为大写字母或者小写字母，最后一位是数字

        //分析
        //方法:在一堆没有规律的数据中随机抽取，可以把这些数据放到数组中，在随机抽取索引

        //1 大小写字母放到数组中
        char[] chs = new char[52];
        for (int i = 0; i < chs.length/2; i++) {
            chs[i] = (char)(65+i);
        }
        int index = 0;
        for (int i = chs.length/2; i < chs.length; i++) {
            chs[i] = (char)(97+index);
            index+=1;
        }

        //2 随机抽取四次
        String res = "";
        Random r = new Random();
        for (int i = 0; i < 4; i++) {
            int num = r.nextInt(chs.length);
            res+=chs[num];
        }

        //3 随机抽取一个0-9的数字
        int number = r.nextInt(10);
        res+=number;
        System.out.println(res);
    }

}

package Day02;

import java.util.Scanner;

public class PracticesJudgesScores {
    public static void main(String[] args){
        //6名评委打分，分数为[0-100]之间的整数
        //选手最后得分为，去掉一个最后高分，去掉一个最低分后4个评委的平均分，请完成上述过程并计算选手得分

        //1 定义一个数组，键盘录入6个选手分数
        int[] scoreArray = scoreArray();
        //2 去掉数组中的最高分和最低分
        int[] score = minMaxScore(scoreArray);
        //3 求出总和，并减去数组中的最高分和最低分
        int sum = 0;
        for (int i = 0; i < scoreArray.length; i++) {
            sum+=scoreArray[i];
        }
        for (int i = 0; i < score.length; i++) {
            sum-=score[i];
            System.out.println(score[i]);
        }

        //4 求出最终分数··
        int scoreFinal = sum/(scoreArray.length-2);
        System.out.println("最后分数为:"+scoreFinal);
    }

    //定义一个数组，键盘录入6个选手分数
    public static int[] scoreArray(){
        int[] scoreArray = new int[6];
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < scoreArray.length;) {
            System.out.println("请输入第"+(i+1)+"个分数[0-100]");
            int score = sc.nextInt();
            if(score>=0&&score<=100){
                scoreArray[i] = score;
                i++;
            }
            else {
                System.out.println("输入错误，重新输入");
            }
        }
        return scoreArray;
    }

    //求最高分最低分方法
    public static int[] minMaxScore(int[] arr){
        int maxScore = arr[0];
        int minScore = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i]>=maxScore){
                maxScore = arr[i];
            }else {
                minScore = arr[i];
            }
        }
        int[] minMaxArray ={maxScore,minScore};
        return minMaxArray;
    }
}

package Day02;

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

        //先得到每位数字，然后对每位数字都加上5，再对10取余，最后将数字反转
        //1983 --- 8346

        //1 把整数里面的每一位放到数组中
        int number = 1983;
        int[] arr = arrNumber(number);

        //2 加密
        int[] numArray = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            numArray[i] = numEncryption(arr[i]);
        }

        //3 反转
        int[] reverA = reverseArray(numArray);

        //4 把数组中的每一位进行拼接
        int indexNumber = 0;
        for (int i = 0; i < reverA.length; i++) {
            indexNumber = indexNumber*10+reverA[i];
        }
        System.out.println(indexNumber);

    }

    //把整数里面的每一位放到数组中
    public static int[] arrNumber(int number){
        int temp = number;
        //1 计算数组长度
        int count = 0;
        while (number!=0){
            number/=10;
            count+=1;
        }
        int[] arr1 = new int[count];
        for (int i = arr1.length-1; i >=0; i--) {
            int num = temp%10;
            temp/=10;
            arr1[i] = num;
        }
        return arr1;

    }

    //加密
    public static int numEncryption(int number){
        number = number+5;
        number = number%10;
        return number;
    }

    //反转
    public static int[] reverseArray(int[] arr){
        int left = 0;
        int right = arr.length-1;
        while(left<right){
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left+=1;
            right-=1;
        }
        return arr;
    }


}

抽奖方法一

package Day02;

import java.util.Random;

public class PracticesGrabPacket {
    public static void main(String[] args){
        //有五个奖金{2,588,888,1000,10000}
        //打印每个奖金，奖金出现顺序随机不重复
        //1 定义数组表示奖金
        int[] oldPrice = {2,588,888,1000,10000};
        //2 定义一个新数组用于存放抽奖结果
        int[] newPrice = new int[oldPrice.length];
        //3 随机抽奖 判断当前随机奖金是否在数组中存在，存在则继续随机抽奖
        Random r = new Random();
        for (int i = 0; i < newPrice.length; ) {
            int number = r.nextInt(oldPrice.length);
            if(flag(newPrice,oldPrice[number])){
                continue;
            }else {
                newPrice[i] = oldPrice[number];
                i++;
            }
        }
        for (int i = 0; i < newPrice.length; i++) {
            System.out.println(newPrice[i]+"元的奖金被抽到");
        }

    }

    public static boolean flag(int[] oldPrice,int num){
        boolean flag = false;
        for (int i = 0; i < oldPrice.length; i++) {
            if(oldPrice[i]==num){
                flag = true;
            }
        }
        return flag;
    }

}

抽奖方法二

package Day02;

import java.util.Random;

public class PracticesGrabPacket2 {
    public static void main(String[] args){
        //有五个奖金{2,588,888,1000,10000}
        //打印每个奖金，奖金出现顺序随机不重复

        //1 打乱奖金池中顺序
        int [] arrPrice = {2,588,888,1000,10000};
        Random r = new Random();
        for (int i = 0; i < arrPrice.length; i++) {
            int num = r.nextInt(arrPrice.length);
            int temp = arrPrice[i];
            arrPrice[i] = arrPrice[num];
            arrPrice[num] = temp;
        }
        //2 遍历奖池
        for (int i = 0; i < arrPrice.length; i++) {
            System.out.println(arrPrice[i]+"元的奖金被抽到");
        }
    }
}