Java基础提升高级API---百知教育java基础学习3

Java基础提升高级API—百知教育java基础学习3
https://www.bilibili.com/video/BV1pE41137JY

函数接口回调 — todo day10

目录

P1-Object类    15:41
P2-Object类中的方法-1    1:08:32
P3-Object类中的方法-2    55:06
P4-包装类    49:17
P5-Object类习题课    45:36
P6-日期处理    24:56
P7-String类的用法    1:04:47
P8-String习题课    25:58
P9-字符串常量池    1:04:48
P10-集合的概念    48:30
P11-List的常用方法    35:27
P12-List的四种遍历方式    1:13:15
P13-泛型    45:57
P14-List的实现类    33:44
P15-Set集合    1:23:26
P16-Map集合    1:14:55
P17-集合习题课    1:01:16
P18-JDK5中的语法    44:22
P19-异常的分类    1:08:31
P20-异常的产生和传递    23:56
P21-声明抛出异常    55:41
P22-捕获异常    1:05:23
P23-IO流的分类    43:34
P24-字节流-1    25:39
P25-字节流-2    34:57
P26-缓冲字节流    1:16:22
P27-对象序列化    40:25
P28-对象的克隆    1:04:49
P29-字符编码与乱码问题    1:12:26
P30-字符流    33:46
P31-File类    20:06
P32-IO习题课    42:45
P33-多线程的基本编程    1:01:23
P34-线程的基本状态    35:57
P35-线程的阻塞    22:40
P36-线程池    1:01:04
P37-Callable和Future接口    54:46
P38-多线程的同步    1:06:12
P39-同步代码块    58:42
P40-同步方法    11:13
P41-线程安全的集合    50:24
P42-队列接口    31:51
P43-死锁问题    28:59
P44-类对象    56:58
P45-反射的应用    1:08:47
P46-单例设计模式    55:02
P47-工厂设计模式    42:55

类和包装类

P1-Object类 15:41

Object类，所有类的父类
如果一个类没有指定父类，默认继承Object类 
Object o = 任何对象 
Object o != 8种基本类型（byte short int long float double char boolean）
Object 类中定义的方法，是所有java对象都具有的方法  （public protected）

P2-Object类中的方法-1 1:08:32

P3-Object类中的方法-2 55:06

方法名	作用	备注
getClass()	获得对象的实际类型	o1.getClass()=o2.getClass(); 判断类型是否相同
finalize()	在对象被垃圾回收时调用	没有典型的使用场景
toString()	返回对象的字符串形式	System.out.println(o); 等于System.out.pringln(o.toSTring());
equals	判断两个对象的内容是否相同	o1.equals(o2) 判断o1和o2内容是否相同

垃圾自动收集：由JVM的垃圾收集器自动回收垃圾对象，释放对象的堆空间
问：什么对象被认为是垃圾对象？
答：零引用算法 如果一个对象，没有任何对象引用它，就判断它是垃圾
问： 垃圾对象何时被回收？
答：不得不回收时候，才回收（全家人一起吃饭，刷碗要等到所有人吃完饭以后一起刷，不会一个人吃饭饭后，刷一个碗）
问：finalize() 具体作用？
答： 没有什么作用
JVM规范
JVM产品

System.gc(); //呼吁垃圾回收器，开始收集垃圾

toString()
返回对象的字符串形式
打印一个对象，就是打印这个对象toString()方法的返回值String
可以在子类覆盖toString();方法

== 用在引用类型时候判断地址是否相同
equals 判断内容是否相同 s1.equals(s2) 说明s1 s2 内容相同
object类中的equals方法，依然比较两个对象的地址

getClass() 获得对象实际类型
instanceof 判断对象是不是某一类型 a instanceof Animal ; a instance of Dog ;

equals 标准写法

 public boolean equals(Object o){
   
   
        // 是否同一个对象
       // 是否非Null
       // 是否同一类
       // 强转
       // 属性比较
   }


  //this     vs  o  比较内容
   public boolean equals(Object o){
   
   
        //1 判断 this    o  是不是同一对象  ，你媳妇 和你孩子他妈
       if(this == o ) return true;
       //2 判断o 是不是Null
       if(o ==null) return false;
       //3 判断this    o  是不是属于同一个类
       if(this.getClass() != o.getClass()) return false;
       // 4  对o 做强制类型转化，变为 Employee 类型
       Employee e =(Employee) o;
       // 5 逐个比较属性  基本类型用 == 引用类型 用equals
       if(this.age == e.age && this.name.equals(e.name)) {
   
   
           return true;
       }else{
   
   
           return false;
       }
   }

P4-包装类 49:17

Object o= 任何对象
Object o =10; error

为8中基本数据类型 各自提供一个类(8个类，是8个基本类型的对象形式)
所有的基本数据类型就有了对应的对象形式

int ---- > Integer

基本类型	对应的包装类
int	Integer
char	Charactor
byte	Byte
short	Short
long	Long
float	Float
double	Double
boolean	Boolean

• 基本类型 与 包装类之间的转换
  int — > Integer
  Integer.valueOf(i); 获得一个Integer对象
  Integer内部会预先创建 -128 ~ 127 256个对象，如果在此区间不会创建新对象
  Integer —> int
  a.intValue();
  从jdk5开始，编译器帮助我们，自动封箱、自动拆箱 ；
  虚拟机还是会区分，什么是基本类型 ，什么是 对象（包装类） ；
• 基本类型与String之间的转换 （这块用的多 ）
  int ----> String
  int i=12; String s=i+“”;
  String s =String.valueof(i);
  String----> int
  String s=“123456”; int i=Integer.ParseInt(s);
• 包装类与String之间的转换
  Integer ----> String
  Integer a=1234; String s = a.toString(); //是对象所以有Object的toString()方法 ；
  String ----> Integer
  String s =“1234”; Integer a =Integer.valueof(s);

P5-Object类习题课 45:36

修饰符总结

表格	类	方法	构造方法	成员变量	局部变量	初始代码块	成员内部类
private		√	√	√			√
默认	√	√	√	√			√
protected		√	√	√			√
public	√	√	√	√			√
static		√		√		√	√
final	√	√		√	√
abstract	√	√

  System.out.println("=================================");
        int a1=new Integer(128);
        int a2=new Integer(128);
        System.out.println(a1== a2);              //true  比较的是值 所以 true

        Integer integer1 = Integer.valueOf(a1);
        Integer integer2 = Integer.valueOf(a2);  //a1  a2 都不影响结果
        System.out.println(integer1==integer2);  //false  比较的是对象  且128 不在-128~127  需要单独创建

        Integer int1=new Integer(120);
        Integer int2=new Integer(120);
        System.out.println(int1==int2);          //false  比较对象

        Integer integer11 = Integer.valueOf(int1);
        Integer integer12 = Integer.valueOf(int2);//int1 int2  都不影响结果
        System.out.println(integer11==integer12);  //true   在-128~127  无需单独创建

        Integer int3 = new Integer(128);
        Integer int4 = new Integer(128);
        System.out.println(int3==int4);            //false  比较对象
        System.out.println("=================================");

P6-日期处理 24:56

package day16;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;

/**
 * @author leowei
 * @date 2020/12/29  - 13:40
 */
public class TestCalendar {
   
   
    public static void main(String[] args) {
   
   

        // *******
        long timeNowLong = System.currentTimeMillis();       // 距离 1970 年 的毫秒数
        System.out.println("timeNow = " + timeNowLong);

        // *******
       // Calendar c = Calendar.getInstance();
        Calendar c = Calendar.getInstance(Locale.FRANCE);  //
        Date timeNow = c.getTime();
        System.out.println("timeNow = " + timeNow);

        // *******
        c.setTimeInMillis(timeNowLong);
        int year = c.get(Calendar.YEAR);
        int dayM = c.get(Calendar.DAY_OF_MONTH);
        int dayY = c.get(Calendar.DAY_OF_YEAR);
        int dayW = c.get(Calendar.DAY_OF_WEEK);
        int daySpe =c.getFirstDayOfWeek();
        System.out.println("dayW: " + dayW+ " ;  dayMonth:"+ dayM + "; dayYear:"+ dayY + " ; year: "+ year +"; firstDayofWeek:"+ daySpe);
        //dayW: 3 ;  dayMonth:29; dayYear:364 ; year: 2020; firstDayofWeek:1
        // *******
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String formatTime = sdf.format(timeNow);
        System.out.println("formatTime = " + formatTime);



    }
}

P7-String类的用法 1:04:47

凡是没有数值含义的数字，一定不要把它当数值类型。

字符串中的常用方法

• 与字符数组相关操作
  String(char[] cs) 利用字符数组构造字符串
  toCharArray() 把字符串转字符数组
• 基础方法
  toUpperCase()
  toLowerCase()
  charAt(int index)
  length()
  trim();
  equals();
  equalsIgnoreCase();//忽略大小写比较，使用场景 验证码
• 与子串相关
  contains(String str)
  indexof(String str)
  indexof(String str,int fromIndex);
  substring(int fromIndex)
  substring(int fromIndex,int endIndex);
  replace(string str1,string str2)
  split(String str); str作为分隔符,将字符串切割为String[]

P8-String习题课 25:58

1.判断一个字符串是否为 回文 字符串 abcdcba --》 abcdcba
2. 在一个字符串“ABCDIFGABC234BC23432BAC2343ABCD”中找出所有的“BC”字符串

private static boolean huiwen03() {
   
   
        String strInput="abcdefggfedcba";  //abcdcba   abcba  abba  都可以

        for(int i=0;i< strInput.length()/2; i++){
   
   
           if(strInput.charAt(i)!=strInput.charAt(strInput.length()-1-i)) return  false;
        }
        return true;
    }
  private static  void AllIndexOf(String s,String str){
   
   
        int start=0;
        while(true){
   
   
            int indexOf = s.indexOf(str, start);
            if(indexOf==-1) break;
            System.out.println(indexOf);
            start = indexOf + str.length();

        }
    }

P9-字符串常量池 1:04:48

串池，与 StringBuilder

一个String对象的内容是不可以改变的，因此多个引用可以指向同一个字符创对象。-----这句话体会一下串池的概念
当字符串的内容发生改变时候，只会创建新对象
虚拟机存储空间 ：堆 栈 方法区
串池：字符串常量池 ，用来存放字符串对象，以供多个引用共享（通常存放在方法区）

public interface CharSequence {

package day14;

/**
 * @author leowei
 * @date 2020/12/29  - 15:27
 */
public class TestStringAppend {
   
   
    public static void main(String[] args) {
   
   
        String s1="ABC";
        String s2="ABC";
        System.out.println("s1 =  s2 :" +  s1== s2);            //false why???
        System.out.println("s1 =  s2 :" +  (s1== s2));            //true 
        System.out.println("s1.equals(s2) = " + s1.equals(s2));  //true 
        System.out.println("s2.equals(s1) = " + s2.equals(s1));  //true 

        String s3=new String("ABC");
        String s4=new String("ABC");
        System.out.println("s3==s4 = " + (s3 == s4));  //false 
    }
}

集合

P10-集合的概念 48:30

集合： 用来存储对象的对象叫做集合-----容器 
object[]   数组，最基础的集合
数组是一种基础集合，数组存在如下弊端
1.数组长度固定，数组扩充是需要复杂的拷贝操作
2.数组元素在插入，删除时候不方便
         Object[] o={
   
   "ABC","DEF","XYZ"};  要插入LMN  到数组第一个位置
         Object[] o={
   
   "ABC","DEF","XYZ",null,null,null};  -- step1 扩容
         Object[] o={
   
   "ABC","DEF","XYZ","XYZ",null,null};  --- step2 挪动
         Object[] o={
   
   "ABC","DEF","DEF","XYZ",null,null};--- step3 挪动
         Object[] o={
   
   "ABC","ABC","DEF","XYZ",null,null};--- step4 挪动
         Object[] o={
   
   "LMN","ABC","DEF","XYZ",null,null}; --- step5 插入 

// 自定义List 类

package day14.day15;

import java.util.Objects;

/**
 * @author leowei
 * @date 2020/12/29  - 16:18
 */
public class TestList {
   
   
    public static void main(String[] args) {
   
   

        MyList list = new MyList();
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");
        list.add("gousheng");    //大于三个自动扩容
        list.add("xiaoli");
        list.add(0,"huhu");

        for(int i=0;i<list.size();i++){
   
   
            Object o = list.get(i);
            System.out.println("o = " + o);
        }
        /*
        o = huhu     o = zhangsan   o = lisi
        o = wangwu   o = gousheng   o = xiaoli
        * */


    }
}

class  MyList{
   
   
    private Object[] os =new Object[3];
    private int index;  //数组中有效元素的个数，也是元素下标范围  0 -  index-1 ;

    //添加到元素末尾
    public void add(Object o){
   
   
       if(os.length==index){
   
   
           expand();
       }
       os[index]=o;
       index++;
    }

    //添加元素到指定pos下标
    public void add(int pos,Object o){
   
   
        if(os.length==index){
   
   
            expand();
        }
        for(int i=index;i>pos;i--){
   
   
            os[i]=os[i-1];
        }
        os[pos]=o;
        index++;

    }

    //数组扩容 2 倍
    public  void expand(){
   
   
        Object[] os2 = new Object[os.length * 2];
        for(int i=0;i<os.length;i++){
   
   
            os2[i]=os[i];
        }
        os=os2;
    }


    public int size(){
   
   
      return index;
    }

    public Object get(int pos){
   
   
        return os[pos];
    }
}

P11-List的常用方法 35:27

collection 方法	说明
add（Object o)	把对象放入当前集合
AddAll(Collection c)
Clear()	清空集合
contains(Object o)	判断集合中是否存在o
remove(Object o)	00
size()	00
forEach()	遍历当前集合
toArray()	将当前集合转换为Object[]
-----list方法--------	----------------
add(int pos,Object o)	将元素插入到当前集合的pos下标上
get(int pos )
indexOf(Object o)
remove(int pos)	删除集合中pos位置的元素
set(int pos,Object o)	将元素设置到当前集合的pos下标上

map 方法	说明
put(K key,V value)	把 key-value 键值对 放入map ,如果key 已经存在，新value覆盖老value
V get(K key)
containsKey(K key)
containsValue(V value)
size()
remove(K key)
keySet	返回所有键的集合
values	返回map中所有值的集合

集合的组成      java.util 包 
----collection----接口
      接口特点： 元素是对象（Objet）
      常用方法：（见上表 ）
      遍历： 见下
      实现类： 无直接实现类
     
List   Collection 子接口
     接口特点：  元素有顺序，有下标 ，可以重复  
      常用方法：（见上表 ）
      遍历： (四种) 迭代遍历  for-Each遍历  forEach()自遍历   下标遍历 
      实现类： ArrayList
Set    Collection 子接口
     接口特点：   元素无顺序，无下标 ，内容不可以重复  
      常用方法：（见上表 ）
      遍历： (三种) 迭代遍历  for-Each遍历  forEach()自遍历 
      实现类： HashSet    LinkedHashSet    TreeSet  (自动对元素进行排序，根据规则过滤重复元素，极少用)

----map----接口
      接口特点： 元素是键值对    Key对象 无顺序，内容不可重复 ; value 对象 可以重复
      常用方法： 
      遍历： 见下
      实现类： HashMap  使用Hash算法实现（链表数组，红黑树）  1.2  线程不安全   允许Null作为key 或 value
              LinkedHashMap   HashMap的子类，维护键值对的添加顺序
              TreeMap  自动对键进行排序 
              HashTable     1.0 线程安全   慢   不允许Null作为key 或 value 
              Properties  Hashtable的子类 用于配置文件 
      简介：    英汉词典就是 map       apple --苹果    (apple 不可以重复)
               用户名密码  也是 map    username1 -- pwd1 （username不可以重复）

P12-List的四种遍历方式 1:13:15

pa