java基础 20140316
（十七）java语法之IO流
(一)基本理论
1.文件：数据在物理介质上的一种存储形式
2.目录：文件夹
3.路径：文件夹的位置
4.流的定义：文件与程序之间的管道使用
5.流的分类：
方向：输入流和输出流
类型：字节流byte和字符流char
管道：处理流和节点流
IO包名：java.io.*;
(二)File
1.定义：包含文件的静态信息，不包含文件的操作
2.构造函数：
File("路径+文件名")
File(uri-http 请求流文件定义)
3.常用方法：
exists()该对象是否存在
createNewFile()创建文件或者是目录
getAbsolutePath()获得当前文件的绝对路径
getName()获得文件的名称
isDirectory()判断是否是目录
isFile()是否是一个文件
length()文件的大小
list()遍历某个文件夹下所有的文件
4.以文件为对象
1>.new File("路径+文件名")
2>.打印文件相关信息 canRead() canWriter() length() isFile()
5.以目录为对象
1>.new File("路径")
2>.打印文件夹相关信息
String[] strArr = list();
isDirectory() 是否是目录对象
//打印E:\software\Java方向下的所有文件
String path ="F:\\feiq";
//step1:创建File对象-目录
File dir = new File(path);
//step2:通过dir得到文件列表
String[]strArr = dir.list();
//step3:循环测试
for (StringstrFileName : strArr) {
//判断strFileName是否是文件
StringfilePath = path+"\\"+strFileName;
//创建文件对象
FilefileObject = new File(filePath);
if(fileObject.isFile())
{
System.out.println(strFileName);
}
}
(三)文本文件流的处理 FileReaderFileWriter
1.字符流的继承关系
1>.Reader抽象类，read(char[],startposition,length)
2>.FileReader最终类
1）构造函数
new FileReader(File)File对象创建输入流
new FileReader(path+name)文件路径字符串创建输入流
2）基本函数
intRead() 一个字符一个字符读取
read(char[],s,l)读取部分批量字符
3>. 缓冲流：BufferedReader
File:开水 BufferedReader:水杯 FileReader:口腔
步骤一：建立File对象
Filefobject = new File("f:\\0305.txt");
步骤二：建立FileReader对象-Exception
FileReaderfreader = newFileReader(fobject);
步骤三：建立缓冲区[固定大小]=BufferedReader缓冲流(reader对象)
BufferedReader breader = newBufferedReader(freader);
步骤四：read完成读操作并放入缓冲区中=readline方法读取每行，知道返回结果为null，流读取完成
while(true)
{
Stringstr = breader.readLine();
if(str == null)
{
break;
}
System.out.println(str);
}
步骤五：关闭流
breader.close();
freader.close();
4>.Writer抽象类 write(char[],s,l)
5>.FileWriter最终类
1）构造函数
FileWriter(File对象)
FileWriter(File对象，boolean追加)
FileWriter(String路径)
FileWriter(String路径，boolean追加)
2）基本函数
writer(String,s,l)
6>.BufferedWriter:中间流
//step1:建立File对象
File fobject= new File("f:\\0305.txt");
//step2:建立FileWriter对象
try {
FileWriterfwriter = new FileWriter(fobject,true);
//step3:建立缓冲流BufferedWriter
BufferedWriterbwriter = new BufferedWriter(fwriter);
//step4:写入信息来自控制台输入,循环输入，直到输入E退出
bwriter.write("\r\napple");
//bwriter.newLine();
//step5:关闭流
bwriter.close();
fwriter.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
(四)任何流的处理 FileInputStream,FileOutputStream
1>.继承关系
inputStream输入流父类-->FileInputStream文件输入流
outputStream输出流父类-->FileOutputStream文件输出流
2>.FileInputStream
1).构造函数：
new FileInputStream(File)
new FileInputStream(String)
2).基本方法
available()当前流的可用长度
read(byte[] b, int off, int len)读取流中的部分数据
close()关闭流
//step1:定义File对象f:\\a.txt
File fobject= new File("f:\\a.txt");
if(!fobject.exists())//如果文件不存在
{
//创建文件
fobject.createNewFile();
}
//step2:定义FileInputStream
FileInputStreamfis = new FileInputStream(fobject);
//step3:定义缓冲区
byte[] bResult = new byte[fis.available()];
//step4:读取流
fis.read(bResult);
//step5:关闭流
fis.close();
//step6：显示输入流数据信息
String str = new String(bResult);
System.out.println(str);
3>.FileOutputStream
1).构造函数
FileOutputStream(Filefile)
FileOutputStream(Filefile,boolean append)
FileOutputStream(Stringname)
FileOutputStream(Stringname,boolean append)
2).基本方法
write(byte[] b, int off, int len)
close()
//step1:File
File fobject= new File("f:\\a.txt");
if(!fobject.exists())//如果文件不存在
{
//创建文件
try {
fobject.createNewFile();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//step2:FileOutputStream
try {
FileOutputStreamfos = new FileOutputStream(fobject,true);
//step3:建立写的流的缓冲区
StringstrOut = new Scanner(System.in).nextLine()+"\r\n";
//String=>byte[]
byte[] bResult =strOut.getBytes();
//step4:完成写操作
fos.write(bResult);
//step5:关闭流
fos.close();
} catch(FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
4>.中间流
InputStreamReader
OutputStreamWriter
图片文件：
//f:\a.jpg读取之后存储在e:\a.jpg
//步骤一：读取a.jpg
//step1-1:建立File对象
FilefileIn = new File("f:\\a.jpg");
if(!fileIn.exists())
{
System.out.println("您所需要的文件并不存在");
return;
}
//step1-2:建立FileInputStream
FileInputStreamfis = new FileInputStream(fileIn);
//step1-3:定义缓冲区***********************************************************
byte[] bImage =new byte[fis.available()];
//step1-4: 读取数据信息
fis.read(bImage);
//step1-5:关闭输入流
fis.close();
//步骤二：写入a.jpg
//step2-1:建立File对象
FilefileOut = new File("e:\\a.jpg");
if(!fileOut.exists())
{
fileOut.createNewFile();
}
//step2-2:建立FileOutputStream
FileOutputStreamfos = new FileOutputStream(fileOut);
//step2-4:输出数据信息
fos.write(bImage,0,bImage.length);
//step2-5:关闭输出流
fos.close();
十八、java语法之线程
（一）：线程基本概念
1-1、 1程序：一个可执行的文件或者一段可执行的代码
1进程：是一个程序运行的实例，拥有自己独立的运行内存空间
n线程：一个进程中的不同执行路径，共享一个存储空间
1-2、 特点：
系统的并发多个任务
单CPU多任务机制（时间片）
并发：某个cpu在某个时刻处理一个任务或者一个进程
1-3、 线程的分类
1主线程：启动线程，自动执行，生命周期贯穿整个项目的始终
n子线程：多线程方式，主线程创建主线程控制
守护线程（精灵线程）：后台线程，垃圾回收机制
（二）线程的应用 java.lang.* 默认导入
方式一：通过Thread定义子线程
classMyClass extends Thread{
//函数重写
Publicvoid run(){
//完成子线程的处理
}
}
方式二：通过Runnable接口实现子线程
ClassMyClass implements Runnable{
Publicvoid run(){
}
}
Thread implements Runnable
启动线程：
1：实例化线程对象
MyClassmc = new MyClass();
2：通过Thread类启动线程对象
Thread th = new Thread(mcs);
Th.start()
（三）线程基本方法
1.静态方法
currentThread()得到当前线程对象
sleep(毫秒)
2.基本方法
.getName()
getPriority()1-10 1:Min 10:Max 5:Normal
isAlive()判断当前线程是否活着
join()：合并线程，当前线程合并到该线程中
yield()：把cpu让出，此线程排入队列中
wait()
notify()/notifyAll()
（四）线程应用-时间显示
1.内部类创建线程类定义【lbl.isRun】
2.重写run方法
publicvoid run(){
while(true)//让线程不停止
{
Thread.sleep(1);
While(isRun)//刷新标签
{
Date
SimpleDateFormat
Str= Format()
Lbl.setText(str);
}
}
}
3.构造函数中启动线程
NewThread(new MyThread()).start()
4. isRun= true或false
（五）synchronized互斥锁定概念
1. synchronized块
synchronized（锁定对象）{
//锁定代码
}
2. synchronized函数
public synchronized void fun(){
//锁定函数代码
}
| public class Rukou {
/** * @param args */ public static void main(String[] args) { Account p1 = new Account(); Thread ATM1= new Thread(p1); Thread ATM2 = new Thread(p1); ATM1.start(); ATM2.start();
}
} class Accountextends Thread{ private int money = 2000; public void run(){ while(true) { synchronized (this) { money--; System.out.println(this.getName()+":"+money); } try { Thread.sleep(500); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } } 插卡 输入密码 查询余额 取钱 输入金额 验证金额可行性 取钱 Synchronized（账户） { 账户-- } 交易成功 退卡 |
十九.java语法之网络编程
（一）基本概念
1、三个基本概念
网络： 网线 - 道路
通信： 七层协议 - tel
协议： TCP UDP - 公交车
TCP：有去有回
UPD：有去无回
2、二个主要元素
IP地址：女朋友的家庭地址 –识别主机
端口号：门定义 – 0 – 65535 【1433、1521、3306】 1024以下在MS中被占用80
3、一个包
套接字：Socket
技术模式：Server<->Client
技术代码：流的处理
输入：InputStream– 字节
输出：OutputStream– 字节
（二）基于TCP通信
1、服务器：ServerSocket Socket
2、客户端：Socket
3、IO流
1>输入流: byte[] ->new String(byte[])->String
socket.getInputStream()->InputStreamReader->BufferedReader
2>输出流:
Socket.getOutputStream()->OutputStreamWriter->PrintWriter定向输出
(三)TCP案例：服务器和客户端打招呼，客户端响应服务器
（四）基于UDP通信
1.DatagramSocket 数据发送对象
2.DatagramPacket 数据包
| public class SendClass { public static void main(String[] args) {
while(true) { try { //step1:建立发送对象 DatagramSocket sendScocket = new DatagramSocket(); //step2:建立发送包(buf数据byte[],lenght:数据长度，address：地址，port：端口号) System.out.print("发送信息："); String strIn = new Scanner(System.in).nextLine(); byte[] bMsg = strIn.getBytes(); //准备ip地址 String strIp = "192.168.80.200"; InetAddress address = InetAddress.getByName(strIp);//String=>InetAddress //发送host的port：8888 DatagramPacket pack = new DatagramPacket(bMsg, bMsg.length,address,8888); //step3:发送包 sendScocket.send(pack); //step4:关闭 sendScocket.close();
if(strIn.equals("bye")) { System.out.println("我不再发包了"); break; }
} catch (SocketException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (UnknownHostException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } }
|
| public class ReceiveClass {
/** * @param args */ public static void main(String[] args) {
while(true) { try { System.out.println("建立接收对象>>>>>>>>>>>>"); //step1:建立接收对象 DatagramSocket receiveSocket = new DatagramSocket(8888); //step2:定义接收包(buf=byte[], length) byte[] buf =new byte[1000]; DatagramPacket pack = new DatagramPacket(buf, buf.length); //step3:接收方法 System.out.println("收到信息>>>>>>>>>>>>>"); receiveSocket.receive(pack);//阻塞 //step4:显示接收信息 String str = new String(buf); System.out.println("["+str+"]"); //step5:释放资源 receiveSocket.close();
if(str.indexOf("bye")!=-1) { System.out.println("我不再接收包了"); break; } } catch (SocketException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
}
|
（五）TCP UDP 的区别和优缺点
方法：流 数据包
安全性：高 低
性能：低 高
扫一扫
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
