java 数组、猜数字游戏、随机排名、冒泡排序

 数组

一、静态数组

格式：数据类型[ ]  数组名 = new 数据类型[ ] {元素1，元素2，元素3，...};

例：int[ ]  age = new int[ ] {12,24,35};

简化写法：数据类型[ ]  数组名 = {元素1，元素2，元素3，...};

例：int[ ]  age = {12,24,35};

数组长度：数组名.length     

注意的点：

1、“数据类型[ ]  数组名”也可以写成“数据类型  数组名[ ]”

2、什么类型的数据只能存放什么类型的元素

3、数组一旦定义出来，类型和长度就固定了

二、动态数组

只确定元素的类型和长度，之后在存入具体数据

格式：数据类型[ ] 数组名 = new 数据类型[长度];

例：int[ ] arr = new int[3];

静态数组和动态数组的区别

当前已经知道存入的数据使用静态数组初始化

当前还不清楚存入的数据使用动态数组初始化

int[ ] arr = new int[3]{30,40,50};  这种写法是错误的

不能两种格式混用

//数组
public class biji {
    public static void main(String[] args) {
        //静态数组
        //double[] score = new double[]{99.5,67.5,89.5};
        double[] score ={99.5,67.5,89.5};

//      int[] age = new int[]{15,17,24};
        int[] age = {15,17,24};

//      String[] name = new String[]{"小美","小明"};
        String[] name = {"小美","小明"};

        //数组长度
        System.out.println("数组长度："+name.length);

        System.out.println("--------------------");
        //动态数组初始化
        double[] scores = new double[3];
        //赋值
        scores[0]=99.5;
        System.out.println(scores[0]);//99.5
        System.out.println(scores[2]);//0.0

        String[] names = new String[5];
        names[0]="迪丽热巴";
        names[2]="马尔扎哈";
        System.out.println(names[0]);
        System.out.println(names[1]);
        System.out.println(names[2]);

        //元素默认规则
        //byte、short、char、int、long 默认值是0
        //float、double 默认值是：0.0
        //boolean默认值是：false
        //类、接口、数组、String默认值：null
        System.out.println("--------------------");
        //整型
        int[] num = new int[3];
        System.out.println(num[0]);//0
        System.out.println(num[2]);//0

        //浮点型
        double[] num1 = new double[3];
        System.out.println(num1[0]);//0.0
        System.out.println(num1[2]);//0.0

        //字符型
        char[] ch = new char[5];
        System.out.println((int)ch[0]);
        System.out.println(ch[4]);

        //布尔型
        boolean[] booleans = new boolean[99];
        System.out.println(booleans[0]);//false
        System.out.println(booleans[98]);//false

        System.out.println("--------数组遍历---------");
        int[] arr = {12,24,35,46};
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

    }
}

 猜数字游戏

import java.util.Random;
import java.util.Scanner;

public class lianxi {
    public static void main(String[] args) {
        //猜数字游戏
        //随机生成一个1-100的数字，提示用户猜测，猜测大了就提示大了，猜测小了就提示小了，猜中了就结束游戏

        Random r = new Random();
        Scanner sc = new Scanner(System.in);
        int num = r.nextInt(100) + 1;   //随机生成一个1-100的数字
        while(true){
            System.out.println("请输入猜测的数字(1-100)：");
            int num1 = sc.nextInt();//用户输入数据
            if(num1>num){
                System.out.println("猜大了！");
            }
            else if(num1<num){
                System.out.println("猜小了！");
            }
            else{
                System.out.println("猜对了！");
                break;
            }
        }
    }
}

import java.util.Random;
import java.util.Scanner;

public class lianxi {
    public static void main(String[] args) {
        //生成5个1-20之间的随机数，用户进行猜测，猜中要提示猜中，还要输出数据在数组中第一次出现的位置，并打印数组的内容
        //没有猜中继续进行猜测

        //1、定义一个动态初始化数组存储5个随机数
        int[] num = new int[5];

        //2、生成5个随机数放进数组
        Random r = new Random(); //创建随机数对象
        for (int i = 0; i < num.length; i++) {
            num[i] = r.nextInt(20)+1;//随机数存进数组
        }

        //3、使用一个死循环进行猜测
        Scanner rs = new Scanner(System.in);//创建键盘录入对象
        Out:
        while (true) {
            System.out.println("请您输入一个1-20之间的数进行猜测：");
            int guess = rs.nextInt();
            for (int i = 0; i < num.length; i++) {
                if (guess == num[i]) {
                    System.out.println("恭喜您猜中了！您猜中的数字索引是：" + i);
                    break Out;  //结束整个死循环
                }
            }
            System.out.println("您当前猜测的数据不在数组中，请重新进行猜测！");
        }

        //5、输出数组的5个随机数
        for (int i = 0; i < num.length; i++) {
            System.out.print(num[i] + "\t");
        }
    }
}

随机排名

import java.util.Random;
import java.util.Scanner;

public class lianxi {
    public static void main(String[] args) {
        //键盘录入一组工号，随机输出一组排名
        //1、动态初始化一个数组，存放5个工号
        int[] code = new int[5];

        //2、定义一个循环，存放工号
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < code.length; i++) {
            System.out.println("请输入第" + (i + 1) + "个工号：");
            code[i] = sc.nextInt();
        }

        //3、遍历数组中的每个元素，然后随机生成一个索引，让该元素与随机索引位置的元素进行交换
        Random r = new Random();
        for (int i = 0; i < code.length; i++) {
            int index = r.nextInt(code.length);//随机生成0-4的索引
            //当前数组元素与索引位置的元素交换
            int temp = code[index];
            code[index] = code[i];
            code[i] = temp;
        }

        //4、遍历数组输出随机排名后的工号
        System.out.println("随机排名后的工号是：");
        for (int i = 0; i < code.length; i++) {
            System.out.print(code[i] + "\t");
        }
    }
}

冒泡排序

思想：每次从数组中找出最大值放在数组的后面去

确定总共做几轮：数组长度-1

每轮做几次比较：数组长度-i

当前位置大于后一个位置则进行交换数据

import java.util.Random;
import java.util.Scanner;

public class lianxi {
    public static void main(String[] args) {
        //1、定义一个数组存放需要排序的数据
        int[] arr = {55, 44, 33, 22, 11};

        //2、定义一个循环控制比较的轮数
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                //当前位置的元素与后一个元素比较，大了则交换进行升序排序
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        //遍历数组输出
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }
}

两个数组变量指向同一数组对象 

public class lianxi {
    public static void main(String[] args) {
        //理解两个数组变量指向同一数组对象
        int[] arr1 = {11,12,13};
        //把数组arr1的变量赋值给数组变量arr2
        int[] arr2 = arr1;

        //查看arr1和arr2数组的地址
        System.out.println(arr1);
        System.out.println(arr2);

        arr2[1]=99;
        System.out.println(arr2[1]);

        System.out.println(arr2[0]);
        System.out.println(arr1[1]);
        System.out.println(arr2[2]);
    }
}