Java基础学习笔记

个人学习所做笔记，内容仅供参考！

1、Java运算符

2、原码、反码、补码

2.1、原码

• 定义：最高位为符号位（0-正，1-负），其他数字位表示数值本身的绝对值。
• 说明：用原码进行乘除运算时结果是正确的，而在加减运算时会出现问题。
• 范围：-127 ~ 127

2.2、反码

• 定义：如果是正数，与原码一致；如果是负数，则除符号位的其他数位取反。
• 说明：在计算中，在+0和-0会出现问题。
• 范围：-127 ~ 127 （-128表示-0）

2.3、补码

• 定义：如果是正数，与原码一致；如果是负数，则将数字的反码加上1。
• 范围：-128 ~ 127

2.4、例子System.out.println(~4);

// 打印的结果为-5
System.out.println(~4);
/*
4 的二进制表示为 0000 0100
~4 =》1111 1011 （这是一个负数，在计算机中是以补码表示的）
接下来需要将补码进行转换，求出原码
由于补码是有原码按位取反+1而得的，故而原码为补码-1再取反
减1 =》1111 1010
取反 =》1000 0101 -》-5
*/

3、基本数据类型的转换

• 自动转换：在运算过程中，数据类型不一致，会自动将小的数据类型转换成大的数据类型，不会出现运算错误。
• 强制转换：需要显示强制转换，可能损失精度，结果可能错误。

4、数组

• 当new一个数组时，就是在内存空间划出一块连续的内存空间。

5、成员变量与局部变量

• 成员变量：类中的属性，有默认值，分配在堆中，需要垃圾回收器进行回收。
• 局部变量：方法中的变量，没有默认值，使用前必须初始化，分配在栈中，方法执行完毕，自定释放空间。

6、值传递、引用传递

• Java中方法的参数是值传递。

7、字符串的比较问题

import java.util.Scanner;

/**
 * @author IT00ZYQ
 * @Date 2021/3/5 14:53
 **/
public class T01_TestString {

    public static void main(String[] args) {
        String str1 = "abc";


        Scanner in = new Scanner(System.in);
        String str2 = in.nextLine();
        System.out.println("str2.hashCode() : " + str2.hashCode());
        System.out.printf("str2 == str1 ? %b\n", str1 == str2);
        System.out.println("str1.equals(str2) ? " + str1.equals(str2));

        System.out.println("===============================");
        String str3 = new String("abc");
        System.out.println("str3.hashCode() : " + str3.hashCode());
        System.out.printf("str3 == str1 ? %b\n", str1 == str3);
        System.out.println("str1.equals(str3) ? " + str1.equals(str3));

        System.out.println("===============================");
        String str4 = "abc";
        System.out.println("str4.hashCode() : " + str4.hashCode());
        System.out.printf("str4 == str1 ? %b\n", (str1 == str4));
        System.out.println("str1.equals(str4) ? " + str1.equals(str4));

    }

}

运行结果：

abc
str2.hashCode() : 96354
str2 == str1 ? false
str1.equals(str2) ? true
===============================
str3.hashCode() : 96354
str3 == str1 ? false
str1.equals(str3) ? true
===============================
str4.hashCode() : 96354
str4 == str1 ? true
str1.equals(str4) ? true
Process finished with exit code 0

结果分析：
hashcode应该都是字符串"abc"在常量池中的地址，str2与str3中间还有一个堆内存的，所以str2==str1 与 str3==str1是拿堆内存的地址与常量池中“abc”的地址进行比较，故而都为false。

8、代码块

8.1、普通代码块

• 定义： 方法中的代码块

8.2、构造代码块

• 定义：直接定义在类中的代码块，编译后会出现在构造函数的第一行。

8.3、静态代码块

• 定义：使用static修饰的代码块，在程序载入的时候就被执行

8.4、同步代码块

• 定义：在多线程的时候使用，用来给共享空间加锁。

9、继承

• 子类重写父类的方法，不允许拥有比父类更小的访问权限。
• 多重继承的危险性：C++中的多重继承，一个类可能继承了同一个方法的不同实现，会导致系统奔溃。
• extends必须位于implements之前

10、抽象类与接口的异同

• 抽象类中可以有抽象方法，也可以有普通方法；接口中只能有抽象方法。
• 抽象类使用abstract修饰；接口使用interface修饰。
• 子类使用extends关键字继承抽象类；使用implements关键字实现接口。
• 子类只能继承一个抽象方法，可以实现多个接口。
• 抽象类中可以定义普通的成员变量；接口中只能定义常量，默认加上public static final三个修饰符。
• 抽象类和接口都不能实例化，但是抽象类可以有构造方法，接口没有构造方法。

11、内部类

• 普通内部类创建方法：Outer.Inner inner = new Outer().new Inner();
• 静态内部类创建方法：Outer.Inner inner = new Outer.Inner();
• 内部类可以访问外部类的属性，包括私有属性。
• 内部类中不能定义静态属性
• 内部类与外部类有相同名字的成员变量时，在内部类中默认访问的是内部类的成员变量，若要访问外部类的成员变量，需要通过this关键字。

12、异常类

12、StringBuffer与StringBuilder

• 底层都是char数字，默认初始长度是16，每次扩容(value.length << 1) + 2，即新字符串的长度的2配再加上2。
• StringBuffer是线程安全的，效率较低；StringBuilder是线程不安全的，效率较高。

13、枚举enum

• 所有枚举类型都隐性继承java.lang.Enum，枚举实质上还是一个类。
• 枚举每个成员变量实质就是一个被public static final修饰的实例。

14、Java集合框架

迭代器Iterator

• 迭代器，增强for循环foreach底层是基于Iterator实现的。
• 所有集合实现类都有一个内部类实现了Iterator接口。
• 要在遍历过程中删除元素，只能通过ListIterator

import java.util.*;

/**
 * @author IT00ZYQ
 * @Date 2021/3/6 0:22
 **/
public class T03_Collections {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

}

List

ArrayList

• 特点：数组实现，内存连续，扩容1.5倍
• 优点：遍历元素和随机访问元素的效率较高
• 缺点：添加和删除元素需要移动大量元素，效率较低。按照内容查询的效率较低

LinkedList

• 特点：双向链表实现，内存分散
• 优点：插入和删除的效率较高
• 缺点：遍历和查询效率较低

Vector

• 特点：与ArrayList类似，数组实现，内存连续，线程安全，几乎所有的public方法都加上了synchronized关键字，扩容两倍。

Set

如何保证元素的唯一性？

• 通过元素的两个方法，hashCode()和equals()方法来完成
• 如果元素的hashCode值相同，不会调用equals()
• 只有hashCode值不同，才会调用equals()进行判断

HashSet

• 特点：底层是一个HashMap，value是一个final修饰的Object()实例。无序，添加、删除、查询速度快。

LinkedHashSet

• 特点：采用哈希表存储结构，同时使用链表维护插入顺序。

TreeSet

• 特点：底层是一个TreeMap，采用红黑树的数据结构，有序（升序），查询速度比List快但比HashSet慢。
• 说明：TreeSet的元素是需要进行排序的，如果存储的元素是自定义类，需要实现Comparable接口，否则在编译的时候会报错。也可以使用外部比较器实现Compartor接口，在new TreeSet的时候传入外部比较器。外部比较器的优先级较高。

Map

HashMap

• 实现：1.7 => 数组+链表；1.8 => 数组+链表+红黑树(当链表的长度大于等于8是，链表转化为红黑树)；
• key与value都允许为NULL
• 链表转化为红黑树的条件：链表长度等于8，数组长度不小于64
• 红黑树转化为链表的条件：链表小于等于6时，红黑树重新转化为链表。
• 容量取2的n次幂的原因：在根据hash值求元素在数组中的位置时，需要进行hash%(length-1)操作，因为&操作的效率远高于%求余运算，当(length-1)的二进制数位都为1时，hash%(length-1) == hash & (length-1)；在进行扩容操作时，需要进行元素转移，由于数组的长度改变了，需要重新根据hash值求元素在数组中的位置，当求余数只是变为原来的2的次幂倍时，只需要判断高n位的值就可确定元素在新数组中的位置，当高n位都为0是，元素的位置不变，当高n位存在1时，新位置=旧位置 + 2^(为1的位-1) + …
• 每次扩容两倍
• 加载因子为0.75，即当存储的元素数量达到容量的0.75倍时，触发扩容

TreeMap

• 特点：采用红黑树的数据结构，有序（升序），查询速度比HashMap慢。
• 说明：TreeMap是按key进行排序的，如果存储的key是自定义类，需要实现Comparable接口，否则在编译的时候会报错。也可以使用外部比较器实现Compartor接口，在new TreeMap的时候传入外部比较器。外部比较器的优先级较高。
• key与value都不允许为NULL

LinkedHashMap

• 特点：采用哈希表存储结构，同时使用链表维护插入顺序。

个人学习所做笔记，内容仅供参考！