zzz‘sJava知识点概括总结

类型转化

字符串：c语言：char Java：string

表达式值的类型由最高类型决定：

取值范围：byte<short<int<long<float<double（且运算时byte和short都是转化为int类型进行计算防止数据溢出）

强制转换数据类型：大范围的赋值给小范围（但可能会导致数据丢失溢出，如浮点型转为整型会直接丢掉小数，保留整数）

运算符：

逻辑运算符：

&&（短路与）从左边开始运行，如果左边false，则右边不运行

||（短路或）从左边开始运行，如果左边true，则右边不运行

&&优先级高于||

&或者|左右都要执行

算术运算符：

当字符+字符或者字符+数字时会先把字符通过ASCII码表查询到对应的数字再进行计算

赋值运算符：底层下都隐藏了一个强制类型转换

三元运算符：

条件表达式b?x:y;，先计算条件b，然后进行判断。如果b的值为true，计算x的值，运算结果为x的值；否则，计算y的值，运算结果为y的值。

拓展：

case穿透：语句体中未写break导致

流程跳转语句：

break：在switch中结束case条件判断，在循环体中结束循环

continue：作用在循环体中，结束循环体的本次循环，从而进入下次循环

多个数组变量对应同一个地址：

数组1的地址被赋给数组2，则两数组的地址是相同的

代码块：

局部代码块：节省内存空间

构造代码块：写在成员位置，可以把多个构造方法中重复的代码抽取出来。创建本类对象的时候会先执行构造代码块再执行构造代码。

静态代码块：随着类的加载而加载，并且只执行一次。

数组：

地址值：

D：表示当前数组内元素是double类型的

索引

=>下标，从0开始

最大索引：数组长度-1

把数据存储到数组中，一旦覆盖之后，原来的数据就不存在了

数组的遍历：

是取出数据的过程，遍历≠打印

数组的长度属性：

数组名.length

数据类型的默认初始值：

1.整数类型：0 2.小数类型：0.0

3.字符类型：空格 4.布尔类型：false

5.引用数据类型：null

动/静态初始化：

动态初始化：明确元素个数

静态初始化：明确具体元素内容

随机数读入：

打乱数组：

二维数组：

二维数组的length属性：

public class ArrayTest4 {public static void main(String[] args) {int[][] a ={{1,2,3},{10,20,30,40,50},{6,7,8,9},{0}};System.out.println(a.length);//指二维数组中有几个大括号//输出4System.out.println(a[0].length);//指{1,2,3}的长度//输出3}
}

二维数组的元素访问：

a[二维数组中的一维数组的下标][一维数组的小标]

a[0][0]:表示第一个一维数组中的一个一维元素。

遍历：

public class ArrayTest5 {public static void main(String[] args) {String[][] array = {{"java","oracle","c++","python","c#"},{"张三","李四","王五"},{"lucy","jack","rose"}};for (int i = 0; i < array.length; i++){for (int j = 0 ; j < array[i].length ; j++){System.out.print(array[i][j] + " ");}System.out.println("");}}
}

方法：

类似于c语言的函数

注意：Java中没有指针，但是改变数组数据时是对地址中数据改变（类似于指针操作，但仅限于数组中）称之为引用传递。

方法重载：

数组遍历：

方法的内存分配：

数据类型：

基本数据类型：变量里面存储的是真实数据

引用数据类型：例如数组，new出来的类型

变量里面存储的是地址值

引用：使用了其他空间的数据。

方法的值传递：

方法引用：

静态方法内不存在this和super

示例：
把字符串改为大写：
方法1.内部类

方法2.方法引用：

引用数组的构造方法就是为了构建一个数组。

泛型当中不能写基本数据类型。

数组的类型需要跟流中的数据类型保持一致，也就是说一开始是什么类型的容器去储存数组后面也要是什么类型的容器。

面向对象：

类似于c语言的结构体，但具有储存方法，可以直接调用方法

初始化：

public class 类名{1.变量，用来说明对象可以处理什么数据2.方法，描述对象有什么功能，可以对数据进行什么样的处理。...
}

关键字：
private关键字：权限修饰符

被private修饰后需要在本类中进行编写set和get类型函数，才能在其他类中进行输入输出内容

set方法：给成员变量赋值

get方法：对外提供成员变量的值

this关键字：

作用：区别局部变量和成员变量

本质：所在方法调用者的地址值

就近原则

static关键字：

静态方法不能调用非静态

非静态可以访问所有

final关键字：
最终的，不能被改变

final定义的父方法不能被子类重写。

final定义的变量叫常量，常量只能被赋值一次。

常量记录的数据不能发生改变。

字符串不可变。

权限修饰符：

变量：

局部变量：定义在方法里面

成员变量：类中的变量

JavaBean类：

对象内存图：

String函数：

快捷函数

类如：

比较字符：

String str = "smart";String str1 = "scarf";System.out.println(str.equals(str1));System.out.println(str.equalsIgnoreCase(str1));

相同返回true，不同返回false

截取字符串：

 String s3 = "java is the best";String rs=s3.substring(0,8);System.out.println(rs);

上述例子中0，8表示从开头开始截取八位字符（一个空格占两个字符空间）

克隆：
分为浅克隆和深克隆

浅克隆：拷贝出的新对象，与原对象中的数据一模一样（引用类型拷贝的是地址）

深克隆：

StringBuilder：

使用场景：1.字符串的拼接，2.字符串的反转。

示例：

容量：能存储的

长度：实际存储的

StringJoiner：

不用，那个位置就不写

例如，只需间隔符号：（---）；那么每个字符间就会多一个---间隔

只需间隔和开始：（---，[）；

注意：添加只能添加字符串，不能添加整数。

字符串原理：

API：

Math类常用方法：

正则表达式：

System工具类：

存在时间差：我们国家时间原点为：00：08：00

Runtime：

表示当前虚拟机的运行环境

Object和Objects：

object：Java中的顶级父类，所有的类都直接或者间接的继承它

object中的成员方法：

toString方法返回的是地址值

objects成员方法：

BigInteger：

大的整数

整数四种类型：byte(1个字节)，short(2个字节)，int(4个字节)，long(8个字节)。

二进制第一位是符号位：0表示正数，1表示负数。

字符串中必须是整数，否则会报错。

字符串中数字必须跟进制吻合。

valueOf方法的能表示范围比较小，只能在long的取值范围内。在内部对-16—16进行了优化，提前把-16—16先创建好BigInteger的对象，如果多次获取不会重新创建新的对象。

成员方法：

BigDecimal：

大的小数。

用于小数的精确计算，也可以用来表示很大的小数。

链式编程：

在调用一个方法的时候，不需要用变量去接受它的结果，可以继续调用其他方法。

集合的使用Arraylist：

示例：

导入数据：

插入数据：

根据索引获取某个地方的值：

获取集合的大小，内含数据的个数：

根据索引删除某个位置的元素值：

直接删除某个元素值，成功返回true，反之false

修改集合中某个位置的数据值：

Arraylist集合：

底层原理：

右移运算符：

双列集合：Map

Map的遍历方式：

1.键找值：

import java.util.*;
public class test {public static void main(String[] args) {Map<String,String>map=new HashMap<>();//第一个string是键的类型，第二个string是值的类型map.put("1","1");map.put("2","2");map.put("3","3");Set<String>keys=map.keySet();for(String key:keys){//key是键，value是值String value=map.get(key);System.out.println(key+"="+value);}}
}

2.键值对：
entry：键值对对象

entry：键值对对象

3.Lambda表达式：

import java.util.*;
import java.util.function.BiConsumer;
public class test {public static void main(String[] args) {Map<String,String>map=new HashMap<>();//第一个string是键的类型，第二个string是值的类型map.put("1","1");map.put("2","2");map.put("3","3");/* map.forEach(new BiConsumer<String,String>(){@Overridepublic void accept(String key,String value){System.out.println(key+"="+value);}});*///lambda表达式map.forEach((key,value)->System.out.println(key+"="+value));}
}

Hashmap：

特点：

LinkHashmap：

import java.util.*;
import java.util.function.BiConsumer;
public class test {public static void main(String[] args) {LinkedHashMap<String,Integer> lhm=new LinkedHashMap<>();lhm.put("java",100);//put方法有两个功能，一个添加，一个覆盖。lhm.put("python",90);lhm.put("c++",80);System.out.println(lhm);}
}

Treemap：

集合工具类Collections：

只能给单列集合进行批量添加元素。

获取随机数：

import java.util.*;
public class test {public static void main(String[] args) {ArrayList<Integer>list=new ArrayList<>();Collections.addAll(list,1,2,3,4,5,6,7,8,9,10);Collections.shuffle(list);Random r=new Random();int index=r.nextInt(list.size());int number=list.get(index);System.out.println(number);}
}

不可变集合：

不可以被修改的集合（长度、内容不可变）

一旦创建完毕后，只能进行查询操作。

参数不能相同

方法为ofEntries方法。

正则表达式：

作用：

校验字符串是否满足规则

在一段文本中查找满足要求的内容

爬虫：

分为本地爬虫和网络爬虫

两个特殊类：

包装类：

把数据包装成对象

（泛型不制裁基本类型数据，只能支持引用类型数据）

基本数据类型	对应的包装类（引用数据类型）
byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double
boolean	Boolean

继承：

爸爸：父类

儿子：子类

父类有的子类都具有，所以子类中只需创造它特有的就行，子类需要用的时候可以直接在父类里面调用。

继承特点：Java只支持单继承，不支持多继承，但支持多层继承。

单继承：一个子类只能继承一个父类，子类不能同时继承多个父类。

多层继承：子类A继承父类B，父类B可以继承父类C。AC关系为间接父类。AB为直接父类。

每一个类都直接或间接的继承于Object。Object类Java虚拟机内本身就存在的。

书写代码：从父类开始写

子类只能访问父类中非私有的成员//私有：private

如果一个类中没有构造方法，虚拟机会自动添加一个空参构造

继承过程中：
成员变量访问特点：就近原则，谁近用谁

虚方法表：非private，非static，非final。

方法重写的本质：如果发生了重写，则会覆盖。

只有被添加到虚方法表中的方法才能被重写。

不能被继承，就不能被重写。

继承中构造方法的访问特点：

继承中运用的关键字this，super：

super中调用的是父类的成员变量。

this是调用的子类的成员变量。

多态：

同类型的对象表现出的不同形态

多态调用成员的特点：
调用时变量是父类的，方法是子类的

在Java中加载字节码文件时永远先加载父类，再加载子类。

包：

就是文件夹，用来管理各种不同功能的Java类，方便后期代码维护。

包名+类名：全类名/全限定名

使用其他类的规则：使用其他类时，需要使用全类名。

抽象类和抽象方法：

注意事项、特点：

抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。
类该有的成员(成员变量、方法、构造器)抽象类都可以有。
抽象类最主要的特点:抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。
一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
抽象类不能创造对象
没有方法体的方法是抽象方法，抽象方法所在的类必须是抽象类

接口：

一种规则，对行为的抽象

接口中成员的特点：

多个接口中同名且同参的方法，只需重写一次。而同名不同参的视为两个不同的方法，都需要重写。

如果实现多个接口，需要重写所有的抽象方法。

接口中default关键字定义默认方法，默认方法重写时去掉default关键字。

static修饰静态方法，private修饰私有方法。

重写：子类把从父类继承下来的虚方法表里面的方法覆盖

类的五大成员：属性，方法，构造方法，代码块，内部类。

内部类：

在一个类的里面，再次定义一个类。

如果外部类想要访问内部类的成员，必须定义一个内部类成员对象。

成员内部类：

想要调用成员变量，只能通过对象去调用。

内部类里面外部类成员变量的调用。

示例：

静态内部类：

静态方法只能访问静态变量。

局部内部类：

匿名内部类：

时间表达：

同一个经线上的时间是一致的。

利用空参构造创建的对象，默认表示当前时间

利用有参构造创建的对象，表示指定时间。

对象不能直接进行计算。

JDK7：Date类：

JDK7：SimpleDateFormat类：

JDK7:Calender类：

JDK8：

List系列集合：

特点：

特有方法：

示例代码：

import java.util.List;
import java.util.ArrayList;
public class test {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("aaa");list.add("bbb");list.add("ccc");System.out.println(list);//[aaa, bbb, ccc]list.add(1,"ddd");//1为想要插入的索引位置。//原来索引上的元素后移System.out.println(list);//[aaa, ddd, bbb, ccc]list.remove(1);System.out.println(list);//[aaa, bbb, ccc]}
}

list集合的五种遍历方式：

迭代器遍历：能删除元素

增强for遍历

Lambda表达式遍历

普通for循环遍历

列表迭代器遍历：能添加元素（list集合系列独有）

泛型类：

检擦数据类型：

Integer类型不能强转为String类型。

泛型的继承和通配符：

泛型不具备继承性，但数据具有继承性。

泛型内写什么类型，就只能传递什么类型的数据值。

泛型的通配符：？就是一个问号。

Set系列集合：

元素是唯一的。

HashSet：

哈希值：

如果没有重写hashcode方法和equals方法，那么哈希值是根据地址值计算的。

LinkedHashSet：

TreeSet底层为红黑树。

红黑树：两个红色节点不能相连。

可变参数：

细节：

1.在方法的形参中最多只能写一个可变参数。

2.在方法中，如果除了可变参数之外还有其他的参数，可变参数就写在最后。

public class test {public static void main(String[] args) {int sum=getSum(1,2,3,4,5,6,7,8,9,10);System.out.println(sum);}public static int getSum(int...arr){int sum=0;for(int i:arr){sum+=i;}return sum;}
}

Stream流：

import java.util.*;
import java.util.function.BiConsumer;
public class test {public static void main(String[] args) {ArrayList<String> list=new ArrayList<>();list.add("张婧仪");list.add("周雨彤");list.add("赵丽颖");list.add("张张");list.add("张凌赫");list.stream().filter(name->name.startsWith("张")).filter(name->name.length()==3).forEach(name->System.out.println(name));/*ArrayList<String> list1=new ArrayList<>();for(String name:list){if(name.startsWith("张")){list1.add(name);}}System.out.println(list1);ArrayList<String> list2=new ArrayList<>();for(String name:list1){if(name.length()==3){list2.add(name);}}System.out.println(list2);*/}
}

最长的那行代码等于注释掉的代码。

HashMap不能保证存和取的顺序的，只能保证内容不变。

异常：

File类：

常见构造方法：

成员方法：

length方法无法获取文件夹的大小。内存之间的进制为1024.

IO流：

存储和读取数字的解决方案。

分类：

四大家族：字节输入流字节输出流字符输入流字符输出流

纯文本文件：用windows自带笔记本打开能读懂的文件

字节输出流：FileOutputStream

import java.io.FileOutputStream;
import java.io.IOException;
public class test {public static void main(String[] args) throws IOException {FileOutputStream fos=new FileOutputStream("src\\a.txt");String str="abc";byte[] arr=str.getBytes();fos.write(arr);String str2="\r\n";//换行符byte[] byte1=str2.getBytes();fos.write(byte1);String str3="def";byte[] byte2=str3.getBytes();fos.write(byte2);fos.close();//释放资源}
}

运行操作结果：

示例：

字节输入流·：FileInputStream

循环读取：

可以自行打印b，也可以强转为char类型打印

如果b中存有字符a，自行打印就为97（ascll码表对应数字），强转就打印a。

文件拷贝：

字节流读取中文会出现乱码。

字符集：

计算机存储英文，一个字节就足以。

汉字以两个字节存储。

在UTF—8的编码规则下，英文占一个字节，中文3个字节（且第一个字节的首位是1）。

存在乱码原因：读取数据时未读完整个汉字。

编码和解码方法不统一。

Java中解码和编码的方法：

字符流：

字符输入流FileReader:

idea默认是UTF—8

强转为char类型就行。

字符输出流FileWriter:

缓冲流：

拷贝文件操作：

将a.txt中的内容拷贝到b.txt中

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class test {public static void main(String[] args) throws IOException {BufferedInputStream bis=new BufferedInputStream (new FileInputStream("src\\a.txt"));BufferedOutputStream bos=new BufferedOutputStream (new FileOutputStream("src\\b.txt"));byte[] bytes=new byte[1024];int len;while((len=bis.read(bytes))!=-1){bos.write(bytes,0,len);}bos.close();bis.close();}
}

字节/字符缓冲流：