程序员编程笔记

1.查看电脑当前进程和端口cmd netstat -pid netstat -a  查看全部端口信息:netstat –ano

2.创建文件夹 mkdir 文件名或文件路径

3.删除文件夹 rmdir

4.删除文件 del

5.打开计算机calc

6.打开画图mspaint

7.用echo "写入新数据">d:\a.txt，echo 字符串 >文件路径 文件名(会覆盖原内容)

8.用echo "写入新数据">>d:\a.txt，echo 字符串 >文件路径 文件名(不会覆盖原内容，添加到后面)

9.powershell和cmd功能类似

10.架构师需要关注编程语言的版本，初学者不要关注版本，只需要学会常用版本

11.java简单易用，健壮性，开源，跨平台

12.java源文件后缀是.java，编译文件后缀是.class由JVM虚拟机运行，常用虚拟机是ORACLE版本的

13.JVM不是跨平台的，各种平台系统有对应的JVM

14.jdk是java开发核心工具包

15.Mysql数据库里的is仅用在is null或is not null，=用在2种情况下：一是判断值是否相等 where id=1；二是用于赋值set id=1

16.bin目录里面有.class可执行文件,src里面有.java源码文件。

17.//alt+/表示补全代码，//ctrl+F11表示执行代码

18.程序的主方法就相当于入口，相当于进入房间的大门，只允许一个大门。

19.用来分析当前进程占用内存的数据统计excel统计表的powershell命令如下：

# create new excel instance

$objExcel = New-Object -comobject Excel.Application

$objExcel.Visible = $True

$objWorkbook = $objExcel.Workbooks.Add()

$objWorksheet = $objWorkbook.Worksheets.Item(1)

# write information to the excel file

$i = 0

$first10 = (ps | sort ws -Descending | select -first 10)

$first10 | foreach -Process {$i++; $objWorksheet.Cells.Item($i,1) = $_.name; $objWorksheet.Cells.Item($i,2) = $_.ws}

$otherMem = (ps | measure ws -s).Sum - ($first10 | measure ws -s).Sum

$objWorksheet.Cells.Item(11,1) = "Others"; $objWorksheet.Cells.Item(11,2) = $otherMem

# draw the pie chart

$objCharts = $objWorksheet.ChartObjects()

$objChart = $objCharts.Add(0, 0, 500, 300)

$objChart.Chart.SetSourceData($objWorksheet.range("A1:B11"), 2)

$objChart.Chart.ChartType = 70

$objChart.Chart.ApplyDataLabels(5)

20.项目峰会，接口设计，算法和数据结构设计，数据库设计，原型设计

21.eclipse,syso+alt+/打印输出快捷键

22.后缀.java的源文件在按ctrl+s时会触发编译，编译生成.class字节码文件，在按Ctrl+F11后JVM虚拟机会执行.class字节码文件

23.文档注释格式 （斜杠/+2个*+内容+1个*+斜杠/）举例：/**文档注释 author ***  2021年4月30日*/

   多行注释格式 （斜杠/+1个*+内容+1个*+斜杠/）举例：/*多行注释 练习map遍历*/

24.位（比特） bit，来自英文bit，音译为“比特”，表示二进制位。比特是英文 binary digit的缩写。比特是表示信息的最小单位，

   是二进制数的一位包含的信息或2个选项中特别指定1个的需要信息量。一般来说，n比特的信息量可以表现出2的n次方种选择。

   Byte字节，1Byte = 8Bits (1字节 = 8位)  8字节=64位，4字节=32位

25.java共有53个关键字，2个保留字const或goto，8个基本数据类型，单行注释，多行注释，文档注释

26.0b开头表示2进制数，0开头表示8进制数，0x表示16进制数，\u表示char类型数据

27.byte/short/char 三种比int范围小的数，在运算时会自动提升为int类型；

28.java里整数不能除以0,浮点数可以除以0，结果是无穷大，Infinity是无穷大

29.代码中的命名严禁使用拼音和英文混合。比如DaZheModule这样就是错误的。

30.0.0除以0或0.0除以0结果是NaN表示Not a Number;

31.类名大驼峰，方法名小驼峰，变量名小驼峰，常量名全大写

32.alt+↓，向下移动某行代码alt+↑表示向上移动某行代码,ctrl+d删除某行代码，alt+/补全代码

33.java跨平台的含义：一份代码，处处运行。

34.变量不能只申明不赋值; 不赋值,不使用就不要申明，否则会浪费内存空间。

35.数据小转大没问题，但是大转小可能会溢出。

36.方法内部的变量是局部变量，方法之外的是全局变量。

37.静态web资源是指：千人一面的，不同人不同条件下访问的内容一样，比如百度首页，京东首页

   动态web资源是指：千人千面，不同的人在不同条件下访问的内容不一样，比如淘宝的订单页，收藏页，因为带有用户的属性.

38.小到大，直接转；大到小，强制转； 浮变整，小数没

   低 ------------------------------------> 高

   byte,short,char→ int→ long→float→double(boolean不能类型转换)

39.1？2：3表示三元运算符；？前面是条件表达式1；若条件为真计算结果为2；若条件为假计算结果为3。

40.同一个类中，两个方法名相同，参数类型相同，只是形参名不同，这样的两个方法不是方法的重载。

41.同一个类中，两个方法名相同，参数个数不同，一定构成重载。

42.同一个类中，两个方法名相同，参数个数相同，要看参数类型才能确定是否为方法的重载。

43.局部变量：

   位置：定义在方法里或局部代码块中，必须手动初始化来分配内存，如int i=5;

   作用域：在方法里或代码块之内有效，方法运行完内存就释放了。

44.成员变量：

   位置：定义在类里，方法外

   不用手动初始化，也会被自动初始化为默认值，作用域：在类中有效，类消失，成员变量会被释放

45.java里8种基本数据类型，整数型byte short int long  浮点型float double 字符型char 布尔型boolean

     整数的默认字面值是int，小数的默认字面值是double，byte short char 在运算时会提升为int类型

    a=a+b这种如果两边类型不同的话,可能会报错,但是a+=b这种会自动进行类型转换.

46.java里面的switch case 分支结构如果case后面没有加break,那么会向下穿透依次执行，就像糖葫芦一样.

47.java里面给程序添加断点，双击行数列左边的蓝色区域确定断点，然后点击小虫子debug图标.

48.switch(分支条件){ //分支条件可以是byte short char int String 5种数据类型，不能是布尔类型.

     case表达式1:语句1;break;

     case表达式2:语句2;break;

     case表达式3:语句3;break;

     default:语句4;break;}

49.for循环里的统计数量的count,用count++或者++count或者count=count+1都行，但是常用count++，因为都是循环结束再返回统计结果。

50.java里的parallelSort 和 sort 哪个更快，取决于待排序的数据的规模，以及可以利用的核数。parallelsort(并行排序) 会利用多线程优势，将原始数据

   分为多个子数组，子数组内在利用类似 merge & sort 方法排序，多个子数组会并行排序，所以理应更快。虽然多线程调度会带来额外开销，

   但在数据规模较大时额外开销可能会显得微不足道。具体多大的数据量应该使用 parallelsort，取决于你代码运行机器允许的资源和处理

   数据量大小，时效性要求等。如果数据量大于某个 threshold(阈值/临界点) （源码中默认是 8192），机器允许利用多核并且有较高的时效性要求，

   不妨优先使用 parallelSort。

51.for(开始条件申明循环变量;循环条件;更改条件){循环体}

52.方法的返回值可以不用变量接收，直接用print打印，比如println(method());

53.//自创的另类的冒泡排序，用嵌套for循环对数组元素进行排序，（这种是把一个数组看成两个一样的数组,相当于两个手掌，左手掌和右手掌，看做两个一样的数组，左右手的手指按序进行比较）

for(int i=0;i<b.length;i++) {

for(int j=0;j<b.length;j++) {

if(i<j&&b[i]>b[j]) {

char temp=0;

temp=b[i];

b[i]=b[j];

b[j]=temp;

}

}

}

System.out.println(Arrays.toString(b));

   //传统的冒泡排序，用嵌套for循环对数组元素进行排序，这种效率高一点点！！！

for(int i=1;i<=b.length-1;i++) {

for(int j=0;j<b.length-i;j++) {

if(b[j]>b[j+1]) {

char temp=0;

temp=b[j+1];

b[j+1]=b[j];

b[j]=temp;

}

}

}

System.out.println("这是用传统冒泡排序进行升序排序");

System.out.println(Arrays.toString(b));

54.break和continue之后都不允许写代码，因为在它们之后的代码是无法到达和执行的unreachable.

55.return可以返回方法的返回值，同时结束方法。

56.程序报出空指针异常，nullpointer异常，都是因为某个变量或某个对象没有申明或者没有new，导致没有创建内存空间。

57.do while循环格式，do{循环体}while(循环条件);注意最右边有分号，do while至少执行一次。

58.三种循环的区别:

   for：知道循环次数

   while/do while：当循环次数不确定时

   while：先判断，不符合规则，不执行代码

   do while：代码最少被执行一次，再去判断，符合规则，再次执行代码

   循环之间都可以互相替代,但是一般最好选择合适的循环结构来完成代码.

59.冒泡排序，外循环i 循环1到(length-1)轮，内循环j 循环0到(length-i-1)轮，在内循环中交换顺序，内循环是相邻元素比较，所以j下标从0开始

例子：原始数组：[99,97,95,92,90,86,82]，内循环的轮数是递减的

97,95,92,90,86,82,99，7个数，外循环第i=1轮，内循环相邻2个数比较0到length-i-1=6轮

95,92,90,86,82,97,99，7个数，外循环第i=2轮，内循环相邻2个数比较0到length-i-1=5次     

92,90,86,82,95,97,99，7个数，外循环第i=3轮，内循环相邻2个数比较0到length-i-1=4次

90,86,82,92,95,97,99，7个数，外循环第i=4轮，内循环相邻2个数比较0到length-i-1=3次

86,82,90,92,95,97,99，7个数，外循环第i=5轮，内循环相邻2个数比较0到length-i-1=2次

82,86,90,92,95,97,99，7个数，外循环第i=6轮，内循环相邻2个数比较0到length-i-1=1次

60. 八大基本类型字节大小：

    byte 1字节，short 2字节，char 2字节，int 4字节，

    long 8字节，float 4字节，double 8字节，boolean 1个字节。

61.数组的工具类Arrays,数组的名称Array,标志[].

62.for循环和while循环可以互相替代，包括嵌套的for循环也可以用嵌套的while循环替代,只是两者设置的循环条件的放置顺序不一样.

63.面向对象的三大特征：封装，继承，多态

64.什么是面向对象：把功能按类型封装起来装箱作为一个工具箱，比如工具箱里装：

    起子 扳手 钳子 锤子 螺丝 钉子 等，需要干什么活只需要拿出对应的工具就行。

65.类相当于设计图纸或者模板，对象相当于按照图纸生产的产品的实例。

66.类是一类事物的抽象，对象是具体的实现。

67.栈内存：先进后出，Firt in Last Out,存储：方法/局部变量/地址

   堆内存：先进先出，First in First Out,存储：对象(对象的属性和方法)

68.创建对象时，内存经历了什么：

   a.在栈内存中开辟一个块空间，存放引用类型变量var，并把它压入栈底

   b.在堆内存中开辟一个块空间，存放类的对象

   c.完成对象的实例化/初始化，并赋予默认值

   d.给初始化完毕的对象赋予唯一的地址值

   e.把地址值交给引用类型变量var保存，该地址指向堆中的对象

69.报错的常见英语单词：visible,nullPointerException,

70.类-一类事物的抽象-模板

   1.创建类

   2.创建类的属性

   3.封装类的属性

   4.提供set和get方法,toString,hashcode,.equal等方法.

   5.提供类的一些方法/功能

   创建对象（类的实例化）

   如果封装了私有属性的话:

   通过对象调用方法

   1.可以调用set方法设置私有属性的值

   2.可以调用get方法获取私有属性的值

   3.可以调用普通方法执行对应的功能

   4.私有的方法可以在类的公有方法里调用,间接的对外提供私有方法的调用。

71.私有方法如果不放在公有的方法中调用，那么对外就无法调用，程序设计就有问题。

71.面向过程：思想-干活的主体是自己（属性和方法分离），面向对象：干活的不是自己,我们是指挥者不是干活的。

72.类：把一类事物抽象成一个类型-模板/图纸，对象：根据图纸创建的实例。

73.无参构造方法不写也是有的，默认存在无参构造，

   构造方法是没有返回值类型的不能用void修饰,构造方法也可以重载。

74.同一个类可以有任意个构造方法（任意个的构造方法重载）。

75.构造方法主要用来创建对象和完成属性初始化

76.当只提供了含参构造方法时，无参构造方法会被覆盖，

    所以在创建重载的构造方法时，需要手动的创建无参构造。

77.构造方法的方法体里可以调用成员方法包括私有的成员方法。

78.重载让程序更灵活，但也容易导致混淆和脆弱。

79.无参构造是默认存在的，不写也有，但是如果写了含参构造，无参会被覆盖

80.创建对象时构造方法会被立即执行。

81.构造代码块含义：

   *1.每次创建对象，都会执行一次构造代码块

   *2.它的位置在类里方法外，用一对花括号括起来

   *3.用于提取所有构造方法中的共性内容

   *4.构造代码块优先于构造方法执行。

82.当创建对象时，程序会自动调用构造方法，

   但是如果有构造代码块，会先执行构造代码块，再执行构造方法。

83.当通过对象调用方法时，会执行方法中的功能，如果方法中有局部代码块会执行此局部代码块。

84.执行顺序：构造代码块-->构造方法-->局部代码块

85.局部代码块含义：

   * 1.局部代码块在方法里，用一对花括号括起来，作用域只限于括号之内

   * 2.局部代码作用：是用来控制变量的作用范围（作用范围越小越好，因为越小越安全）

   * 3.局部代码作用执行时机：调用方法时。

86.Java类编码流程：

   1.抽取形成类,如Phone/Student/Teacher/Person

   2.成员属性，可以封装

   3.构造方法

   4.构造代码块

   5.成员方法

87.this的用法：this表示当前类，可以用this.调用当前类的成员属性和成员方法

   a.当一个类存在同名的两个变量：一个是成员变量，一个是局部变量，

     如果想要使用成员变量，可以用：this.成员变量 进行指定

   b.如果想在无参构造中调用含参构造，写上：this(参数)，this语句必须在构造方法里的第一行

   c.如果想在含参构造中调用无参构造，写上：this()，this语句必须在构造方法里的第一行

   d.无参里调含参，或者含参里调无参，只能二选一或不选，不能二选二，否则就是死锁/死循环。

88.Java里的继承：

   1.只能单继承，一脉相传：爸爸/儿子/孙子,一个子类只能有一个直接父类，

     父类的私有资源，子类不可见，是一种is A的强耦合关系。

   2.子类可以有自己独有的方法和属性，子类可以重写父类的同名方法。

89.在子类中使用父类的成员属性或方法，需要使用super指定，super是表示父类的一个对象的引用。

    super.成员属性=value,这种赋值要写在成员方法里，如果写在构造方法或构造代码块中，赋的是初始默认值null或0或空。

90.构造方法可以重载，全参构造一般用于给对象的全属性赋值。

91.权限修饰符，权限由大到小排名：

   *public（同类 同包 子类 其他工程）

   *protected（同类 同包 子类）

   *缺省（同类 同包）缺省就是没有修饰符

   *private(同类)

92.软件编程的OCP原则，面向功能修改关闭，面向功能拓展开放，只允许功能拓展，不允许修改原来的。

   *这个功能的修改被称作方法的重写*重写和父类的方法签名一致*

   *修改的是子类的功能，父类的功能没有改变。

   *重写时，子类必须有权限去重写父类的功能，父类的private和final方法不能被重写。

   *子类的方法修饰符权限>=父类被重写方法的修饰符权限，

   *子类继承父类方法时不能降低父类方法的可见性。

   *子类重写父类方法只是修改了子类的功能，父类的功能不被影响。

   *重写父类方法时不能改变方法的名字和返回值。

93.父类的构造方法不能被子类继承。

94.子类的构造方法中，默认存在super()，也就是创建子类对象时会默认调用父类的无参构造。

95.如果父类中没有无参构造，这时调用的就是含参构造super(实参)，super(实参)这种需要写才存在。

96.创建子类对象时默认会先看父类的无参构造方法。

97.如果发生了重写，还需要调用父类的方法，要使用super.来调用。

98.*this(""）代表调用本类的含参构造，括号需要加上实参

   *this() 代表调用本类的无参构造

   *super() 代表调用父类的无参构造

   *super("") 代表调用父类的含参构造，括号需要加上实参

   *this 和super调用方法时必须写在第一行，二选一,两个不能都写。

99.static资源也就是类的静态资源,静态资源特征：

   * 可以修饰成员变量与成员方法

   * 随着类的加载而加载，优先于对象加载

   * 只加载一次，就会一直存在，不再开辟新空间, 直到类消失才一起消失

   * 静态资源也叫做类资源,全局唯一,被类所有对象共享

   * 可以直接被类名调用

   * 静态只能调用静态，非静态可以随意调用（非静态或静态）

   * static不能和this或者super共用，因为有static时可能还没有对象

100.静态代码块 构造代码块 构造方法 普通方法 局部代码块的加载顺序:

   * 在创建对象之前会自动加载静态代码块static{}，且只加载一次

   * 在创建对象时会自动调用构造代码块和构造方法，构造代码块先执行

   * 当通过对象调用方法时，若方法里有局部代码块，局部代码块才会执行

   * 再次创建对象，静态代码块也不会再加载了*/

   * 代码块的执行顺序：静态代码块-->构造代码块-->构造方法-->普通方法-->局部代码块。

101.如何判断一个方法该不该写返回值？没有强制要求，写不写返回值取决于程序设计的思路

    如果想在方法外部继续使用这个方法的结果，就需要写返回值。

    如果只是在方法调用时输出结果，就无需返回值。

102.main方法是入口函数，也必须用static修饰

103.静态资源里面不能写super.和this.因为静态资源优先于对象加载，那时候还没有产生对象

105.父类和子类的各种代码块执行顺序：

    a.父类静态代码块

    b.子类静态代码块

    c.父类构造代码块

    d.父类构造方法

    e.子类构造代码块

    f.子类构造方法

    g.子类重写父类的方法

    h.子类局部代码块

106.private让子类不能用,final让子类不能改

107.多态的前提条件：1.要有子类继承父类 2.要有方法的重写

108.多态的特征：1.父类引用指向子类对象 2.编译看左边运行看右边

109.多态的例子：例如 花木兰替父从军，用父亲的名义去参军打仗，只能用父亲的方法

110.异常的继承结构：

    Throwable:可抛出

         -Erro：系统错误，不可修复错误

         -Exception：可修复错误

          -RunTimeException:运行时异常,这类异常不受检查

           -ClassCastException

           -ClassNotFoundException

111.遇到异常要么向上抛出throw，要么捕获try{代码块} catch{异常类型 异常名}{解决方案}

112.同一种事务的多种表现形式，可以把子类当做父类来看，统一/简化调用标准。

113.实现多态的前提：继承+重写，多态特点：父类引用指向子类对象，编译看左运行看右

114.多态的使用：成员变量是父类的，成员方法：父类的声明&子类的实现，

    多态中如果父子类中都有同名静态方法，调用的静态方法使用的是父类的。

115.多态：Father f=new Son();把子类对象赋给父类引用属于向上转型。

    Son s=(Son)f;把父类引用f强转为子类Son对象，属于向下强制转型。

116.静态方法可以继承，但是静态方法不能被重写，父类和子类可以有同名的静态方法,静态方法直接用类名.调用

117.抽象类中可以没有抽象方法，抽象类不能实例化，不能创建对象

118.抽象方法要求子类继承后必须实现抽象方法，

    private：私有资源，子类不可见不可继承，但是abstract类需要子类来实现，这样就矛盾

    final：final资源不可被继承，但是abstract需要子类来实现，这样就矛盾，所以不能与abstract搭配

    static:静态优先于对象存在，所以abstract不能与static搭配使用

119.接口与接口的关系：

    是继承关系,可以单继承,也可以多继承

interface A extends B,C{}

其中ABC都是接口,

    A是子接口,具有B,C接口的所有功能(抽象方法)

class X implements A{}

X实现类需要重写ABC接口的所有方法,

    否则就是抽象类

class A extends B implements C,D{}

其中A是实现类,也是B的子类,同时拥有CD接口的所有

    功能

这时A需要重写CD接口里的所有抽象方法

120.抽象类与接口的区别：

    抽象类是一个特殊的类,特殊在抽象类中可以包含没有方法体的方法(抽象方法)

    接口可以理解成一个特殊的抽象类,特殊在接口里的都是抽象方法,java8以前接口里没有普通方法

    接口里会为抽象方法自动拼接public abstract,还会为变量自动拼接public final static

    抽象类可以有构造方法，用来给子类创建对象,接口中没有构造方法，接口的实现类调用的Object类的构造

    抽象类和接口都不能实例化就是不能创建对象

    接口可继承接口，并可继承多个接口，但类/抽象类只能单继承

    接口是设计的结果，抽象类是重构的结果

    接口一般先继承再实现，面向接口编程，创建接口，抽取共性，形成抽象层，体现接口。

121.idea里面的project是工作空间而不是工程，这个跟eclipse不同。

121.数组的定义书写

    *一维数组：1)int[] x;2)int x[];

    *二维数组：1)int[][] y;2)int y[][];3)int[]y[]

    *例:int[] x,y[];? ?//定义了一维数组x，二维数组y

122.返回值是引用类型时，子类的返回值类型要小于/等于父类的返回值类型

123.子类的异常抛出的类型要小于/等于父类的抛出异常的类型

124.子类重写父类的方法时，子类的方法可见范围要大于等于父类的方法的可见范围，

    比如父类方法是protected，子类可以是public。

125.二维数组里面的一维数组长度可以不一样。

126.数组的长度可以为0，比如String [] s=new String[0];

127.String类重写了equlas()，默认比较的是值，如果值相同，则比较结果为true.而==比较的是两个对象的地址值。

128.正则表达式的组件可以是单个的字符、字符集合、字符范围、字符间的选择或者所有这些组件的任意组合。

129.FileOutputStream(String name) 创建一个向具有指定名称的文件中写入数据的输出文件流。

       FileOutputStream(File file) 创建一个向指定 File 对象表示的文件中写出数据的文件输出流。

       FileOutputStream(File file, boolean append)创建一个向指定 File 对象表示的文件中写入数据的文件输出流。

130.代码块执行顺序是：静态代码块 > 构造代码块 > 构造方法。

131.Java 中的字节流处理的最基本单位为 1 个字节，通常用来处理二进制数据，字节流操作的基本单元是字节

      字节流类 InputStream 和 OutputStream 类均为抽象类，代表了基本的输入字节流和输出字节流 ，

     Java 中的字符流处理的最基本的单元是 Unicode 代码单元（大小2字节），通常用来处理文本数据。

     字符流操作的基本单元是字符，字节流默认不使用缓冲区，字符流使用缓冲区

     按行处理、比较特定字符的时候一般会选择字符流；仅仅读写文件，不处理内容，一般选择字节流

132.流都是单方向的，所以输入流只能用来读取数据，输出数据只能用输出流。

133.Java编码顺序：

    1.）抽取共性形成类：如Phone/Student/Teacher，类名是大驼峰。

    2.）属性：成员变量，属性可以是基本类型变量，也可以是对象，私有属性可以封装，并提供公有set,get方法

    3.）静态代码块：类加载的时候加载，只加载一次，静态资源在类对象中是共享的

    4.）构造代码块：用于提取构造方法中的共性内容，如果有共性需要提取，可以写构造代码块。

    5.）构造方法:无参和含参，用于本类或子类创建对象用

    6.）普通方法/成员方法：完成一些业务功能。

    7.）局部代码块：要写在方法里，用一对花括号括起来，调用方法时才执行。

134.面向对象三大特征:

    封装：private，私有标记

    继承:extends，子类继承父类的属性和方法，但是私有的属性和方法不可继承

    多态:向上转型/装箱，把子类对象看做父类类型-花木兰替父从军

    向下转型：（子类）多态对象

135.多态最主要的作用是提供通用解决方案，统一调用标准。

136.super可以理解为父类对象的一个引用，super（）表示调用父类的构造方法，super（实参）调用父类含参

137.静态资源只能调用静态资源，非静态可以调静态和非静态。

138.重载和重写：

    重载：同一个类里，方法名相同，参数列表不同

    重写：父类和子类里，方法签名一致，方法体不同，子方法修饰符>=父方法修饰符。

139.接口里没有成员变量，可以有常量，比如int a=10；

140.接口不可以创建对象，一般用接口的实现类来创建对象。

141.print方法默认会调用toString方法，该方法默认会打印对象的哈希码值整数，可以重写toString方法

142.哈希码值可以是负数，同一个对象的哈希码值可以发生变化.

143.==和equals的区别：

　　1）对于==，如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；

　　　 如果作用于引用类型的变量，则比较的是所指向的对象的地址；

　　2）对于equals方法，注意：equals方法不能作用于基本数据类型的变量

　　　 如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；

　　　 诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。

144.高效字符串StringBuffer和StringBuilder优化了String拼接的效率，时间利用效率比String快千倍。

145.String s1="ab";String s2=new String("ab");String s3="a"+"b";String s4="a";s4+="b";

    创建字符串常量时，栈指向堆，堆指向方法区运行时常量池。

146.String s1="ab";String s2=new String("ab");String s3="a"+"b";String s4="a";s4+="b";

    创建字符串常量时，栈指向堆，堆指向方法区运行时常量池。

147.lang包无需导包也存在

148.顶级父类Object中的常用方法：

    toString默认返回的是地址值，重写后是打印：类型+属性值。 

    hashCode返回哈希码值, 哈希码值是把地址转换为整数，不同对象的哈希码值不一样

    equals默认是比较地址值，重写后是比较属性值

149.正则表达式，加了中括号[字符]表示字符取值范围，多选一/其中一个，横杠-表示从起点到终点，^表示取反或匹配行首，$匹配行尾，|表示或/并列，

    \w小写字母，\W表示排除小写字母，\d表示数字，\D表示排除数字，花括号{ }表示字符出现的次数，（）括号表示分组。

    JS里面写正则表达式需要用//斜杠包起来。

150.包装类Integer有高效的效果，高效的范围是（-128--127）在此范围内创建相同的数据的对象，

    只会存一次，后续再存都会使用之前的对象，超出范围就会重新创建对象，只有Integer有高效效果。

151.BigDecimal的小数四则运算是精确的，普通的四则运算，遇到小数乘除会不精确

152.BigDecimal bd1=new BigDecimal(d1+"");//用此种方式需要拼接空字符串“”否则会不精确。

153.Stream:字节流，处理二进制数据，分为输入inputStream和输出OutputStream

    字符流：用于处理字符文件，分为输入Reader和输出Writer

    File:文件类，文件和目录（文件夹）路径名的抽象表示形式。

154.字节流里面的读操作：int b;

            while((b=in2.read())!=-1){//这里是固定写法，表示读/赋值/判断同时进行，

            //这样才不会少读或者越界

                char c=(char)b;

                System.out.print(c+"*");

            }

155.File不是抽象类，可以创建对象，比如File f=new File("path");//path可以是文件路径，

    或者不存在但要创建的路径，或者父级路径+文件名。

156.字符读入流Reader和Writer是抽象类 不能直接new。

157.字节流Stream也是抽象类，不能直接new

158.字符流Reader和Writer读写复制文本文件有用，其他文件比如exe视频或者音乐图片等它搞不定

159.字节流Stream可以读写复制二进制文件，只要是计算机的二进制文件都能读写和复制

160.用IO流读写操作完之后，流资源必须关掉，关流是有顺序的，后创建的流先关闭

161.FileWriter里面append参数可以加个true表示不覆盖原有数据

162.序列化：ObjectOutputStream把对象序列化为二进制数据后输出保存到磁盘中。

    反序列化：ObjectInputStream读取磁盘中序列化的数据，并恢复为对象到程序中（内存）。

    可以用序列化和反序列化实现深拷贝.

    实际编码中用json格式序列化较多.

163.类的对象需要如果要能序列化，必须要实现序列化的接口，implements serilizable。

164.类属性里如果手动添加了固定的serialVersionUID，则可以多次反序列化

165.类属性里如果没有添加serialVersionUID，则序列化和反序列化要成对每次匹配，一次序列化匹配一次反序列化。

166.类里如果不手动添加serialVersionUID，修改类的属性(包括UID属性)之后要重新序列化，否则反序列化会报错。

167.最后再补充两点， 哪些字段是不能被序列化的呢：

    static 修饰的， 因为序列化操作是对于堆区 ，而static的在全局区。

    transient 修饰的字段 ，在使用implements Serializable 的时候，也是避开序列化的。

168.简单的问题用 数据结构可以解决，更难的问题需要数据结构+算法才能解决。

169.字节流一次读一个字节，字符流一次读一个字符。

170.泛型在编译后会被删除，所以在.class字节码文件中不存在泛型，泛型不影响JVM的运行。

171.ArrayList底层是数组结构，查询快增删慢；LinkedList底层是链表结构增删快，查询慢。

   查询的快慢是指数据量大时的查询快慢。

172.遍历是为了对单个元素进行处理。

173.HashMap底层是一个Entry[ ]数组,当存放数据时,会根据hash算法来计算数据的存放位置

算法:hash(key)%n ,

    n就是数组的长度,其实也就是集合的容量

当计算的位置没有数据的时候,会直接存放数据

当计算的位置,

    有数据时,会发生hash冲突/hash碰撞,解决的办法就是采用链表的结构,在对应的数据位置存放链表的头节点,

    对于这个链表来说,每次新加的节点会从头部位置开始加入,也就是说,数组中的永远是新节点.

174.HashMap的底层结构：数组+链表（如果链表长度超过8会转成红黑树，低于6又退回链表）

175.Hashmap的默认初始容量是16，增长因子(临界点Threshold)是0.75，比如长度达到12，也就是达到初始容量的75%

    就要扩容，每次扩容2倍，比如从16扩容成32，再扩容就是64。

176.分时系统的线程有随机性，不分轻重缓急

177.不同线程微观上是分时切换进行的，宏观上是同时进行的。

178.线程的三种状态：就绪状态，运行状态，阻塞状态，终止。

    就绪相当于，乘客进了火车站候车室，运行相当于，乘客从候车室进了火车。

179.StringBuffer或StringBuider是高效字符串里面有append(添加)，reverse(逆序)，insert(插入),

    replace(替换)等方法。

180.Collection是单列集合的接口，Map是双列集合的接口，

    Collections是集合的工具类，里面有操作Collection集合的各种方法。

180.ArrayList:线程不安全，每次增长1.5，如果无参构造，增长到10，再每次增长1.5倍，底层是可变数组

    Vector:线程安全，每次增长2倍，底层是可变数组

    HashSet:无序，单列数据，无索引，不可重复，每次增长2倍，底层是：数组+链表+红黑树

    TreeSet:有序，单列数据，数据不可重复，默认按照字典排序,元素对象需要实现Comparable接口

    HashMap:无序，双列键值对数据，不可重复，初始容量16，每次增长2倍，加载因子0.75(达到阈值就扩容)，底层是：数组+链表+红黑树

    Properties:是HashTable的子类，并实现Map接口，Properties可以用于从.properties文件中读取数据并加载到对象中

181.Comparable比较器不能用于基本数据类型的比较，基本数据类型需要转为包装类才可以比较，

    只能用于类对象的比较，需要明确比较的规则，才能比较。

182.设计企业级散列表需要考虑的：hash冲突，空间，时间，线程安全，性能，高并发。

183.继承Thread类

优点: 编写简单,如果需要访问当前线程,无需使用Thread.currentThread()方法,

    直接使用this即可获得当前线程

缺点: 自定义的线程类已继承了Thread类,所以后续无法再继承其他的类

    实现Runnable接口

优点: 自定义的线程类只是实现了Runnable接口或Callable接口,后续还可以继承其他类,在这种方式下,

    多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,

    从而可以将CPU、代码、还有数据分开(解耦),形成清晰的模型,较好地体现了面向对象的思想

    缺点: 编程稍微复杂,如想访问当前线程,则需使用Thread.currentThread()方法

184.如何判断程序有没有线程安全问题：

    多线程中，如果有静态共享资源，多个线程同时操作（写操作）静态共享资源，会产生线程安全问题（数据不同步导致）

185.CPU：读取数据，数据寄存，计算，写出数据。

186.程序：比如.exe文件，进程：进入内存的程序，线程：程序的最小单元。

187.线程由OS操作系统调度。

188.线程切换：保存旧线程，执行新线程，恢复旧线程。

189.同步方法，如果一个方法里所有的代码都需要同步，那就在方法前加synchronized.

190.同步代码块:synchronized（o）{同步代码块（范围需要调试）}，

    其中参数o是Object对象要在成员变量处申明。

191.StringBuilder效率快，但是线程不安全，StringBuffer线程安全。

192.创建线程池对象:ExecutorServi