第三周学习内容

1.什么是集合，集合的特点，集合的基础与高级运用，集合与数组的区别
2.插入排序的思想与实现
3.Random类
4.Date类与SimpleDateformat类的使用，以及与String的相互转化
5.String，StringBuffer，StringBuilder类以及区别
6.引入Integer类以及基础类的包装类，自动拆箱与装箱
7.泛型在集合的基础运用
8.多种类的源码查看练习与学习
9.html的标签学习，扩展知识库
10.再次学习上周未学习完成的内容加进度
11.二次规划路线
12.cpu基本原理，多线程的由来(部分)
13.使用集合完成网吧注册登录系统
14.html表单登录界面的再完善(基础运用)
15.递归思想(部分基础)
16.迭代器与增强for循环

现在来介绍一下我整理的内容吧
集合：集合的上层是接口，由底层实现，只能存储引用类型数据，基础类型会自动装箱为引用类型，现在主要学习的是Collection集合内容，Collection的子接口分为List和Set。
List集合有序，底层是数组，元素可重复，可以直接以角标值查询内容。
set集合无序，底层是链表，元素不可重复，查询费劲
List集合下的子实现类为ArrayList，Vector，LinkedList
ArrayList与LinkedList查询快，线程不安全
Vector查询慢，线程安全
集合的运用:

//定义方式
父类接口<泛型名,默认Object类> 对象名 =new 子实现类<>();
//父类接口定义的方法仅能使用父类方法!
//添加元素
对象名.add(元素名);
//删除元素
对象名.remove(元素名);
对象名.removeAll();//删除所有元素
//提取元素
对象名.get(角标值);//ArrayList
//查询是否为空，返回布尔值，ArrayList
对象名.isEmpty();
//查询长度
对象名.size();
//equals方法由泛型类的equals方法决定
//set类的元素是地址值

现在来看一下我写的源码程序吧，该内容为我全部手写！
faceUser接口，设定出该程序的父接口，用于设置登录与注册功能，引用参数根据子类实现修改

interface faceUser{
    ArrayList register(ArrayList list);
    void sign(ArrayList list);
}

User子实现类
该内容简单，不写注释。

class User implements faceUser{
   //注册功能
    @Override
    public ArrayList<String> register(ArrayList list) {
        Scanner sc=new Scanner(System.in);
        System.out.println("#用户注册界面");
        System.out.println("请输入用户名:");
        String user=sc.next();
        System.out.println("请输入密码:");
        String word=sc.next();
        String User=user+word;
        if(!list.contains(User)){
        list.add(User);
        }else {
            System.out.println("该用户名已注册");
        }
        return list;
    }
  //登录功能
    @Override
    public void sign(ArrayList list) {
        Scanner sc=new Scanner(System.in);
        System.out.println("#用户登录界面");
        System.out.println("请输入用户名:");
        String user=sc.next();
        System.out.println("请输入密码:");
        String word=sc.next();
        String User=user+word;
        if(list.contains(User)){
            System.out.println("登陆成功!");
        }else {
            System.out.println("用户名或密码错误!");
        }
    }
}

具体实现类
UserDemo

public class UserDemo {
    public static void main(String[] args) {
        ArrayList list=new ArrayList<>();
        Scanner sc=new Scanner(System.in);
        while (true){
        System.out.println("欢迎来到猎神网咖");
        System.out.println("1.登录，2.注册");
        int num=sc.nextInt();
        faceUser user=new User();
        switch (num){
            case 1:
                user.sign(list);
                break;
            case 2:
                list=user.register(list);
                break;
        }
    }
    }
}

String,StringBuffer,StringBuilder的区别？
String：字符串存储在常量池，地址值不可改变，无需写new 类名即可赋值，是特殊的引用类型
StringBuffer：字符串存储在缓冲区，地址值可改变，线程不安全，运行快
StringBuilder：地址值可改变，线程安全，运行慢

Integer类
Integer类的定义方式:
构造方法可以传入int和String类型

Integer类的类型转换方法;

比较内容

在集合中定义int会自动升为Integer类

什么是泛型??

泛型即自定义类型,可以在<>中写入类型，可以为基础/引用类型，如不写入则默认为Object类，在接口，抽象类中可以定义自定义类型，在子类实现时必须有具体的类

Date类与SimpleDateformat类

//类的定义
Date 对象名1=new Date():
SimpleDateformat 对象名2=new SimpleDateformat("yyyy-MM--dd");
//转换字符串为Date类方法:
Date 对象名=new Date("字符串");
/Calendar类
Calendar cl=Calendar,getInstance();
//添加数据
cl.add();
//cl默认值为当前时间
cl.YEAR;//年,YEAR为泛型
cl.Month;//月
cl.Date//日

迭代器与增强for循环

//迭代器，不允许在使用next时插入元素
while(集合对象名.hasnext()){
  集合对象名.next;
  //带泛型类的转化
  泛型类 对象名=集合对象名.next;
  //输出:
  System.out.println(对象名);
}
//增强for/foreach,还是迭代器
for(泛型类型 对象名:集合对象名){
  System.out.println(对象名);
}

迭代方式5种！
在这里学到了一定要点赞，这个内容挺珍贵的

  public static void main(String[] args) {
        List<Teacher> list=new ArrayList<Teacher>();
        Teacher tea=new Teacher("王老师",27);
        Teacher tea2=new Teacher("张老师",24);
        Teacher tea3=new Teacher("李老师",25);
        list.add(tea);
        list.add(tea2);
        list.add(tea3);
        Iterator<Teacher> it=list.iterator();
        Object[] obj=list.toArray();
        //方式1:
//        for(int i=0;i<obj.length;i++){
//            //1.直接输出obj
//            //System.out.println(obj[i]);
//            //2.转化为Teacher类使用方法输出
//            Teacher t=(Teacher)obj[i];
//            System.out.println(t.getName()+"---"+t.getAge());
//        }
        //2.迭代器输出
//        while(it.hasNext()){
//            //1.直接输出
//            //System.out.println(it.next());
//            //2.转化t2获得，调用方法
//            Teacher t2=it.next();
//            System.out.println(t2.getName()+"---"+t2.getAge());
//        }
         //方式3:size()+get
//        for (int i=0;i<list.size();i++){
            Teacher t3=list.get(i);
            System.out.println(t3.getName()+"--"+t3.getAge());
        }
        //方式4:正向
        ListIterator<Teacher> lt=list.listIterator();
        while(lt.hasNext()) {
            Teacher t4 = lt.next();
            System.out.println(t4.getName() + "--" + t4.getAge());
      }

        //方式5:逆向(前提是有正向)
       // ListIterator<Teacher> lt=list.listIterator();
        while (lt.hasPrevious()){
            Teacher t5=lt.previous();
            System.out.println(t5.getName()+"---"+t5.getAge());
        }

    }

注册界面的再次完善
加入性别，出生日期选项，修复清空失败的bug，增加了用户名的默认值，仅前端界面，尚未写入后端内容

总结
学习真的很快乐，不要只是见证别人的经历，自己的经历往往更加曲折，一定更加有意思
一个有趣的for循环，该内容不会输出，你可以作为送给下一个接受程序员的礼物，也可以写的复杂一点，运行出想要的结果，加入多线程不容易被发现哦(🤭)

for(int i=0;i>0;i--){
System.out.println("你也想起舞吗");
}

新:非正常人编程!!!
首先是代码块与静态与内部类以及匿名内部类的叠加，在顶部加上创建对象与定义对象，该对象类容再来一次，嵌套多个，并使用链式编程，有意无意的写错类名，变量名方法名，用adcd作为名称彰显你的记忆力，方法一定要多种多样，同一内容的不同方法，void，有返回值，写入不同的返回值类型，特别是偷偷重写，改为另一个功能，接受的人一定大惊失色，在构造方法，会用到的方法中，偷偷调用其他类，创建对象等，最好使用链式编程不易发现，特别是一行让人难以发现的返回匿名对象，或者是来回指的指针，让他感受C语言的魅力，一定要加入多态！指过来再new，或者写入其他的对象名，惊喜常在，出现让人觉得不可能出现的报错，bug，最好偷偷多写几个无限循环，特别是while，非常好用，让程序卡住，同时在里面再次创建对象调用到其他地方的死循环，嵌套式超多重超长死循环，甚至可以不用死循环，用有结束的循环，再结束时调用过来，再调用回去，然后一直创建对象，挤爆jvm
这样肯定是很快就被解决了，因为都不够复杂，一定要偷偷重写一些Object的方法，特别是equals和hashcode以及length，改为一个超长的复杂代码，但功能不变或功能改变，会让人很惊喜，封装时将姓名赋值给性别等，很刺激，在代码块中多写几个try-catch，将一些地方的错误抛出，让程序不完整的运行，并写上注释，该功能正常，基础类型自动装箱为引用类型，再拆箱回来，然后做几个惊喜，比如手写几个引用类型，名字非常近似与原本的引用类型，或者干脆尝试一样指向该类型，然后一定要写在其他类的里面，作为副类，极难被发现，特别是这个优秀的程序，还可以正常运行，偷偷的已经挤的jvm痛苦不堪，在崩溃的边缘又不报错，或者偷偷优化一下jvm，让cv的人拿去无限爆破，链式编程是有趣的写法，等我研究了mvc分层后，会尝试做一个快乐程序ABC分层，也许还得等几年吧，工作中一定不要使用这个程序，有这个想法一定要用rm -f/*来杜绝自己的想法，在使用前解决掉->它，从根源结束问题