JavaSE 思维导图模板_ProcessOn思维导图、流程图

Collection（集合）

常用功能

add(E e)：添加到当前集合中。

clear():清空集合中所有的元素。

remove(E e):删除当前集合中的对象。

contains(E e):判断当前集合中是否包含给定的对象。

isEmpty():判断当前集合是否为空。

size():返回集合中元素的个数。

toArray():把集合中的元素，存储到数组中。

Collections

shuffle(): 乱序

addAll(Collection<T>c,T...elements):往集合中添加一些元素。

sort(List<T>list):将集合中元素按照默认规则排序。

sort(List<T>list，Comparator<?superT>):将集合中元素按照指定规则排序

Comparable和Comparator两个接口的区别

Comparable

自然排序，类的compareTo方法被称为它的自然比较方法。 只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。 实现接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序， 对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

Comparator

强行对某个对象进行整体排序。可以将Comparator传递给sort方法（如Collections.sort或Arrays.sort）， 从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序， 或者为那些没有自然顺序的对象collection提供排序。

List

ArrayList

底层数据结构为线性表，增删慢，查询快，线程非安全

add(Object)

List list = new ArrayList(); list.add(1);

size()

list.size()

get(index)

返回集合中指定位置的元素。

set(intindex,Eelement)

用指定元素替换集合中指定位置的元素,返回值的更新前的元素。

remove(index)

移除列表中指定位置的元素

contains(Object)

toArray()     E[]

返回E[]

iterator()     Iterator<E>

返回Iterator<E>

LinkedList

底层数据为双向链表，增删快，查询慢，线程非安全

addFirst(Ee):将指定元素插入此列表的开头。

addLast(E e):将指定元素添加到此列表的结尾。

getFirst():返回此列表的第一个元素。

getLast():返回此列表的最后一个元素。

removeFirst():移除并返回此列表的第一个元素。

removeLast():移除并返回此列表的最后一个元素。

pop():从此列表所表示的堆栈处弹出一个元素。

push(E e):将元素推入此列表所表示的堆栈。

isEmpty()：如果列表不包含元素，则返回true。

Vector

线程安全，效率低，不经常用

Set

HashSet<Object>

add()

存储的元素是不可重复的，无序的

需要重写对象中的hashCode和equals方法，才能保证HashSet集合中的对象唯一

LinkedHashSet

存储的元素是不可重复的，有序的

TreeSet

Map

HashMap

元素的存取顺序不能保证一致

key唯一性，不能重复

需要重写键的hashCode()方法、equals()方法。

LikedHashMap

HashMap的子类

存储数据采用的哈希表结构+链表结构。 通过链表结构可以保证元素的存取顺序一致

常用方法

put(K  key,V  value):把指定的键与指定的值添加到Map集合中。

remove(Object  key):把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值。

get(Object   key)根据指定的键，在Map集合中获取对应的值。

Set<K>  keySet():获取Map集合中所有的键，存储到Set集合中。

Set<Map.Entry<K,V>>entrySet():获取到Map集合中所有的键值对对象的集合(Set集合)。

List、Set、Map的区别

List、Set同属于Collection接口

List添加有序，Set添加无序

List、Set可以使用Iteration遍历，而Map不行

List里面的元素可以重复，Set里面的元素不可以重复

Map使用put<K,V>添加元素，K唯一

Throwable （异常）

异常分类

Error

严重错误Error，无法通过处理的错误。

Exception

表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。

编译时期异常:checked异常。

在编译时期,就会检查,如果没有处理异常,则编译失败。(如日期格式化异常)

运行时期异常:runtime异常

在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。(如数学异常)

常用方法

printStackTrace():打印异常的详细信息。

getMessage():获取发生异常的原因。

toString():获取异常的类型和异常描述信息(不用)。

子主题

异常处理

异常处理的五个关键字：try、catch、finally、throw、throws

抛出异常throw

throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。

throw  new  异常类名  (参数);

声明异常throws

：将问题标识出来，报告给调用者

修饰符返回值类型方法名(参数)throws异常类名1,异常类名2…{  。。。} public  static  void  main(String  []  args)  throws   IOException{  。。。}

捕获异常try…catch

：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理

try：该代码块中编写可能产生异常的代码。

catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。

finally代码块

finally：无论异常是否发生，都会执行

因为异常会引发程序跳转，导致有些语句执行不到。 而finally就是解决这个问题的，在finally中一定会被执行的。

try...catch....finally:自身需要处理异常,最终还得关闭资源。

异常注意事项

运行时异常被抛出可以不处理。即不捕获也不声明抛出。

如果finally有return语句,永远返回finally中的结果,避免该情况.

如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。

父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出

自定义异常

在开发中根据自己业务的异常情况来定义异常类. 自定义一个业务逻辑异常:RegisterException。一个注册异常类。

自定义一个业务逻辑异常:RegisterException。一个注册异常类。

自定义一个运行时期的异常类:自定义类并继承于java.lang.RuntimeException。

泛型

可以在类或方法中预支地使用未知的类型

程序发生转换异常时，需要用到泛型

Collection虽然可以存储各种对象，但实际上通常Collection只存储同一类型对象。否则需要内部的转换

在JDK5之后，新增了泛型(Generic)语法

在创建对象的时候确定泛型

地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递

通配符

不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。

上线

类型名称<?extends类>对象名称

只能接收该类型及其子类

下线

类型名称<?super类>对象名称

只能接收该类型及其父类型

多线程

继承Thread类，重写run（）

实现Runnable接口

并发与并行

并发

指两个或多个事件在同一个时间段内发生。

并行

指两个或多个事件在同一时刻发生（同时发生）。

进程

是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程； 进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。

线程

线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。 一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

线程调度

分时调度（平均分配）

抢占式调度（优先级高的先行）

创建线程

所有的线程对象都必须是Thread类或其子类的实例

Java中通过继承Thread类来创建并启动多线程

1、定义Thread类的子类，并重写该类的run()方法， run()方法代表了线程需要完成的任务,因此把run()方法称为线程执行体

2、创建Thread子类的实例，即创建了线程对象

3、调用线程对象的start()方法来启动该线程

Thread类

Thread():分配一个新的线程对象。

Thread(String  name):分配一个指定名字的新的线程对象。

Thread(Runnable  target):分配一个带有指定目标新的线程对象。

Thread(Runnable  target,String  name):分配一个带有指定目标新的线程对象并指定名字。

getName():获取当前线程名称

start():导致此线程开始执行;Java虚拟机调用此线程的run方法。

run():此线程要执行的任务在此处定义代码。

sleep(longmillis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。

currentThread():返回对当前正在执行的线程对象的引用。

Runnable

1、定义Runnable接口的实现类，并重写该接口的run()方法，run()方法是该线程的线程执行体

2、创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象， 该Thread对象才是真正的线程对象。

3、调用线程对象的start()方法来启动线程。

Thread和Runnable区别

如果一个类继承Thread，则不适合资源共享。 如果实现了Runable接口的话，则很容易的实现资源共享。

实现Runnable接口比继承Thread类所具有的优势：

1.适合多个相同的程序代码的线程去共享同一个资源。

2.可以避免java中的单继承的局限性。

3.增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。

4.线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

线程安全

线程同步

要解决上述多线程并发访问一个资源的安全性问题：使用同步机制(synchronized)来解决。

1. 同步代码块。

2. 同步方法。

3. 锁机制。

同步代码块

synchronized 关键字可以用于方法中的某个区块中

synchronized( 同步锁 ){           需要同步操作的代码    }

同步锁:

对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.

1. 锁对象 可以是任意类型

2. 多个线程对象 要使用同一把锁。

同步方法

使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。

public synchronized void method ( ) { 可能会产生线程安全问题的代码 }

Lock锁

了比synchronized代码块和synchronized方法更广泛的锁定操作, 同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

lock() :加同步锁。

unlock() :释放同步锁。

线程状态

Timed Waiting（计时等待）

一个线程正在等待被另一个线程执唤醒动作的这一状态

BLOCKED（锁阻塞）

一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。

Waiting（无限等待）

一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。

常用方法

notify ( )

唤醒此对象监视器上等待的单个线程

notifyAll ( )

唤醒此对象监视器上等待的所有线程

wait ( )

在其他线程调用此对象的notify（）或notifyAll（）方法前，导致当前线程等待。

wati（Long timeout）

在其他线程调用此对象的notify（）或notifyAll（），或者超过指定的时间量前，导致当前线程等待。

线程池

就是一个容纳多个线程的容器，其中的线程可以反复使用，无需反复创建线程而消耗过多资源。

好处：

1. 降低资源消耗。

2. 提高响应速度。

3. 提高线程的可管理性

方法

newFixedThreadPool ( int nThreads) ：返回线程池对象

submit( Runnable task) :获取线程池中的某一个线程对象，并执行

、步骤

1. 创建线程池对象。

2. 创建Runnable接口子类对象。(task)

3. 提交Runnable接口子类对象。(take task)

4. shutdown (  ) 销毁线程池(一般不做)。

流

IO流

input  输入流

把数据从其他设备上读取到内存中的流。

output   输出流

把数据从内存中写出到其他设备上的流。

字节流

以字节为单位，读写数据的流。

输入流 InputStream

abstract int read() ： 从输入流读取数据的下一个字节。

close( )  :   关闭并释放资源

read(byte[] b) ： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。

FileInputStream

FileInputStream(File file) ： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。

FileInputStream(String name) ： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

输出流 OutputStream

close() ：关闭并释放资源

flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。

write(int b) ：将指定的字节输出流。

write(byte[] b) ：将 b.length字节从指定的字节数组写入此输出流。

write(byte[] b, int off, int len) ：从字节数组写入 len字节，从偏移量 off开始输出到此输出流。

FileOutputStream

FileOutputStream(File file) ：创建文件输出流以写入由指定的 File对象表示的文件。

FileOutputStream(String name) ： 创建文件并写入文件。

FileOutputStream(String name, boolean t) ：指定文件追加内容 （true 表示追加数据， false 表示清空原有数据。）

FileOutputStream(File file, boolean t) ： 创建文件输出流以写入由指定的 File对象表示的文件。 （true 表示追加数据， false 表示清空原有数据。）

字符流

以字符为单位，读写数据的流。

输入流 Reader

read() ： 从输入流读取一个字符。

read(char [] arr) ： 从输入流中读取一些字符存储到数组中 。

FileReader

FileReader(File file) ： 创建一个新的 FileReader ，给定要读取的File对象

FileReader(String fileName) ： 创建一个新的 FileReader ，给定要读取的文件的名称。

输出流 Writer

write(int c) 写入单个字符。

write(char[] cbuf) 写入字符数组

write(char[] a, int b, int len)  写入字符数组的某一部分,b数组的开始索引,len写的字符个数。

write(String str) 写入字符串。

flush() 刷新该流的缓冲。

close() 关闭此流，但要先刷新它。

FileWriter

FileWriter(File file) ： 创建一个新的 FileWriter，给定要读取的File对象。

FileWriter(String fileName) ： 创建一个新的 FileWriter，给定要读取的文件的名称

缓冲流

对字节流和字符流的增强

字节缓冲流

BufferedInputStream         字节输入流

BufferedOutputStream          字节输出流

字符缓冲流

BufferedReader    字符输入流

BufferedWriter    字符输出流

转换流

InputStreamReader

InputStreamReader(InputStream in, String charsetName) : 创建一个指定字符集的字符流。

OutputStreamWriter

OutputStreamWriter(OutputStream in, String charsetName) : 创建一个指定字符集的字符流。

序列化流

ObjectOutputStream       对象的序列化流

ObjectOutputStream(OutputStream out) ： 创建一个指定OutputStream的ObjectOutputStream。

ObjectInputStream   对象的反序列化流

ObjectInputStream(InputStream in) ： 创建一个指定InputStream的ObjectInputStream。

打印流

PrintStream

print

println

Stream流

Stream（流）是一个来自数据源的元素队列

元素是特定类型的对象，形成一个队列

数据源：流的来源。 可以是集合，数组 等。

Pipelining: 中间操作都会返回流对象本身。

内部迭代：Stream流可以直接调用遍历方法。

属于管道流，只能被（消费）使用一次

常用方法

逐一处理：forEach

过滤：filter

映射：map

统计个数：count

取用前几个：limit

跳过前几个：skip

将2个合并为1个：concat

排序算法

选择排序

每一个元素与第一个元素比较，如果小，则交换

i:第一个元素的位置

0~arr.length-1

j：后面那个元素的位置

i+1~arr.length

冒泡排序

两两比较，如果后面的小，交换

i：比较的轮数

0~arr.length-1

j：比较的位置

0~arr.length-i-1

a[j] a[j+1]

快速排序*

其他排序

JDK提供的排序方法

Arrays.sort(arr[]

底层实现使用的排序算法中的快速排序

递归算法

在方法体内调用自身的方法

递归头

递归循环体

Java基础入门

了解java

什么是java

Java语言是美国Sun公司（Stanford University Network），在1995年推出的高级的编程语言。所谓编程语言，是 计算机的语言，人们可以使用编程语言对计算机下达命令，让计算机完成人们需要的功能。

能干什么

Java语言主要应用在互联网程序的开发领域。常见的互联网程序比如天猫、京东、物流系统、网银系统等，以及服 务器后台处理大数据的存储、查询、数据挖掘等也有很多应用。

核心优势

跨平台

所谓跨平台性，是指java语言编写的程序，一次编译后，可以在多个系统平台上运行。

实现原理：Java程序是通过java虚拟机在系统平台上运行的，只要该系统可以安装相应的java虚拟机，该系统就可以运行java程序。（注意不是能在所有的平台上运行，关键是该平台是否能安装相应的虚拟机）。

JDK/JRE/JVM

JDK

是Java程序开发工具，包含 JRE 和开发人员使用的工具。

JRE

是Java程序的运行时环境，包含 JVM 和运行时所需要的核心类库。

JVM

Java虚拟机，我们编写的Java代码，都运行在 JVM 之上。

常量

概述

常量：是指在Java程序中固定不变的数据。

分类

变量

概述：常量是固定不变的数据，那么在程序中可以变化的量称为变量。

数据类型

基本数据类型

整形

byte（1个字节）

-128~127

short（2个字节）

-2^15~2^15-1

65535

int（4个字节）

-2^31~2^31-1

+-2.1GB

long（8个字节）

-2^63~2^63-1

浮点型

float（4个字节）

1.4013E-45~3.4028E+38

double（8个字节）

4.9E-324~1.7977E+308

布尔类型

boolean

true

false

字符类型

char

0~65535

引用类型

类

的内部封装了成员变量、构造方法和成员方法

数组

数组有固定的长度，长度一旦指定，不可更改。

数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。

接口

的内部主要就是封装了方法

可以继承，可以重写，二选一，但是只能通过实现类的对象来调用。

不能创建对象，但是可以被实现（ implements ，类似于被继承）。

数据类型的转化

自动转化（隐藏转化）

小转大

long a =10;

强制数据类型转化（显示转化）

大转小

byte b =(byte) 129;//会溢出，损失精度

转换格式

数据类型变量名 = （数据类型）被转数据值；

注意点

浮点转成整数，直接取消小数点，可能造成数据损失精度。

int 强制转成 short 砍掉2个字节，可能造成数据丢失。

ASCII编码表

就是将人类的文字和一个十进制数进行对应起来组成一张表格。

运算符

算数运算符

变量前++ ：先自加在赋值 变量后++ ：先赋值在自加

赋值运算符

=、+=、-=、*=、/=、%=

比较运算符

逻辑运算符

逻辑运算符，是用来连接两个布尔类型结果的运算符，运算结果都是布尔值 true 或者 false

三目运算符

数据类型变量名 = 布尔类型表达式？结果1：结果

布尔类型表达式结果是true，三元运算符整体结果为结果1，赋值给变量。 布尔类型表达式结果是false，三元运算符整体结果为结果2，赋值给变量。

移位运算符

>>、<<、>>>

运算符的优先级

算数>比较>逻辑>赋值

方法

概述

就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。 当我们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。

方法的重载规则（背）

指在同一个类中，方法名相同，参数列表不同即可， 与修饰符和返回值类型无关。

参数列表：个数不同，数据类型不同，顺序不同

重载方法调用：JVM通过方法的参数列表，调用不同的方法。

流程控制

顺序流程

程序的流程对运行结果有直接的影响。所以，我们必须清楚每条语句的执行流程。 而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能。

判断语句

if（关系表达式）{         语句体； }

if（关系表达式）{      语句体1； }else{      语句体2； }

if (判断条件1) { 执行语句1; } else if (判断条件2) { 执行语句2; } else { 执行语句n+1; }

选择语句

switch(表达式) { case 常量值1: 语句体1; break; case 常量值2: 语句体2; break; ... default: 语句体n+1; break; }

switch(int、自动转化为int、枚举类型、字符串)

支持的有：char、byte、short、int 和 Character、Byte、Short、Integer 和 String，枚举 表达式的值不能是null，否则会在运行时抛出NullPointerException。 在case子句中也不能使用null，否则会出现编译错误。 JAVA中switch为什么不能使用long的根本原因是long转化成int会丢失精度，导致数据不准确，

循环流程

while

int i=1; while(i<=10){     输出（"123"）;     i++; }

for

break

跳出并结束语句块

continue

跳出本次循环，继续执行后面的语句

for 和 while 的小区别：

控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了， 而while循环结束还可以继续使用，如果你想继续使用，就用while， 否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。 在已知循环次数的时候使用推荐使用for，循环次数未知的时推荐使用while。

do...while

初始化表达式① do{ 循环体③ 步进表达式④ }while(布尔表达式②);

死循环

不是代码错误，是一种循环结构

也就是循环中的条件永远为true，死循环的是永不结束的循环。例如：while(true){}。

循环嵌套

是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环，就是嵌套循环。总 共的循环次数=外循环次数*内循环次数

数组

概念：数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致

数组的特点

数据类型相同的数组

长度一旦指定，不可更改。

数组的初始化

静态初始化

动态初始化

数组的长度

arr.length

每个数组都具有长度，而且是固定的

数组的遍历

就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。

OOP

概述

Java语言是面向对象的程序语言，面向对象思想是一种程序设计思想。

特点

将复杂的事情简单化，并将我们从执行者变成了指挥者。 面向对象的语言中，包含了三大基本特征，即封装、继承和多态。

三大特征

封装

内部方法外部调用，外部无需关心内部实现

继承

子类方法属性使用父类，不需要自己定义，扩展自己的个性化

多态

外部调用同一个方法，实际执行的逻辑不同。父类引用指向子类对象

内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

内部类可以直接访问外部类的成员，包括私有成员

外部类要访问内部类的成员，必须要建立内部类的对象。

匿名内部类

匿名内部类必须继承一个父类或者实现一个父接口。

接口名称对象名=new 接口名称（）{    }；

常用API

java.lang

Math

abs(double a) ：返回 double 值的绝对值。

ceil(double a) ：返回大于等于参数的最小的整数。

floor(double a) ：返回小于等于参数最大的整数。

round(double a) ：四舍五入。(float时返回int值，double时返回long值)

rint()  :  四舍五入，（.5的时候返回偶数）

sqrt(num) :  num的平方根

cbrt(x)  :  开立方

pow(a,b)  :  a的b次方

random()  :  随机去0~1的数

max(a,b)  :  取最大值

max(a,b)  :   取最大值

String

length () ：返回此字符串的长度。

concat ("string") ：将指定的字符串连接到该字符串的末尾。

charAt ( 1 ) ：返回指定索引处的 char值。

A-Z 65-90 a-z 97-122 '0'-'9' 48-57

indexOf ("a") ：返回第一次出现在该字符串的索引。

lastIndexOf（ char）：int

返回字符最后出现的下标

substring ( 1 ) ：返回一个子字符串，从 xx  开始截取字符串到字符串结尾。

substring (int  a, int b) ：返回一个子字符串，从a到b截取字符串。(含a,不含b)

toCharArray () ：将此字符串转换为新的字符数组。

trim（）：String

去首尾空格

getBytes () ：转换为新的字节数组。

replace (char oldChar、 char newChar) ：字符串替换。

Integer.valueOf(string)

字符串转为整数，如果原字符串不是数字字符串，则报错

String.valueOf（Object）

将object转化为字符串

split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。 "aa+bb+cc"--------->{"aa","bb","cc"}

System

out.print()

输出

out.printIn()

换行输出

gc()

调用垃圾收集器

exit()

System.exit(0) 程序正常退出

System.exit(1)或者说非0表示非正常退出程序

in

键盘录入

currentTimeMillis（）

格林威治时间的毫秒值

arrraycopy(src,srcPos,dest,destPos,length)

数组的复制，底层代码是C++写的，调用底层，没有返回值（native）

Object

toString()

toString方法返回该对象的字符串形式，也就是该对象的类型+@+内存地址值。

equals()

如果没有覆盖重写equals方法，那么Object类中默认进行 == 运算符的对象地址比较， 只要不是同一个对象，结果必然为false。

如果覆盖重写equals方法，则进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同

Conparable

compareTo(T)

作用一般是看两个数组是否一样

java.util

Random

//获得0~9随机数 Random r =new Random(); int rd = r.nextInt(10);

ArrayList

是大小可变的数组的实现，存储在内的数据称为元素。

.add() 添加

get()  取值

Scanner

nextDouble()

nextLine()  String类型

nextInt()    intl类型

Arrays（数组的工具类）

toString（T [] arr）

copyOf（T[]  arr,newLength）

数组的扩容，缩容

sort(T [])

升序

equals（T[],T[]）

判断两个数组是否相等

Date

yyyy-MM-dd HH:mm:ss

年月日时分秒（毫秒.SSS）

小写的hh代表12小时制，大写的HH代表24小时制

Calendar()

日历类

get(int field) ：返回给定日历字段的值。

set(int field, int value) ：将给定的日历字段设置为给定值。

add(int field, int amount)  : 添加或减去指定的时间量。

getTime() ：返回的是Date对象,并不是获取毫秒时刻

new Date() 当前系统时间

String str = df.format（date）

将日期转化为字符串

DateFormat df = new SimpleDateFormat(yyyy-MM-dd HH:mm:ss); String str= df.format(new Data() );

Calendar

该类将时间信息封装为静态成员变量,方便获取时间的属性。

Calendar为抽象类,通过静态方法创建，返回子类对象        Calendar cal = Calendar.getInstance();

get(int field) ：返回给定日历字段的值。    cal.get(Calendar.YEAR) //当前时间的年份

set(int field, int value) ：将给定的日历字段设置为给定值。

add(int field, int amount) ：给字段添加或减去指定的时间量。    cal.add(Calendar.YEAR, ‐3); // 减3年

getTime() ：返回毫秒值

Date date = df2.parse（str）

DateFormat df2 = new SimpleDateFormat(yyyy-MM-dd HH:mm:ss); Date d = df2.parse(str);

将字符串转化为日期

getTime（） 1970-01-01 00:00:00.000到时间的毫秒数

Java.text

abstract DateFormat

不能直接new（）实例，只能通过赋值多态去定义

SimpleDateFormat

DateFormat df = new SingleDateFormat("yyyy-MM-dd HH:mm:ss")

关键字

static

以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。 既然属于类，就可以不靠创建对象来调用了。

可以修饰类、方法、成员变量；  不能修饰构造方法 

static 修饰表示静态或全局，被修饰的属性和方法属于类，可以用类名.静态属性 / 方法名访问

static 修饰的代码块表示静态代码块，当 Java 虚拟机（JVM）加载类时，就会执行该代码块,只会被执行一次

static 修饰的属性，也就是类变量，是在类加载时被创建并进行初始化，只会被创建一次

static 修饰的变量可以重新赋值

static 方法中不能用 this 和 super 关键字

static 方法必须被实现，而不能是抽象的abstract

static 方法不能被重写

static关键字

从属类

静态属性使用类名.静态变量名

静态方法使用类名.静态方法

在JVM中仅初始化一次

存储于常量池

final

final 修饰类，不能被子类继承

final 修饰方法，不能被子类重写，但可以被重载

final 修饰表示常量、一旦创建不可改变

修饰变量，常量，不能被二次赋值

final 标记的成员变量必须在声明的同时赋值，或在该类的构造方法中赋值，不可以重新赋值

final :  最终的，不可改变的，可以用于修饰类、方法和变量。

面向对象

使用new关键字创建对象

JVM有一个默认的构造方法

根据需求重载构造方法

NPE

null值调用属性或者方法会出现NullPointerExption

三大基本特征

封装

概述

内部细节对外部调用透明，外部调用无需修改或者关心内部实现

访问权限修饰符

在编程规约中所有的非特殊成员变量不允许外部直接访问成员变量，必须将其私有，且提供对外公开的方法

this关键字

this代表所在类的当前对象的引用（地址值），即对象自己的引用。

指代当前对象的关键字

根据本类其他构造方法，必须写到第一行

构造方法（构造器）

没有返回值类型

类名相同

1. 如果你不提供构造方法，系统会给出无参数构造方法。 2. 如果你提供了构造方法，系统将不再提供无参数构造方法。 3. 构造方法是可以重载的，既可以定义参数，也可以不定义参数。

继承（extends）

概述

子类共性的方法或者属性直接使用父类的，而不需要自己再定义，只需扩展自己个性化的

特点

Java只支持单继承，不支持多继承。

Java支持多层继承(继承体系)。

子类和父类是一种相对的概念。

extends关键字继承父类除了构造方法以外的所有的属性和方法

子类的构造方法默认调用父类构造方法

super关键字

表父类的存储空间标识(可以理解为父亲的引用)

指代当前类的直接父类

super（）必须放到构造方法的第一行，且不能与this（）并存

子类继承父类语句的执行顺序

父类的静态代码块

子类静态代码块

父类的普通代码块

父类的构造方法

子类的普通代码块

子类的构造方法

说明：静态方法（有静态先加载静态） > 普通代码块> 方法（其他） 先加载用到的所有静态方法，然后按运行顺序加载普通代码块和方法

重写的规则

父子类中，必须要有继承的概念

相同的签名

相同的方法名+参数序列

方法的访问权限大于等于父类权限。

方法返回值类型、函数名和参数列表都要一模一样。

垃圾回收机制GC*

多态

概述

是指同一行为，具有多个不同表现形式。

赋值多态

Shape shape = new Circle();

向上转型

当父类引用指向一个子类对象时，便是向上转型。 父类类型变量名 = new 子类类型();

向下转型

父类类型向子类类型向下转换的过程，这个过程是强制的。 子类类型变量名 = (子类类型) 父类变量名;

传参多态

存在于声明方法

声明：public void a(Shape n){};            Circle circle = new Circle(); 使用：a(circle);

构成Java多态的规则

1.要有继承（直接继承）

2.要有方法的重写

3.父类的引用指向子类的对象

Object类

所有类的父类

equals（）

==和equals（）的区别

==比较的是地址

如果“==”两边是基本数据类型或者字符串常量，比较的是常量池中的数值

equals（）方法在没有重写父类方法时比较的也是地址

在重写equals（）后比较的是引用类型属性的值是否相等

在实际应用中必须重写equals（）方法

hashcode（）

调用本地操作系统的C++库哈希地址

toString（）

由完全限定名 + “@”+十六进制的哈希地址组成

子类按需求重写父类的toString（）方法

引用类型直接输出对象名，默认调用toString（）方法

Java实体类编程规约

类必须实现可序列化接口

成员变量私有化

必须提供无参的构造方法

对外提供公开的方法访问和设置成员变量

必须重写toString（），equals（），hashcode（）方法

包装类

装箱

从基本类型转换为对应的包装类对象。

拆箱

从包装类对象转换为对应的基本类型。

从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成

基本类型转换为String类

toString（）

先把基本数据类型装箱，再用对象的toString()方法

valueOf（）

+""

String类转基本类型

parseByte(String s) ：将字符串参数转换为对应的byte基本类型。

parseShort(String s) ：将字符串参数转换为对应的short基本类型。

parseInt(String s) ：将字符串参数转换为对应的int基本类型。

parseLong(String s) ：将字符串参数转换为对应的long基本类型。

parseFloat(String s) ：将字符串参数转换为对应的float基本类型。

parseDouble(String s) ：将字符串参数转换为对应的double基本类型

parseBoolean(String s) ：将字符串参数转换为对应的boolean基本类型。

抽象类

由abstract关键字修饰的类

有抽象方法的类必须定义为抽象类

抽象类不一定有抽象方法,也可以有普通方法

抽象方法不可以有方法体， 即不能有{}

抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

抽象类不能创建对象

抽象类中定义子类共有的属性

子类必须要重写父类中所有的抽象方法

作用：让子类继承

抽象方法

没有方法体的方法。

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

接口

比抽象类还抽象的抽象类 interface

在接口中定义的属性全为常量

public static final int a = 10;

接口中的方法必须全为抽象方法

类与接口的关系是实现的关系

implements

类与类之间的关系继承的关系

extends

接口与接口的关系继承

extends

如果你是。。。就必须得会。。。

定义类某些规范

与抽象类的区别

1.抽象类只能单继承，接口可以多实现

2.接口中的变量全是常量，方法全是抽象方法，抽象类可以有普通变量，方法可以有非抽象方法

3.接口存在的意义就是为了定义规范，让子类去继承

String、StringBuilder、StringBuffer

String

String是final修饰的，不可变。每次操作都会生产新的String对象

StringBuilder

经常需要改变字符串内容时优先使用StringBuilder

可变字符序列：(默认16字符空间，超过自动扩充)

append(...) ：添加任意类型数据的字符串形式

toString() ：将当前StringBuilder对象转换为String对象。

StringBuffer

多线程使用共享变量时使用StringBuffer

StringBuilder线程非安全，效率较高，StringBuffer线程安全

String和StringBuilder和StringBuffer的区别（背）

1.String 不可变长

2.StringBuilder和StringBuffer可变长

3.用StringBuilder代替StringBuffer，因为效率高

4.大量字符串操作时，用StringBuilder代替String