JAVA基础 数组

一、数组概述

　　数组就是用来存储一批同种类型数据的内存区域（可以理解成容器）

二、实例1

package com.hello.array;

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

/*
一、java内存分配介绍
1、方法区：字节码文件加载时进入的内存  .class文件
2、栈：方法运行时所进入的内存 变量也是在这里
3、堆：new出来的东西会在这块内存中开辟空间并产生地址
4、本地方法栈
5、寄存器
二、两个数组变量指向同一个数组对象
 */

public class Array {
    public static void main(String[] args) {
        //静态初始化数组的格式与数组的访问
        int[] ages = {11,15,21,25,31,35};//完整格式：int[] ages = new int[] {11,15,21,25,31,35};
        System.out.println(ages);//打印的是数组存储的地址
        System.out.println(ages[0]);//数组的访问： 数组名称[索引]，  数组的长度：数组名称.length，数组的最大索引：数组名.length-1

        //动态初始化数组：定义数组的时候只确定元素的类型和数组的长度，之后再存入具体数据。
        double[] score = new double[3];//元素默认值：float\double是0.0，byte\short\char\int\long是0，string是null，boolean是false
        score[0] = 89.5;
        System.out.println(score[0]);

        //数组遍历：就是一个一个数据的访问
        //需求1 数组元素求和：某部门5名员工的销售额分别是16、26、36、6、100，请计算出他们部门的销售总额
        int [] money = {16,26,36,6,100};
        int sum = 0;
        for(int i=0;i<money.length;i++){
            sum += money[i];
        }
        System.out.println(sum);

        //需求2 数组求最值
        int[] faceScore = {15,9000,10000,20000,9500,-5};//定义一个静态初始化数组，存储一组颜值
        int max = faceScore[0];//定义一个变量用于存储最大值元素，建议使用第一个元素作为参照
        //遍历数组的每个元素，依次与最大值变量的数据比较，若较大，则替换
        for (int i=0;i<faceScore.length;i++){ //根据实际业务场景，i初始化值应为1，因为15不用跟自己比
            if(faceScore[i]>max){
                max = faceScore[i];
            }
        }
        System.out.println("数组的最大值是:"+max);

        //需求3 猜数字游戏：随机生成1-20之间的5个数，未猜中提示未命中，猜中提示运气不错，并输出该数据第一次出现的位置，且输出全部5个数据，最终结束本游戏
        Random r = new Random();
        int[] luckyArray = new int[5];//定义一个动态初始化的数组存储5个随机的1-20之间的数据
        for(int i=0;i<luckyArray.length;i++){ //动态的生成5个随机数并存储到数组中去
            luckyArray[i] = r.nextInt(20)+1;
            System.out.println(luckyArray[i]);
        }
        Scanner sc = new Scanner(System.in);
        OUT:
        while (true){ //使用一个死循环让用户进行猜测
            System.out.println("请您输入一个1-20之间的整数进行猜测：");
            int guessData = sc.nextInt();
            for (int i=0;i<luckyArray.length;i++) {
                if (guessData == luckyArray[i]) {
                    System.out.println("恭喜您猜中了" + luckyArray[i]);
                    break OUT;//结束了整个死循环，代表游戏结束了（如果只break，只会会结束for循环，并没有结束整个while）
                }
            }
            System.out.println("未猜中，请继续");
        }
        for (int i = 0; i < luckyArray.length; i++) {
            System.out.print(luckyArray[i]+"\t");
        }

        //需求4：键盘录入一组工号，最终要随机输出一组出来作为排名
        Scanner scCode = new Scanner(System.in);
        int [] codes = new int[5];//动态初始化一个数组，存储5个工号
        for (int i = 0; i < codes.length; i++) {  //定义一个循环，依次录入一个工号存入对应的位置
            System.out.println("请输入第"+(i+1)+"个员工的工号");
            codes[i] = scCode.nextInt();
        }

        //遍历数组中的每个元素，然后随机一个索引出来 ，让该元素与随机索引位置处的元素进行交换
        //codes = [11,22,33,44,55]
        Random r1 = new Random();
        for (int i = 0; i < codes.length; i++) {
            //当前遍历的元素值：codes[i]
            //随机一个索引位置出来：codes[index]
            int index = r1.nextInt(codes.length);
            //定义一个临时变量存储index位置处的值
            int temp = codes[index];
            codes[index]=codes[i];
            codes[i] = temp;
        }
        for (int i = 0; i < codes.length; i++) {
            System.out.print(codes[i]+"\t");
        }

        //冒泡排序（要了解比较的轮次，每轮比较的次数）
        //冒泡排序思想：1、从头开始两两比较，把较大的元素与较小的元素进行交换；
        // 2、每轮把当前最大的一个元素存入到数组当前的末尾。
        //冒泡排序的实现步骤：1、定义一个外部循环控制总共需要冒几轮（数组的长度-1）；
        // 2、定义一个内部循环，控制每轮依次往后比较几个位置（数组长度-i-1）；
        // 3、如果当前位置的元素值>后一个位置的元素值，两者交换。
        int [] arr = {5,2,3,1};//定义一个数组，存储一些数据
        //定义一个循环控制比较的轮数
        for(int i=0;i<arr.length-1;i++){
            //i==0  比较的次数3  j= 0  1  2
            //i==1  比较的次数2  j= 0  1
            //i==2  比较的次数1  j= 0
            //定义一个循环控制每轮比较的次数
            for(int j=0;j<arr.length-i-1;j++){
                //判断j当前位置的元素值
                if(arr[j]>arr[j+1]){
                    int tem = arr[j+1];
                    arr[j+1]=arr[j];
                    arr[j]=tem;
                }
            }
        }
        //遍布数组的输出
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
    }
}

 三、实例2

1、ArrayListDemo.java

package com.hello.array;

import java.util.ArrayList;
import java.util.Scanner;

public class ArrayListDemo {
    /*
    目标：创建arraylist对象，代表集合容器，住里面添加元素
     */
    public static void main(String[] args) {
        //创建arraylist集合的对象
        ArrayList list = new ArrayList();
        //添加数据
        list.add("java");
        list.add("sql");
        System.out.println(list);
        //给指定索引位置插入元素
        list.add(1,"sql");
        System.out.println(list);

        //arraylist<E>：其实就是一个泛型类，可以在编译阶段约束集合对象只能操作某种数据类型
        //ArrayList<String>：此集合只能操作字符串类型的元素；ArrayList<integer>：此集合只能操作整数类型的元素
        ArrayList<String> a = new ArrayList<>();
        a.add("李白");
        System.out.println(a);

        /*
        目标：掌握ArrayList集合的常用API
         */
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("HTML");
        list1.add("MyBatis");
        list1.add("java");
        String e = list1.get(1);//获取某个索引位置处的元素值
        System.out.println(e);

        System.out.println(list1.size());//获取集合的大小（元素的个数）

        //完成集合的遍历
        for (int i = 0; i < list1.size(); i++) {
            System.out.println(list1.get(i));
        }

        //删除某个索引位置处的元素值
        System.out.println(list1);
        String e2 = list1.remove(2);
        System.out.println(e2);
        System.out.println(list1);

        //修改某个索引位置处的元素值
        String e3 = list1.set(1,"newMyBetis");
        System.out.println(e3);
        System.out.println(list1);

        /*
        案例一：遍历并删除元素值
        需求：某个班级的考试在系统上进行，成绩大致为：98、77、66、89、79、50、100；现在需要先把成绩低于80分以下的数据去掉
        分析：1、定义ArrayList集合存储多名学员的成绩；2、遍历集合每个元素，如果元素值低于80分，去掉它
         */
        //创建集合对象：存入学生成绩
        ArrayList<Integer> scores = new ArrayList<>();
        scores.add(98);
        scores.add(77);
        scores.add(66);
        scores.add(89);
        scores.add(79);
        scores.add(50);
        scores.add(100);
        System.out.println(scores);

        //遍历集合中的每个元素(从集合后面遍历然后删除，可以避免漏掉元素)
        for (int i = scores.size()-1; i >=0; i--) {
            int score = scores.get(i);
            //判断这个分数是否低于80分，如果低于就从这个集中中删除它
            if(score<80){
                scores.remove(i);
            }
        }
        System.out.println(scores);

        /*
        案例三：影片信息在程序中的表示：某影院系统需要在后台存储上述三部电影，然后依次展示出来
        分析：1、三部电影是3个对象，定义一个电影类，定义一个集合存储电影对象；2、创建3个电影对象，封装相关数据，把3个对象存入到集合中去
         */
        //定义一个电影类：Movie    定义一个ArrayList集合存储这些影片对象
        ArrayList<Movie> movies = new ArrayList<>();//Movie是对象，也是引用类型，即泛型
        //创建影片对象封装电影数据，把对象加入到集合中去
        movies.add(new Movie("《肖生克的救赎》",9.7,"罗宾斯"));
        movies.add(new Movie("《霸王别姬》",9.6,"张国荣"));
        movies.add(new Movie("《阿甘正传》",9.5,"汤克汉姆"));

        System.out.println(movies);//这打印出来的是地址，需要for遍历出来

        //遍历集合中的影片对象并展示出来
        for (int i = 0; i < movies.size(); i++) {
            Movie movie = movies.get(i);//这里的Movie相当于是一个类型，定义一个Movie类型的movie变量来接收遍历出来的数据
            System.out.println("片名："+movie.getName());
            System.out.println("评分："+movie.getScore());
            System.out.println("主演："+movie.getActor());
        }

        /*
        案例四：学生信息系统的数据搜索
        需求：后台程序需要存储学生信息并展示，然后要提供按照学号搜索学生信息的功能
        分析：
        1、定义ArraStudent类，定义arraylist集合存储学生对象信息，并遍历展示出来
        2、提供一个方法，可以接收arraylist集合，和要搜索的学号，返回搜索到的学生对象信息，并展示
        3、使用死循环，让用户可以不停的搜索
         */

        ArrayList<ArraStudent> students = new ArrayList<>();
        students.add(new ArraStudent("2021001","李白",23,"诗歌班"));
        students.add(new ArraStudent("2021002","白居易",23,"诗歌班"));
        students.add(new ArraStudent("2021003","杜甫",23,"诗歌班"));
        students.add(new ArraStudent("2021004","李清照",23,"诗歌班"));
        System.out.println("学号\t\t名称\t\t年龄\t\t班级");

        //遍历集合中的每个学生对象并展示期数据
        for (int i = 0; i < students.size(); i++) {
            ArraStudent s = students.get(i);
            System.out.println(s.getStudyId()+"\t\t"+s.getName()+"\t\t"+s.getAge()+"\t\t"+s.getClassName());
        }
        //让用户不断的输入学号，可以搜索出该学生对象信息并展示出来（独立成方法）
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.println("请您输入要查询的学号：");
            String id = sc.next();
            ArraStudent s = getStudentStudyId(students,id);
            //判断学号是否存在
            if(s==null){
                System.out.println("查无此人");
            }else {
                //找到了该学生对象了，信息如下
                System.out.println(s.getStudyId()+"\t\t"+s.getName()+"\t\t"+s.getAge()+"\t\t"+s.getClassName());
            }
        }
    }
    //根据学号，去集合中找出学生对象并返回
    //方法需要有返回值，返回值类型是ArraStudent
    //ArrayList<ArraStudent>  代表需要接收一个学生类型的集合
    //定义形参变量students，studyId，与上面的是不冲突的
    public static ArraStudent getStudentStudyId(ArrayList<ArraStudent> students,String studyId){
        for (int i = 0; i < students.size(); i++) {
            ArraStudent s = students.get(i);
            if(s.getStudyId().equals(studyId)){
                return s;
            }
        }
        return null;//查无此学号
    }
}

2、ArraStudent.java

package com.hello.array;

public class ArraStudent {
    private String studyId;
    private String name;
    private int age;
    private String className;

    public ArraStudent(String studyId, String name, int age, String className) {
        this.studyId = studyId;
        this.name = name;
        this.age = age;
        this.className = className;
    }

    public String getStudyId() {
        return studyId;
    }

    public void setStudyId(String studyId) {
        this.studyId = studyId;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }
}

3、Movie.java

package com.hello.array;

public class Movie {
    private String name;
    private double score;
    private String actor;

    public Movie(String name, double score, String actor) {
        this.name = name;
        this.score = score;
        this.actor = actor;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public String getActor() {
        return actor;
    }

    public void setActor(String actor) {
        this.actor = actor;
    }
}