java复习

interface

• 里面无静态 代码块和 构造方法的；

• 一个类 的直接父类 是 唯一的 ，但是一个趔可以实现多个接口；

• 如果实现类 实现了 多个接口， 那么接口中有相同 方法，实习类实现了 A,B两个接口相同方法 一个；

• 如果实现类 没有完全实现 抽象方法，那么该类 是抽象类了；

• 如果 实现类 实现了多个接口 中，存在默认的构造方法，实现类一定要对重复 的 默认 方法 覆盖重写；

• 一个类中 直接实现类 中的方法和 接口中 的方法重复，那么实现类 优先 直接父类；（继承优先于 接口实现）；

• 接口可以多继承的；

• 多个 父接口 重复，没关系；多个默认 方法重复，有关系，那么子接口必须进行默认方法的 重写，必须带着default关键字；

• 面向对象三大特征：封装，继承，多态；

多态

• 父类 引用指向子类对象；

• 成员变量 没有覆盖重写；（没有多态）；

instanceof 关键字

• 对象名 instanceof 类名，返回一个boolean类型；

局部内部类，匿名内部类；成员内部类；

• 匿名内部类结构：

• MyInterFace inter = new MyInterFace()
  {
  @Override
  Public void method()
  {
  …
  }
  }

• 匿名内部类 在创建对象 时 ，只能用唯一 一次；

• 匿名对象（注意），匿名对象在调用方法时只能用一次；注意他和匿名内部类可不是同一个东西；

• 匿名内部类可是省略了 类名称，

知识点

• 接口可以作为成员变量；
• 接口也可以作为方法的参数和返回值，例如List接口

日历类

• java.util.Calendar;
• 抽象类，里面提供很多操作日历的方法 ；
• 里面有个静态方法，getInstance();返回Calendar子类对象；
• Calendar c =Calendar.getInstance();
• 参数传递指定的日历字段；
• c.get(Calendar.YEAR); //里面有许多静态成员变量；
• c.get(Calendar.DAY_OF_MOYTH);
• c.set(Calendar.YEAR,9999);//设置年是9999年；
• c.set(8888,8,8);//方法的重载；
• c.add();//把对应字段增加或者减少；
• c.getTime();//返回的是data方法；

Data类

System系统类；放在java.lang里面

• System.getCurrentTimeMillis();返回系统当前的时间，毫秒数值；
• 验证程序执行的时间；
• arrayCopy();// 参数：src, indexsor, obj, indexobj,length;
• Array.toString();//

StringBuilder

• 里面的字符串可变，线程不安全；
• 常用方法：append(); toString();

装箱和拆箱；

基本类型和String类型相互转换；

• “”+…

• Integer.toString();//不是重载了object类的tostring()方法：

• String.ValueOf();

• 字符串转基本类型；

• Integer.parseInt();

集合

• 1. Collection;
• 集合可变，并且存的是对象;
• Vector,Arraylist,LinkLIst, TreeSet,HashSet, LinkedHashSet;
• List 接口 特点： 1. 有序，2. 允许存放重复元素； 3. 有索引，可以使用普通的for循环遍历；
• Set 接口 特点，1. 不允许存放重复元素 2. 没有索引；
• 1. Collection() 中的方法；
• add(),clear,remove,contains,isempty(),size(),toarray()
• 2. iterator; hasNext(), next();
• 3. Iterable,实现这个接口的 类允许使用增强For,（本质上是用了迭代器的原理);

泛型

• 一种未知的数据类型；不知道使用什么数据类型时，我么使用泛型；

• T t Type; E e Element;
  创建集合对象的时候，就会确定泛型的 数据类型；

• example: public class ArrayList {}

• 定义含有泛型的方法，泛型的方法在泛型的修饰符和返回值之间； 格式；修饰符 返回值 方法名() {}

• public void method(M m)
  {
  System.out.println(m);
  }

• 定义一个含有泛型 的静态方法；public static void method(M m){}

• 定义一个泛型 的接口： public interface test{}

• 接口实现类： public class genericInterfaceImpl implements GenericInterface {}

• 接口实现类的第二种方法，public GenericInterfaceImpl implements GenericInterface{};

泛型的通配符;

• ?
• ? 代表任意 数据类型；
• 不能创建对象 时使用，只能作为方法的参书使用；
• 泛型的高级使用；上限 是? extends E,下限限定是
  ? super E ;

List接口

• 有序集合，有索引，允许重复元素；
• add(int index， E element)
• 使用索引是，防止索引越界异常；
• get(int index);
• remove(int index);
• set(int index,E element);//别替换元素的下标，替换后的元素；

LinkList集合

• add() ;addFirst()(等效于Push());
• getFirst(); getLast();
• remove(); pop();

可变参数

• 格式： 修饰符 返回值类型 方法名(数据类型…变量名){};
• 一个方法的可变参数，只能有一个；
• 如果方法参数有多个，那么可变参数必须放在末尾，本质是个数组；
• 可变参数的特殊写法（终极写法），Object…obj;

Collections

• Collections.shuffle(list);//乱序；

• 实现sort两种方法，一种list集合中的 对象重写Compareto方法，另一种是直接在sort（）方法体里面添加Comparator<>(){}

• Collections.sort(list，Comparator{});//排序；

• 注意： sort方法的使用前提，被排序的集合必须实现compareTo方法，实现compareable接口；

• 自己（this）-参数 就是升序；

• Comparator<>(){}这个类 实现 了Comparable接口的方法 ；

map集合

• map集合 是一个 双列值；2. map 结合中的k,v对可以相同，也可以不同； 3.map里面k不允许重发，但是v可以重复；
• HashMap取出元素和 放进元素去的 顺序可能不一致； 他是一个无 序 的集合；
• LinkHashMap取出元素和放进元素 一致；

HashMap

• put(k,v);

• remove(k);//没有k值，返回为null,否则返回删除的v;

• get(K);//k存在返回对应的数值，否则返回是null；

• containsKey(k);//返回一个boolean值；

• 遍历map的方式： set it =map.getkeySet();

• map集合的第二种遍历方法；Map.Entry;

• Map 集合保证key是唯一的，所以必需重写hashCode()和equals方法保证key 的唯一性；

• keySet(); entrySet();

• HashTable和HashMap的区别，首先它是线程安全，其次它是不能存储Null的；

of方法只适用于 list，map，set接口；java9 新特性

• off方法的 返回值是一个不能改变的集合，不能够在适用add，put方法添加元素；适用了会抛出UnsupportedOperationException异常；
• example:List list =List.of(“a”,"ba’);
• Set 调用of方法 里面初始化 的话 会抛出 异常；就是IllegalArgumentException;//非法参数异常；

处理异常

• try{}catch(){};
• throws//抛出异常，交给jvm处理；
• throw new NullPointerexception("");
• Object.requireNonNull(obj,“传递的参数不能够为空”);
• 异常类型 异常原因 异常位置；
• e.printStacktrace();
• e.getMessage();
• e.toString();

错误

• OutOfMemoryError();//内存溢出错误；这个可不是异常；

异常

• NumberFormatException;数字格式化异常；

• ClassCastException; 类型转换异常；

• IndexOutOfBoundException;// 索引越界异常，通常集合会报这个异常；

• arrayIndexOutOfBoundException;//数组越界异常；

• StrigINdexOutOfBoundException;// 字符串越界异常；

• NosuchElementException;// 集合中清空元素后 在getFirst();会报这个异常；

• parseException;//解析异常；

• example：simpledateformat sdf = new simpaledatformate(“yyyy-MM-dd”); sdf.parse(1997-04-20);//返回一个date类型；

• 假如他格式没有按照要求来，就会报parseException;//解析异常；

• FileNotFindException;//文件找不到异常//是一个编译异常；

• IOException;//编译异常，io异常；

• filename.endsWith(“hhh.txt”);

• 父类异常什么样，子类异常就什么样；

自定义异常类；

• public class XXXException{};
• 自定义异常必须继承Exception;
• 继承 Exception 类，那么自定义的异常类 就是一个编译器异常；如果方法内部抛出了编译期 异常，那么必须处理这个异常，要么throws，要么try…catch(){};
• 继承RuntimeException类 的异常就是运行期异常，无需处理，必须交给jvm处理；

线程

• 并发和并行 的概念；
• java线程调度 的两种方法：分时调度； 抢占式调度；
• 内存：每次开辟一个线程，就是内存中开辟一个新的栈空间，他们并发执行，相当于cpu有了执行了权利，他们互不影响；
• Thread的方法：
• 1. getName(); //获取线程的名字；
• Thread.currentThread();//获取的就是当前的线程；
• Thread.sleep(long mils);
• 创建线程的第二种方式： 实现runable接口：

线程安全

• 出现了卖相同的票或者 卖了不存在的票；
• 为了解决这个问题，引入了线程同步机制：
• 1. 同步代码块 2. 同步方法 3. 锁机制
• 同步代码块 synchronized(同步锁){};

静态同步方法的所对象：

• 不能是this，因为静态方法优先于对选哪个
• 静态方法的锁对象是 class属性，也叫 class文件对象
• 普通同步方法的锁对像 是this

lock 和 unlock

• lock 获取锁
• 使用步骤： 1、创建Reentrantlock对象，2、 在可能出现安全问题的代码前调用lock方法， 3.执行完成后调用unlock.

java 内存空间划分为 5个部分；

• 1. 栈： 存放的都是方法中的局部变量，；
     局部变量： 方法 的参数，或者方法内的变量；
     作用域： 一旦超出作用域，立即从栈内存中存储；
• 2. 堆内存：
     凡是new 出来的东西，都在 堆当中；
     堆内存 里面的东西 都是一个地址，如16进制；
     堆内存里面的数据都有默认值，规则：
     如果是整数： 默认是0；
     如果是 浮点数：默认是0.0；
     如果是字符，默认是 \u0000;
     如果是boolean, 默认是 false；
     如果是引用类型，默认是null值；
• 3. 方法区： 存储：class相关信息，包含方法的信息。
     真正方法运行在栈空间；
• 4. 本地方法栈；于操作系统相关；
• 5. 寄存器： 与CPU 相关，

集合；；

• 集合是个接口api,他是一组对象，有的 是有序的，有点事无序的；

• collection 系列； ; Map

• list set ; HashMap TreeMap;

• ArrayList LinkList HashSet TreeSet;

• 他们位于java.util包中；

collection方法

• 存储数据 是不唯一，无序 的对象；（唯一，元素只有一个，无序 指的 是 输入 顺序和输出顺序不一致叫做 无序）：

• add()方法；

• 他是个接口，不能够实例化；

• Collection coll = new ArrayList();

• coll.add(“a”);

• coll.clear(),清空集合中的所有元素；

• Student stu1 = new Student();

• Student stu2 = new Student();

• coll.add(stu);

• 2. collection 可以直接有效的求出数组真实 数据的 元素个数；
• 3. addAll(); 可以将一个集合中的所有元素增加到 所有另一个 集合当中； coll1.addAll(coll2);
• 4. contains(“a”); 判断是否包含a;
• 5. containsAll() 判断一个集合是够包含 另一个 集合 的 所有元素；
• 6. isEmpty(),判断集合是不是空，返回Boolean 数值；
• 7. iterator(); 返回迭代器；
• 8. while( iter.hasNext()) { iter.next();//取出下一个元素；}
• 9. remove(“b”);//可以 删除集合当中 指定 的 对象；
• 10. coll1.removeAll(coll1); //从集合当中删除另一个集合所包含 的 元素
• 11. retainAll(); 从一个集合 只保留另一个 集合所 包含 的元素；
• 12. size() 获取当前元素 集合中的个数；
• 13. toArray();//将集合转换为 数组；

集合 list 方法；

• 1. List list = new ArrayList();
• add();// 有序；按照a,b,c,d;
• add(index,“a”);// 重载方法；在index 下标下 增加 一个对象；
• addAll(indx,coll(集合));// 和上面 的 add() 类似；从第几个位置开始添加集合；
• 2. get(); /返回指定位置 的元素；list.get(1);
• 3. indexOf(); //返回， 从左往右查找；
• 4. lastIndexOf(“a”); //从后往前找，返回Int（位置);
• 5. remove(“e”);// 可以删除指定元素 第一次 出现的 位置；
• remove(3);// 删除 指定位置的 元素；
• 注意 collection 不可以 按照 顺序 删除；
• 6. set(); list.set(3,“中”); //将 指定 位置 的元素 或者 对象 修改 为新的 对象；
• 7. list.sublist(2,4); 左闭右开； 截取 和 substring() 类似；

ArrayList ， linklist, hashSet,TreeSet HashMap, TreeMap;

• HashXXX; 底层借助了 哈希表 的结构；
• treeXXX；底层借助了 红黑树， 可以排序；

LinkList()

• addFirst(); addLast();
• remove(index);//根据 下标删除， 或者根据内容 删除；
• set 智能 根据 内容删除， 不能根据 下标删除， 因为他是 无序 ；

Map 和 collection 无关系；

• collection 是单只集合 ，但是 map 是 kv 对；
• 可以 根据 k 找到 value；
• map.put(k,value);//插入元素；
• map.get(k);
• map.size();
• map.containsKey(k); map.containsValue(value);
• 双值集合 变成 单值 集合； map.keySet(); 返回set 类型；value 是不唯一的；
• map.values(); 返回 collection;
• map.remove(key); 如果删除 不存在， 则不报错；返回值 是删除 的对象；
• 删除： 如果是collection 中的类，返回 值 是boolean, 如果是 map ，返回值 是value；

遍历ji合 的 方法

• for 循环；无序 的数组 没有 get 方法， 用增强 For；（ 普通for: 对 hashset 不适用—）；
• 迭代器；hasNext(); next();

匿名对象

• new person()
• int num = new Scanner(System.in).nextInt();
• 使用匿名对象作为方法 的参数 和 返回值 都是可以的；

Random

• 导包，创建，使用；
• Random r = new Random();
• r.nextInt(); //返回值 是 int;
• r.nextInt(10); //0 到9 之间；
• 如果获取 1到N呢， r.nextInt(N)+1; //返回值是 int

ArrayList 动态数组

• Arraylist array = new ArrayList<>();
• 空的 是[];
• array.add(“赵丽颖”);

线程池

• java.util.concurrent;
• Executors, 静态方法：newFixedThredPool(int number);
• jdk1.5后提供；
• 底层是集合；
• java.util.concurrent.ExecutorService接口；
• 使用步骤： 使用Executors使用静态方法生产线程池，创建一个类实现runnablue接口
• 然后调用线程池的submit 方法，传递线程任务（实现类），开启线程，执行run方法；
• 调用线程池的方法 shutdowm，销毁线程池（不建议 使用）：

lambda表达式，

• 函数式的编程思想；

使用前提：

1、存在接口，内部只有一个抽象方法（函数式接口）

使用规则：

• 1. ()->{}
• 2. 省略规则：（）里面可以省略类型，（int a,int b) (a,b);
• 3. 函数体只有一行，可以省略{} ; return 这三个要省略一起省略。
• 4. （）里面有且只有一个参数，那么小括号可以省略，ex： （int a) a;

file类

• java.io.File类

• 文件和目录路径名的抽象表示形式。

• file 文件 directory 目录 path路径；

• 普通方法：

• getName();

• lengeth();//获取文件大小，以字节为单位；

• 文件夹没有大小概念，返回为0；

• boolean exists();//判断构造方法中的路径是否存在；

• boolean isDirectory();//判断构造方法给定的路径是否是以文件夹结尾

• Boolean isFile();//判断这个文件是不是存在；

• Boolean createNewFile();//创建新的文件；

• mkdir();//创建单级文件夹

• mkdirs();//多级文件夹

• list();遍历文件中所有的文件夹，返回string 数组

• listFiles();返回文件中所有的文件夹，返回File数组

递归；

• 直接递归和间接递归

字符串

• endwith();判断字符串是否以。。结尾；

lambda表达式使用场景，对于匿名内部类进行优化，接口只有一个方法

文件过滤器

• Filefilter; accept(File pathname)方法；
• FileNameFilter ; accept(File dir, String name);

arraylist

• 底层是object 数组 elemenetData

• size 是实际添加的个数，不是底层的 长度

• 构造方法，传长度，如果长度大于0,那么长度等于 参数

• 如果参数为0，那么 EMPTY_ELEMENTDATA{} 长度等于0 的数组

• 否则（参数<0)，抛出异常

• 无参构造， 长度为0 的数组

• arraylist() 和 arraylist(0) 的区别

• 无参构造在 首次扩容 的时候 长度 至少扩容 到10；在mincapacity和default_capacity=10中 取得最大数值；

• • add()

    • ensureCapacityInternal(size+1)
      *1 ensureExplicitCapacity

      • claculateCapacity(elementData,minCapacity)
        • 如果是无参 构造首次添加是，长度 会至少 扩大 到10 ；

      1 这个方法 调用grow函数，进行1.5倍扩容，oldcapacity+ oldcapacity>>1; oldcapacity是原来的长度； 101.5 =15；

      • 如果还不够，更新到110；
      • 如果 新长度 大于 最大 长度， 返回int 的最大值；
      • 调用grow(int mincapacity)扩容，然后grow()进行判断，调用 arrays.copyOf(elementData, newCapacity)进行扩容；

    • elementData[size++]

linklist 双向链表

• 内部类Node，表示 每一个元素 都封装到Node

• 存 的内容 是item

• prev 上一个node 地址，这个 是地址

• next 下一个 node 地址

• size 表示 实际添加 的元素

• first 表示 队手是 那个 Node

• last 表示 队尾 是那个 Node

• modCount ++ ; 记录 的是操作次数

• 介绍了 add 和 get 方法 的底层实现 原理

Linklist 和 Arraylist 性能比较

• 尾部添加 的 时候 linkList 快（10万），可以忽视。100万 的时候arraylist 快

• 中间插入的 时候 linkList 性能 高于 arrayList 很多很多

• 查询的话，遍历 时间差不多

• 增强for 是迭代器 的 简写

HashMap

• map.put(k,v);

• map.get(k);

• 底层是 数组 套链表，底层是Node()数组

• 通过key 计算出来应该 放到 那个 数组 的下标

• 负载因子 0.75，当你用到 0.75时候，就认为你得扩容了。

长度必须是 2的幂次方

• 如果数组 长度到达64，且 链大于8才转 红黑树，否则扩容

• Node: hash,key,value, next

• 单项链表

• 2 个参数的 构造函数， 负载因子(loadfactor)，临界值初始化(threshold)

• 返回一个 2的幂次方

• 一个参数 的 构造， 一个 参数 就 是调用 两个 参数 的构造，负载因子 固定0.75 threshold

• 无参构造方法； 只有负载因子 赋值（loadfactor);

• 无论 调用 几个 参数 的 构造函数，数组 table 都没有初始化；

• put(k,v);

• put 调用 的是 putVal();

• hash(k); 计算 通过k 计算 哈希码

• default_initial_capacity: 默认的初始化容量是 16；

• 负载因子 是0.75， newthr= 默认初始容量*负载因子；也就是说，当 用到12个的时候，他就达到了 新的临界值，危险了，得扩容了；

• 长度 一定 是 2的幂次方的原因： 就是因为 在这个情况下通过不同 的哈希吗 计算出 不同 的下标来；

• 所以扩容 每次 *2；

string

• string a = “abc”;
  final string b =“ab”;
  string c = a+b;
  a==c? true;
• string a = “abc”;
  string b =“ab”;
  string c = a+b;
  a==c? false;

countDownLantch

• countDouwnLatch.countDown(); 解锁
• coutDowmLatch.await(); 等待
• volatile ； 线程 的可见性

arraylist 是非线程 安全的，但是vector是线程 安全的；

• stringbuffer 和 Stringbuilder 一个 安全，一个 不安全；

• 在自己 不加 任何 同步 的情况 下，仍然 是 安全 的，叫做 线程 安全的；

• 加上 synchronized 是多车道变成 了 单车道

• 信号量 可以 将 多车道 变成 双车道 啊等等

• Semaphore

• acquire; release;

• hashmap 的 线程 安全类 ； 是hashtable;

day06

• 连接池
• druid(阿里) hikan(日本) c3p0(性能很差)

javaweb

• bs(执行代码在server) cs(执行代码在客户端)

• 用户向 server 发送请求，就是 url,

• 服务器接收到请求，根据不同的请求 做不同 的事情

• servlet组件，专门用来 处理用户请求

• 组件：.java文件 （类） 能够实现特定功能 的类(实现接口 或者 继承父类)

• 怎么让 一个 类 成为 servlet 组件？

• 1. 继承 httpServelt(导入servlet.jar)
• 2. 配地址： 1 。 配置web.xml 2.配置webServlet注解 @WebServlet("\test")
• 3. 重写 doGet 和 doPost();不建议 重写 Servlet();

• response.getWriter("");

• <%
  工作时 绝对不能 里面 嵌套 java 代码
  %>

• 现在 作用域 搭配 el表达式

• 所有 的浏览器 都不允许 直接访问jsp

• el 表达式： &{}

• 所有 的jsp都放在web-inf 目录下

• 必须经过 servlet 转发

作用域

• pageContext 当前页面

• request 当前页面 和 转发页面（同一次请求）

• session 当前页面存，当前 会话取出

• application 当前服务器下取出，只要服务器 不重启，就可以取出

• 方法： setAttribute(key,value); getAttribute(key);

• <%=session.getAttribute(“key”)%>

• 转发：request.getRequestDispatcher().forword();

• 重定向： sendRedirect(“index2.jsp”); 定向后 request没了

• session的会话跟踪 依赖 于 cookie;

• session是一种机制，但是httpsession是一种技术

• http是 一种 无状态 的 协议

• 转发 是1次请求，地址栏不变，不能跨域

• 重定向 是2次请求，可以跨域，地址栏变化