JAVASE总结
java是做什么?
大中型企业应用软件 服务器端开发
*1.jdk（java 开发 工具包）
jdk
jre: java运行 环境（运行 java程序的最小标准）
jvm:java虚拟机(运行或者执行 java代码的)
java类库(很多很多类 理解很多小零件)
java的开发工具(javac java等)
*2.java程序 如何执行的: 先编译 后执行。
源代码(.java源文件)-----编译(理解为检查语法问题)----.class字节码文件(0,1)-----jvm解释执行------软件结果
*3.配置 java的 环境变量:
java_home:配置的是jdk的 安装位置(jdk的家).
eclipse/tomcat/maven等这些软件 需要知道 jdk的安装位置.
C:\Program Files\Java\jdk1.8.0_91
path： 命令工具搜索路径
javac:编译工具
java:执行工具
C:\Program Files\Java\jdk1.8.0_91\bin
或者
%java_home%\bin
classpath:字节码文件搜索路径(类文件搜索路径)
.:当前位置: 在哪个位置 运行的 就去 哪个位置找字节码文件.
- 4.HelloWorld 程序 演示:
HelloWorld.java源文件 -----javac HelloWorld.java(编译这个源文件)-------HelloWorld.class---------java HelloWorld(执行)
*5.标识符
类名 变量名 函数名等。
由字母 数字 下划线 $组成的
数字不能开头.长度没有限制。
System.out.println(“a”); 固定输出a字母
System.out.println(a); 输出 a变量
System.out.println(“aaaa”); 换行
System.out.print(“aaaa”); 不换行
System.out.println(); 只换行
6.注释
编译不管 执行不管 只是让程序员来看的
起到 备注 做笔记的作用，
单行注释: 后面 只能写一行文字
//
/* /：多行注释 / 和*/之间 可以写很多行文字
/** */:文档注释 可以写多行文字 可以形成文档
- 7.关键字 53个左右
java中这个单词 已经有特殊的作用和功能了 不能写错
public:公开的
class:类
static:静态的
int:整型
…
关键字不能作为标识符.
8.变量 保存内存中 一个值的.
1)变量 声明 并且初始化 后才能使用。
2)变量的作用域（变量的使用范围）： 从声明的那一行开始 到 最近的大括号} 结束
3)变量再同一作用域内 不能重复声明
*9. java的类型
1)基本类型
2)引用对象类型(面向对象详细讲解)
java中的基本类型: 8种
byte:8位 -128 ~127
short：16位 -32768 ~32767
int ：32位 -21亿多 ~ 21多
long ：64位 -2的63次方 ~ 2的63次方 -1
float: 32位 单精度 不够精确
double:64位 双精度 精确
boolean:8位 布尔类型 值只能是 true 和false
true:对的 成立的 符合条件的
false：不对的 不成立的 不符合条件的
char:16位 [0,65535] 字符类型 值必须用 '‘引起来
任何一个字符 都有编码值（实质就是一个对应的整数）
英文字符和数字字符的编码值是连续的
特殊字符需要转义：’ " \ \t \n \r \u
Unicode:是java内存中的编码方案 内码
-
10.运算符：
1）算术运算符：-
-
- / %
a.同种类型 运算 结果还是这种类型
b.将低于int类型的类型(byte short char) 转换为int类型运算
c.当类型 不一样的时候，低类型会自动转换成高类型（自动类型转换）
byte---->short---->int---->long
float---->double
d.高类型 转换成低类型 需要 强制 转换.
long---->int---->short---->byte
double---->float
2)自增（减）运算符
- / %
-
3）比较关系运算符
= < <= == !=
4)逻辑运算符
&& & || | !- 三目运算符
6）赋值 运算符
7）移位运算符
11.什么是面向对象
将数据和功能封装到对象中,拿到对象就可以操作对象 持有的数据和功能了;
12.java是如何实现面向对象的?
java是靠类与对象实现面向对象。
类是抽象描述,描述了对象所具有的属性(变量)和功能(方法); — 不存在
对象是类的实体,创建出了类的对象,这个对象才真正持有类所描述的属性和功能; ---- 存在
类 ------ 描述
class Student{//属性
int sno;String name;
int age;
//方法
public void eat(){}
public void sleep(){
}
}
对象 ---- 实体
Student s1 = new Student();
s1.sno = 101;
s1.name = “张三”;
s1.age = 20;
s1.eat();Student s2 = new Student();
s2.sno = 102;
s2.name = “李四”;
s2.age = 22;
s2.eat(); -
-
static：
静态的
修饰方法 变量 代码块static修饰的变量叫静态变量，也称为类变量
类变量特点：
1.可以通过类名直接调用
2.类变量可以被类的所有对象共享class A{ int m;//成员变量 static int n;//静态变量---类变量 } A a1=new A(); A a2=new A();static修饰的方法叫静态方法，也称为类方法
类方法特点：
可以通过类名直接调用
静态方法中不可以调用非静态的成员
一般在工具类中将工具类中的工具方法都声明为静态方法static修饰的代码块叫静态代码块
静态代码块特点：
静态代码块中的代码在类加载的时候执行
14.单例模式:
单例：单个的实例 单个的对象
简单来说，就是一个类在整个内存中只有一个这个类的对象
1.构造方法私有化
2.在本类中创建一个私有的本类对象（static修饰的）
3.提供一个可以让外部类通过类名直接调用的方法（static方法），方法将本类对象提供给外部类
饿汉式：
public class Single{
private static Single s=new Single();
private Single(){}
public static Single getInstance(){
return s;
}
}
懒汉式：
public class Single{
private static Single s;
private Single(){}
public static Single getInstance(){
if(s==null){
s=new Single();
}
return s;
}
}
- 代码块：
{}括起来的代码
构造代码块—初始化代码块
直接定义在类中的代码块
class A{
{
构造代码块
}
}
构造代码块在每次创建对象之前执行
构造代码块在构造方法之前执行
静态代码块
直接定义在类中的用static修饰代码块
class A{
static{
静态代码块
}
}
静态代码块在类加载的时候执行
局部代码块
定义在方法中的代码块
class A{
public void fun(){
int m;
{
int n;
}
}
}
局部代码块有什么作用？
一般情况下用局部代码块来缩短变量的声明周期
16.面向对象的特点?
封装 继承 多态
封装:隐藏实现细节,对外提供公共的访问方式;
封装的常见操作:
1)私有化成员属性然后提供public的get/set方法去间接的取值和赋值
private int age;
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
2)方法:
public int add(int a,int b){
return a+b;
}
方法已经将功能封装好了,我们只需要知道方法的名字 参数类型 返回值类型 作用;
3)对象:
对象就封装了数据和功能;
继承:
多个类中存在共性内容时,将共性内容抽取出来定义在父类中,然后子类通过继承父类就
可以继承到父类中定义的共性内容了;
属性一般都是使用继承父类的,方法是如果子类没有特殊操作也是使用继承父类的,如果
子类中有特定操作就去覆盖继承父类的方法;
class A{
int num = 100;
public void setNum(int num){
this.num = num;
}
public void showNum(){
sop(num);
}
}
class B extends A{
}
class C extends A{
int num = 200;//子类自己的属性num
//覆盖了
public void showNum(){
num+=100;
sop(num);
}
}
C c = new C();
c.setNum(500);//将继承自父类的num属性值改为了500
多态:
对象的多种形态;接口引用指向实现类对象或父类引用指向子类对象;
class A{
public void show(){
}
}
class B extends A{
//重写
public void show(){
sop(“BBBBB”)
}
}
class C extends A{
//重写
public void show(){
sop(“CCCCC”);
}
}
B b = new B();//自己本身类型
A a = new B();//多态形式
//A a = new B();
A a = new C();
a.show();
重载:
1)同一个类中;
2)区分同名的多个方法的;
方法名相同,参数列表不同,与返回值类型无关(不考虑返回值)的多个方法就是重载的方法;
这些同名的重载的多个方法的区分是通过方法的参数列表区分的,就是参数个数
参数类型 参数顺序不同来区分的;
public void a(int a){
}
public void a(double d){
}
public void a(int a,int b){
}
public void a(int a,double b){
}
public void a(double b,int a){
}
重写(覆盖):
1)子父类之间;
2)区分子类中和父类中同名的方法;
在子类中出现了和父类中方法名 参数列表 返回值类型都相同的方法,就是子类覆盖
父类的方法;那么在调用时,它调用的是子类覆盖父类的同名方法;
w:for(int i = 1;i<=5;i++){
for(int j = 1;j<+3;j++){
if(i == 2){
break w;
}
}
}
内部类：
成员内部类
定义在类中的内部类
成员内部类对象依赖于外部类对象
对象：
外部类类名.内部类类名 对象引用=new 外部类().new 内部类();
静态内部类
定义在类中使用static修饰的内部类
对象：
外部类类名.内部类类名 对象引用=new 外部类类名.内部类();
静态内部类不能访问外部类的非静态成员
局部内部类
定义在方法中的内部类
局部类的对象只能在它定义的方法中创建
匿名内部类
定义在方法中没有名字的内部类
创建类的同时创建了类的对象
匿名内部类依赖于一个父类或者是一个接口
继承父类的方式
new 父类(){
};
实现接口的方式
new 接口(){
};
匿名内类是否可以实现多个接口？
不可以
Inter1{}
Inter2{}
Inter3 extends Inter1,Inter2{}
new Inter3(){}
包 package
就是文件夹，主要就是用来管理我们的类的
1.方便我们管理类
2.方便起名
同一个包下不能有同名的类，但是不同的包下可以
创建包：
src---new -----package
包名：一般全小写
类中package
package com.ytc1;
import com.ytc.A;
public class B {}
如果想要访问不同包下的类，有两种方式
//1.写类的全限命名 包名+类名
/*com.ytc.A a=new com.ytc.A();
a.methodA();*/
//2.将类导入到当前类中 import 包名+类名
import 包名+类名；
如果我们需要导入一个包中的多个类：
import com.ytc.*;
导入com.ytc包下的所有类
java中提供常用包：
java.lang java的核心包
这个包中的类不需要使用import导入，可以直接使用
java.util java的工具类包
java.io io流的包
java.sql 数据库相关的包
异常
异常：程序运行过程中的非正常情况，和预期结果不一致的情况
异常的分类：
Throwable:
Throwable 类是 Java 语言中所有错误或异常的超类。
两个直接的子类：
Error 和 Exception，通常用于指示发生了异常情况
Error:
Error 是 Throwable 的子类，用于指示合理的应用程序不应该试图捕获的严重问题。
错误，是程序运行中出现的比较严重的，不可恢复的错误，是不需要使用异常处理去解决
内存溢出错误
Exception:
Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。
异常，可以通过程序去处理或者是可以通过程序去避免的异常情况
处理异常：Exception
分为两类：
检查时异常—编译期异常：可能在编译期抛出的异常
检查时异常必须要处理的异常
非检查时异常—运行期异常:可能在运行期抛出的异常
RuntimeException是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。
对于可能抛出的检查时异常，代码必须要将异常进行处理，不处理编译出错。
对于可能出现的非检查时异常，代码不是必须要进行处理
对于非检查时异常，一般情况下都是因为我们写的代码有问题，我们应该尽量的去完善我们的代码
异常处理主要用来处理检查时异常
处理异常：
主要有两种方式
1.使用try..catch...获取异常并处理异常
try{
可能会出现异常的代码
}catch(XXXException e){
对可能出现的异常的处理过程
}
将可能出现异常的代码放到try块中，代码一旦出现异常，中止执行，try块会将出现的异常封装成一个异常对象，
然后判断异常对象是否数据catch块中处理的异常的类型，如果属于他的类型，就将这个异常对象交给当前的catch块去处理，如果不属于他的类型，交给下个catch块，。。。。。如果没有找到可以处理这个异常的catch块，异常没有被处理，代码终止执行。如果异常有catch块处理，处理完后，代码就可以继续往下执行
一个try后面可以跟多个catch块
try{
可能出现异常的代码
}catch(AAAException e){
}catch(BBBException e){
}catch(CCCException e){
}
。。。。
一个try后面的多个catch,catch中的类型应该是从小到大
try块不可以单独出现
try可以只跟catch,也可以只跟finally,还可以try..catch...finally
try...catch..catch..
try...finally...
try...catch...finally..
finally:
try{
可能出现异常的代码
}catch(xxxException e){
处理异常的代码
}finally{
始终会执行的代码
不管有没有抛出异常，也不管抛出的异常有没有被处理掉，都会去执行的代码
}
catch(XXXException e){
e.printStackTrace();//打印异常的堆栈信息
//打印一般只会在开发阶段使用，在项目正式发布时一般是将异常信息写到日志文件中
}
try中可以抛出异常
2.使用throws抛出可能出现的异常
当程序中可能出现异常时，如果当前代码有处理异常的能力，就在当前方法中使用try...catch将异常处理掉
如果当前方法没有处理异常的能力，可以使用throws将异常抛给上层代码
throws用在方法声明时，声明可能会抛出的异常
可以声明可能抛出的多个异常，多个异常可以使用逗号进行分隔
throw和throws区别
throws用在方法声明时，声明方法中可能抛出的异常
throw用在方法中。手动的抛出一个异常对象
一个方法如果有throws，不一定有异常
throw,一定有异常抛出
throw:
用在方法中，手动的抛出一个异常对象
常见的异常：
Exception:所有异常的超类
RuntimeException：运行时异常
ArithmeticException：当出现异常的运算条件时，抛出此异常。例如，一个整数“除以零”时，抛出此类的一个实例。
NullPoniterException:空指针异常，对null去调用属性和方法 null
当应用程序试图在需要对象的地方使用 null 时，抛出该异常。这种情况包括：
调用 null 对象的实例方法。
访问或修改 null 对象的字段。
将 null 作为一个数组，获得其长度。
将 null 作为一个数组，访问或修改其时间片。
将 null 作为 Throwable 值抛出。
应用程序应该抛出该类的实例，指示其他对 null 对象的非法使用。
ArrayIndexOutOfBoundsException:数组下标越界异常
用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引。
NumberFormatException 字符串到数字格式的非法转换
"123" "123..."
IOException I/O异常的根类
FileNotFoundException 不能找到文件
IllegalAccessException 对类的访问被拒绝
ClassNotFoundException 不能加载请求的类
NoSuchMethodException 请求的方法不存在
SecurityException 试图违反安全性
InterruptedException 线程中断
自定义异常：
1.创建自定义异常类继承Exception
public class MyException extends Exception {//检查时异常
public MyException(){
}
public MyException(String msg){
//调用父类的带有参数的构造方法
super(msg);
}
}
2.声明什么时候抛出自定义异常
if(a<=0){
//抛出正自定异常对象
throw new MyException("参数为负数");
}else{
System.out.println(a);
}
3.自定义异常的处理和系统定义的异常一致的
try...catch...
throws抛出
获取begin–end的随机整数：
(int)(Math.random()*(end-begin+1))+begin
API的知识点:
java中给我们提供的类
我们主要学习常用类的使用
API：API(Application Programming Interface)
Object类
Scanner类—了解
String类
StringBuffer类/StringBuilder类
Arrays类
基本类型包装类(Integer,Character)
正则表达式(Pattern,Matcher)
Math类/Random类/System类
System.out.println()
BigInteger类/BigDecimal类—了解
Date类/DateFormat类/Calendar类
Object:
类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。
构造方法：
Object()
创建子类对象时，默认调用父类无参的构造方法
成员方法：
String toString() ******8
返回该对象的字符串表示。
常，toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。
Object类的toString方法返回一个字符串，对象的类名+@+对象的哈希码的十六进制表示
return getClass().getName() + "@" + Integer.toHexString(hashCode());
一般重写一个类的toString方法都是返回对象的属性值组成的字符串
Class<?> getClass()
返回此 Object 的运行时类。
java中想要使用类，首先要将类加载到内存并生成Class对象（字节码文件对象）
Student stu =new Student();
stu.getClass()---获取Student类的对象
Class:
Class 类的实例表示正在运行的 Java 应用程序中的类和接口
getName()以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称。
int hashCode() *******
返回该对象的哈希码值。
hashCode 的常规协定是：
1.在 Java 应用程序执行期间，在对同一对象多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是将对象进行 equals 比较时所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。
2.如果根据 equals(Object) 方法，两个对象是相等的，那么对这两个对象中的每个对象调用 hashCode 方法都必须生成相同的整数结果。
3.如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么对这两个对象中的任一对象上调用 hashCode 方法不 要求一定生成不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同整数结果可以提高哈希表的性能。
实际上，由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。（这一般是通过将该对象的内部地址转换成一个整数来实现的，但是 JavaTM 编程语言不需要这种实现技巧。）
如果两个对象相等，他们的hashCode值一定相等
如果两个对象不相等，他们的hashCode值不一定不相等
y=x^2-1
boolean equals(Object obj) ********
指示其他某个对象是否与此对象“相等”。
Object 类的 equals 方法；即，对于任何非空引用值 x 和 y，当且仅当 x 和 y 引用同一个对象时，此方法才返回 true（x == y 具有值 true）。
public boolean equals(Object obj) {
return (this == obj);
}
Object中的equals方法是和==是等价的
但是我们在子类中，可以重写equals方法
注意：当此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。
protected void finalize()
当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
强制的运行垃圾回收器：
System.gc();
调用 System.gc() 实际上等效于调用：
Runtime.getRuntime().gc()
protected Object clone()
创建并返回此对象的一个副本。
如果想要克隆一个类的对象，类需要实现接口：Cloneable
此类实现了 Cloneable 接口，以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。
Cloneable接口中没有任何的方法，只是标识一个类可不可以克隆对象
实现了接口就可以
没有实现接口就不可以
对于这样的接口称为标识接口
final finally finalize
Scanner—了解
构造方法：
Scanner(InputStream source)
Scanner sc=new Scanner(System.in);
成员方法：
hasNext() ：判断有没有下一个录入的内容，有就返回true ,没有返回false
nextXXX():
XXX—数据类型
nextLine():获取一行字符串
nextInt():
nextDouble()
3
asd
-
String和StringBuffer及StringBuilder相关的知识点:
1)创建String对象:
String s1 = “abc”;
String s2 = new String(“abc”);
两者的区别是什么?String s1 = “abc”;
创建的是一个对象,引用变量直接指向的是字符串常量池中的字符串对象;
构造方法：
public String()：创建一个空的字符串
public String(byte[] bytes)： 通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
String(byte[] bytes, Charset charset) ：通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。
字符串—字节 编码
字节------字符串 解码
public String(byte[] bytes,int offset,int length)：通过byte数组的一部分创建字符串
offset：起始位置
length:长度
public String(char[] value)
public String(char[] value,int offset,int count)
public String(String original)
成员方法：
判断方法：
boolean equals(Object obj)：重写的Object类的方 法，判断当前字符串和指定字符串的内容是否 boolean equalsIgnoreCase(String str)：判断当前字符串和指定字符串的内容是否一致，忽略大小写
boolean contains(String str)：判断当前字符串中是否包含指定子串str
boolean startsWith(String str):判断当前字符串是否以指定的子串作为开始
boolean endsWith(String str)：判断当前字符串是否以指定的子串作为结尾
boolean isEmpty()：判断当前字符串是否为空。判断是否为空字符串，字符串中没有一个字符
null
“”
" "
获取方法：
int length()：获取字符串偿付
char charAt(int index)：获取指定下标位置的字符
int indexOf(int ch)：获取指定字符在字符串中第一次出现的下标
hello
int indexOf(String str):获取指定子串在字符串中第一次出现的下标
如果没有这个串，返回-1
int indexOf(int ch,int fromIndex)：从指定位置开始查找，指定字符第一次出现的下标
int indexOf(String str,int fromIndex)从指定位置开始查找，指定字符串第一次出现的下标
String substring(int start)：截取从下标start开始直到最后的子串
String substring(int start,int end)：截取下标start—end之间的子串 [start,end)String s2 = new String(“abc”);
创建的是两个对象,引用变量直接指向的是堆内存中的String对象,然后堆内存
中的String对象又指向了字符串常量池中的字符串对象;
2)字符串对象一旦创建是不可变的;(指的是使用定义变量的形式创建的String对象,
且是String的引用变量所引用的字符串常量池中的字符串对象是不可变的)
为什么字符串对象一旦创建是不可变的?
当使用定义变量的形式创建String对象时,首先会从字符串常量池中找是否存在
该字符串对象,如果存在则直接引用,如果不存在则新建然后再引用;所说字符串
对象一旦创建不可变,是指字符串常量池中的字符串对象一旦创建不可变的,改变
String类型的引用变量的值只是将String类型变量的指向给改变了,而字符串常量
池中的字符串对象是没有改变的;
3)在实际开发中操作字符串使用String和StringBuffer的区别:
当经常性的需要改变字符串内容时,使用String不太合适了,而是建议使用StringBuffer;
使用String来操作字符串,当不断的改变字符串内容时,其实就是在字符串常量池中不断
的创建字符串对象;而使用StringBuffer,始终操作的是同一个StringBuffer对象,对字符
串内容的不断改变,只是对StringBuffer容器的内容在不断改变,而StringBuffer对象地
址并没有发生改变;
4)StringBuffer是线程安全的,StringBuilder是线程不安全的;
Arrays:
java提供的对数组操作的工具类
Arrays类中的方法都是静态方法，可以通过类名直接调用
成员方法
public static String toString(int[] a)：可以返回任意类型数组的字符串表示
public static void sort(int[] a)：对数组按照升序排序
public static int binarySearch(int[] a,int key)：使用二分查找在指定数组中查找指定内容
1.冒泡排序
2.选择排序
3.二分查找
4.将数组格式化为字符串
八种基本数据类型的包装类：
将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
一般情况下使用包装类实现基本数据类型和字符串之间的转换
包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
Integer:
字段：
MIN_VALUE:int类型的最小值
MAX_VALUE ：int类型的最大值
构造方法：
Integer(int value)
构造一个新分配的 Integer 对象，它表示指定的 int 值。
Integer(String s)
构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
成员方法：
static int parseInt(String s) 将字符串参数作为有符号的十进制整数进行解析。
public int intValue():将Integer转换为int
从jdk1.5开始可以自动拆箱
public static String toString(int i)：将int转换为String
public static Integer valueOf(int i):将int转换为integer
public static Integer valueOf(String s):将string转换为Integer
常用的基本进制转换
public static String toBinaryString(int i)：获取二进制的字符串
public static String toOctalString(int i)：获取八进制的字符串
public static String toHexString(int i):获取十六进制的字符串
十进制到其他进制
public static String toString(int i,int radix)：i要转换的10进制数 radix：要转换成几进制
其他进制到十进制
public static int parseInt(String s,int radix)：s:要转换的其他进制的字符串 radix:指名前面的字符串是几进制的字符串
int和String之间的转换：*******
int转换为String
int n=10;
1.将int变量拼接一个空字符串
String s=n+"";
2.使用String类中静态方法valueOf
String s=String.valueOf(n);
3.使用Integer类中的静态方法 toString(int i)
String s=Integer.toString(n)
String转换为int:
String s="123";
使用Interger类中的静态方法 parseInt(String s)
int n=Integer.parseInt(s);
double和String之间的转换：*******
double转换为String
double n=10;
1.将double变量拼接一个空字符串
String s=n+"";
2.使用String类中静态方法valueOf
String s=String.valueOf(n);
3.使用Double类中的静态方法 toString(int i)
String s=Double.toString(n)
String转换为double:
String s="123";
使用Double类中的静态方法 parseDouble(String s)
double n=Integer.parseDouble(s);
自动装箱和自动拆箱：
从jdk1.5开始，可以
Integer in=123;//自动装箱
将基本数据类型的值直接赋值给引用类型变量
int i=in;//自动拆箱
Character:
Character 类在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段。
此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然。
构造方法：
Character(char value)
构造一个新分配的 Character 对象，用以表示指定的 char 值。
成员方法：
public static boolean isUpperCase(char ch)：判断一个字符是否是大写字母
public static boolean isLowerCase(char ch)：判断一个字符是否是小写
public static boolean isDigit(char ch)：判断一个字符是否是数字
public static char toUpperCase(char ch)：将字符转换为大写
public static char toLowerCase(char ch):将指定字符转换为小写
Math:
Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
Math类是final修饰的类，不能被继承
Math类中所有的方法都是静态方法，可以通过类名直接调用
两个静态常量：
public static final double E
比任何其他值都更接近 e（即自然对数的底数）的 double 值。
public static final double PI
比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值
成员方法：
public static double random()：获取0-1之间的随机数[0,1)
获取begin--end之间的随机整数
(int)(Math.random()*(end-begin+1))+begin
public static int abs(int a):求绝对值
public static double ceil(double a)：向上取整 45.0001----46.0
public static double floor(double a)：向下取整 45.9999999----45.0
public static int round(float a) ：四舍五入取整
public static int max(int a,int b) :获取两个数的最大值
public static int mix(int a,int b) ：获取两个数的最小值
public static double pow(double a,double b):获取a的b次方
public static double sqrt(double a)：获取a的平方根
Random：
此类的实例用于生成伪随机数流。
如果用相同的种子创建两个 Random 实例，则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。
构造方法：
Random()
创建一个新的随机数生成器。
Random(long seed)
使用单个 long 种子创建一个新的随机数生成器。
成员方法：
nextXXX():获取指定类型的随机数
nextInt():随机获取一个int类型的数 范围就是int类型的范围
nextInt(int n):获取0--n之间的随机整数 包括0，不包括n
获取begin--end之间的随机整数
System:
System 类包含一些有用的类字段和方法。它不能被实例化。
在 System 类提供的设施中，有标准输入、标准输出和错误输出流；对外部定义的属性和环境变量的访问；加载文件和库的方法；还有快速复制数组的一部分的实用方法。
字段：
in:标准输入流
out:标准输出流
err:标准错误输出流
方法：
public static void gc()：运行垃圾回收器。
Runtime.getRuntime().gc()
public static void exit(int status)：
终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非 0 的状态码表示异常终止。
public static long currentTimeMillis()：获取当前系统时间的毫秒值
当前时间与协调世界时 1970 年 1 月 1 日午夜之间的时间差（以毫秒为单位测量）。
1s=1000ms
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
复制数组
src:原数组
srcPos:原数组中的位置
dest：目标数组
destPos:目标数组中的位置
length:要复制的元素的个数
从src数组中向dest数组中复制元素，从原数组的下标为srcPos的位置开始取，去length个元素，将这个length个元素方法哦目标数组中，放的时候是从下标为destPos这个位置开始放
int[] a={1,2,3,4,5,6,7};
int[] b={11,12,13,14,15,16,17};
System.arraycopy(a, 2, b, 3, 4);
System.out.println("a:"+Arrays.toString(a));//[1, 2, 3, 4, 5, 6, 7]
System.out.println("b:"+Arrays.toString(b));//[11, 12, 13, 3, 4, 5, 6]
//从数组a向数组b中赋值元素，从数组a下标2的位置开始取4个元素赋值到数组b中，放到数组b中时，是从下标为3的位置开始放
BigInteger—了解
可以让超过Integer范围内的数据进行运算
不可变的任意精度的整数。所有操作中，都以二进制补码形式表示 BigInteger（如 Java 的基本整数类型）。BigInteger 提供所有 Java 的基本整数操作符的对应物，并提供 java.lang.Math 的所有相关方法。另外，BigInteger 还提供以下运算：模算术、GCD 计算、质数测试、素数生成、位操作以及一些其他操作。
提供了对于大整型数据的数学运算方法
+ - * / %---提供了响应的方法
+
构造方法：
BigInteger(String val)
将 BigInteger 的十进制字符串表示形式转换为 BigInteger。
方法：
public BigInteger add(BigInteger val)：加法 +
public BigInteger subtract(BigInteger val):减法 -
public BigInteger multiply(BigInteger val)：乘 *
public BigInteger divide(BigInteger val)：除 /
public BigInteger mod(BigInteger m)：求余 %
public BigInteger[] divideAndRemainder(BigInteger val):获取商和余数组成的数组
public BigInteger abs()
public BigInteger pow(int exponent)
正则表达式：
正则：正常的规则
描述正常规则的一个字符串
控制台录入一个qq号，要求长度在9--15之间，只能包含数字，而且第一个数字不能是0
正则表达式的构造摘要
构造 匹配
字符
x 字符 x a
\\ 反斜线字符
\t 制表符 ('\u0009')
\n 新行（换行）符 ('\u000A')
\r 回车符 ('\u000D')
\f 换页符 ('\u000C')
字符类
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]] d、e 或 f（交集）
[a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去）
[0-9]
预定义字符类
. 任何字符（与行结束符可能匹配也可能不匹配）
\d 数字：[0-9]
\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]
边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界
\B 非单词边界
\A 输入的开头
\G 上一个匹配的结尾
\Z 输入的结尾，仅用于最后的结束符（如果有的话）
\z 输入的结尾
Greedy 数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次
如果没有数量词，代表就是1次
Logical 运算符
XY X 后跟 Y
X|Y X 或 Y
(X) X，作为捕获组
File和IO流：
java.io包下的内容
File：
java.io.File
文件和目录路径名的抽象表示形式。
java.io包下代表平台无关的文件和目录。也就是说如果希望在程序中操作文件和目录都可以通过File类来完成。
File可以新建、删除、和重命名文件和目录。但File不能访问文件本身，如果需要访问文件内容，则需要 I/O
File类的实例表示一个文档或者目录
构造一个File实例并不是创建这个目录或文件，而是该路径的一个抽象，它可能真实存在也可能不存在
构造方法：
File(File parent, String child) ：就是根据父文件对象和当前文件路径创建文件对象
可以简单理解为根据文件所在的文件夹以及文件的路径名创建File对象
根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
File(String pathname) ：使用文件的路径创建File对象
通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
File(String parent, String child) ：使用父目录的路径和当前文件路径名创建File对象
根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
文件路径的写法：
不同的操作系统对文件路径的设定各有不同
Windows
“C:\\Workspace\\CH10\\”
Linux
“/home/workspace/ch10”
成员方法：
boolean exists()：测试此抽象路径名表示的文件或目录是否存在。
boolean isDirectory() 测试此抽象路径名表示的文件是否是一个目录。
boolean isFile() 测试此抽象路径名表示的文件是否是一个标准文件。
String getName() 返回由此抽象路径名表示的文件或目录的名称
boolean canRead() 测试应用程序是否可以读取此抽象路径名表示的文件。
boolean canWrite() 测试应用程序是否可以修改此抽象路径名表示的文件。
boolean delete() 删除此抽象路径名表示的文件或目录。
String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。
String getPath() 将此抽象路径名转换为一个路径名字符串。
boolean createNewFile() 当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
boolean mkdir() 创建此抽象路径名指定的目录。
如果当前目录所需要的父目录不存在，不能创建
boolean mkdirs() 创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。
如果当前目录所需要的父目录不存在，先创建父目录在创建当前目录
String[] list() 返回当前目录下的所有的文件名和目录名组成的数组
返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录
File[] listFiles() ：返回当前目录下所有的文件对象
返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。
获取一个文件夹以及子文件夹中的所有的文件的文件名
E:\\113\\javaSE0830
1.使用listFiles()获取当前文件夹下的所有文件
2.遍历数组获取每个文件的文件名
3.如果文件是文件夹，就对获取到的这个文件夹做第一步的操作
使用递归
创建一个方法，获取一个文件夹中所有的文件的名称的方法
getNames(File file){
1.使用listFiles方法获取目录下的所有文件对象
2.判断文件对象是文件还是目录
a.如果是文件，就直接输出文件名
b.如果是目录，先输出目录名，然后调用getNames方法获取这个目录下的所有文件的文件名
}
IO流：
输入输出流
I：input 输入流
O：output 输出流
输入输出相对于程序来说
将数据从磁盘文件读取到程序中，数据相对于程序来说，是入，使用输入流
将数据从程序写到磁盘文件中，数据相对于程序来说，是出，使用输出流
字节流
单位是字节
如果读取的是音频，视频等原始流文件，使用字节流。
InputStream:字节输入流
此抽象类是表示字节输入流的所有类的超类。
子类：
FileInputStream 文件字节输入流
FileInputStream 从文件系统中的某个文件中获得输入字节。哪些文件可用取决于主机环境。
FileInputStream 用于读取诸如图像数据之类的原始字节流。要读取字符流，请考虑使用 FileReader。
构造方法：
FileInputStream(File file) ：通过指定输入文件对象获取输入流对象
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
FileInputStream(String name) ：通过指定输入文件的路径获取输入流对象
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。
成员方法：
int read() 从此输入流中读取一个数据字节。
void close() 关闭此文件输入流并释放与此流有关的所有系统资源。
OutputStream：字节输出流
抽象类
子类：FileOutputStream:文件字节输出流
构造方法：
FileOutputStream(String path):通过指定输出到的文件的路径创建输出流对象
FileOutputStream(String path，boolean append)
FileOutputStream(File file):通过指定输出到的文件的对象创建输出流对象
FileOutputStream(File file,boolean append)
append:指名是否将内容追加到原有内容的后面
true:追加
fasle:覆盖文件中原有内容
成员方法：
向输出流中写数据
write(int n):向输出流中写入一个字节
write(byte[] b):将字节数组中的所有内容写到输出流中
write(byte[] b,int off,int len):从数组b的下标为off的位置开始，获取len个元素，写到输出流中
关闭流的方法
close()
总结：
使用字节输出流向文件中写内容
1.创建字节输出流对象
OutputStream out=new FileOutputStream("要导出的文件的路径或者是文件对象"，指名是否追加到原有内容的后面);
2.使用write方法向输出流中写内容
write(int n)
write(byte[] b)
write(byte[] b,int off,int len)***********
3.关闭输出流
out.close();
文件复制：
1.创建输入流对象和输出流对象
InputStream in=new FileInputStream("...");
OutputStream out=new FileOutputStream("...");
2.读取输入流中的内容，并将读到的内容写到输出流中
byte[] b=new byte[1024];
int len;
while((len=in.read(b))!=-1){
out.write(b,0,len);
}
3.关闭流
out.close();
in.close();
字符流
Reader:
所有的字符输入流的超类。抽象类
子类：
FileReader:文件字符输入流
主要用来操作字符文件的
构造方法：
FileReader(File file):通过指定要输入的文件的对象创建输入流对象
FileReader(String path)：通过指定要输入的文件的路径创建输入流对象
成员方法：
int read():从输入流中读取一个字符。
如果已经到达文件末尾，返回-1
int read(char[] c):最多读取c.length个字符到数组c中
返回值是实际读取的字符的个数
如果已经到达文件末尾，返回-1
int read(char[] c,int off,int len):
最多读取len个字符存到数组c中，放的时候是从下标为off的位置开始放
close():关闭流的方法
Writer:
所有的字符输出流的超类.抽象类
子类：
FileWrite:文件字符输出流
转换流：
将字节流和字符流进行转换的流
InputStreamReader:
继承Reader
将字节输入流转换为字符输入流
InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。
构造方法：
InputStreamReader(InputStream in) ：创建一个使用默认字符集的 InputStreamReader
InputStreamReader(InputStream in, String charsetName)：创建使用指定字符集的 InputStreamReader。
成员方法：
read():读取一个字符
read(char[] c)
read(char[] c,int off,int len)
close()
String getEncoding() 返回此流使用的字符编码的名称。
OutputStreamWriter
继承Writer类
OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。
通过字节输出流对象得到字符输出流对象
构造方法：
OutputStreamWriter(OutputStream out) 创建使用默认字符编码的 OutputStreamWriter。
OutputStreamWriter(OutputStream out, String charsetName) 创建使用指定字符集的 OutputStreamWriter。
成员方法：
write(int c):向输出流中写入一个字符
write(char[] c):将输出c中的所有字符写到输出流中
write(char[] c,int off,int len):将数组的一部分写到输出流
从下标为off的位置开始取len个元素写到输出流
write(String s):将整个字符串写到输出流
write(String s,int off,int len):将字符串的一部分写到输出流
close():关闭流的方法
代码上：
通过字节输出流获取了字符输出流对象
实现上：
我们写的内容直接写到字符输出流中，最终和文件交互的是字节输出流，所以会首先将字符输出流中的内容转换为字节输出流再更新到文件中
缓冲流：
缓冲区
缓冲字节流
BufferedInputStream
创建 BufferedInputStream 时，会创建一个内部缓冲区数组。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。
默认的缓冲区大小是8192
构造方法：
BufferedInputStream(InputStream in)
创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
BufferedInputStream(InputStream in, int size) size:设置缓冲区大小
创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
成员方法：
read()：读取一个字节
read(byte[] b)
read(byte[] b,int off,int len)
close()
BufferedOutputStream
构造方法：
BufferedOutputStream(OutputStream out)
创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
BufferedOutputStream(OutputStream out, int size)
创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。
成员方法：
write()...
void flush() 刷新此缓冲的输出流。
将缓冲区中的内容刷出到文件中
close():关闭流
使用缓冲输出流写内容的时候，内容是写到缓冲区，只有将缓冲区的内容刷出才会真正的将内容写到文件
刷出缓冲区：
自动刷出：当关闭流的时候会自动的将缓冲区内容输出
手动刷出：调用flush()方法刷出
缓冲字符流
BufferedReader
从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。
构造方法：
BufferedReader(Reader in)
创建一个使用默认大小输入缓冲区的缓冲字符输入流。
BufferedReader(Reader in, int sz)
创建一个使用指定大小输入缓冲区的缓冲字符输入流。
成员方法：
read():读取一个字符
read(char[] c)
read(char[] c,int off,int len)
String readLine() 读取一个文本行。******
通过下列字符之一即可认为某行已终止：换行 ('\n')、回车 ('\r') 或回车后直接跟着换行
返回：
包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
close():关闭流
BufferedWriter
将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。
该类提供了 newLine() 方法，它使用平台自己的行分隔符概念，此概念由系统属性 line.separator 定义。并非所有平台都使用新行符 ('\n') 来终止各行。因此调用此方法来终止每个输出行要优于直接写入新行符。
构造方法：
BufferedWriter(Writer out)
创建一个使用默认大小输出缓冲区的缓冲字符输出流。
BufferedWriter(Writer out, int sz)
创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
成员方法：
write(int c):向输出流中写入一个字符
write(char[] c):将输出c中的所有字符写到输出流中
write(char[] c,int off,int len):将数组的一部分写到输出流
从下标为off的位置开始取len个元素写到输出流
write(String s):将整个字符串写到输出流
write(String s,int off,int len):将字符串的一部分写到输出流
newLine() 写入一个行分隔符。
flush() 刷新该流的缓冲。
PrintWriter
向文本输出流打印对象的格式化表示形式。此类实现在 PrintStream 中的所有 print 方法。它不包含用于写入原始字节的方法，对于这些字节，程序应该使用未编码的字节流进行写入。
构造方法：
PrintWriter(File file)
使用指定文件创建不具有自动行刷新的新 PrintWriter。
PrintWriter(File file, String csn)
创建具有指定文件和字符集且不带自动刷行新的新 PrintWriter。
PrintWriter(OutputStream out)
根据现有的 OutputStream 创建不带自动行刷新的新 PrintWriter。
PrintWriter(OutputStream out, boolean autoFlush)
通过现有的 OutputStream 创建新的 PrintWriter。
PrintWriter(String fileName)
创建具有指定文件名称且不带自动行刷新的新 PrintWriter。
PrintWriter(String fileName, String csn)
创建具有指定文件名称和字符集且不带自动行刷新的新 PrintWriter。
PrintWriter(Writer out)
创建不带自动行刷新的新 PrintWriter。
PrintWriter(Writer out, boolean autoFlush)
创建新 PrintWriter。
成员方法：
print(Object o):打印指定内容，可以打印任意的数据类型，重载了多个方法
print(int i)
println(XXX x) 打印指定内容值，然后终止该行
打印的内容可以是任意的数据类型
close()
关闭该流并释放与之关联的所有系统资源。
void flush()
刷新该流的缓冲
对象流：
实现对对象的读写
ObjectOutputStream:
ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。可以使用 ObjectInputStream 读取（重构）对象。通过在流中使用文件可以实现对象的持久存储。
只能将支持 java.io.Serializable 接口的对象写入流中。
构造方法：
ObjectOutputStream(OutputStream out)
创建写入指定 OutputStream 的 ObjectOutputStream。
成员方法：
writeXXXX():将任意的的数据写到输出流
writeInt()
writeDouble()
writeObject()
ObjectInputStream:
ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。
构造方法：
ObjectInputStream(InputStream in)
创建从指定 InputStream 读取的 ObjectInputStream。
成员数据：
readXXX():读取任意数据类型的数据
readInt
readDouble
readObject
集合:
Collection接口：
Set和List的父接口
Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。
一些 collection 允许有重复的元素，而另一些则不允许。
一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。
Collection接口中的方法：
boolean add(E e)
确保此 collection 包含指定的元素（可选操作）。
boolean addAll(Collection<? extends E> c)
将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
void clear()
移除此 collection 中的所有元素（可选操作）。
boolean contains(Object o)
如果此 collection 包含指定的元素，则返回 true。
boolean containsAll(Collection<?> c)
如果此 collection 包含指定 collection 中的所有元素，则返回 true。
boolean equals(Object o)
比较此 collection 与指定对象是否相等。
int hashCode()
返回此 collection 的哈希码值。
boolean isEmpty()
如果此 collection 不包含元素，则返回 true。
Iterator<E> iterator()
返回在此 collection 的元素上进行迭代的迭代器。
boolean remove(Object o)
从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
boolean removeAll(Collection<?> c)
移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
boolean retainAll(Collection<?> c)
仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
int size()
返回此 collection 中的元素数。
Object[] toArray()
返回包含此 collection 中所有元素的数组。
<T> T[]
toArray(T[] a)
返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。
子接口：
Set:表示一组无序不可重复的对象 无序 不可重复
List：表示一组有序可以重复的对象 有序 可以重复 1>list集合和set集合的区别?
list集合和set集合的选择依据?
存储单列数据,是选择list好还是set好?
list和set都是单列集合,存储单列数据的;
list集合存储的数据是有序重复的;
set集合存储的数据是无需不可重复的;
2>list中常见的实现有ArrayList和LinkedList,怎么去选择？
两者的区别?
集合中的内容不被经常改变,且为了提高查询性能,一般都是使用ArrayList;
因为ArrayList底层是可变长数组数据结构,所以查询性能高于更新性能;
集合中的内容经常要去操作头尾元素,一般使用LinkedList;因为LinkedList
底层是链表式数据结构,那么链表数据结构操作首尾的性能是最高的;
3>set集合中常见的实现有HashSet TreeSet LinkedHashSet,怎么去选择?
三者的区别?
在存储数据的时候需要通过元素的哈希值和内容进行去重,就使用HashSet;
在存储数据的时候如果需要通过比较元素的大小实现去重,实现TreeSet,正数
当前元素大于被比较元素,负数当前元素小于被比较元素,0当前元素等于被比价
元素就视为是相同元素不让重复存储;同时元素还会进行大小排序;
LinkedHashSet的底层包含了哈希表数据结构和链表数据结构,哈希表数据结构
决定了元素不可重复,链表数据结构决定了元素是有序的,所以如果存储的数据
要求是有序且不可重复的就使用LinkedHashSet;
4>Map集合:
Map集合的特点?
存储的键值对(键映射到值的映射关系),所以Map集合的泛型有两个,一个是键的
泛型一个是值的泛型,键是唯一不能重复的,值可以重复;
Map集合中常见的实现HashMap TreeMap LinkedHashMap选择依据?区别?
Map集合的所有实现底层的数据结构都是用于操作键的;
Set集合的实现的数据结构和Map集合的实现的数据结构一样;
Set集合就是从Map集合的键列剥离出去的,Set集合的特点是无序不可重复,
而Map集合的键的特点也是无序不可重复;
HashMap:底层就是哈希表数据结构
当存储键值对的键需要通过元素的哈希值和内容进行去重时,就使用HashMap;
TreeMap:底层就是二叉树数据结构
当存储的键值对的键需要进行大小比较来去重并进行大小排序时,就使用TreeMap;
LinkedHashMap:底层就是链表和哈希表数据结构
当存储的键值对的键要求是有序且不可重复的就使用LinkedHashMap;
多线程：
进程： 正在运行的程序，是系统进行资源分配和调用的独立单位。
每一个进程都有它自己的内存空间和系统资源。
多进程：多个程序可以“同时”运行
所谓的同时是不是真正的同时？
并行：在一个时间点，多个程序同时执行
并发：在同一个时间段内，多个程序“同时”执行
大部分时候我们看见的同时都不是真正的同时，只是计算机做了快速的交替
线程：
线程是程序运行过程中的一个顺序流
在一个进程内部又可以执行多个任务，而这每一个任务我们就可以看成是一个线程。线程是程序中单个顺序的控制流，是程序使用CPU的基本单位。
一个进程如果只有一条执行路径，则称为单线程程序。
一个进程如果有多条执行路径，则称为多线程程序。
如何实现多线程的程序：
常用的有两种实现多线程的方式：
1.继承Thread类的方式
步骤：
a.创建子类继承Thread类
b.在子类中重写Thread类的run方法
run方法中写要线程执行的任务的代码
c.创建子类的对象，
想要几个线程同时运行，就创建几个线程对象
d.启动线程
start()方法
2.实现Runnable接口的方式
步骤：
a.创建实现类实现Runnable接口
b.实现接口的run()
c.创建实现类的对象---执行任务的对象
d.创建Thread类的对象，创建对象时将实现类的对象作为构造方法的参数
e.启动线程
start方法
实现接口方式的好处
可以避免由于Java单继承带来的局限性。
适合多个相同程序的代码去处理同一个资源的情况，把线程同程序的代码，数据有效分离，较好的体现了面向对象的设计思想。
多个线程同时执行，其实是快速的交替
Thread类中有一个静态方法：
sleep(long millis):当前线程暂停指定的毫秒数
获取线程的名字：
Thread类中 getName()
自定义的线程默认是有名字的 Thread-数字
主线程的名字默认是main
如果自定义的线程类继承Thread.就继承了getName() this.getName()可以获取当前线程的名字
main方法中的主线程如何获取线程名称？
Thread类中提供了静态方法
static Thread currentThread():返回当前正在执行的线程对象
Thread.currentThread().getName()
给线程设置名字：
setName(String name)
还可以在构造方法中设置线程的名字：
Thread的构造方法：
Thread()
分配新的 Thread 对象。
Thread(Runnable target)
分配新的 Thread 对象。
Thread(Runnable target, String name)
分配新的 Thread 对象。
Thread(String name)
分配新的 Thread 对象。
name:新线程的名字
线程的调度：
控制线程的执行顺序的
线程的调度方式有两种：
分时调度模型：
所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
抢占式调度模型：
优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些。
java中使用的是抢占式调度模型
线程的优先级：
获取线程的优先级：
int getPriority() 返回线程的优先级。
没有设置时，线程默认的优先级是5
设置线程的优先级：
void setPriority(int newPriority) 更改线程的优先级。
设置优先级的时候并不是所有的int数据都可以，值必须在MIN_PRIORITY--- MAX_PRIORITY
public static final int MAX_PRIORITY 10
public static final int MIN_PRIORITY 1
public static final int NORM_PRIORITY 5
线程控制的方法：
static void sleep(long millis) 让当前线程暂停指定的毫秒数
void join() 将当前线程加入到一个正在执行的线程中，一致等待加入的线程执行完毕后，本来执行的线程才会继续执行， 等待该线程终止
t1 t2
t2正在执行
t1.join()
t2会暂停执行，一致等到t1执行完毕后t2才会继续执行
static void yield() 礼让
暂停当前正在执行的线程对象，并执行其他线程。
public final void setDaemon(boolean on)设置后台线程
后台线程又称为守护线程
守护线程是为了保证非后台线程正常执行的
只要所有的非后台线程执行完毕后，jvm就会停止运行
中断线程：
stop()：强制停止当前线程
public void interrupt()中断线程。
线程的声明周期：
一个东西的声明周期，出生—做事----死亡
线程对象的状态：
创建状态：创建线程对象后
就绪状态：调用了start()方法后
执行状态：抢到了cpu执行权
阻塞状态：线程没有执行完毕，遇到 sleep wait
死亡状态：线程执行完毕
1463
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
