阿里代码命名规约

1. 【强制】方法名、参数名、成员变量、局部变量都统一使用 lowerCamelCase 风格，必须遵从驼峰形式。正例： localValue / getHttpMessage() / inputUserId
2. 【强制】类名使用 UpperCamelCase 风格，必须遵从驼峰形式，但以下情形例外：DO / BO / DTO / VO / AO 正例：MarcoPolo / UserDO / XmlService / TcpUdpDeal / TaPromotion 反例：macroPolo / UserDo / XMLService / TCPUDPDeal / TAPromotion
3. 【强制】常量命名全部大写，单词间用下划线隔开，力求语义表达完整清楚，不要嫌名字长。正例：MAX_STOCK_COUNT 反例：MAX_COUNT
4. 【强制】POJO 类中布尔类型的变量，都不要加 is，否则部分框架解析会引起序列化错误。反例：定义为基本数据类型 Boolean isDeleted；的属性，它的方法也是 isDeleted()，RPC阿里巴巴 Java 开发手册框架在反向解析的时候，“以为”对应的属性名称是 deleted，导致属性获取不到，进而抛出异常。
5. 【强制】包名统一使用小写，点分隔符之间有且仅有一个自然语义的英语单词。包名统一使用单数形式，但是类名如果有复数含义，类名可以使用复数形式。正例： 应用工具类包名为 com.alibaba.open.util、类名为 MessageUtils（此规则参考spring 的框架结构）

一. 基础语法重要知识点

1. 隐式转换

概念：

​ 也叫自动类型提升。
​ 就是把一个取值范围小的数据或者变量，赋值给另一个取值范围大的变量。此时不需要我们额外写代码单独实现，是程序自动帮我们完成的。

简单记忆：

​ 就是小的给大的，可以直接给。

两种提升规则：

• 取值范围小的，和取值范围大的进行运算，小的会先提升为大的，再进行运算。
• byte、short、char三种类型的数据在运算的时候，都会直接先提升为int，然后再进行运算。

取值范围从小到大的关系：

​byte short int long float double

2.强制转换

概念：

​ 如果要把一个取值范围大的数据或者变量赋值给另一个取值范围小的变量。是不允许直接操作。
​ 如果一定要这么干，就需要加入强制转换。

书写格式：

​ 目标数据类型 变量名 = （目标数据类型）被强转的数据；

简单理解：

​ 要转成什么类型的，那么就在小括号中写什么类型就可以了。

注意点

• 如果要定义 一个整数类型的变量，不知道选择哪种数据类型了，默认使用int。
• 如果要定义 一个小数类型的变量，不知道选择哪种数据类型了，默认使用double。
• 如果要定义一个long类型的变量，那么在数据值的后面需要加上L后缀。（大小写都可以，建议大写。）
• 如果要定义一个float类型的变量，那么在数据值的后面需要加上F后缀。（大小写都可以）
• 强制转换有可能会导致数据发生错误。（数据的精度丢失）

案例：

public class OperatorDemo2 {
    public static void main(String[] args) {
        double a = 12.3;
        int b = (int) a;
        System.out.println(b);//12
    }
}

3. 运算符总结

• 字符串运算：字符串只有+操作，没有其他操作。
• 扩展的赋值运算符中隐层还包含了一个强制转换。以+=为例。当a和b均为byte类型时，a += b ;实际上相当于 a = (byte)(a + b);
• && 和 & 、||和|的运行结果都是一模一样的。但是&&和||是短路逻辑运算符可以提高程序的运行效率。

4. 键盘录入数据总结

• next（），nextInt（），nextDouble（）在接收数据的时候，会遇到空格，回车，制表符其中一个就会停止接收数据。但是这些符号 + 后面的数据还在内存中并没有接收。如果后面还有其他键盘录入的方法，会自动将这些数据接收。
• nextLine() nextLine（）方法是把一整行全部接收完毕。
• 两套键盘录入不能混用，如果混用会有严重的后果,导致nextLine接收到的是接收不到数据。

二. Java重要API

1. String字符串

重点：Java的String类为不可变类型，意思就是String str = “abc”，这个"abc"是无法变化的，而str可以更改其引用比如str = “bcd”，只是常量池中的"abc"无法被更改。如果非要更改可以用 StringBuilder().append()

1. 字符串存储的内存原理

   String s = “abc”；直接赋值

   特点：

   ​ 此时字符串abc是存在字符串常量池中的。

   ​ 先检查字符串常量池中有没有字符串abc，如果有，不会创建新的，而是直接复用。如果没有abc，才会创建一个新的。

   所以，直接赋值的方式，代码简单，而且节约内存。

2. new出来的字符串

   看到new关键字，一定是在堆里面开辟了一个小空间。

   String s1 = new String（“abc”）；

   String s2 = “abc”；

   s1记录的是new出来的，在堆里面的地址值。

   s2是直接赋值的，所以记录的是字符串常量池中的地址值。

3. ==号比较的到底是什么？
   如果比较的是基本数据类型：比的是具体的数值是否相等。
   如果比较的是引用数据类型：比的是地址值是否相等。
   结论： 只能用于比较基本数据类型。不能比较引用数据类型。

2. ArrayList类常用方法（仅存储引用类型的数据）

2.1 构造方法

方法名	说明
public ArrayList()	创建一个空的集合对象

2.2 成员方法

方法名	说明
public boolean add(要添加的元素)	将指定的元素追加到此集合的末尾
public boolean remove(要删除的元素)	删除指定元素,返回值表示是否删除成功
public E remove(int index)	删除指定索引处的元素，返回被删除的元素
public E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
public E get(int index)	返回指定索引处的元素
public int size()	返回集合中的元素的个数

遍历直接按下标顺序类似数组一样遍历即可。

三. 面向对象进阶

1 static关键字

1.当 static 修饰成员变量或者成员方法时，该变量称为静态变量，该方法称为静态方法。该类的每个对象都共享同一个类的静态变量和静态方法。任何对象都可以更改该静态变量的值或者访问静态方法。但是不推荐这种方式去访问。因为静态变量或者静态方法直接通过类名访问即可，完全没有必要用对象去访问。

2.无static修饰的成员变量或者成员方法，称为实例变量，实例方法，实例变量和实例方法必须创建类的对象，然后通过对象来访问。

3.static修饰的成员属于类，会存储在静态区，是随着类的加载而加载的，且只加载一次，所以只有一份，节省内存。存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。它优先于对象存在，所以，可以被所有对象共享。static修饰的成员方法中不可以出现非static类型的成员变量/方法。

4.无static修饰的成员，是属于对象，对象有多少个，他们就会出现多少份。所以必须由对象调用。

2 继承extends

• 子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。

• super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。

• super(…)和this(…)是根据参数去确定调用父类哪个构造方法的。

• super(…)可以调用父类构造方法初始化继承自父类的成员变量的数据。

• this(…)可以调用本类中的其他构造方法。

1. Java只支持单继承，不支持多继承。
2. 一个类可以有多个子类。
3. 可以多层继承：A继承B，C继承A。

3 多态以及多态转型

• 调用成员变量时：编译看左边，运行看左边
• 调用成员方法时：编译看左边，运行看右边
• 多态编译阶段是看左边父类类型的，如果子类有些独有的功能，此时多态的写法就无法访问子类独有功能了。即多态必须子类重写父类的方法，如果是子类单独有的方法则无法显示出多态。

代码示例：

Fu f = new Zi()；
//编译看左边的父类中有没有name这个属性，没有就报错
//在实际运行的时候，把父类name属性的值打印出来
System.out.println(f.name);
//编译看左边的父类中有没有show这个方法，没有就报错
//在实际运行的时候，运行的是子类中的show方法
f.show();

多态的写法就无法访问子类独有功能了。

注意，父类范围大，子类范围小，类比数据的转型，小转大自动转，大转小需强制
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。

多态的转型分为向上转型（自动转换）与向下转型（强制转换）两种。

• 向上转型（自动转换）：多态本身是子类类型向父类类型向上转换（自动转换）的过程，这个过程是默认的。
  当父类引用指向一个子类对象时，便是向上转型。

使用格式：

父类类型  变量名 = new 子类类型();
如：Animal a = new Cat();

• 向下转型（强制转换）：父类类型向子类类型向下转换的过程，这个过程是强制的。
  一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。
  使用格式：

子类类型 变量名 = (子类类型) 父类变量名;
如:Aniaml a = new Cat();
   Cat c =(Cat) a;  

4 抽象类，接口，内部类

4.1 抽象类

• 如果一个类包含抽象方法，那么该类必须是抽象类。注意：抽象类不一定有抽象方法，但是有抽象方法的类必须定义成抽象类。

定义格式：

public abstract class Animal {
    public abstract void run()；
}

• 继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。
• 创建抽象类,抽象类不能创建对象，假设抽象类里面的抽象方法没有方法体，无法执行，所以不让我们创建对象。

4.2 接口以及实现 implements

接口是更加彻底的抽象，JDK7之前，包括JDK7，接口中全部是抽象方法。接口同样是不能创建对象的。 在接口中定义的成员变量默认会加上： public static final修饰，所以不需要自己手动添加

• 在接口中定义的成员变量默认会加上： public static final修饰。也就是说在接口中定义的成员变量实际上是一个常量。

/**接口的实现：接口是可以被多实现的
    在Java中接口是被实现的，实现接口的类称为实现类。
    实现类的格式:*/
class 类名 implements 接口1,接口2,接口3...{

}

类实现接口的要求和意义:

1. 必须重写实现的全部接口中所有抽象方法。
2. 如果一个类实现了接口，但是没有重写完全部接口的全部抽象方法，这个类也必须定义成抽象类。
3. 意义：接口体现的是一种规范，接口对实现类是一种强制性的约束，要么全部完成接口申明的功能，要么自己也定义成抽象类。这正是一种强制性的规范。

总结：

1. 类与接口之间是多实现的关系：一个类可以同时实现多个接口
2. 接口与接口的多继承关系：一个接口可以同时继承多个接口

4.3 内部类

成员内部类特点：

• 无static修饰的内部类，属于外部类对象的。
• 宿主：外部类对象。
  内部类的使用格式：

 外部类.内部类。 // 访问内部类的类型都是用 外部类.内部类

获取成员内部类对象的两种方式：

方式一：外部直接创建成员内部类的对象

外部类.内部类 变量 = new 外部类（）.new 内部类（）;

方式二：在外部类中定义一个方法提供内部类的对象

案例演示

方式一：
public class Test {
    public static void main(String[] args) {
        //  宿主：外部类对象。
       // Outer out = new Outer();
        // 创建内部类对象。
        Outer.Inner oi = new Outer().new Inner();
        oi.method();
    }
}

class Outer {
    // 成员内部类，属于外部类对象的。
    // 拓展：成员内部类不能定义静态成员。
    public class Inner{
        // 这里面的东西与类是完全一样的。
        public void method(){
            System.out.println("内部类中的方法被调用了");
        }
    }
}

方式二：
public class Outer {
    String name;
    private class Inner{
        static int a = 10;
    }
    public Inner getInstance(){
        return new Inner();
    }
}

public class Test {
    public static void main(String[] args) {
        Outer o = new Outer();
        System.out.println(o.getInstance());


    }
}

成员内部类的细节

编写成员内部类的注意点：

1. 成员内部类可以被一些修饰符所修饰，比如： private，默认，protected，public，static等
2. 在成员内部类里面，JDK16之前不能定义静态变量，JDK16开始才可以定义静态变量。
3. 创建内部类对象时，对象中有一个隐含的Outer.this记录外部类对象的地址值。（请参见3.6节的内存图）

详解：

1. 内部类被private修饰，外界无法直接获取内部类的对象，只能通过3.3节中的方式二也就是提供一个get方法获取内部类的对象
2. 被其他权限修饰符修饰的内部类一般用3.3节中的方式一直接获取内部类的对象
3. 内部类被static修饰是成员内部类中的特殊情况，叫做静态内部类下面单独学习。
4. 内部类如果想要访问外部类的成员变量，外部类的变量必须用final修饰，JDK8以前必须手动写final，JDK8之后不需要手动写，JDK默认加上。

内部类面试题：

public class Test {
    public static void main(String[] args) {
        Outer.inner oi = new Outer().new inner();
        oi.method();
    }
}

class Outer {	// 外部类
    private int a = 30;

    // 在成员位置定义一个类
    class inner {
        private int a = 20;

        public void method() {
            int a = 10;
            System.out.println(???);	// 10   答案：a
            System.out.println(???);	// 20	答案：this.a
            System.out.println(???);	// 30	答案：Outer.this.a
        }
    }
}

局部内部类 ：定义在方法中的类。

4.4 匿名内部类【重点】

匿名内部类 ：可以创建一个继承父类或者实现接口的对象，而不用真的构建一个子类或者实现类。是内部类的简化写法，他是一个隐含了名字的内部类，开发中，最常用到的内部类就是匿名内部类了。实际上，如果我们希望定义一个只要使用一次的类，就可考虑使用匿名内部类。匿名内部类的本质作用是为了简化代码。

匿名内部类格式

new 父类名或者接口名(){
    // 方法重写
    @Override 
    public void method() {
        // 执行语句
    }
};

匿名内部类特点：

1. 定义一个没有名字的内部类
2. 这个类实现了父类，或者父类接口
3. 匿名内部类会创建这个没有名字的类的对象

以接口为例，匿名内部类的使用，代码如下：

interface Swim {
    public abstract void swimming();
}

public class Demo07 {
    public static void main(String[] args) {
        // 使用匿名内部类
		new Swim() {
			@Override
			public void swimming() {
				System.out.println("自由泳...");
			}
		}.swimming();

        // 接口 变量 = new 实现类(); // 多态,走子类的重写方法
        Swim s2 = new Swim() {
            @Override
            public void swimming() {
                System.out.println("蛙泳...");
            }
        };

        s2.swimming();
        s2.swimming();
    }
}

四. 正则表达式、lambda表达式

1. 正则表达式

在Java中，我们经常需要验证一些字符串，例如：年龄必须是2位的数字、用户名必须是8位长度而且只能包含大小写字母、数字等。正则表达式就是用来验证各种字符串的规则。它内部描述了一些规则，我们可以验证用户输入的字符串是否匹配这个规则。

• 字符类语法：

1. [abc]：代表a或者b，或者c字符中的一个。
2. [^abc]：代表除a,b,c以外的任何字符。
3. [a-z]：代表a-z的所有小写字符中的一个。
4. [A-Z]：代表A-Z的所有大写字符中的一个。
5. [0-9]：代表0-9之间的某一个数字字符。
6. [a-zA-Z0-9]：代表a-z或者A-Z或者0-9之间的任意一个字符。
7. [a-dm-p]：a 到 d 或 m 到 p之间的任意一个字符。

// [a-z&&[^bc]] a-z和非bc的交集。(等同于[ad-z])
System.out.println("a".matches("[a-z&&[^bc]]"));//true
System.out.println("b".matches("[a-z&&[^bc]]")); //false
System.out.println("0".matches("[a-z&&[^bc]]")); //false

• 字符类语法：逻辑运算符

1. &&：并且
2. | ：或者
3. \ ：转义字符

public class Demo {
	public static void main(String[] args) {
		String str = "had";
		
		//1.要求字符串是小写辅音字符开头，后跟ad
		String regex = "[a-z&&[^aeiou]]ad";
		System.out.println("1." + str.matches(regex));
		
		//2.要求字符串是aeiou中的某个字符开头，后跟ad
		regex = "[a|e|i|o|u]ad";//这种写法相当于：regex = "[aeiou]ad";
		System.out.println("2." + str.matches(regex));
	}
}

• 正则表达式 预定义字符

1. “.” ： 匹配任何字符。
2. “\d”：任何数字[0-9]的简写；
3. “\D”：任何非数字[^0-9]的简写；
4. “\s”： 空白字符：[ \t\n\x0B\f\r] 的简写
5. “\S”： 非空白字符：[^\s] 的简写
6. “\w”：单词字符：[a-zA-Z_0-9]的简写
7. “\W”：非单词字符：[^\w]

都是匹配的单个字符，并且对于\d符号需要用转义字符\将\d中的\其转换成普通含义，所以用起来就是\d

public class Demo {
	public static void main(String[] args) {
        //.表示任意一个字符
        System.out.println("你".matches("..")); //false
        System.out.println("你".matches(".")); //true
        
        // \\d只能是任意的一位数字
        System.out.println("a".matches("\\d")); // false
        System.out.println("3".matches("\\d")); // true

        //\\w只能是一位单词字符[a-zA-Z_0-9]
        System.out.println("z".matches("\\w")); // true
        System.out.println("2".matches("\\w")); // true
        System.out.println("21".matches("\\w")); // false
        System.out.println("你".matches("\\w"));//false

        // 非单词字符
        System.out.println("你".matches("\\W")); // true
        System.out.println("---------------------------------------------");
       
        // 以上正则匹配只能校验单个字符。
        // 必须是数字 字母 下划线 至少 6位
        System.out.println("2442fsfsf".matches("\\w{6,}"));//true
        System.out.println("244f".matches("\\w{6,}"));//false
	}
}

• 正则表达式 数量词

1. X? : 0次或1次
2. X* : 0次到多次
3. X+ : 1次或多次
4. X{n} : 恰好n次
5. X{n,} : 至少n次
6. X{n,m}: n到m次(n和m都是包含的)

public class Demo {
	public static void main(String[] args) {
		 // 必须是数字 字母 下划线 至少 6位
        System.out.println("2442fsfsf".matches("\\w{6,}"));//true
        System.out.println("244f".matches("\\w{6,}"));//false

        // 必须是数字和字符 必须是4位
        System.out.println("23dF".matches("[a-zA-Z0-9]{4}"));//true
        System.out.println("23 F".matches("[a-zA-Z0-9]{4}"));//false
        System.out.println("23dF".matches("[\\w&&[^_]]{4}"));//true
        System.out.println("23_F".matches("[\\w&&[^_]]{4}"));//false
	}
}

额外重要的正则表达式知识点：

• (?i) ：表示忽略后面数据的大小写
• 只写+和*表示贪婪匹配

        +? 非贪婪匹配
        *? 非贪婪匹配

        贪婪爬取:在爬取数据的时候尽可能的多获取数据
        非贪婪爬取:在爬取数据的时候尽可能的少获取数据

        ab+:
        贪婪爬取:abbbbbbbbbbbb
        ab+?:
        非贪婪爬取:ab

• String的split方法中使用正则表达式

public String[] split(String regex)
//参数regex表示正则表达式。可以将当前字符串中匹配regex正则表达式的符号作为"分隔符"来切割字符串。

• String类的replaceAll方法中使用正则表达式

public String replaceAll(String regex,String newStr)
//参数regex表示一个正则表达式。可以将当前字符串中匹配regex正则表达式的字符串替换为newStr。

• 正则表达式-分组括号( )

细节：如何识别组号？

只看左括号，不看有括号，按照左括号的顺序，从左往右，依次为第一组，第二组，第三组等等
\\组号: 表示把第X组的内容再出来用一次
\\2: 把首字母拿出来再次使用

//需求1:判断一个字符串的开始字符和结束字符是否一致?只考虑一个字符
//举例: a123a b456b 17891 &abc& a123b(false)
// \\组号:表示把第X组的内容再出来用一次
String regex1 = "(.).+\\1";
System.out.println("a123a".matches(regex1));
System.out.println("b456b".matches(regex1));
System.out.println("17891".matches(regex1));
System.out.println("&abc&".matches(regex1));
System.out.println("a123b".matches(regex1));
System.out.println("--------------------------");


//需求2:判断一个字符串的开始部分和结束部分是否一致?可以有多个字符
//举例: abc123abc b456b 123789123 &!@abc&!@ abc123abd(false)
String regex2 = "(.+).+\\1";
System.out.println("abc123abc".matches(regex2));
System.out.println("b456b".matches(regex2));
System.out.println("123789123".matches(regex2));
System.out.println("&!@abc&!@".matches(regex2));
System.out.println("abc123abd".matches(regex2));
System.out.println("---------------------");

//需求3:判断一个字符串的开始部分和结束部分是否一致?开始部分内部每个字符也需要一致
//举例: aaa123aaa bbb456bbb 111789111 &&abc&&
//(.):把首字母看做一组
// \\2:把首字母拿出来再次使用
// *:作用于\\2,表示后面重复的内容出现日次或多次
String regex3 = "((.)\\2*).+\\1";
System.out.println("aaa123aaa".matches(regex3));
System.out.println("bbb456bbb".matches(regex3));
System.out.println("111789111".matches(regex3));
System.out.println("&&abc&&".matches(regex3));
System.out.println("aaa123aab".matches(regex3));

手机号、座机号、邮箱号限制练习

package com.itheima.a08regexdemo;

public class RegexDemo4 {
    public static void main(String[] args) {
        /*
            需求
            请编写正则表达式验证用户输入的手机号码是否满足要求。请编写正则表达式验证用户输入的邮箱号是否满足要求。请编写正则表达式验证用户输入的电话号码是否满足要求。
            验证手机号码 13112345678 13712345667 13945679027 139456790271
            验证座机电话号码 020-2324242 02122442 027-42424 0712-3242434
            验证邮箱号码 3232323@qq.com zhangsan@itcast.cnn dlei0009@163.com dlei0009@pci.com.cn
        */

        //心得:
        //拿着一个正确的数据，从左到右依次去写。
        //13112345678
        //分成三部分:
        //第一部分:1 表示手机号码只能以1开头
        //第二部分:[3-9] 表示手机号码第二位只能是3-9之间的
        //第三部分:\\d{9} 表示任意数字可以出现9次，也只能出现9次
        String regex1 = "1[3-9]\\d{9}";
        System.out.println("13112345678".matches(regex1));//true
        System.out.println("13712345667".matches(regex1));//true
        System.out.println("13945679027".matches(regex1));//true
        System.out.println("139456790271".matches(regex1));//false
        System.out.println("-----------------------------------");

        //座机电话号码
        //020-2324242 02122442 027-42424 0712-3242434
        //思路:
        //在书写座机号正则的时候需要把正确的数据分为三部分
        //一:区号@\\d{2,3}
        //      0:表示区号一定是以0开头的
        //      \\d{2,3}:表示区号从第二位开始可以是任意的数字，可以出现2到3次。
        //二:- ?表示次数，日次或一次
        //三:号码 号码的第一位也不能以日开头，从第二位开始可以是任意的数字，号码的总长度:5-10位
        String regex2 = "0\\d{2,3}-?[1-9]\\d{4,9}";
        System.out.println("020-2324242".matches(regex2));
        System.out.println("02122442".matches(regex2));
        System.out.println("027-42424".matches(regex2));
        System.out.println("0712-3242434".matches(regex2));

        //邮箱号码
        //3232323@qq.com zhangsan@itcast.cnn dlei0009@163.com dlei0009@pci.com.cn
        //思路:
        //在书写邮箱号码正则的时候需要把正确的数据分为三部分
        //第一部分:@的左边 \\w+
        //      任意的字母数字下划线，至少出现一次就可以了
        //第二部分:@ 只能出现一次
        //第三部分:
        //      3.1         .的左边[\\w&&[^_]]{2,6}
        //                  任意的字母加数字，总共出现2-6次(此时不能出现下划线)
        //      3.2         . \\.
        //      3.3         大写字母，小写字母都可以，只能出现2-3次[a-zA-Z]{2,3}
        //      我们可以把3.2和3.3看成一组，这一组可以出现1次或者两次
        String regex3 = "\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2}";
        System.out.println("3232323@qq.com".matches(regex3));
        System.out.println("zhangsan@itcast.cnn".matches(regex3));
        System.out.println("dlei0009@163.com".matches(regex3));
        System.out.println("dlei0009@pci.com.cn".matches(regex3));


        //24小时的正则表达式
        String regex4 = "([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d";
        System.out.println("23:11:11".matches(regex4));

        String regex5 = "([01]\\d 2[0-3])(:[0-5]\\d){2}";
        System.out.println("23:11:11".matches(regex5));
    }
}

用户名和身份证号限制练习

public class RegexDemo5 {
    public static void main(String[] args) {
        /*
            正则表达式练习:
            需求
            请编写正则表达式验证用户名是否满足要求。要求:大小写字母，数字，下划线一共4-16位
            请编写正则表达式验证身份证号码是否满足要求。
            简单要求:
                18位，前17位任意数字，最后一位可以是数字可以是大写或小写的x
            复杂要求:
                按照身份证号码的格式严格要求。

            身份证号码:
            41080119930228457x
            510801197609022309
            15040119810705387X
            130133197204039024 I
            430102197606046442
        */

        //用户名要求:大小写字母，数字，下划线一共4-16位
        String regex1 = "\\w{4,16}";
        System.out.println("zhangsan".matches(regex1));
        System.out.println("lisi".matches(regex1));
        System.out.println("wangwu".matches(regex1));
        System.out.println("$123".matches(regex1));


        //身份证号码的简单校验:
        //18位，前17位任意数字，最后一位可以是数字可以是大写或小写的x
        String regex2 = "[1-9]\\d{16}(\\d|x|x)";
        String regex3 = "[1-9]\\d{16}[\\dXx]";
        String regex5 = "[1-9]\\d{16}(\\d(?i)x)";

        //忽略大小写的书写方式
        //在匹配的时候忽略abc的大小写
        String regex4 = "a((?i)b)c";
        System.out.println("------------------------------");
        System.out.println("abc".matches(regex4));//true
        System.out.println("ABC".matches(regex4));//false
        System.out.println("aBc".matches(regex4));//true

        //身份证号码的严格校验
        //编写正则的小心得:
        //第一步:按照正确的数据进行拆分
        //第二步:找每一部分的规律，并编写正则表达式
        //第三步:把每一部分的正则拼接在一起，就是最终的结果
        //书写的时候:从左到右去书写。

        //410801 1993 02 28 457x
        //前面6位:省份，市区，派出所等信息，第一位不能是0，后面5位是任意数字       [1-9]\\d{5}
        //年的前半段: 18 19 20                                                (18|19|20)
        //年的后半段: 任意数字出现两次                                           \\d{2}
        //月份: 01~ 09 10 11 12                                               (@[1-9]|1[0-2])
        //日期: 01~09 10~19 20~29 30 31                                       (0[1-9]|[12]\\d|3[01])
        //后面四位: 任意数字出现3次 最后一位可以是数字也可以是大写x或者小写x        \\d{3}[\\dXx]
        String regex6 = "[1-9]\\d{5}(18|19|20)\\d{2}(@[1-9]|1[0-2])(@[1-9]|[12]\\d|3[01])\\d{3}[\\dxXx]";
    }
}

正则表达式练习

手机号码:1[3-9]\\d{9}
座机号码：0\\d{2,3}-?[1-9]\\d{4,9}
邮箱号码：\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2}
24小时：([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d
	   ([01]\\d|2[0-3])(:[0-5]\\d){2}
用户名:	\\w{4,16}
身份证号码，简单校验：
		[1-9]\\d{16}(\\d|X|x)
		[1-9]\\d{16}[\\dXx]
		[1-9]\\d{16}(\\d(?i)X)
身份证号码，严格校验：
		[1-9]\\d{5}(18|19|20)\\d{2}(0[1-9]|1[0-2])(0[1-9|[12])\\d|3[01])\\d{3}[\\dXx]

2. Date类及其相关时间API

2.1 Date类

• public Date()：从运行程序的此时此刻到时间原点经历的毫秒值,转换成Date对象，分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
• public Date(long date)：将指定参数的毫秒值date,转换成Date对象，分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数。

Date类中的多数方法已经过时，常用的方法有：

• public long getTime() 把日期对象转换成对应的时间毫秒值。
• public void setTime(long time) 把方法参数给定的毫秒值设置给日期对象

2.2 SimpleDateFormat类

java.text.SimpleDateFormat 是日期/时间格式化类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。

• 格式化：按照指定的格式，把Date对象转换为String对象。
• 解析：按照指定的格式，把String对象转换为Date对象。

DateFormat类的常用方法有：

• public String format(Date date)：将Date对象格式化为字符串。
• public Date parse(String source)：将字符串解析为Date对象。

private static void method() {
        //1.利用空参构造创建simpleDateFormat对象，默认格式
        SimpleDateFormat sdf1 = new SimpleDateFormat();
        Date d1 = new Date(0L);
        String str1 = sdf1.format(d1);
        System.out.println(str1);//1970/1/1 上午8:00

        //2.利用带参构造创建simpleDateFormat对象，指定格式
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
        String str2 = sdf2.format(d1);
        System.out.println(str2);//1970年01月01日 08:00:00

        //课堂练习:yyyy年MM月dd日 时:分:秒 星期
    }

DateFormat可以将Date对象和字符串相互转换。

综合练习：给字符串，前转化为Date数据，再由Date数据转化为指定格式的字符串表示。

/*
     假设，你初恋的出生年月日为:2000-11-11
     请用字符串表示这个数据，并将其转换为:2000年11月11日

     创建一个Date对象表示2000年11月11日
     创建一个SimpleDateFormat对象，并定义格式为年月日把时间变成:2000年11月11日
*/

//1.可以通过2000-11-11进行解析，解析成一个Date对象
String str = "2000-11-11";
//2.解析
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
Date date = sdf1.parse(str);
//3.格式化
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日");
String result = sdf2.format(date);
System.out.println(result);

2.3 jdk8时间相关类

JDK8时间类类名	作用
ZoneId	时区
Instant	时间戳
ZoneDateTime	带时区的时间
DateTimeFormatter	用于时间的格式化和解析
LocalDate	年、月、日
LocalTime	时、分、秒
LocalDateTime	年、月、日、时、分、秒
Duration	时间间隔（秒，纳，秒）
Period	时间间隔（年，月，日）
ChronoUnit	时间间隔（所有单位）

3. 包装类和Array类

基本类型 对应的包装类（位于java.lang包中）

byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

3.1 Integer类

• Integer类概述
  包装一个对象中的原始类型 int 的值
• Integer类构造方法及静态方法

方法名	说明
public Integer(int value)	根据 int 值创建 Integer 对象(过时)
public Integer(String s)	根据 String 值创建 Integer 对象(过时)
public static Integer valueOf(int i)	返回表示指定的 int 值的 Integer 实例
public static Integer valueOf(String s)	返回保存指定String值的 Integer 对象
static string tobinarystring(int i)	得到二进制
static string tooctalstring(int i)	得到八进制
static string toHexstring(int i)	得到十六进制
static int parseInt(string s)	将字符串类型的整数转成int类型的整数

3.2 Arrays操作数据工具类

五. lambda表达式

lambda表达式是一种忽略类名、方法名重视方法体中行为的一种表达，只保留方法的参数和方法体中内容。

注意，简化的匿名抽象类必须是接口的实现类，抽象类不行，只能是接口，并且接口中只能有一个抽象函数。也称之为函数式接口

String[] arr={"a","aaaa","aaa","aa"};
Arrays.sort(arr,(o1,o2)->o1.length()-o2.length());
for(String i:arr){
     System.out.println(i);
}

六. 集合List、Set和数据结构

1.Collection集合

1.1数组和集合的区别【理解】

• 相同点
  都是容器,可以存储多个数据
• 不同点
  • 数组的长度是不可变的,集合的长度是可变的
  • 数组可以存基本数据类型和引用数据类型
    集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类

1.2集合类体系结构【理解】

1.3Collection 集合概述和使用【应用】

• Collection集合概述
  • 是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素
  • JDK 不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现
• 创建Collection集合的对象
  • 多态的方式
  • 具体的实现类ArrayList
• Collection集合常用方法
  方法名 说明
  boolean add(E e) 添加元素
  boolean remove(Object o) 从集合中移除指定的元素
  boolean removeIf(Object o) 根据条件进行移除
  void clear() 清空集合中的元素
  boolean contains(Object o) 判断集合中是否存在指定的元素
  boolean isEmpty() 判断集合是否为空
  int size() 集合的长度，也就是集合中元素的个数

1.4Collection集合的遍历

1.4.1 迭代器遍历

• 迭代器介绍

  • 迭代器,集合的专用遍历方式
  • Iterator iterator(): 返回此集合中元素的迭代器,通过集合对象的iterator()方法得到

• Iterator中的常用方法
  boolean hasNext(): 判断当前位置是否有元素可以被取出
  E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置

• Collection集合的遍历
  public class IteratorDemo1 {
  public static void main(String[] args) {
  //创建集合对象
  Collection c = new ArrayList<>();

          //添加元素
          c.add("hello");
          c.add("world");
          c.add("java");
          c.add("javaee");
  
          //Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
          Iterator<String> it = c.iterator();
  
          //用while循环改进元素的判断和获取
          while (it.hasNext()) {
              String s = it.next();
              System.out.println(s);
          }
      }
  }
  

• 迭代器中删除的方法
  void remove(): 删除迭代器对象当前指向的元素
  public class IteratorDemo2 {
  public static void main(String[] args) {
  ArrayList list = new ArrayList<>();
  list.add(“a”);
  list.add(“b”);

          Iterator<String> it = list.iterator();
          while(it.hasNext()){
              String s = it.next();
              if("b".equals(s)){
                  //指向谁,那么此时就删除谁.
                  it.remove();
              }
          }
          System.out.println(list);
      }
  }
  

1.4.2 增强for

• 介绍

  • 它是JDK5之后出现的,其内部原理是一个Iterator迭代器
  • 实现Iterable接口的类才可以使用迭代器和增强for
  • 简化数组和Collection集合的遍历

• 格式
  for(集合/数组中元素的数据类型 变量名 : 集合/数组名) {
  // 已经将当前遍历到的元素封装到变量中了,直接使用变量即可
  }

• 代码
  public class MyCollectonDemo1 {
  public static void main(String[] args) {
  ArrayList list = new ArrayList<>();
  list.add(“a”);
  list.add(“b”);

          //1,数据类型一定是集合或者数组中元素的类型
          //2,str仅仅是一个变量名而已,在循环的过程中,依次表示集合或者数组中的每一个元素
          //3,list就是要遍历的集合或者数组
          for(String str : list){
              System.out.println(str);
          }
      }
  }
  

• 细节点注意：

1.报错NoSuchElementException

2.迭代器遍历完毕，指针不会复位

3.循环中只能用一次next方法

4.迭代器遍历时，不能用集合的方法进行增加或者删除

public class A04_CollectionDemo4 {
    public static void main(String[] args) {
      /*
        迭代器的细节注意点：
            1.报错NoSuchElementException
            2.迭代器遍历完毕，指针不会复位
            3.循环中只能用一次next方法
            4.迭代器遍历时，不能用集合的方法进行增加或者删除
            	暂时当做一个结论先行记忆，在今天我们会讲解源码详细的再来分析。
                如果我实在要删除：那么可以用迭代器提供的remove方法进行删除。
                如果我要添加，暂时没有办法。(只是暂时)
       */

        //1.创建集合并添加元素
        Collection<String> coll = new ArrayList<>();
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        coll.add("ddd");

        //2.获取迭代器对象
        //迭代器就好比是一个箭头，默认指向集合的0索引处
        Iterator<String> it = coll.iterator();
        //3.利用循环不断的去获取集合中的每一个元素
        while(it.hasNext()){
            //4.next方法的两件事情：获取元素并移动指针
            String str = it.next();
            System.out.println(str);
        }

        //当上面循环结束之后，迭代器的指针已经指向了最后没有元素的位置
        //System.out.println(it.next());//NoSuchElementException

        //迭代器遍历完毕，指针不会复位
        System.out.println(it.hasNext());

        //如果我们要继续第二次遍历集合，只能再次获取一个新的迭代器对象
        Iterator<String> it2 = coll.iterator();
        while(it2.hasNext()){
            String str = it2.next();
            System.out.println(str);
        }
    }
}

1.4.3 lambda表达式

利用forEach方法，再结合lambda表达式的方式进行遍历

public class A07_CollectionDemo7 {
    public static void main(String[] args) {
       /* 
        lambda表达式遍历：
                default void forEach(Consumer<? super T> action):
        */

        //1.创建集合并添加元素
        Collection<String> coll = new ArrayList<>();
        coll.add("zhangsan");
        coll.add("lisi");
        coll.add("wangwu");
        //2.利用匿名内部类的形式
        //底层原理：
        //其实也会自己遍历集合，依次得到每一个元素
        //把得到的每一个元素，传递给下面的accept方法
        //s依次表示集合中的每一个数据
       /* coll.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/

        //lambda表达式
        coll.forEach(s -> System.out.println(s));
    }
}

2.List集合

2.1List集合的概述和特点【记忆】

• List集合的概述
  • 有序集合,这里的有序指的是存取顺序
  • 用户可以精确控制列表中每个元素的插入位置,用户可以通过整数索引访问元素,并搜索列表中的元素
  • 与Set集合不同,列表通常允许重复的元素
• List集合的特点
  • 存取有序
  • 可以重复
  • 有索引

2.2List集合的特有方法【应用】

• 方法介绍
  方法名 描述
  void add(int index,E element) 在此集合中的指定位置插入指定的元素
  E remove(int index) 删除指定索引处的元素，返回被删除的元素
  E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
  E get(int index) 返回指定索引处的元素
• 示例代码

      public class MyListDemo {
          public static void main(String[] args) {
              List<String> list = new ArrayList<>();
              list.add("aaa");
              list.add("bbb");
              list.add("ccc");
              //method1(list);
              //method2(list);
              //method3(list);
              //method4(list);
          }
      
          private static void method4(List<String> list) {
              //        E get(int index)		返回指定索引处的元素
              String s = list.get(0);
              System.out.println(s);
          }
      
          private static void method3(List<String> list) {
              //        E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
              //被替换的那个元素,在集合中就不存在了.
              String result = list.set(0, "qqq");
              System.out.println(result);
              System.out.println(list);
          }
      
          private static void method2(List<String> list) {
              //        E remove(int index)		删除指定索引处的元素，返回被删除的元素
              //在List集合中有两个删除的方法
              //第一个 删除指定的元素,返回值表示当前元素是否删除成功
              //第二个 删除指定索引的元素,返回值表示实际删除的元素
              String s = list.remove(0);
              System.out.println(s);
              System.out.println(list);
          }
      
          private static void method1(List<String> list) {
              //        void add(int index,E element)	在此集合中的指定位置插入指定的元素
              //原来位置上的元素往后挪一个索引.
              list.add(0,"qqq");
              System.out.println(list);
          }
      }

2.3List集合的五种遍历方式【应用】

1. 迭代器
2. 列表迭代器
3. 增强for
4. Lambda表达式
5. 普通for循环

代码示例：

//创建集合并添加元素
List<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");

//1.迭代器
/*Iterator<String> it = list.iterator();
     while(it.hasNext()){
        String str = it.next();
        System.out.println(str);
}*/


//2.增强for
//下面的变量s，其实就是一个第三方的变量而已。
//在循环的过程中，依次表示集合中的每一个元素
/* for (String s : list) {
       System.out.println(s);
   }*/

//3.Lambda表达式
//forEach方法的底层其实就是一个循环遍历，依次得到集合中的每一个元素
//并把每一个元素传递给下面的accept方法
//accept方法的形参s，依次表示集合中的每一个元素
//list.forEach(s->System.out.println(s) );


//4.普通for循环
//size方法跟get方法还有循环结合的方式，利用索引获取到集合中的每一个元素
/*for (int i = 0; i < list.size(); i++) {
            //i:依次表示集合中的每一个索引
            String s = list.get(i);
            System.out.println(s);
        }*/

// 5.列表迭代器
//获取一个列表迭代器的对象，里面的指针默认也是指向0索引的

//额外添加了一个方法：在遍历的过程中，可以添加元素
ListIterator<String> it = list.listIterator();
while(it.hasNext()){
    String str = it.next();
    if("bbb".equals(str)){
        //qqq
        it.add("qqq");
    }
}
System.out.println(list);

2.4 细节点注意：

List系列集合中的两个删除的方法

1.直接删除元素: remove（），用于迭代器遍历
2.通过索引进行删除：remove（i），用于for i的形式遍历，但是注意i--需在删除之后执行一次。

普通for循环可以删除或者增加list中元素，仅仅涉及删除可以采用迭代器遍历，仅仅设计增加元素可以采用普通for循环

3.数据结构

3.1数据结构之栈和队列【记忆】

• 栈结构
  先进后出
• 队列结构
  先进先出

3.2数据结构之数组和链表【记忆】

• 数组结构
  查询快、增删慢
• 队列结构
  查询慢、增删快

4. List集合的实现类

4.1 List集合子类的特点【记忆】

• ArrayList集合
  底层是数组结构实现，查询快、增删慢
• LinkedList集合
  底层是链表结构实现，查询慢、增删快

4.2LinkedList集合的特有功能【应用】

• 特有方法
  方法名 说明
  public void addFirst(E e) 在该列表开头插入指定的元素
  public void addLast(E e) 将指定的元素追加到此列表的末尾
  public E getFirst() 返回此列表中的第一个元素
  public E getLast() 返回此列表中的最后一个元素
  public E removeFirst() 从此列表中删除并返回第一个元素
  public E removeLast() 从此列表中删除并返回最后一个元素
• 示例代码

      public class MyLinkedListDemo4 {
          public static void main(String[] args) {
              LinkedList<String> list = new LinkedList<>();
              list.add("aaa");
              list.add("bbb");
              list.add("ccc");
      //        public void addFirst(E e)	在该列表开头插入指定的元素
              //method1(list);
      
      //        public void addLast(E e)	将指定的元素追加到此列表的末尾
              //method2(list);
      
      //        public E getFirst()		返回此列表中的第一个元素
      //        public E getLast()		返回此列表中的最后一个元素
              //method3(list);
      
      //        public E removeFirst()		从此列表中删除并返回第一个元素
      //        public E removeLast()		从此列表中删除并返回最后一个元素
              //method4(list);
            
          }
      
          private static void method4(LinkedList<String> list) {
              String first = list.removeFirst();
              System.out.println(first);
      
              String last = list.removeLast();
              System.out.println(last);
      
              System.out.println(list);
          }
      
          private static void method3(LinkedList<String> list) {
              String first = list.getFirst();
              String last = list.getLast();
              System.out.println(first);
              System.out.println(last);
          }
      
          private static void method2(LinkedList<String> list) {
              list.addLast("www");
              System.out.println(list);
          }
      
          private static void method1(LinkedList<String> list) {
              list.addFirst("qqq");
              System.out.println(list);
          }
      }

5. 源码分析

5.1 ArrayList源码分析：

核心步骤：

1. 创建ArrayList对象的时候，他在底层先创建了一个长度为0的数组。
   数组名字：elementDate，定义变量size。
   size这个变量有两层含义：
   ①：元素的个数，也就是集合的长度
   ②：下一个元素的存入位置
2. 添加元素，添加完毕后，size++

扩容时机一：

1. 当存满时候，会创建一个新的数组，新数组的长度，是原来的1.5倍，也就是长度为15.再把所有的元素，全拷贝到新数组中。如果继续添加数据，这个长度为15的数组也满了，那么下次还会继续扩容，还是1.5倍。

扩容时机二：

1. 一次性添加多个数据，扩容1.5倍不够，怎么办呀？
   如果一次添加多个元素，1.5倍放不下，那么新创建数组的长度以实际为准。

举个例子：

在一开始，如果默认的长度为10的数组已经装满了，在装满的情况下，我一次性要添加100个数据很显然，10扩容1.5倍，变成15，还是不够，

怎么办？

此时新数组的长度，就以实际情况为准，就是110

5.2 LinkedList源码分析：

底层是双向链表结构

核心步骤如下：

1. 刚开始创建的时候，底层创建了两个变量：一个记录头结点first，一个记录尾结点last，默认为null
2. 添加第一个元素时，底层创建一个结点对象，first和last都记录这个结点的地址值
3. 添加第二个元素时，底层创建一个结点对象，第一个结点会记录第二个结点的地址值，last会记录新结点的地址值

具体分析过程可以参见视频讲解。

5.3 迭代器源码分析：

迭代器遍历相关的三个方法：

• Iterator iterator() ：获取一个迭代器对象
• boolean hasNext() ：判断当前指向的位置是否有元素
• E next() ：获取当前指向的元素并移动指针

1.泛型

1.1泛型概述

• 泛型的介绍
  泛型是JDK5中引入的特性，它提供了编译时类型安全检测机制
• 泛型的好处
  1. 把运行时期的问题提前到了编译期间
  2. 避免了强制类型转换
• 泛型的定义格式
  • <类型>: 指定一种类型的格式.尖括号里面可以任意书写,一般只写一个字母.例如:
  • <类型1,类型2…>: 指定多种类型的格式,多种类型之间用逗号隔开.例如: <E,T> <K,V>

2.Set集合

2.1 Set集合概述和特点【应用】

• 不可以存储重复元素
• 没有索引,不能使用普通for循环遍历

2.2 Set集合的使用【应用】

存储字符串并遍历

public class MySet1 {
    public static void main(String[] args) {
      	//创建集合对象
        Set<String> set = new TreeSet<>();
      	//添加元素
        set.add("ccc");
        set.add("aaa");
        set.add("aaa");
        set.add("bbb");

//        for (int i = 0; i < set.size(); i++) {
//            //Set集合是没有索引的，所以不能使用通过索引获取元素的方法
//        }
      
      	//遍历集合
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("-----------------------------------");
        for (String s : set) {
            System.out.println(s);
        }
    }
}

3.TreeSet集合

3.1TreeSet集合概述和特点【应用】

• 不可以存储重复元素
• 没有索引
• 可以将元素按照规则进行排序
  • TreeSet()：根据其元素的自然排序进行排序
  • TreeSet(Comparator comparator) ：根据指定的比较器进行排序

3.2TreeSet集合基本使用【应用】

存储Integer类型的整数并遍历

public class TreeSetDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Integer> ts = new TreeSet<Integer>();

        //添加元素
        ts.add(10);
        ts.add(40);
        ts.add(30);
        ts.add(50);
        ts.add(20);

        ts.add(30);

        //遍历集合
        for(Integer i : ts) {
            System.out.println(i);
        }
    }
}

3.3自然排序Comparable的使用【应用】

• 案例需求

  • 存储学生对象并遍历，创建TreeSet集合使用无参构造方法
  • 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

• 实现步骤

  1. 使用空参构造创建TreeSet集合
     • 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
  2. 自定义的Student类实现Comparable接口
     • 自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
  3. 重写接口中的compareTo方法
     • 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

• 代码实现
  学生类

      public class Student implements Comparable<Student>{
          private String name;
          private int age;
      
          public Student() {
          }
      
          public Student(String name, int age) {
              this.name = name;
              this.age = age;
          }
      
          public String getName() {
              return name;
          }
      
          public void setName(String name) {
              this.name = name;
          }
      
          public int getAge() {
              return age;
          }
      
          public void setAge(int age) {
              this.age = age;
          }
      
          @Override
          public String toString() {
              return "Student{" +
                      "name='" + name + '\'' +
                      ", age=" + age +
                      '}';
          }
      
          @Override
          public int compareTo(Student o) {
              //按照对象的年龄进行排序
              //主要判断条件: 按照年龄从小到大排序
              int result = this.age - o.age;
              //次要判断条件: 年龄相同时，按照姓名的字母顺序排序
              result = result == 0 ? this.name.compareTo(o.getName()) : result;
              return result;
          }
      }
  测试类
      public class MyTreeSet2 {
          public static void main(String[] args) {
              //创建集合对象
              TreeSet<Student> ts = new TreeSet<>();
      	    //创建学生对象
              Student s1 = new Student("zhangsan",28);
              Student s2 = new Student("lisi",27);
              Student s3 = new Student("wangwu",29);
              Student s4 = new Student("zhaoliu",28);
              Student s5 = new Student("qianqi",30);
      		//把学生添加到集合
              ts.add(s1);
              ts.add(s2);
              ts.add(s3);
              ts.add(s4);
              ts.add(s5);
      		//遍历集合
              for (Student student : ts) {
                  System.out.println(student);
              }
          }
      }
  
  

3.4 比较器排序Comparator的使用【应用】

• 案例需求
  • 存储老师对象并遍历，创建TreeSet集合使用带参构造方法
  • 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
• 实现步骤
  • 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
  • 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法
  • 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
• 代码实现
  老师类

      public class Teacher {
          private String name;
          private int age;
      
          public Teacher() {
          }
      
          public Teacher(String name, int age) {
              this.name = name;
              this.age = age;
          }
      
          public String getName() {
              return name;
          }
      
          public void setName(String name) {
              this.name = name;
          }
      
          public int getAge() {
              return age;
          }
      
          public void setAge(int age) {
              this.age = age;
          }
      
          @Override
          public String toString() {
              return "Teacher{" +
                      "name='" + name + '\'' +
                      ", age=" + age +
                      '}';
          }
      }

测试类

    public class MyTreeSet4 {
        public static void main(String[] args) {
          	//创建集合对象
            TreeSet<Teacher> ts = new TreeSet<>(new Comparator<Teacher>() {
                @Override
                public int compare(Teacher o1, Teacher o2) {
                    //o1表示现在要存入的那个元素
                    //o2表示已经存入到集合中的元素
                  
                    //主要条件
                    int result = o1.getAge() - o2.getAge();
                    //次要条件
                    result = result == 0 ? o1.getName().compareTo(o2.getName()) : result;
                    return result;
                }
            });
    		//创建老师对象
            Teacher t1 = new Teacher("zhangsan",23);
            Teacher t2 = new Teacher("lisi",22);
            Teacher t3 = new Teacher("wangwu",24);
            Teacher t4 = new Teacher("zhaoliu",24);
    		//把老师添加到集合
            ts.add(t1);
            ts.add(t2);
            ts.add(t3);
            ts.add(t4);
    		//遍历集合
            for (Teacher teacher : ts) {
                System.out.println(teacher);
            }
        }
    }

3.5两种比较方式总结【理解】

• 两种比较方式小结
  • 自然排序: 自定义类实现Comparable接口,重写compareTo方法,根据返回值进行排序
  • 比较器排序: 创建TreeSet对象的时候传递Comparator的实现类对象,重写compare方法,根据返回值进行排序
  • 在使用的时候,默认使用自然排序,当自然排序不满足现在的需求时,必须使用比较器排序
• 两种方式中关于返回值的规则
  • 如果返回值为负数，表示当前存入的元素是较小值，存左边
  • 如果返回值为0，表示当前存入的元素跟集合中元素重复了，不存
  • 如果返回值为正数，表示当前存入的元素是较大值，存右边

4.数据结构

4.1二叉树【理解】

• 二叉树的特点
  • 二叉树中,任意一个节点的度要小于等于2
    • 节点: 在树结构中,每一个元素称之为节点
    • 度: 每一个节点的子节点数量称之为度
• 二叉树结构图

4.2二叉查找树【理解】

• 二叉查找树的特点

  • 二叉查找树,又称二叉排序树或者二叉搜索树
  • 每一个节点上最多有两个子节点
  • 左子树上所有节点的值都小于根节点的值
  • 右子树上所有节点的值都大于根节点的值

• 二叉查找树结构图

• 二叉查找树和二叉树对比结构图

• 二叉查找树添加节点规则

  • 小的存左边
  • 大的存右边
  • 一样的不存

4.3平衡二叉树【理解】

• 平衡二叉树的特点

  • 二叉树左右两个子树的高度差不超过1
  • 任意节点的左右两个子树都是一颗平衡二叉树

• 平衡二叉树旋转

  • 旋转触发时机

    • 当添加一个节点之后,该树不再是一颗平衡二叉树

  • 左旋

    • 就是将根节点的右侧往左拉,原先的右子节点变成新的父节点,并把多余的左子节点出让,给已经降级的根节点当右子节点

  • 右旋

    • 就是将根节点的左侧往右拉,左子节点变成了新的父节点,并把多余的右子节点出让,给已经降级根节点当左子节点

• 平衡二叉树和二叉查找树对比结构图

• 平衡二叉树旋转的四种情况

  • 左左

    • 左左: 当根节点左子树的左子树有节点插入,导致二叉树不平衡
    • 如何旋转: 直接对整体进行右旋即可

  • 左右

    • 左右: 当根节点左子树的右子树有节点插入,导致二叉树不平衡
    • 如何旋转: 先在左子树对应的节点位置进行左旋,在对整体进行右旋

  • 右右

    • 右右: 当根节点右子树的右子树有节点插入,导致二叉树不平衡
    • 如何旋转: 直接对整体进行左旋即可

  • 右左

    • 右左:当根节点右子树的左子树有节点插入,导致二叉树不平衡
    • 如何旋转: 先在右子树对应的节点位置进行右旋,在对整体进行左旋

4.3红黑树【理解】

• 红黑树的特点

  • 平衡二叉B树
  • 每一个节点可以是红或者黑
  • 红黑树不是高度平衡的,它的平衡是通过"自己的红黑规则"进行实现的

• 红黑树的红黑规则有哪些

  1. 每一个节点或是红色的,或者是黑色的
  2. 根节点必须是黑色
  3. 如果一个节点没有子节点或者父节点,则该节点相应的指针属性值为Nil,这些Nil视为叶节点,每个叶节点(Nil)是黑色的
  4. 如果某一个节点是红色,那么它的子节点必须是黑色(不能出现两个红色节点相连 的情况)
  5. 对每一个节点,从该节点到其所有后代叶节点的简单路径上,均包含相同数目的黑色节点

• 红黑树添加节点的默认颜色

  • 添加节点时,默认为红色,效率高

• 红黑树添加节点后如何保持红黑规则

  • 根节点位置
    • 直接变为黑色
  • 非根节点位置
    • 父节点为黑色
      • 不需要任何操作,默认红色即可
    • 父节点为红色
      • 叔叔节点为红色
        1. 将"父节点"设为黑色,将"叔叔节点"设为黑色
        2. 将"祖父节点"设为红色
        3. 如果"祖父节点"为根节点,则将根节点再次变成黑色
      • 叔叔节点为黑色
        1. 将"父节点"设为黑色
        2. 将"祖父节点"设为红色
        3. 以"祖父节点"为支点进行旋转

5.HashSet集合

5.1HashSet集合概述和特点【应用】

• 底层数据结构是哈希表
• 存取无序
• 不可以存储重复元素
• 没有索引,不能使用普通for循环遍历

5.2HashSet集合的基本应用【应用】

存储字符串并遍历

public class HashSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<String> set = new HashSet<String>();

        //添加元素
        set.add("hello");
        set.add("world");
        set.add("java");
        //不包含重复元素的集合
        set.add("world");

        //遍历
        for(String s : set) {
            System.out.println(s);
        }
    }
}

5.3哈希值【理解】

• 哈希值简介
  是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
• 如何获取哈希值
  Object类中的public int hashCode()：返回对象的哈希码值
• 哈希值的特点
  • 同一个对象多次调用hashCode()方法返回的哈希值是相同的
  • 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同

5.4哈希表结构【理解】

• JDK1.8以前
  数组 + 链表

• JDK1.8以后

  • 节点个数少于等于8个
    数组 + 链表
  • 节点个数多于8个
    数组 + 红黑树

5.5HashSet集合存储学生对象并遍历【应用】

• 案例需求
  • 创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历该集合
  • 要求：学生对象的成员变量值相同，我们就认为是同一个对象
• 代码实现
  学生类

      public class Student {
          private String name;
          private int age;
      
          public Student() {
          }
      
          public Student(String name, int age) {
              this.name = name;
              this.age = age;
          }
      
          public String getName() {
              return name;
          }
      
          public void setName(String name) {
              this.name = name;
          }
      
          public int getAge() {
              return age;
          }
      
          public void setAge(int age) {
              this.age = age;
          }
      
          @Override
          public boolean equals(Object o) {
              if (this == o) return true;
              if (o == null || getClass() != o.getClass()) return false;
      
              Student student = (Student) o;
      
              if (age != student.age) return false;
              return name != null ? name.equals(student.name) : student.name == null;
          }
      
          @Override
          public int hashCode() {
              int result = name != null ? name.hashCode() : 0;
              result = 31 * result + age;
              return result;
          }
      }
  测试类
      public class HashSetDemo02 {
          public static void main(String[] args) {
              //创建HashSet集合对象
              HashSet<Student> hs = new HashSet<Student>();
      
              //创建学生对象
              Student s1 = new Student("林青霞", 30);
              Student s2 = new Student("张曼玉", 35);
              Student s3 = new Student("王祖贤", 33);
      
              Student s4 = new Student("王祖贤", 33);
      
              //把学生添加到集合
              hs.add(s1);
              hs.add(s2);
              hs.add(s3);
              hs.add(s4);
      
              //遍历集合(增强for)
              for (Student s : hs) {
                  System.out.println(s.getName() + "," + s.getAge());
              }
          }
      }

• 总结
  HashSet集合存储自定义类型元素,要想实现元素的唯一,要求必须重写hashCode方法和equals方法