A Java基础整合---从配置环境变量到完成学生管理系统-阿里云开发者社区

1 java基础知识梳理

用思维导图，结构化展现java基础大概内容。

2 开发环境搭建

学习编程，必须有自己的开发环境

2.1 安装JDK

1.拓展知识：

java语言是跨平台语言，一套java代码可以去多个系统软件上运行（Windows、macOS、Linux…）,但前提是需要在系统软件上安装有java运行环境(JRE)；

JRE：（java Runtime Environment）java运行环境，它**包含java虚拟机(JVM)**和一些标准类库；

JVM：(Java Virtual Machine)，java字节码文件(.class)在虚拟机上运行。java程序离不开java虚拟机。

JDK： Java Development Kit，java语言开发工具包，包含java运行环境JRE和java工具

JDK、JRE、JVM三者之间是包含与被包含关系

2.安装JDK

打开浏览器输入甲骨文公司官网(https://www.oracle.com),在导航栏点击产品（Products）进入页面底部，选择java

进入java页面，翻到页面底部选择Orele JDK

进入下载页面根据需求下载

安装过程一路next就可以（如果想修改安装目录，最好安装在纯英文目录下）

2.2 配置环境变量

为什么要配置环境变量？

答：因为在不配置环境变量的情况下，java的编译运行操作只能在java安装目录下进行，使得工作很难展开。（高版本JDK会自动配置环境变量，存在功能不全问题；建议手动配置）

配置工作

找到此电脑，右击选择属性

进入属性界面后选择高级系统设置

进入系统设置后选择高级，再选择环境变量设置

进入环境变量配置页面后在系统环境变量下，选择新建

新建JAVA_HOME并配置安装目录到jdk版本目录

在path环境变量下，添加新配置;配置内容：“%JAVA_HOME%\bin”

到这里配置就算完成了。

怎么检查是否配置成功？

答：在键盘上，按住win键+R键，输入“cmd”；

然后在DOS窗口输入“java -version”如果有出现java版本信息，那么恭喜你成功啦

3 java基础语法

清楚基础语法知识对于后期学习是十分必要的，一点一点的必须搞懂；

注意：【java语言中对字母的大小写是严格区分的，大写和小写代表两个东西。】

我们先看一个完整java程序案例：

案例1 — HelloWord案例

public class HelloWord {
    public static void main(String[] args) {
        System.out.println("HelloWrod");
    }
}

3.1 标识符和关键字

什么是标识符？

标识符：java开发中用到的名字，就是各种名字：变量名、类名、包名等等；

案例1中：HelloWord是类名、main是方法名，args是变量名；这些都是标识符

名字呢不能乱起，那么该如何命名？【标识符的命名规则】

只能由：数字、字母、下划线(_)和“$”组成！不能出现其他任何字符。

不能以数字开头

江湖规则1：小驼峰命名法，一个单词时全小写，多个单词时从第二个单词开始首字母大写，常见在（变量、方法名）

江湖规则2：大驼峰命名法，每个单词首字母大写常见在（类名）话说不遵守江湖规则是行不通滴；

注意：【标识符要做到见名知意】

关键字是什么？

关键字：java中有特殊含义的单词，在高级记事本或者集成开发环境中都会用不同的颜色显示；不需要特意背知道常见，慢慢积累；

java常用关键字：

class	public	static	private
break	continute	default	import
if	else	for	while
int	short	char	double
float	switch	long	return

3.2 常量和变量

常量和变量都描述的是数据，数据有不同的类型我们首先了解一下java中的数据类型

1.常量：就是值不会发生改变的数据，比如：2，‘a’,"java"等等

此处需要注意的是：

浮点型常量：浮点型就是小数类型常量，小数默认是double类型，如果是float类型数值后必须加F或f

字符型常量：用单引号括起来的的单个字符如：‘a’、‘6’、'A’等等；

字符串常量：用双引号括起来的内容如：“helloword”、“15121”、" "等等；

注意：空字符串""，字符串的值为空；空字符’'会报错

2.变量：变量定义格式

数据类型变量名；

数据类型变量名 = 变量值；

3.3 运算符

1.算术运算符：

符合含义

+、-、*、/ 与数学中使用方法一样

% 取模（也叫取余）

++、- - 自增、自减运算符

算术运算符注意事项【面试题】：

以下语句会不会报错？为什么？
  short num1 = 10,num2;
        byte num3 = 20;
        num2 = num1+num3;      //第一句
        //---------------------------------------------------
        num2 = 200+30;    //第二句
        //-------------------------------------------------
        num3 = 120+10;      //第三句
        //-------------------------------------------------
        //解析
        /*
    第一句：会报错，这边存在一个隐式转换；【任何整型变量在计算时都会默认转为int类型】再做计算；此处num1与num3会先转int计算完再赋值，然而num2是short类型，大类型值赋值给小类型会报错；
    第二句：不会报错，此处存在常量优化机制，因为200与30都是常量，在编译过程中会将结果计算出来，再给num2赋值；num2是short类型230在它的范围内；所以不会出错；
    第三句：会报错，虽然java有常量优化机制，但是，此处优化后的结果是130，超出了byte的范围；【byte范围：-128----+127】
  */

2.赋值运算符：

符号含义

= 赋值运算符，将符号右边的值赋给左边变量

+= 加等

-= 减等

/= 除等

%= 取模等

赋值运算案例：

int  num2  = 20;  //把 常量20赋给num2
  //-----------------------------------------------
  byte num3 = 20;
        num3 += 20; //此处实质是：num3 = (num3类型)（num3+20）

注意：【类似+=、-=、%=这样的赋值运算存在默认强制转换机制】

3.判断运算符：

符号含义

==、!=、等于、不等于

“>”、<、>=、<= 大于、小于、大于等于、小于等于

4.逻辑运算符：

符号含义

&、!、与、非

&& 短路与

|        // 逻辑或
^        // 逻辑异或
||   // 短路或

两个变量值互换要求：不用第三方变量【面试题】：

方案1 数学思维解决

int num1 = 20;
        int num2 = 30;
        num1 = num1+num2;
        num2 = num1-num2;
        num1 = num1-num2;

方案2 用异或解决【一个数被另一个数连续异或两次，这个数值不变】

int num1 = 20;
        int num2 = 30;
        num1 = num1^num2;
        num2 = num1^num2;
        num1 = num2^num1;

4 数组

4.1 一维数组

1. 数组概念：

数组是一个可以存储多个相同数据类型的数据的容器；

2. 数组的定义与初始化

数据类型 [ ] 数组名；

数据类型数组名 [ ]；

3. 静态初始化，两种格式：

完整格式1

数据类型 [ ] 数组名 = new 数据类型[ ] { 数据1,数据2,数据3… };

简化格式2

数据类型 [ ] 数组名 = { 数据1,数据2,数据3… };

静态初始化案例-1

//数组定义初始化完整格式
        int [] arr1 = new int[]{1,2,3};
        //数组定义初始化简化格式
        int [] arr2 = {1,2,3};

4. 动态初始化格式

数据类型 [ ] 数组名;

数组名 = new 数据类型 [ 所需的存储空间];

动态初始化案例-2

int [] arr3;//定义数组
  arr3 = new int[10];//动态初始化
  arr3[0] = 15;
  arr3[1] = 20;
  .
  .
  .
  arr[9] = 9

5. 数组元素访问

索引

索引的概念：容器中空间的编号就是索引，索引值从0开始（容器中空间编号从0开始）

元素：数组中存储的数据被称为

访问格式

格式：数组名 [索引值]；

eg: int [] arr2 = {1,2,3};

arr2[0];

arr2[1];

注意：数组元素以索引值访问时只能，一个一个单独访问，不能同时出现多个索引值;

–

错误示例： arr2[0,1,2];

访问案例

int [] arr2 = {1,2,3};
 System.out.println("arr2数组中第一元素为："+arr2[0]);

6. 数组遍历

数组遍历：就是把数组中的每个元素，依次都访问一遍；

数组遍历，输出所有元素格式：

for (int i = 0; i < 数组长度; i++) {

System.out.println(“数组值：”+数组名[i]);

}

友情提示:【IDEA快捷键—生成遍历框架【数组名 .fori +Enter 】

案例2—数组案例集

数组遍历输出案例-3

int [] arr2 = {1,2,3};//定义，静态初始化数组
for (int i = 0; i < arr2.length; i++) {
    System.out.println("数组值："+arr2[i]); //遍历输出arr2数组中的每个元素
}

求数组元素偶数和案例-4

int [] arr4 = {1,2,3,4};   //静态初始化数组
        int sum =0;
        for (int i = 0; i < arr4.length; i++) {
            if (arr4[i]%2==0){  //通过取模筛选出所有偶数
                sum += arr4[i]; //累加计算偶数和
            }
        }
        System.out.println("数组元素中所有偶数和为："+sum); //输出偶数和

求数组元素中最大值案例-5

public static void main(String[] args) {
        int [] arr5 = {1,15,20,9,88,8}; //静态初始化数组
        for (int i = 1; i < arr5.length; i++) {
            if (arr5[0]<arr5[i]){ //筛选出大于arr5[0]的数
                arr5[0] = arr5[i];//将筛选出的数，赋值给arr5[0]
            }
        }
        int max = arr5[0];    //将arr5[0]赋值给max变量
        System.out.println("次数组最大值为："+max);
    }

4.2 数组初始化内存分配图解

public static void main(String[] args) {
        int [] arr = new int [7]; //动态初始化一个长度为10的数组
    }

方法区： java中字节码文件会存在方法区；【注意：字节码文件不调用不加载】

栈内存： java把内存分为两部分，栈内存和堆内存，基本类型变量存于栈内存，栈内存存储特点，先进栈的内容后出栈；

堆内存：所有new出来的东西存放在堆内存中。

当arr的值为null时，再访问arr数组元素时，就会出现空指针异常，报错如下：

Exception in thread "main" java.lang.NullPointerException
  at HelloWord.main(HelloWord.java:8)

4.3 二维数组

二维数组就是，一维数组的元素时一维数组；也就是数组存数组，这边不详细展开

5 流程控制

流程控制在各编程语言中通用，所以这是必须要掌握的第4点内容

5.1 顺序结构

程序默认是按照从上往下的顺序，执行流程；

5.2 分支结构

5.2.1 if语句（判断条件最终必须为：布尔类型值）

简单if语句格式：

语句格式：

if (判断条件){

语句体; //判断条件成立执行语句体；

}

int nub1 = 1;
int nub2 = 2;
if(nub1>nub2){
       System.out.println("执行了语句体");  //判断条件为false，此语句不执行；
}

if…else if…else…语句格式

语句格式：

if (判断条件1){

语句体1; //判断条件成立执行语句体1；

}else if(判断条件2){

语句体2; //判断条件1不成立,判断条件2成立，执行语句体2；

}else{

语句体3; //判断条件1和2都不成立执行语句体3；

}

案例3—成绩奖励（if案例）

/*
考试奖励：
    分数>=90:奖励自行车一辆
    90>分数>=80:奖励游乐园一日游
    80>分数:一顿狂揍
*/
public class IfTest {
    public static void main(String[] args) {
        int chengji;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入成绩：");
           chengji = sc.nextInt();
           if (chengji <=100 && chengji>=0){
               if (chengji>=90){
                   System.out.println("恭喜！奖励自行车一辆！");
               }else if (chengji>=80 && chengji<90){
                   System.out.println("恭喜！奖励游乐园一日游！");
               }else{
                   System.out.println("来吧一顿接受狂揍！");
               }
           }else{
               System.out.println("成绩输入有误！");
           }
    }
}

5.2.2 switch语句

switch语句格式：如下伪代码所示

switch(variable){
           case 1:
               语句体1;
               break;
           case 2:
              语句体2;
               break;
           case 3:
               语句体3;
               break;
               .
               .
               .
           default:
               默认语句;
               break;
       }

variable的取值范围

基本类型：byte、short、int、long

引用类型：jdk5开始，允许枚举类型；jdk7开始，允许String

jdk14开始允许，一个case 后跟多个值：case 1,2,3:

if与switch选用：范围性的判断用if更合理；switch更适合固定值判断；

2.case穿透（可以优化代码）

case穿透示例：如果有多个重复的语句体可以使用case穿透

switch(variable){
    case 1:
    case 2:
    case 3:
        //重复语句体；
        break;
    default:
        break;

3.jdk14以后新特性（可以优化代码）

case穿透示例：如果有多个重复的语句体可以使用case穿透

switch(variable){
    case 1,2,3:
        //重复语句体；
        break;
    default:
        break;
}

案例4 — 成绩录入输出评价（switch案例）

等级评语

A 成绩良好

B 成绩中等

C 及格

D 成绩不合格

System.out.println("请输入成绩：可选项【A、B、C、D】");
        switch ('B') {
            case 'A':
                System.out.println("成绩良好");
                break;
            case 'B':
                System.out.println("成绩中等");
                break;
            case 'C':
                System.out.println("及格");
                break;
            default:
                System.out.println("成绩不合格！");
                break;
        }

switch语句执行流程：

第一步：拿variable值与case值对比，如果对比结果相等，则进入语句体，直到遇到break；或者执行结束才会退出switch语句；

第二步：如果在case中没有匹配到值，就会进入default语句，直到遇到break;或者执行结束才会退出switch语句。在switch语句中执行顺序与case 、default的位置无关；

知识拓展【三目运算符：】

三目运算符格式：

判断条件？值1 : 值2；

执行流程：

1 判断条件是否为真？

2 如果判断条件为真，则值1 赋给这这条语句的结果；

3 如果判断条件为假，则值2 赋给这这条语句的结果；

案例5—三目运算符操作案例：

public void  operator(){
    int a,b,c;
    a = 10;
    b = 20;
    //第一种情况判断条件(b>a)为真
    c = b>a ? a:b;//c的值为10；
    //第二种情况判断条件(b
    c = b
}

5.3 循环结构

for(初始化语句;条件判断语句;条件控制语句){
       //循环体语句;
    }
//在for循环中，初始化语句只执行1次；
//for循环案例：
 public static void main(String[] args) {
        for(int i =0;i<3;i++){
            System.out.println("执行第"+i+"次循环！");
        }
    }

for循环执行流程（重中之重）

for(初始化语句;条件判断语句;条件控制语句){
       //循环体语句;
    }

注意：【在for循环中初始化语句只执行一次】

案例6 — 求100以内偶数和(for循环案例)

//for循环案例3（1-100之间的偶数和）
//实现方案1
        int sum =0;
        for (int i = 1;i<=100;i++){
            if (i%2==0){
                sum += i;
            }
        }
        System.out.println("1-100之间偶数和为："+sum);
//实现方案2
        int sum =0;
        for (int i = 2;i<=100;i+=2){
                sum += i;
        }
        System.out.println("1-100之间偶数和为："+sum);

案例7 — 打印所有水仙花数（for循环）

需求分析：什么是水仙花数？

答：水仙花数是一个三位数，它的每个位上的数字的 3次幂之和等于它本身。

步骤分析：

1 通过for循环筛选出三位数

2 通过if按照水仙花数概念，晒出水仙花数

//for循环找出水仙花数
        for (int i=100;i<=999;i++){
            int ge,shi,bai; //定义各位、十位、百位变量准备后续操作
            ge = i%10;
            shi = i/10%10;
            bai = i/100;
            //用if对水仙花数条件进行筛选
            if (i==(ge*ge*ge+shi*shi*shi+bai*bai*bai)){
                System.out.println("水仙花数："+i);
            }
        }

6 java中的方法

6.1方法的概念与功能

方法概念：具有独立功能的代码块【在其他语言中也叫函数】

IDEA涨知识：Ctrl + F12，打开类的大纲

6.2 方法定义格式：

修饰符返回值类型方法名(参数类型参数名1，参数类型参数名2){

return 返回值；

}

6.2.3 形参（形式参数）与实参（实际参数）

形参：定义方法时声明的参数

实参：调用时传入的实际参数

//形参
public static void prints(int num) { //此处的 num就是形参
     //方法体语句
 }
//main方法调用prints()方法时需要传实参
 public static void main(String[] args) {
          prints(5);    //此处5就是实际参数
 }

案例8— 方法定义

//1无参方法
    public static void prints() {
        System.out.println("*******************");
    }
//2带参方法
    //案例1 主方法：
        public static void main(String[] args) {
                //方法体语句
        }
    //案例2 自定义方法：
         public static int sum(int num1,int num2){
                int sum = num1+num2;
                return sum;//返回值
         }

6.3 自定义方法的位置：

方法与方法之间保持平级关系，方法不允许嵌套定义；

6.4 方法的调用与执行：

方法不调用不执行：

方法的执行顺序与编写顺序无关，只与调用顺序相关；

方法的调用方式1：用类名直接调用，被static修饰的方法，属于类所有，可以直接用:类名.方法名(); 直接调

方法的调用方式2：通通对象调用，对象名.方法名();

6.5 方法调用内存图解

6.6 java方法的值传递与址传递

问题：在java中方法传参到底是值传递还是址传递？

案例1：【问：num1的值会不会变？答：不会】

public static void main(String[] args) {
        int num1 = 100; //定义变量num1
        test1(num1);    //把num1，作为参数传给test1方法
        System.out.println(num1);
    }
    public static int test1(int num1){
        return num1 = 200; //在test1方法中，给num1重新赋值
    }

基本数据类型作为参数的内存图解：

2. 引用类型数据

案例1：【问：num1的值会不会变？答：会】

public static void main(String[] args) {
        int [] num1 = {10,11}; //定义数组num1
        test1(num1);    //把num1地址，作为参数传给test1方法
        System.out.println(num1[0]);
    }
    public static int test1(int [] num1){
        return num1[0] = 200; //在test1方法中，给num1[0]重新赋值
    }

引用类型数据作为参数的内存图解：

案例9— 定义方法做输出

public static void prints(int freq) {
        if(freq<0 ){
            System.out.println("输入次数有误，请重新输入：");
        }else {
            for (int i = 0; i < freq; i++) {
                System.out.println("学好编程！");
            }
        }
    }

7 初识面向对象

面向对象是java语言的一大特征，也是java学习分水岭，理解掌握好这块基础对后期学习而言非常必要

7.1 类与对象

7.1.1. 类是什么？

答：类是把一类事物的属性，行为抽象成一个java文件，用文件来表现这类事物，那么这个文件就是一个类；

7.1.2. 对象是什么？

答：对象是类的一个具象，比如：通过一个描述所有人特征的类，可以具象出某一个具体的人如张三；通过人类产生的这个张三，就是人类的一个对象；

成员变量成员变量是对同一类事物共同属性的一个抽象

成员方法成员方法是对同一类事物共同行为的一个抽象

public class Students {
   int age;         //学生类成员变量age
   String name;     //学生类成员变量name
   void speak(){    //学生类成员方法speak
       System.out.println("大家好！我是"+name+"今年"+age+"岁");
   }
}

【注意：】类定义时，class前的public有什么用?

答：public修饰的类有最大权限，大家都可以访问，程序的主类必须用public修饰；被public修饰的类，类名与文件名必须保持一致，否则报错；

7.1.5. 对象的创建和使用

对象的创建格式：

类名对象名 = new 类名();

案例10—根据案例9创建学生对象张三

public static void main(String[] args) {
        Students zhangsan = new Students();  //创建学生对象张三
        zhangsan.age = 18;          //用对象为成员方法赋值
        zhangsan.name = "张三";       
        zhangsan.speak();          //用对象调用成员方法
    }

7.2 构造方法

构造方法又叫构造器

是在构建、创造对象的时候调用的方法，（没有构造方法不能创建对象）

注意：【一个类中如果没有手动写构造方法，系统会默认提供一个无参构造方法】

7.2.1. 构造方法格式

构造方法名与类名相同

没有返回值类型，连void也没有

没有具体返回值，不能使用return带回结果

注意：【在构造方法中“return;”是可以存在的，this代表当前类对象的地址，谁调用代表谁】

案例1-构造方法格式

class Students{   //创建Students类
    String name;  //成员变量name
    int age;      //成员变量age
    //无参构造方法
    Students(){}
    //带参构造方法
    Students(int age,String name){ 
        this.age = age;   //通过局部变量为成员变量age赋值
        this.name = name; //通过局部变量为成员变量name赋值
    }
}

7.2.2. 构造方法的作用

2.1 本质作用是用于创建对象

2.2 可以在创建对象的时候，直接给成员变量赋值

案例2–通过构造方法为成员变量赋值

public class ThisDemo {
    public static void main(String[] args) {
        Students stu1 = new Students(18,"小明"); //创建对象stu1,并传参
    }
}
class Students{
    String name;  //成员变量
    int age;      //成员变量
    Students(int age,String name){ //构造方法
        this.age = age;   //通过局部变量为成员变量age赋值
        this.name = name; //通过局部变量为成员变量name赋值
    }
}

7.2.3. 构造方法内存解析（案例2解析）

注意：【字节码文件不调用不加载】

7.3 java面向对象的特征

话说java万物皆对象，怎么理解呢？

答：生活中的所有事务我们都可以进行归类，归类后就能找出共性，共同属性，共同行为等等那么就可以将事物抽象成类；一个类可以创建无数对象，这样就便于开，发节省开发成本。也就是万物皆对象。

7.3.1 java的封装

什么是封装？

答：大概可以这么理解，就好比公开且无人管的器材室，所有人都可以随意出入，里面篮球🏀、足球⚽、羽毛球🏸等等器材大家都可以自由使用想怎么用就怎么用。封装就是现在来了一个管理员器材室不能随意出入了，你要东西可以，但是不能让你自己随意拿了，得经过管理员之手。(这段纯属我自己理解的，有问题欢迎在评论区指正)

a. 此处公开就对应权限修饰：public，被public修饰的属性用最大权限，可以被任意class调用；

b. 不公开就对应：private，被private修饰的属性只能在本类内部使用，外部无法直接访问，但是可以通过类提供的public修饰的方法间接访问。

为什么要封装？封装有什么好处？

外部不能直接访问、提高代码的安全性，可控性更方便管理；

降低程序复杂度。

案例11—学生类的封装案例

public class Studens {
    private int age;        //定义成员变量 age并私有
    private String naem;    //定义成员变量 name并私有
    public Studens() {      //无参构造
    }
    public Studens(int age, String naem) {  //带参构造
        this.age = age;
        this.naem = naem;
    }
    public void speak(){
        System.out.println("讲中国话");     // 成员方法
    }
    public int getAge() {                  //为外部提供变量访问的方法getXxx方法
        return age;
    }
    public void setAge(int age) {           //为外部提供变量访问的方法setXxx方法
        this.age = age;
    }
    public String getNaem() {               //为外部提供变量访问的方法getXxx方法
        return naem;
    }
    public void setNaem(String naem) {      //为外部提供变量访问的方法setXxx方法
        this.naem = naem;
    }
}

继承、多态java进阶补充；

7.3.2 java的继承

7.3.3 java的多态

8 初识javaAPI

javaAPI（Application Programming Interface）应用程序编程接口

public static void main(String[] args) {
        boolean flag;
        //第一题
        String str1 = "hello";
        String str2 = new String("hello");
        flag = str1 == str2 ;
        System.out.println("第一题，输出为true还是false？："+flag);
        //第二题
        String str3 = "hello";
        flag = str1 == str3;
        System.out.println("第二题，输出为true还是false？："+flag);
    }

解析：①此处涉及到字符串常量池知识，在用“”直接创建字符串对象时，首先会到字符串常量池中查找是否有该字符串，如果有直接从常量池中把地址拿给字符串常量，如果没有则往常量池中添加新元素。

②用new方法创建字符串对象时，在栈内存开辟变量空间后，再到堆内存new出一块新空间，此时拿参数字符串对象去常量池中复制一份赋值给new出来的空间，再将空间地址赋给字符串变量；

String类的常见方法

方法功能

boolean equals（Object anObject）比较两个字符串是否相等

boolean equalsIgnoreCase(String anotherString) 比较两个字符串是否相等(忽略大小写)

char [] toCharArray() 将字符串转换为一个新的字符数组

案例13—自定义方法统计指定字符在本字符串中出现的次数

public static int countChar(String String, char cha) {
        int count = 0;                          
        char []arr = String.toCharArray();      //使用String类的toCharArray方法将字符串转为字符数组
        for (int i = 0; i < arr.length; i++) {  //for循环遍历数组
            if (cha == arr[i]){                 //if语句对比字符，用count统计
                count ++;
            }
        }
        return count;                           //返回统计数
    }

8.3 Random类

方法含义

int nextInt(int n) 返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。

规则简单记：【包左不包右】

案例14—java小游戏【猜数字】

public static void numGame() {
        int count = 3;                                    //控制循环次数
        Random r = new Random();
        int num = r.nextInt(100)+91;               //生成0---100的随机数
                Scanner sc = new Scanner(System.in);
        while (count > 0){                               //循环控制输入次数
            System.out.println("请输入1--100的随机数值：");
            int numb = sc.nextInt();
            if (num==numb) {
                System.out.println("恭喜您猜对啦！");
                break;
            }else if (numb
                System.out.println("您猜的数偏小，您还有"+(count-1)+"次机会！");
                count --;
            }else {
                System.out.println("您猜的数偏大，您还有"+(count-1)+"次机会！");
                count --;
            }
        }
    }

9 初识集合

9.1 ArryList集合

ArrayList构造方1

public ArrayList();

泛型：<>

在类名之后加<>,可以使集合存储的数据类型，进行类型限制；

尖括号中只能使用引用数据类型，不能是基本数据类型

1 ArrayList的常用成员方法

增

public boolean add(E e);向集合尾部添加数据，返回添加成功的状态

public void add(int index,E element);插队添加

ArrayList list1 = new ArrayList<>();//创建list集合
        list1.add("张三");                    //添加元素

删

public E remove(int index);根据索引删除集合中的元素

public boolean remove(元素);根据元素删除集合中的内容，重复元素只删除第一个；返回添加成功的状态

ArrayList list1 = new ArrayList<>();//创建list集合
        list1.add("张三");                    //添加元素
        list1.add("王五");
        list1.add("上官铁蛋");
        list1.add("张三");
        list1.add("诸葛订单");
        list1.remove("张三");                //根据元素删除
        list1.remove(2);                    //根据索引值删除元素

改

public E set(int index,E element);修改指定索引位置，返回被覆盖的元素

ArrayList list1 = new ArrayList<>();//创建list集合

list1.add("张三");                   //添加元素
        list1.add("王五");
        list1.add("上官铁蛋");
        list1.add("张三");
        list1.add("诸葛订单");  
        list1.set(2,"年薪百万");             //修改集合数据

查

public E get(int index);根据索引，获取集合中的元素

ArrayList list1 = new ArrayList<>();//创建集合

list1.add("张三");                        //添加元素
        list1.add("王五");
        list1.add("上官铁蛋");
        list1.add("张三");
        list1.add("诸葛订单");
        list1.get(2);                           //查找集合元素

案例15 ----ArrayList初使用

创建一个存储字符串集合，存储5个字符串元素，找出4个字的人名，并打印

public static void main(String[] args) {
        ArrayList list1 = new ArrayList<>();//创建list集合
        list1.add("张三");                           //添加元素
        list1.add("王五");
        list1.add("上官铁蛋");
        list1.add("张三");
        list1.add("诸葛订单");
        for (int i = 0; i < list1.size(); i++) {    //遍历集合
            String name = list1.get(i);             //获取集合元素
            if (list1.get(i).length()==4){          //判断字符串长度是否为4
                System.out.println(name);           //打印4个字的名字
            }
        }
    }