java基础（15）(泛型，File常用的操作功能，递归，目录的遍历等)

最新推荐文章于 2024-10-12 08:30:00 发布

double_lifly

最新推荐文章于 2024-10-12 08:30:00 发布

阅读量159

点赞数

分类专栏： java 文章标签：泛型 file File常用功能递归 File与递归的综合练习

本文链接：https://blog.csdn.net/qq_41934990/article/details/116500540

版权

java 专栏收录该内容

38 篇文章 2 订阅

订阅专栏

泛型

一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。

好处

将运行时期的ClassCastException，转移到了编译时期变成了编译失败。

避免了类型强转的麻烦

泛型是数据类型的一部分，通常将类名与泛型合并一起看做数据类型

public class genericDemo01 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        ArrayList list1 = new ArrayList();
        list1.add("abc");
        list1.add(true);
        list1.add('c');
        list1.add(123);
        for (Object o : list1) {
            System.out.println(o);
        }
        //Exception in thread "main" java.lang.ClassCastException: class java.lang.Boolean cannot be cast to class java.lang.String
       /* for (Object o : list1) {
            String str = (String) o;
            System.out.println(str.length());
        }*/
    }
}

定义与使用

通常在集合中泛型比较常用。

但是泛型也可以用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。

定义和使用含有泛型的类

比如说ArrayList集合中的使用

也可以自定义泛型，比如以下代码

public class Generic {

        /**
         * 泛型修饰方法
         * 修饰符<字母> 返回值类型 方法名称(字母 变量名){}
         */
    /**
     * 无返回值
     * @param t 参数
     * @param <T> 数据类型
     */
    public static <T> void method(T t){
        System.out.println(t);
    }

    /**
     * 返回值为泛型
     * @param t 参数
     * @param <T> 数据类型
     * @return 泛型参数
     */
    public static <T> T method1(T t){
        return t;
    }
}

泛型的使用

public class GenericTest {
    public static void main(String[] args) {
        //自定义泛型
        //定义的是静态方法，直接通过类名.方法调用
        //调用无返回值方法
       Generic.method("abc");
       Generic.method('a');
       Generic.method(true);
       Generic.method(12.3);
       Generic.method(new String("张三"));
        System.out.println("===========");
        String s = Generic.method1("1234");
        System.out.println(s);
        Integer intNumber = Generic.method1(123);
        System.out.println(intNumber);

    }
}

泛型接口

public interface GenericInterface <A>{
    public void method(A a);
}

接口实现

public class GenericInterfaceImpl implements GenericInterface<String> {
    @Override
    public void method(String s) {
    }
}

public class GenericInterfaceImpl02<A> implements GenericInterface<A> {
    @Override
    public void method(A a) {

    }
}

接口的测试

public class GenericTest {
    public static void main(String[] args) {
        /**
         *    MyInterface接口的实现类
         *         之前实现接口，在实现类中直接重写抽象方法即可
         *         现在实现的接口，该接口上有泛型的
         *
         *         两种格式：
         *             1. 实现该接口时，能确定接口泛型的数据类型是什么了
         *             2. 实现该接口时，不能确定接口泛型的数据类型是什么，该实现类上要写泛型
         */
        GenericInterfaceImpl genericInterface = new GenericInterfaceImpl();
        genericInterface.method("ssss");

        GenericInterfaceImpl02<String> stringGenericInterfaceImpl02 = new GenericInterfaceImpl02<>();
        stringGenericInterfaceImpl02.method("字符串");
    }
}

泛型通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。

通配符的高级使用--受限泛型

之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限

泛型的上限 `类型名称 <? extends 类 > 对象名称` 只能接收该类型及该类型的子类

泛型的下限 `类型名称 <? super 类 > 对象名称` 只能接受该类型及该类型的父类型

比如以下代码：

public class GenericCase {
    public static void main(String[] args) {
        Collection<Integer> list1 = new ArrayList<Integer>();
        Collection<String> list2 = new ArrayList<String>();
        Collection<Number> list3 = new ArrayList<Number>();
        Collection<Object> list4 = new ArrayList<Object>();

        getElement1(list1);
        // getElement1(list2);
        getElement1(list3);
        // getElement1(list4);

        // getElement2(list1);
        // getElement2(list2);
        getElement2(list3);
        getElement2(list4);

    }
    // 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
    public static void getElement1(Collection<? extends Number> coll){}
    // 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
    public static void getElement2(Collection<? super Number> coll){}
}

测试类

public class GenericTest {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("abc");
        list1.add("bce");

        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(123);
        list2.add(456);
        //遍历集合
        for (String s : list1) {
            System.out.println(s);
        }
        System.out.println("============");
        for (Integer integer : list2) {
            System.out.println(integer);
        }

        System.out.println("=============");
        //两个集合遍历太过于麻烦。使用泛型来遍历
        printList(list1);
        printList(list2);
    }

         /*
       不管你的集合中存储的是什么元素类型，我只做遍历，不关心集合中元素的类型
       可以使用一个通配符，进行完成遍历的功能
       ? --> <?>

       ? 通配符的好处:
            可以遍历集合中元素的类型是任意类型的数据
         缺点:
            只能做遍历或者删除元素，不能做其它操作

     */
     public static void printList(ArrayList<?>list){
         for (int i = 0; i < list.size(); i++) {
             System.out.println(list.get(i));
         }
     }
}

File类

java.io.File 类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。

File类的构造方法

方法名	说明
public File(String pathname)	通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
public File(String parent, String child)	从父路径名字符串和子路径名字符串创建新的 File实例。
public File(File parent, String child)	从父抽象路径名和子路径名字符串创建新的 File实例。

public class FileDemo02 {
    public static void main(String[] args) {
        /**
         * File(String pathname)	            :将一个字符串路径封装成File对象
         * File(String parent,String child)     :传入一个父级路径和子级路径
         * File(File parent,String child)	    :传入一个File类型的父级路径和子级路径
         */
        File file = new File("C:\\Users\\Administrator\\Desktop\\资料\\day10泛型\\代码\\day10_file\\src\\com\\itfxp\\file\\FileDemo.java");
        System.out.println(file);
        File file1 = new File("C:\\Users\\Administrator\\Desktop\\资料\\day10泛型\\代码\\day10_file\\src\\com\\itfxp\\file", "FileDemo02.java");
        System.out.println(file1);
/**
 *         // 复制文件夹时，会用到路径的拼接
 *         // 做路径拼接时，经常会用到File类中的静态常量：separator : \  /
 *         // 这个地方动态的获取当前系统的文件或目录的路径的分隔符
 *         // Z:+File.separator + upload + File.separator + 1.jpg
 *         // File(File parent,String child)	    :传入一个File类型的父级路径和子级路径
 */
        File file2 = new File("C:\\Users\\Administrator\\Desktop\\资料\\day10泛型\\代码\\day10_file\\src\\com\\itfxp\\file");
        new File(file2,"FileDemo02.java");
    }
}

注意事项：

一个File对象代表硬盘中实际存在的一个文件或者目录

无论该路径下是否存在文件或者目录，都不会影响File对象的创建

File获取功能方法

方法名	说明
public String getAbsolutePath()	返回此File的绝对路径名字符串。
public String getPath()	将此File转换为路径名字符串
public String getName()	返回由此File表示的文件或目录的名称。
public long length()	返回由此File表示的文件的长度。

public class FileGetMethod {
    public static void main(String[] args) {
        /**
         * public String getAbsolutePath()返回此File的绝对路径名字符串。
         * public String getPath()将此File转换为路径名字符串
         * public String getName()返回由此File表示的文件或目录的名称。
         * public long length()返回由此File表示的文件的长度。
         * String getParent()      ：返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
         * File getParentFile()    ：返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录，则返回 null。
         */
        File file = new File("D:\\jdk\\conf\\sound.properties");
        //public String getAbsolutePath()返回此File的绝对路径名字符串。
        String absolutePath = file.getAbsolutePath();
        System.out.println(absolutePath);
        //public String getPath()将此File转换为路径名字符串
        String path = file.getPath();
        System.out.println(path);
        //public String getName()返回由此File表示的文件或目录的名称。
        String name = file.getName();
        System.out.println(name);
        //public long length()返回由此File表示的文件的长度。
        long length = file.length();
        System.out.println(length);

        //String getParent()      ：返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
        String parent = file.getParent();
        System.out.println(parent);

        //File getParentFile()    ：返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录，则返回 null。
        File parentFile = file.getParentFile();
        System.out.println(parentFile);
    }
}

File的绝对路径和相对路径

绝对路径：从盘符开始的路径，是一个完整的路径

相对路径：相对于项目目录的路径，是一个便捷的路径，开发中经常用相对路径

public class PathTest {
    public static void main(String[] args) {
        /**
         * 绝对路径：从盘符开始的路径
         * 相对路径：相对于项目目录的路径，是一个便捷的路径，开发中经常使用
         */
        //盘符下的路径
        File file = new File("d:\\qq\\a.txt");
        System.out.println(file.getAbsoluteFile());
        //项目中的路径
        File file1 = new File("day120427\\code\\file\\path.txt");
        System.out.println(file1.getAbsoluteFile());

    }
}

File的判断功能的方法

方法名	说明
public boolean exists()	此File表示的文件或目录是否实际存在。
public boolean isDirectory()	此File表示的是否为目录。
public String getName()	返回由此File表示的文件或目录的名称。

public class JudgeTest {
    public static void main(String[] args) {
        /**
         * public boolean exists()此File表示的文件或目录是否实际存在。
         * public boolean isDirectory()此File表示的是否为目录。
         * public String getName()返回由此File表示的文件或目录的名称。
         * boolean isHidden()   : 判断当前路径是否是隐藏文件
         */
        //public boolean exists()此File表示的文件或目录是否实际存在。
        File file = new File("D:\\jdk\\conf\\logging.properties");
        boolean flag = file.exists();
        System.out.println(flag);//true
        //不存在的文件
        File file1 = new File("D:\\test.txt");
        boolean exists = file1.exists();
        System.out.println(exists);//false

        //public boolean isDirectory()此File表示的是否为目录。
        boolean isFlag = file.isDirectory();
        System.out.println(isFlag);//不是目录。是一个文件
        File file2 = new File("D:");
        boolean directory = file2.isDirectory();
        System.out.println(directory);//D盘是一个目录

        //public String getName()返回由此File表示的文件或目录的名称。
        String name = file.getName();//logging.properties
        System.out.println(name);

        String name1 = file2.getName();
        System.out.println(name1);//无字天书，不显示D：

        //boolean isHidden()   : 判断当前路径是否是隐藏文件
        boolean hidden = file.isHidden();
        System.out.println(hidden);//false

    }
}

File创建删除功能的方法

方法名	说明
public boolean createNewFile()	当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
public boolean delete()	删除由此File表示的文件或目录。
public boolean mkdir()	创建由此File表示的目录。
public boolean mkdirs()	创建由此File表示的目录，包括任何必需但不存在的父目录。

public class EstablishDeleteTest {
    public static void main(String[] args) throws IOException {
        /**
         * public boolean createNewFile()当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
         * public boolean delete()删除由此File表示的文件或目录。
         * public boolean mkdir()创建由此File表示的目录。
         * public boolean mkdirs()创建由此File表示的目录，包括任何必需但不存在的父目录。
         */
        //public boolean createNewFile()当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
        //创建文件
        File file = new File("java.text");
        System.out.println(file.exists());//是否存在  false
        System.out.println(file.createNewFile()); //创建
        System.out.println(file.exists());//是否存在 true

        //创建目录
        File jdbc = new File("jdbc");
        System.out.println(jdbc.exists());//是否存在 false
        System.out.println(jdbc.mkdir());//创建目录  创建
        System.out.println(jdbc.exists());//是否存在 true

        //创建多级目录
        File file1 = new File("newDir\\newTest");
        System.out.println(file1.mkdir());//false
        File file2 = new File("newDir\\newTest");
        System.out.println(file2.mkdirs());//true

        //public boolean delete()删除由此File表示的文件或目录。
        System.out.println(file.delete());//true
        System.out.println(jdbc.delete());//true
        System.out.println(file1.delete());//true

        System.out.println(file2.delete());
    }
}

File目录的遍历

方法名	说明
public String[] list()	返回一个String数组，表示该File目录中的所有子文件或目录。
public File[] listFiles()	返回一个File数组，表示该File目录中的所有的子文件或目录。

public class FileFor {
    public static void main(String[] args) {
        /**
         * public String[] list()返回一个String数组，表示该File目录中的所有子文件或目录。
         * public File[] listFiles()返回一个File数组，表示该File目录中的所有的子文件或目录。
         * static File[] listRoots() :获取计算机中所有的盘符
         */
        //public String[] list()返回一个String数组，表示该File目录中的所有子文件或目录。
        File file = new File("D:\\jdk\\conf");
        String[] list = file.list();
        for (String s : list) {
            System.out.println(s);
        }

        //public File[] listFiles()返回一个File数组，表示该File目录中的所有的子文件或目录。
        File[] files = file.listFiles();
        for (File file1 : files) {
            System.out.println(file1);
        }
        //调用listFiles方法的File对象，表示的必须是实际存在的目录，否则返回null，无法进行遍历。

        //static File[] listRoots() :获取计算机中所有的盘符
        File[] files1 = File.listRoots();
        for (File file1 : files1) {
            System.out.println(file1);
        }
    }
}

注意：调用listFiles方法的File对象，表示的必须是实际存在的目录，否则返回null，无法进行遍历

递归

递归是指在当前方法内调用自己；分为直接递归和间接递归

注意事项：递归一定有条件限定，保证递归能停止下来，否则会发生栈内存溢出

在递归中虽然有条件限定，但是递归次数不能太多，否则也会发生栈内存溢出

构造方法禁止递归。

递归的小练习

public class Recursion {
    public static void main(String[] args) {
        /**
         * 使用递归求5的阶乘
         */
        int sum = getSum(5);
        System.out.println(sum);
    }
    public static int getSum(int num){
        if (num == 1){
            return 1;
        }
        return num*getSum(num-1);
    }
}

递归打印多级目录

public class RecursionTest01 {
    public static void main(String[] args) {
        /**
         * 递归打印多级目录
         *  案例演示: 找出一个文件夹下所有的文件和文件夹(包含子目录)
         *
         * 假设给的一个目录的路径day10_file目录路径
         */

        //创建File对象
        File file = new File("day140427");
        printFileName(file);

    }
    public static void printFileName(File file){
        //获取该目录下所有的文件及目录
        File[] files = file.listFiles();
        //遍历文件数组
        for (File file1 : files) {
            //如果该file1是一个文件直接输出
            if (file1.isFile()){
                System.out.println(file1);
                //如果该file1是一个目录递归调用printFileName方法
            }else if (file1.isDirectory()){
                printFileName(file1);
            }
        }
    }
}

File与递归综合练习

public class RecursionTest02 {
    public static void main(String[] args) {
        /**
         * 综合案例之多级目录搜索
         *      案例演示: 找出一个文件夹下所有的.java文件(包含子目录)
         */
        File file = new File("day140427");
        printFileName(file);
    }
    public static void printFileName(File file){
        File[] files = file.listFiles();
        for (File file1 : files) {
            //如果file1是一个文件
            if (file1.isFile()){
                //如果file1.getName是以.java结尾的，则输出
                if (file1.getName().endsWith(".java")){
                    System.out.println(file1);
                }
            }else {
                printFileName(file1);
            }
        }
    }
}