15.泛型、File文件

package com.atguigu.java1;
import org.junit.Test;
import java.util.*;

/*
泛型的使用：
   1.jdk5.0新增的特性

   2.在集合中使用泛型：
   总结：①集合接口或集合类在jdk5.0都修改为带泛型的结构
        ②在实例化集合类时，可以指明泛型的类型
        ③指明完以后，在集合类或接口中凡是定义类或接口时，内部结构使用到类的泛型的位置，都指定为实例化时的泛型类型
        ④泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，用包装类替换
        ⑤实例化时，没有指明泛型的类型，默认为Object类型
 */
public class GenericTest {
    //在集合中使用泛型之前的情况
    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        //需求：存放学生的成绩
        list.add(78);
        list.add(68);
        list.add(89);
        list.add(88);
        //问题一：类型不安全
        list.add("Tom");
        for(Object obj :list){
            //问题二：强转时，可能出现ClassCastException
            int student = (int)obj;
            System.out.println(student);
        }
    }
    //在集合中使用泛型的情况
    @Test
    public void test2(){
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(78);
        list.add(68);
        list.add(89);
        list.add(88);
        //list.add("Tom"); 编译时，就会进行类型检查，保证数据的安全
        for (Integer score :list) {
            //避免了强转操作
            int students = score;
            System.out.println(students);
        }
    }
    //在集合中使用泛型的情况--Map为例
    @Test
    public void test3(){
        HashMap<String, Integer> map = new HashMap<>();
        map.put("Tom",23);
        map.put("Jerry",24);
        //泛型的嵌套
        Set<Map.Entry<String, Integer>> entry = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
        while(iterator.hasNext()){
            Map.Entry<String, Integer> next = iterator.next();
            String key = next.getKey();
            Integer value = next.getValue();
            System.out.println(key + "-->"+value);//Tom-->23 Jerry-->24
        }
    }
}

package com.atguigu.java1;
/*
  自定义泛型
  1.如何自定义泛型结构：泛型类、泛型接口、泛型方法
 */
public class Order<T> {
    String orderName;
    int orderId;
    T orderT;
    public Order(){

    }
    public Order(String orderName,int orderId,T orderT){
        this.orderId = orderId;
        this.orderName = orderName;
        this.orderT = orderT;
    }
    public T getOrderT(){
        return orderT;
    }
    public void setOrderT(T orderT){
        this.orderT = orderT;
    }
}

package com.atguigu.java1;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/*
自定义泛型、泛型类、泛型接口、泛型方法
 1/泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数无关（即，泛型方法所属的类是不是泛型都无关）
   public (static)<E> List<E> copyFromArrayToList(E[] arr){}
   泛型方法可以声明为静态的，泛型参数是在调用方法时确定的，而非在实例化类时，确认的
 */
public class GenericTest1 {
    @Test
    public void test1(){
        Order order = new Order();
        //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型的类型为Object类型
        //如果定义了类是带泛型的，建议在实例化时指明泛型的类型
        //如果子类在继承带泛型的父类时，指明了泛型的类型，则子类对象的实例化时，不在需要指明泛型

        order.setOrderT(123);
        order.setOrderT("abc");
        System.out.println(order.getOrderT());

        Order<String> order1 = new Order<>();
        order1.setOrderT("abcd");
    }
    /*
    泛型在继承方面的体现
       虽然类A是类B的父类，但是G<A>和G<B> 二者不具备子父类关系而是并列关系

       类A是类B的父类，A<G>是B<G>父类
     */
    @Test
    public void test2(){
        List<Object> list1 = null;
        List<String> list2 = null;
        //此时的list1和list2的类型不具有字符类关系 G<A>和G<B>
        //list1 = list2;


        //A<G>和B<G>
        List<String> list3 = null;
        ArrayList<String> list4 = null;
        list3 = list4;
    }
    /*
    通配符的使用
      通配符： ？
         A是类B的父类，但是G<A>和G<B>没有关系，二者公共的父类G<?>

      有限制条件的通配符
       ? extends A:
             G<? extends A> 可以作为G<A>和G<B>的公共父类，其中B是A的子类
       ? super A：
             G<? super A> 可以作为G<A>和G<B>的公共父类，其中B是A的父类
     */
    @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("abc");
        list3.add("cc");
        list3.add("def");
        list = list3;
        //添加:对于List<?>就不能向其内部添加数据，出了添加null;允许读取数据，返回类型为object
        list.add(null);
        //list.add("DD");
        Object o = list.get(0);
        System.out.println(o);//abc
    }
    public void print(List<?> list){
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
    }

}

 File

package com.atguigu.java2;
import org.junit.Test;
import java.io.File;
import java.io.IOException;
/*
 File类的使用：
  1.File的一个对象就代表一个文件或文件目录（文件夹）
  2.File类声明在java.io包下
  3.File类中涉及到关于文件或文件目录的创建、删除、重命名，修改时间等方法，
    但并未涉及到写入或读取文件内容的操作，如果读取或写入文件内容，则需使用IO流
  4.File类的对象常作为参数传递到流的构造器中，指明读取或写入的“终点”
 */
public class FileTest {
    /*
    1.如何创建File的实例 :调用构造器
       File(String filepath):指明文件路径 （使用相对或绝对路径）
       File(String parentpath,childpath): 指定文件目录
       File(File parentFile,String childpath):指定文件目录文件

    2.路径：
    相对路径: 相较于某个路径下，指明的路径
    绝对路径: 包含盘符在内的文件或文件目录的路径

    3.路径分隔符：
    window ：\\
    unix :/

     */
    @Test
    public void test1() {
        //构造器1
        //相对路径
        File file1 = new File("hello.txt");//相对于当前module
        //绝对文件
        File file2 = new File("D:\\IntelliJ  IDEA 2020\\workspace\\JavaSenior\\Day05");
        System.out.println(file1);//hello.txt
        System.out.println(file2);//D:\IntelliJ  IDEA 2020\workspace\JavaSenior\Day05

        //构造器2
        File file3 = new File("D:\\IntelliJ  IDEA 2020\\workspace", "JavaSenior");
        System.out.println(file3);//D:\IntelliJ  IDEA 2020\workspace\JavaSenior

        //构造器3
        File file4 = new File(file3, "hi.txt");
        System.out.println(file4);//D:\IntelliJ  IDEA 2020\workspace\JavaSenior\hi.txt
    }

    /*
    File的获取功能：
     public String getAbsolutePath():获取绝对路径
     public String getPath():获取路径
     public String getName():获取名称
     public String getParent():获取上一层文件目录。若无，返回null
     public long length(): 获取文件长度（即：字节数）
     public long lastMosified():获取最后一次的修改时间，毫秒值
     适用于文件目录
     public String[] list():获取指定目录下的所有文件或文件目录名称数组
     public File[] listFile():获取指定目录下的所有文件或文件目录的File数组
     */
    @Test
    public void test2() {
        File file = new File("D:\\IntelliJ  IDEA 2020\\workspace\\JavaSenior");
        String[] list = file.list();
        for (String s : list) {
            System.out.println(s);//.idea Day01 Day02 Day03……
        }

        File[] files = file.listFiles();
        for (File f : files) {
            System.out.println(f);//D:\IntelliJ  IDEA 2020\workspace\JavaSenior\.idea……
        }
    }

    /*
    File的重命名
    public boolean renameTo(File dest):把文件重命名为指定的文件路径
      比如file1.renameTo(file2): 使得返回true，则要求file1存在，并且file2不能存在
     */
    @Test
    public void test3() {
        File file1 = new File("hello2.txt");
        File file2 = new File("D:\\IntelliJ  IDEA 2020\\workspace\\JavaSenior\\hi2.txt");
        boolean renameTo = file1.renameTo(file2);//true
        System.out.println(renameTo);
        //原来Day05中的hello.txt 文件不见，D:\IntelliJ  IDEA 2020\workspace\JavaSenior 文件下有 hi.txt文件，内容为hello.txt中内容
    }

    /*
    file中常用功能：
    public boolean isDirectory():是否为文件目录
    public boolean idFile():是否为文件
    public boolean exists():是否存在：可先判断是否存在
    public boolean canRead():是否可读
    public boolean canWrite():是否可写
    public boolean isHidden():是否隐藏
     */
    /*
    真正内存硬盘上，File文件或文件目录的创建、删除
    public boolean createNewFile();创建文件，若文件存在，则不创建，返回false
    public boolean mkdir：创建文件目录，如果文件目录存在，则不创建，如果此文件目录的上层目录不存在，也不创建
    public boolean mkdirs：创建文件目录，如果上层文件目录不存在，一并创建

    public booelan detele():删除文件或文件夹，Java的删除不走回收站
     */
    @Test
    public void test4() throws IOException {
        File file = new File("hello.txt");//当前文件目录下创建文件
        if (!file.exists()) {
            file.createNewFile();
            System.out.println("创建成功");
        } else {
            file.delete();
            System.out.println("删除成功");
        }
    }
}