认识java基础语法平时我们编写代码，在代码量比较少的时候，我们还可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需

1、认识基础

1.1 注释

平时我们编写代码，在代码量比较少的时候，我们还可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需要用到注释了。

注释并不会执行，是给我们写代码的人看的。书写注释是一个非常好的习惯。

Java 中的注释有三种：

1.单行注释( // 需要注释的内容)

2.多行注释(/需要注释掉的内容/)

3.文档注释

有趣的注释代码

/***
 *                    _ooOoo_
 *                   o8888888o
 *                   88" . "88
 *                   (| -_- |)
 *                    O\ = /O
 *                ____/`---'____
 *              .   ' \| |// `.
 *               / \||| : |||// \
 *             / _||||| -:- |||||- \
 *               | | \\ - /// | |
 *             | _| ''---/'' | |
 *              \ .-__ `-` ___/-. /
 *           ___`. .' /--.--\ `. . __
 *        ."" '< `.____<|>_/___.' >'"".
 *       | | : `- `.;`\ _ /`;.`/ - ` : | |
 *         \ \ `-. _ __\ /__ _/ .-` / /
 * ======`-.____`-.________/___.-`____.-'======
 *                    `=---='
 *
 * .............................................
 *          佛祖保佑             永无BUG
 */

1.2 标识符

关键字

$<img src="C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200728191919602.png" alt="image-20200728191919602" style="zoom: 67%;" />$

Java所有的组成部分都需要名字。类名、变量名以及方法名都被成为标识符。

标识符注意：

所有的标识符都只能以字母（A~~Z，a~~z），$，或者下划线（_）开始
不能使用关键字作为变量名或方法名。
标识符是大小写不一的
可以使用中文命名，但是一般不建议使用中文。

2.数据类型

强类型语言：要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用弱类型语言：不要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用

2.1 基本数据类型(primitive type)

简单介绍	类型	占用字节(byte)	取值范围	默认值
整型	int	4	-2147483648~+2147483647	0
字节型，最小数据类型	byte	1	-128~127	0
短整型	short	2	-32768~32717	0
长整型	long	8	-2^63~2^63-1	0L
浮点，带小数点	float	4		0.0f
双精度浮点型	double	8		0.0d
字符型，存储单个字符	char	2	0~65535	空
布尔型，true 或者 false	boolean	1	true false	false

2.2 引用类型(reference type)

除了基本数据类型外的都是引用类型(类、接口、数组 ...)

引用类型就是指向一个对象，指向对象的变量是引用变量。这些变量在声明被制定为一个特定的类型，一旦声明后，类型不能被改变。

2.3 数据类型扩展

public class HelloWorld {
    public static void main(String[] args) {
        //二进制0b  十进制  八进制0  十六进制0x
        int i = 10;
        int i2 = 010;   //八进制
        int i3 = 0x10;  //十六进制

        System.out.println(i2);   //结果  8
        System.out.println(i3);   //结果  16
        //-------------------------------------
        //浮点数  ，银行不会用浮点表示，BigDecimal 数学工具类
        //最好不要使用浮点数进行比较
        //float  有限  离散  舍入误差  大约   接近但不等于
        float f = 0.1f;   //0.1
        double d = 1.0/10;   //0.1

        System.out.println(f == d);  //false

        float d1 = 34343434343f;
        float d2 = d1+1;

        System.out.println(d1 == d2);   //true
        //-------------------------------------
        //强制类型转换
        char c1 = 'A';
        char c2 = '我';

        System.out.println(c1);       //A
        System.out.println((int)c1);  //65
        System.out.println(c2);       //我
        System.out.println((int)c2);  //25105
        //-------------------------------------
        //所有字符的本质还是数字   Unicode表
        char c3 = '\u0061';
        System.out.println(c3);   //a
        //-------------------------------------
        //转义字符
            //  \t   制表符
            //  \n   换行
        //-------------------------------------
        String a = new String("Hello World");
        String b = new String("Hello World");
        System.out.println(a == b);    //false

        String c = "Hello World";
        String e = "Hello World";
        System.out.println(c == e);    //false
    }
}

3.类型转换

由低到高：byte, short,char ---- int ---- long ---- float ---- double

在运算过程中，不同类型的数据会先转换为同一类型，然后进行运算。

注意事项：

不能对boolean类型进行转换
不能把对象类型转换为不相干的类型
将类型比较高的转换为低的时候需要强制转换 ：(需要转换为的类型)变量
转换的时候可能存在内存溢出或者精度问题
强制转换 (类型)变量名高 -- 低

自动转换低 -- 高

public class Demo01 {
    public static void main(String[] args) {
        //内存溢出或精度问题
        System.out.println((int)23.7);    //23
        System.out.println((int)-45.89f); //-45
        //===============================
        char  c = 'a';
        int d = c + 1;
        System.out.println(d);        //98
        System.out.println((char)d);  //b
    }
}

4.变量

变量就是可以变化的量，Java是一种强类型语言，所以每一个变量都必须声明类型，Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

注意事项：

每个变量都有类型，类型可以是基本类型，也可以是引用类型
变量名必须是合法的标识符。
变量声明是一条完整的语句，因此每一个声明都必须以分号结束。

变量作用域：

局部变量，类变量，实例变量

public class Demo02 {

    //类变量 static
    static double salary = 2500;

    //除了基本类型，其余的默认值都是null；
    String name;
    int age;

    public static void main(String[] args) {
        //局部变量：必须声明和初始化值
        int i = 10;
        System.out.println(i);

        //变量类型 变量名字=new Demo02();
        Demo02 demo02 = new Demo02();
        System.out.println(demo02.age);
        System.out.println(demo02.name);

        //类变量 static
        System.out.println(salary);
    }
}

5.常量

常量(Constant)：初始化后不能再改变值，不会变的值

常量就是一种特殊的变量，它的值一旦被设定后，在程序运行过程中不允许被改变。

常量名一般用大写字符。

static final double PI = 3.14;

常量变量的命名规范：

所有变量、方法、类型：见名知意
类成员变量：首字母小写和驼峰原则
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线： PI
类型：首字母大写和驼峰原则
方法名：首字母小写和驼峰原则

6.运算符

注意

public class Demo03 {
    public static void main(String[] args) {

        int a = 10 ;
        int b = 20 ;
        //当 + 左面出现String类型后按照连接，后面进行计算
        System.out.println(""+a+b);   //运行结果为：1020
        System.out.println(a+b+"");   //运行结果为：30
    }
}

7.JavaDoc生成文档

javadoc命令是用来生成自己API文档的

参数信息

    1. @author  作者名

        2. @version  版本号
                3. @since  指明需要最早使用的jdk版本
                            4. @param   参数名
                                    5. @return  返回值情况
                                                6. @throws  异常抛出情况

public class Demo04 {
    
        String name;

    /**
     * 
     * @param li
     * @version 1.0
     * @return name
     * @throws Exception
     */

    public String test(String name) throws Exception {
            return name;
        }
}

命令行生成Doc文档：javadoc 参数 java文件
IDEA生成JavaDoc文档：Tools菜单 --> Generate Java Doc scope -->Output directory(选择生成文档的位置)

$<img src="C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200729190853304.png" alt="image-20200729190853304" style="zoom:67%;" />$

本章知识点学习自

1.用户交互Scanner

头文件：java.util.Scanner

通过 Scanner 类获取用户的输入

基础语法：Scanner scanner = new Scanner(System.in);

next();

一定要读取到有效字符后才可以结束输入。
对输入有效字符之前遇到的空白，next（）方法会自动将其去掉
只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
next()不能得到带有空格的字符串。

import java.util.Scanner;

public class Demo05 {
    public static void main(String[] args) {

        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next方式接受：");

        //判断用户有没有输入字符串
        if (scanner.hasNext()){         //判断语句可以省略
            //使用next方法接收
            String str = scanner.next();   //等待用户输入完毕
            System.out.println("输出的内容为："+str);    //加入输入a a a
                                                       //输入结果为：a
        }

        //凡是属于IO流的类如果不关闭会一直占用资源，记得关掉
        scanner.close();

    }
}

nextLine( ) :

以Enter为结束符，nextLine()方法返回的是输入回车之前的所有字符。
可以获得带有空格的字符串

import java.util.Scanner;

public class Demo05 {
    public static void main(String[] args) {

        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next方式接受：");

        //判断用户有没有输入字符串
        if (scanner.hasNextLine()){         //判断语句可以省略
            //使用next方法接收
            String str = scanner.nextLine();   //等待用户输入完毕
            System.out.println("输出的内容为："+str);    //加入输入a a a
                                                       //输入结果为：a a a 
        }

        //凡是属于IO流的类如果不关闭会一直占用资源，记得关掉
        scanner.close();

    }
}

2.顺序结构

JAVA的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。

顺序结构是最简单的算法结构

3.选择结构

if 单选择结构

if(布尔表达式){
	//如果布尔表达式为ture将执行的语句
}

$<img src="C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200729212656292.png" alt="image-20200729212656292" style="zoom:50%;" />$

if 双选择结构

if(布尔表达式){
	//如果布尔表达式的值为true执行的语句
}else{
	//如果布尔表达式的值为false执行的语句
}

$<img src="C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200729213016106.png" alt="image-20200729213016106" style="zoom:50%;" />$

if 多选择结构

if(布尔表达式 1){
	//如果布尔表达式 1的值为true执行的代码
}else if(布尔表达式 2){
	//如果布尔表达式 2的值为true执行的代码
}else if(布尔表达式 3){
	//如果布尔表达式 3的值为true执行的代码
}else {
	//如果以上布尔表达式都不为true执行的代码
}

$<img src="C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200729213407692.png" alt="image-20200729213407692" style="zoom:67%;" />$

嵌套的if结构

if(布尔表达式 1){
	//如果布尔表达式1的值为true执行的代码
	if(布尔表达式2){
		//如果布尔表达式2的值为true执行的代码
	}
}

switch多选择结构

switch case语句判断一个变量与一些列值中某个值是否相等，每个值称为一个分支。

switch(expression){
	case value;
		//语句
		break;   //可选
	case value;
		//语句
		break;   //可选
	//可以任意数量的case语句
	default ; //可选
		//语句
}

switch 语句中的变量类型可以是：

1. byte  short  int  char
2. 从Java SE7开始switch支持字符串String类型
3. case标签必须为字符串常量或字面量。

4.循环结构

while循环
```
while(布尔表达式){
	//循环内容
}
```
1. 只要布尔表达式为true，循环就会一直执行
2. 大多数情况会让循环停止，需要布尔表达式为false
3. 布尔表达式一直为true会造成无限循环（死循环），应避免死循环
do...while循环
```
do{
	//代码语句
}while(布尔表达式);
```
对于while语句而言，不满足条件则不能进入循环，但有时候需要即使不满足条件也至少执行一次。

do...while会至少执行一次。

while和do...while的区别
```
1. while先判断后执行，do...while是先执行后判断。
2. do...while总是保证循环会被至少执行一次，主要区别。
```

for循环

for循环执行的次数是在执行前就确定的。

for(初始值；布尔表达式；更新值){
	//代码语句
}

主要用于数组的增强型for循环
```
for(声明语句:表达式){
	//代码句子
}
```
声明语句： 声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式： 表达式是要访问的数组名，或者是返回值为数组的方法。

5.break 和 continue

break 在任何循环语句的主体部分，均可用break控制循环的流程。break用于强化退出循环，不执行循环中剩余的语句。(break语句也在switch语句中使用)

continue用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

本章知识点学习自

1. 什么是方法

Java方法是语句的集合，他们在一起执行一个功能。

方法是解决一类问题的步骤的有序结合
方法包含于类或对象中
方法在程序中被创建，在其他地方被引用

设计方法的原则： 方法的本意是功能快，就是实现某个功能的语句块的集合。在设计方法的时候，最好保持方法的原子性，就是一个方法只能完成1个功能，有利于后期扩展。

public class Demo07 {

    //main 方法
    public static void main(String[] args) {
        int sum = add(1,2);
        System.out.println(sum);
    }

    //加法方法
    public static int add(int a,int b){
        return a + b;
    }
}

2.方法的定义

Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段

方法包含一个方法头和一个方法体，下面是一个方法的所有部分
1. 修饰符：可选，告诉编译器如何调用该方法，定义了该方法的访问类型
2. 返回值类型：方法可能会返回值，
3. 方法名：方法的实际名称，方法名和参数表共同构成方法签名。
4. 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
  - 形式参数：在方法调用时用于接收外界输入的数据
  - 实参：调用方法是实际传给方法的数据
5. 方法体：方法体包含具体的语句，定义该方法的功能

修饰符 返回值类型 方法名(参数类型 参数名){
	...
	方法体
	...
	return 返回值;
}

3.方法调用

调用方法：对象名.方法名(实参列表)

Java支持两种调用方法的方式，根据方法是否返回值来选择。

当方法返回一个值的时候，方法调用通常被当作一个值。
```
例如：int larger = max(30,40);
```
如果方法返回值void,方法调用一定是一条语句。
```
例如：System.out.println("Hello World!");
```
Java中都是值传递

4.方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的参数。
方法的重载的规则：
1. 方法名称必须相同
2. 参数列表必须不同(个数不同、或类型不同、参数排列顺序不同等)。
3. 方法的返回类型可以相同也可以不相同。
4. 仅仅返回类型不同不足以成为方法的重载。

理论： 方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

5.可变参数

在方法声明中，在指定参数类型后加一个省略号(...)
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

public class Demo09 {

    public static void main(String[] args) {
        Demo09 demo09 = new Demo09();
        demo09.test(1,2,3,4,5);     //参数可以随意添加或删除
    }

    public void test(int... i){
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
        System.out.println(i[4]);
    }
}

6.递归

递归就是：A方法调用A方法，就是自己调用自己
利用递归可以用简单的程序解决一些复杂问题。通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来解决，递归策略只需要少量的程序就可以描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
递归结构包括两个部分：
1. 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
2. 递归体：什么时候需要调用自身方法

public class Demo010 {

    /*
        使用递归算法实现5！
        对于数比较少可以使用，但比较大的计算尽量避免递归算法
        主要是学习递归算法的思想
     */
    
    public static void main(String[] args) {
        System.out.println(f(5));
    }

    public static int f(int n){
        if (n==1){
            return 1;
        }else {
            return n * f(n-1);
        }
    }
}

本章知识点学习自

1.数组概述

数组是相同类型数据（数据类型可以为任何类型）的有序集合
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
每一个数据成为一个数组元素，每个数组元素可以通过一个下标来访问他们
数组的下标从 0 开始的
数组也是对象，数组元素相当于对象的成员变量
数组长度的确定，不可变的。越界报错：ArrayIndexOutofBoundsException
下标的合法区间：[0,length-1]

2.数组声明创建

首先声明数组变量，才能使用数组，声明语法：

dataType[] arrayRefVar;		//首选的方法
或
dataType arrayRefVar[];		//效果相同，但不是首选方法

使用new操作符来创建数组，语法：

dataType[] arrayRefVar = new dataType[arraySize];

数组的元素是通过索引访问的，数组索引从0 开始
获取数组的长度：arrays.length

public class Demo01 {
    //变量的类型 变量名= 变量值;
    //数组类型 变量名[] = 变量值;

    public static void main(String[] args) {
        int[] nums;     //1.声明一个数组

        nums = new int[10];     //2.创建一个数组

        //3.给数组元素赋值
        for (int i = 0; i < nums.length; i++) {
            nums[i]=i+1;
        }

        System.out.println(nums[0]);
    }
}

在这里插入图片描述

三种初始化

静态初始化
```
int[] a = {1,2,3};
```

动态初始化

int[] a = new int[2];
a[0] = 1;
a[1] = 2;

数组的默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

数组的基本特点
1. 长度是确定的，数组一旦被创建，它的大小就是不可以改变的。
2. 元素必须是相同的类型，不允许出现混合类型
3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型
4. 数组变量属于引用类型，数组也可以看成是对象，数组中每个元素相当于该对象的成员变量。
5. 数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象理性，数组对象本身是在堆中的。

3.数组使用

public class Demo02 {
//数组的简单操作
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};

        //打印全部的数组元素
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }

        //计算所有元素的和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum += arrays[i];
        }
        System.out.println("sum="+sum);

        //查找最大元素
        int max = arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            if (arrays[i]>max){
                max = arrays[i];
            }
        }
        System.out.println("max="+max);
    }
}

public class Demo03 {
//数组的进阶操作
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};

        //JDK1.5, 没有下标
        for (int array : arrays) {
            System.out.println(array);
        }

        printArray(arrays);

        System.out.println();
        int[] reverse = reverse(arrays);
        printArray(reverse);
    }

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

    //反转数组
    public static int[] reverse(int[] arrays) {
        int[] result = new int[arrays.length];

        //反转的操作
        for (int i = 0, j = result.length - 1; i < arrays.length; i++, j--) {
            result[j] = arrays[i];
        }

        return result;
    }
}

4.多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其中每一个元素都是一个一维数组
语法格式：int a[] [] = new int[n] [m]; // 可以看成n行 m列 $<img src="C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200730144908896.png" alt="image-20200730144908896" style="zoom: 67%;" />$

  public class Demo04 {
      public static void main(String[] args) {
  
          int[][] array = {{1, 2}, {2, 3}, {3, 4}, {4, 5}};
  
          for (int i = 0; i < array.length; i++) {
              for (int j = 0; j < array[i].length; j++) {
                  System.out.print(array[i][j]);
              }
              System.out.println();
          }
      }
  }

5.Arrays类

数组的工具类java.util.Arrays
由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作
Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用(注意：是“不用”而不是“不能”)
具有以下常用功能
1. 给数组赋值：通过 fill 方法
2. 对数组排序：通过 sort 方法，按升序。
3. 比较数组：通过 equals 方法比较数组中元素值是否相等。
4. 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

public class Demo05 {
    public static void main(String[] args) {
        int[] a = {1,4,7,2,9};

        //打印数组元素Arrays.toString
        System.out.println(Arrays.toString(a));

        Arrays.sort(a);//对数组元素进行排序   升序
        System.out.println(Arrays.toString(a));

        Arrays.fill(a,0); //填充数组
        System.out.println(Arrays.toString(a));
    }
}

冒泡排序

import java.util.Arrays;

public class Demo07 {
    //冒泡排序
    //时间复杂度：O(n的二次方)
    //1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，就交换
    //2.每一次比较，都会产生出一个最大，或者最小的数
    //3.下轮少一次排序
    //4.依次循环，知道结束
    public static void main(String[] args) {
        int[] a = {1,6,9,6,4,3};

        int[] sort = sort(a);//调用sort方法 ，返回排序后的数组
        System.out.println(Arrays.toString(sort));
    }

    public static int[] sort(int[] array) {
        //临时变量
        int temp = 0;
        //外层循环，判断要走多少次
        for (int i = 0; i < array.length - 1; i++) {
            //内层循环，比较判断两个方法，如果第一个数比第二个大，则交换
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j + 1] > array[j]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
        return array;
    }
}

6.稀疏数组

当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。
稀疏数组的处理方式是：
1. 记录数组一共有几行几列，有多少个不同值
2. 把具有不同值得元素和行列及值记录在一个小规模的数据中，从而缩小程序的规模
左边是原始数组，右边是稀疏数组

$<img src="C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200730161635012.png" alt="image-20200730161635012" style="zoom: 67%;" />$

public class Demo08 {
    public static void main(String[] args) {
        //1.创建一个二维数组 11*11    0：没有棋子 1：黑棋 2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始的数组
        System.out.println("输出原始的数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }

        System.out.println("===================================");
        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j] != 0) {
                    sum++;
                }
            }

        }
        System.out.println("有效值的个数；" + sum);

        //2.创建一个稀疏数组的数组
        int[][] array2 = new int[sum + 1][3];

        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //遍历二维数组，将非零的值，存放稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j]!=0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }

        //输出稀疏数组
        System.out.println("输出稀疏数组");

        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]+"\t");
        }

        System.out.println("===================================");
        System.out.println("还原稀疏数组");
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //2.给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]]=array2[i][2];
        }
        //3.打印
        System.out.println("输出还原的数组");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
}

本章知识点学习自

在 java.util 包中提供了 Date 类来封装当前的日期和时间，Date 类提供两个构造函数来实例化 Date 对象。

构造函数使用当前日期和时间来初始化对象
```
Date date = new Date();
```
构造函数接收一个参数，该参数是从 1970年1月1日起的毫秒数。
```
Date date = new Date(10000);		--参数类型 long millisec
```

1. Date 对象创建后，常用的方法

boolean after(Date date)

功能：可以用于两个日期的比较，如果调用此方法的Date对象在指定日期之后返回true，否则为false

public class TestString {
    public static void main(String[] args) throws InterruptedException {
        Date date = new Date();
        System.out.println(date.after(new Date(1000)));
    }
}

运行结果：
    true

boolean before(Date date)

功能：可以用于两个日期的比较，如果调用此方法的Date对象在指定日期之前返回true，否则为false

public class TestString {
    public static void main(String[] args) throws InterruptedException {
        Date date = new Date();
        Thread.sleep(3000);		//休眠3秒
        System.out.println(date.before(new Date()));
    }
}

运行结果：
    true

int compareTo(Date date)

功能：可以用于两个日期的比较，比较当调用此方法的Date对象和指定日期。两者相同时候返回 0，调用对象在指定日期之前返回负数，之后返回正数。

public class TestString {
    public static void main(String[] args) throws InterruptedException {
        Date date = new Date();
        Thread.sleep(3000);
        System.out.println(date.compareTo(date));
        System.out.println(date.compareTo(new Date()));
        System.out.println(date.compareTo(new Date(10000)));
    }
}

运行结果：
    0
    -1
    1

boolean equals(Object date)

功能：可以用于两个日期的比较，调用此方法的Date对象和指定日期相等时候返回true，否则返回false

public class TestString {
    public static void main(String[] args) throws InterruptedException {
        Date date1 = new Date(10000);
        Date date2 = new Date(10000);
        System.out.println(date1.equals(date2));
    }
}

运行结果：
    true

long getTime()

功能：可以用于两个日期的比较，返回 1970年1月1日00：00：00以来此Date对象表示的毫秒数

public class TestString {
    public static void main(String[] args) throws InterruptedException {
        Date date1 = new Date();
        System.out.println(date1.getTime());
    }
}

运行结果：
    1605070329120

int hashCode()

功能：返回此对象的哈希码值

public class TestString {
    public static void main(String[] args) throws InterruptedException {
        Date date1 = new Date();
        System.out.println(date1.hashCode());
    }
}

运行结果：
    -1247371646

void setTime(long time)

功能：根据1970年1月1日00：00：00以后时间毫秒数设置时间和日期

public class TestString {
    public static void main(String[] args) throws InterruptedException {
        Date date1 = new Date();
        date1.setTime(1);
        System.out.println(date1);
    }
}

运行结果：
    Thu Jan 01 08:00:00 CST 1970

String toString()

功能：把Date对象转换成String类型格式：

周几(Sun,Mon,Tue,Wed,Thu,Fri,Sat) mon dd hh:mm:ss zzz yyyy

public class TestString {
    public static void main(String[] args){
        Date date1 = new Date();
        System.out.println(date1.toString());
    }
}

运行结果：
    Wed Nov 11 12:56:39 CST 2020

2. SimpleDateFormat 格式化日期

public class TestString {
    public static void main(String[] args){
        Date date = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        System.out.println(simpleDateFormat.format(date));
    }
}

运行结果：
    2020-11-11 01:05:29

SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

这一行确立转换的格式，yyyy是完整的公元年，MM是月份，dd是日期，hh：mm：ss是时、分、秒。

2.1 解析字符串为时间

parse()，附加方法，按照给定的 SimpleDateFormat 对象的格式化存储来解析字符串

public class TestString {
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        System.out.println(simpleDateFormat.parse("2020-11-11"));

    }
}

运行结果：
    Wed Nov 11 00:00:00 CST 2020

2.2 使用 pringf 格式化日期

printf 方法可以很轻松地格式化时间和日期。使用字符的格式，以 %t 开头并且，以表格中的一个字母结尾。

符号	说明	例子
c	包括全部日期和时间信息	星期三十一月 11 12:00:00 CST 2020
F	年-月-日	2020-11-11
D	月/日/年	11/11/2020
r	HH:MM:SS PM --12时制	12：00：00 中午
T	HH:MM:SS --24时制	13：00：00
R	HH:MM --24时制	13：00

public class TestString {
    public static void main(String[] args){
        Date date = new Date();
        System.out.printf("%tc%n", date); //%n是换行
        System.out.printf("%tF%n", date);
        System.out.printf("%tD%n", date);
        System.out.printf("%tr%n", date);
        System.out.printf("%tT%n", date);
        System.out.printf("%tR%n", date);

    }
}

运行结果：
    星期三 十一月 11 13:17:25 CST 2020
	2020-11-11
	11/11/20
	01:17:25 下午
	13:17:25
	13:17

3. Java 中的休眠和测量时间

3.1 休眠，sleep

sleep() 使当前的线程变成停滞状态，阻塞当前线程，让出 CPU 的使用，目的是不让当前的线程独占该进程所获取的 CPU 资源，以留一定时间给其他线程执行。

public class TestString {
    public static void main(String[] args) {

        System.out.println(new Date());
        try {
            Thread.sleep(3000);//休眠3秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(new Date());
    }
}

运行结果：
    Wed Nov 11 13:36:29 CST 2020
	Wed Nov 11 13:36:32 CST 2020

3.2 测量时间，以毫秒为单位

public class TestString {
    public static void main(String[] args) {
        try {
            long start = System.currentTimeMillis();
            System.out.println(new Date());
            Thread.sleep(3000);
            System.out.println(new Date());
            long end = System.currentTimeMillis();
            System.out.println(end - start);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果：
    Wed Nov 11 13:39:52 CST 2020
	Wed Nov 11 13:39:55 CST 2020
	3018

认识java基础语法

1、认识基础

1.1 注释

1.2 标识符

2.数据类型

2.1 基本数据类型(primitive type)

2.2 引用类型(reference type)

2.3 数据类型扩展

3.类型转换

4.变量

5.常量

6.运算符

7.JavaDoc生成文档

1.用户交互Scanner

2.顺序结构

3.选择结构

4.循环结构

5.break 和 continue

1. 什么是方法

2.方法的定义

3.方法调用

4.方法的重载

5.可变参数

6.递归

1.数组概述

2.数组声明创建

数组的基本特点

3.数组使用

4.多维数组

5.Arrays类

6.稀疏数组

1. Date 对象创建后，常用的方法

2. SimpleDateFormat 格式化日期

2.1 解析字符串为时间

2.2 使用 pringf 格式化日期

3. Java 中的休眠和测量时间

3.1 休眠，sleep

3.2 测量时间，以毫秒为单位