java学习笔记—尚学堂

以下是一名初学者记录的笔记，若有错误请大家指正。

第一章 JAVA背景知识和jdk的安装配置

• JAVA由美国SUN公司于1995年发明，发明者詹姆斯·高斯林。

• JAVA主要的应用范围

  1. 服务器端软件开发：大中小型网站系统、政务系统、银行系统、医疗系统、各行各业软件系统。

  1. 移动端开发：安卓、鸿蒙均以java为主

  1. 大数据、云计算、科学研究等

• JAVA薪资待遇

  1. 薪资：跨度大（人口多）

  1. 内部岗位划分： 初级程序员、中级程序员、高级程序员、架构师、CTO

  1. 就业地域广：上至北上广深、下至三五六线。

• JVM（java Virtual Machine）：即虚拟计算机， 它主要负责java程序的运行（边解释边运行），java程序是在jvm上直接运行，而不是运行在操作系统上，java的跨平台就是基于不同版本的jvm来实现的。

• JRE（java Runtime Environment）:java运行时环境

JRE=JVM+ 核心类库和相关文件

• JDK（java Development Kit）:java开发工具包，提供给开发人员使用

JDK=JRE+java开发工具

包含关系：JDK = JAVA开发工具 + JVM + 相关类库

• JDK的安装：推荐jdk8.0

  • 进入oracle的官网下载jdk（www.oracle.com）

  1. 安装

  1. 配置环境变量

  1. 测试安装是否成功:cmd java -version

 

第二章 写出第一个java程序和bug调试技巧

Public class word{ 
​
    Public static void main(String[] args){
​
        System.out.println("Hello World");
​
    }
}
​

• 总结：java程序的运行机制：

• 1. 利用文本编辑器编写java源程序（.java）

  2. 利用编辑器将源程序编译成字节码文件（.class）

  3. 利用虚拟机解释运行

• 面对bug调试心态四定律：

• 1. Bug是程序和你互动的信号

  2. 程序越复杂，Bug越多

  3. 段位最高的程序员，一定是调Bug最多的程序员

  4. 写不出Bug的程序员一定是没写代码的程序员

第三章 标识符、关键字、变量本质、注释

• 标识符命名四大规则：

• 1. 标识符必须以字母、下划线_、美元符＄开头

  2. 标识符其他部分可以是字母、下划线_、美元符＄和数字的任意组合

  3. java标识符大小写敏感、且长度无限制

  4. 标识符不可以是java的关键字

• 标识符使用规范

• 1. 表示类名的标识符：每个单词的首字母大写，如Word、Test

  2. 表示方法和变量的标识符：第一个单词小写，从第二个单词开始首字母大写（驼峰原则）如eatFood（）

注：JAVA采用的是unicode字符集，汉字也属于字母，因此我们在命名时可以使用汉字，但是不推荐

• 关键字：有特殊含义的保留字

• 变量本质：就是代表一个“可操作的存储空间“，空间位置是确定的，但是里面放置什么值不确定。 我们可以通过变量名来访问“对应的存储空间”从而操纵这个“存储空间”存储的值。

• 注释的三种方式

• 1. 单行注释：单行注释使用//开头，//后面的单行内容均为注释

  2. 多行注释：多行注释以“/”开头，以“/”结尾，在中间的内容为注释，我们也可以使用多行注释作为行内注释。 但是在使用时要注意多行注释不能嵌套使用

  3. 文档注释：文档注释以“/*”开头以“/”结尾，注释中包含一些说明性的文字及一些javaDoc标签（后期些项目时，可以生成项目的API）

第四章 基本数据类型 整形 浮点型

• 变量本质是可操作的存储空间，像停车场；数据类型则类似于停车位的大小

• JAVA是一种强类型的语言，每个变量都必须声明数据类型。

• 数据类型分为：基本数据类型、引用数据类型。

• 基本数据类型分为：数值型（整形、浮点型）、字符型、布尔型。

  基本数据类型：

整形（数值型）	byte short int long	1字节 -27~27-1（-128~127） 2字节 -215~215-1（-32768~32767） 4字节 -231~231-1（约正负21亿） 8字节 -263~263-1
浮点型（数值型）	float double	4字节 -3.403E38~3.403E38 8字节 -1.798E308~1.798E308
字符型	char	2字节
布尔型	Boolean	1字节或4字节（true & false）

• 注：

  1. float类型被称作单精度类型，位数可以精确到7位有效数字；

  2. double表示这种类型的数值精度约是float类型的两倍，又被称作双精度类型，绝大部分应用程序都采用double类型；

  3. 浮点数默认double类型，浮点数是不精确的，要使用精确的运算用BigDecimal类；

关于进制：

int t1 = 65；	//十进制
int t2 = 065;	//八进制
int t3 = 0x65;	//十六进制
int t4 = 0b01000001;	//二进制

• ASCII码：使用一个字节的后7位来表示一个字符，总共表示128个字符，剩下最高位的bit一般为0；

• 字符集的进化史：ASCII~ISO8859-1~GB2312（国标码 2字节表示1汉字）~Unicode字符集（统一的字符集）— UTF-16 — UTF-8（主流编码） —UTF-32

• Unicode：字符集和编码区分开；通常两个字节表示一个字符（UTF-8用1~6个字节表示一个字符）

转义字符

转义符	含义	Unicode值
\b	退格	\u0008
\n	换行	\u000a
\r	回车	\u000d
\t	制表符（tab）	\u0009
\"	双引号	\u0022
\'	单引号	\u0027
\\	反斜杠	\u005c

第五章 基本运算符

运算符	分类
算术运算符 二元运算符 一元运算符	+，-，*，/，% ++，--
赋值运算符	=
扩展运算符	+=，-=，*=，/=
关系运算符	>,<,>=,<=,==,!=
逻辑运算符	&，|，&&，||，！，^
位运算符	&，|，^，~，>>，<<，>>>
条件运算符	？=
字符串运算符	+

• 算数运算符：

  1. +、-、*、/、%属于二元运算符，二元运算符指的是需要两个操作数才能完成的运算符。其中的%是取模运算符，就是我们常说的求余数操作。

  2. ++（自增），--（自减）属于一元运算符，该类运算符只需要一个操作数。、

  3. a++(先赋值，后自增)，++a（先自增，再赋值）

• 赋值及扩展运算符示例：a+=b 等效 a=a+b；

• 关系运算符示例：a==b（返回值布尔类型）；

• 逻辑运算符

  运算符	说明
  逻辑与 &（与）	两个操作数为true，结果才是true，否则是false
  逻辑或 |（或）	两个操作数有一个是true，结果就是true
  短路与 &&（与）	只要有一个为false，则直接返回false
  短路或 ||（或）	只要有一个为true，则直接返回true
  逻辑非 ！（非）	取反：！false为true，！true为false
  逻辑异或 ^ (异或)	相同为false，不同为true

• 位运算符

  位运算符	说明
  ~	取反
  &	按位与
  |	按位或
  ^	按位异或
  <<	左移运算符，左移1位相当于乘2
  >>	右移运算符，右移1位相当于除2取商

• 字符串运算符：有字符串参与运算，+号起连接作用；

• 条件运算符：a = x ? y : z ; x为true时返回y值，x为false时返回z值;

第六章 数据类型转换

• 自动类型转换：容量小的数据类型可以自动转换为容量大的数据类型（表数范围）

  • 整形常量直接赋值给byte/short/char等类型，只要不超过表数范围，则可以自动转换

  • 算术运算符，两个操作数都是整形：有一个是long，则结果为long。否则结果int（即使byte，结果也是int）

  • 算术运算符，有一个操作数是double，则结果是double

• 强制类型转换：会丢失精度; 方法如下

  • double e1 = 3.98;
    int e2 =(int)e1; //输出3

  • 当将一种类型强制转换成另一种类型，而又超出了目标类型的表数范围，就会被截断成一个完全不同的值。

  • 溢出错误：操作比较大的数，要留意是否溢出。

• Scanner键盘录入

  • import java.util.Scanner; //导入包
    ​
    public class JPSR {
         public static void main(String[] args){
             Scanner sc = new Scanner(System.in); 
             String str = sc.nextLine();
             System.out.println(str);
         }
    }

第七章 IDEA

1. 市场主流IDEA：IDEA、eclipse、vs code

2. IDEA捷克官网：(www.jetbralns.com)

3. 找到开发者工具Developer Tools——Choose your tool

4. 快捷方式：main回车；sout回车

第八章 选择结构

控制语句 if or else

• 编程的本质：用代码表达现实世界的逻辑，现实世界任何逻辑都可拆分成选择结构和循环结构；

  1. 选择结构：如果...则

  2. 循环结构：如果...则重复执行

• if语句

  1. 表示如果...则...的逻辑，也叫条件判断

  2. 语法结构：if（布尔表达式）{}如果是true则执行语句块，如果是false则不执行

  3. if else双分支语句块，表示有两个语句块；

  4. 语法结构
     if(a<5){
         System.out.println("数据比较小");
     }else{
         System.out.println("数据比较大");
     }

  5. 多分支结构：嵌套使用；

  6. 随机数命令：Math.random //范围[0,1)

控制语句 switch

• switch语法结构

  • switch(a){
        case 1 :                    //当a=1的情况下
            System.out.println("大学一年级");
            break;                  //中断、结束
        case 2 :
            System.out.println("大学二年级");
            break;
        default :
            System.out.println("大学三年级");
            break;

• switch语句中case标签可以接收整数、枚举、字符串；

第九章 循环结构

while循环

• 语法结构：while（布尔表达式）{循环体;} //true则执行循环体，false则跳出；

• 要有迭代词，否则死循环

for循环

• for循环：本质上跟while循环是一样的

  • 语法结构：for(初始表达式;布尔表达式;迭代因子){循环体;}x

  • for循环语句三个核心部分

    1. 初始化部分设置循环变量的初值

    2. 条件判断部分为任意布尔表达式

    3. 迭代因子控制循环变量的增减

• 嵌套循环：把循环控制语句组合起来；

• break（破坏）：在循环结构中，break代表强行结束整个循环结构；

• continue（继续）：在循环结构中，continue代表结束本次循环，继续下一次循环；

• 所有的编程都是由变量、选择结构、循环结构组成；

第十章 方法

方法的定义_内存结构

• 方法（method）：本质就是一段用来完成特定功能的代码片段；

• 方法声明格式：[多个修饰符] 返回值类型 方法名 (形式参数列表){多个java语句;}

• 无返回值时使用void参数；

方法重载

• 方法的重载(overload)定义:指一个类中可以定义多个方法名相同，但参数不同的方法。调用时会根据不同的参数自动匹配对应的方法；

  • 重载的方法实际是完全不同的方法，只是名称相同而已。

• 构成方法重载的条件：

  1. 不同的含义：形参类型、形参个数、形参顺序不同；

  2. 只有返回值不同不构成方法的重载 如：int a(String str){}与void a(String str){}不构成方法重载；

  3. 只有形参的名称不同，不构成方法的重载 如：int a(String str){} 与 int a(String s){}不构成方法重载；

第十一章 面向对象(Object)

类和对象

• 类如何定义

  • 三个常见成员	负责
    属性field	静态特征（数据）
    方法method	动态行为（对数据的操作）
    构造器constructor	初始化对象

    • 属性：也叫做成员变量，java使用默认的值对其初始化

    • 数据类型	默认值
      整形	0
      浮点型	0.0
      字符型	'\u000'
      布尔型	false
      所有引用类型	null

• 类和对象的关系

  • 类（class）

  • 对象（Object），也叫实例（instance），它们的含义是一样的。

  • 类是模板，对象是汽车；

  • obj xs1  =   new   obj();
    类型 变量 = 创建一个对象 构造方法;

• 理解流程图

构造器（构造方法）

• 构造方法作用：用于对象的初始化；

• java通过new关键字来调用构造器，它是一种特殊的方法；

• 声明格式：[修饰符] 类名 (形参列表){//n个语句}

• 构造器4大要点：

  1. 构造器通过new关键字调用！

  2. 构造器虽然有返回值，但是不能定义返回类型（返回的类型肯定是本类），不能在构造器里使用return返回某个值。

  3. 如果我们没有定义构造器，则编译器会自动定义一个无参的构造器（方法）。如果已定义则编译器不会自动添加！

  4. 构造器的方法名必须和类名一致！

• 创建对象4大步和构造方法调用关系

  1. 分配对象空间，并将对象成员变量初始化为0或空；

  2. 执行属性值的显式初始化；

  3. 执行构造方法，舒适化对象；

  4. 返回对象的地址给相关的变量；

分析：内存_栈和堆

• 栈的特点：

  1. 栈描述的是方法执行的内存模型。每个方法被调用都会创建一个栈帧（存储局部变量、操作数、方法出口等）

  2. 栈的存储特性是“先进后出，后进先出”

  3. 栈是由系统自动分配，速度快！栈是一个连续的内存空间！

  4. JVM为每个线程创建一个栈，用于存放该线程执行方法的信息（实际参数、局部变量等）

  5. 栈属于线程私有，不能实现线程间的共享！

• 堆的特点：

  1. 堆用于存储创建好的对象和数组（数组也是对象）

  2. 堆是一个不连续的内存空间，分配灵活，速度慢！

  3. JVM只有一个堆，被所有线程共享

• 方法区（又叫静态区，也是堆）特点：

  1. 方法区是JAVA虚拟机规范，可以有不同的实现。（jdk8是“元数据空间”和堆结合起来）

  2. 方法区实际也是堆，只是用于存储类、常量相关的信息！

  3. 用来存放程序中永远不变或唯一的内容。（类信息、静态变量、字符串常量等）

  4. JVM只有一个方法区，被所有线程共享！

分析：this的本质

• this的本质就是“当前对象的地址”

  • 普通方法中，this总是指向调用该方法的对象；

  • 构造方法中，this总是指向正要初始化的对象；

• 方法2：this(id,name) //调用了重载的构造器！这种调用，必须位于构造器的第一行！

static 本质

• static关键字核心用法

  • 用static声明的变量为静态成员变量，也成为类变量。特点如下：

    1. 从属于类，只有一份，在类被载入时被显示初始化。

    2. 一般用“类名.类属性/方法”来调用。

    3. 在static方法中不可直接访问非static的成员。

• 静态初始化块

  • 构造方法用于对象的初始化；

  • 静态初始化块，用于类的初始化操作；可以初始化static属性。

  • 在静态初始化块中不能直接访问非static成员。

面向对象编程

package_import

• package位于类的第一个非注释性语句

• JDK中的主要包

java中的常用包	说明
java.lang	包含了一些java语言的核心类，如String、Math、Integer、System、和Thread，提供常用功能。
java.awt	包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面（GUI）
java.net	包含执行与网络相关的操作的类。
java.io	包含能提供多种输入\输出功能的类。
java.util	包含一些使用工具类，如定义系统特性、使用与日期日历相关的函数。

• import

  1. 如果我们要使用其他包的类，需要使用import导入，从而可以在本类中直接通过类名来调用，否则就需要书写类的完整包名和类名。

  2. java会默认导入java.lang包下所有的类，因此这些类我们可以直接使用。

  3. 如果导入两个同名的类，只能用包名+类名来显示调用相关类。

  4. java.util.* //*导入该包下所有的类，他会降低编译速度，但不会降低运行速度

• 静态导入(import static)：作用是用于导入指定类的静态属性和静态方法，这样我们可以直接使用静态属性和静态方法。

  • import static java.lang.Math.random;

面向对象三大特点

• 继承的实现

  • 继承让我们更容易实现类的扩展。这样就实现了代码的重用，不用再重新发明轮子；

  • 从英文字面意识理解，extends的意思是“扩展”。子类是父类的扩展；

• 继承使用要点：

  1. java中只有单继承，没有像C++那样的多继承 。

  2. java中类没有多继承，接口有多继承。

  3. 子类继承父类，可以得到父类的全部属性和方法（除了父类的构造方法），但不见得可以直接访问（比如，父类私有的属性和方法）

  4. 如果定义一个类时，没有调用extends，则他的父类是：java.lang.Object;

• instanceof（运算符）

  • stu1 instanceof Student :判断左边的对象是否是右边类的实例

• 方法的重写（override）：子类通过重写父类的方法可以用自身的行为替换父类的行为；

  • 方法的重写是实现多态的必要条件；

• 方法的重写需要符合下面的三个要点：

  1. “==”：方法名、形参列表相同。

  2. “《=”：返回值类型和声明异常类型，子类小于等于父类。

  3. “》=”：访问权限，子类大于等于父类。

• final的三种用法：

  1. 修饰变量：被它修饰的变量不可改变。一旦赋了初值，就不能被重新赋值。final int MAX_SPEED = 120;

  2. 修饰方法：该方法不可被子类重写。但是可以被重载！final void study(){}

  3. 修饰类：修饰的类不能被继承。比如：Math、String等。final class A{}

继承和组合

• 组合的核心：就是“将父类对象作为子类的属性”。然后，“子类通过调用这个属性来获取父类的属性和方法”

• 组合比较灵活。继承只能有一个父类，但是组合可以有多个属性。

• 对于“is -a”关系建议使用继承，“has -a”关系建议使用组合。

Object类

• Object类源码解析（ctrl+左键单击）

  • 所有类默认继承自Object

• 重写toString()方法

  • 打印对象默认是调用的toString()

• 重写equals()方法

  • e1.equals(e2)：判断两个对象是否相等(逻辑上进行某些值的比较)

super

• super是什么：

  1. super“可以看做”是直接对 父类对象的引用；

  2. 可以通过super来访问父类中被子类覆盖的方法或属性

• super的本质：

  1. 在一个类中，若是构造方法的第一行代码没有显式的调用super(...)或者this(...)；那么java默认都会调用super()，含义是调用父类的无参数构造方法。这里的super()可以省略。

  2. 子类创建的整个过程只创建了一个对象。

  3. super的本质就是：当前对象的父类的特征。

封装

• 封装的定义（encapsulation）：对于一个类，需要让外部调用者知道的才暴露出来，不需要让外部调用者知道的全部隐藏起来。

• 封装目的：让程序做到高内聚，低耦合；

  • 高内聚：类内部复杂的数据处理尽量自己完成，不让外部知道；

  • 低耦合：尽量方便外部调用者的使用；

• 封装的优点：

  1. 提高代码的安全性。

  2. 提高代码的复用性。

  3. “高内聚”：封装细节，便于修改内部代码，提高可维护性。

  4. “低耦合”：简化外部调用，便于调用者使用，便于扩展和协作。

• 封装的实现（使用访问控制符）：java中是使用访问控制符来控制这些细节，通过它我们可以知道哪些属性或方法需要封装，那些需要暴露；

  • private：表示私有，只有自己类能访问；

  • default：表示没有修饰符修饰，只有同一个包的类能访问；

  • protected：表示可以被同一个包的类以及其他包中的子类访问；

  • public：表示可以被该项目的所有包中的所有类访问；

  • 

• 封装的简单规则：

  • 属性：一般使用private访问权限。

  • 属性私有后，提供相应的get/set方法来访问相关属性，这些方法通常是public修饰的，以提供对属性的赋值与读取操作

    • 注意：boolean变量的get方法是is开头！

  • 方法：一些只用于本类的辅助性方法可以用private修饰，希望其他类调用的方法用public修饰

多态（polymorphism）

• 多态的定义：多态指的是同一个方法调用，由于对象不同可能会有不同的行为

• 多态的要点：

  1. 多态是方法的多态，不是属性的多态（多态与属性无关）

  2. 多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象。

  3. 父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

  4. 

抽象类和抽象方法

• 抽象(abstract)的真实含义：“抽出像的部分”，学术一点就是：“抽出共同特征”。

• 抽象方法

  1. 使用abstract修饰的方法，没有方法体，只有声明。

  2. 定义的是一种“规范”，就是告诉子类必须要给抽象方法提供具体的实现。

• 抽象类

  1. 包含抽象方法的类就是抽象类。

  2. 通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。

• 抽象类的使用要点：

  1. 有抽象方法的类只能定义成抽象类。

  2. 抽象类不能实例化，即不能用new来实例化抽象类

  3. 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例，只能用来被子类调用。

  4. 抽象类只能用来被继承。

  5. 抽象方法必须被子类实现。

接口(interface)

接口全面的实现了：规范和具体的分离。

• 区别：

  • 普通类：具体实现

  • 抽象类：具体实现，规范（抽象方法）

  • 接口：规范！

• 如何定义和使用接口

  • 声明格式：
        [访问修饰符] interface 接口名 [extends 父接口1，父接口2...]{
                常量定义;
                方法定义;
    }  
        class Test implements C{}

  • 注：接口里只能定义常量和抽象方法；

• 接口的使用说明：

  1. 子类通过implements来实现接口中的规范。

  2. 接口不能创建实例，但是可用于声明引用变量类型。

  3. 一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的。

  4. JDK1.8之前，接口中只能包含静态常量、抽象方法，不能有普通属性、构造方法、普通方法

  5. JDK1.8后，接口中包含普通的静态方法、默认方法，让接口更加灵活、扩展性更强

• 默认方法：

  • 默认方法用default关键字，一个接口中可以有多个默认方法。默认方法也叫扩展方法。

  • 子类实现接口时，可以直接调用接口中的默认方法，也可以重写。

• 静态方法：

  • 接口中同时还可以定义静态方法，静态方法通过接口名调用。

  • 如果实现类中定义了相同名字的静态方法，那就是完全不同的方法了，直接从属于实现类。通过类名直接调用。

• 命名冲突问题（如果方法名称和形参列表相同，会发生命名冲突）

  1. 父类优先。如果父类的方法和接口默认方法名冲突，则父类优先。

  2. 接口冲突。如果多个接口中默认方法有相同名字，则子类必须实现重新实现。

内部类

• 内部类的要点：

  1. 内部类是一类特殊的类，指的是定义在一个类的内部的类。

  2. 实际开发中，为了方便的使用外部类的相关属性和方法，这时候我们通常会定义一个内部类。内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员。但外部类不能访问内部类的内部属性。

  3. 内部类提供了更好的封装。只能让外部类直接访问。

• 注：非静态内部类不能有静态的方法、静态的属性、静态初始化块。

• System.out.println("外部age"+inne.this.age);
  //通过：外部类名.this.属性名，访问外部类的属性

• 构造内部类对象

• //非静态内部类的对象必须寄存在一个外部类对象里
  //先创建外部类的对象，然后使用外部类对象创建内部类对象
  inne.inner i = new inne().new inner();

• 静态内部类

  • 定义方式：
        static class ClassName{
        //类体
        }

• 使用要点：

  1. 静态内部类可以访问外部类的静态成员，不能访问外部类的普通成员。

  2. 静态内部类看做外部类的一个静态成员。

• 构造静态内部类对象：

  • //通过new 外部类名.内部类名()来创建静态内部类的对象
    inne.inner j = new inne.inner();

• 匿名内部类：适合那种只需要使用一次的类。比如：键盘监听操作等等。在安卓开发 awt swing GUI里开发中常见（GUI就是用户界面编程）

  • new A3():执行定义匿名内部类的同时创建匿名内部类对象。

  • 匿名内部类只使用一次，用完就报废。

• 局部内部类：定义在方法内部的，作用域只限于本方法，称为局部内部类。

  • 局部内部类在实际开发中应用很少，作为一个基本知识点了解即可

第十二章 数组和算法

一维数组

• 数组的定义：数组是相同类型数据的有序集合。

  • 动态初始化：int [] a = new int[5];

  • 静态初始化：int[] a = {100,200,300,400};

• 数组的四个特点：

  1. 长度是确定的。数组一旦被创建，它的大小就是不可以改变的。

  2. 其元素的类型必须是相同类型，不允许出现混合类型。

  3. 数组类型可以是任何数据类型，包括基本类型和引用类型。

  4. 数组也是对象。数组中的元素相当于该对象的成员变量。

• 知识点

  • 数组索引从0开始

  • a.length计算数组的长度

  • 增强for循环（temp:c）:从c这个数组里取出遍历的元素，临时变量叫temp，更方便地遍历数组；

  • 数组的拷贝(arraycopy)：System.arraycopy(a原数组,1从1开始拷贝,b目标数组,0存放位置,2拷贝数量2个);

  • 工具类(import java.util.Arrays):更方便地操作数组；

    • 打印数组:Arrays.toString(c) 是一个静态方法。

    • 排序数组：Arrays.sort(c); 将数组按升序排序。

    • 二分查找：Arrays.binarySearch(c,100) 查找当前数组有没有100这个值。

    • 快速填充：Arrays.fill(a,100); 表示将数组a的值全部填充成100。

多维数组

• 多维数组的本质

  1. 多维数组可以看成以数组为元素的数组。例：int[] []a={{1,2,3},{5,6},{7,8,9}};

• 多维数组的遍历：

  • for循环嵌套循环

  • 嵌套使用Arrays.toString

冒泡排序

int[] values = {2,6,3,8,1,3,7,0,1,9,4};
​
System.out.println("排序前数组："+ Arrays.toString(values));
​
int temp;//临时变量，用于交换
boolean flag = true; //定义一个布尔类型变量，标记数组是否已达到有序状态
​
for(int i=0;i<values.length;i++){
​
    for (int j=0;j<values.length-1;j++){
​
        if (values[j]>values[j+1])
        {
            //两两交换，如果大于，则互换元素
            temp = values[j];
            values[j] = values[j+1];
            values[j+1] = temp;
            //判断
            flag = false;
        }
​
    }
    System.out.println("第"+i+"次循环，结果为："+Arrays.toString(values));
​
    //冒泡排序的优化
    if(flag==true){
        System.out.println("循环结束");
        break;
    }else {
        flag=true;
    }
}

二分法查找（折半查找）

• 二分法查找针对的是有序数组，要先进行排序。

• 代码案例
  public static int chazao(int array[],int shu){
  ​
      Arrays.sort(array);
      System.out.println(Arrays.toString(array));
  ​
      int air = 0;
      int high = array.length-1;
  ​
      while(air <= high){
          int min = (high+air)/2;
  ​
          if(array[min]==shu){
              return min;
          }
          if (shu<array[min]){
               high = min-1;
          }
          if(shu>array[min]){
              air = min+1;
          }
      }
      return -1;
  }

第十三章 常用类

String类（不可变字符序列）

• String类是什么？

  • String类又称作不可变字符序列。

  • String位于java.lang包中，java程序默认导入java.lang包下的所有类。

  • java字符串就是Unicode字符序列，例如字符集“java”就是4个Unicod字符'j','a','v','a'组成的。

  • java没有内置的字符串类型，而是在标准java类库中提供了一预定义的类String，每个用双引号括起来的字符串都是String类的一个实例。

• 知识点

  • String s1 = "abc"; //凡是字符串常量，都会放到字符串常量池中

  • String s2 = new String("abc"); //建了一个新的字符串对象

  • ==：判断两个字符串是不是同一个对象

  • s1.equals(s2)： //判断字符串的值是不是同一个

  • s1.equalsIgnoreCase(s4); //忽视大小写比较值

  • 

StringBuilder / StringBuffer（可变字符序列）

• 区别

  • String：不可变字符序列

  • StringBuffer和StringBuilder：可变字符序列，方法一模一样。

  • StringBuffer：线程安全，做线程同步检查，效率较低。

  • String Builder：线程不安全，不做线程同步检查，因此效率较高。建议采用该类。

• 常用命令方法

  • sb.reverse():字符串逆序

  • ab.append(""):添加字符串

  • ab.insert(0,"")：在0索引位置添加字符串

  • ab.delete(0,2):删除索引[0,2)位置的字符串

  • ab.deleteCharAt(0):删除该索引位置字符

• 补充小知识：

  • long num = Runtime.getRuntime().freeMemory(); //获取jvm剩余的内存空间，单位是字节

  • long time = System.currentTimeMillis(); //获取当前时间，单位是毫秒

包装类

• 小知识：JAVA是面向对象的语言，但并不是“纯面向对象”。他不像Python，一切都是对象。java中，基本数据类型不是对象。这时候，我们可以用包装类把基本数据类型变成对象。

• 包装类基本用法

public static void testInteger(){
    //基本数据类型转化成Integer对象
    Integer int1 = Integer.valueOf(100);
​
    //包装类对象转成基本数据类型
    int int2 = int1.intValue();
    long long1 = int1.longValue();
​
    //字符串转成Integer对象
    Integer int3 = Integer.parseInt("324");
    System.out.println(int3);
    System.out.println(int3.toString());  //包装类对象转成字符串
​
    System.out.println("int能表示的最大整数"+Integer.MAX_VALUE);
​
}

• 自动装箱：Integer a = 100; //编译器自动添加：Integer a = Integer.valueOf(100);

  • 整形、char类型所对应的包装类。在自动装箱时，对于-128到127之间的值会进行缓存处理，为了提高效率。

• 自动拆箱：int b = a; //编译器自动添加：int b = a.intValue();

  • 要注意 空指针异常

时间转换字符串

• 1970.1.1 00：00：00定位基准时间，每个计时单位是毫秒

• 获取当前时刻方法：System.currentTimeMillis

• 时间类对象：Date d1 = new Date(); //默认返回当前时间

• DateFormat类的使用：时间和字符串之间互相转换

  • DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

  • //转换时需要指定格式，如yyyy-MM-dd hh:mm:ss（年-月-日 时-分-秒）

  • df.format(d2); //传进来一个时间对象，返回一个字符串

  • df.parse(str3); //传进来一个字符串，返回一个时间对象

第十四章 IO流

io流是什么

• io：Input（输入）/Output（输出）

  • java中io流技术屏蔽了外部的所有差异，只需要知道各种流对象该怎么用就可以，不用关心外部是什么设备

  • java.io包为我们提供了相关的API，实现了对所有外部系统的输入输出操作。

• 数据源

  • 数据源data source，提供数据的原始媒介。常见的数据源有：数据库，文件，其他程序，内存，网络连接，IO设备。

  • 数据源分为：源设备、目标设备。

    • 源设备：为程序提供数据，一般对应输入流。

    • 目标设备：程序数据的目的地，一般对应输出流。

      

• 流的概念

  • 流是一个抽象、动态的概念，是一连串连续动态的数据集合。

  • 对于输入流而言，数据源就像是水箱，流（stream）就像水管中流动着的水流，程序就是我们最终的用户。我们通过流（A Stream）将数据源（Source）中数据（information）输送到程序（Program）中。

  • 对于输出流而言，目标数据流就是目的地（dest），我们通过流将程序中的数据输送到目的数据源（dest）中。

    

JAVA中流的概念细分

• 按流的方向分类：

  • 输入流：数据流向是数据源到程序

  • 输出流：数据流向是程序到目的地

• 按处理的数据单元分类：

  • 字节流：以字节为单位获取数据，命名上以Stream结尾的流一般是字节流

  • 字符流：以字符为单位获取数据，命名上以Reader/Writer结尾的流一般是字符流

• 按处理对象不同分类：

  • 节点流：可以直接从数据流或目的地读写数据

  • 处理流：不直接连接到数据流或目的地，是“处理流的流”。通过对其他流的处理提高程序的性能

    

IO流体系介绍

• 文件字符流：文件字节流可以处理所有的文件，但是字节流不能很好的处理Unicode字符，经常会出现“乱码”现象。所以，我们处理文本文件，一般可以使用文件字符流，他以字符为单位进行操作

• 字节数组流：ByteArrayInputStream和ByteArrayOutputStream经常用在需要流和数组之间转化的情况！说白了，FilelnputStream是把文件当作数据流。ByteArrayInputStream则是把内存中的“某个字节数组对象”当做数据流。

• 数据流：数据流将“基本数据类型与字符串类型”作为数据流，从而允许程序以与机器无关的方式从底层输入输出流中操作java基本数据类型与字符串类型。

• 对象流：ObjectInputStream/ObjectOutputStream是以“对象”为数据流，但是必须将传输的对象进行序列化与反序列化操作。

  • 需要序列化的对象，需要实现接口：java.io.Serializable对象序列化的作用有如下两种：

    • 持久化：把对象的字节序列永久地保存在硬盘上，通常存放在一个文件中，比如：休眠的实现。

    • 网络通信：在网络上传送对象的字节序列。比如：服务器之间的数据通信、对象传递。

  • 注：static属性不参与序列化。 对象中的某些属性如果不想被序列化，不能使用static，而是使用transient修饰

• 随意访问文件流：RandomAccessFile可以实现两个作用：

  1. 实现对一个文件做读和写的操作。

  2. 可以访问文件的任意位置。不像其他流只能按照先后顺序读取。