黑马笔记总结(二)

14.02_常见对象(字符类演示)

  • A:字符类

    • [abc] a、b 或 c(简单类)
    • [^abc] 任何字符,除了 a、b 或 c(否定)
    • [a-zA-Z] a到 z 或 A到 Z,两头的字母包括在内(范围)
    • [0-9] 0到9的字符都包括
  • A:预定义字符类

    • . 任何字符。
    • \d 数字:[0-9]
    • \w 单词字符:[a-zA-Z_0-9]
  • A:Greedy 数量词

    • X? X,一次或一次也没有
    • X* X,零次或多次
    • X+ X,一次或多次
    • X{n} X,恰好 n 次
    • X{n,} X,至少 n 次
    • X{n,m} X,至少 n 次,但是不超过 m 次

14.09_常见对象(Pattern和Matcher的概述)

  • B:模式和匹配器的典型调用顺序

    • 通过JDK提供的API,查看Pattern类的说明

    • 典型的调用顺序是

    • Pattern p = Pattern.compile(“a*b”);
    • Matcher m = p.matcher(“aaaaab”);
    • boolean b = m.matches();

14.17_常见对象(SimpleDateFormat类实现日期和字符串的相互转换)(掌握)

  • A:DateFormat类的概述
    • DateFormat 是日期/时间格式化子类的抽象类,它以与语言无关的方式格式化并解析日期或时间。是抽象类,所以使用其子类SimpleDateFormat
  • B:SimpleDateFormat构造方法
    • public SimpleDateFormat()
    • public SimpleDateFormat(String pattern)
  • C:成员方法
    • public final String format(Date date)
    • public Date parse(String source)

15.02_集合框架(集合的由来及集合继承体系图)

  • B:数组和集合的区别
    • 区别1 :
      • 数组既可以存储基本数据类型,又可以存储引用数据类型,基本数据类型存储的是值,引用数据类型存储的是地址值
      • 集合只能存储引用数据类型(对象)集合中也可以存储基本数据类型,但是在存储的时候会自动装箱变成对象
    • 区别2:
      • 数组长度是固定的,不能自动增长
      • 集合的长度的是可变的,可以根据元素的增加而增长
  • C:数组和集合什么时候用
    * 1,如果元素个数是固定的推荐用数组
    * 2,如果元素个数不是固定的推荐用集合

15.04_集合框架(集合的遍历之集合转数组遍历)

  • 把集合转成数组,可以实现集合的遍历toArray()

15.06_集合框架(集合的遍历之迭代器遍历)

  • 迭代器的使用

        Collection c = new ArrayList();
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");
    
        Iterator it = c.iterator();                     //获取迭代器的引用
        while(it.hasNext()) {                           //集合中的迭代方法(遍历)
            System.out.println(it.next());
        }
    

15.10_集合框架(List集合存储学生对象并遍历)

* 通过size()和get()方法结合使用遍历。
        List list = new ArrayList();
        list.add(new Student("张三", 18));
        list.add(new Student("李四", 18));
        list.add(new Student("王五", 18));
        list.add(new Student("赵六", 18));

        for(int i = 0; i < list.size(); i++) {
            Student s = (Student)list.get(i);
            System.out.println(s.getName() + "," + s.getAge());
        }

B:ConcurrentModificationException出现
* 迭代器遍历,集合修改集合
* C:解决方案
* a:迭代器迭代元素,迭代器修改元素(ListIterator的特有功能add)
* b:集合遍历元素,集合修改元素
ListIterator lit = list.listIterator(); //如果想在遍历的过程中添加元素,可以用ListIterator中的add方法
while(lit.hasNext()) {
String str = (String)lit.next();
if(str.equals(“world”)) {
lit.add(“javaee”);
//list.add(“javaee”);
}
}

16.06_集合框架(泛型概述和基本使用)(掌握)

  • B:泛型好处
    • 提高安全性(将运行期的错误转换到编译期)
    • 省去强转的麻烦
  • C:泛型基本使用
    • <>中放的必须是引用数据类型
  • D:泛型使用注意事项
    • 前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型)

16.12_集合框架(泛型高级之通配符)(了解)

  • A:泛型通配符

16.16_集合框架(静态导入的概述和使用)(掌握)

  • A:静态导入概述
  • B:格式:
    • import static 包名….类名.方法名;
    • 可以直接导入到方法的级别
  • C:注意事项
    • 方法必须是静态的,如果有多个同名的静态方法,容易不知道使用谁?这个时候要使用,必须加前缀。由此可见,意义不大,所以一般不用,但是要能看懂。

16.17_集合框架(可变参数的概述和使用)(掌握)

  • A:可变参数概述
    • 定义方法的时候不知道该定义多少个参数
  • B:格式
    • 修饰符 返回值类型 方法名(数据类型… 变量名){}
  • C:注意事项:
    • 这里的变量其实是一个数组
    • 如果一个方法有可变参数,并且有多个参数,那么,可变参数肯定是最后一个

17.02_集合框架(HashSet存储自定义对象保证元素唯一性)

  • A:案例演示
    • 存储自定义对象,并保证元素唯一性。
  • 重写hashCode()和equals()方法

17.04_集合框架(HashSet如何保证元素唯一性的原理)

  • 1.HashSet原理
    • 我们使用Set集合都是需要去掉重复元素的, 如果在存储的时候逐个equals()比较, 效率较低,哈希算法提高了去重复的效率, 降低了使用equals()方法的次数
    • 当HashSet调用add()方法存储对象的时候, 先调用对象的hashCode()方法得到一个哈希值, 然后在集合中查找是否有哈希值相同的对象
      • 如果没有哈希值相同的对象就直接存入集合
      • 如果有哈希值相同的对象, 就和哈希值相同的对象逐个进行equals()比较,比较结果为false就存入, true则不存
  • 2.将自定义类的对象存入HashSet去重复
    • 类中必须重写hashCode()和equals()方法
    • hashCode(): 属性相同的对象返回值必须相同, 属性不同的返回值尽量不同(提高效率)
    • equals(): 属性相同返回true, 属性不同返回false,返回false的时候存储

17.15_集合框架(TreeSet原理)

  • 2.使用方式
    • a.自然顺序(Comparable)
      • TreeSet类的add()方法中会把存入的对象提升为Comparable类型
      • 调用对象的compareTo()方法和集合中的对象比较
      • 根据compareTo()方法返回的结果进行存储
    • b.比较器顺序(Comparator)
      • 创建TreeSet的时候可以制定 一个Comparator
      • 如果传入了Comparator的子类对象, 那么TreeSet就会按照比较器中的顺序排序
      • add()方法内部会自动调用Comparator接口中compare()方法排序
      • 调用的对象是compare方法的第一个参数,集合中的对象是compare方法的第二个参数
    • c.两种方式的区别
      • TreeSet构造函数什么都不传, 默认按照类中Comparable的顺序(没有就报错ClassCastException)
      • TreeSet如果传入Comparator, 就优先按照Comparator

18.02_集合框架(Map集合的功能概述)

  • A:Map集合的功能概述
    • d:获取功能
      • Set

18.10_集合框架(HashMap和Hashtable的区别)

  • A:面试题
    • HashMap和Hashtable的区别
      • Hashtable是JDK1.0版本出现的,是线程安全的,效率低,HashMap是JDK1.2版本出现的,是线程不安全的,效率高
      • Hashtable不可以存储null键和null值,HashMap可以存储null键和null值

19.01_异常(异常的概述和分类)

C:异常的继承体系
* Throwable
* Error
* Exception
* RuntimeException

19.02_异常(JVM默认是如何处理异常的)

  • A:JVM默认是如何处理异常的
    • main函数收到这个问题时,有两种处理方式:
    • a:自己将该问题处理,然后继续运行
    • b:自己没有针对的处理方式,只有交给调用main的jvm来处理
    • jvm有一个默认的异常处理机制,就将该异常进行处理.
    • 并将该异常的名称,异常的信息.异常出现的位置打印在了控制台上,同时将程序停止运行

19.03_异常(try…catch的方式处理异常1)

  • A:异常处理的两种方式
    • a:try…catch…finally
      • try catch
      • try catch finally
      • try finally
    • b:throws

19.08_异常(throw的概述以及和throws的区别)

  • C:throws和throw的区别
    • a:throws
      • 用在方法声明后面,跟的是异常类名
      • 可以跟多个异常类名,用逗号隔开
      • 表示抛出异常,由该方法的调用者来处理
    • b:throw
      • 用在方法体内,跟的是异常对象名
      • 只能抛出一个异常对象名
      • 表示抛出异常,由方法体内的语句处理

19.12_异常(异常的注意事项及如何使用异常处理)

  • A:异常注意事项
    • a:子类重写父类方法时,子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏)
    • b:如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常
    • c:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws
  • B:如何使用异常处理
    • 原则:如果该功能内部可以将问题处理,用try,如果处理不了,交由调用者处理,这是用throws
    • 区别:
      • 后续程序需要继续运行就try
      • 后续程序不需要继续运行就throws

20.03_IO流(read()方法返回值为什么是int)

  • read()方法读取的是一个字节,为什么返回是int,而不是byte
  • 因为字节输入流可以操作任意类型的文件,比如图片音频等,这些文件底层都是以二进制形式的存储的,如果每次读取都返回byte,有可能在读到中间的时候遇到111111111那么这11111111是byte类型的-1,我们的程序是遇到-1就会停止不读了,后面的数据就读不到了,所以在读取的时候用int类型接收,如果11111111会在其前面补上24个0凑足4个字节,那么byte类型的-1就变成int类型的255了这样可以保证整个数据读完,而结束标记的-1就是int类型

20.10_IO流(定义小数组的标准格式)

  • A:案例演示

    • 字节流一次读写一个字节数组复制图片和视频
      FileInputStream fis = new FileInputStream(“致青春.mp3”);
      FileOutputStream fos = new FileOutputStream(“copy.mp3”);
      int len;
      byte[] arr = new byte[1024 * 8]; //自定义字节数组

      while((len = fis.read(arr)) != -1) {
      //fos.write(arr);
      fos.write(arr, 0, len); //写出字节数组写出有效个字节个数
      }

      fis.close();
      fos.close();

  • E.小数组的读写和带Buffered的读取哪个更快?

    • 定义小数组如果是8192个字节大小和Buffered比较的话
    • 定义小数组会略胜一筹,因为读和写操作的是同一个数组
    • 而Buffered操作的是两个数组

20.13_IO流(字节流读写中文)

  • 字节流写出中文的问题
    • 字节流直接操作的字节,所以写出中文必须将字符串转换成字节数组
    • 写出回车换行 write(“\r\n”.getBytes());

20.14_IO流(流的标准处理异常代码1.6版本及其以前)

  • try finally嵌套

    FileInputStream fis = null;
    FileOutputStream fos = null;
    try {
        fis = new FileInputStream("aaa.txt");
        fos = new FileOutputStream("bbb.txt");
        int b;
        while((b = fis.read()) != -1) {
            fos.write(b);
        }
    } finally {
        try {
            if(fis != null)
                fis.close();
        }finally {
            if(fos != null)
                fos.close();
        }
    }
    

20.15_IO流(流的标准处理异常代码1.7版本)

  • try close

    try(
        FileInputStream fis = new FileInputStream("aaa.txt");
        FileOutputStream fos = new FileOutputStream("bbb.txt");
        MyClose mc = new MyClose();
    ){
        int b;
        while((b = fis.read()) != -1) {
            fos.write(b);
        }
    }
    
  • 原理
    • 在try()中创建的流对象必须实现了AutoCloseable这个接口,如果实现了,在try后面的{}(读写代码)执行后就会自动调用,流对象的close方法将流关掉

20.18_IO流(录入数据拷贝到文件)

  • 将键盘录入的数据拷贝到当前项目下的text.txt文件中,键盘录入数据当遇到quit时就退出

    Scanner sc = new Scanner(System.in);
    FileOutputStream fos = new FileOutputStream("text.txt");
    System.out.println("请输入:");
    while(true) {
        String line = sc.nextLine();
        if("quit".equals(line))
            break;
        fos.write(line.getBytes());
        fos.write("\r\n".getBytes());
    }
    
    fos.close();
    

21.04_IO流(什么情况下使用字符流)

  • 字符流也可以拷贝文本文件, 但不推荐使用. 因为读取时会把字节转为字符, 写出时还要把字符转回字节.
  • 程序需要读取一段文本, 或者需要写出一段文本的时候可以使用字符流
  • 读取的时候是按照字符的大小读取的,不会出现半个中文
  • 写出的时候可以直接将字符串写出,不用转换为字节数组

21.05_IO流(字符流是否可以拷贝非纯文本的文件)

  • 不可以拷贝非纯文本的文件
  • 因为在读的时候会将字节转换为字符,在转换过程中,可能找不到对应的字符,就会用?代替,写出的时候会将字符转换成字节写出去
  • 如果是?,直接写出,这样写出之后的文件就乱了,看不了了

21.08_IO流(readLine()和newLine()方法)

  • BufferedReader的readLine()方法可以读取一行字符(不包含换行符号)
  • BufferedWriter的newLine()可以输出一个跨平台的换行符号”\r\n”
    BufferedReader br = new BufferedReader(new FileReader(“aaa.txt”));
    BufferedWriter bw = new BufferedWriter(new FileWriter(“bbb.txt”));
    String line;
    while((line = br.readLine()) != null) {
    bw.write(line);
    //bw.write(“\r\n”); //只支持windows系统
    bw.newLine(); //跨平台的
    }

    br.close();
    bw.close();
    

21.10_IO流(LineNumberReader)

  • LineNumberReader是BufferedReader的子类, 具有相同的功能, 并且可以统计行号
    • 调用getLineNumber()方法可以获取当前行号
    • 调用setLineNumber()方法可以设置当前行号
  • LineNumberReader lnr = new LineNumberReader(new FileReader("aaa.txt"));
    String line;
    lnr.setLineNumber(100);                                 //设置行号
    while((line = lnr.readLine()) != null) {
        System.out.println(lnr.getLineNumber() + ":" + line);//获取行号
    }
    
    lnr.close();
    

21.11_IO流(装饰设计模式)

    interface Coder {
        public void code();
    }

    class Student implements Coder {

        @Override
        public void code() {
            System.out.println("javase");
            System.out.println("javaweb");
        }

    }

    class HeiMaStudent implements Coder {
        private Student s;                      //获取到被包装的类的引用
        public ItcastStudent(Student s) {       //通过构造函数创建对象的时候,传入被包装的对象
            this.s = s;
        }
        @Override
        public void code() {                    //对其原有功能进行升级
            s.code();
            System.out.println("数据库");
            System.out.println("ssh");
            System.out.println("安卓");
            System.out.println(".....");
        }

    } 

21.12_IO流(使用指定的码表读写字符)

  • FileReader是使用默认码表读取文件, 如果需要使用指定码表读取, 那么可以使用InputStreamReader(字节流,编码表)
  • FileWriter是使用默认码表写出文件, 如果需要使用指定码表写出, 那么可以使用OutputStreamWriter(字节流,编码表)
  • BufferedReader br =                                     //高效的用指定的编码表读
            new BufferedReader(new InputStreamReader(new FileInputStream("UTF-8.txt"), "UTF-8"));
    BufferedWriter bw =                                     //高效的用指定的编码表写
            new BufferedWriter(new OutputStreamWriter(new FileOutputStream("GBK.txt"), "GBK"));
    int ch;
    while((ch = br.read()) != -1) {
        bw.write(ch);
    }
    
    br.close();
    bw.close();
    

22.02_IO流(序列流整合多个)(了解)

  • 整合多个: SequenceInputStream(Enumeration)
  • FileInputStream fis1 = new FileInputStream("a.txt");    //创建输入流对象,关联a.txt
    FileInputStream fis2 = new FileInputStream("b.txt");    //创建输入流对象,关联b.txt
    FileInputStream fis3 = new FileInputStream("c.txt");    //创建输入流对象,关联c.txt
    Vector<InputStream> v = new Vector<>();                 //创建vector集合对象
    v.add(fis1);                                            //将流对象添加
    v.add(fis2);
    v.add(fis3);
    Enumeration<InputStream> en = v.elements();             //获取枚举引用
    SequenceInputStream sis = new SequenceInputStream(en);  //传递给SequenceInputStream构造
    FileOutputStream fos = new FileOutputStream("d.txt");
    int b;
    while((b = sis.read()) != -1) {
        fos.write(b);
    }
    
    sis.close();
    fos.close();
    

22.03_IO流(内存输出流*)(掌握)

  • 2.使用方式

    • 创建对象: new ByteArrayOutputStream()
    • 写出数据: write(int), write(byte[])
    • 获取数据: toByteArray()
    • FileInputStream fis = new FileInputStream("a.txt");
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      int b;
      while((b = fis.read()) != -1) {
          baos.write(b);
      }
      
      //byte[] newArr = baos.toByteArray();               //将内存缓冲区中所有的字节存储在newArr中
      //System.out.println(new String(newArr));
      System.out.println(baos);
      fis.close();
      

22.04_IO流(内存输出流之黑马面试题)(掌握)

  • 定义一个文件输入流,调用read(byte[] b)方法,将a.txt文件中的内容打印出来(byte数组大小限制为5)

  • FileInputStream fis = new FileInputStream(“a.txt”); //创建字节输入流,关联a.txt
    ByteArrayOutputStream baos = new ByteArrayOutputStream(); //创建内存输出流
    byte[] arr = new byte[5]; //创建字节数组,大小为5
    int len;
    while((len = fis.read(arr)) != -1) { //将文件上的数据读到字节数组中
    baos.write(arr, 0, len); //将字节数组的数据写到内存缓冲区中
    }
    System.out.println(baos); //将内存缓冲区的内容转换为字符串打印
    fis.close();

22.09_IO流(打印流的概述和特点)(掌握)

  • 1.什么是打印流
    • 该流可以很方便的将对象的toString()结果输出, 并且自动加上换行, 而且可以使用自动刷出的模式
  • 2.使用方式

    • 打印: print(), println()
    • 自动刷出: PrintWriter(OutputStream out, boolean autoFlush, String encoding)
    • 打印流只操作数据目的

      PrintWriter pw = new PrintWriter(new FileOutputStream("g.txt"), true);
      pw.write(97);
      pw.print("大家好");
      pw.println("你好");               //自动刷出,只针对的是println方法
      pw.close();
      
  • 2.修改标准输入输出流(了解)

    • 修改输入流: System.setIn(InputStream)
    • 修改输出流: System.setOut(PrintStream)
      System.setIn(new FileInputStream(“a.txt”)); //修改标准输入流
      System.setOut(new PrintStream(“b.txt”)); //修改标准输出流

      InputStream in = System.in;                             //获取标准输入流
      PrintStream ps = System.out;                            //获取标准输出流
      int b;
      while((b = in.read()) != -1) {                          //从a.txt上读取数据
          ps.write(b);                                        //将数据写到b.txt上
      }
      
      in.close();
      ps.close();
      

22.11_IO流(两种方式实现键盘录入)(了解)

  • A:BufferedReader的readLine方法。
    • BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  • B:Scanner

22.14_IO流(Properties的概述和作为Map集合的使用)(了解)

  • A:Properties的概述

    • Properties 类表示了一个持久的属性集。
    • Properties 可保存在流中或从流中加载。
    • 属性列表中每个键及其对应值都是一个字符串。
  • A:Properties的特殊功能

    • public Object setProperty(String key,String value)
    • public String getProperty(String key)
    • public Enumeration stringPropertyNames()
  • A:Properties的load()和store()功能

你可能感兴趣的:(黑马笔记总结(二))