程序员编程笔记

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

  • 2
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
程序员学习笔记app是一款为程序员打造的学习工具,旨在帮助他们提高学习效率、管理学习内容,并激发学习动力。 首先,该app提供了丰富的学习资源和教程。程序员可以在app中浏览各种编程语言、框架和工具的教程,学习专业知识和技能。这些教程不仅简明易懂,还包含大量的实例和代码,程序员可以通过实践巩固学习成果。 其次,该app具有个性化学习管理功能。程序员可以根据自己的学习目标和阶段,设置学习计划和提醒。例如,可以设定每天学习一定时间,或者每周学习特定主题。同时,app还提供了笔记功能,方便程序员记录学习心得、难点和解决方案。这些笔记可以随时查看和编辑,帮助程序员进行复习和总结。 另外,该app还提供了学习进度统计和反馈。程序员可以查看自己的学习时间、完成的教程和理解程度等信息,了解自己的学习情况和进步。同时,app还会根据学习情况给出相应的建议和鼓励,让程序员感到自己的努力得到了认可和支持。 最后,该app还具有社交化功能。程序员可以在app上与其他学习者交流、分享学习心得和经验。他们可以发布问题并得到他人的解答和帮助,同时也能从他人的经验中获得启发和提升。这种社区交流的环境可以激发程序员的学习热情和团队合作精神。 总之,程序员学习笔记app通过提供学习资源、个性化管理、学习反馈和社交交流等功能,有效地帮助程序员提高学习效率和成果。这样的学习工具将成为程序员们的得力助手,助推他们在编程领域的进步和发展。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

黑客&画家

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值