java基础总结三--让大学生活不再迷茫

最新推荐文章于 2024-04-21 19:56:18 发布

dotaer-df

最新推荐文章于 2024-04-21 19:56:18 发布

阅读量609

点赞数 2

分类专栏： java基础篇文章标签： java基础总结三--让大学生活不再迷茫

本文链接：https://blog.csdn.net/weixin_43410352/article/details/87347385

版权

java基础篇专栏收录该内容

31 篇文章 0 订阅

订阅专栏

承接我的上篇博客
https://mp.csdn.net/mdeditor/87073372# java基础总结一
https://mp.csdn.net/mdeditor/87201024# java基础总结二

13.javaAPI

一.Java中的String，StringBuilder，StringBuffer三者的区别

（1）String在于一旦创建将不能再更改
String str="abc“
str+=“de”
虽然不会报错,str结果也是abcde但是事实上前一个str已经被jvm收回,后一个str为新建的str,如果大量的进行这样改动操作，其实是在不断的创建，回收当中，这样很耗费时间

（2)StringBuffer和StringBuilder可以更改,并且不会创建新对象
而它区别在于StringBuilder线程不安全它其中的方法没有加上synchronized关键字,而StringBuffer是线程安全的,在单线程中推荐使用
StringBuilder.
他们整体效率:
StringBuilder > StringBuffer > String

对字符串的操作是重点
str1.indexOf(String str)
返回指定子字符串在此字符串中第一次出现处的索引。
str1.subString(int beginindex)
返回一个新的字符串，它是此字符串beginindex下标后的一个子字符串。
str1.charAt(int index)
通过传入下标返回当前下标对应的字符
str1.spilt(String regx)
通过传入切割限定符,按切割符划分成诺干字符串数组
str1.startsWith(prefix)
该字符串是否已指定字符串开始,是返回true,否则flase
str1.endsWith(suffix)
该字符串是否已指定字符串结尾,是返回true,否则flase
str1.replace(oldChar, newChar)
替换字符串
str1.toCharArray();
将字符串转换为字符数组
str1.contains(s)
判断是否包含字符串
str1.equals(anObject)
判断两者字符串内容是否一致
str1.toUpperCase()
转换为全部大写
str1.toUpperCase()
转换为全部小写
str1.isEmpty()
判断是否为null符串,是返回true,否则返回false,如果是"“空白字符串它返回的是false
str1.trim()
去掉字符串两端的空格如要去掉所有str1.replace(” ", “”)

再怎么说不如实际动手操作就能很容易明白,
下面是一个简单提取简历信息例子:

	String str="个人简历: 姓名:刘德华 年龄:18 爱好:足球,dota 个人网站:'www.xxx.com'";
		StringBuffer sb=new StringBuffer();
		int index=str.indexOf(":")+1;//获得当前冒号的下标 +1为了获得下个字符的下标
		String str1=str.substring(index);
		System.out.println(str1);
		
		String[] str2=str1.split(" ");
		for (int i = 0; i < str2.length; i++) {
			//通过split方法窃取出来的效果,返回的是一个数组
			System.out.println("str2["+i+"]"+str2[i]);
		}
		for (int i = 0; i < str2.length; i++) {
			if(i==0||i==str2.length-1)
			{
				sb.append(str2[i].substring(str2[i].indexOf(":")+1));
			}else
			{
			sb.append(str2[i].substring(str2[i].indexOf(":")+1)).append(',');
			}
		}
		System.out.println("个人信息："+sb.toString());	 
	}

在这里插入图片描述

二.包装类及其作用
byte->Byte
short->Short
String->String
boolean->Boolean
double->Double
float->Float
long->Long

特例：
char->Character
int ->Integer
为什么要使用包装类
(1).有时候如果你想两种数据类型直接的转换比如 int->String，基本数据类型之间是不能转换的但是使用包装类可以
int a=232;
String c=String.valueOf(a);//将int->String
String b=“3431”;
int d=Integer.parseInt(b);//将String->int
(2)有时候方法参数中需要传入Object对象基本数据类型也是不行的,必须是包装类
public void test(Object obj){
}
你想传递5进去就可以这样
test(new Integer(5));
(3)泛型中必须使用包装类，不能使用基本数据类型

三.System类

System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。由于该类的构造方法是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便的进行调用。

https://www.cnblogs.com/xuhuan/articles/1522212.html
这篇博客很好

四.Runtime类
该类主要代表了应用程序的运行环境。一个RunTime就代表一个运行环境。
https://blog.csdn.net/zhuwei1035838807/article/details/79464603

五.Date类
位于java.util包下
Date date=new Date();
这个date对象代表当前时间
在这里插入图片描述且这样的格式不太好
需要用到SimpleDateFormat类转换一下

            Date date=new Date();
	        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	        String newdate=	simpleDateFormat.format(date);
            System.out.println(newdate);
            
          //  结果:2019-02-15 11:29:27

需要注意的是设置时间格式时候的大小写一定要规范，不然时间不正确

还可以使用SimpleDateFormat 类的 parse() 方法将文本转换为日期

            String date="2019-02-15 11:29:27";
	        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	        Date today = null;
			try {
				today = simpleDateFormat.parse(date);
			} catch (ParseException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	         System.out.println(today);
	}
	调用 SimpleDateFormat 对象的 parse() 方法时可能会出现转换异常，即 ParseException ，因此需要进行异常处理

六,其他类可查询相关api文档

14.集合
在这里插入图片描述从图可知List，Set，Map都是抽象类无法通过new来产生对象
所以都要通过他们的实现类
List list=new ArrayList();
Set set=new HashSet<>();
Map map=new HashMap<>();
。。。

collection:单列集合根接口Set和List是它重要两个子接口
其中方法有：
booleadn add(Object o)
boolean addAll(Collection c)将指定集合添加到该集合中
void clear()删除所有
boolean remove(Object o)删除该集合指定元素
boolean removeAll(Collection c)删除指定集合所有元素
boolean isEmpty()判断是否为空
boolean contains(Object o)判断是否包含某个元素
boolean contaiinsAll(Collection c)判断该集合是否包含指定集合所有元素

现在讲讲他们的区别：

List:中存入的是有序，元素可重复
主要实现类：ArrayList和LinkedList

ArrayList 可以将它理解成一个可增长的数组，它提供快速迭代和快速随机访问的能力。(查询快，删改慢,线程不安全)
LinkedList 中的元素之间是双链接的，当需要快速插入和删除时LinkedList成为List中的不二选择。(查询相对ArrayList 慢，删改快)
Vector用法与ArrayList完全相同，区别在于Vector线程是安全的，而ArrayList是不安全的

Set:中存入的是无序，元素不可重复
主要实现类：HashSet和TreeSet

HashSet 当不希望集合中有重复值，并且不关心元素之间的顺序时可以使用此类。
LinkedHashset 当不希望集合中有重复值，并且希望按照元素的插入顺序进行迭代遍历时可采用此类。
TreeSet 当不希望集合中有重复值，并且希望按照元素的自然顺序进行排序时可以采用此类。（自然顺序意思是某种和插入顺序无关，而是和元素本身的内容和特质有关的排序方式，譬如“abc”排在“abd”前面。）

Set因为无序，所以也就没有索引位置，也就没有这一些与索引相关的方法

Set<String> set = new HashSet<String>();
	    set.add("Eg");
	    set.add("Gh");
	    set.add("Cn");
	    set.add("Ev");
	    set.add("Bc");
	    System.out.println(set);
	    Set<String> sortedSet = new TreeSet<String>(set);
	    System.out.println(sortedSet);
	    
	    结果：
	    [Gh, Ev, Bc, Eg, Cn]
        [Bc, Cn, Eg, Ev, Gh]  //默认自然顺序abcde

Map:中存入的每个元素是包含一个键对象Key和一个值对象Value，键和值存在一种对应关系，称为映射
主要实现类:HashMap和TreeMap和 LinkedHashMap 和HashTable(不常用了，不过它的子类Properties集合）

HashMap中必须保证不出现重复的键，否则新添加的会覆盖掉原来的键(键相同,值覆盖)
LinkedHashMap 当需要键值对，并且关心插入顺序时可采用它。
TreeMap 当需要键值对，并关心元素的自然排序时可采用它。
HashTable 线程安全，存取元素很慢，已经不用了

知道了什么情况下用什么集合现在该知道如何遍历集合
1.通用遍历集合Iterator
Iterator it = list.iterator();
while(it.hasNext()) {
　　Object obj = it.next();
//hasNext判断迭代器中是否还有下一个元素
//next返回下个元素

List遍历方式：
1.foreach

for (Object object : list) {
System.out.println(object);
}

2.for

for(int i = 0 ;i<list.size();i++) {
int j= (Integer) list.get(i);
System.out.println(j);
}

Map遍历方式:
1.通过获得所有的key
Set set = map.keySet(); //得到所有key的集合
for (Integer in : map.keySet()) {
String str = map.get(in);//得到的是每个key对应的value的值
}

2.通过Map.entrySet使用iterator遍历key和value
Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<Integer, String> entry = it.next();
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}

3.通过foreach和entrySet结合推荐适合容量大的时候
for (Map.Entry<Integer, String> entry : map.entrySet()) {
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}

4.这种方法不能遍历key
for (String v : map.values()) {
System.out.println("value= " + v);
}

排序
两种方法：
1.自定义实体类实现java.lang.Comparable接口，重写public int compareTo(Object obj)方法。自定义业务比较规则

public class Test5 {
	
	public static void main(String[] args) {
		Worker worker=new Worker(2222,2018,1);
		Worker worker2=new Worker(1111,2017,3);
		Worker worker3=new Worker(3333,2016,2);
		Worker worker4=new Worker(22243,2018,1);
		Worker worker6=new Worker(2222,2016,1);
		Worker worker7=new Worker(2342,2019,1);
		Worker worker8=new Worker(2222,2017,1);
		List<Worker> list=new ArrayList<>();
		list.add(worker);
		list.add(worker2);
		list.add(worker3);
		list.add(worker4);
		list.add(worker6);
		list.add(worker7);
		list.add(worker8);
		for (Worker worker5 : list) {
			System.out.println("排序前:"+worker5.toString());
		}
		Collections.sort(list);
		System.out.println("--------------------------");
		for (Worker worker5 : list) {
			System.out.println("排序后:"+worker5.toString());
		}
		
		
		

	}
}

class Worker implements Comparable<Worker>
{
	//工资
	int money;
	//入职年份
	int year;
	//级别
	int level;
	
	
	@Override
	public String toString() {
		return "Worker [money=" + money + ", year=" + year + ", level=" + level + "]";
	}
	public Worker(int money,int year,int level) {
		// TODO Auto-generated constructor stub
		
		this.money=money;
		this.year=year;
		this.level=level;
	}
	
	public int getMoney() {
		return money;
	}
	public void setMoney(int money) {
		this.money = money;
	}
	public int getYear() {
		return year;
	}
	public void setYear(int year) {
		this.year = year;
	}
	public int getLevel() {
		return level;
	}
	public void setLevel(int level) {
		this.level = level;
	}
	@Override
	public int compareTo(Worker o) {
		// TODO Auto-generated method stub
		int result=0;
		result=this.level-o.level;//按级别升序
		if(result==0)
		{
			result=this.money-o.money;//级别相同,按工资升序
			if (result==0) {
				result=-(this.year-o.year);//工资，级别都相同，按入职年份降序
			}
		}
		return result;
	}
	
}
结果：
排序前:Worker [money=2222, year=2018, level=1]
排序前:Worker [money=1111, year=2017, level=3]
排序前:Worker [money=3333, year=2016, level=2]
排序前:Worker [money=22243, year=2018, level=1]
排序前:Worker [money=2222, year=2016, level=1]
排序前:Worker [money=2342, year=2019, level=1]
排序前:Worker [money=2222, year=2017, level=1]
--------------------------
排序后:Worker [money=2222, year=2018, level=1]
排序后:Worker [money=2222, year=2017, level=1]
排序后:Worker [money=2222, year=2016, level=1]
排序后:Worker [money=2342, year=2019, level=1]
排序后:Worker [money=22243, year=2018, level=1]
排序后:Worker [money=3333, year=2016, level=2]
排序后:Worker [money=1111, year=2017, level=3]

第二种思路

2.自己编写业务比较规则类。实体类不用实现任何借口。业务比较规则类实现java.util.Comparator接口。重写public int compare(String o1, String o2)方法，编写排序规则
　　
　　一般推荐使用第二种思路。
　　
　　原因：
（1）排序规则和实体类解耦。当业务发生变化，可以灵活改变。

（2）如果项目是接手别的公司，实体类无源代码，则可以编写排序规则业务类。

public class Test5 {
	
	public static void main(String[] args) {
		Worker worker=new Worker(2222,2018,1);
		Worker worker2=new Worker(1111,2017,3);
		Worker worker3=new Worker(3333,2016,2);
		Worker worker4=new Worker(22243,2018,1);
		Worker worker6=new Worker(2222,2016,1);
		Worker worker7=new Worker(2342,2019,1);
		List<Worker> list=new ArrayList<>();
		list.add(worker);
		list.add(worker2);
		list.add(worker3);
		list.add(worker4);
		list.add(worker6);
		list.add(worker7);
		for (Worker worker5 : list) {
			System.out.println("排序前:"+worker5.toString());
		}
		Collections.sort(list, new MySort());
		System.out.println("--------------------------");
		for (Worker worker5 : list) {
			System.out.println("排序后:"+worker5.toString());
		}
		
		
		

	}
}

class Worker
{
	//工资
	int money;
	//入职年份
	int year;
	//级别
	int level;
	
	
	@Override
	public String toString() {
		return "Worker [money=" + money + ", year=" + year + ", level=" + level + "]";
	}
	public Worker(int money,int year,int level) {
		// TODO Auto-generated constructor stub
		
		this.money=money;
		this.year=year;
		this.level=level;
	}
	
	public int getMoney() {
		return money;
	}
	public void setMoney(int money) {
		this.money = money;
	}
	public int getYear() {
		return year;
	}
	public void setYear(int year) {
		this.year = year;
	}
	public int getLevel() {
		return level;
	}
	public void setLevel(int level) {
		this.level = level;
	}
	
}

class MySort implements Comparator<Worker>
{

	@Override
	public int compare(Worker o1, Worker o2) {
		// TODO Auto-generated method stub
		int result=0;
		result=o1.getLevel()-o2.getLevel();
		if(result==0)
		{
			result=o1.getMoney()-o2.getMoney();
			if(result==0)
			{
				result=-(o1.getYear()-o2.getYear());
			}
		}
		return result;
	}
	
}
结果:
排序前:Worker [money=2222, year=2018, level=1]
排序前:Worker [money=1111, year=2017, level=3]
排序前:Worker [money=3333, year=2016, level=2]
排序前:Worker [money=22243, year=2018, level=1]
排序前:Worker [money=2222, year=2016, level=1]
排序前:Worker [money=2342, year=2019, level=1]
--------------------------
排序后:Worker [money=2222, year=2018, level=1]
排序后:Worker [money=2222, year=2016, level=1]
排序后:Worker [money=2342, year=2019, level=1]
排序后:Worker [money=22243, year=2018, level=1]
排序后:Worker [money=3333, year=2016, level=2]
排序后:Worker [money=1111, year=2017, level=3]

15.io流

在这里插入图片描述其中，以Stream结尾的为字节流，以Writer或者Reader结尾的为字符流。所有的输入流都是抽象类IuputStream（字节输入流）或者抽象类Reader（字符输入流）的子类，所有的输出流都是抽象类OutputStream(字节输出流)或者抽象类Writer(字符输出流)的子类。字符流能实现的功能字节流都能实现，反之不一定。如：图片，视频等二进制文件，只能使用字节流读写，字符流主要读取文本

1.字符流
使用FileReader和FileWriter类完成文本文件复制：
public static void main(String[] args) throws IOException {
FileReader reader=new FileReader(new File(“F:\read.txt”))；

	FileWriter writer=new FileWriter(new File("F:\\writer.txt"));
	
	char[] flush =new char[1024];
	int len=0;
	while((len=bre.read(flush))!=-1)
	{
		writer.write(flush, 0, len);
		
	}
	reader.close();
	writer.close();
}

注意：当读到文件末尾的时候会返回-1.正常情况下是不会返回-1的。

2、字符缓冲流BufferedReader和BufferedWriter
为什么要用到缓冲流：
答：某些情况下，如果一个程序频繁地操作一个资源（如文件或数据库），则性能会很低，此时为了提升性能，就可以将一部分数据暂时读入到内存的一块区域之中，以后直接从此区域中读取数据即可，因为读取内存速度会比较快，这样可以提升程序的性能。
在字符流的操作中，所有的字符都是在内存中形成的，在输出前会将所有的内容暂时保存在内存之中，所以使用了缓冲区暂存数据。
如果想在不关闭时也可以将字符流的内容全部输出，则可以使用Writer类中的flush()方法完成。

工作原理:
1、使用了底层流对象获取数据，并将数据存储到缓冲区的数组内。2、通过缓冲区的read()方法从缓冲区获取具体的字符数据，就不用每次到文件中读取,这样就提高了效率。3、如果用read方法读取字符数据，并存储到另一个容器中，直到读取到了换行符时，将另一个容器临时存储的数据转成字符串返回，就形成了readLine()功能。

BufferedReader

(1)从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
(2)可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。
(3)通常，Reader 所作的每个读取请求都会导致对底层字符或字节流进行相应的读取请求。因此，建议用 BufferedReader 包装所有其 read() 操作可能开销很高的 Reader（如 FileReader 和 InputStreamReader）。例如，
BufferedReader in
= new BufferedReader(new FileReader(“foo.in”));

BufferedWriter

(1)将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
(2)可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。
(3)该类提供了 newLine() 方法，它使用平台自己的行分隔符概念，此概念由系统属性 line.separator 定义。并非所有平台都使用新行符 (’\n’) 来终止各行。因此调用此方法来终止每个输出行要优于直接写入新行符。
(4)通常 Writer 将其输出立即发送到底层字符或字节流。除非要求提示输出，否则建议用 BufferedWriter 包装所有其 write() 操作可能开销很高的 Writer（如 FileWriters 和 OutputStreamWriters）。例如，
PrintWriter out
= new PrintWriter(new BufferedWriter(new FileWriter(“foo.out”)));

例子：

      //创建输入流对象
        BufferedReader br=new BufferedReader(new FileReader("C:\\Test\\copyfrom.txt"));//文件不存在会抛出java.io.FileNotFoundException
        //创建输出流对象
        BufferedWriter bw=new BufferedWriter(new FileWriter("C:\\Test\\copyto.txt"));
        //文本文件复制
        char [] chs=new char[1024];
        int len=0;
        while((len=br.read(chs))!=-1) {
            bw.write(chs, 0, len);
        }
        //释放资源
        br.close();
        bw.close();

3.字节流FileInputStream和FileOutputStream
使用字节流复制图片
例子1：

默认“追加模式”是false，即“写到输出的流内容”将覆盖原文件内容。
若要追加则为（String path， true）; 
        FileInputStream in=new FileInputStream("F:\\img1.jpg",true);
        FileOutputStream out=new FileOutputStream("F:\\\\img2.jpg");
        int len=0;
        byte[] flush=new byte[1024];
        while((len=in.read(buff))!=-1) {
            out.write(buff, 0, len);
        }
        in.close();
        out.close();

例子2

public class FileCopy {

	public static void main(String[] args) {
		String srcpath="F:/java/1.txt";
		String destpath="F:/java/2.txt";
		copyFile(srcpath,destpath);

	}

	public static void copyFile(String srcpath, String destpath)  {
		copyFile(new File(srcpath),new File(destpath));
	}
	public static void copyFile(File srcpath, File destpath)  {
		InputStream in=null;
		OutputStream os=null;
		try {
			in = new FileInputStream(srcpath);
		    os = new FileOutputStream(destpath,true);
			byte[] flush = new byte[1024];
			int len = 0;
			while (-1 != (len = (in.read(flush)))) {
				os.write(flush, 0, len);
				System.out.println();
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally
		{
		
		try {
			os.flush();
			os.close();
			in.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		}

	}

}

4.字节缓冲流BufferedInputStream和BufferedOutputStream与字符缓冲流类似

5.转换流：InputStreamReader和OutputStreamWriter
它是字符流和字节流转换间的一座桥梁
InputStreamReader
(1)InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。

(2)每次调用 InputStreamReader 中的一个 read() 方法都会导致从底层输入流读取一个或多个字节。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节，使其超过满足当前读取操作所需的字节。

(3)为了达到最高效率，可以考虑在 BufferedReader 内包装 InputStreamReader。例如：

**字节流转为字符流**

BufferedReader in = new BufferedReader(new InputStreamReader(System.in))；
例子：
 BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream("F:\\read.txt"),"gbk"));
	      char[] f=new char[1024];
	      int len=in.read(f);
	      System.out.println(new String(f,0,len));

OutputStreamWriter
字符流转为字节流的桥梁( 其实没必要）

因为字节是面向机器而言的，程序的最终目的是将流解析出来而不是将流转来转去，对于流而言一般都是先得到字节流，然后向更高级构造，变成字符流，最终是字符串或者数据集，很少有得到较为高级的数据流向低级转换完在读取的。字节流一般都是做完处理后写入最终数据流，用于不同协议间数据通信用的，所以要从字符流变成字节流就要自己构造。因为很少有人会遇到这种情况，所以jdk中没有提供类似功能的类。
但是不是不可以，可以自己构造一个有这样功能的类。
比如可以用String的构造函数String(Char[])和getByte()方法（new String(char[]).getBytes()），间接把字符流转换一下在构造成想要的字节流。

将字符串按照指定的编码表转成字节，再使用字符流将这些字节写出去

//将你好字符写入text文件中
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("text.txt"),"utf-8");//本身是字符流，传入字节流
        osw.write("你好");
        osw.close();

6.打印流PrintWriter和PrintStream
打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。

使用打印流复制文本文件

 BufferedReader br=new BufferedReader(new FileReader("copy.java"));
        PrintWriter pw=new PrintWriter("printcopy.java");
        String line;
        while((line=br.readLine())!=null) {
            pw.println(line);
        }
        br.close();
        pw.close();

优势：
1.
为其他输出流添加了功能（增加了很多打印方法），使它们能够方便地打印各种数据值表示形式(例如：希望写一个整数，到目的地整数的表现形式不变。字节流的write方法只将一个整数的最低字节写入到目的地，比如写fos.write(97)，到目的地（记事本打开文件）会变成字符’a’,需要手动转换：fos.write(Integer.toString(97).getBytes());而采用PrintStream：ps.print(97)，则可以保证数据的表现形式)。
2.
永远不会抛出 IOException

7.File类
File类是文件和目录路径名的抽象表示形式。并不是单单指一个文件
1）File(String pathname)

该构造方法通过将给定路径名字字符串转换为抽象路径来创建一个新File实例。

new File(String pathname)

pathname：是指路径名（包含文件名）

File file = new File(“D:/test.txt”)或者 File file =new File(“D:\test.txt”)

（2）File(String parent ,String child)

该构造方法根据定义的父路径和子路径字符串（包含文件名）创建一个新的File实例。

（3）File(File f ,String child)

该构造方法根据parent抽象路径名和child路径名字符串创建一个新File实例。

File file=new File(“D:/myword”,“word.txt”);

这个file是抽象的磁盘中不一定有这个文件
file常用方法:

String getName() 获取文件的名称
boolean canRead() 判断文件是否是可读的
boolean canWrite() 品判断文件是否可被写入
boolean exits() 判断文件长度是否存在
int length() 获取文件的长度（以字节为单位）
String getAbsolutePath() 获取文件的绝对路径
String getParent() 获取文件的父路径
boolean isFile() 判断此抽象路径名表示的文件是否为普通文件
boolean isDirectory() 判断此抽象路径名表示的是否是一个目录
boolean isHidden 判断文件是否是隐藏文件
long lastModified() 获取文件最后修改时间
Boolean canExecute()
测试应用程序是否可以执行此抽象路径名表示的文件。
boolean createNewFile() 当且仅当具有该名称的文件尚不存在时，原子地创建一个由该抽象路径名命名的新的空文件。
boolean delete() 删除由此抽象路径名表示的文件或目录。
File[] listFiles() 返回一个抽象路径名数组，表示由该抽象路径名表示的目录中的文件。
String[] list() 返回一个字符串数组，命名由此抽象路径名表示的目录中的文件和目录。
boolean mkdirs() 创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录。可创建多层文件包
boolean mkdir() 创建由此抽象路径名命名的目录。只能创建一层文件包
boolean reNameTo(File dest) 重命名由此抽象路径名表示的文件。
boolean setReadOnly()
标记由此抽象路径名命名的文件或目录，以便只允许读取操作。
boolean setWritable(boolean writable)
一种方便的方法来设置所有者对此抽象路径名的写入权限。


File  file  =  new File("F:\\myword","word.txt"); //在我磁盘中没有这个路径
		if(file.exists())
		{
			file.delete();
			System.out.println("已删除");
		}
		else
		{
			//file.createNewFile();
			System.out.println("文件名"+file.getName());
			System.out.println("绝对路径:"+file.getAbsolutePath());
			System.out.println("父路径:"+file.getParent());
		}
		if(file.isDirectory())
		{
			System.out.println("是一个目录");
		}
		else if(file.isFile()) {
			System.out.println("是一个文件");
		}
结果：
word.txt
绝对路径:F:\myword\word.txt
父路径:F:\myword
既不是文件，也不是目录，没有此路径

注意：
File类中的mkdir()和mkdirs(): //只能用来创建目录不能创建文件
mkdir()：只能创建一层目录.
如: File file = new File(“c:/aa”);
file.mkdir(); //这样可以在c:/下创建aa目录
假如有多层目录,则不能用mkdir创建:File file = new File(“c:/aa/bb”); file.mkdir() //这样创建不了.
应该改为: mkdirs():

dotaer-df

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
java基础总结三--让大学生活不再迷茫

承接我的上篇博客https://mp.csdn.net/mdeditor/87073372# java基础总结一https://mp.csdn.net/mdeditor/87201024# java基础总结二13.javaAPI一.Java中的String，StringBuilder，StringBuffer三者的区别（1）String在于一旦创建将不能再更改String str=...
复制链接

扫一扫