javaSE基础入门知识笔记2

编程训练

案例一、买飞机票

package org.example.demo;

import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) {
        //目标：完成买飞机票的价格计算
        Scanner sc=new Scanner(System.in);
        System.out.println("请您输入机票的原价：");
        double money=sc.nextDouble();
        System.out.println("请您输入机票的月份（1-12）：");
        int month=sc.nextInt();
        System.out.println("请您输入机票的仓位类型：");
        String type=sc.next();
        //调用方法计算最终价格
        money=calc(money,month,type);
        System.out.println("机票优惠后的价格为："+money);
    }
    //计算最终的价格
    public static double calc(double money,int month,String type){
        if(month>=5&&month<=10){
            //旺季
            switch (type){
                case "头等舱":
                    money *=0.9;
                    break;
                case "经济舱":
                    money *=0.85;
                    break;
                default:
                    System.out.println("您输入的仓位有问题~~~");
                    money=-1;
            }
        }else if (month==11||month==12||month>=1&&month<=4){
            //淡季
            switch (type){
                case "头等舱":
                    money *=0.7;
                    break;
                case "经济舱":
                    money *=0.65;
                    break;
                default:
                    System.out.println("您输入的仓位有问题~~~");
                    money=-1;
            }
        }else {
            System.out.println("您输入的月份有误~~~~");
            money=-1;
        }
        return money;
    }
}

案例二：找素数

package org.example.demo;

public class Test2 {
    //需求：找出101-200之间的素数并输出
    public static void main(String[] args) {
        for (int i = 101; i < 200; i++) {
            //信号为：标记
            boolean flag=true;//一开始认为他是一个素数
            for (int j = 2; j < i/2; j++) {
                if (i%j==0){
                    flag=false;
                    break;
                }
            }
            //输出素数
            if (flag){
                System.out.print(i+"\t");
            }
        }
    }
}

案例三：开发验证码

package org.example.demo;

import java.util.Random;

public class Test3 {
    //需求：随机产生5位数的验证码，包括数字，大写字母，小写字母
    public static void main(String[] args) {
        //调用生成验证码的方法产生随机验证码
        String code=createCode(5);
        System.out.println("验证码是："+code);
    }
    public static String createCode(int n){
        String code="";
        Random r=new Random();
        for (int i = 0; i < n; i++) {
            //先生成一个随机数，代表随机数的类型（0：大写字母，1：小写字母，2：数字）
            int type=r.nextInt(3);
            switch (type){
                case 0:
                    //大写字母（A：65-Z：65+25）
                    char ch= (char) (r.nextInt(25)+65);
                    code+=ch;
                    break;
                case 1:
                    //小写字母（a：97，A：97+25）
                    char ch1= (char) (r.nextInt(25)+97);
                    code+=ch1;
                    break;
                case 2:
                    //数字
                    code +=r.nextInt(10);
                    break;
            }
        }
        return code;
    }
}

注意String a=null和 String =""的区别
区别

案例四：数组的复制

package org.example.demo;

public class Test4 {
    //需求：把一个数组复制到另一个数组中去
    public static void main(String[] args) {
        int[] arr1 = {11, 22, 33, 44};
//        int[] arr2=arr1;//这不是数组的复制
        int[] arr2 = new int[arr1.length];
        copy(arr1,arr2);
        printArray(arr1);
        printArray(arr2);
    }

    public static void printArray(int[] arr) {
        //数组的遍历
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(i==arr.length-1?arr[i]:arr[i]+", ");
        }
        System.out.println("]");
    }

    public static void copy(int[] arr1, int[] arr2) {
        //正式完成数组的复制
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }
    }
}

案例5：评委打分

package org.example.demo;

import java.util.Scanner;

public class Test5 {
    //评委打分
    public static void main(String[] args) {
        int[] scores = new int[6];
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < scores.length; i++) {
            System.out.println("请录入第"+(i+1)+"个评委的分数：");
            scores[i] = sc.nextInt();
        }
        int max=scores[0];
        int min=scores[0];
        int sum=0;
        for (int i = 0; i < scores.length; i++) {
            if (max<scores[i]){
                max=scores[i];
            }
            if (min>scores[i]){
                min=scores[i];
            }
            sum +=scores[i];
        }
        System.out.println("最高分是："+max);
        System.out.println("最低分是："+min);
        double average=(sum-max-min)*1.0/(scores.length-2);
        System.out.println("选手最终得分是："+average);
    }
}

案例六：数字加密

package org.example.demo;

import java.util.Scanner;

public class Test6 {
    //数据加密
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入您要加密的密码长度：");
        int length = sc.nextInt();
        int[] arr = new int[length];
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请您输入第" + (i + 1) + "个密码数字");
            arr[i] = sc.nextInt();
        }
        //打印所得的密码
        printArray(arr);
        //密码加密
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (arr[i] + 5) % 10;
        }
        for (int i = 0, j = arr.length - 1; i < j; i++,j--) {
            int temp=arr[j];
            arr[j]=arr[i];
            arr[i]=temp;
        }
        //打印加密后数组
        System.out.println("加密后的数组内容为：");
        printArray(arr);
    }

    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ", ");
        }
        System.out.println("]");
    }

}

加密也是解密的过程

案例7：双色球系统的开发

package org.example.demo;

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

/**
 * 模拟双色球
 */
public class Test7 {
    public static void main(String[] args) {
        int[] luckNumber = createLuckNumber();
        //录入用户号码
        int[] userNumber = userInputNumber();
        //判断中奖情况
        System.out.println("中奖号码是：");
        printArray(luckNumber);
        System.out.println("您投注的号码是：");
        printArray(userNumber);
        judge(luckNumber,userNumber);
    }

    //打印数组元素
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {

            System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ", ");

        }
        System.out.println("]");
    }

    //获得双色球的随机号码
    public static int[] createLuckNumber() {
        //随机前六个不重复的号码为一个数组
        int[] numbers = new int[7];
        Random r = new Random();
        for (int i = 0; i < numbers.length - 1; i++) {
            while (true) {
                //先认为他是不重复的
                boolean flag = true;
                //红球号码为1-33
                int data = r.nextInt(33) + 1;
                for (int j = 0; j < i; j++) {
                    if (data == numbers[j]) {
                        flag = false;
                        break;
                    }
                }
                if (flag == true) {
                    numbers[i] = data;
                    break;
                }
            }
        }
        //随机一个蓝色的球的号码（1-16）
        numbers[numbers.length - 1] = r.nextInt(16) + 1;
        return numbers;
    }

    //用户输入的选号
    public static int[] userInputNumber() {
        int[] numbers = new int[7];
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < numbers.length - 1; i++) {
            System.out.println("请您输入第" + (i + 1) + "个红球号码（1-33），要求不重复");

            int data = sc.nextInt();
            numbers[i] = data;
        }
        //输入一个蓝球号码
        System.out.println("请您输入蓝球号码（1-16）：");
        numbers[numbers.length - 1] = sc.nextInt();
        return numbers;
    }

    //判断中奖情况
    public static void judge(int[] luckNumber, int[] userNumber) {
        //判断红球和蓝球各命中几个
        int redHitNumber = 0;
        int blueHitNumber = 0;
        //判断红球命中个数
        for (int i = 0; i < userNumber.length - 1; i++) {
            for (int j = 0; j < luckNumber.length - 1; j++) {
                if (userNumber[i] == luckNumber[j]) {
                    redHitNumber++;
                    break;
                }
            }
        }
        //判断蓝球命中个数
        blueHitNumber = userNumber[userNumber.length - 1] == luckNumber[luckNumber.length - 1] ? 1 : 0;
        System.out.println("您命中的红球个数是："+redHitNumber);
        System.out.println("您命中蓝球的个数是："+blueHitNumber);
        //判断中奖情况
        if(blueHitNumber==1&&redHitNumber<3){
            System.out.println("恭喜您，中了5元小奖！");
        }else if (blueHitNumber==1&&redHitNumber==3||blueHitNumber==0&&redHitNumber==4){
            System.out.println("恭喜您，中了10元奖金！");
        }else if (blueHitNumber==1&&redHitNumber==4||blueHitNumber==0&&redHitNumber==5){
            System.out.println("恭喜您，中了200元奖金！");
        }else if (blueHitNumber==1&&redHitNumber==5){
            System.out.println("恭喜您，中了3000元奖金！");
        }else if (blueHitNumber==0&redHitNumber==6){
            System.out.println("恭喜您，中了500万大奖！");
        }else if (blueHitNumber==1&redHitNumber==6){
            System.out.println("恭喜您，中了1000万元巨奖！可以享受人生");
        }else {
            System.out.println("很遗憾，您没有中奖~~");
        }
    }
}

面向对象

设计对象、注意事项

package org.example.createObject;

public class Car {
    String name;
    double price;
    public void start(){
        System.out.println(name+"启动了");
    }
    public void run(){
        System.out.println("价格为"+price+"万的"+name+"汽车时速很快");
    }
}

package org.example.createObject;

/**
 * 学会设计对象并使用
 */
public class Test1 {
    public static void main(String[] args) {
        Car c=new Car();
        c.name="宝马";
        c.price=78.2;
        c.start();
        c.run();
        System.out.println("================");
        Car c2=new Car();
        c2.name="奔驰";
        c2.price=223;
        c2.start();
        c2.run();
    }
}

内存机制

面向对象实战：购物车案例

package org.example.demo;

import java.util.Scanner;

public class ShopCarTest {
    public static void main(String[] args) {
        //定义购物车对象，使用数组表示
        Goods[] shopCar=new Goods[100];
        OUT:
        while (true) {
            System.out.println("请您选择如下命令进行操作：");
            System.out.println("添加商品到购物车：add");
            System.out.println("查询购物车商品展示：query");
            System.out.println("修改商品购买数量：update");
            System.out.println("结算购买商品的金额：pay");
            System.out.println("退出命令为：exit");
            System.out.println("请您输入命令：");
            Scanner sc=new Scanner(System.in);
            String commend=sc.next();
            switch (commend){
                case "add":
                    //添加商品到购物车
                    addGoods(shopCar);
                    break;
                case "query":
    //                查询购物车商品展示
                    queryGoods(shopCar);
                    break;
                case "update":
                    updateGoods(shopCar);
    //                修改商品购买数量
                    break;
                case "pay":
                     pay(shopCar);
    //                修改商品购买数量
                    break;
                case "exit":
                    break OUT;
                default:
                    System.out.println("命令输入错误！");
            }
        }
    }

    public static void pay(Goods[] shopCar) {
        double money=0;
        for (int i = 0; i < shopCar.length; i++) {
            Goods g=shopCar[i];
            if (g!=null){
                money +=(g.buyNumber*g.price);
            }else {
                break;
            }
        }
        System.out.println("所有购物车商品的总价格为："+money);
    }

    public static void updateGoods(Goods[] shopCar) {
        Scanner sc=new Scanner(System.in);
        //让用户输入id,根据id返回要修改的商品对象
        while (true) {
            System.out.println("请您输入要修改的商品id：");
            int id=sc.nextInt();
            Goods g=getGoodById(shopCar,id);
            if(g==null){
                System.out.println("对不起，您还没有购买过该商品！");
            }else {
                System.out.println("请您输入该商品要购买的数量：");
                int buyNumber=sc.nextInt();
                g.buyNumber=buyNumber;
                System.out.println("修改完成！");
                queryGoods(shopCar);
                break;
            }
        }
    }
    public static Goods getGoodById(Goods[] shopCar,int id){
        for (int i = 0; i < shopCar.length; i++) {
            Goods g=shopCar[i];
            if (g!=null){
                if (id==g.id){
                    return g;
                }
            }else {
                return null;
            }
        }
        return null;
    }

    public static void queryGoods(Goods[] shopCar) {
        System.out.println("=============查询购物车信息如下=============");
        System.out.println("编号\t\t名称\t\t\t价格\t\t购买数量");
        for (int i = 0; i < shopCar.length; i++) {
            Goods g=shopCar[i];
            if(g!=null){
                //输出商品内容
                System.out.println(g.id+"\t\t"+g.name+"\t\t\t"+g.price+"\t\t"+g.buyNumber);
            }else {
                break;
            }
        }
    }

    public static void addGoods(Goods[] shopCar) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请您录入添加商品的id（不重复）：");
        int id=sc.nextInt();
        System.out.println("请您录入添加商品的名称：");
        String name=sc.next();
        System.out.println("请您录入添加商品的价格：");
        Double price=sc.nextDouble();
        System.out.println("请您录入添加商品的购买数量：");
        int buyNumber=sc.nextInt();
        Goods g=new Goods();
        g.id=id;
        g.name=name;
        g.price=price;
        g.buyNumber=buyNumber;
        for (int i = 0; i < shopCar.length; i++) {
            if(shopCar[i]==null){
                shopCar[i]=g;
                break;
            }
        }
        System.out.println("您已经添加了"+name+"商品到购物车中了");
    }
}

package org.example.demo;

public class Goods {
    int id;//商品id
    String name;//商品名称
    double price;//商品价格
    int buyNumber;//购买数量
}

面向对象：构造器、this

this关键字是什么

• 可以出现在构造器、方法中
• 代表当前对象的地址。
  

package org.example.thisdemo;

/**
 * 理解this关键字的作用
 */
public class Test1 {
    public static void main(String[] args) {
        Car c=new Car();
        c.run();
        System.out.println(c);
        System.out.println("================");
        Car c1=new Car("奔驰",678.3);
        System.out.println(c1.name);
        System.out.println(c1.price);
        c1.goWith("宝马");
    }
}

package org.example.thisdemo;

public class Car {
    String name;
    double price;
    public Car(){
        System.out.println("无参构造器中的this："+this);
    }
    public Car(String name,double price){
        this.name=name;
        this.price=price;
    }
    public void goWith(String name){
        System.out.println(name+"和"+this.name+"正在比赛");

    }
    public void run(){
        System.out.println("方法中的this:"+this);
    }
}

封装

面向对象的三大特征：封装，继承，多态。
封装：告诉我们，如何正确设计对象的属性和方法。
封装的原则：对象代表什么，就得封装对应的数据，并提供数据对应的行为。

如何进行更好的封装：

• 一般建议对成员变量使用private(私有、隐藏)关键字修饰进**（private修饰的成员只能在当前类中访问）。**
• 为每个成员变量提供配套public修饰的的getter、setter方法暴露其取值和赋值

标准JavaBean

package org.example.thisdemo;

/**
 * 一个标准的javaBean
 */
public class User {
    String name;
    double height;
    double salary;

    public User() {
    }

    public User(String name, double height, double salary) {
        this.name = name;
        this.height = height;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

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

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

成员变量和局部变量的区别

面向对象综合案例：模仿电影信息展示

package org.example.demo;

public class Test1 {
    public static void main(String[] args) {
        Movie[] movies=new Movie[3];
        movies[0]=new Movie("流浪地球",9.2,"吴京");
        movies[1]=new Movie("我和我的父辈",9.4,"吴京");
        movies[2]=new Movie("扑水少年",9.5,"王川");
        for (int i = 0; i < movies.length; i++) {
            Movie m=movies[i];
            System.out.println("电影名："+m.getName());
            System.out.println("评分："+m.getScore());
            System.out.println("主演："+m.getActor());
            System.out.println("======================");
        }
    }
}

package org.example.demo;

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

    public Movie() {
    }

    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;
    }
}

String、ArrayList学习

String概述、对象创建原理

1、字符串对象的特点有哪些？

• 双引号创建的字符串对象，在字符串常量池中存储同一个。
• 通过new构造器创建的字符串对象，在堆内存中分开存储。

String类常见面试题

String类常用API

字符串的内容比较API

==进行字符串比较时会比较内存地址
字符串的equals方法只会比较内容是否一致

package org.example.string;

import java.util.Scanner;

public class StringEqualsDemo2 {
    public static void main(String[] args) {
        //正确的登录名和密码
        String okName="admin";
        String okPassword="password";
        //用户输入的用户名和密码
        System.out.println("请您输入正确的用户名和密码：");
        Scanner sc=new Scanner(System.in);
        System.out.println("请您输入用户名：");
        String name=sc.next();
        System.out.println("请您输入密码：");
        String password=sc.next();
        if(okName.equals(name)&&okPassword.equals(password)){
            System.out.println("登录成功");
        }else {
            System.out.println("用户名或密码错误");
        }
        //忽略大小写的比较内容API一般用于：验证码
        
    }
}

遍历、替换、截取、分割操作

package org.example.string;

public class StringAPIOtherDemo {
    public static void main(String[] args) {
//        public int length​()			返回此字符串的长度
        String name = "我爱你中国love";
        System.out.println(name.length());
//        public char charAt​(int index)		获取某个索引位置处的字符
        char c = name.charAt(1);
        System.out.println(c);
        System.out.println("============遍历字符串中的每个元素=========");
        for (int i = 0; i < name.length(); i++) {
            System.out.print(name.charAt(i) + "\t");
        }
//        public char[] toCharArray​()：		将当前字符串转换成字符数组返回
        char[] chars = name.toCharArray();
        System.out.println();
        System.out.println("=======================");
        for (int i = 0; i < chars.length; i++) {
            System.out.print(chars[i] + "\t");
        }
//        public String substring(int beginIndex, int endIndex) 		根据开始和结束索引进行截取，得到新的字符串（包前不包后）
        String name2 = "java是最厉害的编程语言";
        System.out.println();
        System.out.println(name2.substring(0, 9));
//        public String substring(int beginIndex) 		从传入的索引处截取，截取到末尾，得到新的字符串
        System.out.println(name2.substring(4));
//        public String replace(CharSequence target, CharSequence replacement) 		使用新值，将字符串中的旧值替换，得到新的字符串
       /* String name3 = "金三胖是最厉害的80后，金三胖棒棒的，我最爱金三胖";
        System.out.println(name3.replace("金三胖","***"));
        //contain方法的使用
        System.out.println(name3.contains("金三胖"));
        System.out.println(name3.contains("棒棒"));
        //startWith方法的使用
        System.out.println(name3.startsWith("金三胖"));
        System.out.println(name3.startsWith("我"));
//        public String[] split(String regex) 		根据传入的规则切割字符串，得到字符串数组返回
*/
        String name4="王宝强,刘亦菲,王冰冰";
        String[] names=name4.split(",");
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);
        }
    }
}

String案例：验证码、登录、隐私号码

package org.example.string;

import java.util.Random;

/*
        生成验证码
 */
public class StringExec3 {
    public static void main(String[] args) {
        String data = "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890";
        String codes = "";
        Random r = new Random();
        for (int i = 0; i < 5; i++) {
            int index = r.nextInt(data.length());
            codes +=data.charAt(index);
        }
        System.out.println(codes);
    }
}

package org.example.string;

import java.util.Scanner;

/**
 * 模拟登录
 */
public class StringExec4 {
    public static void main(String[] args) {
        String okLoginName = "admin";
        String okPassword = "password";
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            System.out.println("请您输入用户名：");
            String name = sc.next();
            System.out.println("请您输入密码：");
            String password = sc.next();
            if (okLoginName.equals(name) && okPassword.equals(password)) {
                System.out.println("登录成功~~");
                break;
            } else {
                System.out.println("您输入的用户名或密码错误，您还有" + (2 - i) + "次机会");
            }
        }
    }
}

package org.example.string;

import java.util.Scanner;

/**
 * 手机号码中间四位屏蔽
 */
public class StringExec5 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请您输入您的手机号");
        String tel=sc.next();
        String before=tel.substring(0,3);
        String after=tel.substring(7);
        String printTel=before+"****"+after;
        System.out.println(printTel);
    }
}

ArrayList学习

ArrayList的使用

package org.example.arraylist;

import java.util.ArrayList;

public class ArrayListDemo1 {
    public static void main(String[] args) {
        ArrayList list=new ArrayList();
        //添加不同类型元素
        list.add("java");
        list.add("学习");
        list.add(34);
        list.add(78.9);
        System.out.println(list.add('中'));
        System.out.println(list);

        //给指定位置索引插入元素
        list.add(1,"MySQL");
        System.out.println(list);

        //使用泛型约束ArrayList集合的使用类型
        ArrayList<String> list1=new ArrayList<>();
        list1.add("宝马");
        list1.add("奔驰");
        System.out.println(list1);
    }
}

package org.example.arraylist;

import java.util.ArrayList;

public class ArrayListDemo2 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        list.add("java");
        list.add("MYSQL");
        list.add("HTML");
        list.add("日历");
        list.add("结婚");
        //获取某个索引位置处的元素值
        System.out.println(list.get(3));

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

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

        //删除集合某个索引位置处的元素值，并返回该元素值
        System.out.println(list);
        System.out.println(list.remove(2));

        //删除某个元素值，成功返回true(只删除第一次出现的，后面若是有也不删除）
        System.out.println(list.remove("java"));

        //修改某个索引位置处的元素值
        System.out.println(list.set(2,"离婚"));
        System.out.println(list);
    }
}

集合案例：ArrayList遍历删除，存对象，搜索

package org.example.arraylist;

import java.util.ArrayList;

public class ArrayListTest3 {
    public static void main(String[] args) {
        //目标：删除并遍历元素
        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);
        //删除80分以下的成绩
        //错误代码
//        for (int i = 0; i < scores.size(); i++) {
//            int score=scores.get(i);
//            if (score<80){
//                scores.remove(i);
//            }
//        }
//        System.out.println(scores);
        //完美方案之一
        /*for (int i = 0; i < scores.size(); i++) {
            int score=scores.get(i);
            if (score<80){
                scores.remove(i);
                i--;
            }
        }
        System.out.println(scores);*/
        
        //完美方案之二：倒着从后往前删
        for (int i = scores.size()-1; i >= 0; i--) {
            int score=scores.get(i);
            if (score<80){
                scores.remove(i);
            }
        }
        System.out.println(scores);
    }
}

package org.example.arraylist;

import java.util.ArrayList;

public class ArrayListTest4 {
    public static void main(String[] args) {
        //目标：理解ArrayList集合存储自定义类型的对象
        ArrayList<Movie> movies=new ArrayList<>();
        Movie m1=new Movie("肖申克的救赎",9.7,"罗宾斯");
        Movie m2=new Movie("霸王别姬",9.4,"张国荣");
        Movie m3=new Movie("阿甘正传",9.7,"汤姆.汉克斯");
        movies.add(m1);
        movies.add(m2);
        movies.add(m3);
        System.out.println(movies);

        for (int i = 0; i < movies.size(); i++) {
            Movie m=movies.get(i);
            System.out.println("电影名称："+m.getName()+"         电影评分："+m.getScore()+"     电影主演："+m.getActor());
            System.out.println("======================================================");
        }
    }
}

package org.example.arraylist;

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

public class ArrayListTest5 {
    public static void main(String[] args) {
        //需求：展示信息，并按照学号进行搜索
        ArrayList<Student> students=new ArrayList<>();
        students.add(new Student("20180302","叶孤城",23,"护理一班"));
        students.add(new Student("20180303","东方不败",23,"推拿二班"));
        students.add(new Student("20180304","西门吹雪",23,"车辆五班"));
        students.add(new Student("20180305","梅超风",23,"车俩五班"));
        //学生信息展示
        for (int i = 0; i < students.size(); i++) {
            Student s=students.get(i);
            System.out.println(s.getStuNumber()+"\t"+s.getName()+"\t"+s.getAge()+"\t"+s.getClassName());
        }
        //定义方法完成学生搜索功能
        Scanner sc=new Scanner(System.in);
        while (true) {
            System.out.println("请您输入要查询的学生学号：");
            String stuNumber=sc.next();
            Student s=getStudentById(students,stuNumber);
            if (s==null){
                System.out.println("查无此人");
            }else {
                System.out.println("该学生为："+s.getClassName()+"的"+s.getName());
            }
        }
    }

    /**
     * 按照学号搜索学生的方法
     * @param students
     * @param stuNumber
     * @return
     */
    public static Student getStudentById(ArrayList<Student> students,String stuNumber){
        for (int i = 0; i < students.size(); i++) {
            Student s=students.get(i);
            if (s.getStuNumber().equals(stuNumber)){
                return s;
            }
        }
        return null;
    }
}

package org.example.arraylist;

public class Student {
    private String stuNumber;
    private String name;
    private int age;
    private String className;

    public Student() {
    }

    public Student(String stuNumber, String name, int age, String className) {
        this.stuNumber = stuNumber;
        this.name = name;
        this.age = age;
        this.className = className;
    }

    public String getStuNumber() {
        return stuNumber;
    }

    public void setStuNumber(String stuNumber) {
        this.stuNumber = stuNumber;
    }

    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;
    }
}

ATM系统

package org.example;

public class Account {
    private String cardId;
    private String username;
    private String password;
    private double money;
    private double quotaMoney;

    public Account() {
    }

    public Account(String cardId, String username, String password, double money, double quotaMoney) {
        this.cardId = cardId;
        this.username = username;
        this.password = password;
        this.money = money;
        this.quotaMoney = quotaMoney;
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public double getQuotaMoney() {
        return quotaMoney;
    }

    public void setQuotaMoney(double quotaMoney) {
        this.quotaMoney = quotaMoney;
    }
}

package org.example;

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

public class Test1 {
    public static void main(String[] args) {
        ArrayList<Account> accounts=new ArrayList<>();
        Scanner sc=new Scanner(System.in);
        while (true) {
            System.out.println("================欢迎登录兰州ATM银行系统==============");
            System.out.println("1.登录账号");
            System.out.println("2.注册开号");
            System.out.println("请您选择操作：");
            int command=sc.nextInt();
            switch (command){
                case 1:
                    //登录验证
                    login(accounts,sc);
                    break;
                case 2:
                    //注册开户
                    register(accounts,sc);
                    break;
                default:
                    System.out.println("您输入的命令有误！！！");
            }
        }
    }

    /**
     * 登录账号操作
     * @param accounts
     * @param sc
     */
    private static void login(ArrayList<Account> accounts, Scanner sc) {
        System.out.println("===============系统登录页面====================");
        if (accounts.size()==0){
            System.out.println("对不起，当前系统中还没用用户，请您先选择开户");
            return;
        }
        while (true) {
            System.out.println("请您输入您的卡号：");
            String cardId = sc.next();
            Account account = getAccountByCardId(cardId, accounts);
            if (account!=null){
                System.out.println("请您输入登录密码：");
                String password=sc.next();
                if (password.equals(account.getPassword())){
                    System.out.println("恭喜您登录成功，"+account.getUsername()+"先生/女士,您的卡号为"+account.getCardId());
                    //展示登录后的操作页
                    showUserCommand(sc,account,accounts);
                    return;
                }
                else {
                    System.out.println("您输入的密码不正确！！！");
                }
            }else {
                System.out.println("您输入的卡号不正确，请您重新输入");
            }
        }
    }

    /**
     * 登录后的操作页展示
     */
    private static void showUserCommand(Scanner sc,Account account,ArrayList<Account> accounts) {
        while (true) {
            System.out.println("=================用户操作页==================");
            System.out.println("1.查询账户");
            System.out.println("2.存款");
            System.out.println("3.取款");
            System.out.println("4.转账");
            System.out.println("5.修改密码");
            System.out.println("6.退出");
            System.out.println("7.注销");
            System.out.println("请选择：");
            int command=sc.nextInt();
            switch (command){
                case 1:
                    //查询账户
                    showAccount(account);
                    break;
                case 2:
                    //存款
                    depositMoney(sc,account);
                    break;
                case 3:
                    //取款
                    drawMoney(sc,account);
                    break;
                case 4:
                    //转账
                    transferMoney(sc,account,accounts);
                    break;
                case 5:
                    //修改密码
                    updatePassword(sc,account);
                    return;
                case 6:
                    //退出
                    System.out.println("退出成功");
                    return;
                case 7:
                    //注销
                    System.out.println("注销成功！！！");
                    accounts.remove(account);
                    return;
                default:
                    System.out.println("您输入的命令有误，请重新操作！！！");
            }
        }

    }

    /**
     * 修改密码操作的实现
     * @param sc
     * @param account
     */
    private static void updatePassword(Scanner sc, Account account) {
        while (true) {
            System.out.println("==================修改密码操作页====================");
            System.out.println("请输入当前用户的密码：");
            String password=sc.next();
            if (password.equals(account.getPassword())){
                while (true) {
                    System.out.println("请输入您要修改的密码：");
                    String password1=sc.next();
                    System.out.println("请确认您要修改的密码：");
                    String okPassword1=sc.next();
                    if (okPassword1.equals(password)) {
                        System.out.println("修改密码成功！");
                        account.setPassword(okPassword1);
                        return;
                    }else {
                        System.out.println("您俩次输入的密码不正确，请重新输入要修改的密码");
                    }
                }
            }else {
                System.out.println("您输入的密码错误！！!");
            }
        }
    }

    /**
     * 转账功能实现
     * @param sc
     * @param account
     * @param accounts
     */
    private static void transferMoney(Scanner sc, Account account, ArrayList<Account> accounts) {
        System.out.println("===============用户转账操作==================");
        if (accounts.size()<2){
            System.out.println("当前系统中不足俩个账号，请您先开户！！！");
            return;
        }

        if (account.getMoney()==0){
            System.out.println("您自己都没钱了，就别转了~~~");
            return;
        }

        while (true) {
            System.out.println("请您输入对方的卡号：");
            String cardId=sc.next();

            if (cardId.equals(account.getCardId())){
                System.out.println("您不能给自己转账~~~");
                continue;
            }
            Account account1=getAccountByCardId(cardId,accounts);
            if (account1==null){
                System.out.println("您输入的对方卡号不正确，请重新输入：");
            }else {
                String userName= account1.getUsername();
                String tip="*"+userName.substring(1);
                System.out.println("请您输入"+tip+"的姓氏");
                String preName=sc.next();
                if (userName.startsWith(preName)){
                    while (true) {
                        System.out.println("请您输入要转账的金额：");
                        double money=sc.nextDouble();
                        if (money>account.getQuotaMoney()){
                            System.out.println("您转账金额超过了今日限额，转账失败");
                        }else {
                            if (money>account.getMoney()){
                                System.out.println("您自己都没这么多钱，请少转点！");
                            }
                            else {
                                account.setMoney(account.getMoney()-money);
                                account1.setMoney(account1.getMoney()+money);
                                System.out.println("转账成功！您的账户还剩余"+account.getMoney()+"钱");
                                return;
                            }
                        }
                    }

                }else {
                    System.out.println("您输入的姓氏不正确！");
                }
            }
        }
    }

    /**
     * 取款功能实现
     * @param sc
     * @param account
     */
    private static void drawMoney(Scanner sc, Account account) {
        System.out.println("==================用户取钱操作================");
        if (account.getMoney()<100){
            System.out.println("很抱歉，您当前的余额少于100元，不能够取钱！！！");
            return;
        }
        while (true) {
            //用户输入取钱金额
            System.out.println("请您输入要取的金额：");
            double money=sc.nextDouble();
            if (money>account.getQuotaMoney()){
                System.out.println("很抱歉，您要取的钱超过了今日取钱的限额，今日取钱的限额为："+account.getQuotaMoney());
            }else {
                if (money>account.getMoney()){
                    System.out.println("很抱歉，您的账户没有这么多的余额，取钱失败");
                }else {
                    System.out.println("恭喜您取钱成功");
                    account.setMoney(account.getMoney()-money);
                    showAccount(account);
                    return;
                }
            }
        }
    }

    /**
     * 存款操作
     * @param sc
     * @param account
     */
    private static void depositMoney(Scanner sc, Account account) {
        System.out.println("===================用户存钱操作==============");
        System.out.println("请您输入您要存入的金额：");
        double money = sc.nextDouble();
        account.setMoney(account.getMoney()+money);
        System.out.println("存钱成功");
        showAccount(account);
    }

    /**
     * 展示登录的用户信息
     * @param account
     */
    private static void showAccount(Account account) {
        System.out.println("====================用户信息展示===================");
        System.out.println("卡号："+account.getCardId());
        System.out.println("户主："+account.getUsername());
        System.out.println("余额："+account.getMoney());
        System.out.println("限额："+account.getQuotaMoney());
    }

    public static void register(ArrayList<Account> accounts,Scanner sc){
        //1.创建一个账户对象，用于后期封装用户账号信息
        Account account=new Account();
        //2.录入当前账户信息，注入到账号对象中
        System.out.println("=====================您已经进入到账户开户操作当中==========");
        System.out.println("请您输入用户名：");
        String name=sc.next();
        account.setUsername(name);
        while (true) {
            System.out.println("请您输入密码：");
            String password=sc.next();
            System.out.println("请您确认密码：");
            String okPassword=sc.next();
            if (okPassword.equals(password)){
                account.setPassword(password);
                break;
            }else {
                System.out.println("您输入的俩次密码不一致，请重新输入：");
            }
        }
        System.out.println("请您输入当日的限额：");

        Double quotaMoney=sc.nextDouble();
        account.setQuotaMoney(quotaMoney);

        //随机生成一个卡号
        String cardId=getRandomCardId(accounts);
        account.setCardId(cardId);
        //3.把账号对象添加到账号集合中
        accounts.add(account);
        System.out.println("恭喜您"+name+"先生/女士，开户成功，您的卡号是："+cardId);
    }

    //随机生成一个八位数的卡号
    private static String getRandomCardId(ArrayList<Account> accounts) {
        Random r=new Random();
        while (true) {
            String cardId="";
            for (int i = 0; i < 8; i++) {
                cardId+=r.nextInt(10);
            }
            //判断这个卡号是否与其他卡号是否重复
            Account account=getAccountByCardId(cardId,accounts);
            if (account==null){
                //说明没有重复的卡号
                return cardId;
            }
        }
    }

    /**
     * 判断生成的卡号是否与其他卡号重复
     * @param cardId
     * @param accounts
     * @return
     */
    private static Account getAccountByCardId(String cardId, ArrayList<Account> accounts) {
        for (int i = 0; i < accounts.size(); i++) {
            Account account=accounts.get(i);
            if (account.getCardId().equals(cardId)){
                return account;
            }
        }
        return null;
    }

}

参考视频