Java从入门到精通(三）

// 方式三：自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)
DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
System.out.println(formatter3.format(localDateTime));
TemporalAccessor accessor = formatter3.parse("2021-11-25 21:53:44");
System.out.println(accessor);

/**
 * ZoneId：类中包含了所有时区信息
 */
@Test
public void test4(){
    // getAvailableZoneIds()：获取对应的 ZoneId
    Set<String> zoneIds = ZoneId.getAvailableZoneIds();
    for (String zoneId : zoneIds) {
        System.out.println(zoneId);
    }
    System.out.println();
    // 获取"Asia/Tokyo"时区对应的时间
    System.out.println(LocalDateTime.now(ZoneId.of("Asia/Tokyo")));
}
/**
 * ZonedDateTime：带时区的日期时间
 */
@Test
public void test5(){
    // now()：获取本时区的 ZonedDateTime 对象
    System.out.println(ZonedDateTime.now());
    // now(ZoneId id)：获取指定时区的 ZonedDateTime 对象
    ZonedDateTime.now(ZoneId.of("Asia/Tokyo"));
}

@Test
public void test6(){
    //Duration:用于计算两个“时间”间隔，以秒和纳秒为基准  
    LocalTime localTime = LocalTime.now();
    LocalTime localTime1 = LocalTime.of(15, 23, 32);
    //between():静态方法，返回Duration对象，表示两个时间的间隔  
    Duration duration = Duration.between(localTime1, localTime);      
    System.out.println(duration);
    System.out.println(duration.getSeconds()); 
    System.out.println(duration.getNano());
    LocalDateTime localDateTime = LocalDateTime.of(2016, 6, 12, 15, 23, 32);
    LocalDateTime localDateTime1 = LocalDateTime.of(2017, 6, 12, 15, 23, 32);
    Duration duration1 = Duration.between(localDateTime1, localDateTime);  
    System.out.println(duration1.toDays());
}

@Test
public void test7(){
    LocalDate localDate = LocalDate.now();
    LocalDate localDate1 = LocalDate.of(2028, 3, 18);
    Period period = Period.between(localDate, localDate1);  
    System.out.println(period);
    System.out.println(period.getYears()); 
    System.out.println(period.getMonths());
    System.out.println(period.getDays());
    Period period1 = period.withYears(2);  
    System.out.println(period1);
}

@Test
public void test8(){
    // 获取当前日期的下一个周日是哪天？
    TemporalAdjuster temporalAdjuster = TemporalAdjusters.next(DayOfWeek.SUNDAY);  
    LocalDateTime localDateTime = LocalDateTime.now().with(temporalAdjuster);  
    System.out.println(localDateTime);
    // 获取下一个工作日是哪天？
    LocalDate localDate = LocalDate.now().with(new TemporalAdjuster() {
        @Override
        public Temporal adjustInto(Temporal temporal) {
            LocalDate date = (LocalDate) temporal;
            if (date.getDayOfWeek().equals(DayOfWeek.FRIDAY)) {
                return date.plusDays(3);
            } else if (date.getDayOfWeek().equals(DayOfWeek.SATURDAY)) {  
                return date.plusDays(2);
            } else {
                return date.plusDays(1);
            }
        }
    });
    System.out.println("下一个工作日是：" + localDate);
}

public class Goods implements Comparable{
    private String name;
    private double price;
    public Goods() {
    }
    public Goods(String name, double price) {
        this.name = name;
        this.price = price;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return "Goods{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
    /**
     * 指明商品比较大小的方式：按照价格从低到高排序，再按照产品名称从低到高排序
     * @param o
     * @return
     */
    @Override
    public int compareTo(Object o) {
        if (o instanceof Goods){
            Goods goods = (Goods) o;
            // 方式一
            if (this.price > goods.price){
                return 1;
            }else if (this.price < goods.price){
                return -1;
            }else {
                return this.name.compareTo(goods.name);
            }
            // 方式二
            // return Double.compare(this.price, goods.price);
        }
        throw new RuntimeException("传入的数据类型不一致");
    }
}

Comparator comparator = new Comparator() {
    /**
     * 按照字符串从大到小排序
     * @param o1
     * @param o2
     * @return
     */
    @Override
    public int compare(Object o1, Object o2) {
        if (o1 instanceof String && o2 instanceof  String){
            String s1 = (String) o1;
            String s2 = (String) o2;
            return -s1.compareTo(s2);
        }
        throw new RuntimeException("输入的数据类型不一致");
    }
};

@Test
public void testBigInteger() {
    BigInteger bi = new BigInteger("12433241123");
    BigDecimal bd = new BigDecimal("12435.351");
    BigDecimal bd2 = new BigDecimal("11");
    System.out.println(bi);
    // System.out.println(bd.divide(bd2));
    System.out.println(bd.divide(bd2, BigDecimal.ROUND_HALF_UP));
    System.out.println(bd.divide(bd2, 25, BigDecimal.ROUND_HALF_UP));
}

// 自定义枚举类
class Season{
    // 1.声明 Season 对象的属性，private final 修饰
    private final String seasonName;
    private final String seasonDesc;
    // 2.私有化类的构造器
    private Season(String seasonName, String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
    // 3.提供当前枚举类的多个对象：public static final 的
    public static final Season SPRING = new Season("春天", "春暖花开");
    public static final Season SUMMER = new Season("夏天", "夏日炎炎");
    public static final Season AUTUMN = new Season("秋天", "秋高气爽");
    public static final Season WINTER = new Season("冬天", "冰天雪地");
    // 4.其它诉求1：获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }
    // 4.其它诉求2：提供 toString()
    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}

// 使用 enum 关键字定义枚举类
enum Season1{
    // 1.提供当前枚举类的对象，多个对象之间用逗号隔开
    SPRING("春天", "春暖花开").
    SUMMER("夏天", "夏日炎炎"),
    AUTUMN("秋天", "秋高气爽"),
    WINTER("冬天", "冰天雪地");
    // 2.声明 Season 对象的属性，private final 修饰
    private final String seasonName;
    private final String seasonDesc;
    // 3.私有化类的构造器
    Season1(String seasonName, String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
    // 4.其它诉求1：获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }
}

public static void main(String[] args) {
    Season1 summer = Season1.SUMMER;
    System.out.println(summer);
    System.out.println(Season1.class.getSuperclass());
    // values()
    Season1[] values = Season1.values();
    for (Season1 value : values) {
        System.out.println(value);
    }
    for (Thread.State value : Thread.State.values()) {
        System.out.println(value);
    }
    // valueOf(String objName)：返回枚举类中对象名是 objName 的对象
    // 如果没有 objName 的枚举类对象，则抛异常 IllegalArgumentsException
    Season1 winter = Season1.valueOf("WINTER");
    System.out.println(winter);
}

interface Info{
    void show();
}
// 使用 enum 关键字定义枚举类
enum Season1 implements Info{
    // 1.提供当前枚举类的对象，多个对象之间用逗号隔开
    SPRING("春天", "春暖花开"){
        @Override
        public void show() {
            System.out.println("春天在哪里");
        }
    },
    SUMMER("夏天", "夏日炎炎") {
        @Override
        public void show() {
            System.out.println("宁夏");
        }
    },
    AUTUMN("秋天", "秋高气爽") {
        @Override
        public void show() {
            System.out.println("秋天不回来");
        }
    },
    WINTER("冬天", "冰天雪地") {
        @Override
        public void show() {
            System.out.println("大约在冬季");
        }
    };
    // 2.声明 Season 对象的属性，private final 修饰
    private final String seasonName;
    private final String seasonDesc;
    // 3.私有化类的构造器
    Season1(String seasonName, String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
    // 4.其它诉求1：获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }
}

@Inherited
@Repeatable(MyAnnotations.class)
@Retention(RetentionPolicy.RUNTIME)
@Target({
        ElementType.TYPE,
        ElementType.FIELD,
        ElementType.METHOD,
        ElementType.LOCAL_VARIABLE,
        ElementType.TYPE_PARAMETER,
        ElementType.TYPE_USE
})
public @interface MyAnnotation {
    String value() default "hello";
}

|---- Collection 接口：单列集合，用来存储一个一个的数据
      |---- List 接口：存储有序的、可重复的数据 --> “动态"数组
            |---- ArrayList
            |---- LinkedList
            |---- Vector
      |---- Set 接口：存储无序的、不可重复的数据 --> 高中讲的"集合“
            |---- HashSet
                  |---- LinkedHashSet
            |---- TreeSet
|---- Map 接口：双列集合，用来存储一对（key : value）一对的数据 --> 高中函数： y = f(x)
      |---- HashMap
            |---- LinkedHashMap
      |---- TreeMap
      |---- HashTable
      |---- Properties

|---- Collection 接口：单列集合，用来存储一个一个的数据
      |---- List 接口：存储有序的、可重复的数据 --> “动态"数组
            |---- ArrayList
            |---- LinkedList
            |---- Vector
      |---- Set 接口：存储无序的、不可重复的数据 --> 高中讲的"集合“
            |---- HashSet
                    |---- LinkedHashSet
            |---- TreeSet

// 8.toArray()：集合转换为数组
Object[] arr = collection.toArray();
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}
// 扩展：数组转换为集合：调用 Arrays 类的静态方法 asList()
List<String> list = Arrays.asList(new String[] {"aa", "bb", "cc"});
System.out.println(list);

Iterator iterator = collection.iterator();
// hasNext()：判断是否会有下一个元素
while (iterator.hasNext()){
    // next()：指针下移；将下移以后集合位置上的元素返回
    System.out.println(iterator.next());
}

// 如果还未调用 next() 或在上一次调用 next 方法之后已经调用了 remove 方法,
// 再调用 remove 都会报 IllegalStateException。
// 内部定义了 remove()，可以在遍历的时候，删除集合中的元素，此方法不同于集合直接调用 remove()
@Test
public void test3() {
    Collection collection = new ArrayList();
    collection.add(123);
    collection.add(456);
    collection.add(new Person("Jerry", 20));
    collection.add(new String("Tom"));
    collection.add(false);
    Iterator iterator = collection.iterator();
    // 删除集合中 “Tom” 数据
    while (iterator.hasNext()){
        Object obj = iterator.next();
        if ("Tom".equals(obj)){
            iterator.remove();
        }
    }
    iterator = collection.iterator();
    while (iterator.hasNext()){
        System.out.println(iterator.next());
    }
}

@Test
public void test1() {
    Collection collection = new ArrayList();
    collection.add(123);
    collection.add(456);
    collection.add(new Person("Jerry", 20));
    collection.add(new String("Tom"));
    collection.add(false);
    // for(集合中元素的类型 局部变量 : 集合对象)
    // 内部仍然调用了迭代器
    for(Object obj : collection){
        System.out.println(obj);
    }
}

@Test
public void test2(){
    int[] arr = new int[]{1, 2, 3, 4, 5, 6};
    for (int a : arr){
        System.out.println(a);
    }
}

|---- Collection 接口：单列集合，用来存储一个一个的数据
      |---- List 接口：存储有序的、可重复的数据 --> “动态"数组，替换原有数组
            |---- ArrayList
                     作为 List 接口的主要实现类
                     线程不安全，效率高
                     底层使用 Object[] elementData 存储
            |---- LinkedList
                     对于频繁的插入和删除，使用此类效率比 ArrayList 高
                     底层使用双向列表存储
            |---- Vector
                     作为 List 接口的古老实现类
                     线程安全，效率低
                     底层使用 Object[] elementData 存储

private static class Node<E> {
      E item;
      Node<E> next;
      Node<E> prev;
      Node(Node<E> prev, E element, Node<E> next) {
          this.item = element;
          this.next = next;
          this.prev = prev;
      }
  }

|---- Collection 接口：单列集合，用来存储一个一个的数据
    |---- Set 接口：存储无序的、不可重复的数据 --> 高中讲的"集合“
          |---- HashSet
                    作为 Set 接口的主要实现类
                    线程不安全的
                    可以存储 null 值
               |---- LinkedHashSet
                         作为 HashSet 的子类，在添加数据的同时，每个数据还维护了两个引用，
                         记录此数据的前一个数据和后一个数据
                         遍历其内部数据时，可以按照添加的顺序遍历
                         对于频繁的遍历操作：LinkedHashSet 效率高于 HashSet
          |---- TreeSet
                    可以按照添加对象的指定属性，进行排序

@Test
public void test1(){
    TreeSet set = new TreeSet();
    // 失败：不能添加不同类的对象
    // set.add(456);
    // set.add(123);
    // set.add("AA");
    // set.add("CC");
    // set.add(new User("Tom", 12));
    // set.add(34);
    // set.add(-34);
    // set.add(43);
    // set.add(11);
    // set.add(8);
    set.add(new User("Tom", 12));
    set.add(new User("Jerry", 32));
    set.add(new User("Jim", 22));
    set.add(new User("Mike", 65));
    set.add(new User("Jack", 33));
    set.add(new User("Jack", 56));
    Iterator iterator = set.iterator();
    while (iterator.hasNext()) {
        System.out.println(iterator.next());
    }
}

@Test
public void test2() {
    Comparator comparator = new Comparator() {
        /**
         * 按照年龄从小到大排列
         * @param o1
         * @param o2
         * @return
         */
        @Override
        public int compare(Object o1, Object o2) {
            if (o1 instanceof User && o2 instanceof User){
                User u1 = (User) o1;
                User u2 = (User) o2;
                return Integer.compare(u1.getAge(), u2.getAge());
            }
            throw new RuntimeException("输入的数据类型不匹配");
        }
    };
    TreeSet set = new TreeSet(comparator);
    set.add(new User("Tom", 12));
    set.add(new User("Jerry", 32));
    set.add(new User("Jim", 22));
    set.add(new User("Mike", 65));
    set.add(new User("Jack", 33));
    set.add(new User("Jack", 56));
    Iterator iterator = set.iterator();
    while (iterator.hasNext()) {
        System.out.println(iterator.next());
    }
}

|---- Map：双列数据，存储 key-value 对的数据 --> 类似于高中函数：y = f(x)
      |---- HashMap
                作为 Map 的主要实现类
                线程不安全的，效率高
                存储 null 的 key 和 value
            |---- LinkedHashMap
                        保证在遍历 map 元素时，可以按照添加的顺序实现遍历
                        原因：在原有的 HashMap 底层结构基础上，添加了一对指针，指向前一个和后一个元素
                        对于频繁的遍历操作，此类执行效率高于 HashMap
      |---- TreeMap
                保证按照添加的 key-value 对进行排序，实现排序遍历，此时考虑 key 的自然排序和定制排序
                底层使用红黑树
      |---- Hashtable
                作为 Map 的古老实现类
                线程安全的，效率低
                不能存储 null 的 key 和 value
            |---- Properties
                      常用来处理配置文件
                      key 和 value 都是 String 类型

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;
    Node(int hash, K key, V value, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }
    public final K getKey()        { return key; }
    public final V getValue()      { return value; }
    public final String toString() { return key + "=" + value; }
    public final int hashCode() {
        return Objects.hashCode(key) ^ Objects.hashCode(value);
    }
    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }
    public final boolean equals(Object o) {
        if (o == this)
            return true;
        if (o instanceof Map.Entry) {
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            if (Objects.equals(key, e.getKey()) &&
                Objects.equals(value, e.getValue()))
                return true;
        }
        return false;
    }
}

static class Entry<K,V> extends HashMap.Node<K,V> {
      Entry<K,V> before, after; // 能够记录添加元素的先后顺序
      Entry(int hash, K key, V value, Node<K,V> next) {
          super(hash, key, value, next);
      }
  }

public static void main(String[] args)  {
    FileInputStream fileInputStream = null;
    try {
        Properties prop = new Properties();
        fileInputStream = new FileInputStream("jdbc.properties");
        prop.load(fileInputStream);
        String name = prop.getProperty("name");
        String password = prop.getProperty("password");
        System.out.println("name = " + name);
        System.out.println("password = " + password);
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (fileInputStream != null) {
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

@Test
public void test1(){
    ArrayList list = new ArrayList();
    list.add(78);
    list.add(77);
    list.add(89);
    list.add(88);
    // 问题一：类型不安全
    // list.add("Tom");
    for (Object score : list) {
        // 问题二：强转时，可能出现 ClassCastException
        int stuScore = (int) score;
        System.out.println(stuScore);
    }
}

@Test
public void test2(){
    // ArrayList<Integer> list = new ArrayList<Integer>();
    // JDK7 新特性：类型推断
    ArrayList<Integer> list = new ArrayList<>();
    list.add(78);
    list.add(87);
    list.add(99);
    list.add(65);
    // 编译时，就会进行类型检查，保证数据的安全
    // list.add("65");
    /*for(Integer score : list){
        // 避免了强转操作
        int stuScore = score;
        System.out.println(stuScore);
    }*/
    Iterator<Integer> iterator = list.iterator();
    while (iterator.hasNext()){
        int stuScore = iterator.next();
        System.out.println(stuScore);
    }
}

@Test
public void test3(){
    Map<String, Integer> map = new HashMap<>();
    map.put("Tom", 87);
    map.put("Jerry", 87);
    map.put("Jack", 67);
    // map.put(123, "67");
    Set<Map.Entry<String, Integer>> entry = map.entrySet();
    Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
    while (iterator.hasNext()){
        Map.Entry<String, Integer> e = iterator.next();
        String key = e.getKey();
        Integer value = e.getValue();
        System.out.println(key + " --- " + value);
    }
}

public class Order<T> {
    String orderName;
    int orderId;
    // 类的内部结构就可以使用类的泛型
    T orderT;
    public Order(){
        // 编译不通过
        // T[] arr = new T[10];
        // 编译通过
        T[] arr = (T[]) new Object[10];
    }
    public Order(String orderName, int orderId, T orderT) {
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }
    public String getOrderName() {
        return orderName;
    }
    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }
    public int getOrderId() {
        return orderId;
    }
    public void setOrderId(int orderId) {
        this.orderId = orderId;
    }
    public T getOrderT() {
        return orderT;
    }
    public void setOrderT(T orderT) {
        this.orderT = orderT;
    }
    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }
    // 静态方法中不能使用类的泛型
    /*public static void show(){
        System.out.println(orderT);
    }*/
    public void show(){
        // 编译不通过
       /*try {
       }catch (T t){
       }*/
    }
    // 泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系
    // 换句话说，泛型方法所属的类是不是泛型类都没有关系
    // 泛型方法可以声明为静态的，原因：泛型参数是在调用方法时确定的，并非在实例化类时确定
    public static <E> List<E> copyFromArrayToList(E[] arr){
        ArrayList<E> list = new ArrayList<>();
        for (E e : arr) {
            list.add(e);
        }
        return list;
    }
}

public class SubOrder extends Order<Integer> {
    public static <E> List<E> copyFromArrayToList(E[] arr){
        ArrayList<E> list = new ArrayList<>();
        for (E e : arr) {
            list.add(e);
        }
        return list;
    }
}

public class GenericTest1 {
    @Test
    public void test1(){
        // 如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为 Object 类型
        // 要求：如果定义了类是带泛型的，建议在实例化时要指明类的泛型
        Order order = new Order();
        order.setOrderT(123);
        order.setOrderT("123");
        // 建议：实例化时指明类的泛型
        Order<String> order1 = new Order<>("orderAA",
                1001, "order:AA") ;
        order1.setOrderT("AA:hello");
    }
    @Test
    public void test2(){
        // 由于子类在继承带泛型的父类时，指明了泛型类型，则实例化子类对象时，不再需要指明泛型
        SubOrder subOrder = new SubOrder();
        subOrder.setOrderT(1122);
        SubOrder1<String> subOrder1 = new SubOrder1<>();
        subOrder1.setOrderT("order2...");
    }
    @Test
    public void test3(){
        // 泛型不同的引用不能相互赋值
        ArrayList<String> list1 = null;
        ArrayList<Integer> list2 = new ArrayList<>();
        // list1 = list2;
        Person p1 = null;
        Person p2 = null;
        p1 = p2;
    }
    // 测试泛型方法
    @Test
    public void test4(){
        Order<String> order = new Order<>();
        Integer[] arr = {1, 2, 3, 4};
        // 泛型方法在调用时，指明泛型参数的类型
        List<Integer> list = order.copyFromArrayToList(arr);
        System.out.println(list);
    }
}

public class DAO<T> {
    // 添加一条记录
    public void add(T t){
    }
    // 删除一条记录
    public boolean remove(int index){
        return false;
    }
    // 修改一条记录
    public void update(int index, T t){
    }
    // 查询一条记录
    public T getIndex(int index){
        return null;
    }
    // 查询多条记录
    public List<T> getForList(int index){
        return null;
    }
    public <E> E getValue(){
        return null;
    }
}

@Test
public void test1(){
    Object obj = null;
    String str = null;
    obj = str;
    Date date = new Date();
    // 编译不通过
    // str = date;
    Object[] arr1 = null;
    String[] arr2 = null;
    arr1 = arr2;
    List<Object> list1 = null;
    List<String> list2 = new ArrayList<>();
    // 此时的 list1 和 list2 的类型不具备子父类关系
    // 编译不通过
    // list1 = list2;
    /*
        反证法
        假设 list1 = list2; // 导致混入非 String 的数据，出错
     */
    show(list1);
    // show(list2);
}
public void show(List<Object> list){
}
@Test
public void test2(){
    AbstractList<String> list1 = null;
    List<String> list2 = null;
    ArrayList<String> list3 = null;
    list1 = list3;
    list2 = list3;
}

@Test
public void test3() {
    List<Object> list1 = null;
    List<String> list2 = null;
    List<?> list = null;
    list = list1;
    list = list2;
    // print(list1);
    // print(list2);
    List<String> list3 = new ArrayList<>();
    list3.add("AA");
    list3.add("BB");
    list3.add("CC");
    list = list3;
    // 添加（写入）：对于 List<?> 就不能向其内部添加数据，除了添加 null 之外
    // list.add("DD");
    list.add(null);
    // 获取（读取）：允许读取数据，读取的数据类型为 Object
    Object o = list.get(0);
    System.out.println(o);
}
public void print(List<?> list){
    Iterator<?> iterator = list.iterator();
    while (iterator.hasNext()){
        Object obj = iterator.next();
        System.out.println(obj);
    }
}

@Test
public void test3() {
    List<Object> list1 = null;
    List<String> list3 = new ArrayList<>();
    list3.add("AA");
    list3.add("BB");
    list3.add("CC");
    list = list3;
    // 添加（写入）：对于 List<?> 就不能向其内部添加数据，除了添加 null 之外
    // list.add("DD");
    list.add(null);
    // 获取（读取）：允许读取数据，读取的数据类型为 Object
    Object o = list.get(0);
    System.out.println(o);
}

@Test
public void test4(){
    List<? extends Person> list1 = null;
    List<? super Person> list2 = null;
    List<Student> list3 = new ArrayList<>();
    List<Person> list4 = new ArrayList<>();
    List<Object> list5 = new ArrayList<>();
    list1 = list3;
    list1 = list4;
    // list1 = list5;
    // list2 = list3;
    list2 = list4;
    list2 = list5;
    // 读取数据
    list1 = list3;
    Person person = list1.get(0);
    // 编译不通过
    // Person person1 = list1.get(0);
    list2 = list4;
    Object obj = list2.get(0);
    // 写入数据：
    // list1.add(new Student());
    list2.add(new Person());
    list2.add(new Student());
}

@Test
public void testFileReader1() {
    FileReader fileReader = null;
    try {
        // 1.File 类的实例化
        File file = new File("hello.txt");
        // 2.FileReader 流的实例化
        fileReader = new FileReader(file);
        // 3.读入的操作
        // read(char[] cbuf)：返回每次读入 cbuf 数组中的字符的个数，如果达到文件末尾，返回-1
        char[] cbuf = new char[5];
        int len = 0;
        while ((len = fileReader.read(cbuf)) != -1){
            // 错误的写法
            /*for (int i = 0; i < cbuf.length; i++) {
                System.out.print(cbuf[i]);
            }*/
            // 正确的写法
            /*for (int i = 0; i < len; i++) {
                System.out.print(cbuf[i]);
            }*/
            // 错误的写法
            // System.out.print(new String(cbuf));
            // 正确的写法
            System.out.print(new String(cbuf, 0, len));
        }
    } catch (IOException e){
        e.printStackTrace();
    } finally{
        // 4.资源的关闭
        if (fileReader != null) {
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

@Test
public void testFileWriter(){
    FileWriter fileWriter = null;
    try {
        // 1.提供 File 类的对象，指明写出到的文件
        File file = new File("hello1.txt");
        // 2.提供 FileWriter 的对象，用于数据的写出
        fileWriter = new FileWriter(file, false);
        // 3.写出的操作
        fileWriter.write("I have a dream!\n");
        fileWriter.write("you need to have a dream!");
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        // 4.流资源的关闭
        if (fileWriter != null) {
            try {
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

@Test
public void testFileReaderFileWriter() {
    FileReader fileReader = null;
    FileWriter fileWriter = null;
    try {
        // 1.创建 File 类的对象，指明读入和写出的文件
        // File srcFile = new File("hello.txt");
        // File destFile = new File("hello2.txt");
        // 不能使用字符流来处理图片等字节数据
        File srcFile = new File("爱情与友情.png");
        File destFile = new File("爱情与友情1.png");
        // 2.创建输入流和输出流的对象
        fileReader = new FileReader(srcFile);
        fileWriter = new FileWriter(destFile);
        // 3.数据的读入和写出操作
        char[] cbuf = new char[5];
        // 记录每次读入到 cbuf 数组中的字符的个数
        int len = 0;
        while ((len = fileReader.read(cbuf)) != -1){
            // 每次写出 len 个字符
            fileWriter.write(cbuf, 0, len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        // 4.关闭流资源
        if (fileWriter != null) {
            try {
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (fileReader != null) {
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
 * 实现对图片的复制
 */
@Test
public void testFileInputOutputStream(){
    FileInputStream fileInputStream = null;
    FileOutputStream fileOutputStream = null;
    try {
        File srcFile = new File("爱情与友情.png");
        File destFile = new File("爱情与友情2.png");
        fileInputStream = new FileInputStream(srcFile);
        fileOutputStream = new FileOutputStream(destFile);
        // 复制的过程
        byte[] buffer = new byte[5];
        int len = 0;
        while ((len = fileInputStream.read(buffer)) != -1){
            fileOutputStream.write(buffer, 0, len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        if (fileInputStream != null) {
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (fileOutputStream != null) {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

public class BufferedInputStream extends FilterInputStream {
    private static int DEFAULT_BUFFER_SIZE = 8192;
}

/**
 * 实现文件复制的方法
 */
public void copyFileWithBuffered(String srcPath, String destPath){
    BufferedInputStream bufferedInputStream = null;
    BufferedOutputStream bufferedOutputStream = null;
    try {
        // 造文件
        File srcFile = new File(srcPath);
        File destFile = new File(destPath);
        // 2.造流
        // 2.1.造节点流
        FileInputStream fileInputStream = new FileInputStream(srcFile);
        FileOutputStream fileOutputStream = new FileOutputStream(destFile);
        // 2.2.造缓冲流
        bufferedInputStream = new BufferedInputStream(fileInputStream);
        bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
        // 3.复制的细节
        byte[] buffer = new byte[1024];
        int len = 0;
        while ((len = bufferedInputStream.read(buffer)) != -1){
            bufferedOutputStream.write(buffer, 0, len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        // 4.资源关闭
        // 要求：先关闭外层的流，再关闭内层的流
        if (bufferedOutputStream != null) {
            try {
                bufferedOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (bufferedInputStream != null) {
            try {
                bufferedInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        // 说明：在关闭外层流的同时，内层流也会自动进行关闭，对于内层流的关闭，可以省略
        // fileOutputStream.close();
        // fileInputStream.close();
    }
}

/**
 * 使用 BufferedReader 和 BufferedWriter 实现文本文件的复制
 */
@Test
public void testBufferedReaderBufferedWriter(){
    BufferedReader bufferedReader = null;
    BufferedWriter bufferedWriter = null;
    try {
        // 创建文件和相应的流
        bufferedReader = new BufferedReader(new FileReader(new File("dbcp.txt")));
        bufferedWriter = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));
        // 读写操作
        // 方式一，使用 char[] 数组
        /*char[] cbuf = new char[1024];
        int len = 0;
        while ((len = bufferedReader.read(cbuf)) != -1){
            bufferedWriter.write(cbuf, 0, len);
        }*/
        // 方式二：使用 String
        String data;
        while ((data = bufferedReader.readLine()) != null){
            // 方法一：
            // data 中不包含换行符
            // bufferedWriter.write(data + "\n");
            // 方法二：
            bufferedWriter.write(data);
            // 提供换行的操作
            bufferedWriter.newLine();
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (bufferedReader != null) {
            try {
                bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (bufferedWriter != null) {
            try {
                bufferedWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

@Test
public void test1(){
    InputStreamReader inputStreamReader = null;
    try {
        FileInputStream fileInputStream = new FileInputStream("dbcp.txt");
        // 使用系统默认的字符集
        // InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
        // 参数2指明了字符集：具体使用哪个字符集，取决于文件 dbcp.txt 保存时使用的字符集
        inputStreamReader = new InputStreamReader(fileInputStream, StandardCharsets.UTF_8);
        char[] cbuf = new char[20];
        int len = 0;
        while ((len = inputStreamReader.read(cbuf)) != -1){
            System.out.print(new String(cbuf,0, len));
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (inputStreamReader != null) {
            try {
                inputStreamReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
 * 综合使用 InputStreamReader 和 OutputStreamWriter
 */
@Test
public void test2(){
    InputStreamReader inputStreamReader = null;
    OutputStreamWriter outputStreamWriter = null;
    try {
        File file1 = new File("dbcp.txt");
        File file2 = new File("dbcp_gbk.txt");
        FileInputStream fileInputStream = new FileInputStream(file1);
        FileOutputStream fileOutputStream = new FileOutputStream(file2);
        inputStreamReader = new InputStreamReader(fileInputStream, StandardCharsets.UTF_8);
        outputStreamWriter = new OutputStreamWriter(fileOutputStream, "gbk");
        char[] cbuf = new char[20];
        int len = 0;
        while ((len = inputStreamReader.read(cbuf)) != -1){
            outputStreamWriter.write(cbuf, 0, len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        if (inputStreamReader != null) {
            try {
                inputStreamReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (outputStreamWriter != null) {
            try {
                outputStreamWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
 * 数据流：DataInputStream 和 DataOutputStream
 * 1.作用：用于读取或写出基本数据类型的变量或字符串
 */
@Test
public void test3(){
    DataOutputStream dataOutputStream = null;
    try {
        dataOutputStream = new DataOutputStream(new FileOutputStream("data.txt"));
        dataOutputStream.writeUTF("刘建辰");
        dataOutputStream.writeInt(23);
        dataOutputStream.writeBoolean(true);
        // 刷新操作，将内存中的数据写入文件
        dataOutputStream.flush();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (dataOutputStream != null) {
            try {
                dataOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
 * 将文件中存储的基本数据类型变量和字符串读取到内存中
 * 注意点：读取不同类型数据的顺序要以当初写入文件时，保存的数据的顺序一致
 */
@Test
public void test4(){
    DataInputStream dataInputStream = null;
    try {
        dataInputStream = new DataInputStream(new FileInputStream("data.txt"));
        System.out.println(dataInputStream.readUTF());
        System.out.println(dataInputStream.readInt());
        System.out.println(dataInputStream.readBoolean());
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (dataInputStream != null) {
            try {
                dataInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

@Test
public void testObjectOuputStream(){
    ObjectOutputStream objectOutputStream = null;
    try {
        objectOutputStream = new ObjectOutputStream(new FileOutputStream("object.dat"));
        objectOutputStream.writeObject(new String("我爱北京天安门"));
        // 刷新操作
        objectOutputStream.flush();
        objectOutputStream.writeObject(new Person("王铭", 23));
        objectOutputStream.flush();
        objectOutputStream.writeObject(new Person("张学良", 23, 1001, new Account(5000)));
        objectOutputStream.flush();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (objectOutputStream != null) {
            try {
                objectOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

@Test
public void testObjectInputStream(){
    ObjectInputStream objectInputStream = null;
    try {
        objectInputStream = new ObjectInputStream(new FileInputStream("object.dat"));
        Object obj = objectInputStream.readObject();
        String str = (String) obj;
        System.out.println(str);
        Person person = (Person) objectInputStream.readObject();
        System.out.println(person);
        Person person1 = (Person) objectInputStream.readObject();
        System.out.println(person1);
    } catch (IOException | ClassNotFoundException e) {
        e.printStackTrace();
    } finally {
        if (objectInputStream != null) {
            try {
                objectInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

@Test
public void test1(){
    RandomAccessFile randomAccessFile1 = null;
    RandomAccessFile randomAccessFile2 = null;
    try {
        randomAccessFile1 = new RandomAccessFile(new File("爱情与友情.png"), "r");
        randomAccessFile2 = new RandomAccessFile(new File("爱情与友情1.png"), "rw");
        byte[] buffer = new byte[1024];
        int len = 0;
        while ((len = randomAccessFile1.read(buffer)) != -1){
            randomAccessFile2.write(buffer, 0, len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (randomAccessFile1 != null) {
            try {
                randomAccessFile1.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (randomAccessFile2 != null) {
            try {
                randomAccessFile2.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

@Test
public void test3() {
    RandomAccessFile randomAccessFile = null;
    ByteArrayOutputStream byteArrayOutputStream = null;
    try {
        randomAccessFile = new RandomAccessFile("hello.txt", "rw");
        // 将指针调到角标为3的位置
        randomAccessFile.seek(3);
        // 保存指针3后面的所有数据到 ByteArrayOutputStream / StringBuilder 中
        byteArrayOutputStream = new ByteArrayOutputStream();
        /*StringBuilder builder = new StringBuilder(
                (int) new File("hello.txt").length());*/
        byte[] buffer = new byte[20];
        int len = 0;
        while ((len = randomAccessFile.read(buffer)) != -1){
            // builder.append(new String(buffer, 0, len));
            byteArrayOutputStream.write(buffer, 0, len);
        }
        randomAccessFile.seek(3);
        randomAccessFile.write("xyz".getBytes());
        // randomAccessFile.write(builder.toString().getBytes());
        randomAccessFile.write(byteArrayOutputStream.toByteArray());
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (byteArrayOutputStream != null) {
            try {
                byteArrayOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (randomAccessFile != null) {
            try {
                randomAccessFile.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

public class TCPTest1 {
    /**
     * 客户端
     */
    @Test
    public void client(){
        Socket socket = null;
        OutputStream outputStream = null;
        try {
            // 1.创建 Socket 对象，指明服务器的 IP 和端口号
            InetAddress inet = InetAddress.getByName("127.0.0.1");
            socket = new Socket(inet, 8899);
            // 2.获取一个输出流，用于输出数据
            outputStream = socket.getOutputStream();
            // 3.写出数据的操作
            outputStream.write("你好，我是客户端mm".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            // 4.资源的关闭
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    /**
     * 服务端
     */
    @Test
    public void server(){
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream inputStream = null;
        ByteArrayOutputStream byteArrayOutputStream = null;
        try {
            // 1.创建服务器端的 ServerSocket，指明自己的端口号
            serverSocket = new ServerSocket(8899);
            // 2.调用 accept() 表示接收来自于客户端的 socket
            socket = serverSocket.accept();
            // 3.获取输入流
            inputStream = socket.getInputStream();
            // 不建议，有乱码
            /*byte[] buffer = new byte[1024];
            int len = 0;
            while ((len = inputStream.read(buffer)) != -1){
                System.out.print(new String(buffer, 0, len));
            }*/
            // 4.获取输入流中的数据
            byteArrayOutputStream = new ByteArrayOutputStream();
            byte[] buffer = new byte[5];
            int len = 0;
            while ((len = inputStream.read(buffer)) != -1){
                byteArrayOutputStream.write(buffer, 0, len);
            }
            System.out.println(byteArrayOutputStream);
            System.out.println("收到了来自于：" + socket.getInetAddress().getHostAddress() + " 的数据");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 5.资源的关闭
            if (byteArrayOutputStream != null) {
                try {
                    byteArrayOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

public class TCPTest2 {
    @Test
    public void client(){
        Socket socket = null;
        OutputStream outputStream = null;
        FileInputStream fileInputStream = null;
        try {
            socket = new Socket(InetAddress.getByName("127.0.0.1"), 9090);
            outputStream = socket.getOutputStream();
            fileInputStream = new FileInputStream("beauty.png");
            byte[] buffer = new byte[1024];
            int len = 0;
            while ((len = fileInputStream.read(buffer)) != -1){
                outputStream.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileInputStream != null) {
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    @Test
    public void server(){
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream inputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            serverSocket = new ServerSocket(9090);
            socket = serverSocket.accept();
            inputStream = socket.getInputStream();
            fileOutputStream = new FileOutputStream("beauty1.png");
            byte[] buffer = new byte[1024];
            int len = 0;
            while ((len = inputStream.read(buffer)) != -1){
                fileOutputStream.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileOutputStream != null) {
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

public class TCPTest3 {
    @Test
    public void client(){
        Socket socket = null;
        OutputStream outputStream = null;
        InputStream inputStream = null;
        FileInputStream fileInputStream = null;
        ByteArrayOutputStream byteArrayOutputStream = null;
        try {
            socket = new Socket(InetAddress.getByName("127.0.0.1"), 9090);
            outputStream = socket.getOutputStream();
            fileInputStream = new FileInputStream("beauty.png");
            byte[] buffer = new byte[1024];
            int len = 0;
            while ((len = fileInputStream.read(buffer)) != -1){
                outputStream.write(buffer, 0, len);
            }
            // 关闭数据的输出
            socket.shutdownOutput();
            // 接收来自于服务器端的数据，并显示到控制台
            inputStream = socket.getInputStream();
            byteArrayOutputStream = new ByteArrayOutputStream();
            byte[] bufferr = new byte[20];
            int len1 = 0;
            while ((len1 = inputStream.read(bufferr)) != -1){
                byteArrayOutputStream.write(bufferr, 0, len1);
            }
            System.out.println(byteArrayOutputStream);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (byteArrayOutputStream != null) {
                try {
                    byteArrayOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fileInputStream != null) {
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    @Test
    public void server(){
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream inputStream = null;
        FileOutputStream fileOutputStream = null;
        OutputStream outputStream = null;
        try {
            serverSocket = new ServerSocket(9090);
            socket = serverSocket.accept();
            inputStream = socket.getInputStream();
            fileOutputStream = new FileOutputStream("beauty2.png");
            byte[] buffer = new byte[1024];
            int len = 0;
            while ((len = inputStream.read(buffer)) != -1){
                fileOutputStream.write(buffer, 0, len);
            }
            System.out.println("图片传输完成");
            // 服务器给予客户端反馈
            outputStream = socket.getOutputStream();
            outputStream.write("你好，美女，照片我已收到，非常漂亮".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fileOutputStream != null) {
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

public class UDPTest {
    /**
     * 发送端
     */
    @Test
    public void sender(){
        DatagramSocket socket = null;
         try {
            socket = new DatagramSocket();
            String str = "我是 UDP 方式发送的导弹";
            byte[] data = str.getBytes();
            InetAddress inet = InetAddress.getLocalHost();
            DatagramPacket packet = new DatagramPacket(data, 0, data.length, inet, 9090);
            socket.send(packet);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            socket.close();
        }
    }
    /**
     * 接收端
     */
    @Test
    public void receiver(){
        DatagramSocket socket = null;
        try {
            socket = new DatagramSocket(9090);
            byte[] buffer = new byte[100];
            DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
            socket.receive(packet);
            System.out.println(new String(packet.getData(), 0, packet.getLength()));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            socket.close();
        }
    }
}

public class URLTest1 {
    public static void main(String[] args){
        HttpURLConnection urlConnection = null;
        InputStream inputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            URL url = new URL("http://localhost:8080/examples/beauty.png");
            urlConnection = (HttpURLConnection) url.openConnection();
            urlConnection.connect();
            inputStream = urlConnection.getInputStream();
            fileOutputStream = new FileOutputStream("JavaSenior\\day10\\beauty3.png");
            byte[] buffer = new byte[1024];
            int len = 0;
            while ((len = inputStream.read(buffer)) != -1){
                fileOutputStream.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileOutputStream != null) {
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (urlConnection != null) {
                urlConnection.disconnect();
            }
        }
    }
}

@Test
public void test2(){
    for (int i = 0; i < 100; i++) {
        int num = new Random().nextInt(3);
        String classPath = "";
        switch (num){
            case 0:
                classPath = "java.util.Date";
                break;
            case 1:
                classPath = "java.lang.Object";
                break;
            case 2:
                classPath = "cn.tedu.java.Person";
                break;
        }
        System.out.println(getInstance(classPath));
    }
}
/**
 * 创建一个指定类的对象
 * @param classPath 指定类的全类名
 * @return
 * @throws Exception
 */
public Object getInstance(String classPath){
    try {
        return Class.forName(classPath).newInstance();
    } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
        e.printStackTrace();
    }
    return null;
}

/**
 * 获取 Class 的实例的方式(前三种需要掌握)
 */
@Test
public void test3() throws ClassNotFoundException {
    // 方式一：调用运行时类的属性：.class
    Class<Person> clazz1 = Person.class;
    System.out.println(clazz1);
    // 方式二：通过运行时类的对象，调用 getClass()
    Person p1 = new Person();
    Class<? extends Person> clazz2 = p1.getClass();
    System.out.println(clazz2);
    // 方式三：调用 Class 的静态方法：forname(String classPath)
    Class<?> clazz3 = Class.forName("cn.tedu.java.Person");
    // clazz3 = Class.forName("java.lang.String");
    System.out.println(clazz3);
    System.out.println(clazz1 == clazz2);
    System.out.println(clazz1 == clazz3);
    // 方式四：使用类的加载器：ClassLoader(了解)
    ClassLoader classLoader = ReflectionTest.class.getClassLoader();
    Class<?> clazz4 = classLoader.loadClass("cn.tedu.java.Person");
    System.out.println(clazz4);
}

@Test
public void test2() throws IOException {
    Properties properties = new Properties();
    // 此时的文件默认在当前的 Module 下
    // 读取配置方式一：
    // FileInputStream fileInputStream = new FileInputStream("jdbc.properties");
    // FileInputStream fileInputStream = new FileInputStream("src\\jdbc1.properties");
    // properties.load(fileInputStream);
    // 读取配置方式二：使用 ClassLoader
    // 配置文件默认识别为：当前 module 的 src 下
    ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
    InputStream resourceAsStream = classLoader.getResourceAsStream("jdbc1.properties");
    properties.load(resourceAsStream);
    String user = properties.getProperty("user");
    String password = properties.getProperty("password");
    System.out.println("user = " + user  + ", password = " + password);
}

@Test
public void test1() throws Exception{
    Class<Person> clazz = Person.class;
    Person person = clazz.newInstance();
    System.out.println(person);
}

@Test
public void test1(){
    Class<Person> clazz = Person.class;
    // 获取属性结构
    // getFeilds()：获取当前运行时类及其父类声明为 public 访问权限的属性
    Field[] fields = clazz.getFields();
    for (Field field : fields) {
        System.out.println(field);
    }
    System.out.println();
    // getDeclaredFields()：获取当前运行时类中声明的所有的属性(不包含父类中声明的属性)
    for (Field declaredField : clazz.getDeclaredFields()) {
        System.out.println(declaredField);
    }
}

@Test
public void test1(){
    Class<Person> clazz = Person.class;
    // getMethods()：获取当前运行时类及其父类声明为 public 访问权限的方法
    Method[] methods = clazz.getMethods();
    for (Method m : methods) {
        System.out.println(m);
    }
    System.out.println();
    // getDeclaredMethods()：获取当前运行时类中声明的所有的方法(不包含父类中声明的方法)
    for (Method declaredMethod : clazz.getDeclaredMethods()) {
        System.out.println(declaredMethod);
    }
}