以下内容为之前的补充以及后续的扩展

常用类

方法重写

/**
 * 
 *   对于一个方法而言： 区分方法 通过方法名找方法  通过参数列表来确定方法
 *   方法重写：
 *      发生继承关系、实现关系  父类不满足子类的需求  子类重写父类中的方法
 *   
 *   什么情况下会发生重写？
 *      1：发生继承
 *      2：方法名同名
 *      3：参数列表要一模一样  (顺序 个数 类型)
 *      4：子类的返回值类型<=父类的返回值类型(引用)  基本类型一模一样
 *      5：子类的修饰符>=父类的修饰符  (父类中的修饰符不能是private)
 *      6：子类抛出的异常<=父类抛出的异常  (理解：可以认为任意一个方法都会对外抛出运行时异常)
 *      参一反小修大异小
 */

public class Test01 {
    public static void main(String[] args) {
        
    }
}
class F{
    F fun(F s) {
        System.out.println(1/0);
        return null;
    }
}
class S extends F{
    public S fun(F s)throws NullPointerException{
        return null;
    }
}

Scanner

/*
 *  学习使用Scanner
 *      hasNextXXX   获取扫描到的数据是否是XXX类型
 *      nextXXX      获取下一个扫描到的内容转为XXX类型(转换过程中有可能存在问题)
 */

public class Test01 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        if(sc.hasNextInt()) {
            System.out.println(sc.nextInt());
        }
        if(sc.hasNext()) {
            System.out.println(sc.next());
        }
        
        //重新创建Scanner对象 指定文件为输入源
        Scanner input = new Scanner("");
        System.out.println(input.next());
    }
}

Objects

/*
 * isNull:判定对象是否为null
 * toString：输出对象的
 * requireNonNull 判定对象是否为null 如果是null则抛出空指针异常不是null就打印相应的值
 */

public class Test01 {
    public static void main(String[] args) {
        String str = null;
        //System.out.println(str.toString());
        
        if(!Objects.isNull(str)) {
            System.out.println(str.toString());
        }
        
        System.out.println(Objects.toString(str));
        
        foo(str);
    }

    private static void foo(String str) {
        System.out.println(Objects.requireNonNull(str));
    }
}

字符串

String

String的构建

/**
 *   String：
 *        字符串： 一组字符序列    (不可变的串)
 *      创建String对象：
 *          new String();
 *          new String("abc");
 *          "love";
 *          new String(buf,2,2);//通过字节数组创建
 *      
 *   StringBuffer
 *   StringBuilder(jdk1.5之后才有的)
 * @author wawjy
 *
 */

public class Test01 {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //String构造器
        String str1 = new String();//new一个对象
        System.out.println(str1);
        
        //通过双引号直接创建String对象
        String str2 = "liuhang";
        System.out.println(str2);//通过字符串常量直接给String对象赋值
        
        //比较str1和str2
        String str3="";
        System.out.println(str1==str3);
        
        //按照字节数组创建字符串对象
        byte[] b = new byte[] {65,67,64,98};
        String str4 = new String(b);
        System.out.println("通过字节数组创建字符串"+str4);
        str4 = new String(b,2,2);//截取索引为2开始的2个长度的字符串
        System.out.println("通过字节数组创建字符串"+str4);
        
        str4 = new String(b,2,2,"UTF-8");
        System.out.println("通过字节数组创建字符串"+str4);
    
        
        //按照字符数组创建字符数组
        char[] c = new char[] {'刘','杭','最','大','气','了'};
        str4 = new String(c);
        System.out.println("通过字符数组创建字符串"+str4);
        str4 = new String(c,0,2);//截取索引为0开始的2个长度的字符串
        System.out.println("通过字符数组创建字符串"+str4);
        
        //按照代码点创建字符串数组
        int[] i = new int[] {88,89,100,99};
        str4 = new String(i,0,3);//截取索引为0开始的3个长度的字符串
        System.out.println("通过代码点创建字符串"+str4);
        
        //按照字符串对象创建字符串对象
        String str5 = new String("asdasd");
        System.out.println("通过字符串对象创建字符串"+str5);
    }
}

String的常见方法

public class Test02 {
    public static void main(String[] args) {
        
        //创建一个String对象
        String str = "ilivezhangke";
        //charAt(int index)
        char ch1 = str.charAt(0);
        System.out.println("返回当前索引位置上的指定字符："+ch1);
        
        //charPointAt(int index)
        int num = str.codePointAt(0);
        System.out.println("返回当前指定索引位置上元素的代码点："+num);
        
        //compareTo(String)
        String cStr = "ilovebasketball";
        num = str.compareTo(cStr);
        System.out.println("比较两个字符串的大小："+num);
        
        //compareToIgnoreCase(String)
        cStr = "ILOVEYOUVERYMUCH";
        num = str.compareToIgnoreCase(cStr);
        System.out.println("比较两个字符串的大小（忽略大小写）："+num);
        
        //concat(String)
        cStr = "shuaiqi";
        str = str.concat(cStr);
        System.out.println("拼接之后的结果是："+str);
        
        //copeValueOf(char[])
        char[] ch2 = new char[] {'i','l','o','v','e'};
        str = String.copyValueOf(ch2);
        System.out.println("创建新的字符串："+str);
        
        str = String.copyValueOf(ch2, 0, 2);//从索引0开始截取两个长度的字符串
        System.out.println("创建新的字符串："+str);
        
        str = "adi.aavi";
        boolean flag = str.endsWith(".aavi");
        System.out.println("str是否是.aavi格式"+flag);
        
        //getBytes
        byte[] buf = str.getBytes();
        System.out.println("获取字符串的字节数组："+Arrays.toString(buf));
        
        
        //indexOf  返回负数代表未找到
        str = "heihe.i.avi";
        int index = str.indexOf(".");
        System.out.println(".在string中第一次出现的位置是："+index);
        
        
        index = str.indexOf(101);
        System.out.println("e在string中第一次出现的位置是："+index);
        
        index = str.indexOf(".",5);
        System.out.println(".在string中第五个索引位置开始计算，第一次出现的位置是："+index);
        
        index = str.lastIndexOf(".");
        System.out.println(".在string中最后一次出现的位置是："+index);
        
        //isEmpty()
        System.out.println("查看数组是否为null："+str.isEmpty());
        
        //replace  代替
        str = "asdsdkj";
        str = str.replace("a","c");
        System.out.println("替换后的结果为："+str);
        
        //splite:  切割
        str = "login?uname=zs&pwd=zs";
        String[] strs = str.split("\\?");//以”？“为分割线进行分割
        for(String string:strs) {
            System.out.println(string);
        }
        
        System.out.println("====");
        String parms = strs[1];
        strs = parms.split("&");
        for(String str1 : strs) {
            String[] ss = str1.split("=");
            System.out.println(ss[1]);
        }
        
        
        //subString
        str = "login?uname=zs&pwd=zs";
        str = str.substring(4);//从4索引开始截取到最后
        System.out.println("截取字符串："+str);
        str = str.substring(1, 3);//从索引1开始到索引3但是不包括3为止
        System.out.println("截取字符串："+str);
        
        //大小写转换
        str = "login?uname=zs&pwd=zs";
        str = str.toUpperCase();
        System.out.println("转为大写为："+str);
        str = str.toLowerCase();
        System.out.println("转为小写为："+str);
        
        
        //通过静态方法创建String对象
        String str1 = String.valueOf(123);
        System.out.println(str1);
        
        //对象转字符串其实就是调用当前对象的toString方法
        User u = new User(10);
        String str2 = String.valueOf(u);
        System.out.println(str2);
    }
}
class User{
    @Override
    public String toString() {
        return "User [age=" + age + "]";
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    private int age;

    public User(int i) {
        super();
        // TODO Auto-generated constructor stub
    }
    
}

String面试题

//由于String不可变 所以经过方法不会发生改变 
public class Test03 { 
    public static void main(String[] args) { 
        String str = "123"; 
        System.out.println(str);
        change(str);
        System.out.println(str);
    }
    public static void change(String str) {
        str = "234"; 
    } 
}

//intern 获取到的是当前String对象 的地址
public class Test01 {
    public static void main(String[] args) {
        String str1 = "cat";
        String str2 = "cat";
        String str3 = new String("cat");
        
        System.out.println(str1==str2);
        System.out.println(str1==str3);
        
        String str4 = str1.intern();
        System.out.println(str1==str4);
        System.out.println(str2==str4);
        System.out.println(str3==str4);
    }
}

/*
 * 
 *  1: new  堆开空间
 *  2： "zhangsan"  常量池
 *  3：+号拼接：
 *      左右两边操作数如果是字面值  则直接拼接之后再常量池开空间
 *      如果左右两边操作数是变量 则通过常量值重新分配空间 存储变量地址 
 */

public class Test02 {
    public static void main(String[] args) {
        String s1 = "Cat";
        String s2 = "Dog";
        final String s3 = s1+s2;
        String s4 = "CatDog";
        String s5 = "Cat"+"Dog";
        System.out.println(s3==s4);
        System.out.println(s5==s4);
    }
}

Stringbuffer

/**
 *  StringBuffer :
 *          之所以能够可变的原因，底层就是一个字符数组，动态数组。
 *          调用关系画出来。         
 *  StringBuilder    1.5之后
 */

public class Test04 {
    public static void main(String[] args) {
        //创建StringBuffer对象
        StringBuffer sb = new StringBuffer();
        //默认容量为16
        System.out.println("通过空构造器创建的StringBuffer的容量为16");
        
        //添加元素
        sb.append(true);
        sb.append(false).append("232").append("asd");//链式编程
        System.out.println(sb);
        System.out.println("当前sb对象的字符串长度为："+sb.length());
        
        //添加元素
        sb.insert(1, "asa");
        System.out.println(sb);
    }
}

StringBuilder

/**
 *   StringBuilder和StringBuffer 都继承了AbstractStringBuilder
 *   
 *   StringBuffer效率低于StringBuilder
 *   StringBuffer安全性要高于StringBuilder
 *      一般情况下使用StringBuilder  
 
 *   jdk9之后  String中存储数据通过byte数组存储 + 变量
 *   jdk中对于String存储时的内容消耗极大降低
 */
public class Test05 {
    public static void main(String[] args) {
        //StringBuilder
        StringBuilder sb = new StringBuilder();//构建16个长度的字符数组
        //添加元素
        sb.append("sd");
        sb.insert(0, "21312");
        System.out.println(sb);
    }
}

性能比较

第一种用例：拼接相同的字符串数量固定

public class StringConcat {
    public static void main(String[] args) {
        plus();
        concat();
        stringBuffer();
        stringBuilder();
    }

    public static void plus(){
        String initial = "";
        long start = System.currentTimeMillis();
        for(int i = 0; i < 100000; i++){
            initial = initial + "a";
        }
        long end = System.currentTimeMillis();
        System.out.println("plus:" + (end - start));
    }

    public static void stringBuilder(){
        StringBuilder initial = new StringBuilder("");
        long start = System.currentTimeMillis();
        for(int i = 0; i < 100000; i++){
            initial = initial.append("b");
        }
        long end = System.currentTimeMillis();
        System.out.println("StringBuilder:" + (end - start));

    }

    public static void stringBuffer(){
        StringBuffer initial = new StringBuffer("");
        long start = System.currentTimeMillis();
        for(int i = 0; i < 100000; i++){
            initial = initial.append("c");
        }
        long end = System.currentTimeMillis();
        System.out.println("StringBuffer:" + (end - start));
    }
    public static void concat(){
        String initial = "";
        long start = System.currentTimeMillis();
        for(int i = 0; i < 100000; i++){
            initial = initial.concat("d");
        }
        long end = System.currentTimeMillis();
        System.out.println("concat:" + (end - start));
    }
}
结果：
plus:5328
concat:2220
StringBuffer:12
StringBuilder:0
当拼接相同字符串时性能由好到差为：StringBuilder，StringBuffer，concat，“+”

第二种用例：拼接不同的字符串但是数量相同

public class StringConcat {
    public static void main(String[] args) {
        plus();
        concat();
        stringBuffer();
        stringBuilder();
    }

    public static void plus() {
        Long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            String a = "a";
            a = a + String.valueOf(i);
        }
        Long end = System.currentTimeMillis();
        System.out.println("double plus:" + (end - start));
    }

    public static void stringBuilder() {
        Long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            StringBuilder b = new StringBuilder("b");
            b.append(String.valueOf(i));
        }
        Long end = System.currentTimeMillis();
        System.out.println("double StringBuilder:" + (end - start));
    }

    public static void stringBuffer() {

        Long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            StringBuffer c = new StringBuffer("c");
            c.append(String.valueOf(i));
        }
        Long end = System.currentTimeMillis();
        System.out.println("double StringBuffer:" + (end - start));
    }

    public static void concat() {
        Long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            String d = "d";
            d = d.concat(String.valueOf(i));
        }
        Long end = System.currentTimeMillis();
        System.out.println("double concat:" + (end - start));
    }
}
结果：
double plus:72
double concat:23
double StringBuffer:32
double StringBuilder:26
当拼接不相同字符串且数量相同时性能由好到差为：concat，StringBuilder，StringBuffer，“+”

包装类

Integer

/*
 *   包装类：
 *      8大基本数据类型  ->  8个包装类 
 *      byte->Byte
 *      short->Short
 *      char ->Character
 *      int  ->Integer
 *      long ->Long
 *      float->Float
 *      double->Double
 *      boolean->Boolean
 *   
 *   jdk12 Integer中的所有构造器都过时 通过valueOf方法获取int对应的Integer对象
 *   
 *   String->int  Integer.parseInt();// 可能报异常
 *   int ->String    String.valueOf()
 *   
 *   
 */

public class Test01 {
    public static void main(String[] args) {

        // 静态成员变量
        System.out.println("BYTES:" + Integer.BYTES);
        System.out.println("MAXVALUE:" + Integer.MAX_VALUE);
        System.out.println("MINVALUE:" + Integer.MIN_VALUE);
        System.out.println("SIZE" + Integer.SIZE);
        System.out.println("CLASS:" + Integer.TYPE);

        // 构造器
        Integer i1 = new Integer(12);
        System.out.println(i1);

        Integer i2 = new Integer("123");// 可能出现数字格式化异常
        System.out.println(i2);

        System.out.println(Integer.max(12, 12));

        // parseInt(String)字符串转换为int
        System.out.println("字符串转换为int" + Integer.parseInt("212"));
        // 将一个对应进制的数转换为十进制
        System.out.println("字符串转换为int" + Integer.parseInt("1100", 2));
        // 将当前数值在计算机中存储的补码进行翻转得到的十进制的数
        System.out.println("" + Integer.reverse(Integer.MAX_VALUE));

        System.out.println("2进制：" + Integer.toBinaryString(12));
        System.out.println("8进制：" + Integer.toOctalString(12));

        // 获取Integer对象
        Integer i3 = Integer.valueOf(12);
        System.out.println(i3);

        Integer i4 = Integer.valueOf("12");
        System.out.println(i4);
        System.out.println(Integer.class);
        System.out.println(Integer.decode("12"));
    }
}

/**
 * 
 * @author wawjy
 *  jdk1.5之后支持自动拆装箱，本质上就是调用了 
 *          装箱：Integer.valueOf()
 *          拆箱：对象.intValue()
 *  
 *   自动装箱时，首先会判定当前的值是否在缓冲区中[-128,127],如果在该区间中，直接从缓冲区中获取对应的Integer对象
 *      反之会重新创建一个新的Integer对象
 */

public class Test02 {
    public static void main(String[] args) {
        Integer i1 = 123;//jdk1.5之后支持自动装箱 Integer.valueOf(123)
        int num = i1;//jdk1.5之后支持自动拆箱 i1.intValue()
        
        Integer i2 = 98;
        Integer i3 = 98;
        System.out.println(i2==i3);
        
        i2 = 128;
        i3= 128;
        System.out.println(i2==i3);
    }
}

Boolean

/*
 *    字面值创建Boolean对象时 只能指定true和false 并且创建的对象也是对应的true和false
 *    字符串创建Boolean对象是 只要字符是true/false 无所谓大小写 得到对应的Boolean对象就是与之对应的true和false
 *    其它所有字符串赋值都是false
 * 
 */

public class Test03 {
    public static void main(String[] args) {
        //创建Boolean对象
        Boolean b1 = new Boolean("true");
        System.out.println(b1);
        
        b1 = new Boolean("false");
        System.out.println(b1);
        
        b1 = new Boolean("2");
        System.out.println(b1);
        
        b1 = new Boolean("TRue");
        System.out.println(b1);
        
        b1 = new Boolean("HJa");
        System.out.println(b1);
        
        b1 = new Boolean("FALSE");
        System.out.println(b1);
    }
}

Date

/* 
 *   和时间有关的类
 *          Date:
 *              空构造器对象创建出的是当前系统时间对象
 */

public class Test01 {
    public static void main(String[] args) {
        
        
        //创建Date对象
        Date d = new Date();
        System.out.println(d);//空构造器对象创建出的是当前系统时间对象
        
        //通过带参构造器创建对象
        Date d1 = new Date(3600);//参数代表毫秒数
        System.out.println(d1);//此时间为1970年加上系统设置的时区再加上参数
        
        System.out.println(d.after(d1));
        System.out.println(d.before(d1));
        
        //获取毫秒数
        Long dateTime = System.currentTimeMillis();
        System.out.println(dateTime);
        
    }
}

SimpleDateFormat

ublic class Test02 {
    public static void main(String[] args) throws Exception {
        //创建对象
        File f = new File("C:\\Users\\HangBaTua\\AppData\\Roaming\\feiq\\Recv File");
        
        System.out.println("查看是否可执行："+f.canExecute());
        System.out.println("查看是否可写："+f.canWrite());
        System.out.println("查看是否可读："+f.canRead());
        System.out.println(f.delete());
        
        File ff = new File("C:\\Users\\HangBaTua\\AppData\\Roaming\\feiq\\Recv Files");
        //比较的path
        System.out.println(ff.compareTo(f));
        //获取路径
        System.out.println(f.getPath());
        //获取路径是否存在
        System.out.println(f.exists());
        //获取绝对路径
        System.out.println(f.getAbsolutePath());
        //创建文件，确保路径是否存在
        System.out.println(f.createNewFile());
        //
        System.out.println(ff.equals(f));
        System.out.println("是否是绝对路径："+f.isAbsolute());
        //获取绝对路劲
        System.out.println("获取绝对路径："+f.getAbsolutePath());
        System.out.println("获取文件名称："+f.getName());// 获取文件名称
        System.out.println("获取父级目录："+f.getParent());
        System.out.println("获取相对路径(项目根目录)："+f.getPath());
        f = new File("c:\\");
        System.out.println("获取剩余大小："+f.getFreeSpace());
        System.out.println("获取总共大小："+f.getTotalSpace());
        System.out.println("获取可用大小："+f.getUsableSpace());
        System.out.println("是否是绝对路径："+f.isAbsolute());
        
        //获取最后一次修改的时间
        long l = f.lastModified();
        /*
         * Date d = new Date(l); SimpleDateFormat sd = new
         * SimpleDateFormat("yyyy/MM/dd hh:mm"); String str = sd.format(d);
         * System.out.println(str);
         */
        System.out.println(new SimpleDateFormat("yyyy/MM/dd hh:mm:ss").format(new Date(l)));
        //获取里面的字节数
        System.out.println(f.length());
        
        f = new File("c:\\");
        //获取c盘下的文件目录
        String[] strs = f.list();
        for(String str:strs) {
            System.out.println(str);
        }
        
        System.out.println("========");
        
        //获取c盘下的文件以及字节数
        File[] fs = f.listFiles();
        for(File fff : fs) {
            System.out.println(fff.getName()+"==="+fff.length());
        }
        download();
        
    }
    public static void download() throws Exception {
        File d = new File("C:\\Users\\HangBaTua\\AppData\\Roaming\\feiq\\Recv Files");
        //在指定文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。
        File temp = File.createTempFile("asdsad", ".avi",d);
        TimeUnit.SECONDS.sleep(2);
        temp.deleteOnExit();
    }
}

Calender

创建方式

public class Test01 {
    public static void main(String[] args) {
        //创建对象
        Calendar c = Calendar.getInstance();
        
        System.out.println(c);
        
        Date d = new Date(1564032018853L);
        SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        String str = sd.format(d);
        System.out.println(str);
        
        System.out.println("获取当前日历中的天："+c.get(Calendar.DATE));
        System.out.println("获取当前日历中的天："+c.get(Calendar.DAY_OF_MONTH));
        System.out.println(c.get(Calendar.DAY_OF_WEEK));//星期从星期天开始 星期天是第一天
        System.out.println(c.get(Calendar.MONTH));
        System.out.println(c.get(Calendar.APRIL));
        System.out.println(c.get(Calendar.AUGUST));
        System.out.println(c.get(Calendar.DAY_OF_WEEK_IN_MONTH));
        System.out.println(c.get(Calendar.ERA));
        System.out.println(c.get(Calendar.HOUR_OF_DAY));
        System.out.println(c.get(Calendar.PM));
        System.out.println(c.get(Calendar.ZONE_OFFSET));
        System.out.println(c.get(Calendar.MONTH));
    }
}

常用方法

public class Test02 {
    public static void main(String[] args) {
        //创建对象
        Calendar c = Calendar.getInstance();
        System.out.println(c);//输出当前时间
        //add累加会增位即：当时间是七月二十五时加13天它会变成八月七号
        c.add(Calendar.DAY_OF_MONTH, 13);
        System.out.println(c.get(Calendar.DAY_OF_MONTH));
        System.out.println(c.get(Calendar.MONTH));
        
        c = Calendar.getInstance();
        //roll  不会增位
        c.roll(Calendar.DAY_OF_MONTH, 13);
        System.out.println(c.get(Calendar.DAY_OF_MONTH));
        System.out.println(c.get(Calendar.MONTH));
        
        System.out.println("=======");
        
        c = Calendar.getInstance();
        //传入参数如果是当前月份之内的天数则设置位指定的日期，如果传入的是超过了字段值的数则会增位
        c.setLenient(true);
        c.set(Calendar.DAY_OF_MONTH,32);
        System.out.println(c.get(Calendar.DAY_OF_MONTH));
        System.out.println(c.get(Calendar.MONTH));
    }
}

编写万年历

public class PrintCalendar {    
    public PrintCalendar(int year,int month,int day) {
        c.set(Calendar.YEAR, year);
        c.set(Calendar.MONTH, month-1);
        c.set(Calendar.DAY_OF_MONTH, day);
    }

        System.out.println("天\t一\t二\t三\t四\t五\t六");
        //设置当前日期对象的第一天为当前日历对象
        c.set(Calendar.DAY_OF_MONTH, 1);
        //获取当前月份第一天是周几
        int blankCount = c.get(Calendar.DAY_OF_WEEK)-1;
        //打印空格
        for(int i = 0;i<blankCount;i++) {
            System.out.print(" \t");
        }
        
        //准备打印日期
        //获取当前月份中天数的最大值
        int days = c.getActualMaximum(Calendar.DAY_OF_MONTH);
        //循环
        for(int i=1;i<=days;i++) {
            if(day==c.get(Calendar.DAY_OF_MONTH)) {
                System.out.print("*");
            }
            System.out.print(i+"\t");
            
            if(c.get(Calendar.DAY_OF_WEEK)==Calendar.SATURDAY) {
                System.out.println();
            }
            //改变日历
            c.set(Calendar.DAY_OF_MONTH, i+1);
        }
        
    }

File

构造器

*
 *   file:
 *          抽象的路径以及文件
 *          1：创建对象是 无需注意当前路径或者是文件是否存在 都会创建出来
 *          2：和平台无关的路径分隔符
 *              File.pathSeparator路径结束符
 *              File.separator路径分割符
 */
public class Test01 {
    public static void main(String[] args) {
        //创建一个File对象
        File f = new File("C:\\Users\\HangBaTua\\AppData\\Roaming\\feiq\\Recv Files");
        System.out.println(f);
        
        System.out.println(File.pathSeparator);
        System.out.println(File.pathSeparatorChar);
        System.out.println(File.separator);
        System.out.println(File.separatorChar);
        f = new File("C:"+File.separator+"Users"+File.separatorChar+"wawjy"+File.separatorChar+"Desktop");
        System.out.println(f);
    }
}

常见方法

ublic class Test02 {
    public static void main(String[] args) throws Exception {
        //创建对象
        File f = new File("C:\\Users\\HangBaTua\\AppData\\Roaming\\feiq\\Recv File");
        
        System.out.println("查看是否可执行："+f.canExecute());
        System.out.println("查看是否可写："+f.canWrite());
        System.out.println("查看是否可读："+f.canRead());
        System.out.println(f.delete());
        
        File ff = new File("C:\\Users\\HangBaTua\\AppData\\Roaming\\feiq\\Recv Files");
        //比较的path
        System.out.println(ff.compareTo(f));
        //获取路径
        System.out.println(f.getPath());
        //获取路径是否存在
        System.out.println(f.exists());
        //获取绝对路径
        System.out.println(f.getAbsolutePath());
        //创建文件，确保路径是否存在
        System.out.println(f.createNewFile());
        //
        System.out.println(ff.equals(f));
        System.out.println("是否是绝对路径："+f.isAbsolute());
        //获取绝对路劲
        System.out.println("获取绝对路径："+f.getAbsolutePath());
        System.out.println("获取文件名称："+f.getName());// 获取文件名称
        System.out.println("获取父级目录："+f.getParent());
        System.out.println("获取相对路径(项目根目录)："+f.getPath());
        f = new File("c:\\");
        System.out.println("获取剩余大小："+f.getFreeSpace());
        System.out.println("获取总共大小："+f.getTotalSpace());
        System.out.println("获取可用大小："+f.getUsableSpace());
        System.out.println("是否是绝对路径："+f.isAbsolute());
        
        //获取最后一次修改的时间
        long l = f.lastModified();
        /*
         * Date d = new Date(l); SimpleDateFormat sd = new
         * SimpleDateFormat("yyyy/MM/dd hh:mm"); String str = sd.format(d);
         * System.out.println(str);
         */
        System.out.println(new SimpleDateFormat("yyyy/MM/dd hh:mm:ss").format(new Date(l)));
        //获取里面的字节数
        System.out.println(f.length());
        
        f = new File("c:\\");
        //获取c盘下的文件目录
        String[] strs = f.list();
        for(String str:strs) {
            System.out.println(str);
        }
        
        System.out.println("========");
        
        //获取c盘下的文件以及字节数
        File[] fs = f.listFiles();
        for(File fff : fs) {
            System.out.println(fff.getName()+"==="+fff.length());
        }
        download();
        
    }
    public static void download() throws Exception {
        File d = new File("C:\\Users\\HangBaTua\\AppData\\Roaming\\feiq\\Recv Files");
        //在指定文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。
        File temp = File.createTempFile("asdsad", ".avi",d);
        TimeUnit.SECONDS.sleep(2);
        temp.deleteOnExit();
    }
}

编写DIR

public class Test04 {
    public static void main(String[] args) {
        //创建file对象
        File file = new File("c:\\");
        //获取当前file中的所有目录对象
        File[] fs = file.listFiles();
        //迭代所有file
        for(File f : fs ) {
            //获取最近修改的时间
            String dateStr = new SimpleDateFormat("yyyy/MM/dd hh:mm:ss").format(new Date(f.lastModified()));
            //判断是否是一个目录
            String isDirectory = f.isDirectory()?"<DIR>":"";
            //判断是否是一个文件
            String isFile = f.isFile()?String.valueOf(f.length()):"";
            //获取名字
            String fileName = f.getName();
            //打印
            System.out.println(dateStr+"\t"+isDirectory+"\t"+isFile+"\t"+fileName);
        }
    }
}

mikdir和mikdirs区别

/**
 * mkdir 只能创建一级目录
 * 
 * @author wawjy
 *
 */
public class Test03 {
    public static void main(String[] args) throws IOException {
        File f = new File("myfile");

        // 创建路径
        File filePath = new File("myfile\\a.txt");
        filePath.mkdir();

        // 创建文件

        f.createNewFile();
        f.setReadOnly();

    }
}

IO

为什么需要IO

/*
 *  问题：
 *      1： file类本身只能针对文件或者是目录的元数据(除了内容本身)进行操作 不能对于文件中的内容做任何操作。
 *      2： 截止目前，我们存储数据的手段是很有限以及有问题的?
 *          学习过的存储手段：
 *                  变量   对象     数组---> 存储都是在内存中的--->程序启动之后 数据存在 程序销毁之后  数据丢失
 *          但是在后期真个编码、项目的过程中：
 *                  我们对于数据一定要持久的存储起来 方便后期使用以及更新
 *      3: 无法将数据持久化存储起来。
 *          解决办法： 通过学习IO流的知识 将数据写入到文件中去  或者读取文件中的数据信息
 *                 文件时存储在磁盘上的，电脑关机之后，主要文件保存，那么开机之后数据还在。
 *  IO:         
 *      IO: input output 输入输出  
 *      学习流的时候时候 流是有方向的  输入输出说的是针对谁的呢?
 */

IO流的分类

IO流的分类：独立的分类 而是相互
 *          1：按照输出的数据类型不同：
 *              字节流    输出/输入时  按照字节输出/输入
 *              字符流    输出/输入时  按照字符输出/输入
 *          2：按照流的方向
 *              输入流
 *              输出流
 *          3：按照处理功能
 *              节点流
 *              处理流

InputStream

FileInputStream

读取单个字符

/*
 *   读取数据：
 *      字节流：InputStream 是所有字节流的父类
 *      输入 ：
 *      子类：
 *          FileInputStream: 文件字节输入流   数据源在文件中  读取按照字节读取  流的方向是输入
 */

public class Test02 {
    public static void main(String[] args) throws IOException {
        //创建对象
        InputStream is = new FileInputStream(new File("C:\\Users\\HangBaTua\\Desktop\\aa.txt"));
        //读取数据
        int bit = is.read();
        //输出数据
        System.out.println(bit);
        //读取数据
        int bit1 = is.read();
        //输出数据
        System.out.println(bit1);
        //读取数据
        int bit2 = is.read();
        //输出数据
        System.out.println(bit2);
        //读取数据
        int bit3 = is.read();
        //输出数据
        System.out.println(bit3);
        //关闭资源
        is.close();
    }
}

循环读取

/*
 *  每次读取数据时 只能读一个字节，在通过read方法读取时如果
 *  读取到了文件末尾，返回-1
 *  
 *  循环读取
 *    FileInputStream 创建要保证文件存在
 * 
 */

public class Test03 {
    public static void main(String[] args) throws IOException {
        //创建对象
        InputStream is = new FileInputStream(new File("C:\\Users\\HangBaTua\\Desktop\\aa.txt"));
        //读取数据
        int num = 0;
        while((num = is.read())!=-1) {
            //分析数据
            System.out.println(num);
        }
        //关闭资源
        is.close();
    }
}

读取多个字节

/*
 * 
 *    一次性读取一个字节数组
 * 
 */
public class Test04 {
    public static void main(String[] args) throws IOException {
        //声明对象
        InputStream is = new FileInputStream(new File("C:\\Users\\HangBaTua\\Desktop\\aa.txt"));
        //读取数据源
        //声明一个字节数组
        byte[] b = new byte[1024];
        int len = is.read(b);
        
        //分析数据
        String msg = new String(b, 0, len);
        System.out.println(msg);
        //关闭资源
        is.close();
    }
}

处理异常

public class Test05 {
    public static void main(String[] args){
        //声明对象
        InputStream is = null;
        try {
            is = new FileInputStream(new File("C:\\Users\\HangBaTua\\Desktop\\aa.txt"));
            //读取数据
            byte[] b = new byte[1024];
            int len = is.read(b);
            //分析数据
            String msg = new String(b, 0, len);
            System.out.println(msg);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        //关闭资源
        try {
            is.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}

OutputStream

FileOutputStream

写出一个字符

/*
 *  字节输出流：
 *      所有字节输出流的父类都是OutputStrean
 *      
 *      子类：FileOutputStrean  输出的目的地是文件  输出流  输出的类型是字节
 *  
 *  输出时 如果文件不存在会创建该文件 但是不会创建目录
 * 
 */

public class Test06 {
    public static void main(String[] args) throws IOException {
        //创建对象
        OutputStream os = new FileOutputStream(new File("aa.txt"));
        //声明写出数据
        int num = 97;
        //写出数据
        os.write(num);
        //关闭资源
        os.close();
    }
}

写出多个字符

/**
 *  创建FileOutputStream对象时   第二个参数boolean值 
 *  说明是否在当前文件后追加内容
 *      默认情况是false 不追加 
 *              true是追加
 * 
 * @author wawjy
 *
 */

public class Test07 {
    public static void main(String[] args) throws IOException {
        //声明对象
        OutputStream os =  new FileOutputStream(new File("aaa.sa"));
        //声明写出的数据
        String msg = "ilovezhangke";
        //写出数据
        os.write(msg.getBytes(), 0, 10);
        //关闭资源
        os.close();
    }
}

编写复制粘贴

public class Test08 {
    public static void main(String[] args) throws IOException {
        CtrlCV();
    }

    public static void CtrlCV() throws IOException {

        // 1，声明复制和粘贴的文件对象
        String srcFile = "C:\\Users\\HangBaTua\\AppData\\Roaming\\feiq\\Recv Files\\io流分类.png";
        String destFile = "111.png";

        // 2，声明对象
        InputStream is = new FileInputStream(srcFile);
        OutputStream os = new FileOutputStream(destFile);

        // 3，读取文件
        int len = 0;
        while ((len = is.read()) != -1) {
            // 4，写出
            os.write(len);
        }
        // 5，关闭资源
        os.close();
        is.close();
    }

}

小白学习Java开发的第十三天

以下内容为之前的补充以及后续的扩展

常用类

方法重写

Scanner

Objects

字符串

String

String的构建

String的常见方法

String面试题

Stringbuffer

StringBuilder

性能比较

包装类

Integer

Boolean

Date

SimpleDateFormat

Calender

创建方式

常用方法

编写万年历

File

构造器

常见方法

编写DIR

mikdir和mikdirs区别

IO

为什么需要IO

IO流的分类

InputStream

FileInputStream

读取单个字符

循环读取

读取多个字节

处理异常

OutputStream

FileOutputStream

写出一个字符

写出多个字符

编写复制粘贴