Java语言入门学习

int i=10;
       int j=30;
       int k=50;
       //1.找出两个整数的较大值
       int temp=i>j?i:j;
       //2.拿临时变量与第三个变量的值继续比较
       int rsmax=temp>k?temp:k;
       System.out.println(rsmax);
       int rsmax1=i>j?(i>k?i:k):(j>k?j:k);
       System.out.println(rsmax1);

第三节流程控制语句

JAVA提供了一些流程控制语句，来控制程序的执行流程。

顺序结构：程序默认流程

分支结构：If、switch

循环结构：for while do.....while

（一）分支结构

（1）if:

根据判定的结果（真或假）决定执行某个分支的代码。

if(条件表达式）

{

语句体；

}

if(条件表达式）

{

语句体1；

}

else

{

语句体2；

}

if(条件表达式1）

{

语句体1；

}else if(条件表达式2）

{

语句体2；

}else if(条件表达式3）

{

语句体3；

}

.........

else

{

语句体n+1;

}

（2）switch分支

也是匹配条件去执行分支，适合做值匹配的分支选择，结构清晰，格式良好。

执行流程：

1.先执行表达式的值，拿着这个值去与case后的值进行匹配

2.匹配哪个case的值为true就执行哪个case，遇到break就跳出switch分支。

3.如果case后的值都不匹配则执行default代码。

switch(表达式）

{

case 值1：

执行代码.......;

break;

case 值2：

执行代码.......;

break;

..........................

case 值n-1;

执行代码.......;

break;

default:

执行代码n；

}

if其实在功能上远远强大于switch。

if适合做区间匹配。

switch适合做：值匹配的分支选择、代码优雅。

注意事项：

1.表达式类型只能是byte、short、int、char，JDK5开始支持枚举，JDK7开始支持String、不支持double、float、long.

2.case给出的值不允许重复，且只能是字面量，不能是变量

3.不要忘记写break，否则会出现穿透现象。

switch的穿透性：

如果代码执行到没有break的case块，执行完后将直接进入下一个case块执行代码（而且不会进行任何匹配），直到遇到break语句才跳出分支，这就是switch的穿透性。

case中没有写break.

（二）循环结构

（1）for循环：

控制一段代码反复执行很多次。

格式：for（初始化语句；循环条件；迭代语句）

{

循环体语句（重复执行的代码）；

}

例子：

1~10奇数和:

1.for(int i=1;i<=10;i++) if(i%2==1)

2.for(int i=1;i<=10;i+=2)

水仙花数：

个位：data%10

十位：data/10%10

百位：data/10/10%10

知道水仙花数的个数：在循环外定义一个变量count用于记录水仙花数，每输出水仙花数时，让count++

（2）while循环

初始化语句：

while(循环条件）

{

循环语句（被重复执行的代码）；

迭代语句

}

for、while循环：功能上是完全是一样的，for能解决的while也能解决，反之亦然。

使用规范是：知道循环几次，使用for;不知道循环几次，使用while。

（3）do-while循环

先执行再判断循环条件。

初始化语句：

{

循环体语句；

迭代语句；

}while(循环条件）;

特点：一定会先执行一次循环体。

三种循环的区别：

for while循环（先判断后执行）

do......while（第一次先执行后判断）

for和while区别：

for循环和while循环的执行流程是一摸一样的；

如果已知循环次数建议使用for循环，如果不清楚要循环多少次建议使用while循环。

for循环中，控制循环的变量只是在循环中可以使用。while循环中，控制循环的变量在循环后还可以继续使用。

（4）死循环

一直循环的执行下去，如果没有干预就不会停下来。

for(; ;)

{

System.out.println("Hello World");

}

while(true)

{

System.out.println("helloworld");

}

{

System.out.println("helloworld");

}while(true);

（5）循环嵌套

循环中又包含循环

特点：外部循环每循环一次，内部循环全部执行完一次

（6）跳转关键字

跳转控制语句介绍

break:跳出结束当前所在循环的执行

continue:用于跳出当前的循环的当次执行，进入下一次循环

注意：break只能用于结束所在循环，或者结束所在switch分支的执行，continue只能在循环中进行使用。

（7）Random随机数技术

作用：用于在程序中获取随机数的技术

使用步骤：

1.导包：import java.util.Random;

2.写一行代码代表得到随机数对象：Random r=new Random();

3.调用随机数的功能获取0~9的随机数：int number=r.nextInt(10);

注意：nextInt()功能只能生成：0至n-1之间的随机数，不包含n

nextInt(n)功能只能生成：0——(n-1)之间的随机数

Random生成区间随机数的技巧：减加法

例子：

要生成1-10的随机数：jian 1——（0——9）+1

Random r=new Random();

int number=r.nextInt(10)+1;

第四节数组

（一）数组概述

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

数组适合做一批同种类型数据的存储。

（二）静态初始化数组

定义数组的时候直接给数组赋值。

静态初始化数组的格式：

完整格式：数据类型【】数组名=new 数据类型【】{元素1，元素2，元素3........};

简化格式：数据类型【】数组名={元素1，元素2，元素3.............}；

注意：数组变量名中存储的是数组在内存中的地址，数组是引用类型

数组的访问：数组名称【索引】

数组的长度属性：length

获取数组的长度（就是数组元素的个数）：System.out.println(arr.length);

数组的最大索引：数组名.length-1//前提：元素个数大于0

数组的注意事项：

“数据类型【】数组名”也可以写成“数据类型数组名【】”

什么类型的数组存放什么类型的数据，否则报错。

数组一旦定义出来，程序执行过程中，长度、类型就固定了。

（三）数组的动态初始化

定义数组的时候只确定元素的类型和数组的长度，之后再存入具体数据

数组的动态初始化格式：数据类型【】数组名=new 数据类型【长度】；

当前已经知道存入的元素值，用静态初始化；

当前还不清楚要存入哪些数据，用动态初始化。

动态初始化数组的元素默认值：

数据类型   明细   默认值
基本类型   byte short char int long   0
float double   0.0
boolean   false
引用类型   类、接口、数组、String   null
两种初始化的使用场景总结、注意事项说明：

动态初始化：只指定数组长度，后期赋值，适合开始知道数据的数量，但是不确定具体元素值的业务场景。

静态初始化：开始就存入元素值，适合一开始就能确定元素值的业务场景。

两种格式的写法是独立的，不可以混用。

（四）数组遍历

遍历：就是一个一个数据的访问

搜索、数据统计等等都需要用到遍历。

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

数组元素求最大值：1.数据拿到程序中去，用数组装起来2.定义一个变量用于记录最大值，这个变量建议默认存储第一个元素值作为参照3.遍历数组的元素，如果该元素大于变量存储的元素，则替换变量存储的值为该元素。4.循环结束输出最大值。

猜数字游戏：1.动态初始化数组，存入五个随机的1-20之间的数据2.定义一个死循环，不断的猜数据，遍历数组，判断数据是否在数组中，如果在，进行对应提示并结束死循环；如果没有猜中，提示继续。

随即排名：（斗地主洗牌）1.定义一个动态初始化的数组用于录入数据2.遍历数组中的每个元素，每次随机一个索引值，让当前元素与该索引位置处的元素进行交换3.遍历输出数组中的内容即可。

数组排序：就是对数组中的元素，进行升序（由小到大）或者降序（由大到小）的操作。

数组排序的技术：

（五）冒泡排序

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

实现冒泡排序的关键步骤分析：

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

每轮比较几次：次数规律：数组的长度-i

冒泡排序的思想：

从头开始两两比较，把较大的元素与较小的元素进行交换，每轮把当前最大的一个元素存入到数组当前的末尾。

冒泡排序的实现步骤：

1.定义一个外部循环控制总共需要冒几轮（数组的长度-1）

2.定义一个内部循环，控制每轮依次往后比较几个位置（数组长度-i)

3.如果当前位置的元素>后一个位置的元素值，两者交换

（六）数组的内存图

JAVA内存分配、数组内存图

栈、堆、方法区、本地方法栈、寄存器

方法区：字节码文件加载时进入的内存

栈内存：方法运行时所进入的内存变量也是在这里。

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

两个变量指向同一个数组：

数组使用的常见问题

1.如果访问的元素位置超过最大索引，执行时会出现（数组索引越界异常）。

2.如果数组变量中没有存储数组的地址，而是null，在访问数组信息时会出现（空指针异常）。

（七）Debug工具的使用

自带的断点调试（排错工具），可以控制代码从断点开始一行一行的执行，然后仔细观看程序执行的情况。

工具基本使用步骤：

1.在需要控制的代码行左侧，点击一下，形成断点

2.选择使用Debug方式启动程序，启动后程序会在断点暂停

3.控制代码一行一行的往下执行。

第五节方法

（一）方法定义、调用

方法作用：封装一段代码的语法结构，可以被重复调用，以此提高代码的复用性，提高开发效率，让程序逻辑更清晰。

方法定义的完整格式:

修饰符 返回值类型 方法名（形参列表）{
    方法体代码（需要执行的功能代码）
    return 返回值;
}

注意：

1.方法的修饰符：暂时使用public static修饰

2.方法申明了具体的返回值类型，内部必须使用return返回对应类型的数据；

如果方法不需要返回结果，返回值类型必须申明成void（无返回值），此时方法内部不可以使用return返回数据；

方法如果没有参数，或者返回值类型申明为void可以称为无参数、无返回值的方法，依此类推；

3.形参列表可以有多个，甚至可以没有；如果有多个形参，多个形参必须用“，”隔开，且不能给初始化值。

4.方法定义时：返回值类型、形参列表可以按照需求进行填写

方法的调用格式：

方法名（···········）;

有返回值类型申明的方法的调用：

1.赋值调用：定义变量接收方法的结果

2.输出调用：放在输出语句中调用

3.直接调用：方法还是会执行的，只是返回的结果我们不要了

无返回值方法的调用：直接调用一下

注意：

方法的编写顺序无所谓，方法与方法之间是平级关系，不能嵌套定义；

return语句下面，不能编写代码，因为永远执行不到，属于无效的代码；

方法不调用就不执行，调用时必须严格匹配方法的参数情况；

有返回值的方法调用时可以选择定义变量接收结果，或者直接输出调用，甚至直接调用；无返回值方法的调用只能直接调用一下。

（二）方法案例

package com.itheima.demo0;
//计算1-n的和并返回
public class demo0 {
    public static void main(String[] args) {
        System.out.println("1-5的和是："+sum(5));
        System.out.println("1-100的和是："+sum(100));
    }

    public static int sum(int n){
        int sum=0;
        for (int i = 1; i < n; i++) {
            sum+=i;
        }
        return sum;
    }
}

package com.itheima.demo0;
//判断一个整数是奇数还是偶数 并进行结果输出
public class demo0 {
    public static void main(String[] args) {
        check(100);
        check(7);
    }
    public static void check(int n){
        if (n % 2 == 0) {
            System.out.println(n+"是偶数");
        }else{
            System.out.println(n+"是奇数");
        }
    }
}

package com.itheima.demo0;
//支持找出任意整型数组的最大值返回
public class demo0 {
    public static void main(String[] args) {
        int[] ages ={23,19,25,78,34};
        int max=getArrayMaxData(ages);
        System.out.println("最大值数据是:"+max);
    }
    public static int getArrayMaxData(int[] arr){
        //找出数组的最大值返回
        int max=arr[0];
        //遍历数组的每个元素与最大值的数据进行比较，若较大则替换
        for (int i = 1; i < arr.length; i++) {
            if (arr[i]> max) {
                max=arr[i];
            }

        }
        return max;
    }
}

（三）方法调用的内存图

方法没有被调用的时候，在方法区中的字节码文件中存放；

方法被调用的时候，需要进入到栈内存中运行。

方法运行区域：栈内存

（四）方法的参数传递机制

（1）基本类型的参数传递：存储的数据值

值传递

在传递实参给方法的形参的时候，并不是传输实参变量本身，而是传输实参变量中存储的值，这就是值传递。

实参：如在方法内部定义的变量

形参：如在定义方法时，“（）”中所声明的参数

（2）引用类型的参数传递：存储的地址值

package com.itheima.demo0;

public class demo0 {
    public static void main(String[] args) {
        int[] arr={10,20,30};
        change(arr);
        System.out.println(arr[1]);

    }
    public static void change(int[] arr){
        System.out.println(arr[1]);
        arr[1] = 222;
        System.out.println(arr[1]);
    }

}

结果：20 222 222

（五）参数传递案例

1.打印数组内容

package com.itheima.demo0;

public class demo0 {
    public static void main(String[] args) {
        int[] ages={10,90,20,30};
        printArray(ages);
        int[] numbers={90,11,12,13,14,15};
        printArray(numbers);
        int[] numbers1=null;
        printArray(numbers1);
    }
    public static void printArray(int[] arr){
        System.out.print("[");
        if (arr !=null && arr.length>0) {
            for (int i = 0; i < arr.length; i++) {
           /* if (i == arr.length-1) {
                System.out.print(arr[i]);
            } else {
            System.out.print(arr[i]+",");
            }*/
                System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ",");
            }
        }
        System.out.println("]");
    }

}

2.从数组中查询元素的索引返回

package com.itheima.demo0;

public class demo0 {
    public static void main(String[] args) {
        //需求：从整型数组中查询某个数据的索引返回，不存在数据返回-1
        int[] arr = {11, 22, 33, 66, 87, 19};
        int index = searchIndex(arr, 87);
        System.out.println("您查询的数据的索引是"+index);
    }
    public static int searchIndex(int[] arr, int data) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == data) {
                return i;
            }
        }
        return -1; //查无此元素
    }
}

3.比较两个数组内容是否一样

package com.itheima.demo0;

public class demo0 {
    public static void main(String[] args) {
        int[] arr1={10,120,30};
        int[] arr2={10,20,30};
        System.out.println(compare(arr1,arr2));

    }
    public static boolean compare(int[] arr1,int[] arr2){
        if(arr1.length==arr2.length){
            for (int i = 0; i < arr1.length; i++) {
                if (arr1[i] != arr2[i]) {
                    return false;
                }
            }
            return true;
        }else {
            return false;
        }
    }
}

（六）方法重载

1.方法重载：同一个类中，出现多个方法名称相同，但是形参列表是不同的，那么这些方法就是重载方法。

package com.itheima.demo0;

public class demo0 {
    public static void main(String[] args) {
        fire();
        fire("岛国");
        fire("岛国",9);
    }
    public static void fire(){
        System.out.println("默认发射一批武器给米国");
    }
    public static void fire(String location){
        System.out.println("默认发射一批武器给"+location+"~~~~");
    }
    public static void fire(String location,int num){
        System.out.println("默认发射"+num+"枚核武器给"+location+"~~~");
    }
}

方法重载的作用：可读性好，方法名称相同提示是同一类型的功能，通过形参不同实现功能差异化的选择，这是一种专业的代码设计。

2.方法重载的识别技巧：

只要是同一个类中，方法名称相同、形参列表不同，那么他们就是重载的方法，其他都不管！

（只要是修饰符，返回值类型都无所谓）；

形参列表不同指的是：形参的个数、类型、顺序不同，不关心形参的名称。

3.单独使用return关键字

return;-->可以立即跳出并结束当前方法的执行；return关键字单独使用可以放在任何方法中。

package com.itheima.demo0;

public class demo0 {
    public static void main(String[] args) {
        chu(10,0);
    }
    public static void chu(int a,int b){
        if (b == 0) {
            System.out.println("您输入的数据有问题，除数不能是0");
            return;//立即跳出当前方法，并结束当前方法的执行

        }
        int c=a/b;
        System.out.println("结果是："+c);
    }
}

return:跳出并立即结束所在方法的执行；

break：跳出并结束当前所在循环的执行；

continue：结束当前所在循环的当次继续，进入下一次执行。

第六节编程案例

1.买飞机票

需求：机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱。机票最终优惠价格的计算方案如下：旺季（5-10）月头等舱9折，经济舱8.5折，淡季（11月到来年4月）头等舱7折，经济舱6.5折。

package com.itheima.demo0;

import java.util.Scanner;

public class demo0 {
    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();

        System.out.println("机票优惠后的价格是："+calc(money,month,type));
    }
    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;
    }
}

2.找素数

判断101-200之间有多少个素数，并输出所有素数

package com.itheima.demo0;

public class demo0 {
    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");
            }
        }
    }
}

3. 开发验证码

需求：定义方法实现随机产生一个五位的验证码，每位可能是数字、大写字母、小写字母

package com.itheima.demo0;

import java.util.Random;

public class demo0 {
    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++) {
            int type = r.nextInt(3);//0 1 2
            switch (type){
                case 0:
                    //大写字符（A65  -   Z65+25）（0-25  +65）
                    char ch= (char) (r.nextInt(26)+65);
                    code+=ch;
                    break;
                case 1:
                    //小写字符（a97   -z97+25)  (0-25   +97)
                    char ch1= (char) (r.nextInt(26)+97);
                    code+=ch1;
                    break;
                case 2:
                    code+=r.nextInt(10);//0-9
                    break;

            }
        }
        return code;
    }
}

4.数组元素复制

需求：把一个数组中的元素复制到另一个新数组中去。

package com.itheima.demo0;

public class demo0 {
    public static void main(String[] args) {
        int[] arr1={11,22,33,44};
        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.评委打分

需求：在唱歌比赛中，有6名评委给选手打分，分数范围是【0-100】之间的整数。选手的最后得分为：去掉最高分、最低分后的4个评委的平均分，请完成上述过程并计算出选手的得分。

package com.itheima.demo0;

import java.util.Scanner;

public class demo0 {
    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)+"个评委的打分：");
            int score = sc.nextInt();
            scores[i]=score;
        }
        //遍历数组中的每个数据，找出最大值 最小值 总分
        int max=scores[0];
        int min=scores[0];
        int sum=0;
        for (int i = 0; i < scores.length; i++) {
            if (scores[i]>max) {
                max=scores[i];
            }
            if (scores[i]<min){
                min=scores[i];
            }
            sum+=scores[i];
        }
        System.out.println("最高分是："+max);
        System.out.println("最低分是："+min);
        double result=(sum-max-min)*1.0/(scores.length-2);
        System.out.println("选手最终得分是："+result);
    }
}

6.数字加密

需求：某系统的数字加密：比如1983，【8346】采用加密方式进行传输，规则如下：先得到每位数，然后每位数都加上5，再对10求余，最后所有数字反转，得到一串新数。

package com.itheima.demo0;

import java.util.Scanner;

public class demo0 {
    public static void main(String[] args) {
        System.out.println("请您输入需要加密的数字个数：");
        Scanner sc=new Scanner(System.in);
        int length=sc.nextInt();
        int[] arr=new int[length];
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请您输入第"+(i+1)+"个数字：");
            int number=sc.nextInt();
            arr[i]=number;
        }
        //打印数组内容
        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;
        }
        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.模拟双色球

投注号码由6个红色球号码和1个蓝色球号码组成。红色球号码从1-33中选择；蓝色球号码从1-16中选择。

（1）随机生成一组中奖号码（2）用户输入一组双色球号码（3）判断中奖情况

package com.itheima.demo0;

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

public class demo0 {
    public static void main(String[] args) {
        //1.随机6个红球号码（1-33，不能重复），随机一个篮球号码（1-16），可以采用数组装起来作为中奖号码。
        int[] luckNumbers=createLuckNumber();
        printArray(luckNumbers);
        //2.调用一个方法让用户输入7个号码 作为用户选号
        int[] userNumbers=userInputNumber();
        printArray(userNumbers);
        //3.判断中奖情况
        judge(luckNumbers,userNumbers);

    }
    public static void judge(int[] luckNumbers,int[] userNumbers){
        //判断是否中奖了
        //1.定义两个变量分别存储红球命中的个数，以及篮球命中的个数
        int redHitNumbers=0;
        int blueHitNumbers=0;
        //2.判断红球命中了几个，开始统计
        for (int i = 0; i < userNumbers.length; i++) {
            for (int i1 = 0; i1 < luckNumbers.length; i1++) {
                //每次找到了相等，意味着当前号码命中了
                if(userNumbers[i]==luckNumbers[i]){
                    redHitNumbers++;
                    break;
                }
            }
        }
        //篮球号码是否命中了
        blueHitNumbers=luckNumbers[6]==userNumbers[6]?1:0;
        System.out.println("中奖号码是：");
        printArray(luckNumbers);
        System.out.println("您投注号码是：");
        printArray(userNumbers);
        System.out.println("您命中了几个红球:" +redHitNumbers);
        System.out.println("您是否命中篮球:" +(blueHitNumbers==1?"是":"否"));
        //判断中奖情况
        if(blueHitNumbers==1&&redHitNumbers<3){
            System.out.println("恭喜您，中了5元小奖！");
        } else if (blueHitNumbers==1&&redHitNumbers==3
        ||blueHitNumbers==0&&redHitNumbers==4){
            System.out.println("恭喜您，中了10元小奖！");
        } else if (blueHitNumbers==1&&redHitNumbers==4
        ||blueHitNumbers==0&&redHitNumbers==5) {
            System.out.println("恭喜您，中了200元！");
        } else if (blueHitNumbers==1&&redHitNumbers==5) {
            System.out.println("恭喜您，中了3000元大奖");
        } else if (blueHitNumbers==0&&redHitNumbers==6) {
            System.out.println("恭喜您，中了500万超级大奖！");
        } else if (blueHitNumbers==1&&redHitNumbers==6) {
            System.out.println("恭喜您，中了1000万巨奖！");
        }else {
            System.out.println("感谢您为福利事业做出突出贡献!!");
        }
    }
    public static void printArray(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
        System.out.println();//换行
    }

    public static int[] userInputNumber(){
        //a.定义一个数组存储7个号码
        int[] numbers=new int[7];
        //b.让用户录入6个红球号码
        Scanner sc=new Scanner(System.in);
        for (int d = 0; d < numbers.length-1; d++) {
            System.out.println("请您输入第"+(d+1)+"个红球号码（1-33要求 要求不重复）:");
            int data = sc.nextInt();
            //c.把当前选入的数据存入到数组中去
            numbers[d]=data;
        }
        //d.单独录入的数据存入到数组中去
        System.out.println("请您输入篮球号码（1-16）：");
        numbers[6] =sc.nextInt();
        return numbers;
    }
    public static int[] createLuckNumber(){
        //a.定义一个动态初始化的数组，存储七个数字
        int[] numbers=new int[7];
        //b.遍历数组，为每个位置生成对应的号码（注意：遍历前6个位置，生成6个不重复的红球号码，范围是1-33）
        Random r=new Random();
        for (int i = 0; i < numbers.length-1; i++) {
            //为当前位置找出一个不重复1-33之间的数字
            while (true){
                int data = r.nextInt(33) + 1;
                //c.注意：必须判断当前随机的这个号码之前是否出现过，出现过要重新随机一个，直到不重复为止，才可以存入数组中去
                //定义一个flag变量，默认为data是没有重复的
                boolean flag=true;
                for (int j = 0; j < i; j++) {
                    if(numbers[j]==data){
                        //data当前这个数据之前出现过，不能用
                        break;
                    }
                }
                if (flag) {
                    //data这个数据之前没有出现过，可以使用了
                    numbers[i]=data;
                    break;
                }
            }
        }
        //d.为第七个位置生成一个1-16的号码作为蓝球号码
        numbers[numbers.length-1]=r.nextInt(16) +1;
        return numbers;
    }
}

第七节面向对象

（一）设计对象并使用

（1）设计类创建对象并使用

面向对象编程（oop）

面向对象编程好处：代码符合人类的思维习惯，编程程序更简单，看程序更容易理解吧。

类：是对象共同特征的描述；

对象：是真实存在的具体实例；

结论：在JAVA中，必须先设计类，才能创建对象并使用。

1.设计类：

public class 类名{
    1.成员变量（代表属性，一般是名词）
    2.成员方法（代表行为，一般是动词）
    3.构造器
    4.代码块
    5.内部类
}

2.得到类的对象：

类名 对象名=new 类名（）;

3.使用对象：

访问属性：对象名.成员变量
访问行为：对象名.方法名（···）

4.示例：

package com.itheima.demo0;

public class Car {
    //成员变量
    String name;
    double price;
    //方法
    public void start(){
        System.out.println(name+"启动了");
    }
    public void run(){
        System.out.println("价格是："+price+"的"+name+"跑的很快");
    }
}

package com.itheima.demo0;

public class test0 {
    public static void main(String[] args) {
        //创建汽车对象
        Car c=new Car();
        c.name="宝马";
        c.price=38.9;
        System.out.println(c.name);
        System.out.println(c.price);
        c.start();
        c.run();
    }
}

（2）定义类的补充注意事项

1.类名首字母建议大写、英文，且有意义，满足“驼峰模式”，不能用关键字，满足标识符规定；

2.一个JAVA文件中可以定义多个class类，但只能一个类是public修饰，而且public修饰类名必须成为代码文件名。实际开发中建议还是一个文件定义一个class类；

3.成员变量的完整定义格式是：修饰符数据类型变量名称=初始化值；一般无需指定初始化值，存在默认值。

4.默认值规则：

byte、short、int、long: 0

double、float: 0.0

boolean: false

类、接口、数组、String等引用类型： null

（二）对象在内存中的运行机制

（1）多个对象的内存图

对象放置在堆内存中；

类名对象名=new 类名（）; 变量名中存储的是对象在堆内存中的地址；

成员变量的数据放在对象中，存放在堆内存中。

（2）两个变量指向同一个对象内存图

package com.itheima.demo0;

public class Student {

    String name;
    String sex;
    String hobby;
    public void study(){
        System.out.println("名称："+name+",性别:"+sex+",爱好："+hobby+",开始学习了!");
    }
}

package com.itheima.demo0;

public class test0 {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.name="小明";
        s1.sex="男";
        s1.hobby="睡觉，游戏，学习";
        s1.study();
        //把s1变量赋给一个学生类型的变量s2
        Student s2=s1;
        System.out.println(s2);
        System.out.println(s1);
        s2.hobby="爱提问";
        System.out.println(s2.name);
        System.out.println(s2.sex);
        System.out.println(s1.hobby);
        s2.study();
    }
}

垃圾回收

注意：当堆内存中的对象，没有被任何变量引用（指向）时，就会被判定为内存中的“垃圾”。

（三）构造器

购物车模块模拟——架构搭建

需求：模拟购物车模块的功能，需要实现添加商品到购物车中去，同时需要提供修改商品的购买数量，结算商品价格功能。

分析：

购物车上的每个商品都是一个对象，需要定义一个商品类。

购物车本身也是一个对象：可以使用数组对象代表它。

完成界面架构，让用户选择操作的功能。

package com.itheima.demo0;

import java.util.Objects;
import java.util.Scanner;

public class ShopCarTest {
    public static void main(String[] args) {
        //1.定义商品类，用于后期创建商品对象
        //2.定义购物车对象，使用一个数组对象表示
        Goods[] shopCar=new Goods[100];
        //3.搭建操作架构
        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");
            Scanner sc=new Scanner(System.in);
            System.out.println("请您输入命令：");
            String command = sc.next();
            switch (command){
                case"add":
                    addGoods(shopCar,sc);
                    break;
                case"query":
                    queryGoods(shopCar);
                    break;
                case"update":
                    updateGoods(shopCar,sc);
                    break;
                case"pay":
                    pay(shopCar);
                    break;
                case"exit":
                    return;
                default:
                    System.out.println("没有该功能！");
            }
        }

    }
    public static void addGoods(Goods[] shopCar,Scanner sc){
        //完成商品添加到购物车的功能
        //1.录入用户输入的购买商品的信息
        System.out.println("请您输入购买商品的编号（不重复）：");
        int id=sc.nextInt();
        System.out.println("请您输入购买商品的名称：");
        String name = sc.next();
        System.out.println("请您输入购买商品的数量：");
        int buyNumber=sc.nextInt();
        System.out.println("请您输入购买商品的价格：");
        double price = sc.nextDouble();
        //2.把这个购买商品的信息封装成一个商品对象
        Goods g=new Goods();
        g.id=id;
        g.name=name;
        g.buyNumber=buyNumber;
        g.price=price;
        //3.把这个商品对象添加到购物车数组中去
        for (int i = 0; i < shopCar.length; i++) {
            if (shopCar[i] == null) {
                //说明此位置没有元素存入，把我们新买的商品添加到此处即可
                shopCar[i]=g;
                break;//结束 商品存入 不必找位置
            }
        }
        System.out.println("您的商品："+g.name+"添加到购物车完成");


    }
    public static void queryGoods(Goods[] shopCar){
        //查询购物车中的商品对象信息，并展示出来
        System.out.println("===============查询购物车信息如下=============");
        System.out.println("编号\t\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\t"+g.buyNumber);
            }else {
                //遍历结束
                break;
            }
        }
    }
    public static void updateGoods(Goods[] shopCar, Scanner sc){
        //让用户输入需要修改商品的id，根据id查询出要修改的商品对象
        while (true) {
            System.out.println("请您输入要修改的商品的id：");
            int id = sc.nextInt();
            Goods g=getGoodsById(shopCar,id);
            if (g == null) {
                //没有该商品
                System.out.println("对不起，没有购买商品！");

            }else {
                //说明存在该商品对象，可以修改他了
                System.out.println("请您输入"+g.name+"商品最新的购买数量：");
                int buyNumber=  sc.nextInt();
                g.buyNumber=buyNumber;
                System.out.println("修改完成！");
                queryGoods(shopCar);
                break;
            }
        }


    }
    public static Goods getGoodsById(Goods[] shopCar,int id){
        for (int i = 0; i < shopCar.length; i++) {
            Goods g=shopCar[i];
            if (g!=null){
                //判断这个商品对象的id是否是我们要找的
                if(g.id==id){
                    return g;
                }
            }else{
                return null;//找完了前面存在的商品，都没有找到
            }
        }
        return null;//代表找完了100个商品都没有找到id一样的商品
    }
    public static void pay(Goods[] shopCar){
        queryGoods(shopCar);
        //结算金额
        //1.定义一个求和变量累加金额
        double money=0;
        //2.遍历购物车数组中的全部商品对象，累加单价*数量
        for (int i = 0; i < shopCar.length; i++) {
            Goods g=shopCar[i];
            if (g!= null) {
                money+=(g.price*g.buyNumber);
            }else {
                break;
            }
        }
        System.out.println("订单总金额："+money);
    }
}

package com.itheima.demo0;

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

（1）.构造器的作用：

定义在类中的，可以用于初始化一个类的对象，并返回对象的地址。

（2）.构造器的格式：

修饰符 类名（形参列表）{
··········
}

（3）.调用构造器得到对象的格式：

类 变量名称=new 构造器;

（4）.构造器的分类和作用：

无参数构造器（默认存在的）：初始化对象时，成员变量的数据均采用默认值。

有参数构造器：在初始化对象的时候，同时可以接收参数为对象进行赋值。

package com.itheima.demo0;

public class Car {
    String name;
    double price;

    //无参数构造器
    public Car(){
        System.out.println("无参数构造器就被调用了");
    }
    //有参数构造器
    public Car(String n,double p){
        System.out.println("有参数构造器就被调用了");
        name =n;
        price=p;
    }
}

package com.itheima.demo0;

public class Test {
    public static void main(String[] args) {
        //通过调用构造器得到对象
        Car c=new Car();
        c.name="宝马";
        c.price=38.9;
        System.out.println(c.name);
        System.out.println(c.price);

        //调用有参数构造器
        Car c2=new Car("奔驰",39.8);
        System.out.println(c.name);
        System.out.println(c.price);
    }
}

（5）.构造器的注意事项：

任何类定义出来，默认就自带了无参数构造器，写不写都有；

一旦定义了有参数构造器，那么无参数构造器就没有了，如果还想用无参数构造器，此时就需要自己手写一个无参数构造器了。

（四）this关键字

this关键字可以出现在构造器、方法中；代表当前对象的地址。

this 关键字的作用：可以用于指定访问当前对象的成员变量、成员方法。

package com.itheima.demo0;

public class Car {
    String name;
    double price;

    //无参数构造器
    public Car(){
        System.out.println("无参数构造器中的this："+this);
    }
    //有参数构造器
    public Car(String name,double price){
        System.out.println("有参数构造器就被调用了");
        this.name=name;
        this.price=price;
    }
    public void run(){
        System.out.println("方法中的this:"+this);
    }
    public void goWith(String name){
        System.out.println(this.name+"正在和"+name+"比赛···");
    }
}

package com.itheima.demo0;

public class Test {
    public static void main(String[] args) {
        Car c=new Car();
        c.run();
        System.out.println(c);
        System.out.println("==============");
        Car c2=new Car("奔驰",39.9);
        System.out.println(c2.name);
        System.out.println(c2.price);

        c2.goWith("宝马");
    }
}

（五）封装

面向对象的三大特征：封装、继承、多态。

封装：正确设计对象的属性和方法

封装的原则：对象代表什么，就得封装对应的数据，并提供数据对应的行为。

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

package com.itheima.demo0;

public class Student {
    //1.成员变量 使用private修饰，只能在本类中访问了
    private int age;
    //2.提供成套的getter和setter方法暴露其取值和赋值
    public void setAge(int age){
        if (age>=0&&age<=200){
            this.age=age;
        }else {
            System.out.println("您的年龄数据有问题!");

        }
    }
    public int getAge(){
        return age;
    }
}

package com.itheima.demo0;

public class Test {
    public static void main(String[] args) {
        Student s=new Student();
        s.setAge(-23);
        System.out.println(s.getAge());

    }
}

(六）标准JAVABEAN

JavaBean:也可以称为实体类，其对象也可以用于在程序中封装数据。

满足书写要求：

1.成员变量使用private修饰；

2.提供成员变量对应的setXxx()/getXxx()方法；

3.必须提供一个无参构造器；有参数构造器是可写可不写的

package com.itheima.demo0;

public class User {
    //1.成员变量建议使用private私有
    private String name;
    private double height;
    private double salary;
    //3.要求提供无参数构造器，有参数构造器是可选


    public User() {

    }

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


    //2.必须为成员变量提供成套的setter和getter方法

    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 com.itheima.demo0;

public class Test {
    public static void main(String[] args) {
        //1.无参数构造器创建对象封装一个用户信息
        User u1=new User();
        u1.setName("吴彦祖");
        u1.setHeight(180.5);
        u1.setSalary(1000.0);
        System.out.println(u1.getName());
        System.out.println(u1.getHeight());
        System.out.println(u1.getSalary());
        //2.有参数构造器创建对象封装一个用户信息
        User u2=new User("鹿晗",156,3000);
        System.out.println(u2.getName());
        System.out.println(u2.getHeight());
        System.out.println(u2.getSalary());

    }
}

成员变量、局部变量区别：

区别	成员变量	局部变量
类中位置不同	类中、方法外	常见于方法中
初始化值不同	有默认值，无需初始化	没有默认值，使用之前需要完成赋值
内存位置不同	堆内存	栈内存
生命周期不同	随着对象的创建而存在，随着对象的消失而消失	随着方法的调用而存在，随着方法的运行结束而消失
作用域		在所属的大括号中

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

需求：使用面向对象编程，模仿电影信息的展示

package com.itheima.demo0;

public class Movie {
    //1.成员变量
    private String name;
    private double score;
    private String actor;
    //3.有参 无参构造器
    public Movie() {

    }

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

    //2.getter+setter

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

package com.itheima.demo0;

public class Test {
    public static void main(String[] args) {
        //1.设计电影类
        //2.创建三个电影对象，封装电影的信息
        //3.定义一个电影类的数组，存储三部电影
        Movie[] movies=new Movie[3];
        movies[0]=new Movie("《长津湖》",9.7,"吴京");
        movies[1]=new Movie("《我和我的父亲》",9.6,"吴京");
        movies[2]=new Movie("《扑水少年》",9.5,"王川");
        //4.遍历数组中的每个电影对象，然后获取它的信息展示出来
        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("=======================");
        }
    }
}

数组中存储的元素并不是对象本身，而是对象的地址。

第八节

（一）常用API（String、ArrayList）

(1)API：应用程序编程接口

JAVA写好的技术（功能代码），咱们可以直接调用；

Oracle也为Java提供的这些功能代码提供了相应的API文档(技术使用说明书）。

(2)String简单介绍

String类定义的变量可以用于存储字符串，同时String类提供了很多操作字符串的功能，我们可以直接使用。

1.String概述：

java.lang.String类代表字符串，String类定义的变量可以用于指向字符串对象，然后操作该字符串；

java程序中的所有字符串文字（例如“abc”）都为此类的对象。

String类的特点详解：

String其实常被称为不可变字符串类型，它的对象在创建后不能更改。

以“ ”方式给出的字符串对象，在字符串常量池中存储。

String是不可变字符串：

String变量每次的修改其实都是产生并指向了新的字符串对象；

原来的字符串对象都是没有改变的，所以称其不可变字符串

2.String类创建对象的2种方式

方式一：直接使用“ ”定义

方式二：通过String类的构造器创建对象

构造器	说明
public String()	创建一个空白字符串对象，不含有任何内容
public String(String original)	根据传入的字符串内容，来创建字符串对象
public String(char[] chs)	根据字符数组的内容，来创建字符串对象
public String(byte[] chs)	根据字节数组的内容，来创建字符串对象

package com.itheima.demo0;

public class demo0 {
    public static void main(String[] args) {
        String name="我爱你中国";
        System.out.println(name);
        String s1=new String();
        System.out.println(s1);
        String s2=new String("我爱你中国");
        System.out.println(s2);
        char[] chars={'a','b','中','国'};
        String s3=new String(chars);
        System.out.println(s3);
        byte[] bytes={97,98,99,65,66,67};
        String s4 =new String(bytes);
        System.out.println(s4);

    }
}

区别：

以“ ”方式给出的字符串对象，在字符串常量池中存储（同一个），而且相同内容只会在其中存储一份；

通过构造器new对象，每new一次都会产生一个新对象，放在堆内存中（分开存储）。

3.String常见面试题

package com.itheima.demo0;

public class demo0 {
    public static void main(String[] args) {
       String s1="abc";
       String s2="a"+"b"+"c";
        System.out.println(s1==s2);
    }
}

4.String类常用API-字符串内容比较

字符串内容不适合“==”来进行比较，基本数据类型比较时使用。

字符串的内容比较：

推荐使用String类提供的“equals”比较：只关心内容一样即可

方法名	说明
public boolean equals(object anobject)	将此方法串与指定对象进行比较。只关心字符内容是否一致
public boolean equalsIgnoreCase(String anotherString	将此字符串与指定对象进行比较，忽略大小写比较字符串，只关心字符内容是否一致

package com.itheima.demo0;

import java.util.Scanner;

public class demo0 {
    public static void main(String[] args) {
        String okName="itheima";
        String okPassword="12345";
        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("用户名或者密码错误了！");
        }
        String sysCode="23AdFh";
        String code1="23aDfH";
        System.out.println(sysCode.equals(code1));
        System.out.println(sysCode.equalsIgnoreCase(code1));
    }
}

5.String类常用API-遍历、替换、截取、分割操作

public int length()返回此字符串的长度。 长度等于字符串中的Unicode code units的数量。

public char charAt(int index)返回指定索引处的char值。指数范围为0至length() - 1 。序列的第一个char值位于索引0 ，下一个位于索引1 ，依此类推，就像数组索引一样。如果char由索引指定的值是surrogate ，则返回所述替代值。

public String substring(int beginIndex, int endIndex)返回一个字符串，该字符串是此字符串的子字符串。子字符串从指定的beginIndex开始，并扩展到索引endIndex - 1处的字符。因此子串的长度是endIndex-beginIndex 。

public String substring(int beginIndex)返回一个字符串，该字符串是此字符串的子字符串。子字符串以指定索引处的字符开头，并延伸到此字符串的末尾。

public String replace(CharSequence target, CharSequence replacement)将此字符串中与文字目标序列匹配的每个子字符串替换为指定的文字替换序列。替换从字符串的开头到结尾，例如，在字符串“aaa”中将“aa”替换为“b”将导致“ba”而不是“ab”。参数target - 要替换的char值序列replacement - char值的替换序列。

public String[] split(String regex, int limit)将此字符串拆分为给定regular expression的匹配项。此方法返回的数组包含此字符串的每个子字符串，该子字符串由与给定表达式匹配的另一个子字符串终止，或者由字符串的结尾终止。数组中的子串按它们在此字符串中出现的顺序排列。如果表达式与输入的任何部分都不匹配，那么结果数组只有一个元素，即该字符串。当在该字符串的开头存在正宽度匹配时，在结果数组的开头包含空的前导子字符串。然而，开头的零宽度匹配从不会产生这样的空前导子串。limit参数控制应用模式的次数，因此会影响结果数组的长度。

如果限制为正，则模式将应用最多限制 - 1次，数组的长度不会超过限制，并且数组的最后一个条目将包含超出最后一个匹配分隔符的所有输入。
如果限制为零，则模式将尽可能多地应用，数组可以具有任何长度，并且将丢弃尾随空字符串。
如果限制为负，则模式将尽可能多地应用，并且数组可以具有任何长度。

package com.itheima.demo0;

public class demo0 {
    public static void main(String[] args) {
        String name="我爱你中国love";
        System.out.println(name.length());
        System.out.println(name.charAt(1));
        for (int i = 0; i < name.length(); i++) {
            System.out.println(name.charAt(i));
        }
        char[] chars=name.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            char ch=chars[i];
            System.out.println(ch);
        }
        String name4="王宝强，贾乃亮，陈羽凡";
        String[] names=name4.split("，");
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);
        }
    }
}

6.String案例

需求：随机产生一个5位的验证码，每位可能是数字、大写字母、小写字母。

package com.itheima.demo0;

import java.util.Random;

public class demo0 {
    public static void main(String[] args) {
        String datas="abcdefghigklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";
        String code="";
        Random r=new Random();
        for (int i = 0; i < 5; i++) {
            int index= r.nextInt(datas.length());
            char c=datas.charAt(index);
            code+=c;
        }
        System.out.println(code);
    }
}

需求：模拟用户登录功能，最多只给三次机会。

package com.itheima.demo0;

import java.util.Scanner;

public class demo0 {
    public static void main(String[] args) {
        String okLoginName="admin";
        String okPassword="itheima";
        Scanner sc=new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            System.out.println("请输入登录名称：");
            String loginName = sc.next();
            System.out.println("请您输入登录密码：");
            String password= sc.next();
            if(okLoginName.equals(loginName)){
                if(okPassword.equals(password)){
                    System.out.println("登陆成功！");
                    break;
                }else {
                    System.out.println("你的密码不正确！你还剩余"+(3-i)+"次机会登录！");
                }
            }else{
                System.out.println("登录名称错误了!你还剩余"+(3-i)+"次机会登录!");
            }
        }
    }
}

需求：以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽。

package com.itheima.demo0;

import java.util.Scanner;

public class demo0 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入手机号码：");
        String tel = sc.next();
        String s1=tel.substring(3,7);
        String s = tel.replace(s1, "****");
        /*String bef = tel.substring(0, 3);
        String aft = tel.substring(7);
        String s=bef+"****"+aft;*/
        System.out.println(s);
    }
}

(3)ArrayLIst简单介绍

ArrayList代表的是集合类，集合是一种容器，与数组类似，不同的是集合的大小是不固定的；

通过创建ArrayList的对象表示得到一个集合容器，同时ArrayList提供了比数组更好用，更丰富的API（功能）给程序员用。

1.集合概述：

集合是与数组类似，也是一种容器，用于装数据的。

数组定义完成并启动后，类型确定、长度固定；

问题：在个数不能确定，且要进行增删数据操作的时候，数组是不太合适的。

集合的特点：

集合的大小不固定，启动后可以动态变化，类型也可以选择不固定；

集合非常适合做元素个数不确定，且要进行增删操作的业务场景；

集合提供了许多丰富、好用的功能，而数组的功能很单一。

2.ArrayList集合：

ArrayList是集合中的一种，它支持索引。

ArrayList集合的对象获取：

构造器	说明
public ArrayList()	创建一个空的集合对象

ArrayList集合添加元素的方法：

方法名	说明
public boolean add(E,e)	将指定的元素追加到此集合的末尾
public void add(int index,E element)	在此集合中的指定位置插入指定的元素

ArrayList对于泛型的支持：

ArrayList<E>：其实就是一个泛型类，可以在编译阶段约束集合对象只能操作某种数据类型。

举例：

ArrayList < String > ：此集合只能操作字符串类型的元素。

ArrayList < Integer > ：此集合只能操作整数类型的元素。

注意：泛型只能支持引用数据类型，不支持基本数据类型。

ArrayList常用方法、遍历:

方法名称	说明
public E get(int index)	返回指定索引处的元素
public int size()	返回集合中的元素的个数
public E remove(int index)	删除指定索引处的元素，返回被删除的元素
public boolean remove(Object o)	删除指定的元素，返回删除是否成功
public E set(int index,E element)	修改指定索引处的元素，返回被修改的元素

ArrayList集合案例：遍历并删除元素:

package com.itheima.demo0;

import java.util.ArrayList;

public class demo1 {
    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);
        //方式一：
        /*for (int i = 0; i < scores.size(); i++) {
            Integer 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);
    }
}

ArrayList集合案例：存储自定义类型的对象:

package com.itheima.demo0;

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

package com.itheima.demo0;

import java.util.ArrayList;

public class demo2 {
    public static void main(String[] args) {
        Movie m1=new Movie("《肖生客的救赎》",9.7,"罗宾斯");
        Movie m2=new Movie("《霸王别姬》",9.6,"张国荣");
        Movie m3=new Movie("《阿甘正传》",9.5,"汤姆·汉克斯");
        ArrayList<Movie> movies=new ArrayList<>();
        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());
            System.out.println("电影得分："+m.getScore());
            System.out.println("电影主演："+m.getScore());
            System.out.println("====================");
        }

    }
}

ArrayList集合案例：元素搜索:

package com.itheima.demo0;

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


    public Student() {

    }

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

    public String getStudyNumber() {
        return studyNumber;
    }

    public void setStudyNumber(String studyNumber) {
        this.studyNumber = studyNumber;
    }

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

package com.itheima.demo0;

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

public class demo3 {
    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","西门吹雪",26,"中药学四班"));
        students.add(new Student("20180305","梅超风",26,"神经科二班"));
        System.out.println("学号\t\t\t姓名\t\t年龄\t班级");
        for (int i = 0; i < students.size(); i++) {
            Student s = students.get(i);
            System.out.println(s.getStudyNumber()+"\t"+s.getName()+"\t"+s.getAge()+"\t"+s.getClassName());
        }
        Scanner sc=new Scanner(System.in);
        while (true) {
            System.out.println("请您输入学号查询学生对象：");
            String studyNumber = sc.next();
            Student s= getStudentById(students,studyNumber);
            if(s==null){
                System.out.println("对不起，查无此人···");
            }else{
                System.out.println("您查询的学生信息如下：");
                System.out.println(s.getStudyNumber()+"\t"+s.getName()+"\t"+s.getAge()+"\t"+s.getClassName());
                return;
            }
        }
    }
    //定义方法 完成按照学号的搜索功能

    /**
     * 根据学生的学号查询学生对象返回
     * @param students 存储全部学生对象的集合
     * @param studyNumber 搜索的学生的学号
     * @return 学生对象/null
     */
    public static Student getStudentById(ArrayList<Student> students,String studyNumber){
        for (int i = 0; i < students.size(); i++) {
            Student s = students.get(i);
            if(s.getStudyNumber().equals(studyNumber)){
                //这个s代表的学生对象，就是我们要找的：返回它
                return s;
            }
        }
        return null;
    }
}