java udp文件_Java对文件的操作及UDP,TCP
1.文本文件复制
/*
将C盘下的一个文本文件复制到D盘下。
其实就是将C盘下的文件数据存储到D盘下的一个文件中
步骤：
1.在D盘中创建一个文件，用于存储C盘文件中的数据。
2.定义读取流和C盘文件关联
3.通过不断的读写完成数据存储。
4.关闭资源。
*/
//方法一
import java.io.*;
class CopyText {
public static void main(String[] args) throws IOException{
copy();
}
public static void copy(){
FileReader fr = null;
FileWriter fw = null;
try{
fr = new FileReader("c:\\demo.txt");
fw = new FileWriter("d:\\demoD.txt",true);
char[] buf = new char[1024];
int len = 0;
while((len=fr.read(buf))!=-1){
fw.write(buf,0,len);
}
}catch (IOException e){
throw new RuntimeException("读写失败");
}finally{
if(fr!=null)
try{
fr.close();
}catch (IOException e){
System.out.println(e.toString());
}
if(fw!=null)
try{
fw.close();
}catch (IOException e){
System.out.println(e.toString());
}
}
}
}
//方法二
/*
通过缓冲区复制一个文本文件。
*/
import java.io.*;
class CopyTextByBuf{
public static void main(String[] args){
BufferedWriter bufw = null;
BufferedReader bufr = null;
try
{
bufw = new BufferedWriter(new FileWriter("e:\\bufD.txt",true));
bufr = new BufferedReader(new FileReader("c:\\buf.txt"));
String line = null;//相当于中转站。
while((line=bufr.readLine())!=null)
{
bufw.write(line);
bufw.newLine();
bufw.flush();
}
}
catch (IOException e)
{
throw new RuntimeException("读写失败");
}
finally
{
if(bufw!=null)
try
{
bufw.close();
}
catch (IOException e)
{
throw new RuntimeException("写入关闭失败");
}
if(bufr!=null)
try
{
bufr.close();
}
catch (IOException e)
{
throw new RuntimeException("读取关闭失败");
}
}
}
}
2.二进制文件(图片，视频等)复制
/*
复制一个图片(不要拿字符流处理媒体文件，字符流只处理文字数据)
思路：
1.用字节读取流对象和图片关联
2.用字节写入流对象创建一个图片文件，用于存储获取到的图片数据。
3.通过循环读写，完成数据的存储
4.关闭资源。
*/
import java.io.*;
class CopyPic
{
public static void main(String[] args)
{
FileOutputStream fos = null;
FileInputStream fis = null;
try
{
fos = new FileOutputStream("CopyofSrc.png");
fis = new FileInputStream("src.jpg");
byte[] buf = new byte[fis.available()];//定义一个刚刚好的缓冲区，不用再循环了。
int len = 0;
while((len = fis.read(buf))!=-1)
{
fos.write(buf);
}
}
catch (IOException e)
{
throw new RuntimeException("读写失败");
}
finally
{
try
{
if(fos!=null)
fos.close();
}
catch (IOException e)
{
throw new RuntimeException("写入失败");
}
try
{
if(fis!=null)
fis.close();
}
catch (IOException e)
{
throw new RuntimeException("读取失败");
}
}
}
}
3.标准键盘读取/标准控制台输出
//读取键盘输入的最常见写法。
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
//写入控制台的最常用写法。
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
4.UDP
/*
编写一个聊天程序
有收数据的部分和发数据的部分
这两部分需要同时执行，那就需要用到多线程技术，
一个线程控制接收，一个线程控制发送。
因为收和发动作是不一致的，所以要定义两个run方法，
而且这两个方法要封装到不同的类中。
*/
import java.io.*;
import java.net.*;
class Send implements Runnable
{
private DatagramSocket ds ;
public Send(DatagramSocket ds)
{
this.ds = ds;
}
public void run()
{
try
{
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));
String line = null;
while((line = bufr.readLine())!= null)
{
if("886".equals(line))
break;
byte[] buf = line.getBytes();
DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("localhost"),10003);
ds.send(dp);
}
}
catch (Exception e)
{
throw new RuntimeException("发送端失败");
}
}
}
class Rece implements Runnable
{
private DatagramSocket ds ;
public Rece(DatagramSocket ds)
{
this.ds = ds;
}
public void run()
{
try
{
while(true)
{
byte[] buf = new byte[1024*64];
DatagramPacket dp = new DatagramPacket(buf,buf.length);
ds.receive(dp);
String ip = dp.getAddress().getHostAddress();
String data = new String(dp.getData(),0,dp.getLength());
System.out.println(ip+":"+data);
}
}
catch (Exception e)
{
throw new RuntimeException("接收端失败");
}
}
}
class ChatDemo //必须掌握
{
public static void main(String[] args) throws Exception
{
DatagramSocket sendSocket = new DatagramSocket();
DatagramSocket receSocket = new DatagramSocket(10003);
new Thread(new Send(sendSocket)).start();
new Thread(new Rece(receSocket)).start();
}
}
5.TCP
/*
需求：客户端并发上传图片
*/
/*
客户端
1.服务端点
2.读取客户端已有的图片数据
3.通过socket输出流将数据发给服务端
4.读取服务端反馈信息
5.关闭
*/
import java.io.*;
import java.net.*;
class UploadPicClient
{
public static void main(String[] args) throws IOException
{
//主函数传参数 java UploadPicClient c:\1.png
if(args.length!=1)
{
System.out.println("请选择一个jpg格式的图片文件");
return;
}
File file = new File(args[0]);
if(!(file.exists()&&file.isFile()))
{
System.out.println("上传的文件不存在或者不是文件");
return ;
}
if(!(file.getName().endsWith(".png")))
{
System.out.println("上传的文件格式不正确,请重新选择！");
return;
}
if(file.length()>1024*1024*5)
{
System.out.println("文件过大，不安好心，重新选择 ！");
return;
}
Socket s = new Socket("localhost",50005);
FileInputStream in = new FileInputStream(file);
OutputStream out = s.getOutputStream();
byte[] buf = new byte[1024];
int len = 0 ;
while((len = in.read(buf))!=-1)
{
out.write(buf,0,len);
}
//告诉服务器数据写完了。
s.shutdownOutput();
InputStream is = s.getInputStream();
byte[] bufIn = new byte[1024];
int num = is.read(bufIn);
System.out.println(new String(bufIn,0,num));
s.close();
in.close();
}
}
/*
服务端
这个服务端有个局限性，当A客户端连接上以后，被服务端获取到，服务端执行具体流程。
这时B客户端连接，只有等待
因为服务端还没有处理完A客户端的请求，还要循环回来执行下次accept方法，所以
暂时获取不到B客户端对象。
那么为了可以让多个客户端同时并发访问服务端，
那么服务端最好就是将每个客户端封装到一个单独的线程中，这样，就可以
同时处理多个客户端请求。
如何定义线程呢？
只要明确了每一个客户端要在服务端执行的代码即可，将该代码存入run方法中。
*/
class PicThread implements Runnable
{
private Socket s ;
PicThread(Socket s )
{
this.s = s;
}
public void run()
{
String ip = s.getInetAddress().getHostAddress();
int num = 1;//只能定义在函数内，在外的话是共享数据，不行的。
try
{
System.out.println(ip+".....connected");
InputStream in = s.getInputStream();
File file = new File("d:\\server.png");
while(file.exists())
file = new File("d:\\server("+(num++)+").png");
FileOutputStream out = new FileOutputStream(file);
byte[] buf = new byte[1024];
int len = 0 ;
while((len = in.read(buf))!=-1)
{
out.write(buf,0,len);
}
OutputStream os = s.getOutputStream();
os.write("上传图片成功！！".getBytes());
out.close();
s.close();
}
catch (Exception e)
{
throw new RuntimeException(ip+"上传失败^_^");
}
}
}
class UploadPicServer
{
public static void main(String[] args) throws IOException
{
ServerSocket ss = new ServerSocket(50005);
while(true)
{
Socket s = ss.accept();
new Thread(new PicThread(s)).start();//服务器多线程玩法，几乎所有服务器都这么玩。
}
}
}
6.多线程实现方式
//方法一：
/*
创建两个线程，和主线程交替运行
线程都有自己默认的名称
Thread-编号 该编号从0开始
static Thread currentThread():获取当前线程对象。
getName():获取线程名称。
设置线程名称：setName或者通过构造函数
*/
class Test extends Thread
{
public Test(String name)
{
super(name);//通过构造函数给线程取名。
}
public void run(){
for(int x = 0;x <10;x++)
{
System.out.println((Thread.currentThread()==this)+"...."+this.getName()+"run..."+x);
}
}
}
class ThreadTest
{
public static void main(String[] args)
{
Test t1 = new Test("one----");
Test t2 = new Test("two++++");
t1.start();
t2.start();
for(int i = 0 ;i<20;i++)
System.out.println("hello world"+i);
}
}
//方法二
class Ticket implements Runnable
{
private int tick = 10;
public void run()
{
while(true)
{
if(tick>0)
{
System.out.println(Thread.currentThread().getName()+"sale:"+tick--);
}
}
}
}
class TicketDemo
{
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
Thread t4 = new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
7.死锁/线程间通信
/*
死锁程序经典案例。面试可以用
*/
class Test implements Runnable
{
private boolean flag;
Test(boolean flag)
{
this.flag = flag;
}
public void run()
{
if(flag)
{
while(true)
{
synchronized(MyLock.locka)
{
System.out.println("if locka");
synchronized(MyLock.lockb)
{
System.out.println("if lockb");
}
}
}
}
else
{
while(true)
{
synchronized(MyLock.lockb)
{
System.out.println("else lockb");
synchronized(MyLock.locka)
{
System.out.println("else locka");
}
}
}
}
}
}
class MyLock
{
static Object locka = new Object();
static Object lockb = new Object();
}
class DeadLockTest
{
public static void main(String[] args)
{
Thread t1= new Thread(new Test(true));
Thread t2= new Thread(new Test(false));
t1.start();
t2.start();
}
}
/*
经典：面试用。
JDK1.5中提供了多线程升级解决方案
将同步synchronized替换成显示的Lock操作
将Object中的wait,notify,notifyAll,替换了condition对象。
该对象可以通过Lock锁进行获取
该示例中，实现了本方只唤醒对方的操作。
*/
class Resource
{
private String name;
private int count = 1;
private boolean flag = false;
private Lock lock = new ReentrantLock();
private Condition condition_pro = lock.newCondition();
private Condition condition_con = lock.newCondition();
public void set(String name)throws InterruptedException
{
lock.lock();
try
{
while(flag)
condition_pro.await();
this.name = name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"...生产者........."+this.name);
flag = true;
condition_con.signal();
}finally
{
lock.unlock();//释放锁的动作一定要执行，放在finally里面
}
}
public void out()throws InterruptedException
{
lock.lock();
try
{
while(!flag)
condition_con.await();
System.out.println(Thread.currentThread().getName()+"...消费者..."+this.name);
flag = false;
condition_pro.signal();
}finally
{
lock.unlock();
}
}
}
class Producer implements Runnable
{
private Resource res;
Producer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
try
{
res.set("+商品+");
}
catch (InterruptedException e)
{
}
}
}
}
class Consumer implements Runnable
{
private Resource res;
Consumer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
try
{
res.out();
}
catch (InterruptedException e)
{
}
}
}
}
/*
线程间通讯：
其实就是多个线程在操作同一个资源
但是操作的动作不同。
*/
class Res
{
private String name;
private String sex;
private boolean flag = false;
public synchronized void set(String name,String sex)
{
this.name = name;
this.sex = sex;
}
public synchronized void out()
{
System.out.println(name+"....."+sex);
}
}
class Input implements Runnable
{
private Res r;
//Object obj = new Object();
Input(Res r)
{
this.r = r;
}
public void run()
{
int x = 0;
while(true)
{
//synchronized(Input.class) 只要在内存中是唯一的对象就行
synchronized(r)
{
if(r.flag)
try{r.wait();}catch(Exception e){}
if(x == 0)
{
r.name = "mike";
r.sex = "man";
}
else
{
r.name = "丽丽";
r.sex = "女";
}
x = (x+1)%2;
r.flag = true;
r.notify();
}
}
}
}
class Output implements Runnable
{
private Res r;
//Object obj = new Object();
Output(Res r)
{
this.r = r;
}
public void run()
{
while(true)
{
//synchronized(Input.class) 只要在内存中是唯一的对象就行
synchronized(r)
{
if(!r.flag)
try{r.wait();}catch(Exception e){}
System.out.println(r.name+"..."+r.sex);
r.flag = false;
r.notify();
}
}
}
}
class InputOutput
{
public static void main(String[] args)
{
Res r = new Res();
Input in = new Input(r);
Output op = new Output(r);
Thread t1 = new Thread(in);
Thread t2 = new Thread(op);
t1.start();
t2.start();
}
}
/*
wait():
nofity():
notifyAll():
都使用在同步中，因为要对持有监视器(锁)的线程操作。
所以要使用在同步中，因为只有同步才具有锁。
为什么这些操作线程的方法要定义在Object类中呢？
因为这些方法在操作同步中线程时，都必须要标识它们所操作线程持有的锁，
只有同一个锁上的被等待线程，可以被同一个锁上的notify唤醒，
不可以对不同锁中的线程进行唤醒。
也就是说，等待和唤醒必须是同一个锁，而锁可以是任意对象，所以
可以被任意对象调用的方法定义在Object类中。
*/
java udp文件_Java对文件的操作及UDP,TCP相关推荐
- java中的文件_JAVA中文件的操作
在java中,对文件(例如图片)进行操作,包括上传.修改.删除 一,文件上传 1.文件传到哪里,不仅可以保存在数据库中,也可以上传到远程服务器,文件保存的是文件的路径 2.文件上传都需要做什么?写那些 ...
- java 读取浏览器_JAVA读取文件流,设置浏览器下载或直接预览操作
最近项目需要在浏览器中通过URL预览图片.但发现浏览器始终默认下载,而不是预览.研究了一下,发现了问题: // 设置response的Header,注意这句,如果开启,默认浏览器会进行下载操作,如果注 ...
- java 内存读写文件_Java的文件读写操作
file(内存)----输入流---->[程序]----输出流---->file(内存) 当我们读写文本文件的时候,采用Reader是非常方便的,比如FileReader,InputStr ...
- java用浏览器下载文件_JAVA读取文件流,设置浏览器下载或直接预览操作
最近项目需要在浏览器中通过url预览图片.但发现浏览器始终默认下载,而不是预览.研究了一下,发现了问题: // 设置response的header,注意这句,如果开启,默认浏览器会进行下载操作,如果注 ...
- java浏览器预览文件_JAVA读取文件流,设置浏览器下载或直接预览操作
最近项目需要在浏览器中通过URL预览图片.但发现浏览器始终默认下载,而不是预览.研究了一下,发现了问题: // 设置response的Header,注意这句,如果开启,默认浏览器会进行下载操作,如果注 ...
- java io删除文件_java IO 文件操作方法总结
java IO 文件操作方法总结 对于输入输出的理解: 输入输出,以程序为参考点,外部数据进入程序,通过输入流完成.程序将数据给外部设备,通过输出流完成. 文件Io的操作 //获取文件 File fi ...
- java action上传文件_java实现文件上传
在Java中,要实现文件上传,可以有两种方式: 1.通过Servlet类上传 2.通过Struts框架实现上传 这两种方式的根本还是通过Servlet进行IO流的操作. 一.通过Servlet类上传 ...
- java aio复制文件_java复制文件的4种方式及拷贝文件到另一个目录下的实例代码...
尽管Java提供了一个可以处理文件的IO操作类. 但是没有一个复制文件的方法. 复制文件是一个重要的操作,当你的程序必须处理很多文件相关的时候. 然而有几种方法可以进行Java文件复制操作,下面列举出 ...
- java 正则表达式 电话_Java读取文件及基于正则表达式的获取电话号码功能详解...
本文实例讲述了Java读取文件及基于正则表达式的获取电话号码功能.分享给大家供大家参考,具体如下: 1.正则表达式 正则表达式,又称 正规表示法 . 常规表示法 (英语:Regular Express ...
- java json上传文件_java实现文件上传
最近自己在做一个小系统玩的时候涉及到了文件的上传,于是在网上找到Java上传文件的方案,最后确定使用common-fileupload实现上传操作. 需求说明 用户添加页面有一个"上传&qu ...
最新文章
- Python相对导入导致SystemError的解决方案（译）
- 如何混合编译C语言和C++
- 微信小程序开发之https从无到有
- mysql 未找到命令_MySQL主从复制配置说明，一文教你搞懂数据库主从复制
- jdbc连接gp单例模式_JDBC连接备忘单
- 京东到家公布双十二成绩：销售额同比增长1.2倍
- 大数据时代，新起的数据有哪几种模型
- kafka+线程池+Runnable
- Docker 提供外部访问
- Visual SVN Server
- 【渝粤题库】广东开放大学 服务质量管理 形成性考核
- proe常用c语言语句,Proe如何使用if条件语句？
- bms中soh计算方式_原创丨BMS算法中关于健康状态（SOH）的模型设计
- 统计专业人数 （10 分）
- PDF 签章图片不显示问题
- 频繁的去跳槽真的有这么可怕吗？
- Web安全之SQL注入漏洞学习（七）-堆叠注入
- 情感驿站 | 如何构建自己的知识体系？
- CF 246C Beauty Pageant
- 开源网安亮相粤港澳大湾区CIO高峰论坛，保障企业数字化安全转型
热门文章
- 【hadoop】ipc.Client: Retrying connect to server: xxx:8020. Already tried 37 time(s) RetryPolicy[Multi
- Spring : Spring容器之SmartLifeCycle的简单使用
- navicat为什么收费，用的人还是不少
- 分布式定时任务框架选型，写得太好了！
- for、foreach、stream 哪家的效率更高，你真的用对了吗？
- 使用Flask-SQLAlchemy插件操作MySQL
- 华软java_广州大学华软软件学院《Java程序设计》期末复习
- java时间格式转换_Java时间日期格式转换
- js中数组的操作方法
- MySQL 性能分析 之 联合索引(复合索引)实践分析