Java基础知识思维导图思维导图模板_ProcessOn思维导图、流程图

流程控制语句

Java中的程序，执行的顺序是从上而下执行的

if语句

if(关系型表达式){ 语句体； }

首先进行判断关系型表达式

结果为true 执行方法体{}

结果为false 不执行方法体

无论语句体中有多少行代码，一定要写上{}

if(){}else{}

首先进行判断关系型表达式

结果为true 执行if方法体{}

结果为false 执行else方法体{}

if(){}else if(){}else{}

首先进行if关系型表达式判断

结果为true 执行if方法体{}

结果为false 继续判断，往下执行else if方法体{}

以上的if条件都不满足，则执行else方法体{}

switch

例子

switch(表达式){//表达式中可以编写int、char、String、short、enum类型的数据
case 1:

  语句体;

  break;

case 2:

  语句体;

  break;

case 3:

  语句体;

  break;

default:

  语句体;

  break;
}

循环

for(初始化表达式1；布尔表达式2；步进表达式3){
//循环体;
}

初始化表达式1；
while（布尔表达式2）{
   //循环体3；
   步进表达式4；
  }

初始化表达式1；
do{
   //循环体3；
   //步进表达式4；
  }while(布尔表达式2)

break和return和continue关键字的区别

break：结束整个循环，包括剩下后面的循环

return：本循环不进行循环

continue：结束本次循环，还会继续执行后面的循环

数组的使用和创建

数组的创建方式

int[] arr = new int[10]; //进行指定长度

int[] arr01 = new int[]{1,2,3,4};
/*在创建的时候进行存储对应的数据
*注意：{}中的数据类型一定要和当前数组的数据类型一致 */

int[] arr03 = {1,2,5};

注意：数组的索引是从0开始的

数组的拷贝

arraycopy(数组1，开始拷贝下标，数组2，开始拷贝位置，拷贝个数) //将数组1拷贝给数组2

冒泡排序算法

public static void main(String[] args){
    int[] arr = {123,45,6778,78,24,34,67,678};
    //外层
    for(int i = 0; i < arr.length; i++){
        int tem = 0;
        //就是控制相邻的两个数进行比较
        for(int j = i + 1; j < arr.length; j++){
            if(arr[i] > arr[j]){
                tem = arr[j];
                arr[j] = arr[i];
                arr[i] = tem;
            }
        }
    }
    System.out.println("Arrays.toString(arr) = " + Arrays.toString(arr));
}

数组反转算法

public static void main(String[] agrs){
    int[] arr = {12,232,454,565,676,77,11,88};
    for(int i = 0,j = arr.length - 1;i <= j;i++,j--){
        int tem = arr[i];
        arr[i] = arr[j];
        arr[j] = tem;
    }
    //进行反转
    for(int i = 0; i < arr.length; i++){
        System.out.println("i = " + arr.[i]);
    }
}

二维数组

int[][] arr = new int[12][23]; //包含了12个数组，其中每个数组有23个元素
int[][] arr = new int[12][]; //ok

int[][] arr = {{1,2,4,43},{2,3,32,344},{33,333,222,111},{11,33,22,334}};
int[][] arr = new int[4][5];

面向对象的堆栈方法区的概述

面向过程和面向对象的区别

面向过程

把衣服->脱->盆->水->衣服->洗衣粉->搓一搓->拧干->清洗->拧干->找衣架->挂起->晾干

面向对象

把衣服->洗衣机

指的是一切事物，每个事物都有自己的属性和行为

行为

当前事务能干什么事情->对应程序中的方法

人：走路说话

属性

当前事物状态->对应程序中的变量（成员）

人：名称肤色

扩展

在开发的时候，能用包装类，就用包装类，尽量少使用基本数据类型，根据业务情况来进行区分

栈执行程序的顺序

先进后出，后进先出

抽象类的描述和使用

方法的重写

子类中出现了与父类一样的（参数、返回值、类型、名称、参数个数与顺序）

会出现覆盖的效果

抽象类（abstract）

定义

抽象方法：没有对应的方法体

public abstract String getString(String message);

可以有构造函数

可以出现普通方法

继承抽象类的类需要重写抽象方法

接口（interface）

定义

进行将对应公用的抽象方法的一个集合

可以有静态方法

不可以有普通方法

不可以有私有方法

接口与接口之间可以进行多继承

类只能进行实现接口（多实现），如实现了多个接口，当多个接口出现了一样的方法，实现类中可实现一个方法即可

多态

是指同一个行为具有多种不同的表现方式

向上转型

多态本身子类类型向父类类型的向上转型过程

当父类的引用指向了一个子类对象的时候，就是向上转型

向下转型（尽量少使用，会导致数据丢失）

父类类型向子类类型向下转型的过程

将父类引用转为了子类=>（强制转换类型）

final 关键字

不可变的

修饰在类、方法、变量上

public final class String

类：当前类是不能被继承的

方法：不能被重写

变量：不能被重新赋值

修饰符

public private protected default
在同一个类中 v v v v
在同一个包中 v N v v 不同包中的子类 v N v N
不同包中的其他类 V N N N

内部类

一个类中包含了另外一个类

LeftJoin（类）$Header（内部类）编译之后的内部类 .class文件

匿名内部类

new Inter(){
@Override
public void getVoid(){}
};

局部内部类（不能出现静态方法和成员变量）

public Object getObject(){
    class Header{
        private String name;
        public void getLastName(){}
    }
    return null;
}

递归

构造函数中是禁止使用递归的

使用递归的时候需要保证有停止的条件，否则就是死循环 ->内存溢出

循环次数比较少的情况可以进行使用递归，递归的次数不能太多

Arrays、Objects等工具类

Arrays

进行对数组的操作，如搜索、排序......等等

所有的方法都是静态

输出数组：Arrays.toString()

数组排序：Arrays.sort()

字符串转换为字符：str.toCharArray()

返回集合：Arrays.asList(数组)

Object

1.7之后添加的工具类，是所有类的父类

正则表达式

进行对数据的验证

[] //单个字符

[1-9] //1~9之间的数据

[ABC] //AB或者C

[^ABCD] //^排除

[A-Za-z]

[a-f[t-p]] //并集 a-f或者t-p的并集

[a-z && [QWE]] //交集

[A-Z && [^IOP]] //减去IOP

[A-Z && [^T-W]] //减去T-W

\d //0-9的数字

. //任何字符

\D //非数字的情况，对于[^0-9]

\s //空白字符

\S //非空字符

\w //单词字符

\W //非单词字符

x? //x，一次或者一次都没有

x* //零次或者多次

x+ //一次或者多次

x{n} //N次

x{N,M} //N次但是不能超过M次

例子1

public static void main(String[] agrs){
String str = "[1-9]\\d{4-11}";
System.out.println("1234564".matches(str));
}

例子2

public static void main(String[] args){
    String s = "我的手机号是：19122542846";
    String str = "1[35789]\\d{9}";
    Pattern compile = Patten.compile(str);
    Matcher matcher = compile.matcher(s);
    while(matcher.find()){
        System.out.println("matcher.group() = " + matcher.group());
    }
}

HashMap、LinkedHashMap、TreeMap、Hashtable的使用与区别

Map

key 和 value 进行存储数据的

注意：key是不能重复的，因为底层采用Set的方式进行存储的，value可以重复

HashMap

线程不安全的

元素的顺序不能保证一致

key是唯一的，不能重复

能进行使用null键或者null值

keySet()、values()、entrySet()

Set<Map.Entry<Object,Object>> entries = stringObjectHashMap.entrySet();
Iterator<Map.Entry<Object,Object>> iterator2 = entries.iterator();
while(iterator2.hashNext()){
    Map.Entry<Object,Object>> next = iterator2.next();
    System.out.println("next.getKey() = " + next.getKey());
    System.out.println("next.getValue() = " + next.getValue());
}

LinkedHashMap

双向链表

线程不安全的

能进行使用null键或者null值

TreeMap

也可以进行对应数据的排序

如单独对values进行排序，可以存储在set中再次进行定义排序规则

线程不安全的

能进行使用null键或者null值

Hashtable

是属于线程安全的

不能存储null键或者null值

Properties

是属于线程安全的

Hashtable的子类

key和value都是字符串

不能存储null键或者null值

标识符的规则

必须是字母、_下划线、$开头，后面可以跟上数字、下划线、$

字母限制在26个英文字母中，当然也可以使用中文字符集（不推荐）、日文等

严谨区分大小写的

不能是数字开头

不能使用Java中的关键字命名，如public、class、void等等关键字、保留字

不能使用空格

不能使用其他特殊字符，除了$ _

常量和变量

4类8种基本数据类型

常量

Java程序中固定不变的数据

分为以下几种

整数常量

小数常量

字符常量（字符是单引号' '） 'ABC'：语法错误

字符串常量（字符串是双引号" "） "ABC"：语法正确

布尔值常量 true false

空常量 null

变量

就是在程序中可以改变的

如运算：3=X-2

数据类型

8种基本数据类型

整数

①字节 byte 1个字节

②短整型 short 2个字节

③整型 int 4个字节

④长整型 long 8个字节

浮点数

①单精度浮点型 float 4个字节

②双精度浮点型 double 8个字节

字符

字符型 char 2个字节

布尔

布尔型 boolean 1个字节

默认的情况下

整型是int 如1 12 13 14

浮点型是double 如23.5 24.6

如使用long ,后面加上L

如使用float，后面加上f或

Double默认后面是D

应用数据类型

类

Short

Integer

Long

Float

Double

扩展

Integer i=null; //ok

Integer i01=23; //ok

int j=25; //ok

int j01=null; //no

数组

接口

数据类型的转换

基本数据类型的容量大小顺序

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

转换

自动转换小范围转换为大范围

int->long float->double

例子

int i = 1;

byte b = 2;

int in = i +b;

强制转换大范围转换为小范围

int->byte double->int

例子

int i = 1;

byte b = 2;

byte c = (byte)(i + b);

运算符

算术运算符

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

++ 变量进行增加1

-- 变量进行减少1

注意

无论是++或者是-- 在前以及在后运算的结果都是没有什么区别的

例子

// -- 也是相同的道理

   int i = 1,j = 1;

    //++在前（先自增再赋值）

   int in = ++i;

   System.out.println("i = " + i);  //1  NO 2 YES

   System.out.println("i = " + in);  //2

   //++在后（先赋值再自增）

   int t = j++;

   System.out.println("j = " + j);  //2

   System.out.println("j = " + t);  //1

赋值运算符

+= 如：a+=1 相当于a=a+1

-=

*=

/=

比较运算符（返回的结果要么是false 要么是true）

>

<

!= 不等于

== 等于两端相同返回的结果是true

>=

<=

逻辑运算符

&& 短路与两端的结果都是true，如一端为false，结果就是false，如左边的为false，那么右边的判断就不会执行了

|| 短路或两端都是false，返回的结果才为false，如一端为true，返回的结果为true

！取反如为true，返回的结果为false，如为false，返回的结果为true

三元运算符

'' ? '' : ''

eg：'一元' ? '二元' : '三元'

一元

只是需求一个数据可以进行运算如！ ++ -- ...只要返回的结果是true，或者是false都可以

二元

如一元运算返回true，执行二元运算符

三元

如一元运算返回false，执行三元运算符

方法的规则，重载

方法定义的格式

修饰符（可省略不写）返回值的类型方法名(参数列表[可写可不写]){
//方法体
}

修饰符（可省略不写）

public //公共

protect //保护

private //私有

默认不写

返回值的类型

如果是void，表示没有返回值，那么就不需要进行return 返回数据

如果不是void，那么就需要进行返回return

返回的数据类型必须要和返回值的类型一致

或者是返回值类型的子类

方法名

首字母小写，如果后面出现多个单词，那么每个单词的首字母大写

要见名思意（不只是方法，类也是一样的道理）

参数列表[可写可不写]（参数的类型01 参数名称01，参数的类型02 参数名称02，......多个以此类推）

可以进行编写多个，使用逗号相隔

编写方法注意事项

方法是编写在类体中{}

如有返回，必须要return，并且返回的类型要和返回值类型一致

return 是方法体最后一个}前面的（最后一个语句）

方法重载

在同一个类中，允许存在一个以上的相同名称的方法

只要它们的参数列表不同，与修饰符和返回值是无关的

参数列表

个数不同

数据类型不同

顺序不同

JVM通过方法的参数列表，调用不同的方法

String类时间类与格式化时间

String和StringBuilder和StringBuffer的区别

数据修改

String是不可变的

StringBuffer、StringBuilder是可变的

线程安全

由于String中的数据是不可变的，线程安全

StringBuffer由于方法上加了synchronize锁，那么就是线程安全的

StringBuilder线程不安全

String

indexof() 指定字符串第一次出现索引的位置

Lengt() 长度

concat() 拼接字符串末尾

charAt() 返回指定索引的值

subString() 截取

toCharArray() 转换为字符数组

getBytes() 转化为字节数组

replace() 替换

split() 分割

toUpperCase() toLowerCase() 转换为大小写

StringBuilder StringBuffe

append() 追加

setCharAt() 指定索引设置值

insert() 指定索引插入值

delete() 指定索引删除值

toString()

subString()

indexOf() 指定字符串第一次出现索引的位置

replace() 替换

子主题

时间类

Date

时间格式化

public static void main(String[] args) throws Exception{
    Date date = new Date();
    System.out.println("date = " + date);
    DateFormat dateInstance = DateFormat.getDateInstance();
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
    String format = simpleDateFormat.format(new Date());
    System.out.println("format = " + format);

    SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String format1 = simpleDateFormat1.format(new Date());
    System.out.println("format1 = " + format1);

    SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat();
    Date parse = simpleDateFormat2.parse(format1);
    System.out.println("parse = " + parse);
}

日历

calendar

public static void main(Sting[] args){
    Calendar instance = Calendar.getInstance();
    Date time = instance.getTime();
    System.out.println("time = " + time);
}

常见的数据结构与ArrayList、LinkedList

数据结构

栈

先进后出，后进先出

压栈

存数据

弹栈

取数据

队列

如火车进洞

先进先出，后进后出

数组

每个元素都有固定的下标，并且下标从0开始

查询比较快，添加删除比较慢

因为删除和添加会进行对下标进行改变，所以比较慢（每次操作都需要进行移动元素）

链表

其中有两个节点

data 数据域 ->存数据

next 指针域 ->指定下一个数据域地址

多个节点之间使用的通过地址进行连接

查询速度慢

会进行通过地址进行查询

增加删除比较快

红黑树（二叉树）

每个节点不能超过2个有序的树

元素有大小顺序

左边节点小，右边节点大

平衡树

左节点=右节点

非平衡树

左节点！=右节点

红黑树

查询速度快，查找元素节点的时候最少和最多次数不会多于2倍

节点

节点可以是红和黑

根节点是黑的

叶子节点是黑的

每个红节点的子节点是黑的

任何一个节点到叶子节点所有的路径上黑色节点的数量是相同的

集合

list

元素是有序的，并且可以重复的，每个元素都有对应的索引

ArrayList 底层是以数组的方式进行存储非线程安全

LinkedList 底层是以链表的方式进行存储非线程安全

Vector 和 ArrayList是一样的原理，但是Vector是线程安全的

set

不允许有重复的元素，存储无序，无索引

HashSet

public static void main(String[] args){
    Set<Integer> hashSet = new HashSet<>();
    hashSet.add(11);
    hashSet.add(11);
    hashSet.add(13);
    hashSet.add(14);
    hashSet.add(14);
    Iterator<Integer> iterator = hashSet.iterator();
    while(iterator.hasNext()){
        System.out.println(iterator.next());
    }
}

不是线程安全的

元素可以为null

如需要进行排除重复的数据，则要进行重写HashCode，equals

TreeSet

排序的

自然排序（默认的），自定义排序

元素是唯一的

元素不能为null

自定义排序算法

class CompareTreeSet implements Comparator{
    /*
     *如果返回正整数，则表示o1大于o2,
     *如果返回的是0，则表示相等
     *如果返回的是负整数，则表示o1小于o2
     */
    @Override
    public int compare(String o1,String o2){
        int i = o1.length()-o2.length();
        return i == 0?o1.compareTo(o2):i;
    }
}

LinkedHashSet

不允许重复的元素

使用链表的方式进行存储的

不是线程安全的

元素可以为null

map

ArrayList

public static void mian(String[] args){
    //<Object>  标识泛型  进行约束当前集合进行存储的数据类型
    List<String> list = new ArrayList<>();
    lidt.add("A");
    lidt.add("B");
    lidt.add("C");
    lidt.add("D");
    //迭代器
    Iterator<String> iterator = list.iterator();
    while(iterator.hasNext()){
        System.out.println(iterator.next());
    }
}

LinkedList

public static void main(String[] args){
    List<Integer> list = new LinkedList<>();
    lidt.add(1);
    lidt.add(2);
    lidt.add(3);
    lidt.add(4);
    //迭代器
    Iterator<String> iterator = list.iterator();
    while(iterator.hasNext()){
        System.out.println(iterator.next());
    }
}

异常的使用与自定义异常

异常

Error

开发无法进行处理的异常

Exception

编译时异常 ParseException

运行时异常 NullPointerException

几乎都可以进行处理

空指针

下标越界

类型转换异常

IO异常

jvm会根据产生的异常进行创建一个异常对象

主函数中对异常的处理

如有对于异常处理的逻辑，进行执行对应的逻辑处理

如没有就将这个异常抛出调用者来处理

当主函数中发现没有这个异常处理的逻辑，再次将异常抛出给jvm（jvm调用的主函数）

处理异常的方式

try...catch 处理异常

throw 抛出异常

注意

在开发中进行编写接口的时候，有异常一定要抛

在多个catch中，第一个catch处理异常必须是第二个catch的子类或者是兄弟类，不是父类，第二个和第三个以此类推。

inally final finalize 之间的区别

finalize

是在垃圾收集器进行删除对象之前对这个对象的调用

内存中清除的一个工作

自定义异常