(一)File类
file类主要就是用来读取文件的,File类提供一些方法,例如读取文件的名称,获取文件的路径等
File类的使用如下:
import org.junit.Test;
import java.io.File;
public class TestFileClass {
@Test
public void testFile(){
File file=new File("IO","data.txt");
System.out.println(file.getAbsoluteFile());
File dir1 = new File("D:/IOTest/dir1");
if (!dir1.exists()) { // 如果D:/IOTest/dir1不存在,就创建为目录
dir1.mkdir();
}
// 创建以dir1为父目录,名为"dir2"的File对象
File dir2 = new File(dir1, "dir2");
if (!dir2.exists()) { // 如果还不存在,就创建为目录
dir2.mkdirs();
}
File dir4 = new File(dir1, "dir3/dir4");
if (!dir4.exists()) {
dir4.mkdirs();
}
}
}
(二)IO流
对于文本文件(.txt,.java,.c)使用字符流处理
对于非文本文件(.jpg,.mp3,.avi)使用字节流处理
2.1IO流的分类
处理流套在节点流外面,一般释放资源时只需要释放处理流,节点流自动释放。
2.2InputStreamReader&&outputStreamWriter(字符流 节点流)
以字符流Reader为例,读取一个文件中的信息
//read()方法
@Test
public void testReader(){
FileReader fr = null;
try {
//File实例化
File file = new File("data.txt");
//FileReader实例化
fr = new FileReader(file);
//read读取出来的是整数 如果读到最后 返回-1
int a = fr.read();
while (a != -1) {
System.out.println(a);
a = fr.read();
}
} catch (IOException e) {
e.printStackTrace();
}
finally {
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//read() 使用read的重载方法
这里注意,直接在方法上抛异常会导致垃圾可能不能释放。使用try catch保证finally最后的语句会执行。 (快捷键alt+shift+T)
步骤和上面一样
@Test
public void Writer(){
FileWriter fr = null;
try {
File file=new File("data.txt");
fr=new FileWriter("hello.txt");
fr.write("I");
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
fr.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
2.4FileInputStrem&&GFileOutputStream(字节流 节点流)
用于字节流数据的输入与输出
//实现一个视频文件的复制
@Test
public void copy(String srcPath,String desPath){
FileInputStream fi= null;
FileOutputStream fo= null;
try {
fi = null;
fo = null;
File file_1=new File(srcPath);
File file_2=new File(desPath);
fi=new FileInputStream(file_1);
fo=new FileOutputStream(file_2);
byte [] buffer=new byte[1024];
int len;
while((len=fi.read(buffer))!=-1){
fo.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
fi.close();
fo.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
2.6BufferedReader&&BufferedWriter(字符流、处理流)
@Test
public void testBufferedReaderBufferedWriter(){
BufferedReader br = null;
BufferedWriter bw = null;
try {
//创建文件和相应的流
br = new BufferedReader(new FileReader(new File("dbcp.txt")));
bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));
//读写操作
//方式一:使用char[]数组
// char[] cbuf = new char[1024];
// int len;
// while((len = br.read(cbuf)) != -1){
// bw.write(cbuf,0,len);
// // bw.flush();
// }
//方式二:使用String
String data;
while((data = br.readLine()) != null){
//方法一:
// bw.write(data + "\n");//data中不包含换行符
//方法二:
bw.write(data);//data中不包含换行符
bw.newLine();//提供换行的操作
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭资源
if(bw != null){
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(br != null){
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
2.5BufferedInputStream&&BufferedOutputStream(字节流、处理流)
@Test
public void BufferedStreamTest() throws FileNotFoundException {
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
//1.造文件
File srcFile = new File("爱情与友情.jpg");
File destFile = new File("爱情与友情3.jpg");
//2.造流
//2.1 造节点流
FileInputStream fis = new FileInputStream((srcFile));
FileOutputStream fos = new FileOutputStream(destFile);
//2.2 造缓冲流
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos);
//3.复制的细节:读取、写入
byte[] buffer = new byte[10];
int len;
while((len = bis.read(buffer)) != -1){
bos.write(buffer,0,len);
// bos.flush();//刷新缓冲区
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4.资源关闭
//要求:先关闭外层的流,再关闭内层的流
if(bos != null){
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(bis != null){
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//说明:关闭外层流的同时,内层流也会自动的进行关闭。关于内层流的关闭,我们可以省略.
// fos.close();
// fis.close();
}
2.6转换流
-
1.转换流:属于字符流
-
InputStreamReader:将一个字节的输入流转换为字符的输入流
-
OutputStreamWriter:将一个字符的输出流转换为字节的输出流
-
2.作用:提供字节流与字符流之间的转换
//将一个字节的输入流转换为字符的输入流
@Test
public void test1() throws IOException {
FileInputStream fis = new FileInputStream("dbcp.txt");
// InputStreamReader isr = new InputStreamReader(fis);//使用系统默认的字符集
//参数2指明了字符集,具体使用哪个字符集,取决于文件dbcp.txt保存时使用的字符集
InputStreamReader isr = new InputStreamReader(fis,"UTF-8");//使用系统默认的字符集
char[] cbuf = new char[20];
int len;
while((len = isr.read(cbuf)) != -1){
String str = new String(cbuf,0,len);
System.out.print(str);
}
isr.close();
2.7对象流
基本概念:
总结一句话,对象流就是把我们创建的对象通过序列化写入到数据集,并且也可以将对象通过反序列化从数据源中还原回来。
-
对象流的使用
-
1.ObjectInputStream 和 ObjectOutputStream
-
2.作用:用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中,也能把对象从数据源中还原回来。
-
3.要想一个java对象是可序列化的,需要满足相应的要求。见Person.java
-
4.序列化机制:
-
对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流,从而允许把这种
-
二进制流持久地保存在磁盘上,或通过网络将这种二进制流传输到另一个网络节点。
-
当其它程序获取了这种二进制流,就可以恢复成原来的Java对象。
具体如何序列化
public class ObjectInputOutputStreamTest {
/*
序列化过程:将内存中的java对象保存到磁盘中或通过网络传输出去
使用ObjectOutputStream实现
*/
@Test
public void testObjectOutputStream(){
ObjectOutputStream oos = null;
try {
//1.
oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
//2.
oos.writeObject(new String("我爱北京天安门"));
oos.flush();//刷新操作
oos.writeObject(new Person("王铭",23));
oos.flush();
oos.writeObject(new Person("张学良",23,1001,new Account(5000)));
oos.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(oos != null){
//3.
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/*
反序列化:将磁盘文件中的对象还原为内存中的一个java对象
使用ObjectInputStream来实现
*/
@Test
public void testObjectInputStream(){
ObjectInputStream ois = null;
try {
ois = new ObjectInputStream(new FileInputStream("object.dat"));
Object obj = ois.readObject();
String str = (String) obj;
Person p = (Person) ois.readObject();
Person p1 = (Person) ois.readObject();
System.out.println(str);
System.out.println(p);
System.out.println(p1);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
if(ois != null){
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
(三)网络编程
TCP与UDP的区别是什么?
3.1实现TCP的网络编程
- 一、网络编程中有两个主要的问题:
1.如何准确地定位网络上一台或多台主机;定位主机上的特定的应用
2.找到主机后如何可靠高效地进行数据传输 - 二、网络编程中的两个要素:
1.对应问题一:IP和端口号
2.对应问题二:提供网络通信协议:TCP/IP参考模型(应用层、传输层、网络层、物理+数据链路层) - 三、通信要素一:IP和端口号
- IP:唯一的标识 Internet 上的计算机(通信实体)
- 在Java中使用InetAddress类代表IP
- IP分类:IPv4 和 IPv6 ; 万维网 和 局域网
- 域名: www.baidu.com www.mi.com www.sina.com www.jd.com www.vip.com
- 本地回路地址:127.0.0.1 对应着:localhost
- 如何实例化InetAddress:两个方法:getByName(String host) 、 getLocalHost()
两个常用方法:getHostName() / getHostAddress() - 端口号:正在计算机上运行的进程。
要求:不同的进程有不同的端口号
范围:被规定为一个 16 位的整数 0~65535。 - 端口号与IP地址的组合得出一个网络套接字:Socket
创建一个客户端和服务端 实现客户端向服务端发送数据 并且在客户端回显
package com.sgyj.Internet;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
public class TCPTest {
@Test
//创建一个客户端和服务端 实现客户端向服务端发送数据 并且在客户端回显
public void client() {
Socket s1= null;
OutputStream o1= null;
try {
s1 = null;
o1 = null;
//创建socket对象 指明服务器的IP和端口号
InetAddress inetAddress=InetAddress.getByName("127.0.0.1");
s1=new Socket(inetAddress,8844);
//获取一个输出流,表示输出的数据
o1=s1.getOutputStream();
o1.write("我是一个好人".getBytes());
} catch (IOException e) {
e.printStackTrace();
}finally {
if(o1!=null){
try {
o1.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(s1!=null){
try {
s1.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
@Test
public void server(){
ServerSocket ss=null;
Socket socket=null;
InputStream is=null;
//创建服务器段的ServerSocket 表明端口
try {
ss=new ServerSocket(8844);
//调用accept来接受客户端的socket
socket=ss.accept();
//获取输入流
is=socket.getInputStream();
//显示输入
byte buffer []=new byte[1024];
int len;
while((len=is.read(buffer))!=-1) {
String s=new String(buffer,0,len);
System.out.println(s);
}
//4.读取输入流中的数据 防止乱码
//baos = new ByteArrayOutputStream();
//byte[] buffer = new byte[5];
//int len;
//while((len = is.read(buffer)) != -1){
// baos.write(buffer,0,len);
//}
//System.out.println(baos.toString());
} catch (IOException e) {
e.printStackTrace();
}
finally {
if(is!=null){
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(socket!=null){
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(ss!=null){
try {
ss.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
3.2实现UDP的网络编程
package com.atguigu.java1;
import org.junit.Test;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
/**
* UDPd协议的网络编程
* @author shkstart
* @create 2019 下午 4:34
*/
public class UDPTest {
//发送端
@Test
public void sender() throws IOException {
DatagramSocket socket = new DatagramSocket();
String str = "我是UDP方式发送的导弹";
byte[] data = str.getBytes();
InetAddress inet = InetAddress.getLocalHost();
DatagramPacket packet = new DatagramPacket(data,0,data.length,inet,9090);
socket.send(packet);
socket.close();
}
//接收端
@Test
public void receiver() throws IOException {
DatagramSocket socket = new DatagramSocket(9090);
byte[] buffer = new byte[100];
DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);
socket.receive(packet);
System.out.println(new String(packet.getData(),0,packet.getLength()));
socket.close();
}
}