JAVA核心编程教学

时间：2017-12-20 21:52:12 阅读：146 评论：0 收藏：0 [点我收藏+]

标签：index rar 乱序效率字节有关 cas 先进后出 for

常用类

? 1.1 String和StringBuffer

String类封装了对字符串的常见操作，使用频率非常高，所以应该熟练掌握，

String类的方法比较多，无需死记硬背，而是大概了解，用的时候不清楚再查手册，

有些东西用多了，就熟练了

String类常用方法：

length; indexOf; charAt; equals; replace; split; substring; trim; formate

String类的赋值：

int a = 5;
a = 3;

上面代码含义：在内存里申请一个内存单元，命名为a，赋值为3（将3存储在该内存单元上），再次赋值a为5（再把5存储在该内存单元上），这个内存单元的值在被赋值后修改了

String str1 = "abc";
str1 = "123";

应该这样理解：

String str1 = new String("abc");
str1 = new String("123");

所以对于引用来讲，赋值并非改变原引用对象的值，只是调整了引用关系

那么对于 == 运算符就要特别注意了

String str1 = new String("abc");
String str2 = new String("abc");
System.out.println(str1 == str2); //地址
System.out.println(str1.equals(str2)); //内容

运行结果

false

true

Str1和str2引用的是不同对象，所以str1 == str2为假

Str1和str2引用的字符串内容相同，所以tr1.equals(str2)为真

public static void main(String[] args) {
    String str1 = "abc";
    change(str1);
}
/**
* 将字符串中的b替换为B
* @param str1 字符串
*/
private static void change(String str1) {
    str1.replace("b","B");
    System.out.println(str1);
}

运行结果

abc

字符串并没有被修改，注意String类定义的字符串是不可更改的，此时需要用到StringBuffer类

public static void main(String[] args) {
    String str1 = "abc";
    change1(str1);
    System.out.println(str1);

    StringBuffer str2 = new StringBuffer("abc");
    change2(str2);
    System.out.println(str2);
}
/**
* 将字符串中追加一个字符
* @param str1 字符串
*/
private static void change1(String str1) {
    str1 += "123";
}
/**
* 将字符串中追加一个字符
* @param str2 字符串
* @return
*/
private static void change2(StringBuffer str2) {
    str2.append("123");
}

运行结果

abc

abc123

StringBuffer类常用方法：

append、insert、deleteCharAt、delete、replace、setCharAt、reverse

? 1.2 Array数组类

public static void main(String[] args) {
    int [] a = {1,7,3,99,16,4};
    System.out.println(Arrays.toString(a));

    int[] array1 = {2, 1, 3};
    int[] array2 = {2, 1, 3};
    int n1 = array1.length;//数组长度
    int n2 = array2.length;
    System.out.println(compareArray(n1,n2,array1,array2));

    System.out.println(Arrays.equals(array1,array2));//判断数组是否一样
    System.out.println(Arrays.toString(array1));//打印数组字符串形式

    Arrays.sort(array1);//将数组进行升序排序
    System.out.println(Arrays.toString(array1));

    int [] array3 = Arrays.copyOf(array1,array1.length+1);//复制一个数组
    System.out.println(Arrays.toString(array3));

    Arrays.fill(array3,2);//填充
    System.out.println(Arrays.toString(array3));

    Arrays.binarySearch(array3,2);//折半查找，只能用于有序数组
}
/**
*
* @param n1 array1长度
* @param n2 array2长度
* @param array1 数组array1
* @param array2 数组array2
* @return array1array2是否完全相同相等
*/
private static boolean compareArray(int n1, int n2, int[] array1, int[] array2) {
    boolean flag =true;
    if (n1==n2) {
        for (int i = 0;i<n1;i++) {
            if(array1[i]!=array2[i]){
                flag=false;
                break;
            }
        }
    }else {
        flag=false;
    }
    return flag;
}

? 1.3 Math函数

主要提供数学相关的常量和方法，方法都是静态的

常量E，PI（π）

方法：abs;ceil;floor;round;max;min;exp;log;pow;sqrt;random;三角函数

public static void main(String[] args) {
    int a = 3;
    int b = 4;
    int c = 7;
    System.out.println(Math.sqrt(a*a + b*b));   //开根
    System.out.println(Math.random());          //0--1间的随机值
    System.out.println(c/b);                    //向下取整
    System.out.println(Math.max(Math.max(a,b),c));//最大值
    System.out.println(Math.min(Math.min(a,b),c));//最小值
}

? 1.4 日期类

v Date

public static void main(String[] args) {
    Date d1 = new Date();   //当前时间（new的那一刻）
    System.out.println(d1);

    long n = d1.getTime(); //获取自1970-1-1至当前经历的毫秒数(1秒=1000毫秒
    System.out.println(n);
    n += 1000000;
    Date d2 = new Date(n);
    System.out.println(d2);

    System.out.println(new Date(0));//1970-1-1东8区8时
}

Date d = new Date();
DateFormat df1 = DateFormat.getDateInstance(DateFormat.LONG);
System.out.println(df1.format(d));
DateFormat df2 = DateFormat.getDateInstance(DateFormat.SHORT);
System.out.println(df2.format(d));

DateFormat df3 = DateFormat.getDateTimeInstance();
System.out.println(df3.format(d));

运行结果

LONG2017年12月15日

SHORT2017/12/15

GetDateTime2017年12月15日下午2:47:11

SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
System.out.println(sdf1.format(d));
SimpleDateFormat sdf2 = new SimpleDateFormat("yy年MM月");
System.out.println(sdf2.format(d));
SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd hh:mm");
System.out.println(sdf3.format(d));

运行结果

"yyyy-MM-dd" 2017-12-15

"yy年MM月" 17年12月

"yyyy-MM-dd hh:mm" 2017-12-15 02:56

v Calendar

public static void main(String[] args) {
    Calendar c = Calendar.getInstance();
    System.out.println(c);                               //所有时间及相关信息
    System.out.println(c.get(Calendar.YEAR));            //年
    System.out.println(c.get(Calendar.MONTH) +1);        //月（外国0开始）
    System.out.println(c.get(Calendar.DAY_OF_WEEK) - 1); //星期几（外国7开始）
    System.out.println(c.get(Calendar.DATE));            //日
    System.out.println("P.M."+c.get(Calendar.HOUR));     //时AMPM
    System.out.println(c.get(Calendar.HOUR_OF_DAY));     //时24
    System.out.println(c.get(Calendar.MINUTE));          //分
    System.out.println(c.get(Calendar.SECOND));          //秒
}

c.set(2017,Calendar.NOVEMBER,1); //设置年月日2017-11-1
//c.set(Calendar.YEAR,2017);c.set(Calendar.MONTH,11);c.set(Calendar.DAY_OF_MONTH,1);
c.add(Calendar.DAY_OF_MONTH,-1); //日期-1
System.out.println(c.get(Calendar.DAY_OF_MONTH)); //得到2017-10月天数

? 1.5 包装类

JAVA中提供的基本类型（int short byte long float double）等，都有对应的包装类

例如：

int →Integer

float →Float

...

为什么需要包装类

基本类型的处理和其它类型的处理是有不同的

例如：

int a = 3;

int b = 5;

a = b;

...

这种修改是直接改变了变量的值，准确的讲是存放的3个内存单元被修改了

案例：之前的泛型的通用数组

此处只能用Integer，不能用int

很多地方为了统一，尤其是用到泛型的地方，系统提供了基本类型对应的封装类

装箱：基本类型→包装类

拆箱：

集合框架

? 2.1 Vector

Vector（向量）就是动态数组

为什么需要动态数组？很多时候，我们无法事先预定数组元素个数，如果使用静态化数组，小了不够用，大了浪费空间，这时候需要动态数组

v 添加

package 教学.C103_11_Vector;
import java.util.Vector;
public class case1_添加 {
    public static void main(String[] args) {
        Vector<Integer> x1 = new Vector<>();
        System.out.println("Vector默认容量"+x1.capacity());
        System.out.println("Vector初始元素个数"+x1.size());
        x1.add(1);
        x1.add(2);
        x1.add(3);
        x1.add(4);
        x1.add(5);
        x1.add(6);
        x1.add(7);
        x1.add(8);
        x1.add(9);
        x1.add(10);
        x1.add(11);
        System.out.println("添加11个元素后，Vector默认容量"+x1.capacity());
        System.out.println("添加11个元素后，Vector初始元素个数"+x1.size());

System.out.println(x1);
}
}

Vector默认容量10

Vector初始元素个数0

添加11个元素后，Vector默认容量20

添加11个元素后，Vector初始元素个数11

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

size：元素个数

capacity：容量

add：在尾部添加元素

v 删除

package 教学.C103_11_Vector;

import java.util.Vector;

public class case2_删除 {
    public static void main(String[] args) {
        Integer a1 = new Integer(11);
        Integer a2 = new Integer(22);
        Integer a3 = new Integer(33);
        Integer a4 = new Integer(44);
        Integer a5 = new Integer(55);

        Vector<Integer> v1 = new Vector<>(4,2);
        v1.add(a1);
        v1.add(a2);
        v1.add(a3);
        v1.add(a4);
        v1.add(a5);
        System.out.println("容量："+v1.capacity());
        System.out.println("个数："+v1.size());
        System.out.println("（数组）向量："+v1);

        v1.remove(2);//删除下标为2的元素
        v1.remove(a1);//删除a1元素
        System.out.println("容量："+v1.capacity());
        System.out.println("个数："+v1.size());
        System.out.println("（数组）向量："+v1);

        v1.trimToSize();//修剪;按照现有的元素个数调整容量，元素个数=容量大小
        System.out.println("容量："+v1.capacity());
    }
}

方法

remove(int index)删除指定位置的元素

remove(Object obj)删除指定元素

trimToSize()调整容量大小

v 修改

package 教学.C103_11_Vector;
import java.util.Vector;
public class case3_修改 {
    public static void main(String[] args) {
        Integer a1 = new Integer(11);
        Integer a2 = new Integer(22);
        Integer a3 = new Integer(33);
        Integer a4 = new Integer(44);
        Integer a5 = new Integer(55);
        Vector<Integer> v1 = new Vector<>(4,2);
        v1.add(a1);
        v1.add(a2);
        v1.add(a3);
        v1.add(a4);
        v1.add(a5);
        System.out.println(v1.get(3));//找出下标为3的元素
        v1.set(3,99);//把下标为3的元素替换为其它值
        System.out.println(v1);
        System.out.println(v1.contains(a2));//数组是否包含a2元素，返回boolean
        System.out.println(v1.contains(22));//数组是否包含值为22的元素，返回boolean
        System.out.println(v1.indexOf(0));//返回数组内值为33的下标，没有的话返回-1
        System.out.println(v1.firstElement());//获得数组第一个元素值
    }
}

输出结果

[11, 22, 33, 99, 55]

true

-1

方法

contains()

indexOf()

firstElement()

get(int index)

set(int index,Object obj)

? 2.2 Stack堆栈

接口public class Stack<E>

继承自extends Vector<E>

堆栈

在计算机领域，堆栈是一个不容忽视的概念，堆栈是两种数据结构

堆栈都是一种数据项按序排列的数据结构，只能在一端(称为栈顶(top))对数据项进行插入和删除

在单片机应用中，堆栈是个特殊的存储区，主要功能是暂时存放数据和地址，通常用来保护断点和现场

要点：堆，队列优先,先进先出（FIFO—first in first out）;栈，先进后出(FILO—First-In/Last-Out)

中文名堆栈

外文名 stack

领域计算机

定义数据结构

功能对数据项进行插入和删除

package 教学.C103_12_Stack堆栈;
import java.util.Stack;
public class case1 {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.push(11);
        stack.push(22);
        stack.push(33);
        System.out.println(stack);
        System.out.println(stack.peek());//得到栈顶元素
        System.out.println(stack);
        System.out.println(stack.pop());//移除栈顶元素
        System.out.println(stack);
    }
}

方法

push() 表示元素压入栈顶

pop() 移除栈顶元素

peek() 读取栈顶元素

? 2.3Interface List

List是一个接口‘public interface List<E>’，继承自Collection ‘extends Collection<E>’

它提供了一个集合数据的增删改查等基本操作，上面讲的Vector和Stack都实现了这个接口，这里再介绍它的一个实现类--ArrayList

ArrayList类的用法与Vector非常相似

package 教学.C103_13_List;
import java.util.ArrayList;
import java.util.List;
public class case1 {
    public static void main(String[] args) {
        List<Double> list = new ArrayList<>();
        list.add(11.1);
        list.add(22.1);
        list.add(33.1);
        list.add(44.1);
        System.out.println(list);
        list.set(2,99.1);//改变下标为2的元素的值
        System.out.println(list);
        list.remove(1);//删除下标为1的元素
        System.out.println(list);
    }
}

输出结果

[11.1, 22.1, 33.1, 44.1]

[11.1, 22.1, 99.1, 44.1]

[11.1, 99.1, 44.1]

方法

list.add

list.set

list.remove

? 2.4 ForEach

package 教学.C103_14_ForEach;

import java.util.ArrayList;
import java.util.List;
public class case1 {
    public static void main(String[] args) {
        List<Double> list = new ArrayList<>();
        list.add(11.1);
        list.add(22.1);
        list.add(33.1);
        list.add(44.1);
        for(int i=0;i<list.size();i++){
            System.out.printf("%6.2f",list.get(i));
        }
        System.out.println();
        for(Double d:list){
            System.out.printf("%6.2f",d);
        }
    }
}

输出结果

11.10 22.10 33.10 44.10

从代码中可以看出forEach循环比基本的for循环更简洁，但它只适用于集合相关类

for(Double d:list)的含义：d依次引用到List中每一个元素

? 2.5 Set

Set接口表示无重复元素的集合

import java.util.HashSet;
import java.util.Set;
public class case1 {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        set.add(11);
        set.add(12);
        set.add(13);
        set.add(12);
        System.out.println(set);
    }
}

输出结果

[11, 12, 13]

从结果可以看出，最后一次添加12没有成功执行，因为12之前已经有了

所谓的重复，指的是e1.equals(e2);true;

先判断HashCode，再判断是否equals

? 2.6 Map映射函数

Map是以键值对（Key，Vaule）的形式存取数据

package 教学.C103_16_Map;

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

public class case1 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();
        map.put("num1",11);//存储‘对象’和‘对象关键字’
        map.put("num2",22);
        map.put("num3",33);
        map.put("num4",44);

        Integer x = map.get("num3");//通过‘关键字’得到‘对象’
        System.out.println(x);
    }
}

输出结果

方法

map.put()

map.get()

? 2.7 Iterator迭代器

Iterator迭代器：类似于C语言中链表的指针

p = p → next

package 教学.C103_17_Iterator迭代器;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class case2 {
    public static void main(String[] args) {
        List<Double> list = new ArrayList<>();
        list.add(11.1);
        list.add(22.1);
        list.add(33.1);
        list.add(44.1);

        Iterator<Double> iterator = list.iterator();
        while (iterator.hasNext()){
            Double d = iterator.next();
            System.out.println(d);
        }

}
}

输出结果

11.1

22.1

33.1

44.1

? 2.8 Collections工具类

package 教学.C103_18_Collections工具类;

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

public class case1 {
    public static void main(String[] args) {
        List<Double> list = new ArrayList<>();
        list.add(22.1);
        list.add(11.1);
        list.add(44.1);
        list.add(33.1);
        System.out.println(list);
        Collections.reverse(list);//降序;倒序;逆序
        System.out.println(list);
        Collections.sort(list);//排序
        System.out.println(list);
        Collections.shuffle(list);//乱序
        System.out.println(list);
        System.out.println(Collections.max(list));//最大值
    }
}

输出结果

[22.1, 11.1, 44.1, 33.1]

[33.1, 44.1, 11.1, 22.1]

[11.1, 22.1, 33.1, 44.1]

[11.1, 33.1, 44.1, 22.1]

44.1

IO

? 3.1 流的概念

应用程序和设备（主要是CPU）之间经常需要传输数据，java为了屏蔽硬件细节，简化开发流程，将这种传输封装成流的概念

流有两种：字符流/字节流

字节流把传输的数据看成是没有特定含义的二进制数据

字符流把数据看成字符

? 3.2 字节流

InputStream

InputStream提供了字节流的封装，它是一个抽象类

public abstract class InputStream

extends Object

implements Closeable

Direct Known Subclasses: 子类

AudioInputStream, ByteArrayInputStream, FileInputStream, FilterInputStream, InputStream, ObjectInputStream, PipedInputStream, SequenceInputStream, StringBufferInputStream

通过子类的命名前缀可以看出该类是干嘛的

Constructor Summary

Constructors Constructor and Description

InputStream()

v FileInputStream读取

public class FileInputStream

extends InputStream

package 教学.C103_21_字节流;
import java.io.FileInputStream;

public class Test1_Input {
    public static void main(String[] args) throws Exception {
       FileInputStream fis = new FileInputStream("C:\\Users\\my\\IdeaProjects\\C103_JAVA核心编程\\src\\教学\\C103_21_字节流\\Student");
       int ch;
       while (true){
           ch = fis.read();
           if(-1 == ch){
               break;
           }
           System.out.println((char)ch);
       }
       fis.close();
    }
}

v FileOutputStream输出

数据持久化，把数据存到硬盘/数据库中

FileOutputStream，意为文件输出流，是用于将数据写入File或 FileDescriptor的输出流。

中文名文件输出流

外文名 FileOutputStream

定义 java.lang.Object

常用方法返回与此流有关的文件描述符

实现的接口 Closeable, Flushable

package 教学.C103_21_字节流;
        import java.io.FileOutputStream;

public class Test2_Output {
    public static void main(String[] args) throws Exception {
        FileOutputStream fis = new FileOutputStream("C:\\Users\\my\\IdeaProjects\\C103_JAVA核心编程\\src\\教学\\C103_21_字节流\\Student");
        for(int n=1;n<=10;n++){
            fis.write(n);
        }
        fis.close();
    }
}

文件路径字符串要特别注意

"E:\xt.txt"是错误的路径，因为Java会将其中的“\t”理解成转义字符，所以正确的表示方式是“E:/xt.txt”或“E:\ \xt.txt”

此时输出的文件如果用记事本等工具打开，很可能是显示乱七八糟的东西，因为记事本打开文件是要将其中的数据理解成字符，显然有些数据是没有对应的可显示字符

可以借助十六进制编辑器等工具（比如winHex）来打开文件，以十六进制形式来显示文件内容

package 教学.C103_21_字节流;

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class case1 {
    public static void main(String[] args) throws Exception {//调用main函数抛出所有异常
        FileInputStream   fis = new FileInputStream ("C:\\Users\\my\\Documents\\Music\\大谷和夫 - M-23.mp3");//位置读取文件
        FileOutputStream fos = new FileOutputStream ("C:\\Users\\my\\Music\\大谷和夫 - M-23.mp3");//位置输出文件
        int music;
        while (true){//边读边写（循环）
            music = fis.read();//读取
            if(-1 == music){ break; }//读完结束
            fos.write(music);//输出
        }
        fis.close();//关闭读取文件
    }
}

? 3.3 字符流

提供了两个顶级父类

Class Reader

java.lang.Object

java.io.Reader

读取字符流的抽象类；这一类必须实现的唯一方法是读（char []，int，int）和（）；然而，大多数子类将覆盖这里定义的一些方法，以便提供更高的效率、附加功能或两者

子类

BufferedReader, LineNumberReader, CharArrayReader, InputStreamReader, FileReader, FilterReader, PushbackReader, PipedReader, StringReader

Class Writer

java.lang.Object

java.io.Writer

用于字符流写入的抽象类；这一类必须实现的唯一方法是写（char []，int，int），flush()，和（）；然而，大多数子类将覆盖这里定义的一些方法，以便提供更高的效率、附加功能或两者

子类

Writer, BufferedWriter, CharArrayWriter, FilterWriter, OutputStreamWriter, FileWriter, PipedWriter, PrintWriter, StringWriter

常见IO类继承关系图

箭头表示：子类—-〉父类

字节流：（读取单位为byte）

技术分享图片

字符流：（读取单位为char）

技术分享图片

字符流和字节流的区别：

字节流就是按照byte单位来读取，可以用来读取其他格式的文件

字符流是在字节流的基础上实现的，用来读取文本文件，一个字符一个字符的读取

如果字节流是一滴水一滴水的转移，那么字符流是用勺子一勺一勺水的转移，速度明显加快

当然使用缓冲Buffer以后，就是一桶一桶水的转移了

一个字节占8位，java采用unicode编码，占两个字节，即16位，也就是java一个字符是2byte，16位，

那么在文本copy的时候，用字节流就是一byte-byte的copy，字符流就是一个字符一个字符的copy

v FileWriter

package 教学.C103_22_字符流.FileWriter;

import java.io.FileWriter;

public class case1 {
    public static void main(String[] args) throws Exception{
        FileWriter fileWriter = new FileWriter("C:\\Users\\my\\IdeaProjects\\C103_JAVA核心编程\\src\\教学\\C103_22_字符流\\FileWrite\\Demo");
        fileWriter.write("...");
        //fileWriter.flush();//刷新缓冲区
        fileWriter.close();//关闭位置文件，执行前会调用flush
    }
}

write():往流里写内容

flush():刷新缓冲区

close():关闭此流，但要先刷新它(缓冲区)，执行前会调用flush

每次往里面写东西时，会覆盖原有的内容

fileWriter.close();//关闭位置文件，执行前会调用flush
fileWriter.write("...");

Exception in thread "main" java.io.IOException: Stream closed

执行close后不能再写入，否则会报错IOException

Windows操作系统下

fileWriter.write("a\r\n"+"b\r\n"+"c\r\n"); //输出文件内换行

fileWriter.write("a\t"+"b\t"+"c\t"); //输出文件内空格

系统通用换行方法

System.getProperty("line.separator");

v FileReader

package 教学.C103_22_字符流.FileReader;

import java.io.FileReader;

public class case1 {
    public static void main(String[] args) throws Exception {
        FileReader fileReader = new FileReader("C:\\Users\\my\\IdeaProjects\\C103_JAVA核心编程\\src\\教学\\C103_22_字符流\\FileReader\\Demo");
        //while (true){
        //    int num = fileReader.read();
        //    if (num == -1){break;}
        //    System.out.println((char)num);
        //}
        int num;
        while ((num = fileReader.read())!=-1){
            System.out.println((char)num);
        }
        fileReader.close();
    }
}

public static void main(String[] args) throws Exception {
    FileReader fileReader = new FileReader("C:\\Users\\my\\IdeaProjects\\C103_JAVA核心编程\\src\\教学\\C103_22_字符流\\FileReader\\Demo");
    char [] EnglishLetter = new char[26];
    fileReader.read(EnglishLetter,0,10);//一次读取26个英文字母前10个
    fileReader.close();
    System.out.println(EnglishLetter);
}

? 3.4 缓冲区

v BufferedWriter

package 教学.C103_23_缓冲区.BufferedWriter;

import java.io.BufferedWriter;
import java.io.FileWriter;

public class case1 {
    public static void main(String[] args) throws Exception{
        FileWriter fileWriter = new FileWriter("C:\\Users\\my\\IdeaProjects\\C103_JAVA核心编程\\src\\教学\\C103_23_缓冲区\\BufferedWriter\\Demo");
        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
        bufferedWriter.write("abc");
        bufferedWriter.newLine();//换行
        bufferedWriter.write("123");
        bufferedWriter.flush();//刷新缓冲区
        bufferedWriter.close();
        //fileWriter.close();
    }
}

? 3.5 File类

字节流和字符流可以实现对文档内容的操作，但是对于文件属性就无能为力。

属性包括：文件名、类型、最后一次修改时间、存储路径、文件大小

- 什么是File对象?

1) 用来将文件或者文件夹封装成对象

2) 方便对文件夹或文件属性信息进行操作

3) File对象作为参数传递给流的构造方法（构造方法摘要FileWriter(File file)）

- File对象的创建

package 教学.C103_24_File;
import java.io.File;

public class case1 {
    public static void main(String[] args) {
        creatFile();
    }
    private static void creatFile() {
        File file1 = new File("C:\\a1.txt");

        File file2 = new File("C:\\","a2.txt");

        File file3 = new File("C:\\");
        File file4 = new File(file3,"a3.txt");

        File file5 = new File("C:\\"+File.separator+"a4.txt");
        System.out.println(file5);

        File file6 = new File("C:\\Users\\my\\Documents\\Music\\大谷和夫 - M-23.mp3");
        System.out.println(file6.getName());
    }
}

输出结果

C:\a4.txt

大谷和夫 - M-23.mp3

- File的常用方法

1) 获取相关（名称;路径;大小;最后修改）

2) 创建删除（文件;文件夹;重命名）

3) 判断类（判断是否文件夹;判断是路径还是文件;判断是否存在;判断是否隐藏）

//获取相关名称;路径;大小;最后修改

public class case1 {
    public static void main(String[] args) {
        getInfo();//演示获取
    }
private static void getInfo() {
    File file = new File("C:\\Users\\my\\Documents\\Music\\大谷和夫 - M-5.mp3");
    System.out.println(file.getName());//名称
    System.out.println("-----------------------------------------------------------------");
    System.out.println(file.getAbsolutePath());//绝对路径
    System.out.println("-----------------------------------------------------------------");
    System.out.println(file.length());//文件大小
    System.out.println("-----------------------------------------------------------------");
    System.out.println(file.lastModified());//最后修改时间戳 1970-01-01-00:00至最后修改时间中间的毫秒数
    System.out.println("-----------------------------------------------------------------");
    Date date = new Date(file.lastModified());
    System.out.println(date);