java笔记1

最新推荐文章于 2023-10-06 16:25:34 发布

Eli-sun

最新推荐文章于 2023-10-06 16:25:34 发布

阅读量360

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/vfjcgg/article/details/113765861

版权

java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

位(bit):一个数字0或者一个数字1，代表一位

字节(bite):每逢8位是一个字节，这是数据存储的最小单位

1KB = 1024byte

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

命令提示符(cmd) 启动win + R

命令提示符的常用命令：

切换盘符大小写不区分

cd … 回到上一级文件夹

cd 文件名\文件名\文件名到这个文件夹

查看当前内容 dir

清屏 clear

退出 exit

第二章： java语言开发环境搭建

JDK是java程序开发工具包，包含JRE和开发人员的使用工具，JRE包含JVM核心

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B7K6w6jr-1612831449223)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210105160139703.png)]

public class HelloWorld{
	public static void main(String[] args) {
		System.out.println("hello world");
	}
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RbUiUm1b-1612831449227)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210105170026198.png)]

两个单引号之间必须有且仅有一个字符，没有不行

空常量不能用来打印输出

基本数据类型(整数型、浮点型、字符型、布尔型)

引用数据类型（字符串、数组、类、接口、lambda）

变量：程序运行期间，内容可以发生改变的量

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-55DBcnqr-1612831449228)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210105171515294.png)]

数据类型转换

当数据类型不一样时将会发生数据类型转换

自动类型转换（隐式）

1.特点：代码不需要进行特殊处理，自动完成

2.规则：数据范围从小到大

public class Demo01Const {
	public static void main(String[] args) {
		System.out.println(1024); // 这就是一个整数 默认就是int类型
		System.out.println(3.14); // 这就是一个浮点数 默认就是double类型
        // 左边是long类型 右边是默认的int类型 左右不一样
		long num1 = 100L;
		System.out.println(num1); //100
        
        double num2 = 2.5F;
        // 范围float更大一些 符合从小到大规则
        float num3 = 30L;
	}
}

强制类型转换（显式）

1.特点：代码需要进行特殊的格式处理不能自动完成

2.格式：范围小的类型范围小的变量名 = （范围小的类型）原本范围大的数据

public class Demo01Const {
	public static void main(String[] args) {
		// 左边是int类型 右边是long类型
		int num = (int)100L;
		System.out.println(num);
	}
}

注意事项：

1.强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出

2.byte/short/char这三种类型都可以发生数学运算，例如加法“+”

3.byte/short/char这三种类型在运算的时候，都会被首先提升成int类型，然后再计算

4.boolean类型不能发生数据类型转换

计算机的底层都是数字

一旦char进行了数学运算

运算符

运算符：进行特定操作的符号，例如：+

表达式：用运算符连起来的式子叫做表达式，例如：20+5 又例如：a+b

四则运算当中的加号+有常见的三种用法：

1.对于数值来说就是加法

2.对于char类型来说，在计算之前会被提升成为int,然后再计算

3.对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作

任何数据类型类字符串进行连接的时候，结果都会变成字符串

与（并且） && 全部是true 才是true 否则就是false

或（或者） || 至少一个是true 就是true 全都是false 才是false

非（取反）| 本来是true 变成false 本来是false 变成true

与&& ，或|| 具有短路效果，如果根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，从而节省一定的性能

一元运算符：只需要一个数据就可以进行操作的运算符，例如：取反，自增自减

二元运算符：

三元运算符：

方法入门

定义一个方法的格式：public static void 方法名称() {

方法体

}

方法名称的命名规则和变量一样，使用小驼峰

注意事项：

1.方法定义的先后顺序无所谓。

2.方法的定义不能产生嵌套包含关系。

3.方法定义好了不会执行，如果要执行一定要调用

如何调用方法：方法名称();

JShell脚本工具

JDK9的特点：jshell是JDK9特有的

启动jshell: jshell

退出：/exit

扩展知识点

在给变量进行赋值的时候，如果右边的表达式中全部都是常量，没有任何变量，那么编译器javac将会直接将若干个常量表达式计算得到结果。

short result = 5+9;

等号右边全都是常量，没有任何变量参与运算

编译之后，得到的.class字节码文件当中相当于直接就是：short result = 14

这称为“编译器的常量优化”

但是注意：一旦表达式中有变量参与，那么就不会进行这种优化了

流程控制语句

流程控制

顺序结构

判断语句

if(关系表达式){

语句体1;

}else if(判断条件){

语句体2;

}else{

语句体3;

}

选择语句

switch语句使用注意事项：

1.多个case后面的数值不可以重复

2.switch后面的小括号中只能是下列数据类型：

基本数据类型：byte/short/char/int

引用数据类型：String字符串、enum枚举

3.switch语句格式可以很灵活：前后顺序可以颠倒，而且break语句还可以省略。

匹配哪一个case就从哪一个位置向下执行，直到遇到了break或者整体结束为止。

switch(表达式) {

case 常量值1:

语句体1;

break;

case 常量值2:

语句体2;

break;

default:

语句体3;

break;

}

循环语句

循环结构的基本组成部分，一般可以是四个部分：

1.初始化语句：在循环开始执行，而且只做唯一的一次

2.条件判断：

3.循环体：

4.步进语句：每次循环之后都要进行的扫尾工作，每次循环都要进行一次。

for(初始化表达式；布尔表达式；进步表达式){

循环体;

}

while循环有一个标准格式，还有一个扩展格式

标准格式：

while（条件判断）{

循环体;

}

扩展格式：

while（条件判断）{

循环体;

步进语句;

}

do…while()循环

标准格式：

do{

循环体

}while(条件判断);

扩展格式：

do{

循环体;

步进语句;

}while(条件判断);

break关键字的用法有常见的两种：

1.可以用在switch语句中，一旦执行整个switch语句立刻结束。

2.还可以用在循环语句中，一旦执行，整个循环语句立刻结束，打断循环

关于循环的选择，有一个小建议：

凡是次数确定的场景多用for循环，否则多用while循环。

另一种控制语句是continue关键字。

一旦执行，立即跳过当前次循环剩余内容，马上开始下一次循环

扩展知识点：

1.死循环

2.嵌套循环

开发工具IntelliJ IDEA

IDE 集成开发环境

IDEA的项目结构：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tepe2Klr-1612831449230)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210106101557479.png)]

file - > project - > empty project - > next - > 起一个项目名字 - > finish - > 弹出一个框Project Structure -> 点击侧边的Modules -> 点击加号+弹出一个弹框选择New Module - > next - > Module name取名字

所有的源代码都要写在src中

选中src右键选择package-> 给包取一个名字cn.itcast.day04.demo01

这是一个多层级文件夹的嵌套

点击cn.itcast.day04.demo01右键选择new-> java class,这样就可以新建一个类文件

建demo02也是点击src右键新建

快捷键：psvm自动生成main函数

输出语句快捷键：sout

弹出运行框快捷键：alt + 4

IDEA常用快捷键：

alt + enter 导入包自动修正代码

Ctrl + Y 删除光标所在行

Ctrl + D 复制光标所在行的内容插入光标位置下面

Ctrl + atl + L 格式化光标

Ctrl + / 单行注释再按取消注释

Ctrl + shift + / 选中代码注释多行注释再按取消注释

alt + Ins 自动生成代码 toString, get, set等方法

alt + shift + 上下箭头移动当前代码行

for循环的快捷键循环的次数.fori

方法

for循环的快捷键循环的次数.fori

使用方法的时候注意事项：

1.方法应该定义在类当中，但是不能在方法当中定义方法

2.方法定义的前后顺序无所谓

3.如果方法有返回值，那么必须写上return 返回值不能没有

4.return后面的返回值数据，必须和方法后面的返回值只能写return自己

5.一个方法中可以有多个return语句，但是必须保证同事只有一个会被执行到，两个return不能连写

重载

方法的重载（overload）：多个方法的名称一样，但是参数列表不一样

好处：只需要记住一个方法名称就可以实现类似的功能

方法重载与下列因素相关：

1.参数的个数不同

2.参数的类型不同

3.参数的多类型顺序不同

方法重载与下列因素无关：

1.与参数的名称无关

2.与方法的返回类型无关

数组

数组的概念：是一种容器，可以同时存放多个数据值

数组的特点：

1.数组是一种引用数据类型

2.数组当中的多个数据，类型必须统一

3.数组的长度在程序运行期间不可改变

数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值

两种常见的初始化方式：

1.动态初始化（指定长度）

动态初始化数组的格式：

数据类型 [] 数组名称 = new 数据类型[数组长度];

解析含义：

左侧数据类型：也就是数组当中保存的数据，全都是统一的什么类型

左侧的中括号：代表我是一个数组

左侧的数组名称：给数组取一个名字

右侧的new：代表创建数组的动作

右侧数据类型：必须和左边的数据类型保持一致

右侧中括号的长度：也就是数组当中，到底保存多少个数据，是一个int数字

2.静态初始化（指定内容）

静态初始化基本格式：

数据类型[] 数组名称 = new 数据类型[] {元素1，元素2，。。。}

静态初始化省略格式：

数据类型[] 数组名称 = {元素1，元素2，。。。}

注意事项：

虽然静态初始化没有直接告诉长度，但是根据大括号里面元素的具体内容，也可以自动推算出来长度

直接打印素组名称，得到的是数组对应的：内存地址哈希值。

使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值，规则如下：

整数类型，默认0

浮点类型，默认0.0

字符类型，默认’\u0000’

布尔类型，默认false

引用类型，默认null

获取数组的长度：

格式：

数组名称.length

这样会的到一个int数字，代表数组的长度

数组一旦创建程序运行期间，长度不可改变

数组遍历输出：

java的内存需要划分

java的内存需要划分为5个部分：

1.栈（stack）：存放的都是方法中的局部变量。方法运行一定要在栈当中运行。

局部变量：方法的参数，或者是方法（）内部的变量

作用域：一旦超出作用域，立刻从栈内存中消失

2.堆（Heap）：凡是new出来的东西，都在堆当中。

堆内存里面的东西都有一个地址值：16进制

堆内存里面的数据，都有默认值。规则：

如果是：

整数类型，默认0

浮点类型，默认0.0

字符类型，默认’\u0000’

布尔类型，默认false

引用类型，默认null

3.方法区（Method area）：存储class相关信息，包含方法的信息

4.本地方法栈（Native Method Stack）：与操作系统相关。

5.寄存器（pc Register）：与CPU相关

一个数组的内存图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PSisTJGD-1612831449232)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210106161912033.png)]

两个数组的内存图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vGrkf5M5-1612831449233)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210106162309975.png)]

两个引用指向同一个数组的内存值：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qZlia4lf-1612831449234)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210106162815536.png)]

数组索引越界异常

ArrayIndexOutOfBoundsException

原因：索引编号写错了

当一个对象作为参数传递到方法当中时

实际上传递进去的是对象的地址值

局部变量和成员变量：

1.定义的位置不一样

局部变量：在方法的内部

成员变量：在方法的外部直接写在类当中

2.作用范围不一样

局部变量：只有方法当中才可以使用，出了方法就不能再用

成员变量：整个类全部都可以通过

3.默认值不一样

局部变量：没有默认值，如果要想使用必须手动进行赋值

成员变量：如果没有赋值会有默认值规则和数组一样

4.内存的位置不一样

局部变量：位于栈内存

成员变量：位于堆内存

5.生命周期不一样

局部变量：随着方法进战而诞生随着方法出栈而消失

成员变量：随着对象创建而诞生随着对象被垃圾回收而消失

面向对象三大特性

封装性

封装性在java中的体现

1.方法就是一种封装

2.关键字private也是一种封装

private关键字可以提高代码的安全性

this：

* 当方法的局部变量和类的成员变量重名的时候，根据就近原则，优先使用局部变量
* 如果需要访问本类当中的成员变量，需要使用格式：
* this.成员变量名
* 
* 通过谁调用的方法，谁就是this

继承性

多态性

java学到什么程度可以做项目：

javase:

java基础篇：

流程控制（顺序、选择、循环）

面向对象思想（封装、继承、多态（类、接口、对象））

数组、集合（Array、List、Set、Map）

java常用API（日期Date（java8：LocalDateTime、LocalDate）、常用数据类型的封装类（Integer、String…））

IO流（项目中涉及到文件操作）

多线程（偏向开发并发量大的功能）

异常处理（了解一些常见的异常，方便我们对程序进行排错定位）

反射、代理（偏向底层原理、或高级架构）

注解（侧重于使用框架为我们提供的注解）

java网络编程（了解一些网络协议、基础知识。Http协议…）

数据库相关：

数据库管理系统的使用

常见的数据库管理系统比如mysql,oracle

最起码要会使用数据库查询语言(DQL)、数据操纵语言(DML)、数据定义语言(DDL)

数据库视图化管理工具（Windows系统上的SQLyog、NAVcat）

java中的JDBC API

此时学完java基础数据库 JDBC之后可以尝试写一个控制台应用，实现对数据库的单纯的增删改查

前端：

JavaEE：

Servlet(它的生命周期、get和post请求的处理、请求和响应)

Servlet容器(Tomcat、JBoos、Jetty…)

模板引擎(JSP配合使用EL表达式、JSTL标签。ThymeLeaf、FreeMarker…)

MVC三层框架(模型、视图、控制)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1S2wk6HH-1612831449235)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210107103622830.png)]

一个基于Servlet的web应用的工程包(各个包之间的调用关系，遵循MVC框架模式)

使用框架来优化升级项目(学习一个框架先要了解这个框架干嘛用的，如果你写过一个项目，那么要想这个框架主要作用在原来的那一部分)：Spring框架：SpringMVC框架：主要应用在控制层

框架的搭配使用：

Spring+SpringMVC+MyBatista = SSM

SpringBoot + Mybatis = SM(比较热门的，后端的微服务)

构造方法

构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法

格式：

public 类名称（参数类型参数名称）{

方法体

}

注意事项：

1.构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样

2.构造方法不要写返回值类型，连void都不写

3.构造方法不能return一个具体的返回值

String

package cn.itcast.day06.String;

/*
 * API当中说 Java程序中的所有字符串字面值（如：“abc”）都作为此类的实例实现
 * 其实就是说 程序当中所有的双引号字符串 都是String类的对象（就算没有New 也照样是）
 *   特点：
 *   1.字符串的内容永不可变
 *   2.正是因为字符串不可改变 所以字符串可以共享8使用
 *   3.字符串效果上相当于char[]字符数组 但是底层原理是byte[]字节数组
 *
 * 三种构造方法：
 * public String():创建一个空白字符串 不含有任何内容
 * public String(char[] array):根据字符数组的内容 来创建对应的字符串
 * public String(byte[] array):根据字节数组的内容 来创建对应的字符串
 * 一种直接创建：
 *String str = "Hello"
 *
 * 注意：直接写上双引号 就是字符串对象
 * */
public class Demo01String {
    public static void main(String[] args) {
//        1
        String str1 = new String();
        System.out.println("第一个字符串：" + str1);
//        2
        char[] charArray = {'a', 'b', 'c'};
        String str2 = new String(charArray);
        System.out.println("第2个字符串：" + str2);

//        3
        byte[] byteArray = {97, 98, 99};
        String str3 = new String(byteArray);
        System.out.println("第3个字符串：" + str3);

//        4
        String str4 = "Hello";
        System.out.println(str4);


    }
}

字符串常量池：

package cn.itcast.day06.String;
/*
* 字符串常量池：程序当中直接写上的双引号字符串 就在字符串常量池中
*   对于基本类型来说==是进行数值的比较
*   对于引用类型来说 ==是进行地址值的比较
* */
public class Demo02StringPool {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";

        char[] charArray = {'a','b','c'};
        String str3 = new String(charArray);

        System.out.println(str1 == str2);
        System.out.println(str1 == str3);
        System.out.println(str3 == str2);
    }
}

比较：

package cn.itcast.day06.String;
/*
* ==是进行对象的地址值比较 如果确实需要字符串的内容比较 可以使用两个方法
* public boolean equals(Object obj):参数可以是任何对象 只有参数是一个字符串并且内容相同的才会给true 否则就是false
* 备注：任何对象都能用Object进行接收
* equals方法具有对称性 也就是a.equals(b)和b.equals.(a)效果一样
*   如果比较双方一个常量一个变量 推荐把常量写在前面
*
*   public boolean equalsIgnoreCase(String str): 忽略大小写 进行内容比较
* */
public class Demo03StringEquals {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Hello";
        char[] charArray = {'H','e','l','l','o'};
        String str3 = new String(charArray);
        System.out.println(str1.equals(str2));
        System.out.println(str2.equals(str3));
        System.out.println(str3.equals("hello"));

        String strA = "Java";
        String strB = "java";
        System.out.println(strA.equals(strB));
        System.out.println(strA.equalsIgnoreCase(strB));
//      注意：只有英文字母区分大小写 其他都不区分大小写
        System.out.println("abc123".equalsIgnoreCase("abc壹123"));
    }
}

获取字符串

package cn.itcast.day06.String;
/*
* String当中与获取相关的常用方法：
*
* public int length():获取字符串当中含有的字符个数 拿到字符串长度
* public String concat(String str): 将当前字符串和参数字符串拼接成为返回值新的字符串
* public char charAt(int index): 获取指定索引位置的单个字符。（索引从0开始）
* public int indexOf(String str): 查找参数字符串在本字符串中首次出现的索引位置 如果没有返回-1值
*
*
* */
public class Demo04StringGet {
    public static void main(String[] args) {
//        获取字符串长度
        int length = "gxvbendcosm".length();
        System.out.println("字符串的长度是："+length);

//        拼接字符串
        String str1 = "Hello";
        String str2 = "World";
        String str3 = str1.concat(str2);
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
        System.out.println("------------------------------------");

//        获取指定索引位置的单个字符串
        char ch = "Hello".charAt(1);
        System.out.println("在1号索引位置的字符是："+ch);
        System.out.println("------------------------------------");

//        查找参数字符串在本来字符串当中出现的第一次索引位置
//        如果没有 返回-1
        String original = "helloworld";
        int index = original.indexOf("llo");
        System.out.println(index);
        int index2 = original.indexOf("mm");
        System.out.println(index2);


    }
}

字符串截取：

package cn.itcast.day06.String;
/*
* 字符串的截取方法：
* public String substring(int index):截取从参数位置一直到字符串末尾 返回新字符串
* public String substring(int begin, int end):截取begin开始 一直到end结束 中间的字符串。
* 备注：[begin,end) : 包含左边 不包含右边
*
* */
public class Demo05Substring {
    public static void main(String[] args) {
        String str1 = "HelloWorld";
        String str2 = str1.substring(5);
        System.out.println(str1);
        System.out.println(str2);
        System.out.println("------------------------------");

        String str3 = str1.substring(4,7);
        System.out.println(str3);
        System.out.println("------------------------------");

//        变的是地址值 字符串的内容没有改变
        String strA = "Hello";
        System.out.println(strA);
        strA = "Java";
        System.out.println(strA);
    }
}

字符串转换：

package cn.itcast.day06.String;
/*
* String当中与转换相关的常用方法：
* public char[] toCharArray(): 将当前字符串拆分成为字符串数组作为返回值
* public byte[] getBytes(): 获得当前字符串数组作为返回值
* public String replace(CharSequence oldString, CharSequence newString):
* 将所有出现的老字符串替换成为新的字符串 返回替换之后的结果新字符串
* 备注：charSequence意思就是说可以接受字符串类型
*
*
* */
public class Demo06StringConvert {
    public static void main(String[] args) {
//        转换成字符数组
        char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]);
        System.out.println(chars.length); // 5
        System.out.println("---------------------------");

//        转换成字节数组
        byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }
        System.out.println("---------------------------");

        String str1 = "How do you do?";
        String str2 = str1.replace("o","*");
        System.out.println(str2);
        System.out.println("---------------------------");




    }
}

static

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-I2uXhCqs-1612831449236)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210114104742992.png)]

静态方法中不能使用this关键字

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZdFp7fYw-1612831449237)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210114112803194.png)]

Arrays

package cn.itcast.day06.arrays;

import java.util.Arrays;

/*
* java.util.Arrays是一个与数组相关的工具类 里面提供了大量的静态方法 用来实现数组的常见操作
*
* public static String toString(数组)：将参数数组变成字符串（默认格式：[元素1，元素2，元素3]）
* public static void sort(数组)：默认按照升序排序
*
*
*
* */
public class Demo01Arrays {
    public static void main(String[] args) {
        int[] intArray = {10,20,30};
//        将int[]数组按照默认格式变成字符串
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr); // [10, 20, 30]

        int[] array1 = {2,1,3};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1)); // [1, 2, 3]

        String[] array2 = {"aaa","bbb","ccc"};
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2));

    }
}

练习题：

package cn.itcast.day06.arrays;

import java.util.Arrays;
/*
* 将一个随机字符串升序排序 再倒序打印出来
* */
public class Demo02ArraysTest {
    public static void main(String[] args) {
        String str = "edrtfgyhvbioijmncoem";
        char[] chars = str.toCharArray();
        Arrays.sort(chars);
        for (int i = chars.length - 1; i >= 0; i--) {
            System.out.print(chars[i]);
        }
    }
}

Math

java.util.Math类是数学相关的工具类里面提供了大量的静态方法完成与数学运算相关的操作
public static double abs(double num):获取绝对值
public static double ceil(double num):向上取整
public static double flow(double num):向下取整
public static long round(double num): 四舍五入
Math.PI代表近似的圆周率常量

public class Demo01Math {
    public static void main(String[] args) {
//        获取绝对值
        System.out.println(Math.abs(3.14));
        System.out.println(Math.abs(0));
        System.out.println(Math.abs(-3.14));
        System.out.println("------------------------");

//        向上取整
        System.out.println(Math.ceil(3.9));
        System.out.println(Math.ceil(3.1));
        System.out.println("------------------------");

//        向下取整 抹零
        System.out.println(Math.floor(30.1));
        System.out.println(Math.floor(30.9));
        System.out.println(Math.floor(31.0));

        System.out.println(Math.round(3.4));
        System.out.println(Math.round(-2.5));

        System.out.println(Math.PI);

    }
}

练习：

package cn.itcast.day06.math;
/*
* 题目：
* 计算在-10.8到5.9之间 绝对值大于6或者小于2.1的整数有多少个
*
* */
public class Demo02MathPractice {
    public static void main(String[] args) {
        int count = 0;
        double min = -10.8;
        double max = 5.9;
        for(int i = (int)min; i<max; i++) {
            int abs = Math.abs(i);
            if(abs>6 || abs<2.1){
                System.out.println(i);
                count++;
            }
        }
        System.out.println(count);
    }
}

继承

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yefGEmsO-1612831449238)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210114143019171.png)]

继承的格式：

在继承关系中子类就是一个父类也就是说子类可以被当做父类看待
定义父类的格式：（一个普通的类定义）
public class 父类名称{}
定义子类的格式：
public class 子类名称 extends 父类名称{}

重写：

概念：在继承关系中方法的名称一样参数列表也一样

重载：方法的名称一样参数列表不一样

@Override: 写在方法的前面用来检测是不是有效的正确覆盖重写
这个注释就算不写只要满足要求也是正确的方法覆盖重写
子类方法的返回值必须小于等于父类方法的返回值范围
子类方法的权限修饰符必须要大于等于父类方法的权限修饰符

备注：public>protected>(default)>private

default不是关键字default 而是什么都不写

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xAVwNbaZ-1612831449239)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210114154808269.png)]

抽象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q9DwVQDJ-1612831449240)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210114155232793.png)]

抽象方法：就是加上abstract关键字然后去掉大括号直接分号结束
抽象类：抽象方法所在的类必须是抽象类才行在class之前加上abstract
如何使用抽象类和抽象方法：
1.不能直接创建new抽象类对象
2.必须用一个子类来继承抽象父类
3.子类必须覆盖重新写抽象父类当中的所有抽象方法
覆盖重写（实现）：子类去掉抽象方法的abstract关键字然后补上方法体大括号
4.创建子类对象进行使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IJ6Fo2UK-1612831449241)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210114161519483.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Eb0ftnMB-1612831449242)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210114162023335.png)]

发红包案例：

User:

package cn.itcast.day06.demosendmoney;

public class User {
    private String name;
    private int money;

    public User() {

    }

//    展示一下当前用户有多少钱
    public void show() {
        System.out.println("我叫：" + name + ", 我有多少钱：" + money);

    }

    public User(String name, int money) {
        this.name = name;
        this.money = money;
    }

    public String getName() {
        return name;
    }

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

    public int getMoney() {
        return money;
    }

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

Member:

package cn.itcast.day06.demosendmoney;

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

public class Member extends User {
    public Member() {

    }

    public Member(String name, int money) {
        super(name, money);
    }

    public void receive(ArrayList<Integer> list){
        int index = new Random().nextInt(list.size());
        int delta = list.remove(index);
        int money = super.getMoney();
        super.setMoney(money+delta);

    }
}

Manager:

package cn.itcast.day06.demosendmoney;

import java.util.ArrayList;

//群主的类

public class Manager extends User{
    public Manager() {

    }
    public Manager(String name, int money) {
        super(name,money);
    }

    public ArrayList<Integer> send(int totalMoney, int count){
//        首先需要一个集合用来存储若干个红包的金额
        ArrayList<Integer> redList = new ArrayList<>();

        int leftMoney = super.getMoney();

        if(totalMoney > leftMoney) {
            System.out.println("余额不足！");
            return redList; // 返回空集合
        }

//        扣钱
        super.setMoney(leftMoney - totalMoney);

//        发红包需要平均才分成count
        int avg = totalMoney/count;
        int mod = totalMoney%count;

        for (int i = 0; i < count; i++) {
            redList.add(avg);
        }

        int last  = avg+mod;
        redList.add(last);

        return redList;
    }
}

接口

接口就是多个类的公共规范
接口是引用的数据类型最重要的内容就是其中的抽象方法
定义接口的格式：
public interface 接口名称{}
如果是java7那么接口中可以包含的内容
1.常量
2.抽象方法
如果是java8：
3.默认方法
4.静态方法
如果是java9，还可以额外包含有：
5.私有方法
在任何版本的java中接口都能定义抽象方法
格式：
public abstract 返回值类型方法名称（参数列表）：
注意事项：
1.接口当中的抽象方法修饰符必须是两个固定的关键字： public abstract
2.这两个关键字修饰符，可以选择性的省略

接口当中定义常量：

接口当中常量的定义方式：
public static final 数据类型常量名称 = 数据值；
注意：
一旦使用final关键字进行修饰说明不可变
接口当中的常量可以省略public static final 注意：不写也照样是这样
接口当中的常量必须赋值
接口中常量名称使用完全大写的字母用下划线进行分隔

public static final int NUM_OF_MY_CLASS = 10;

在Java9版本中接口的内容可以有：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TetpjHLE-1612831449243)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210121134208015.png)]

package cn.itcast.day06.extendsInterface;

public interface Demo01MyIntreface {
//    static {} 错误写法 接口不能有静态代码块
//    public MyInterface() {} 错误写法 接口不能有构造方法
    /*
    * 使用接口的时候需要注意：
    * 1.接口是没有静态代码块或者构造方法的
    * 2.一个类的直接父类是唯一的 但是一个类可以同时实现多个接口
    * 格式：
    * public class MyInterface implements MyInteraceA, MyInterfaceB{
    *   覆盖重写所有抽象方法
    * }
    *
    *
    * */

}

对象的向上转型和向下转型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WSBse1H7-1612831449244)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210121142534757.png)]

instanceof 关键字

格式：

对象 instanceof 类名称

会得到一个Boolean值

final

final 关键字代表最终的不可改变的

常见的四种用法：
1. 可以用来修饰一个类
1. 可以用来修饰一个方法
1. 可以用来修饰一个局部变量
1. 可以同来修饰一个成员变量

当final关键字用来修饰一个类的时候格式：

public final class 类名称{}
含义：当前的这个类不能有任何子类
但是有父类
注意：一个类如果是一个final类其中的任何成员变量和方法都不能进行覆盖重写
当final关键字用来修饰一个方法的时候这个方法就是最终方法也就是不能被覆盖重写
格式：
修饰符 final 返回值类型方法名称（参数列表）{}
注意事项：
对于类方法来说 abstract关键字和final关键字不能同时使用因为矛盾

一旦使用final用来修饰局部变量那么这个变量就不能进行修改
final int num1 = 30;
System.out.println(num1);
对于基本类型来说不可变是变量的值不能改

对于引用类型来说不可变是指变量的地址值不可改变

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q9KNLFh3-1612831449245)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210121152204895.png)]

四种权限修饰符

public > protected > (default) > private

同一个类四种修饰符都可以访问

同一个包 public protected default 可以访问 private 不可以访问

不同包子类 public protected 可以访问 default private 不可以访问

不同包非子类 public 可以访问其余不可以访问

局部内部类都不能写

匿名内部类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mxfzNtOm-1612831449246)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210121163005196.png)]

匿名内部类和匿名对象不是一回事

Date

package cn.itcast.Date;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

/*
* 计算一个人出生到现在过了多少天
*
* */
public class DatePractice {
    public static void main(String[] args) throws ParseException {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的出生日期,格式为yyyy-MM-dd");
        String birthday = sc.next();
        SimpleDateFormat sfd = new SimpleDateFormat("yyyy-MM-dd");
        Date birthdayDate = sfd.parse(birthday);
        long birthdayTime = birthdayDate.getTime();
        long todayTime = new Date().getTime();
        long time= todayTime-birthdayTime;
        System.out.println(time/1000/60/60/24);
        
    }
}

Calendar

日历类

Calendar类是一个抽象类里面提供了很多操作日历字段的方法（YEAR MONTH DAY DAY_OF_MONTH HOUR）

Calendar类无法直接创建对象使用里面有一个静态方法叫getInstance() 该方法返回了calendar类的子类对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3BZc6iRP-1612831449246)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210122092745065.png)]

package cn.itcast.calendar;

import java.util.Calendar;

/*
* 成员方法的参数：
* int field: 日历类的字段 可以使用Calendar类的静态成员变量获取
* int value: 传递的字段设置的具体的值
*
*
* */
public class Demo02CalendarMember {
    public static void main(String[] args) {
        demo01();
        demo02();
        demo03();
    }

    public static void demo03() {
        Calendar c = Calendar.getInstance();
//        把年增加2年
        c.add(Calendar.YEAR, 2);
//        把月减少3年
        c.add(Calendar.MONTH, -3);

        int year = c.get(Calendar.YEAR);
        System.out.println(year);

        int month = c.get(Calendar.MONTH);
        System.out.println(month+1);
    }

    private static void demo02() {
        Calendar c=Calendar.getInstance();
        c.set(Calendar.YEAR,9999);
        c.set(Calendar.MONTH,9);
        c.set(Calendar.DATE, 9);

        c.set(8888,8,8);

        int year = c.get(Calendar.YEAR);
        System.out.println(year);

        int month = c.get(Calendar.MONTH);
        System.out.println(month+1);

        int date = c.get(Calendar.DATE);
        System.out.println(date);

        int monthdate = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(monthdate);

    }

    private static void demo01() {
//        使用getIntance方法
        Calendar c = Calendar.getInstance();
        int year = c.get(Calendar.YEAR);
        System.out.println(year);

        int month = c.get(Calendar.MONTH);
        System.out.println(month+1);

        int date = c.get(Calendar.DATE);
        System.out.println(date);

        int monthdate = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(monthdate);
    }
}

System

package cn.itcast.system;
import java.util.Arrays;

public class Demo01System {
    public static void main(String[] args) {
        demo01();
        demo02();

    }

    public static void demo01() {
//        联系for循环打印1-9999的时间
        long s = System.currentTimeMillis();

        for (int i = 0; i < 9999; i++) {
            System.out.println(i);
        }
        long e = System.currentTimeMillis();

        System.out.println("程序共耗时："+ (e-s)+"毫秒");


    }

    public static void demo02() {
//        数组复制的方法
        /*
        * arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
        * 将数组中指定的数据拷贝到另一个数组中
        * 参数：
        * src - 原数组
        * srcPos - 原数组中的起始位置
        * dest - 目标数组
        * destPos - 目标数据中的起始位置
        * length - 要复制的数组元素的数量
        *
        *
        * */
        int[] src = {1,2,3,4,5};
        int[] dest = {6,7,8,9,0};
        System.out.println("复制前："+ Arrays.toString(dest));
        System.arraycopy(src,0,dest,0,3);
        System.out.println("复制后："+ Arrays.toString(dest));
        
    }
}

StringBuilder

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xeC6kEhK-1612831449247)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210122101042475.png)]

package cn.itcast.stringBuilder;

public class Demo01Stringbuilder {
    public static void main(String[] args) {
        StringBuilder bu1 = new StringBuilder();
        System.out.println("bu1:"+ bu1);

        StringBuilder bu2 = new StringBuilder("abc");
        System.out.println("bu2:"+bu2);
    }
}

package cn.itcast.stringBuilder;
/*
* Stringbuilder的成员方法：
* append（）：添加任意类型数据的字符串形式 并且返回当前对象自身
* 参数：
*  可以是任意的数据类型
*
* */
public class Demo02Stringbuilder {
    public static void main(String[] args) {
        StringBuilder bu1 = new StringBuilder();
//        append方法返回的是this 调用方法的对象bu1
        StringBuilder bu2 = bu1.append("abc");
        System.out.println(bu1);
        System.out.println(bu2);

        System.out.println(bu1==bu2); // true 两个对象是同一个对象


        /*
        链式编程：方法的返回值是一个对象 可以继续根据对象调用方法
        * */
        System.out.println("abc".toUpperCase().toLowerCase().toUpperCase());
        bu1.append("eee").append(8.8).append(true).append("67890vbnkl");
        System.out.println(bu1);


    }
}

toString()方法：

package cn.itcast.stringBuilder;

/*
 * StringBuilder和String可以相互转换
 * String-> StringBuilder: 可以使用StringBuilder的构造方法
 * StringBuilder-> String: 可以使用StringBuilder中的Tostring方法
 *
 * */
public class Demo03Tostring {
    public static void main(String[] args) {
        // String-> StringBuilder
        String str = "hello";
        System.out.println("str:" + str);

        StringBuilder bu = new StringBuilder(str);
        bu.append("world");
        System.out.println("bu:" + bu);

        // Stringbuilser-> String
        String s = bu.toString();
        System.out.println("s:" + s);

    }

}

包装类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xeY7OnSG-1612831449248)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210122103446404.png)]

自动装箱和自动拆箱：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C1w9w7VG-1612831449249)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210122103924965.png)]

1.基本数据类型对应的包装类

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	character
boolean	Boolean

2.基本数据类型与字符串之间的相互转换

基本类型转换为String

String转换为基本数据类型

除了Character类之外其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：

package cn.itcast.packagegroup;
/*
* 基本类型与字符串之间的转换
* 基本类型-> string
* 1.基本类型数据的值+ ""(工作中常用的方法)
* 2.使用包装类中的静态方法
* static String toString(int t) 返回一个表示指定整数的String对象
* 3.使用String类中的静态方法
* static String valueOf(int i) 返回int参数的字符串表示形式
* 字符串-> 基本类型
* 使用包装类的静态方法parseXxx("字符串")
*
*
* */
public class Stringtobasic {
    public static void main(String[] args) {
//        基本类型--> 字符串
        String  s1 = 100+"";
        System.out.println(s1+200); // 100200

        String s2 = Integer.toString(100);
        System.out.println(s2+200); // 100200

        String s3 = String.valueOf(100);
        System.out.println(s3+200); // 100200

//        字符串 --> 基本类型
        int i = Integer.parseInt("100");
        System.out.println(i+200); // 300



    }
}

Collection

学习顶层

使用底层

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tGCzT3da-1612831449249)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210122110927206.png)]

单列集合的体系结构：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-n7amyJjO-1612831449250)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210122111342644.png)]

Collection集合常用方法：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gvZKuWLI-1612831449250)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210122111647600.png)]

package cn.itcast.collection;

import java.util.Collection;
import java.util.ArrayList;

public class Test01 {
    public static void main(String[] args) {
//        创建集合对象
        Collection<String> coll = new ArrayList<>();
        coll.add("hello");
        coll.add("world");
        coll.add("java");
        coll.add("learner");
        System.out.println(coll);

//        删除集合中的某个元素
        boolean result = coll.remove("hello");
        System.out.println(result);
        System.out.println(coll);

//        清空集合中的所有元素
//        coll.clear();
//        System.out.println(coll);

//        判断集合中是否包含某个元素
        boolean res = coll.contains("java");
        System.out.println(res);

//        判断集合长度是否为空
        System.out.println(coll.isEmpty());

//        获取集合的长度
        System.out.println(coll.size());

//        将集合转换成一个数组
        Object[] arr = coll.toArray();
//        遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }


    }
}

Iterator迭代器

244

package cn.itcast.iterator;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/*
* 迭代器的使用步骤：
* 1.使用集合中的方法iterator()获取迭代器的实现类对象 使用iterator接口接收（多态）
* 2.使用iterator接口中的方法hasNext()判断还有没有下一个元素
* 3.使用iterator接口中的方法next去取出集合中的下一个元素
* */
public class Demo01iterator {
    public static void main(String[] args) {
//        创建一个集合对象
        Collection<String> coll = new ArrayList<>();
//        往集合中添加元素
        coll.add("姚明");
        coll.add("kebi");
        coll.add("rabit");
        coll.add("cat");
        coll.add("tiger");

//        多态
        Iterator<String> it = coll.iterator();

//        判断集合中还有没有下一个元素
        boolean b = it.hasNext();
        System.out.println(b); // true
//        返回迭代的下一个元素
        String s = it.next();
        System.out.println(s);

        while(it.hasNext()){
            String e = it.next();
            System.out.println(e);
        }

        System.out.println("------------------------------------");

        for(Iterator<String> it2 = coll.iterator();it2.hasNext();){
            String e = it2.next();
            System.out.println(e);
        }

    }
}

迭代器的实现原理：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c8sktpMq-1612831449251)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210122142919870.png)]

增强for循环：底层使用的也是迭代器

使用for循环的方式简化了迭代器的书写

所有的单列集合都可以使用增强for

增强for循环用来遍历集合和数组

格式：

for(集合/数组的数据类型变量名：集合名/数组名) {

sout(变量名)；

}

package cn.itcast.iterator;

import java.util.ArrayList;

public class Demo02for {
    public static void main(String[] args) {
        demo01();
        demo02();
    }

//    使用增强for循环遍历数组
    public static void demo01() {
        int[] arr = {1,2,3,4,5};
        for(int i: arr){
            System.out.println(i);
        }
    }
//    使用增强for循环遍历集合
    public static void demo02() {
        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");

        for(String s: list){
            System.out.println(s);
        }
    }
}

泛型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jAn4SUlg-1612831449252)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210122145443300.png)]

定义和使用含有泛型的类

定义和使用含有泛型的方法

泛型的通配符

斗地主综合案例

第一版斗地主：

package study.java.basic.collectionProject;

import java.util.ArrayList;
import java.util.Collections;

/*
* 斗地主综合案例：
* 1.准备牌
* 2.洗牌
* 3.发牌
* 4.看牌
*
* */
public class DouDiZhu {
    public static void main(String[] args) {
        ArrayList<String> poker = new ArrayList<>();
        String[] colors = {"♠","♥","♣","♦"};
        String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
        poker.add("大王");
        poker.add("小王");
        for (String number : numbers) {
            for (String color : colors) {
//                System.out.print(color+number);
                poker.add(color+number);
            }
        }

        /*
        * 洗牌
        * */
        Collections.shuffle(poker);
        System.out.println(poker);

        /*
        * 发牌
        * */
        ArrayList<String> player01 = new ArrayList<>();
        ArrayList<String> player02 = new ArrayList<>();
        ArrayList<String> player03 = new ArrayList<>();
        ArrayList<String> diPai = new ArrayList<>();

        /*
        * 遍历poker集合 获取每一张牌
        * 使用poker集合的索引%3给三个玩家发牌
        * 剩余三张底牌
        * 注意：
        * 先判断（i>=51）否则牌发没了
        * 
        * */
        for (int i = 0; i < poker.size(); i++) {
            String p = poker.get(i);
            if (i>=51){
                diPai.add(p);
            }else if(i%3==0){
                player01.add(p);
            }else if (i%3==1){
                player02.add(p);
            }else if (i%3==2){
                player03.add(p);
            }
        }

        /*
        * 看牌
        * */
        System.out.println("牛德华的牌："+player01);
        System.out.println("周润发的牌："+player02);
        System.out.println("周星驰的牌："+player03);
        System.out.println("底牌："+diPai);

    }
}

第二版斗地主（有序版本）：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fA5LBpLq-1612831449252)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210122165302941.png)]

package study.java.basic.collectionProject;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;

/*
* 斗地主综合案例：
* 1.准备牌
* 2.洗牌
* 3.发牌
* 4.排序
* 5.看牌
*
* */
public class DouDiZhu02 {
    public static void main(String[] args) {
//        1.准备牌
        HashMap<Integer, String> poker = new HashMap<>();
//        创建一个list集合 存储牌的索引
        ArrayList<Integer> pokerIndex = new ArrayList<>();
//        定义两个集合 存储花色和牌的序号
        List<String> colors = List.of("♠","♥","♣","♦");
        List<String> numbers = List.of("2","A","K","Q","J","10","9","8","7","6","5","4","3");
//        先把大王和小王存储到集合中
//        定义一个牌的索引
        int index= 0;
        poker.put(index,"大王");
        pokerIndex.add(index);
        index++;
        poker.put(index,"小王");
        pokerIndex.add(index);
        index++;

//        循环嵌套遍历两个集合 组装52张牌 存储到集合中
        for (String number : numbers) {
            for (String color : colors) {
                poker.put(index,color+number);
                pokerIndex.add(index);
                index++;
            }
        }
//        System.out.println(poker);
//        System.out.println(pokerIndex);

        /*
        * 2.洗牌
        * */
        Collections.shuffle(pokerIndex);
        System.out.println(pokerIndex);

        /*
        * 3.发牌
        * */
        ArrayList<Integer> player01 = new ArrayList<>();
        ArrayList<Integer> player02 = new ArrayList<>();
        ArrayList<Integer> player03 = new ArrayList<>();
        ArrayList<Integer> diPai = new ArrayList<>();

//        遍历存储牌索引的list集合 获取每一个牌的索引
        for (int i = 0; i < pokerIndex.size(); i++) {
            Integer in = pokerIndex.get(i);
            if(i>=51){
                diPai.add(in);
            }else if(i%3==0){
                player01.add(in);
            }else if(i%3==1){
                player02.add(in);
            }else if(i%3==2){
                player03.add(in);
            }
        }

        /*
        * 4.排序
        * */
        Collections.sort(player01);
        Collections.sort(player02);
        Collections.sort(player03);
        Collections.sort(diPai);

        /*
        * 5.看牌 调用看牌的方法
        *
        * */
        lookPoker("刘德华",poker,player01);
        lookPoker("jack",poker,player02);
        lookPoker("tom",poker,player03);
        lookPoker("底牌",poker,diPai);

    }
    /*
    * 定义一个看牌的方法 提高代码的复用性
    * 参数：
    * String name:玩家名称
    * HashMap<Integer,String> poker:存储牌的poker集合
    * ArrayList<Integer> list:存储玩家和底牌的list集合
    * 查表法：
    * 遍历玩家或者底牌集合 获取拍的索引
    * 使用牌的索引 去Map集合中 找到对应的牌
    * */
    public static void lookPoker(String name,HashMap<Integer,String> poker, ArrayList<Integer> list){
//        输出玩家名称 不换行
        System.out.print(name+":");
        for (Integer key : list) {
//            使用牌的索引去map集合中找到对应的牌
            String value = poker.get(key);
            System.out.print(value+":");

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


}

XML

可扩展标记语言

标签是自定义的语法严格

功能：存储数据做配置文件：在网络中传输

语法：

后缀名为.xml

第一行必须写文档声明

xml文档中有且仅有一个根标签

属性值必须用引号引起来

标签必须正确关闭

xml标签区分大小写

1.快速入门

<?xml version='1.0' ？> 文档声明
<users>
	<user id='1'> 
        <name>zhangshan</name>

        <age>1</age>

        <gender>male</gender>
	</user>
	<user id='2'> 
        <name>lisi</name>

        <age>2</age>

        <gender>female</gender>
	</user>

</users>

2.组成部分

文档声明

格式：<?xml 属性列表？>

属性列表：

version:版本号，必须的属性（主流的是1.0）

encoding:编码方式，告知解析引擎当前文档使用的字符集默认值：IOS-8859-1

standalone:是否独立取值（yes:不依赖其他文件/no:依赖其他文件）

指令(了解)

标签：自定义的标签

数字和标点符号不能开头

属性：id属性值唯一

文本：

CDATA区：在区域中的数据会被原样展示

格式：<![CDATA[]]>

项目

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VSlQk8X7-1612831449253)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210121140515317.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xz3CZkjs-1612831449254)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210121140817116.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ObVErUq7-1612831449255)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210121141021357.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pg3Proze-1612831449256)(C:\Users\sjy\AppData\Roaming\Typora\typora-user-images\image-20210121141158848.png)]

){
player02.add(in);
}else if(i%3==2){
player03.add(in);
}
}

    /*
    * 4.排序
    * */
    Collections.sort(player01);
    Collections.sort(player02);
    Collections.sort(player03);
    Collections.sort(diPai);

    /*
    * 5.看牌 调用看牌的方法
    *
    * */
    lookPoker("刘德华",poker,player01);
    lookPoker("jack",poker,player02);
    lookPoker("tom",poker,player03);
    lookPoker("底牌",poker,diPai);

}
/*
* 定义一个看牌的方法 提高代码的复用性
* 参数：
* String name:玩家名称
* HashMap<Integer,String> poker:存储牌的poker集合
* ArrayList<Integer> list:存储玩家和底牌的list集合
* 查表法：
* 遍历玩家或者底牌集合 获取拍的索引
* 使用牌的索引 去Map集合中 找到对应的牌
* */
public static void lookPoker(String name,HashMap<Integer,String> poker, ArrayList<Integer> list){

// 输出玩家名称不换行
System.out.print(name+"😊;
for (Integer key : list) {
// 使用牌的索引去map集合中找到对应的牌
String value = poker.get(key);
System.out.print(value+"😊;

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

}


































#### XML

可扩展标记语言

标签是自定义的 语法严格

功能：存储数据 做配置文件：在网络中传输

语法：

后缀名为.xml

第一行必须写文档声明

xml文档中有且仅有一个根标签

属性值必须用引号引起来

标签必须正确关闭

xml标签区分大小写



1.快速入门

```xml
<?xml version='1.0' ？> 文档声明
<users>
	<user id='1'> 
        <name>zhangshan</name>

        <age>1</age>

        <gender>male</gender>
	</user>
	<user id='2'> 
        <name>lisi</name>

        <age>2</age>

        <gender>female</gender>
	</user>

</users>

2.组成部分

文档声明

格式：<?xml 属性列表？>

属性列表：

version:版本号，必须的属性（主流的是1.0）

encoding:编码方式，告知解析引擎当前文档使用的字符集默认值：IOS-8859-1

standalone:是否独立取值（yes:不依赖其他文件/no:依赖其他文件）

指令(了解)

标签：自定义的标签

数字和标点符号不能开头

属性：id属性值唯一

文本：

CDATA区：在区域中的数据会被原样展示

格式：<![CDATA[]]>

项目

[外链图片转存中…(img-VSlQk8X7-1612831449253)]

[外链图片转存中…(img-xz3CZkjs-1612831449254)]

[外链图片转存中…(img-ObVErUq7-1612831449255)]

[外链图片转存中…(img-pg3Proze-1612831449256)]

Eli-sun

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
java笔记1

位(bit):一个数字0或者一个数字1，代表一位字节(bite):每逢8位是一个字节，这是数据存储的最小单位1KB = 1024byte1MB = 1024KB1GB = 1024MB1TB = 1024GB命令提示符(cmd) 启动win + R命令提示符的常用命令：切换盘符大小写不区分cd … 回到上一级文件夹cd 文件名\文件名\文件名到这个文件夹查看当前内容 dir清屏 clear退出 exit第二章： java语言开发环境搭建JDK是java程序开发工具包，包含J
复制链接

扫一扫