Java学习笔记7

TreeSet保证元素唯一和自然排序的原理和图解

package com.heima.bean;

public class Person implements Comparable<Person>{
    private String name;
    private int age;    
    public Person() {
        super();
        
    }
    public Person(String name, int age) {
        super();
        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 "Person [name=" + name + ", age=" + age + "]";
    }
    /*@Override
    public boolean equals(Object obj) {
        System.out.println("执行了吗");
        Person p = (Person)obj;
        return this.name.equals(p.name) && this.age == p.age;
    }
    @Override
    public int hashCode() {
        final int NUM = 38;
        return name.hashCode() * NUM + age;
    }*/
    /*
     * 为什么是31？
     * 1，31是一个质数，质数是能被1和自己本身整除的数
     * 2，31这个数既不大也不小
     * 3，31这个数好算，2的五次方-1，2向左移动5位减一
     */
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)    //调用的对象和传入的对象是同一个对象
            return true;    //直接返回true
        if (obj == null)    //传入的对象为null
            return false;   //返回false
        if (getClass() != obj.getClass())   //判断两个对象对应的字节码文件是否是同一个字节码
            return false;                   //如果不是直接返回false
        Person other = (Person) obj;        //向下转型
        if (age != other.age)               //调用对象的年龄不等于传入对象的年龄
            return false;                   //返回false
        if (name == null) {                 //调用对象的姓名为null
            if (other.name != null)         //传入对象的姓名不为null
                return false;               //返回false
        } else if (!name.equals(other.name))//调用对象的姓名不为null，且不等于传入对象的姓名
            return false;                   //返回false
        return true;                        //返回true
    }
    //按照年龄排序
    /*@Override
    public int compareTo(Person o) {
        int num = this.age - o.age;         //年龄是比较的主要条件
        return num == 0 ? this.name.compareTo(o.name) : num;
    }*/
    //按照姓名排序
    /*@Override
    public int compareTo(Person o) {
        int num = this.name.compareTo(o.name);  //姓名是比较的主要条件，字符串的compareTo方法
        return num == 0 ? this.age - o.age : num;
    }*/
    //按照姓名长度排序
    @Override
    public int compareTo(Person o) {
        int length = this.name.length() - o.name.length();      //比较长度为主要条件
        int num = length == 0 ? this.name.compareTo(o.name) : length; //比较内容为次要条件
        return num == 0 ? this.age - o.age : num;           //最后比较年龄
    }
    
    
}

package com.heima.set;

import java.util.TreeSet;

import com.heima.bean.Person;

public class Demo3_TreeSet {

    /**
     * TreeSet集合是用来对元素进行排序的，同样他也可以保证元素的唯一
     * 由于Person没有指定比较，所以需要重写compareTo方法
     * 当compareTo方法返回0的时候集合中只有一个元素
     * 当compareTo方法返回正数的时候集合会怎么存就怎么取
     * 当compareTo方法返回负数的时候集合会倒序存储
     */
    public static void main(String[] args) {
        System.out.println('周' + 0);
        System.out.println('张' + 0);
        System.out.println('李' + 0);
        System.out.println('王' + 0);
        System.out.println('赵' + 0);
        demo2();
    }

    public static void demo2() {
        TreeSet<Person> ts = new TreeSet<>();
        ts.add(new Person("张三11111", 23));
        ts.add(new Person("李四1111", 13));
        ts.add(new Person("周七222", 13));
        ts.add(new Person("王五11", 43));
        ts.add(new Person("赵六1", 33));
        
        System.out.println(ts);
    }

    public static void demo1() {
        TreeSet<Integer> ts = new TreeSet<>();
        ts.add(4);
        ts.add(1);
        ts.add(1);
        ts.add(2);
        ts.add(2);
        ts.add(3);
        ts.add(3);
        
        System.out.println(ts);
    }

}

TreeSet自然排序.jpg

TreeSet保证元素唯一和比较器排序的原理及代码实现

package com.heima.set;

import java.util.Comparator;
import java.util.TreeSet;

import com.heima.bean.Person;

public class Demo3_TreeSet {

    /**
     * TreeSet集合是用来对元素进行排序的，同样他也可以保证元素的唯一
     * 由于Person没有指定比较，所以需要重写compareTo方法
     * 当compareTo方法返回0的时候集合中只有一个元素
     * 当compareTo方法返回正数的时候集合会怎么存就怎么取
     * 当compareTo方法返回负数的时候集合会倒序存储
     */
    public static void main(String[] args) {
        /*System.out.println('周' + 0);
        System.out.println('张' + 0);
        System.out.println('李' + 0);
        System.out.println('王' + 0);
        System.out.println('赵' + 0);*/
        //demo2();
        TreeSet<String> ts = new TreeSet<>(new CompareByLen()); //Comparator c = new CompareByLen()
        ts.add("aaaaaaaa");
        ts.add("z");
        ts.add("wc");
        ts.add("nba");
        ts.add("cba");
        
        System.out.println(ts);
    }

    public static void demo2() {
        TreeSet<Person> ts = new TreeSet<>();
        ts.add(new Person("张三11111", 23));
        ts.add(new Person("李四1111", 13));
        ts.add(new Person("周七222", 13));
        ts.add(new Person("王五11", 43));
        ts.add(new Person("赵六1", 33));
        
        System.out.println(ts);
    }

    public static void demo1() {
        TreeSet<Integer> ts = new TreeSet<>();
        ts.add(4);
        ts.add(1);
        ts.add(1);
        ts.add(2);
        ts.add(2);
        ts.add(3);
        ts.add(3);
        
        System.out.println(ts);
    }

}

class CompareByLen implements Comparator<String> {  
    //由于CompareByLen默认继承Object类，继承了equals方法，所以不用去重写equals方法
    //但是一定要重写compare方法
    @Override               
    public int compare(String s1, String s2) {  //按照字符串长度比较
        int num = s1.length() - s2.length();    //长度为主要条件
        return num == 0 ? s1.compareTo(s2) : num;   //内容为次要条件
    }
    
}

比较器原理.jpg

TreeSet原理

1.特点
- TreeSet是用来排序的，可以指定一个顺序，对象存入之后会按照指定的顺序排列
2.使用方式
- a.自然顺序(Comparable)
  - TreeSet类的add()方法中会把存入的对象提升为Comparable类型
  - 调用对象的compareTo()方法和集合中的对象比较
  - 根据compareTo()方法返回的结果进行存储
  - 存入谁谁就会调用compareTo()方法，集合中的元素作为参数传入
- b.比较器顺序(Comparator)
  - 创建TreeSet的时候可以制定一个Comparator
  - 如果传入了Comparator的子类对象，那么TreeSet就会按照比较器中的顺序排序
  - add()方法内部会自动调用Comparator接口中compare()方法排序
    *调用add()方法的对象是compare()方法的第一个参数，集合里面的元素就相当于第二个参数
- c.两种方式的区别
  - TreeSet构造函数什么都不传，默认按照类中Comparable的顺序（没有就报错classCastException）
  - TreeSet如果传入Comparator，就优先按照Comparator

练习

package com.heima.test;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;

public class Test4 {

    /**
     * 在一个集合中存储了无序并且重复的字符串，定义一个方法，让其有序（字典顺序），而且还不能去除重复
     * 1，定义一个List集合，并存储重复的无序的字符串
     * 2，定义方法对其排序保留重复
     * 3，打印List集合
     */
    public static void main(String[] args) {
        //1，定义一个List集合，并存储重复的无序的字符串
        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("aaa");
        list.add("ccc");
        list.add("ddd");
        list.add("fffffffffff");
        list.add("heima");
        list.add("itcast");
        list.add("bbbb");
        list.add("aaa");
        list.add("aaa");
        //2，定义方法对其排序保留重复
        sort(list);
        //3,打印list
        System.out.println(list);
    }
    /*
     * 1，创建TreeSet集合对象，因为String本身就具备比较功能，但是重复不会保留，所以我们用比较器
     * 2，将List集合中所有的元素添加到TreeSet集合中，对其排序，保留重复
     * 3，清空List集合
     * 4，将TreeSet集合中排好序的元素添加到list中
     */
    public static void sort(List<String> list) {
        //1，创建TreeSet集合对象，因为String本身就具备比较功能，但是重复不会保留，所以我们用比较器
        TreeSet<String> ts = new TreeSet<>(new Comparator<String>() {
            //匿名内部类
            @Override
            public int compare(String s1, String s2) {
                int num = s1.compareTo(s2);         //比较内容为主要条件
                return num == 0 ? 1 : num;          //保留重复
            }
        });
        //2，将List集合中所有的元素添加到TreeSet集合中，对其排序，保留重复
        ts.addAll(list);
        //3，清空List集合
        list.clear();
        //4，将TreeSet集合中排好序的元素添加到list中
        list.addAll(ts);
        
    }

}

package com.heima.test;

import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

public class Test5 {

    /**
     * 从键盘接收一个字符串，程序对其中所有字符进行排序，例如键盘输入：helloitcast程序打印：acehillostt
     * 1，键盘录入字符串，Scanner
     * 2，将字符串转换为字符数组
     * 3，定义TreeSet集合，传入比较器对字符排序并保留重复
     * 4，遍历字符数组，将每一个字符存储在TreeSet集合中
     * 5，遍历TreeSet集合，打印每一个字符
     */
    public static void main(String[] args) {
        //1，键盘录入字符串，Scanner
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String line = sc.nextLine();
        //2，将字符串转换为字符数组
        char[] arr = line.toCharArray();
        //3，定义TreeSet集合，传入比较器对字符排序并保留重复
        TreeSet<Character> ts = new TreeSet<>(new Comparator<Character>() {

            @Override
            public int compare(Character c1, Character c2) {
                //int num = c1 - c2;        //自动拆箱
                int num = c1.compareTo(c2);
                return num == 0 ? 1 : num;
            }
        });
        //4，遍历字符数组，将每一个字符存储在TreeSet集合中
        for (char c : arr) {
            ts.add(c);                  //自动装箱
        }
        //5，遍历TreeSet集合，打印每一个字符
        for (Character c : ts) {
            System.out.print(c);
        }
    }

}

package com.heima.test;

import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

public class Test6 {

    /**
     * 程序启动后，可以从键盘输入接收多个整数，直到输入quit时结束输入.把所有输入的整数倒序排列打印.
     * 1,创建Scanner对象，键盘录入
     * 2,创建TreeSet集合对象，TreeSet集合中传入比较器
     * 3，无限循环不断接收整数，遇到quit退出，因为退出是quit，所以键盘录入的时候应该都以字符串的形式录入
     * 4，判断是quit就退出，不是就将其转换为Integer，并添加到集合中
     * 5，遍历TreeSet集合并打印每一个元素
     */
    public static void main(String[] args) {
        //1,创建Scanner对象，键盘录入
        Scanner sc = new Scanner(System.in);
        //2,创建TreeSet集合对象，TreeSet集合中传入比较器
        TreeSet<Integer> ts = new TreeSet<>(new Comparator<Integer>() {

            @Override
            public int compare(Integer i1, Integer i2) {
                //int num = i2 - i1;            //自动拆箱
                int num = i2.compareTo(i1);
                return num == 0 ? 1 : num;
            }
        });
        //3，无限循环不断接收整数，遇到quit退出，因为退出是quit，所以键盘录入的时候应该都以字符串的形式录入
        while(true) {
            String line = sc.nextLine();        //将键盘录入的字符串存储在line中
            //4，判断是quit就退出，不是就将其转换为Integer，并添加到集合中
            if("quit".equals(line)) {
                break;
            }
            Integer i = Integer.parseInt(line);
            ts.add(i);
        }
        //5，遍历TreeSet集合并打印每一个元素
        for (Integer integer : ts) {
            System.out.println(integer);
        }
    }

}

package com.heima.test;

import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

import com.heima.bean.Student;

public class Test7 {

    /**
     * 需求：键盘输入5个学生信息（姓名，语文成绩，数学成绩，英语成绩），按照总分从高到低输出到控制台。
     * 1，定义一个学生类
     *      成员变量：姓名，语文成绩，数学成绩，英语成绩，总成绩
     *      成员方法：空参，有参构造，有参构造的参数分别是姓名，语文成绩，数学成绩，英语成绩
     *          ToString方法，在遍历集合中的Student对象打印对象引用的时候会显示属性值
     * 2，键盘录入需要Scanner，创建键盘录入对象
     * 3，创建TreeSet集合对象，在TreeSet的构造函数中传入比较器，按照总分比较
     * 4，录入五个学生，所以以集合中的学生个数为判断条件，如果size是小于5就存储
     * 5，将录入的字符串切割，用逗号切割，会返回一个字符串数组，从第二个元素开始，将字符串数组中的元素转换成int数
     * 6，将转换后的结果封装成Student对象，将Student添加到TreeSet集合中
     * 7，遍历TreeSet集合打印每一个Student对象
     */     
    public static void main(String[] args) {
        //2，键盘录入需要Scanner，创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生成绩，格式是：姓名，语文成绩，数学成绩，英语成绩");
        //3，创建TreeSet集合对象，在TreeSet的构造函数中传入比较器，按照总分比较
        TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {

            @Override
            public int compare(Student s1, Student s2) {
                int num = s2.getSum() - s1.getSum();
                return num == 0 ? 1 : num;
            }
            
        });
        //4，录入五个学生，所以以集合中的学生个数为判断条件，如果size是小于5就存储
        while(ts.size() < 5) {
            //5，将录入的字符串切割，用逗号切割，会返回一个字符串数组，从第二个元素开始，将字符串数组中的元素转换成int数
            String line = sc.nextLine();
            String[] arr = line.split(",");
            int chinese = Integer.parseInt(arr[1]);
            int math = Integer.parseInt(arr[2]);
            int english = Integer.parseInt(arr[3]);
            //6，将转换后的结果封装成Student对象，将Student添加到TreeSet集合中
            ts.add(new Student(arr[0], chinese, math, english));
        }
        //7，遍历TreeSet集合打印每一个Student对象
        System.out.println("排序后的学生信息");
        for (Student s : ts) {
            System.out.println(s);
        }
    }

}

Map集合概述和特点

A:Map接口概述
- 查看API可以知道：
  - 将键映射到值的对象
  - 一个映射不能包含重复的键
  - 每个键最多只能映射到一个值
B:Map接口和Collection接口的不同
- Map是双列的,Collection是单列的
- Map的键唯一,Collection的子体系Set是唯一的
- Map集合的数据结构值针对键有效，跟值无关;Collection集合的数据结构是针对元素有效

set底层依赖于map

底层结构.jpg

Map集合的功能概述

A:Map集合的功能概述
- a:添加功能
  - V put(K key,V value):添加元素。
    - 如果键是第一次存储，就直接存储元素，返回null
    - 如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
- b:删除功能
  - void clear():移除所有的键值对元素
  - V remove(Object key)：根据键删除键值对元素，并把值返回
- c:判断功能
  - boolean containsKey(Object key)：判断集合是否包含指定的键
  - boolean containsValue(Object value):判断集合是否包含指定的值
  - boolean isEmpty()：判断集合是否为空
- d:获取功能
  - Set<Map.Entry<K,V>> entrySet():
  - V get(Object key):根据键获取值
  - Set<K> keySet():获取集合中所有键的集合
  - Collection<V> values():获取集合中所有值的集合
- e:长度功能
  - int size()：返回集合中的键值对的个数

package com.heima.map;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

public class Demo1_Map {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("张三",23);
        map.put("李四",24);
        map.put("王五",25);
        map.put("赵六", 23);
        
        Collection<Integer> c = map.values();
        System.out.println(c);
        System.out.println(map.size());
    }

    public static void demo2() {
        Map<String, Integer> map = new HashMap<>();
        map.put("张三",23);
        map.put("李四",24);
        map.put("王五",25);
        map.put("赵六", 23);
        Integer value = map.remove("张三");   //根据键删除元素，返回键对应的值
        System.out.println(value);
        System.out.println(map.containsKey("张三"));  //判断是否包含传入的键
        System.out.println(map.containsValue(100)); //判断是否包含传入的值
        System.out.println(map);
    }

    public static void demo1() {
        Map<String, Integer> map = new HashMap<>();
        Integer i1 = map.put("张三", 23);
        Integer i2 = map.put("李四", 24);
        Integer i3 = map.put("王五", 25);
        Integer i4 = map.put("赵六", 26);
        Integer i5 = map.put("张三", 26);     //put方法返回的是被覆盖的值
        
        System.out.println(map);
        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println(i4);
        System.out.println(i5);
    }

}

Map集合的遍历之键找值

A:键找值思路：
- 获取所有键的集合
- 遍历键的集合，获取到每一个键
- 根据键找值

package com.heima.map;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Demo2_Iterator {

    /**
     * 通过查看Map集合的api发现没有iterator方法，那么双列集合如何迭代呢？
     */
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("张三",23);
        map.put("李四",24);
        map.put("王五",25);
        map.put("赵六", 26);
        
        Integer i = map.get("111"); //根据键获取值,若没有返回null
        System.out.println(i);
        //获取所有的键
        /*Set<String> keySet = map.keySet();    //获取所有键的集合
        Iterator<String> it = keySet.iterator();    //获取迭代器
        while(it.hasNext()) {                       //判断集合中是否有元素
            String key = it.next();                 //获取每一个键
            Integer value = map.get(key);           //根据键获取值
            System.out.println(key + "=" + value);
        }*/
        
        //使用增强for循环遍历
        for (String key : map.keySet()) {           //map.keySet()是所有键的集合
            System.out.println(key + "=" + map.get(key));
        }
    }

}

Map集合的遍历之键值对对象找键和值

A:键值对对象找键和值思路：
- 获取所有键值对对象的集合（把双列集合的键值对变成单列集合的键值对对象）
- 遍历键值对对象的集合，获取到每一个键值对对象
- 根据键值对对象找键和值

package com.heima.map;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Demo3_Iterator {

    /**
     * Entry实现了Map.Entry
     */
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("张三",23);
        map.put("李四",24);
        map.put("王五",25);
        map.put("赵六", 26);
        //Map.Entry说明Entry是Map的内部接口，将键和值封装成Entry对象，并存储在Set集合中
        /*Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        //获取每一个对象
        Iterator<Map.Entry<String, Integer>> it = entrySet.iterator();
        while(it.hasNext()) {
            //获取每一个Entry对象
            Map.Entry<String, Integer> en = it.next();  //父类引用指向子类对象
            //Entry<String, Integer> en = it.next();        //直接获取子类对象
            String key = en.getKey();                   //根据键值对对象获取键
            Integer value = en.getValue();              //根据键值对对象获取值
            System.out.println(key + "=" + value);
        }*/
        for (Map.Entry<String, Integer> en : map.entrySet()) {  
            System.out.println(en.getKey() + "=" + en.getValue());
        }
        
    }

}

package com.heima.map;

import java.util.HashMap;

import com.heima.bean.Student;

public class Demo5_HashMap {

    /**
     * HashMap集合键是Student值是String的案例
     */
    public static void main(String[] args) {
        HashMap<Student, String> hm = new HashMap<>();
        hm.put(new Student("张三", 23), "北京");
        hm.put(new Student("张三", 23), "上海");
        hm.put(new Student("李四", 23), "广州");
        hm.put(new Student("王五", 23), "深圳");
        
        System.out.println(hm);
    }

}

LinkedHashMap的概述和使用

package com.heima.map;

import java.util.LinkedHashMap;

public class Demo6_LinkedHashMap {

    /**
     * 底层是链表实现的可以保证怎么存就怎么取
     */
    public static void main(String[] args) {
        LinkedHashMap<String, Integer> lhm = new LinkedHashMap<>();
        lhm.put("张三", 23);
        lhm.put("李四", 24);
        lhm.put("赵六", 25);
        lhm.put("王五", 26);
        System.out.println(lhm);
    }

}

TreeMap集合键是Student值是String的案例

package com.heima.map;

import java.util.Comparator;
import java.util.TreeMap;

import com.heima.bean.Student;

public class Demo7_TreeMap {

    /**
     * @param args
     */
    public static void main(String[] args) {
        TreeMap<Student, String> tm = new TreeMap<>(new Comparator<Student>() {

            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getName().compareTo(s2.getName()); //按照姓名比较
                return num == 0 ? s1.getAge() - s2.getAge() : num;
            }
        });
        tm.put(new Student("李四", 13), "上海");
        tm.put(new Student("张三", 23), "北京");    //TreeMap需要对键有比较的方法
        tm.put(new Student("王五", 33), "广州");    //或者传入比较器
        tm.put(new Student("赵六", 43), "深圳");
        System.out.println(tm);
    }

    public static void demo1() {
        TreeMap<Student, String> tm = new TreeMap<>();
        tm.put(new Student("张三", 23), "北京");    //TreeMap需要对键有比较的方法
        tm.put(new Student("李四", 13), "上海");    //需要重写对象的compareTo方法
        tm.put(new Student("王五", 33), "广州");
        tm.put(new Student("赵六", 43), "深圳");
        System.out.println(tm);
    }

}

统计字符串中每个字符出现的次数

package com.heima.test;

import java.util.HashMap;

public class Test1 {

    /**
     * 需求：统计字符串中每个字符出现的次数
     * 1，定义一个需要被统计字符的字符串
     * 2，将字符串转换为字符数组
     * 3，定义双列集合，存储字符串中字符以及字符出现的次数
     * 4，遍历字符数组获取每一个字符，并将字符存储在双列集合中
     * 5，存储过程中要做判断，如果集合中不包含这个键，就将该字符当作键，值为1存储，否则就将值加一
     * 6，打印双列集合获取字符出现的次数
     */
    public static void main(String[] args) {
        //1，定义一个需要被统计字符的字符串
        String s = "aaaabbbbbccccccccccccc";
        //2，将字符串转换为字符数组
        char[] arr = s.toCharArray();
        //3，定义双列集合，存储字符串中字符以及字符出现的次数
        HashMap<Character, Integer> hm = new HashMap<>();
        //4，遍历字符数组获取每一个字符，并将字符存储在双列集合中
        for(char c: arr) {
            //5，存储过程中要做判断，如果集合中不包含这个键，就将该字符当作键，值为1存储，否则就将值加一
            /*if(!hm.containsKey(c)) {  //如果不包含这个键
                hm.put(c, 1);
            }else {
                hm.put(c, hm.get(c) + 1);
            }*/
            hm.put(c, !hm.containsKey(c) ? 1 : hm.get(c) + 1);
        }
        //6，打印双列集合获取字符出现的次数
        //System.out.println(hm);
        for (Character key : hm.keySet()) {         //hm.keySet()代表所有键的集合
            System.out.println(key + "=" + hm.get(key));    //hm.get(key)根据键获取值
        }
    }

}

集合嵌套之HashMap嵌套HashMap

package com.heima.map;

import java.util.HashMap;

import com.heima.bean.Student;

public class Demo8_HashMapHashMap {

    /**
     * 需求：
     * 双元课堂有很多基础班
     * 第88期基础班定义成一个双列集合，键是学生对象。值是学生的归属地
     * 第99期基础班定义成一个双列集合，键是学生对象。值是学生的归属地
     * 无论88期还是99期都是班级对象，所以为了便于统一管理，把这些班级对象添加到双元课堂集合中
     */
    public static void main(String[] args) {
        //定义88期基础班
        HashMap<Student, String> hm88 = new HashMap<>();
        hm88.put(new Student("张三", 23), "北京");
        hm88.put(new Student("李四", 24), "北京");
        hm88.put(new Student("王五", 25), "上海");
        hm88.put(new Student("赵六", 26), "广州");
        
        //定义99期基础班
        HashMap<Student, String> hm99 = new HashMap<>();
        hm99.put(new Student("唐僧", 23), "北京");
        hm99.put(new Student("孙悟空", 24), "北京");
        hm99.put(new Student("猪八戒", 25), "上海");
        hm99.put(new Student("沙和尚", 26), "广州");
        
        //定义双元课堂
        HashMap<HashMap<Student, String>, String> hm = new HashMap<>();
        hm.put(hm88, "第88期基础班");
        hm.put(hm99, "第99期基础班");
        
        //遍历双列集合
        for (HashMap<Student, String> h : hm.keySet()) {    //hm.keySet()代表的是双列集合中键的集合
            String value = hm.get(h);                       //get(h)根据键对象获取值对象
            //遍历键的双列集合对象    
            for (Student student : h.keySet()) {            //h.keySet()获取集合中所有的键（学生）对象
                String value2 = h.get(student);
                
                System.out.println(student + "=" + value2 + "=" + value);
            }
        }
    }

}

HashMap和Hashtable的区别

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

package com.heima.map;

import java.util.HashMap;
import java.util.Hashtable;

public class Demo9_Hashtable {

    /**
     * 面试题
     * HashMap和Hashtable的区别
     * 共同点：
     * 底层都是哈希算法，都是双列集合
     */
    public static void main(String[] args) {
        /*HashMap<String, Integer> hm = new HashMap<>();
        hm.put(null, null); 
        hm.put("张三", null);
        hm.put(null,23);
        System.out.println(hm);*/
        
        Hashtable<String, Integer> ht = new Hashtable<>();
        ht.put("张三", 23);
        //ht.put(null, 24); //NullPointerException
        ht.put("李四", null);//NullPointerException
        System.out.println(ht);
    }

}

Collections工具类的概述和常见方法讲解

package com.heima.collections;

import java.util.ArrayList;
import java.util.Collections;

public class Demo1_Collections {

    /**
     *  public static <T> void sort(List<T> list)
        public static <T> int binarySearch(List<?> list,T key)
        public static <T> T max(Collection<?> coll)
        public static void reverse(List<?> list)
        public static void shuffle(List<?> list)
     */
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("c");
        list.add("a");
        list.add("d");
        list.add("g");
        list.add("f");
        System.out.println(Collections.max(list));  //根据默认排序结果获取集合中的最大值
        Collections.reverse(list);                  //反转集合
        System.out.println(list);
        Collections.shuffle(list);                  //随机置换，可以用来洗牌
        System.out.println(list);   
    }

    public static void demo2() {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("c");
        list.add("d");
        list.add("f");
        list.add("g");
        
        System.out.println(Collections.binarySearch(list,"c"));
        System.out.println(Collections.binarySearch(list,"b")); //负的插入点减一
    }

    public static void demo1() {
        ArrayList<String> list = new ArrayList<>();
        list.add("c");
        list.add("a");
        list.add("a");
        list.add("b");
        list.add("d");
        
        System.out.println(list);   //[c, a, a, b, d]
        Collections.sort(list);     //将集合排序
        System.out.println(list);   //[a, a, b, c, d]
    }

}

模拟斗地主洗牌和发牌

package com.heima.test;

import java.util.ArrayList;
import java.util.Collections;

public class Test2 {
    public static void main(String[] args) {
        //1,买一副扑克，其实就是自己创建一个集合对象，将扑克牌存储进去
        String[] num = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        String[] color = {"红桃","黑桃","方片","梅花"};
        ArrayList<String> poker = new ArrayList<>();
        
        //拼接花色和数字
        for (String s1 : color) {
            for (String s2 : num) {
                poker.add(s1.concat(s2));   //concat连接两个字符串
            }
        }
        poker.add("小王");
        poker.add("大王");
        //System.out.println(poker);
        //2,洗牌
        Collections.shuffle(poker);
        //System.out.println(poker);
        //3,发牌
        ArrayList<String> gaojin = new ArrayList<>();
        ArrayList<String> longwu = new ArrayList<>();
        ArrayList<String> me = new ArrayList<>();
        ArrayList<String> dipai = new ArrayList<>();
        
        for (int i = 0; i < poker.size(); i++) {
            if(i >= poker.size() - 3) {
                dipai.add(poker.get(i));
            } else if(i % 3 == 0) {
                gaojin.add(poker.get(i));
            } else if(i % 3 == 2) {
                longwu.add(poker.get(i));
            } else {
                me.add(poker.get(i));
            }
        }
        //4，看牌
        System.out.println(me);
        System.out.println(gaojin);
        System.out.println(longwu);
        System.out.println(dipai);
    }

}

模拟斗地主洗牌和发牌并对牌进行排序

斗地主.png

package com.heima.test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;

public class Test3 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //1,买一副扑克，其实就是自己创建一个集合对象，将扑克牌存储进去
        String[] num = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        String[] color = {"红桃","黑桃","方片","梅花"};
        HashMap<Integer, String> hm = new HashMap<>();
        ArrayList<Integer> list = new ArrayList<>();
        int index = 0;
        //拼接扑克牌并将他们存在hm中
        for (String s1 : num) {
            for (String s2 : color) {
                hm.put(index, s2.concat(s1));
                list.add(index);
                index++;
            }
        }
        //将大小王添加到双列集合中
        hm.put(index, "小王");
        list.add(index);
        index++;
        hm.put(index, "大王");
        list.add(index);
        //System.out.println(hm);
        //System.out.println(list);
        //2,洗牌
        Collections.shuffle(list);
        //3,发牌
        TreeSet<Integer> gaojin = new TreeSet<>();
        TreeSet<Integer> longwu = new TreeSet<>();
        TreeSet<Integer> me = new TreeSet<>();
        TreeSet<Integer> dipai = new TreeSet<>();
        
        for (int i = 0; i < list.size(); i++) {
            if(i >= list.size() - 3) {
                dipai.add(list.get(i));         //将三张底牌存储在底牌集合中
            }else if(i % 3 == 0) {
                gaojin.add(list.get(i));
            }else if(i % 3 == 1) {
                longwu.add(list.get(i));
            }else {
                me.add(list.get(i));
            }
        }
        //看牌
        lookPoker(hm,gaojin,"高进");
        lookPoker(hm,gaojin,"龙五");
        lookPoker(hm,me,"aaa");
        lookPoker(hm,dipai,"底牌");
    }
    
    public static void lookPoker(HashMap<Integer, String> hm,TreeSet<Integer> ts
            ,String name) {
        System.out.print(name + "的牌是");
        for (Integer i : ts) {                  //i代表双列集合中的每一个键
            System.out.print(hm.get(i) + " ");
        }
        System.out.println();
    }
}

泛型固定下边界

package com.heima.collections;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.TreeSet;

import com.heima.bean.BaseStudent;
import com.heima.bean.Student;

public class Demo2_Genric {

    /**
     * 泛型固定下边界
     * ？ super E
     * 泛型固定上边界
     * ? extends E
     * 都是父类引用指向子类对象
     */
    public static void main(String[] args) {
        TreeSet<Student> ts1 = new TreeSet<>(new CompareByAge());
        ts1.add(new Student("张三",33));
        ts1.add(new Student("李四",13));
        ts1.add(new Student("王五",23));
        ts1.add(new Student("赵六",43));
        
        TreeSet<BaseStudent> ts2 = new TreeSet<>(new CompareByAge());
        ts2.add(new BaseStudent("张三",33));
        ts2.add(new BaseStudent("李四",13));
        ts2.add(new BaseStudent("王五",23));
        ts2.add(new BaseStudent("赵六",43));
        System.out.println(ts2);    //？ super E     将子类对象放进比较器作比较
    }

    public static void demo1() {
        ArrayList<Student> list1 = new ArrayList<>();
        list1.add(new Student("张三", 23));
        list1.add(new Student("李四", 24));
        
        ArrayList<BaseStudent> list2 = new ArrayList<>();
        list2.add(new BaseStudent("张三", 23));
        list2.add(new BaseStudent("李四", 24));
        
        list1.addAll(list2);    //? extends E    将子类对象储存在父类数组中
    }

}

class CompareByAge implements Comparator<Student> {

    @Override
    public int compare(Student s1, Student s2) {
        int num = s1.getAge() - s2.getAge();
        return num == 0 ? s1.getName().compareTo(s2.getName()) : num;
    }
    
}

总结

package com.heima.collections;

public class Demo3_Collection {

    /**
     * Collection
     *      List(存取有序,有索引,可以重复)
     *          ArrayList
     *              底层是数组实现的,线程不安全,查找和修改快,增和删比较慢
     *          LinkedList
     *              底层是链表实现的,线程不安全,增和删比较快,查找和修改比较慢
     *          Vector
     *              底层是数组实现的,线程安全的,无论增删改查都慢
     *          如果查找和修改多,用ArrayList
     *          如果增和删多,用LinkedList
     *          如果都多,用ArrayList
     *      Set(存取无序,无索引,不可以重复)
     *          HashSet
     *              底层是哈希算法实现
     *              LinkedHashSet
     *                  底层是链表实现,但是也是可以保证元素唯一,和HashSet原理一样
     *          TreeSet
     *              底层是二叉树算法实现
     *          一般在开发的时候不需要对存储的元素排序,所以在开发的时候大多用HashSet,HashSet的效率比较高
     *          TreeSet在面试的时候比较多,问你有几种排序方式,和几种排序方式的区别
     * Map
     *      HashMap
     *          底层是哈希算法,针对键
     *          LinkedHashMap
     *              底层是链表,针对键
     *      TreeMap
     *          底层是二叉树算法,针对键
     *      开发中用HashMap比较多
     */
    public static void main(String[] args) {

    }

}

异常的概述和分类

A:异常的概述
- 异常就是Java程序在运行过程中出现的错误。
B:异常的分类
- 通过API查看Throwable
- Error
  - 服务器宕机,数据库崩溃等
- Exception
C:异常的继承体系
- Throwable
  - Error
  - Exception
    - RuntimeException

JVM默认是如何处理异常的

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

package com.heima.exception;

public class Demo1_Exception {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Demo d = new Demo();
        int x = d.div(10, 0);
        System.out.println(x);
    }

}

class Demo {
    public int div(int a, int b) {  //10 / 0被除数是10，除数是0当除数是0的时候违背算术运算法则，抛出异常
        return a / b;               //new ArithmeticException("/ by zero");返回这样一个对象
    }
}

try...catch的方式处理异常1

A:异常处理的两种方式
- a:try…catch…finally
  - try catch
  - try catch finally
  - try finally
- b:throws
B:try...catch处理异常的基本格式
- try…catch…finally

package com.heima.exception;

public class Demo2_Exception {

    /**
     * try:用来检测异常的
     * catch:用来捕获异常
     * finally:释放资源
     * 当通过trycatch将问题处理了，程序会继续执行
     */
    public static void main(String[] args) {
        Demo2 d = new Demo2();
        try {
            int x = d.div(10, 0);
            System.out.println(x);
        }catch(ArithmeticException a) {         //ArithmeticException a = new ArithmeticException();
            System.out.println("出错了，除数为零了");
        }
        System.out.println("继续执行");
    }

}

class Demo2 {                       //不能在同一个包下有两个相同名字的类
    public int div(int a, int b) {  //10 / 0被除数是10，除数是0当除数是0的时候违背算术运算法则，抛出异常
        return a / b;               //new ArithmeticException("/ by zero");返回这样一个对象
    }
}

try...catch的方式处理异常2

A:案例演示
- try...catch的方式处理多个异常
- JDK7以后处理多个异常的方式及注意事项

package com.heima.exception;

public class Demo3_Exception {
//安卓，服务端开发，如何处理异常？try{}catch(Exception e){}
//ee,服务端开发，一般都是底层开发，从底层向上抛
//try后面如果跟多个catch，那么小的异常放前面，大的异常放后面，根据多态的原理，如果大的放前面，
//就会将所有的子类对象接收，后面的catch就没有意义了
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        int[] arr = {11,22,33,44,55};
        //JDK如何处理多个异常
        try {
            System.out.println(a / b);
            System.out.println(arr[10]);
        } catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
            System.out.println("出错了");
        }
    }

    public static void demo1() {
        int a = 10;
        int b = 0;
        int[] arr = {11,22,33,44,55};
        
        try {
            //System.out.println(a / b);
            //System.out.println(arr[10]);
            arr = null;
            System.out.println(arr[0]);
        } catch (ArithmeticException e) {
            System.out.println("除数不能为零");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("索引越界了");
        } catch (Exception e) {             //Exception e = new NullPointerExcption();
            System.out.println("出错了");      //父类引用指向子类对象
        }
        
        System.out.println("over");
    }

}

编译期异常和运行期异常的区别

A:编译期异常和运行期异常的区别
- Java中的异常被分为两大类：编译时异常和运行时异常。
- 所有的RuntimeException类及其子类的实例被称为运行时异常，其他的异常就是编译时异常
- 编译时异常
  - Java程序必须显示处理，否则程序就会发生错误，无法通过编译
- 运行时异常
  - 无需显示处理，也可以和编译时异常一样处理

package com.heima.exception;

import java.io.FileInputStream;

public class Demo4_Exception {

    /**
     * 编译时异常有点未雨绸缪的味道（不规范的说法）
     * 编译时异常：在编译某个程序的时候，有可能会有一些事情发生，比如文件找不到，这样的异常就必须在编译的时候
     * 处理，如果不处理编译通不过    //自己的理解：就是语法不合符规范
     * 运行时异常：就是程序员所犯得错误，需要回来修改代码    //自己的理解：就是语法符合规范，但是程序逻辑错误
     * 这里的逻辑指的是空指针、除以0等
     */
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("xxx.txt");
        } catch(Exception e) {
            System.out.println(1);
        }
    }

}

Throwable的几个常见方法

A:Throwable的几个常见方法
- a:getMessage()
  - 获取异常信息，返回字符串。
- b:toString()
  - 获取异常类名和异常信息，返回字符串。
- c:printStackTrace()
  - 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

package com.heima.exception;

public class Demo5_Throwable {

    /**
     * @param args
     */
    public static void main(String[] args) {
        try {
            System.out.println(1/0);
        } catch (Exception e) {     //Exception e = new ArithmeticException("/by zero")
            System.out.println(e.getMessage());     //获取异常信息
            System.out.println(e);  //调用toString方法，打印异常类名和异常信息
            e.printStackTrace();    //JVM默认用这种方式处理异常
        }
    }

}

throws的方式处理异常

A:throws的方式处理异常
- 定义功能方法时，需要把出现的问题暴露出来让调用者去处理。
- 那么就通过throws在方法上标识。

package com.heima.exception;

public class Demo6_Exception {

    /**
     * 编译时异常的抛出必须对其进行处理
     * 运行时异常的抛出可以处理也可以不处理
     */
    public static void main(String[] args) throws Exception {
        Person p = new Person();
        p.setAge(-17);
        System.out.println(p.getAge());
    }

}

class Person {
    private String name;
    private int age;
    public Person() {
        super();
        
    }
    public Person(String name, int age) {
        super();
        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) throws Exception {
        if(age > 0 && age <= 150) {
            this.age = age;
        }else {
            throw new Exception("年龄非法");//这里是匿名对象，也可以抛出有名字的对象。
        }   
    }
    
}

throw的概述以及和throws的区别

A:throw的概述
- 在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。
C:throws和throw的区别
- a:throws
  - 用在方法声明后面，跟的是异常类名
  - 可以跟多个异常类名，用逗号隔开
  - 表示抛出异常，由该方法的调用者来处理
- b:throw
  - 用在方法体内，跟的是异常对象名
  - 只能抛出一个异常对象名
  - 表示抛出异常，由方法体内的语句处理

finally关键字的特点及作用

A:finally的特点
* 被finally控制的语句体一定会执行
* 特殊情况：在执行到finally之前jvm退出了(比如System.exit(0))

B:finally的作用
- 用于释放资源，在IO流操作和数据库操作中会见到

package com.heima.exception;

public class Demo7_Finally {

    /**
     * @param args
     */
    public static void main(String[] args) {
        try {
            System.out.println(10/0);
        } catch (Exception e){
            System.out.println("除数为零了");
            System.exit(0);     //退出java虚拟机
            return;     //会先执行finally
        } finally {
            System.out.println("看看我执行了吗");  //即使有return语句也会先执行finally
        }
    }

}

finally关键字的面试题

package com.heima.test;

public class Test1 {

    /**
    * * A:面试题1
        * final,finally和finalize的区别
        * final可以修饰类，不能被继承
        * 修饰方法，不能被重写
        * 修饰变量，只能赋值一次
        * 
        * finally是try语句中的一个语句体，不能单独使用，用来释放资源
        * 
        * finalize是一个方法，当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
    * * B:面试题2
        * 如果catch里面有return语句，请问finally的代码还会执行吗?如果会，请问是在return前还是return后。
        * 无论try里执行了return语句、break语句、还是continue语句，finally语句块还会继续执行
        * 如果try语句里有return，那么代码的行为如下：
            1.如果有返回值，就把返回值保存到局部变量中
            2.执行jsr指令跳到finally语句里执行
            3.执行完finally语句后，返回之前保存在局部变量表里的值
     */
    public static void main(String[] args) {
        Demo d = new Demo();
        System.out.println(d.method());
    }

}

class Demo {
    public int method() {
        int x = 10;
        try {
            x = 20;
            System.out.println(1/0);
            return x;
        } catch (Exception e) {
            x =30;
            return x;
        } finally {
            x = 40;     //如果finally有return，会覆盖之前的return方法，不要在里面写return语句
        }
    }
}

自定义异常概述和基本使用

B:自定义异常概述
* 继承自Exception
* 继承自RuntimeException

package com.heima.exception;

public class Demo8_Exception {

    /**
     * 自定义异常原因：通过名字区分到底是什么异常，有针对的解决办法
     */
    public static void main(String[] args) {

    }

}

class AgeOutOfBoundsException extends Exception {

    public AgeOutOfBoundsException() {
        super();
        
    }

    public AgeOutOfBoundsException(String message) {
        super(message);
        
    }
    
}

异常的注意事项及如何使用异常处理

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

练习

package com.heima.test;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Scanner;

public class Test2 {

    /**
     * 键盘录入一个int类型的整数,对其求二进制表现形式
     * 如果录入的整数过大,给予提示,录入的整数过大请重新录入一个整数BigInteger
     * 如果录入的是小数,给予提示,录入的是小数,请重新录入一个整数
     * 如果录入的是其他字符,给予提示,录入的是非法字符,请重新录入一个整数
     * 
     * 分析：
     * 1，创建键盘录入对象
     * 2，将键盘录入的结果存储在String类型的字符串中，存储int类型中如果有不符合条件的直接报错，无法进行后续判断
     * 3，键盘录入的结果转换成int类型的数据，是正确的还是错误的
     * 4，正确的直接转换
     * 5，错误的要进行对应判断
     * Alt+shitf+z  (try catch代码块快捷键)
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");
            
        while(true) {
            String line = sc.nextLine();            //将键盘录入的结果存储在line中
            try {
                int num = Integer.parseInt(line);           //将字符串转换为整数
                System.out.println(Integer.toBinaryString(num));//将整数转换为二进制
                break;                                      //跳出循环
            }catch(Exception e) {
                try {
                    new BigInteger(line);
                    System.out.println("录入错误，您录入的是一个过大整数，请重新输入一个整数");
                } catch (Exception e1) {
                    try {
                        new BigDecimal(line);
                        System.out.println("录入错误，您录入的是一个小数，请重新输入一个整数");
                    } catch (Exception e2) {
                        System.out.println("录入错误，您录入的是非法字符，请重新输入一个整数");
                    }
                }
            }
        }
    }

}

File类的概述和构造方法

A:File类的概述
- File更应该叫做一个路径
  - 文件路径或者文件夹路径
  - 路径分为绝对路径和相对路径
  - 绝对路径是一个固定的路径,从盘符开始
  - 相对路径相对于某个位置,在eclipse下是指当前项目下,在dos下
- 查看API指的是当前路径
- 文件和目录路径名的抽象表示形式
B:构造方法
- File(String pathname)：根据一个路径得到File对象
- File(String parent, String child):根据一个目录和一个子文件/目录得到File对象
- File(File parent, String child):根据一个父File对象和一个子文件/目录得到File对象

package com.heima.file;

import java.io.File;

public class Demo1_File {

    public static void main(String[] args) {
        File parent =  new File("D:\\BaiduNetdiskDownload\\01-JavaSE知识(学习27天)\\day01(计算机基础知识&jdk安装&标识符)");
        String child = "01.01_计算机基础知识(计算机概述)_rec.avi";
        File file = new File(parent, child);
        System.out.println(file.exists());
        System.out.println(parent.exists());
    }

    public static void demo2() {
        String parent =  "D:\\BaiduNetdiskDownload\\01-JavaSE知识(学习27天)\\day01(计算机基础知识&jdk安装&标识符)";
        String child = "01.01_计算机基础知识(计算机概述)_rec.avi";
        File file = new File(parent, child);
        System.out.println(file.exists());
    }

    public static void demo1() {
        File file = new File("D:\\BaiduNetdiskDownload\\01-JavaSE知识(学习27天)" +
                "\\day01(计算机基础知识&jdk安装&标识符)\\01.01_计算机基础知识(计算机概述)_rec.avi");
        System.out.println(file.exists());
        
        File file2 = new File("xxx.txt");
        System.out.println(file2.exists());
        
        File file3 = new File("yyy.txt");
        System.out.println(file3.exists());
    }

}

File类的创建功能

A:创建功能
- public boolean createNewFile():创建文件如果存在这样的文件，就不创建了
- public boolean mkdir():创建文件夹如果存在这样的文件夹，就不创建了
- public boolean mkdirs():创建文件夹,如果父文件夹不存在，会帮你创建出来
- 注意事项：
  - 如果你创建文件或者文件夹忘了写盘符路径，那么，默认在项目路径下

package com.heima.file;

import java.io.File;
import java.io.IOException;

public class Demo2_FileMethod {

    /**
     * @param args
     *  
     */
    public static void main(String[] args) throws IOException {
        File dir1 = new File("aaa");
        System.out.println(dir1.mkdir());
        
        File dir2 = new File("bbb.txt");        //这样写是可以的，文件夹可以有后缀名
        System.out.println(dir2.mkdir());
        
        File dir3 = new File("ccc\\ddd");
        System.out.println(dir3.mkdirs());      //创建多级目录
    }

    public static void demo1() throws IOException {
        File file = new File("yyy.txt");
        System.out.println(file.createNewFile());   //如果没有就创建，返回true，否则就不创建，返回false
        
        File file2 = new File("zzz");   //没有格式的也可以创建
        System.out.println(file2.createNewFile());
    }

}

File类的重命名和删除功能

A:重命名和删除功能
- public boolean renameTo(File dest):把文件重命名为指定的文件路径
- public boolean delete():删除文件或者文件夹
B:重命名注意事项
- 如果路径名相同，就是改名。
- 如果路径名不同，就是改名并剪切。
C:删除注意事项：
- Java中的删除不走回收站。
- 要删除一个文件夹，请注意该文件夹内不能包含文件或者文件夹

package com.heima.file;

import java.io.File;

public class Demo3_FileMethod {

    /**
     * @param args
     */
    public static void main(String[] args) {
        File file1 = new File("yyy.txt");
        System.out.println(file1.delete());
        
        File file2 = new File("aaa");
        System.out.println(file2.delete());
        
        File file3 = new File("ccc");           //如果删除一个文件夹，那么这个文件夹必须是空的
        System.out.println(file3.delete());
    }

    public static void demo1() {
        File file1 = new File("ooo.txt");
        File file2 = new File("D:\\xxx.txt");
        System.out.println(file1.renameTo(file2));
    }

}

File类的判断功能

A:判断功能
- public boolean isDirectory():判断是否是目录
- public boolean isFile():判断是否是文件
- public boolean exists():判断是否存在
- public boolean canRead():判断是否可读
- public boolean canWrite():判断是否可写
- public boolean isHidden():判断是否隐藏

package com.heima.file;

import java.io.File;

public class Demo4_FileMethod {

    public static void main(String[] args) {
        File file = new File("zzz");
        file.setReadable(false);                
        System.out.println(file.canRead());     //windows系统认为所有的文件都是可读的，一定会返回true
        file.setWritable(false);
        System.out.println(file.canWrite());    //windows系统可以设置为不可写
    }

    public static void demo1() {
        File dir1 = new File("ccc");
        System.out.println(dir1.isDirectory());     //判断是否是文件夹
        
        File dir2 = new File("zzz");
        System.out.println(dir2.isDirectory());
        
        System.out.println(dir1.isFile());          //判断是否是文件
        System.out.println(dir2.isFile());
    }

}

File类的获取功能

A:获取功能
- public String getAbsolutePath()：获取绝对路径
- public String getPath():获取路径
- public String getName():获取名称
- public long length():获取长度。字节数
- public long lastModified():获取最后一次的修改时间，毫秒值
- public String[] list():获取指定目录下的所有文件或者文件夹的名称数组
- public File[] listFiles():获取指定目录下的所有文件或者文件夹的File数组

package com.heima.file;

import java.io.File;
import java.util.Date;

public class Demo5_FileMethod {

    public static void main(String[] args) {
        File dir = new File("D:/BaiduNetdiskDownload/01-JavaSE知识(学习27天)");
        String[] arr = dir.list();      //仅为了获取文件名
        for (String string : arr) {
            System.out.println(string);
        }
        
        File[] subFiles = dir.listFiles();  //获取文件对象
        
        for (File file : subFiles) {
            System.out.println(file);
        }
    }

    public static void demo1() {
        File file1 = new File("xxx.txt");
        File file2 = new File("D:\\双元课堂\\day19\\xxx.txt");
        System.out.println(file1.getAbsolutePath());    //获取绝对路径
        System.out.println(file2.getAbsolutePath());
        System.out.println(file1.getPath());            //获取构造方法中传入的路径
        System.out.println(file2.getPath());
        System.out.println(file1.getName());            //获取文件或文件夹的名字
        System.out.println(file2.getName());
        System.out.println(file1.length());
        System.out.println(file1.lastModified());       //文件的最后修改时间
        Date d = new Date(file1.lastModified());
        System.out.println(d);
    }

}

输出指定目录下指定后缀的文件名

package com.heima.test;

import java.io.File;

public class Test3 {

    /**
     ** 需求：判断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称
     */
    public static void main(String[] args) {
        File dir = new File("C:/Users/yang/Desktop");
        String[] arr = dir.list();              //获取e盘下所有的文件或文件夹
        for (String string : arr) {
            if(string.endsWith(".jpg")) {
                System.out.println(string);
            }
        }
        File[] subFiles = dir.listFiles();      //获取e盘下所有的文件或文件夹对象
        for (File file : subFiles) {
            if(file.isFile() && file.getName().endsWith(".jpg")) {
                System.out.println(file);
            }
        }
        
    }

}

文件名称过滤器的概述及使用

A:文件名称过滤器的概述
- public String[] list(FilenameFilter filter)
- public File[] listFiles(FileFilter filter)
B:文件名称过滤器的使用
- 需求：判断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称
C:源码分析
- 带文件名称过滤器的list()方法的源码

package com.heima.test;

import java.io.File;
import java.io.FilenameFilter;

public class Test3 {

    /**
     ** 需求：判断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称
     */
    public static void main(String[] args) {
        File dir = new File("C:/Users/yang/Desktop");
            
        String[] arr1 = dir.list(new FilenameFilter(){

            @Override
            public boolean accept(File dir, String name) {
                //System.out.println(dir);
                //System.out.println(name);
                File file = new File(dir, name);
                return file.isFile() && file.getName().endsWith(".jpg");
            }
        });
        
        for (String string : arr1) {
            System.out.println(string);
        }
    }

}

IO流概述及其分类

1.概念
- IO流用来处理设备之间的数据传输
- Java对数据的操作是通过流的方式
- Java用于操作流的类都在IO包中
- 流按流向分为两种：输入流，输出流。
- 流按操作类型分为两种：
  - 字节流 : 字节流可以操作任何数据,因为在计算机中任何数据都是以字节的形式存储的
  - 字符流 : 字符流只能操作纯字符数据，比较方便。
2.IO流常用父类
- 字节流的抽象父类：
  - InputStream
  - OutputStream
- 字符流的抽象父类：
  - Reader
  - Writer
3.IO程序书写
- 使用前，导入IO包中的类
- 使用时，进行IO异常处理
- 使用后，释放资源

FileInputStream

read()一次读取一个字节

package com.heima.stream;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Demo1_FileInputStream {

    /*
     */
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("xxx.txt");//创建一个文件输入流对象,并关联aaa.txt
        int b;
        while((b = fis.read()) != -1) {     //当文件读完输出为-1，所以设置-1为结束标志
            System.out.println(b);
        }
        
        fis.close();
    }

    public static void demo1() throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream("xxx.txt");   //创建流对象
        int x = fis.read();         //从硬盘上读取一个字节
        System.out.println(x);
        int y = fis.read();         //从硬盘上读取一个字节
        System.out.println(y);
        int z = fis.read();         //从硬盘上读取一个字节
        System.out.println(z);
        int a = fis.read();         //从硬盘上读取一个字节
        System.out.println(a);
        int b = fis.read();         //从硬盘上读取一个字节
        System.out.println(b);
        
        fis.close();                //关流释放资源
    }

}

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

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

FileOutputStream以及FileOutputStream的追加

write()一次写出一个字节

package com.heima.stream;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo2_FileOutputStream {

    /**
     * FileOutputStream在创建对象的时候是如果没有这个文件会帮我创建出来
     * 如果有这个文件就会先将文件清空
     */
    public static void main(String[] args) throws IOException {
        //FileOutputStream fos = new FileOutputStream("yyy.txt");       //创建IO字节输出流对象，如果没有就自动创建一个
        FileOutputStream fos = new FileOutputStream("yyy.txt",true);    //如果想续写，就在第二个参数传true    
        fos.write(97);      //虽然写出的是一个int数，但是到文件上的是一个字节，会自动去除前3个8位
        fos.write(98);
        fos.write(99);
            
        fos.close();
    }

}

拷贝图片

由于是一个字节一个字节的读，所以效率很低。

package com.heima.stream;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo3_Copy {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("Math.jpg");  //创建输入流对象，关联Math.jpg
        FileOutputStream fos = new FileOutputStream("copy.jpg");    //创建输出流对象，关联copy.jpg
        
        int b;
        while((b = fis.read()) != -1) {     //在不断的读取每一个字节
            fos.write(b);                   //将每一个字节写出
        }
        
        fis.close();                        //关流释放资源
        fos.close();
    }

}

Java学习笔记7

TreeSet保证元素唯一和自然排序的原理和图解

TreeSet保证元素唯一和比较器排序的原理及代码实现

TreeSet原理

练习

Map集合概述和特点

Map集合的功能概述

Map集合的遍历之键找值

Map集合的遍历之键值对对象找键和值

LinkedHashMap的概述和使用

TreeMap集合键是Student值是String的案例

统计字符串中每个字符出现的次数

集合嵌套之HashMap嵌套HashMap

HashMap和Hashtable的区别

Collections工具类的概述和常见方法讲解

模拟斗地主洗牌和发牌

模拟斗地主洗牌和发牌并对牌进行排序

泛型固定下边界

异常的概述和分类

JVM默认是如何处理异常的

try...catch的方式处理异常1

try...catch的方式处理异常2

编译期异常和运行期异常的区别

Throwable的几个常见方法

throws的方式处理异常

throw的概述以及和throws的区别

finally关键字的特点及作用

finally关键字的面试题

自定义异常概述和基本使用

异常的注意事项及如何使用异常处理

练习

File类的概述和构造方法

File类的创建功能

File类的重命名和删除功能

File类的判断功能

File类的获取功能

输出指定目录下指定后缀的文件名

文件名称过滤器的概述及使用

IO流概述及其分类

FileInputStream

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

FileOutputStream以及FileOutputStream的追加

拷贝图片

推荐阅读更多精彩内容