Java

韩顺平Java

前言

Java诞生于1995年，最早是SUN公司,被甲骨文收购，现在由甲骨文公司管理。

Java是解释性语言 解释性语言：javascript,PHP, java 编译性语言: c，c++ 区别是：解释性语言，编译后的代码，不能直接被机器执行，需要解释器；编译性语言，编译后的代码,可以直接被机器执行,c /c++

JDK,JRE,JVM

JDK = JRE + 开发工具集（例如Javac,java编译工具等） JRE = JVM + Java SE标准类库(java核心类库)

入门

用命令行窗口进行javac编译时，写java代码的编译器的编码和命令行窗口的编码要一致，不然不会编译成功（*测试其实也会成功）

在命令行窗口使用java运行类名.class文件时，不要带上.class后缀名，带上反而会报错

.java源文件，.class字节码文件

javac编译后，是生成的源文件中的类名.class，而不是源文件名.class，如果源文件中有多个类，就生成多个字节码文件

一个源文件中只能有一个public类，且源文件名必须为该public类的类名。 一个文件中可以只有非public类，如果只有非public类，此类可以跟文件名不同。main方法也可以写在非public类中 java将public类作为每个编译单元的数据接口，只能有一个，不然不能处理存在多个类的java文件。当一个编译单元（java文件）有多个非public类时，运行时需要对数据来源进行选择。（即IDEA等IDE直接点运行时需要进行选择）

如何快速学习技术或知识点

需求：1.工作时需要，老板要求去学；2.跳槽对方要求，找工作时；3.技术控

首先看能否用传统技术解决：对新技术能有更饱满的理解，理解新技术到底好在哪，用新技术时一定要多问到底优势在哪

新技术或知识点学习顺序：

1.先搞清基本原理和基本语法（不要考虑细节）

2.快速入门案例（基本程序）

3.开始研究技术的注意事项，使用细节，使用规范，如何优化=>永无止境，技术魅力

转义字符

\t ：一个制表位，实现对齐的功能（*相当于TAB键，但TAB无法对齐） \n ：换行符 \ ：一个
" :一个" ' ：一个' \r :一个回车 System.out.println("韩顺平教育\r 北京");

回车和换行的区别

来源于打字机：在每行后面加两个表示结束的字符。一个叫做“回车”，告诉打字机把打印头定位在左边界，不卷动滚筒；另一个叫做“换行”，告诉打字机把滚筒卷一格，不改变水平位置。

至于ENTER键的定义是与操作系统有关的。通常用的Enter是两个加起来。

符号 ASCII码 意义

\n 10 换行NL

\r 13 回车CR

不同操作系统下的含义：

\n: UNIX 系统行末结束符

\r\n: window 系统行末结束符

\r: MAC OS 系统行末结束符

我们经常遇到的一个问题就是，Unix/Mac系统下的文件在Windows里打开的话，所有文字会变成一行；而Windows里的文件在Unix/Mac下打开的话，在每行的结尾可能会多出一个^M符号。

软回车和硬回车：

硬回车就是普通我们按回车产生的，它在换行的同时也起着段落分隔的作用。

软回车是用 Shift + Enter 产生的，它换行，但是并不换段，即前后两段文字在 Word 中属于同一“段”。在应用格式时你会体会到这一点。

软回车能使前后两行的行间距大幅度缩小，因为它不是段落标记，要和法定的段落标记——硬回车区别出来。硬回车的html代码是<p>..</p>，段落的内容就夹在里面，而软回车的代码很精悍：<br>。网页的文字如果复制到word中，则硬回车变为弯曲的箭头，软回车变为向下的箭头。

注释和代码规范

多行注释（/**/）不允许嵌套使用

文档注释可以被javadoc解析，一般写在类上，方法上

非javaDoc注释往往是写给代码维护者看的，告诉为什么这样写，如何修改，注意问题等

Shift+TAB可以左缩进

等号，运算符左右习惯性加空格

源文件用utf-8

行宽不要超过80字符

推荐行尾风格：第一个大括号不另换一行

DOS命令

\1) 查看当前目录是有什么内容 dir dir dir d:\abc2\test200 \2) 切换到其他盘下：盘符号 cd : change directory 案例演示：切换到 c 盘 cd /D c: （切换根目录，即切换盘符需要加/D） \3) 切换到当前盘的其他目录下 (使用相对路径和绝对路径演示), ..\表示上一级目录 案例演示： cd d:\abc2\test200 cd ....\abc2\test200 \4) 切换到上一级： 案例演示： cd .. \5) 切换到根目录：cd
案例演示：cd
\6) 查看指定的目录下所有的子级目录 tree 目录树 \7) 清屏 cls [苍老师] \8) 退出DOS exit \9) 说明: 因为小伙伴后面使用DOS 非常少，所以对下面的几个指令，老韩给大家演示下, 大家了解即可 (md[创建目录],rd[删除目录],copy[拷贝文件],del[删除文件],echo[输入内容到文件],type,move[剪切]) => Linux,

基础

变量

加号+的使用

1.当左右两边都是数值型时，则做加法运算

2.当左右两边有一方为字符串，则做拼接运算

3.运算顺序，是从左到右

下面代码输出什么？

System.out.println(100 + 98);//198
System.out.println("100"+98);//10098
System.out.println(100+3+"hello");//103hello
System.out.println("hello"+100 +3);//hello1003

数据类型

上图必须背下来！！！

整数类型

1.Java各整数类型有固定的范围和字段长度，不受具体OS[操作系统]的影响，以保证java程序的可移植性。

2.Java的整型常量（具体值）默认为int型，声明long型常量须后加l或L

3.java程序中变量常声明为int型，除非不足以表示大数，才使用long

4.bit:计算机中的最小存储单位。byte:计算机中基本存储单元，1byte=8bit。

java的long的小l和大L区别，和由大到小转化问题

首先几乎在所有位置，long的小写和大写都可以互相替换。其次L本质是对象，不是基础类型，具有Object的特性。包装类把基本类型转换为对象，每个基本类型在java.lang包中都有一个相应的包装类

包装类型：nteger、Long、Short、Byte、Character、Double、Float、Boolean、BigInteger、BigDecmail

基本类型和包装类的异同：

• 在Java中，一切皆对象，但八大基本类型却不是对象。
• 声明方式的不同，基本类型无需通过new关键字来创建，而封装类型需new关键字。
• 存储方式及位置的不同，基本类型是直接存储变量的值保存在堆栈中能高效的存取，封装类型需要通过引用指向实例，具体的实例保存在堆中。
• 初始值的不同，封装类型的初始值为nul,基本类型的的初始值视具体的类型而定，比如int类型的初始值为0，boolean类型为false;
• 使用方式的不同：如与集合类合作使用时只能使用包装类型。
• Iong类型最好以大写L来添加尾缀，因为小写引容易和数字1混淆。

（*IDEA中用小写l会警告，但其实能编译通过）

long不能直接赋给int类型，会报错，即使数很小。可以使用（int）强制转换

浮点数

1) 关于浮点数在机器中存放形式的简单说明,浮点数=符号位+指数位+尾数位 2) 尾数部分可能丢失，造成精度损失(小数都是近似值)。

• 1.与整数类型类似，Java浮点类型也有固定的范围和字段长度，不受具体OS的影响。[float4个字节double是8个字节]

• 2.Java的浮点型常量（具体值）默认为double型，声明float型常量，须后加f或F

  float a = 1.1;//错误，因为1.1默认为double，不能由大转小

• 3.浮点型常量有两种表示形式 十进制数形式如：5.12 512.0f .512(必须有小数点，但0可以省略) 科学计数法形式如：5.12e2[5.12*10的2次方] 5.12E-2[5.12/10的2次方]

• 4.通常情况下，应该使用doublei型，因为它比float型更精确。[举例说明]

  double num9=2.1234567851;//输出2.1234567851
  float num10=2.1234567851F;//输出2.1234567

浮点数比较相等

Float.POSITIVE_INFINITY
//Infinity正无穷大，即1.0/0时
Float.NEGATIVE_INFINITY
//-Infinity负无穷大，即-1.0/0时

浮点数比较相等：

方法一：

常用这种不需要精度过高的方法，精度过高容易误判。

Math.abs(f - b) < 0.01

和

Math.abs(f - b) < 0.000000001

得到的结果可能不一样，因为精度问题

方法二：

这种方式精度最高，很能造成0.1！=0.1的情况

Float.toString(f).equals(Float.toString(b))

判断浮点数相等的几种办法，并测试其精确度

    @Test
    public void testFloat(){
        double f1 = 2.07 - 1;  //1.0699999999999998
        double f2 = 1.07;  //1.07
        //Double.toString(f1).equals(Double.toString(f2)) --> false;
        //Math.abs(f1-f2)<0.00000000000000000000000001 --> false;
        //Math.abs(f1-f2)<0.0001 --> true;
        //Double.doubleToLongBits(f1)==Double.doubleToLongBits(f2) --> false;
        //new BigDecimal(f1).equals(new BigDecimal(f2)) --> false;
        //new BigDecimal(f1).compareTo(new BigDecimal(f2))==0 --> false;
        if (new BigDecimal(f1).compareTo(new BigDecimal(f2))==0){
            System.out.println("true");
        }else{
            System.out.println("false");
        }

        Set<Double> hashset = new HashSet<>();
        hashset.add(f1);
        hashset.add(f2);
        //Set并不能认为这两个浮点数相等，无法去重
        // 输出：
        // 1.0699999999999998
        // 1.07
        for (Double f : hashset){
            System.out.println(f);
        }
    }

方法来自：JAVA - 判断两个浮点数相等

字符类型

1.字符常量只能用单引号('')括起来的单个字符。不能用双引号。

2.Java中还允许使用转义字符"\''来将其后的字符转变为特殊字符型常量。例如：char c3=''\n'

3.在java中，char的本质是一个整数，在输出时，是unicode码对应的字符。

4.可以直接给char赋一个整数，然后输出时，会按照对应的unicode字符输出[97-》a

5.char类型是可以进行运算的，相当于一个整数，因为它都对应有Unicodei码.

System.out.println('a'+1);//输出98,而不是b

（*可以理解为加号+两边的计算要么是当作String拼接，要么当作数字）

字符编码相关

1.字符型存储到计算机中，需要将字符对应的码值（整数）找出来，比如a 存储：'a'==>码值97==>二进制(1100001)==>存储 读取：二进制(1100001)=>97===>'a'=>显示

2.字符和码值的对应关系是通过字符编码表决定的（是规定好）

ASCII(ASCII编码表一个字节表示，一个128个字符，实际上一个字节可以表示256个字符，只用128个) Unicode(Unicode编码表固定大小的编码使用两个字节来表示字符，字母和汉字统一都是占用两个字节，这样浪费空间)，Unicode将世界上所有的符号都纳入其中，不会有乱码的问题 utf-8(编码表，大小可变的编码字母使用1个字节，汉字使用3个字节)，UTF-8是Unicode的改进 gbk(可以表示汉字，而且范围广，字母使用1个字节，汉字2个字节) gb2312(可以表示汉字，gb2312<gbk) big5码（繁体中文，台湾，香港）

（char在java中是16位，2个字节，因为*java用的是Unicode。一个16位的编码所能产生的字符只有65536个。 **Unicode码包括ASCII码。）

类型转换

自动类型转换

可以自动类型转换顺序：

(char / byte -> short) -> int -> long -> float -> double

1.有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。

float d1 = n1 + 1.1;//错误 n1 + 1.1 => 结果类型是 double。1.1默认为double

2.当我们把精度（容量）大的数据类型赋值给精度（容量）小的数据类型时，就会报错，反之就会进行自动类型转换。

3.(byte,short)和char之间不会相互自动转换。

int n2 = 1;
byte b2 = n2;//错误，但是
byte b1 = 10;//正确，正确情况下10默认为int型，但此时，因为是把具体的值赋给byte时会先判断该值的范围是否属于byte，是的话就可以正常赋值。上面错误是因为n2已经被包装成4字节的int。

4.byte,short,char他们三者可以计算，在计算时首先转换为int类型。（无论是同种类型运算还是不同类型计算）

byte b2 = 1;
byte b3 = 2;
byte b5 = b2 + b3;//错误，即使同种类型，只要计算就会转为int

5.boolean不参与转换

6.自动提升原则：表达式结果的类型自动提升为操作数中最大的类型

强制类型转换

1.当进行数据的大小从大一>小，就需要使用到强制转换

2.强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级

3.char类型可以保存int的常量值，但不能保存int的变量值需要强转

char c = 65535//编译正常
char c2 = 65536/编译错误。因为char为2字节，为2^16=65536，16位二进制全为1的十进制为65535

4.byte和short,char类型在进行运算时，当做int类型处理

基本数据类型和String类型的转换

基本类型转String类型 语法：将基本类型的值+”"即可

short a = 4;
String f = a + "";

String类型转基本数据类型 语法：通过基本类型的包装类调用parseXX方法即可

运算符

取余%

java中取模就是取余%

在 % 的本质 看一个公式!!!! a % b = a - a / b * b

（*被除数为正结果就为正）

// -10 % 3 => -10 - (-10) / 3 * 3 = -10 + 9 = -1
// 10 % -3 = 10 - 10 / (-3) * (-3) = 10 - 9 = 1
// -10 % -3 = (-10) - (-10) / (-3) * (-3) = -10 + 9 = -1
System.out.println(10 % 3); //1
System.out.println(-10 % 3); // -1
System.out.println(10 % -3); //1
System.out.println(-10 % -3);//-1

自增++（--**//）

面试题

int i = 1;//i->1
i = i++; //规则使用临时变量: (1) temp=i;(2) i=i+1;(3)i=temp;
System.out.println(i); // 1

int i=1;
i=++i; //规则使用临时变量: (1) i=i+1;(2) temp=i;(3)i=temp;
System.out.println(i); //2

instanceof检查是否是类的对象

例如：“hs” instanceof String 返回true

&&短路与，&逻辑与，^异或

开发中基本使用短路与&&，效率高 短路或||同上

a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false

复合赋值运算符会进行类型转换

byte b = 2;
b+=3;//编译正常，等价 b = (byte)(b + 2);添加了类型转换
b++;//编译正常，等价 b = (byte)(b + 1);
b = b + 3//编译错误

进制

二进制：0,1 ，满 2 进 1.以 0b 或 0B 开头。 十进制：0-9 ，满 10 进 1。 八进制：0-7 ，满 8 进 1. 以数字 0 开头表示。 十六进制：0-9 及 A(10)-F(15)，满 16 进 1. 以 0x 或 0X 开头表示。此处的 A-F 不区分大小写。

二进制转八进制

规则：从低位开始，将二进制数每三位一组，转成对应的八进制数即可

案例：请将 ob11010101 转成八进制 ob11(3)010(2)101(5) => 0325

二进制转换成十六进制

规则：从低位开始，将二进制数每四位一组，转成对应的十六进制数即可。

案例：请将 ob11010101 转成十六进制 ob1101(D)0101(5) = 0xD5

八进制转换成二进制

规则：将八进制数每 1 位，转成对应的一个 3 位的二进制数即可。

案例：请将 0237 转成二进制 02(010)3(011)7(111) = 0b10011111

十六进制转换成二进制

规则：将十六进制数每 1 位，转成对应的 4 位的一个二进制数即可。

案例：请将 0x23B 转成二进制 0x2(0010)3(0011)B(1011) = 0b001000111011

原码、反码、补码(重点 难点)

1. 二进制的最高位是符号位：0表示正数，1表示负数（老韩口诀：0->0，1->-）
2. 正数的原码，反码，补码都一样（三码合一）
3. 负数的反码=它的原码符号位不变，其它位取反(0->1,1->0)
4. 负数的补码=它的反码+1，负数的反码=负数的补码-1
5. 0的反码，补码都是0
6. java没有无符号数，换言之，java中的数都是有符号的
7. 在计算机运算的时候，都是以补码的方式来运算的.（因为可以把正数和负数统一起来）
8. 当我们看运算结果的时候，要看他的原码（重点）

位运算符

java 中有 7 个位运算(&、|、^、~、>>、<<和 >>>)

按位与&：两位全为1，结果为1，否则为0 按位或|：两位有一个为1，结果为1，否则为0 按位异或^：两位一个为0，一个为1，结果为1，否则为0 按位取反~：0->1,1->0

算术右移 >>：低位溢出,符号位不变,并用符号位补溢出的高位

算术左移 <<: 符号位不变,低位补 0

>>> 逻辑右移也叫无符号右移,运算规则是: 低位溢出，高位补 0

>>> 特别说明：没有 <<< 符号

int a=1>>2; //1 => 00000001 => 00000000 本质 1 / 2 / 2 =0
int c=1<<2; //1 => 00000001 => 00000100 本质 1 * 2 * 2 = 4

小结

int num1=(int)"18";//错误应该Integer.parselnt("18");
double num3=3d;//ok，d就表示double
int i=48;char ch=i+1;//错误int->char i+1后是int

看代码时可以使用内存分析法。

流程控制

switch

case语句没有break,后面的case无论是否匹配都执行

default有没有break都一样

1. 表达式数据类型，应和case后的常量类型一致，或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是int
2. switch(表达式)中表达式的返回值必须是：(byte,short,int,char,enum[枚举]，String)
3. case子句中的值必须是常量或常量表达式（如'a'+1），而不能是变量
4. default-子句是可选的，当没有匹配的case时，执行default，若也没有default则什么都不执行。
5. breaki语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有写break,程序会顺序执行到switch:结尾，除非遇到break;

例题：

对学生成绩大于 60 分的，输出"合格"。低于 60 分的，输出"不合格"。(注：输入的成绩不能大于 100), 提示 成绩/60

Scanner scan = new Scanner(System.in);
int a = scan.nextInt();
switch(a/60){
    case 1:
        switch(a/101){
            case 0:
                System.out.println("合格");
                break;
            default:
                System.out.println("输入大于100");
        }
        break;
    case 0:
        //先用三目判断a是否为0，如果为0就返回1
        //如果不为零就用公式判断是否为负数
        switch(a==0 ? 1 : a/Math.abs(a)){
            case 1:
                System.out.println("不合格");
                break;
            case -1:
                System.out.println("输入为负数");
                break;
        }
        break;
    default:
        System.out.println("输入有误");
}

switch 和 if 的比较和选择

1) 如果判断的具体数值不多，而且符合 byte、short 、int、char,enum[枚举], String 这 6 种类型。虽然两个语句都可以使用，建议使用 swtich 语句。 2) 其他情况：对区间判断，对结果为 boolean 类型判断，使用 if，if 的使用范围更

for

1) 循环条件是返回一个布尔值的表达式 2) for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。如果循环判断条件也为空则是死循环 3) 循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开。

老韩的两个编程思想(技巧)

1. 化繁为简 : 即将复杂的需求，拆解成简单的需求，逐步完成 编程 = 思想 --练习-> 代码
2. 先死后活 : 先考虑固定的值，然后转成可以灵活变化的值

多重循环

案例：打印空心金字塔

for(int i = 1; i<=n; i++){
    for(int j = 1; j<=n-i; j++){
        System.out.print(" ");
    }

    for(int j = 1; j<=i*2-1; j++){
        if(j==1 || j==i*2-1 || i==n){
            System.out.print("*");
        }else{
            System.out.print(" ");
        }
    }

    for(int j = 1; j<=n-i; j++){
        System.out.print(" ");
    }
    System.out.println();
}
输出：
   *   
  * *
 *   *
*******

break

1. break语句出现在多层嵌套的语句块中时，可以通标签指明要终正的是哪一层语句块（*尽量不要使用标签，影响可读性）

数组

数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。

数组创建

声明数组时

double[] hens和double hens[]是等价的，推荐前者

可以只声明，即声明和创建分开，此时hens是null

创建数组

语法: 数组名=new 数据类型[大小]; a=new int[10];

静态初始化：

语法：数据类型[] 数组名={元素值元素值}

inta[1]={2,5,6,7.8,89,90,34,56}

数组使用注意事项和细节

1) 数组是多个相同类型数据的组合，实现对这些数据的统一管理 2) 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。 3) 数组创建后，如果没有赋值，有默认值int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null 4) 数组属引用类型，数组型数据是对象(object)

赋值机制：数组是引用传递

1) 基本数据类型赋值，这个值就是具体的数据，而且相互不影响。 int n1 = 2; int n2 = n1; 2) 数组在默认情况下是引用传递，赋的值是地址。

（*值传递和引用传递个人理解：int n2时会有默认值0，所以定义后jvm是分配空间了，传值时把值复制到它的位置就行；而int[] arr默认是null，未分配空间，所以传值时没有自己的空间，只能指向别人的空间）

排序

内部排序:

指将需要处理的所有数据都加载到内部存储器中进行排序。包括(交换式排序法、选择式排序法和插入式排序法)；

外部排序法：

数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括(合并排序法和直接合并排序法)。

二维数组

动态初始化-列数不确定：

二维数组的每个一维数组元素的长度可以不一致

int[][] arr = new int[3][]

创建二维数组，一个有3个一维数组，但是每个一维数组还没有开数据空间

静态初始化:

定义 类型 数组名[][] = {{值 1,值 2..},{值 1,值 2..},{值 1,值 2..}}

int[][] arr = {{1,1,1}, {8,8,9}, {100}};

二维数组的声明方式有:

int[][] y 或者 int[] y[] 或者 int y[][]

总结

String[] arr = new String[]{"2","3"};是正确格式

String strs = {"a","b","c");//ok
String strs = new String{"a""b""c");//error
String strs[] = new String[]{"a","b","c");//ok
String[] strs = new String[3]{"a","b","c");//error

4.已知有个升序的数组，要求插入一个元素，该数组顺序依然是升序，比如：[10,12,.45,.90].添加23后，数组为[10,12,23,45,90]

//注意：1.index的设置，一般设置为-1，如果被使用就被赋予别的值，它所在的代码块若未被执行就保持-1，替代了Boolean变量
//2.j变量的设立，和j++的位置，j只跟随arr数组，arr的元素被复制一次，就j++，（*有几个数组参与就设几个下标变量）
int[] arr = {10,12,45,90};
int[] tempArr = new int[arr.length+1];
int a = 15;
int index = tempArr.length-1;
for(int i=0,j=0; j<arr.length; i++){
    if(arr[j] < a){
        tempArr[i] = arr[j];
        j++;

    }else if(arr[j] > a){
        if(index == tempArr.length-1){
            index = i;
            continue;
        }else{
            tempArr[i] = arr[j];
            j++;
        }
    }
}
tempArr[index] = a;
System.out.println(Arrays.toString(tempArr));

面向对象

对象在内存中存在形式(重要的)必须搞清楚。

好文：Java 类和对象在内存中的表现形式，栈、堆、方法区、常量池

Java 内存的结构分析

1) 栈： 一般存放基本数据类型(局部变量) 2) 堆： 存放对象(Cat cat , 数组等) 3) 方法区：常量池(常量，比如字符串)， 类加载信息

Java 创建对象的流程简单分析

1) 先加载 Person 类信息(属性和方法信息, 只会加载一次) 2) 在堆中分配空间, 进行默认初始化(看规则) 3) 把地址赋给 p , p 就指向对象

4) 进行指定初始化， 比如 p.name =”jack” p.age = 10。（*如果赋值为String，则先在常量池里开辟一个空间，再把地址传给堆中，如果是给常量赋值，直接在堆中创建就行）

方法的调用机制原理：(重要!-示意图!!!)