JAVA学习笔记

JavaSE 一、面向对象编程

hang in there ,thinks will work out

1、继承

extends
一个类只可以继承一个父类
java不支持多继承

继承之后可以使用 “ . ” 的方式访问父类中的非 private 的成员变量和方法

继承的使用方法

  //Dog.class 子类
  
// 狗（子类） 继承 动物（父类）
public class Dog extends Animal {}

继承父类后访问父类中的非 private 的成员变量和方法

// AnimalDemo.class 测试类

public class AnimalDemo {
    public static void main(String[] args) {
//        new 狗类
        Dog dog =  new Dog();
//        因为 Dog 继承了 Animal 父类
//        所以Dog可以访问父类中的非 private 成员变量和方法
        dog.eat();
//        因为父类中的name 具有权限修饰符private 所以无法访问到name
//        dog.name;
    }
}

//Animal.class 父类

public class Animal {
    private String name;
    private int age;

    public void eat(){
        System.out.println("这是父类的 吃方法");
    }
}

构造方法
- 子类在继承了父类的时候，其子类的构造方法的第一行都会先执行父类的无参构造方法，若父类没有无参构造方法，则可以在子类的构造方法中，直接使用super(参数)，调用父类的有参构造方法;
  
  若，父类中有无参构造方法，则子类的构造方法默认第一行都为super() , 即 : 第一行调用的都是父类的无参、
- 若父类，有有参构造方法，若不重写子类的无参构造方法，则会报错，因为子类的无参构造方法，默认第一行执行的是父类的无参构造方法，而现在，父类中没有无参构造方法，那么子类不能调用父类的无参构造方法，就必须重写子类的无参构造方法，将第一行改为super( 参数 ) ，这里的参数与父类中的有参构造函数的参数列表相对应
- ```
// StudentParent.class 父类

public class StudentParent {
    private int age;

//    父类的无参构造方法
//    public StudentParent() {
//        System.out.println("这是父类中的无参构造方法");
//    }

//    父类的有参构造方法
    public StudentParent(int age) {
        this.age = age;
    }
}
```
```
// Student.class 子类

public class Student extends StudentParent {
    private String name;

//  子类的无参构造方法
    public Student() {
        super(20); // 父类中没有 无参构造方法， 可以这样直接调用父类的有参构造方法
        System.out.println("子类中的无参构造方法");
    }

//    子类的有参构造方法
    public Student(int age) {
        super(age);
    }
}
```
super 的使用方法
子类访问父类中的非 private 和 static 成员变量、成员方法和构造函数可以使用super 关键字访问
- 这样子访问成员变量需要用一个变量去承接他
- super.age
- ```
public void show(){
        int age1 = super.age;
        System.out.println("父类中的age"+ super.age);
    }
```
在一个方法中访问本类中的成员变量可以使用关键字 this
- this.age

2、方法的重写与重载

Override 重写
- 方法重写的规则
  
  1、参数列表与被重写的参数列表一致
  
  2、返回值不可以修改
  
  3、访问权限不能比父类中被重写方法的权限低
  
  4、父类中的方法只能被他的子类重写
  
  5、父类中被 private 和static 修饰的方法，不能被子类重写
- 子类继承父类后，可以重写父类中的方法
- ```
//Dog.class 子类

// 狗（子类） 继承 动物（父类）
public class Dog extends Animal {

//        子类重写父类中的eat方法
    @Override
    public void eat(){
        System.out.println("这是狗类的 吃 方法");
    }
}
```

Overload 重载

方法重载的条件

1、多个方法在同一个类中

2、多个方法的名相同

3、多个方法传递的参数的类型不同或个数不同
例如某个类中的构造方法

// StudentParent.class

public class StudentParent {
    public int age = 20;

    public  void eat(){
        System.out.println("这是学生的吃方法");
    }

//    无参构造方法
    public StudentParent() {
        System.out.println("这是父类中的无参构造方法");
    }

//    有参构造方法
    public StudentParent(int age) {
        this.age = age;
    }
}

3、多态

多态的基本条件

1、有继承或者实现的关系

2、方法的重写 – 子类重写父类中的方法

3、有父类的引用指向子类 (就是使用父类的类型的变量承接子类的实例对象)

//Demo.calss 测试类

public class Demo {
    public static void main(String[] args) {
//        new 狗类对象
        Dog dog = new Dog();
        dog.eat();
//	【结果】: 这是子类（狗类）重写的父类的吃方法
        
//        父类的引用指向子类对象   多态访问子类的方法
        Animal animal = new Dog(); 
        animal.eat();	// 这里就是父类的引用指向子类 ， 这里的eat() 方法，来自于子类对父类eat方法的重写
//	【结果】: 这是子类（狗类）重写的父类的吃方法
    }
}

//Animal.class 父类

public class Animal {
	public int age = 40;
//    父类的吃方法
    public  void eat(){
        System.out.println("这是父类的 吃方法");
    }
}

// Dog.class 子类

// 狗（子类） 继承 动物（父类）
public class Dog extends Animal {

    public int age = 20;
    public int weight = 100;
//        子类重写父类中的eat方法
    @Override
    public void eat(){
        System.out.println("这是子类（狗类）重写的父类的吃方法");
    }
}

多态的访问特点
- 成员变量：编译看左边，执行看左边；
- 成员方法：编译看左边，执行看右边；（因为执行的成员方法，可以被子类重写，所以看new Dog() 里是否重写了此成员方法）
- 为什么成员变量和成员方法的访问不一样呢？
  
  因为成员方法有方法的重写，而成员方法没有。
多态访问成员变量

//Demo.class 测试类

public class Demo {
    public static void main(String[] args) {
        
//        父类的引用指向子类对象   多态
        Animal animal = new Dog();
        // 左边		// 右边
        System.out.println("animal.age = " + animal.age);
//	【结果】	 animal.age = 40 
//	【原因】	这就是父类中的age，因为多态访问成员变量，编译看左边，执行看左边；
        
        System.out.println("animal.weigth = " + animal.weigth);
//	【结果】	编译期报错 
//	【原因】	因为 多态访问成员变量，编译看左边，执行看左边；所以Animal中没有weight这个成员变量，所以编译期报错了
    }
}

多态访问成员方法

// Demo.class 测试类

public class Demo {
    public static void main(String[] args) {

//        父类的引用指向子类对象   多态
        Animal animal = new Dog();
        // 左边         // 右边
        animal.eat();
//  【结果】  这是子类（狗类）重写的父类的吃方法
//  【原因】	成功！ 因为父类和子类中都有eat()	
        
        animal.show();
//  【结果】  编译期报错
//  【原因】  多态访问子类的成员方法，编译看左边，执行看右边；因为编译期中，看左边，但Animal中并没有show() , 所以会报错
    }
}

使用多态机制的优点：1、提高程序的扩展性
- 具体体现：定义方法的时候，使用父类类型作为参数，将来在使用的时候，使用具体的子类类型作为参数传入
多态机制的弊端：不能使用子类独有的方法，即：父类没有的方法
代码实例：

//AnimalDemo.class 测试类

public class AnimalDemo {
    public static void main(String[] args) {
//        new 动物操作类
        AnimalOperate animalOperate = new AnimalOperate();

//        调用动物的吃饭动作 未使用多态的机制
        animalOperate.userCatEat(new Cat());
        animalOperate.userDogEat(new Dog());
//  【结果】    我是猫类， 我正在吃饭 ...
//  【结果】    我是狗类， 我正在吃饭 ...

//        调用动物的吃饭动作 未使用多态的机制
        animalOperate.userAnimalEat(new Cat());
        animalOperate.userAnimalEat(new Dog());
//  【结果】    我是猫类， 我正在吃饭 ...
//  【结果】    我是狗类， 我正在吃饭 ...
    }
}

//AnimalOperate.class 操作类

public class AnimalOperate {
//     未使用多态机制
    public void userDogEat(Dog dog){
        dog.eat();
    }

    public void userCatEat(Cat cat){
        cat.eat();
    }

//    使用多态机制
    public void userAnimalEat(AnimalParent animalParent){
        animalParent.eat();
    }
}

//Cat.class 子类

public class Cat extends AnimalParent {
    @Override
    public void eat() {
        System.out.println("我是猫类， 我正在吃饭 ... ");
    }
}

//Dog.class 子类

public class Dog extends AnimalParent {
    @Override
    public void eat() {
        System.out.println("我是狗类， 我正在吃饭 ... ");
    }
}

//AnimalParent.class 父类

public class AnimalParent {
    public void eat(){
        System.out.println("我是AnimalParent 父类的吃方法");
    }
}

多态的转型

// AnimalDemo02.class 测试类

public class AnimalDemo02 {
    public static void main(String[] args) {

//        new 狗类
       Dog dog = new Dog();
       dog.showDog();

//  使用多态机制
        AnimalParent animalParent = new Dog();
        animalParent.showDog();
//  【结果】    编译期报错
//  【原因】    父类AnimalParent中没有showDog方法，因为多态访问成员方法，编译看左边，执行看右边

//        将animalParent进行强制转换位Dog类型
        Dog animalParent2 = (Dog) animalParent;
        animalParent2.showDog();
//  【结果】    这是狗类的show方法
//  【原因】    因为animalParent强制转换成了Dog类型，且Dog类中有showDog方法，所以由于多态访问成员方法，编译看左边，执行看右边， 最后执行成功！
    }
}

// Dog.class 子类

public class Dog extends AnimalParent {
    @Override
    public void eat() {
        System.out.println("我是狗类， 我正在吃饭 ... ");
    }

    public void showDog(){
        System.out.println("这是狗类的show方法");
    }
}

// AnimalParent.class 父类

public class AnimalParent {
    public void eat(){
        System.out.println("我是AnimalParent 父类的吃方法");
    }
}

4、抽象类

抽象类：例如动物类是一个抽象的概念，没有确切具体的事物

关键字 abstarct ：如果在方法加上abstarc关键字进行修饰，那么这个方法就为抽象方法；若有个类中存在一个抽象方法，那么这个类就称之为抽象类，抽象类也需要用abstarct进行修饰。

abstarct 不能与哪些关键字共存

关键字	能否共存	原因
private	否，相互冲突	abstarct 必须被重写，而private不能被继承
final	否，相互冲突	final修饰的方法，变量都不能修改，而abstact修饰的方法必须被重写
static	否，无意义	static是静态的，被abstarct 修饰的方法，是没有方法体的

关键字 final ：若给变量加上了final关键字修饰，并赋值，则这个变量为常量，且不可修改的
- 若子类继承的父类为抽象类，那么子类必须重写父类中的抽象方法
抽象类的特点
1. 抽象类中不一定有抽象方法，但有抽象方法的类必须为抽象类
2. 抽象类不能实例化，也就是不能通过new 出来
3. 抽象类由具体的子类进行实例化，也就是子类重写父类中的抽象方法
4. 子类必须对父类中的所有抽象方法进行重写
5. 在抽象类中可以定义非抽象方法
6. 子类不重写抽象类中的方法，那么该子类仍然为抽象类
7. 抽象类中可以有构造方法，用于子类访问父类时的数据初始化

// Animal.class 

//因为类中存在抽象方法，所以此类也需要用abstarct 修饰
public abstract class Animal {

//    在这里我们定义一个吃方法，没有方法体, 因为没有方法体，所以需要用abstarct修饰
    public abstract void eat();
}

// Dog.class 

public class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("我是狗类， 这是重写父类的吃方法。");
    }
}

5、封装

封装：也就是将一个客观的事物封装成抽象类，并且类可以把自己的属性和方法只让可信的类或对象操作，对不可信的类进行隐藏。
封装类的规则
1. 将类的某些信息隐藏在内部，不允许外部的程序直接访问
2. 通过该类提供的方法实现对隐藏信息的操作与访问
封装的实现：
1. 修改属性的私有信（使用private关键词修饰，只能被本类内部使用）
2. 创建属性的getter/setter方法并设置为public，用于属性的读写
3. 在getter/setter方法中加入属性控制语句，（对属性的赋值合理性进行判断）

// Jack.class 测试类

//    Jack 是一个学生，就需要继承学生的基类
public class Jack {
    public static void main(String[] args) {

        Student student = new Student();

//        1、设置学生姓名
        student.setName("Jack");
        System.out.println("学生姓名"+student.getName());
//   【结果】   学生姓名Jack

//        2、设置学生虚假年龄
        student.setAge(200);
        System.out.println("学生年龄"+student.getAge());
//   【结果】   学生年龄0
//   【原因】   因为200属于不合理的年龄。所以赋值操作失败

//        3、设置学生真实年龄
        student.setAge(20);
        System.out.println("学生年龄"+student.getAge());
//   【结果】   学生年龄20

    }
}

// Student.class 封装学生类

public class Student {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
//        对age 的赋值操作进行合理性判断
//          如果学生的年龄大于120岁，则认为不合理，就不执行age的赋值操作
        if(age > 120) return;
        this.age = age;
    }
}

6、接口

接口的特性
1. 没有方法体
2. 实现此接口的类必须重写接口中的所有方法，（若子类不重写接口中的方法，就在子类class前加上 abstract ）
3. 接口是不可以被实例化的（也就是不能像对象一样被 new 出来）
4. 接口中的定义的成员变量（只能是常量）默认是加上public static final关键字的，接口中的成员变量是不可以修改的（直接通过接口的名称访问即可）
5. 在jdk8之前是不可以在接口中定义非抽象方法的，但在jdk8之后可以定义非抽象方法，但必须加上 default 关键字修饰
6. 接口中没有构造方法，但是抽象类中是有构造方法的
7. 实现类先执行Object中的无参构造方法，在执行实现类中的无参构造方法
接口使用多态的特性

7、枚举

枚举类的作用
- 枚举用于做信息标志，信息父类。
枚举类的特点：

枚举类是final修饰的，不能被继承
枚举类默认继承了枚举类型:java.lang.Enum.
枚举的第一行列出的是枚举的对象，而且是用常量保存的，所以枚举类的第一行写的都是常量的名称，默认储存了枚举对象
枚举类的构造器是私有的，在非枚举类中是无法使用的
枚举类相当于是多利设计模式，。。。对象相当于是单例设计模式

枚举类的格式

权限修饰符 enum 枚举类名称{ 名称1，名称2， …}

package javaSE.面向对象编程.枚举;

public class EnumDemo01 {
    public static void main(String[] args) {
        Sex s1 = Sex.BOY;
        System.out.println("s1 = " + s1);
        System.out.println("s1.ordinal() = " + s1.ordinal());
        Sex s2 = Sex.GIRL;
        System.out.println("s2 = " + s2);
        System.out.println("s2.ordinal() = " + s2.ordinal());
        // ordinal()方法，来自于父类-枚举类型， 可以获取枚举类的索引
    }
}

public enum Sex{
    BOY, GIRL;
}

8、包 9、内部类

内部类的特性
1. 内部类可以直接访问外部类的成员属性（包括私有的）
2. 外部类中要访问内部类中的成员属性，就必须new出内部类
注意
1. 通常在企业中，外界是不可以访问内部类的，所以使用private来修饰内部类保证数据的安全性

成员内部类，外界怎么访问呢？

格式：外部类名.内部类名对象名 = 外部类对象.内部类对象
范例：MayiktA.MayiktB mayiktB = new MayiktA().new MayiktB();

package javaSE.面向对象编程.内部类.外界访问内部类;

// 外部类
public class MayiktA {

//    内部类
    public class MayiktB {}

}

package javaSE.面向对象编程.内部类.外界访问内部类;

// 测试类
public class Test {

    public static void main(String[] args) {

//        访问MayiktA 的内部类MayiktB
        MayiktA.MayiktB mayiktB = new MayiktA().new MayiktB();

    }

}

静态内部类，外界如何访问？

外界如果访问静态的内部类中，直接 new 外部类.内部类( )
若静态内部类需要访问外部类的成员属性，则此成员必须被static修饰

package javaSE.面向对象编程.内部类.静态内部类;

public class MayiktA {
    
    private String name;
    private static int age;
    
    public static void show(){
        System.out.println("这是外部类的show方法");
    }
    
    public static class MayiktB{
        public static void main(String[] args) {
            System.out.println(name);
//      【报错】    这里的name是爆红的，因为静态内部类只能访问外部类中被static修饰的成员属性
            System.out.println(age);
//      【结果】    这里的就可以访问age，因为age被static关键字修饰了
            show();
//      【结果】    这里的就可以访问show方法，因为show方法被static关键字修饰了
        }
    }
    
}

局部内部类

在方法中定义的内部类为局部内部类，该局部内部类只能在此方法中使用，此方法外面无法使用

package javaSE.面向对象编程.内部类.局部内部类;

//外部类
public class MayiktA {
//    外部方法
    public void show(){
//        局部内部类
        class MayiktB {
            public void test(){
                System.out.println("这是show方法中的局部内部类中的test方法");       
            }
        }
//        局部内部类只能在该方法中使用，方法外面无法使用
        MayiktB mayiktB = new MayiktB();
    }
    MayiktB mayiktB = new MayiktB();
//    【报错】  这里的MayiktB是爆红的，因为该类在show方法中，所以是局部内部类，只能在show方法中使用。
}

匿名内部类

new出抽象类或者接口，然后重写方法
要知道，接口和抽象类是不能够实例化的，但是匿名内部类中可以new出接口和抽象类，是因为匿名内部类的底层帮你创建了实现类，其名称是 null 的 —– 这是在编译阶段实现的

package javaSE.面向对象编程.内部类.匿名内部类;

//外部类
public class Test01 {
    public static void main(String[] args) {
//        这里的new出来的接口是因为匿名内部类底层帮助创建了实现类
        AnimalParent dog = new AnimalParent() {
            @Override
            public void eat() {
                System.out.println("我是 dog， 这是我的吃方法");
            }
        };
        dog.eat();
    }
}

10、API

api是jdk底层封装好的，可以直接拿来用

11、关键字

static （静态）
- 被static 修饰的成员变量和方法，被类的所有对象共享访问，静态修饰的访问特点：直接类名 . 成员变量 / 方法
- static 修饰成员变量：
  1. 被其修饰的成员变量，在类被同时实例化多次时，所有的实例化中的这个成员变量的指向都是同一个
  2. 使用static 修饰的常量，也可以直接使用类名 . 常量名的形式访问
- static 修饰成员方法：
  - 在同一个类中
    1. 静态方法：可以访问本类中的静态方法和静态成员变量，但是不可以访问非静态方法和非静态成员变量
    2. 非静态方法：可以访问本类中的静态方法和静态成员变量，也可以访问非静态方法和非静态成员变量
abstract (抽象的)
- 被此修饰符修饰的方法，被子类继承的时候，都要被子类重写
- 详解，请跳转至抽象类
final（定义常量）
- 被该关键字修饰的基本数据类型，定义好之后是不可以被修改的
- 通常用来定义常量 public final int code = 200

12、Object

toString方法

若打印对象时，不重写toString方法，那么输出的是内存地址（hashCode）
重写toString方法之后，就可以返回对象的字符串形式

//重写toString方法
@Override
    public String toString() {
        return "Student{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }

equals方法

对象比较

若未重写equals方法，默认调用的是Object父类的equals方法，比较的是两个对象的内存地址
重写equals方法后，比较的是对象的每个值是否相等

// 重写equals方法    
@Override
    public boolean equals(Object o) {
//        判断两个对象的内存地址是否相同
        if (this == o) return true;
//        判断两个对象的类型是否相同，不相同直接返回false
        if (!(o instanceof Student)) return false;
//        如果两个对象的类型相同就将传入的值强转为Student类型
        Student student = (Student) o;
//        最后在每个值进行 一 一 比较
        return age == student.age &&
                Objects.equals(name, student.name);
    }

字符串比较

equals()比较字符串就不需要重写了

//底层源码
public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

13、泛型

什么是泛型？
- 泛型就是一个标签：<数据类型>
- 泛型可以在编译阶段约束只能操作某种类型
注意：JDK1.7之后，泛型后面的声名可以省略不写
泛型和集合都只能支持引用数据类型，不支持基本数据类型，（若使用基本数据类型，则会自动进行包装整引用数据类型）

// 泛型就是在编译阶段约束只能操作某种数据类型
// 后期，可以通过反射向泛型里面添加别的类型
package javaSE.高级教程.泛型;

import java.util.ArrayList;

public class Demo01 {
    public static void main(String[] args) {
        //    这时候不使用泛型
        ArrayList list = new ArrayList();
//        在编译期没有约束，任何类型都可以往里面进行添加
        list.add("Java");
        list.add(true);
        list.add(1);
        list.add(null);
        System.out.println("list = " + list);
//        【结果】 list = [Java, true, 1, null]

//        使用泛型之后
        ArrayList list1 = new ArrayList<>();
        list1.add("Mysql");
//        list1.add(true);
//        就不能添加除String类型之外的类型
    }
}

泛型接口：核心思想=> 在实现接口的时候传入真实的数据类型，这样重写的方法就是对该数据类型进行操作

package javaSE.高级教程.泛型.接口泛型;

//这里使用泛型的好处就是不用写死Demo02的数据类型， 这样就可以重复使用这个接口
public interface Demo02 {
    void add(E stu);
    void delete(E stu);
    void update(E stu);
    E query(int id);
}

package javaSE.高级教程.泛型.接口泛型;

//这里使用泛型，然后下面的参数类型就都为Student类型了
public class Demo02Impl implements Demo02 {
    @Override
    public void add(Student stu) {

    }

    @Override
    public void delete(Student stu) {

    }

    @Override
    public void update(Student stu) {

    }

    @Override
    public Student query(int id) {
        return null;
    }
}

通配符：

E , T , K , V , 可以在定义泛型的时候代表一切类型
? 可以在使用泛型的时候代表一切类型

package javaSE.高级教程.泛型.通配符;

// 所有汽车一起比赛的一个demo

import java.util.ArrayList;

public class Demo03 {
    public static void main(String[] args) {
        ArrayList bwms = new ArrayList();
        bwms.add(new BWM());
        bwms.add(new BWM());
        bwms.add(new BWM());
        run(bwms);

        ArrayList bcs = new ArrayList();
        bcs.add(new BENCHI());
        bcs.add(new BENCHI());
        bcs.add(new BENCHI());
        run(bcs);
    }

//    如果这里ArrayList使用泛型BWM,那么就只能BWM品牌的车子进行比赛
//    public static void run(ArrayList car) {}

//    这里可以泛型的通配符 ？ 就可以接收一切数据类型的ArrayList
    public static void run(ArrayList car) {}
}

class Car{

}

class BWM extends Car{

}

class BENCHI extends Car{

}

泛型的上下限
- ? extend Car : 那么？必须是Car 或者是其子类。
- ? super Car : 那么？必须是Car 或者是其父类

二、高级教程 1、数据结构

队列
- 先进先出，后进后出
栈
- 进栈/压栈出栈/弹栈，先进后出，后进先出原则
数组
链表
红黑树
- 二叉树
- 二叉平衡树
- 红黑树

2、Collection单列集合

集合的特点：1、类型可以不确定 2、大小不固定 3、集合有很多种，不同场景使用的集合不同
集合适用于开发中的增删改查操作、
Collection集合是java中集合的祖宗类
Collection的方法子类都可以使用（集合重写了toString方法）
1. add() : 添加元素，添加成功返回true。
2. clear()：清空集合的所有元素。
3. isEmpty()：判断集合是否为空。
4. size()：获取集合的大小。
5. contains()：判断集合中是否包含某个元素。
6. remove()：删除某个元素，如果有多个重复的元素，默认删除最前面的一个。
7. toArray()：将集合转为数组，接收的变量类型必须为Object[] ，
  
  如果要转成String类型的数组，就需要使用toArray(String[]::new) 这样转出来的就是字符串数组。
8. addAll()：可以将两个集合合并。
List集合的方法
1. add(index, element)：根据索引向集合中添加元素
2. remove(index)：根据索引删除元素
3. get(index)：根据索引获取元素
4. set(index, element)：用指定元素替换集合中指定位置的元素，返回更新前的元素
Collection集合的子类
- Set系列集合：添加的元素是无序的、不重复的、无索引的。（Set系列集合是基于哈希表存储数据的，它的增删改查的性能)
  - —— HashSet: 添加的元素是无序的、不重复的、无索引的。
    - —— LinkedHashSet：添加的元素是有序的、不重复的、无索引的。
  - —— TreeSet：按照大小排列，默认升序排序，不重复的、无索引的。（排序不重复集合）
    
    TreeSet集合自排序的方式
    1. 有值特性的元素直接可以按照升序排序
    2. 字符串类型的元素会按照首字符的ascii 排序
    3. 对于自定义的引用数据类型，TreeSet默认无法排序，执行的时候直接报错，因为人家不知道排序规则
    自定义的引用数据类型的排序实现
    
    对于自定义的引用数据类型，TreeSet默认无法排序
    
    所以我们需要制定排序大小的规则，程序员制定排序大小规则的方案有2种：
    1. 直接为对象的类重写比较器规则接口Comparable，重写比较方法（拓展方式）
```
package javaSE.高级教程.Set集合.TreeSet集合;

import java.util.Objects;

public class Student implements Comparable {
    private String name;
    private int age;
    private String gander;

    public Student(String name, int age, String gander) {
        this.name = name;
        this.age = age;
        this.gander = gander;
    }

//    重写实现 TreeSet的排序规则
    @Override
    public int compareTo(Student o) {
//        规则： Java规则
//        如果程序员认为比较者大于被比较则 返回正数；
//        如果程序员认为比较者小于被比较则 返回负数；
//        如果程序员认为比较者等于被比较则 返回0；

//        if(this.age > o.age){
//            return  1;
//        } else if (this.age < o.age) {
//            return -1;
//        }
//        return 0;
        // 简写
        return this.age - o.age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + ''' +
                ", age=" + age +
                ", gander='" + gander + ''' +
                '}';
    }

    …… 省略getter and setter
}
```
```
package javaSE.高级教程.Set集合.TreeSet集合;

import java.util.TreeSet;

public class demo {
    public static void main(String[] args) {
        TreeSet objects = new TreeSet<>();
        objects.add(new Student("小潘", 20,"女"));
        objects.add(new Student("虎子", 25,"男"));
        objects.add(new Student("阮阮", 22,"女"));
        System.out.println("objects = " + objects);
//      【结果】：objects = [Student{name='小潘', age=20, gander='女'}, 
//        				  Student{name='阮阮', age=22, gander='女'}, 
//      				  Student{name='虎子', age=25, gander='男'}]
    }
}
```
      2、直接为集合设置比较器Comparator对象，重写比较方法
```
//        若类和集合都有比较规则，就近原则，使用集合的比较规则
        TreeSet objects1 = new TreeSet<>(new Comparator() {
            @Override
            public int compare(Student o1, Student o2) {
                return o2.getAge() - o1.getAge();
            }
        });
        objects1.add(new Student("小潘", 20,"女"));
        objects1.add(new Student("虎子", 25,"男"));
        objects1.add(new Student("阮阮", 22,"女"));
        System.out.println("objects1 = " + objects1);
//      objects1 = [Student{name='虎子', age=25, gander='男'}, 
//                  Student{name='阮阮', age=22, gander='女'}, 
//                  Student{name='小潘', age=20, gander='女'}]
```
- Set系列集合无序的原因？
  - Set系列集合添加元素无序的根本原因是因为底层采用了哈希表存储元素
  - 哈希表
    - JDK1.8之前：哈希表 = 数组 + 链表 + （哈希算法）
    - JDK1.8之后：哈希表 = 数组 + 链表 + 红黑树 + (哈希算法)
      
      当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找的时间
  - 哈希算法
    1. 先获取元素对象的哈希值
    2. 让当前对象的哈希值对底层数组长度求余
    3. 将求余的结果作为对象元素在底层数组的索引位置
    4. 把该对象元素存入到该索引位置，若该索引已有元素，就在此索引位置建立链表存储，（在）
- Set系列集合不重复的原因？
  - Set系列集合会先让对象调用hashCode()方法获取两个对象的哈希值比较
    
    /
    
    false true
    
    /
    
    不重复继续让两个对象进行equals比较
    
    /
    
    false true
    
    /
    
    不重复重复了
    
    需求：若只要对象的内容一样就认为两对象重复了，那么就需要重写对象的hashCode方法和equals方法
- List系列集合：添加的元素是有序的、可重复的、有索引的。（查询多增删少，使用ArrayList集合；查询少增删首位较多，用LinkedList集合）
  - —— ArrayList：添加的元素是有序的、可重复的、有索引的。
  - —— LinekdList：添加的元素是有序的、可重复的、有索引的。
    1. addFirst(element)：将指定元素插入此列表的开头。
    2. addLast(element)：将指定元素插入此列表的末尾。
    3. getFirst()：返回此列表的第一个元素
    4. getLast()：返回此列表的最后一个元素
    5. removeFirst()：移除并返回此列表的第一个元素
    6. removeLast()：移除并返回此列表的最后一个元素
    7. pop()：从此列表所表示的堆栈处弹出一个元素
    8. push(element)：将元素推入此列表，所表示的堆栈
  - —— Vector：是线程安全的，速度慢，工作中很少使用
Collection集合的遍历方式一、迭代器
- 获取对应集合的迭代器对象
  - Iterator it = 集合.iterator();
- 迭代器的基本方法
  - public Iterator iterator(){} 获取对应集合的迭代器对象
  - next() 获取下一个元素
  - Boolean hasNext() 判断是否有下一个元素
二、foreach（增强for循环）
- 优点：foreach遍历集合或数组很方便
- 缺点：foreach遍历无法知道遍历到哪个元素了，以为没有索引
- foreach是一种遍历形式，可以遍历集合或者数组
- foreach遍历集合实际上是迭代器遍历的简化写法
- foreach遍历的关键是其语法格式 for(遍历集合的类型变量：集合){}
三、lambda表达式，（jdk1.8之后的新技术）
- 集合.foreach(变量 -> {})
```
package javaSE.高级教程.迭代器;

import java.util.ArrayList;
import java.util.Iterator;

public class demo {
    public static void main(String[] args) {
        ArrayList lists = new ArrayList<>();
        lists.add("贾乃亮");
        lists.add("王宝强");
        lists.add("小妹妹");

//        new 出迭代器对象
        Iterator it = lists.iterator();

//        public Iterator iterator(){} 获取对应集合的迭代器对象
//        Boolean hasNext() 判断是否有下一个元素
//        next() 获取下一个元素

//    1、迭代器遍历    遍历出lists的元素
        while(it.hasNext()){
            String ele = it.next();
            System.out.println("ele = " + ele);
        }
//    2、lambda表达式遍历  lambda表达式，jkd1.8之后的新技术
        lists.forEach(s -> System.out.println("s = " + s));
//        System.out.println("lists = " + lists);

    }
}
```

3、Map双列集合 3.1 Map集合的体系

Map< K ，V >（接口，Map集合的祖宗类）

TreeMap< K ，V > HashMap< K ，V >（实现类、经典的，用的最多）

LinkedHashMap< K ，V >（实现类）

3.2 Map集合的特点

Map集合的特点都是由键决定的
Map集合的键是无序的，不重复的、无索引的，且Map集合后面重复的键会覆盖前面的整个元素
Map集合的值无要求
Map集合的键值对都可以为null
Map集合的键和值都可以为自定义类型，若需要判断自定义类型的键重复，那么就需要重写hashCode()和equals()方法

3.3 Map集合的API

put(k,v) 向map集合中添加元素
clear() 清除map集合中的所有元素
isEmpty() 判断map集合是否为空，返回布尔值
get(key) 根据key获取value
remove() 根据key删除元素
containsKey(key) 判断map集合是否包含key 返回布尔值
containsValue(value) 判断集合是否包含某个值返回布尔值
keySet() 获取全部键的集合返回值为Set()集合
value() 获取全部值的集合返回值为Collection集合
size() 集合的大小
putAll( Map )合并两个map集合

3.4 Map集合的遍历

1、先使用keyset返回键的set集合，再通过遍历set集合获取value

2、键值对遍历方式，使用entrySet()将map集合的键值对整体转化为set集合

Set> entries = maps.entrySet();

for (Map.Entry entry : entries) {
    String key = entry.getKey();
    Integer value1 = entry.getValue();
    System.out.println(key+"="+value1);
}

3、lambda表达式 forEach()

maps.forEach((k,v) -> System.out.println(k+"=="+v) );

3.5 LinkedHashMap

特点：有序，不重复，无索引的键值对集合

小结：1、HashMap是无序不重复的键值对集合

2、LinkedHashMap是有序不重复的键值对集合

3、他们都是基于哈希表存储数据的

3.6 TreeMap

1、双精度浮点型之间的比较，可以使用API Double.compare(o1,o2)

4、异常 4.1 什么是异常？

异常是程序在编译、执行的过程中可能出现的问题；
异常是应该尽量提前避免的
异常一旦出现，如果没有提前避免，就会导致程序退出JVM虚拟机而终止。
重写方法申明抛出的异常，应该与父类被重写方法的异常一致，或者更小
当处理多异常时，捕获处理，前面的异常类不能位后面异常类的父类

例如：try{} catch(Exception e){} catch(ParseException e){} 在这里Exception 类为ParseException类的父类，所有后面抛出的ParseException无意义

4.2 异常体系

Java中异常继承的根类是Thorwable

Throwable（根类，不是异常类）

Error Exception（异常，需要处理）

编译时异常运行时异常（RuntimeException）

Error：错误的意思，严重错误Error，无法通过处理错误来解决，一旦出现，只能优化项目，再重启

Exception: 异常类，它是在开发中代码在编译、执行期间可能出现的错误，它是需要提前处理的

4.3 Exception异常分类

1、编译时异常：继承Exception异常或者其子类，编译阶段就会报错，必须由程序员处理，否则代码编译不通过，无法执行

2、运行时异常：继承RuntionException的异常或则其子类，编译阶段是不会出错的，他是在运行阶段可能出现的错误，运行时异常可以处理，也可以不处理，在编译期是不会报错的，但是在运行期间可能会报错，建议还是需要处理运行时可能出现的异常的

4.4 运行时异常（常见的）

数组索引越界：ArrayIndexOutOfBoundsException

int[] str = {1,2,3};
System.out.println(str[3]);
//        【结果】Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3

空指针异常：NullPointerException

int [] c = null;
System.out.println(c.length);
//        【结果】Exception in thread "main" java.lang.NullPointerException

类型转换异常：ClassCastException

//    例如：将String强转位Int类型        
Object o = "齐天大圣";
Integer i = (Integer) o;
//        【结果】Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer

例如：将String强转位Int类型

迭代器遍历没有此元素异常：NoSuchElementException

Set

JAVA学习笔记

! 恭喜你！ 成功通过 软件创新工作室2021秋的招新计划

.Net相关栏目本月热门文章

! 恭喜你！
成功通过
软件创新工作室2021秋的招新计划