JAVA知识点梳理

我的博客：lcatake_flume,spark,zookeeper-CSDN博客

看不懂的话进去看看

1.Java的三个版本

JAVASE 基本

JAVAME 微缩

JAVAEE 标准

3.java的特点

面向对象

跨平台：jvm将java文件转变为字节码文件（.class）在多个系统中运 行字节码文件

5.Java的三个组件

JDK 语言开发包

JRE 运行环境

JVM 虚拟机

6.基本数据类型

 整数：byte(1字节) short(2) int(4) long(8)

浮点：float(4) double(8)

 字符串：char(2)

布尔：boolean 

5.基本数据类型精度

byte<short<char<int<long<float<double

6.  基本数据类型之间的转换规则

1.低精度给高精度 自动转换

2.高精度给低精度 强制转换

 3.不同类型进行运算时，先将低精度转为高精度，精度一致后再进行计算    

7.break,continue

break 跳出循环

cotinue 跳出本次循环

8.三目运算符 

判断条件?条件满足:条件不满足

9.switch 数据类型 

buty,short,int,char,String

10.while do..while区别

while 先判断后执行

switch 数据类型 buty,short,int,char,String

11.获取控制台的信息

Scanner s1=new Scanner(System.in);

while (s1.hasNext()){

String str1=s1.next();

12.数组的缺点

必须要指定数组长度

13.创建多维数组:

1.int[ ][ ]  a1=new int[3][ ];

a1[0]=new int[1];

2.int[ ][ ]  a1=new int[3][ ];

3. int[][] a3={{1},{2,3},{4,5,6,7},{7,4,5,1}};

14.冒泡排序

 int[] arr = {2, 11,4,7,5,22,15,37,12,1};

int zjvalue = 0;//中间值

boolean boo=false;

//冒泡比较相邻元素将小的提前打的放后

//外层循环时用来控制轮数

//内存循环控制每一轮的；排序

//每个元素都走完一遍全部的长度

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

boo=false;

//每一轮排序都会将最大的一个排到最后 所以-i

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

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

//存储小的值

zjvalue = arr[j];

//把大的值赋给小的

arr[j ] = arr[j+1];

//把小的值赋给大的

arr[j+1] = zjvalue;

}

boo=true;

}

if (boo==false){

break;

}

}

for (int a : arr) {

System.out.print(a + ",");

}

System.out.println();

15.杨辉三角

int[][] arr=new int[7][];
for (int i = 0; i < arr.length; i++) {
arr[i]=new int[i+1];
}
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j <arr[i].length ; j++) {
if (j==0||j==arr[i].length-1){
arr[i][j]=1;
}else{
arr[i][j]=arr[i-1][j]+arr[i-1][j-1];
}
}
}

for (int i = 0; i < arr.length; i++) {
for (int j = 0; j <arr[i].length ; j++) {
System.out.print(arr[i][j]);
}
System.out.println();
}

16.递归算法的条件

递归：

//1.有出口

//2.有递归算法

17.数组的三个方法

1.是否相等 Arrays.equals

2.复制：system.arraycopy

arraycopy(Object src,  int  srcPos, Object dest, int destPos,int length);

3.排序Arrays.sort

18.String的方法 （至少十个）

1。charAt() 

2。replace() 替换字符串 ,replace(旧内容，新内容) 全部对应元素都要改变 str2.replace("a","q");

3。isEmpty() 判断字符串是否为空 

4。concat() 连接字符串

6。indexOf() 查询字符第一次出现的位置 

7。lastIndexOf() 查询字符最后一次出现的位置

8.endsWith() 判断字符串是否以。。。结尾

9。toUpperCase()

10。toLowerCase() 

11。contains() 

12。subString() 截取字符串

13。split() 拆分字符串，变成数组

14。equals() 判断字符串是否相等 

15。compareTo() 比较两个字符串

1.如果相同返回0；

2.第一次不同如果是数值,返回长度差

第一次不同如果是字符,返回两个字符的Ascrll码的差值

16. startsWith("a");以。。开始

17.lenght() 数组长度

19.Math的方法10个

1.Math.max(20.0,10) 最大值 二选一

2.Math.min(20.0,10) 最小值

3.Math.abs(2-1) 绝对值

4.Math.ceil(9.1)相上取整 浮点数

5.Math.floor(8.9) 向下取整

6.Math.round(8.6)四舍五入

7.Math.pow(x,y) x的y次幂'

8.Math.sqrt(64)开平方

9. Math.random()[0,1)随机数

10.Math.PI 圆周率

20.全局遍历和局部变量的区别

//【区别】:1.初始值不同：成员变量有系统给定的默认值

//局部变量没有初始值 需要使用必须赋予初始值

//2.作用域:成员变量可以在整个类中使用；

//局部变量只能在声明的区域内使用

//3。内存地址不同：成员变量存储在堆，局部变量存储在栈

21.什么是面向对象及其特征

//1.面向对象：面向对象是一种编程思想，所有的操作都是针对对象的属性和方法进行操作

//万事万物皆对象

// 2.面对对象的特征：封装，继承，多态，抽象

22.什么是类什么是对象

//3。类：class,类就是描述事物的抽象概念，可以看作一类物的模板

//4.对象：对象就是类的具体实例

//5.类与对象的关系：类是对象的模板，对象是类的实例

23.构造方法

//【构造方法】：1.没有返回值也不用加void

//2.方法名和类名一样

//构造方法：默认无参构造方法--当没有 有参构造方法时，可写可不写，系统默认提供

//当有了构造方法 需要使用无参构造方法时，必须写出来无参构造；

24.值传递与==

//值传递：

//1.基本数据类型传递的是值

//2.类类型传递的是地址

//==

//1.基本数据类型比较的是值

//2.类类型比较的是地址

25.静态

//关键字 static:静态

//静态修饰的对象： 变量 方法 代码块

//静态修饰的变量：1.调用方法： 引用.静态变量；类名.静态变量

//2.在类加载到内存时，还没有创建对象就已经分配了内存

//3.静态只能调静态

// 静态修饰 的方法：1.静态方法只能访问静态成员变量

//2.静态方法中，不能使用this和super

//3.静态方法只能调用其他的静态方法；不能调用其他实例方法

//静态修饰的代码块：类的加载顺序1.静态代码块在没有创建对象之前，【主动执行一次】

//2.非静态代码块，在【每次】创建对象之前都会主动执行一次

26.封装的概念及其可见性和好处

//【封装】：java把变量和方法封装到类中，通过可见性实现封装

//可见性：

//1.public：公共的 在工程中可见

//2.protected:受保护的，当前类可见，本包可见，外包的子类

//3.default: 不写的时候(默认) 本类，本包可见；

//4.private:私有的，本类可见

//【封装的好处】：1.提供方法名供外界调用

// 2.对内隐藏数据，防止被破坏

27.包装类已经自动装箱，自动拆箱

//int------Integer *

//char---Character *

//【自动装箱】:把基本数据类型转换成对应的封装类

//【自动拆箱】：把封装类转换成基本数据类型

28.重载与重写 

【重载 Overload】:在同一个类中 方法名相同，参数的个数或类型不同；

//【重写 @Override】 ：在子类重写父类方法时，同名，同参，同返回类型 ；

//重写后的子类的可视性不能比父类的可视性更严格

29.有继承关系的加载顺序

//（前两步）只执行一次

//父类静态代码块

//子类静态代码块

//（后四步）每次对象创建就执行一次

//父类非静态代码块

//父类构造方法

//子类非静态代码块

//子类构造方法

30.//【继承关系中的构造方法】

// 1.父类和子类都没有构造方法时，系统会给父类与子类分别提供默认的无参构造方法（父类只提供父类，子类提供父类和子类）

//2.如果父类存在有参构造方法，子类必须在构造方法的第一行用super(传参)调用父类的构造方法

31.【super】

//1.区分父类的成员变量和子类的成员变量

//2.子类可以在第一行用super(传参)调用父类的构造方法

//3.子类可以在实例方法用super.实例方法 来调用父类的实例方法

32.This

1.区分成员变量和局部变量

//2. 在构造方法的第一行,用this(传参)调用其他的构造方法

//3.在实例方法使用this.方法名调用其他的实例方法

// 33. 【final】

 1.final 定义的量叫常量，一经修改就不能改变

//2.final 修饰的类不能被继承

// 3.final 修饰的方法不能被重写但可以重载

34.// 【向上转型】 【向下转型】 动态绑定

//【向上转型】:父类的引用指向子类的对象

//1.只能调用父类的方法和父类的属性,不能调用子类的方法和属性；

//2.如果子列重写了父类的方法，调用的是子类的重写方法

//【向下转型】:父类的引用 赋值给子类的引用

//1.可以调用父类和子类的属性和方法

//2.父类的引用必须是：向上转型的引用

  3.向下转型的子类必须和向上转型的子类一致

动态绑定 ：在执行期间 而非编译期间，判断引用的类型，根据实际情况调用方法和属性

35.抽象及其在描述抽象时不可以使用的关键字

//[抽象]:共性的内容抽取到父类,但是某些内容无法在父类中具体实现

//1.抽象方法只有方法声明,没有方法体({})

//可见性 abstract 方法名();

//2.包含抽象方法的类必须声明为抽象类

//3.抽象类里可以有实例反法,构造方法和属性

//4.抽象类不能直接new对象,用来给子类new对象和初始化成员变量

//5.继承抽象类的子类,必须重写父类所有的抽象方法

//final因为final类 不能继承,final方法不能被重写

//static 在类加载时已经分配了内存,无法继承和重写

//private仅本类可见,外包无法访问

//使用抽象方法: 必须要重写,有共性

36.接口

//[关键字]:声明接口 interface

//:实现接口 implements

//1.默认被 public static final 修饰的静态常量;

//2.不能写构造方法

//3. 默认被public abstract修饰的抽象方法

//4.接口可以多实现,用","分割

//5.接口可以继承接口 可以【多继承】（java单继承）

//接口 extends 接口1，接口2.。。

//6.如果类是带有继承关系的接口，

//那就需要把所有父接口和子接口的抽象方法全部实现一遍

 接口回调 

接口的对象指向了 （已经实现了此接口）类的对象

// 这个变量只能调用此接口和父接口在实现类中重写和方法和属性（此接口）

37.java集合体系

//6个接口： 单列 :Collection,(父接口)

// 1.List 有序（有下标，存储位置）（不能去重）

// 2.set 无序（无法使用下标）（可以去重）

//2.1 SortedSet

// 多列：Map

// 1.SortedMap

//一个工具类：Collections

38.[泛型]：

在集合中用来规定集合的类型

List： 实现类，及其区别

Arraylist 2.LinkedList

//1.ArrayList底层是数组存储，LinkList底层是双向列表

//2.ArrayList适合查找，LinkList适合增删

39.List的常用方法

//1.添加元素(在末尾添加，指定位置添加)add可以添加null 并在集合中出现 返回的是布尔类型

//2.删除元素 remove

//3.清空集合

//4。判断是否为空 isEmpty() 

//5.查看集合是否包含某个元素 contains

//6.查找元素下标 indexOf

40.遍历集合三种

//1.for-each循环 元素 集合是整数类型，当有null不能使用，会有空指针异常

for (int i:list1){

System.out.println(i);

}

//2.下标长度 list1.size() 获取值 list1.get(i)

for (int i=0;i<list1.size();i++){

System.out.println(list1.get(i));

}

//迭代器 Iterator 是一个接口 提供了遍历集合的方法

Iterator<Integer> it = list1.iterator();

while(it.hasNext()){

System.out.println(it.next());

}

41.// LinkList 独有的方法

//独有的 打印第一个值：list2.getFirst()

//打印最后一个值：list2.getLast()

//删除第一个值： list2.removeFirst();

//删除最后一个值：list2.removeLast();

42.集合 数组互转

//List和数组转换

//1.集合转数组list1.toArray();

//2.数组转集合Arrays.asList(brr);

Set及其接口的实现类和子接口实现类的区别

//【Set】:继承于Collection集合(无序)

//实现类：HashSet

//【SortedSet】:set的子接口

//实现类：TreeSet

//HashSet

//1.去重，可以添加空 不可以选择添加的位置

//2.for-下标 不能使用 s1.get（i）报错

//3.indexOf 无法使用

//TreeSet

//1.不能添加null,按照数字，字母顺序排序，去重，无法通过指定下标写入

//2.for-下标 不能使用 s1.get（i）报错

//3.indexOf 无法使用

//4.不能添加存储类类型 需要重写compareTo方法；

重写equals

@Override

public boolean equals(Object obj){

// 对比的双方是本体 this指向前面的引用名

if (obj==this){

return true;

}

if (obj instanceof People){

People pp=(People)obj;

return pp.sfz.equals(this.sfz);

}else {

return false;

}

}

//在重写equals时，必须重写hashCode

@Override

public int hashCode() {

return Objects.hash(sfz);

}

Map的实现类与实现类的特点与区别

//【Map】:双列集合，键值对形式存储，映射关系(kay,value)

//实现：HashMap

//子接口：SortedMap Map的子接口

//实现类：TreeMap

//HashMap

//1。可以插入null

//2.key不可以重复 会覆盖value值

//3.value值可以重复

// TreeMap

1.key不可以为null

//1.添加 put 返回值不是布尔类型

获取key value和key value对（方法和返回值类型就行）

//2.遍历 普通for循环无法使用get

//1.key

//keySet() 返回值为Set集合 Key为int 存储不能为null

 Set<Integer> setkey= m1.keySet();

for (int i:setkey){

System.out.print(i);

}

System.out.println();

//2.value

//values() 返回值为Collection

 Collection<String> cc=m1.values();

 Iterator it=cc.iterator();

 while (it.hasNext()){

 System.out.println(it.next());

// 3.key和valueentrySet 返回值为Set<Map.Entry<ket类型，value类型>>

Set<Map.Entry<Integer,String>> entry= m1.entrySet();

for (Map.Entry<Integer,String> en:entry){

System.out.print("key:"+en.getKey()+","+"value:"+en.getValue());

System.out.println();

}

Iterator it3=entry.iterator();

while (it3.hasNext()){

System.out.println(it3.next());

}

常见异常

//1.ArrayIndexOutOfBoundsException 数组下标越界异常

// 2.StringIndexOutOfBoundsException 字符串下标越界异常

//3.NullPointerException 空指针异常

//4.ClassCastException 类转换异常

//5.ArithmeticException 算术异常

//6.NumberFormatException 数字转换异常

50. 【异常的五个关键字】

// try： 指定一个代码块预防所有异常，需要紧跟catch

//后面可以跟多个catch,按照异常顺序捕获异常

//如果有0个catch必须跟上finally

//catch：放在try后面，用来捕获异常类型

//finally: 无论是否发生异常,fianlly都会执行

//在return之前执行.

//

//throws:放在方法名后面主动抛出异常;

//throw:放在方法体里,主动抛出异常;

51. [自定义异常];

//1.新建异常类,继承Execption类,创建构造方法,设置message信息

//2.在需要的地方 用throw new 新的异常类 来抛出异常

52.File的方法

System.out.println(f1.getPath());//地址

System.out.println(f1.getAbsolutePath());//绝对地址

System.out.println(f1.getName());//文件名

System.out.println(f1.exists());//文件是否存在

System.out.println(f1.length());//文件大小

System.out.println(f1.lastModified());//最后一次修改的毫秒数

//获取父目录 getParent() 返回String
        getParentFile() 返回File

//创建文件 createNewFile() 文件前的地址一定要存在否则报IoExecption

//创建目录

//mkdir 如果地址不存在 返回false 创建失败

//mkdirs 如果地址不存在 会把所有的父级目录全都创建一次

//创建文件 createNewFile() 文件前的地址一定要存在否则报IoExecption

//创建目录

//mkdir 如果地址不存在 返回false 创建失败

//mkdirs 如果地址不存在 会把所有的父级目录全都创建一次

//【i/o体系】：及其创建

//1.处理单位：字节流，字符流

// 2.处理流向：输入流，输出流

//3.处理功能：节点流，处理流

字节：

FileInputStream input=null;

FileOutputStreamoutput=null;

input=new FileInputStream(path); output=new FileOutputStream(path)

字节处理流：

BufferedInputStream input = null;
BufferedOutputStream output = null;
input = new BufferedInputStream(new FileInputStream(path));
output = new BufferedOutputStream(new FileOutputStream(path)

字符：

FileReader input = null;

FileWriter output = null;

input = new FileReader(path;

output = new FileWriter(path);

字符 处理流

BufferedReader input = null;

BufferedWriter output = null;

input = new BufferedReader(new FileReader(path) {

});

output = new BufferedWriter(new FileWriter(path));

54.字节流和字符流用于读取什么文件

//字节流：适合处理音频，视频，图片读取汉字 分成三个数字

//字符流：通常适合用于处理汉字多的文本文件 读取汉字 分成一个数字

Write和append的区别

write 不可以写空 append可以为空

Write穿的是 int 和byte

append可以直接串String