一.语法
1. 三元运算 
y = (x>1)?'a':200;

2. switch
int a=4,b =2;

char ch = '+';

switch(ch)
{
case '-':
System.out.println(a-b);
break;
case '+':
System.out.println(a+b);
break;
case '*':
System.out.println(a*b);
break;
case '/':
System.out.println(a/b);
break;
default:
System.out.println("feifa");

}

3. 循环
while(先判断)  
do...while(先执行行一次，在判断) 
for(int x = 0; x<3 ; x++)
for(int x : args)

4.  循环内控制
continue;  只能作用于循环结构。继续循环。特点：结束本次循环，继续下一次循环。
break;     退出整个循环

5. break 和 continue
w:for(int x=0; x<3; x++)
{
for(int y=0; y<4; y++)
{
System.out.println("x="+x);
break w;
continue w;
}

6. 函数
public class Fun {
public static void main(String[] args) 
{
int x = getMax(3,4);
}
public static int getMax(int a,int b)
{
return (a>b)?a:b;
}
}

7. 函数重载
public static int getMax(int a,int b){}
public static int getMax(char b){}

8. 数组(看  进制转换_经典)
int[] x = new int[3];
int[] arr = new int[]{3,1,6,5,4};
int[][] arr = {{3,5,1,7},{2,3,5,8},{6,1,8,2}};
int[] x,y[];//x一维，y二维。

9. for 最小值加一，最大值减一
for(int start=0,end=arr.length-1; start

二。对象
1. 对象
1. private :私有。封装。
2. 匿名对象
new Car().run();
3. 构造代码块
给对象进行初始化
{
cry();   //构造代码块
}
4. 构造函数
Person()
{
System.out.println("A: name="+name+",,age="+age);
}
5. this
this代表所属对象
如果this要用在构造函数内，只能用在第一行(或最前几行), 构造函数中调用其它的构造函数要用 this()  ,只能在构造函数间用这种方法
6. static
静态，，用于修饰成员(成员变量，成员函数)
当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，
还可以直接被类名调用。类名.静态成员。
7. 静态代码块。
static
{
静态代码块中的执行语句。
}
8. 加载顺序
静态代码块--构造代码块--构造函数--
9. 单例设计模式--饿汉式，懒汉式
   
饿汉式
class Single
{
private static final Single s = new Single();
private Single(){}
public static Single getInstance()
{
return s;
}
}
懒汉式
public class Lan {
private static Lan s = null;
private Single(){}
public static Lan getInstance()
{
if(s==null)
{
synchronized(Lan.class)
{
if(s==null)
s = new Single();
}
}
return s;
}
}

2. 继承
class Student extends Person
{
void study()
{
System.out.println("good study");
}
}
1. super
2. 重写(覆盖)
子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。
静态只能覆盖静态。
3. 子类中所有的构造函数默认第一行都是super()
3. 抽像  类 方法
abstract class Student
{
abstract final void study();
//abstract void study1();
void sleep()
{
System.out.println("躺着");
}
}
4. 接口
interface   
接口中的成员都有固定修饰符。
常量：public static final
方法：public abstract 
implements   实现

5. 多态性
Animal a = new Cat();//类型提升，向上转型
Cat c = (Cat)a;  //千万不要出现父类转子类 这样的操作(保留意见)
Fu a = new Zi();   调用父类有，而子类没有的方法，用父类的方法。
调用子类有，而父类没有的方法，报错
调用父类有，而子类也有的方法，用子类的方法复写父类的方法。即调用的是子类的方法。
如果父类和子类用的都是static 静态方法。用父类的方法

在多态中，成员变量的特点：
无论编译和运行，都参考左边(引用型变量所属的类)。
在多态中，静态成员函数的特点：
无论编译和运行，都参考做左边。
6. 内部类
当内部类中定义了静态成员，该内部类必须是static的。
当外部类中的静态方法访问内部类时，内部类也必须是static的。
内部类定义在局部时,
不可以被成员修饰符修饰
可以直接访问外部类中的成员，因为还持有外部类中的引用。
但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
1. 静态内部类   --当外部类中的静态方法访问内部类时，内部类也必须是static的。
2. 匿名内部类    
定义匿名内部类的前提：
内部类必须是继承一个类或者实现接口。
匿名内部类的格式：  new 父类或者接口(){定义子类的内容}
匿名内部类中定义的方法最好不要超过3个。
3.
三。异常     实现接口的类中有异常不能throws ,只能try .因为 接口throws不出去
1.语法
try
{
需要被检测的代码；
}
catch(异常类 变量)
{
处理异常的代码；(处理方式)
}
finally
{
一定会执行的语句；
}
2. 获取异常信息
String getMessage()：

3.异常在子父类覆盖中的体现
子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类

8. 包之间的操作
2. import com.etaoko.packa.*;
1. protected  
四。多线程
1. 多线程的两种方法
1. extends Thread   覆盖run() 方法，然后 .start()   ... .start() 一个线程只能用一次
2. implements Runnable   
覆盖run() 方法， 
创建 实现Runnable 的对象
以Thread中(Runable target) 构造函数，创建线程
以Thread中(Runable target) 构造函数，创建线程
....
然后 .start()
.start()
....
2. 同步
1. Object obj = new Object();   给同步创建锁
synchronized (obj) {};       同步,或用this锁 synchronized (this) {}; 如果是static 用synchronized (类.class) {}; 
2. public synchronized void add(int n)   在函数上同步，锁是this，如果是static函数，用 类名.class 对象锁
3. 死锁
五。线程间的通信
1.  同步，如果两个线程执行的代码不同，则同步时，要把两个线程中的相关的代码都同步，加同一个锁
2. 等待唤醒机制  r.wait()  r.notify(); r.notifyAll();   （全用在同步里）
r.notifyAll(); 用于有 多个生产者和多个消费者 的时候，用 while 替换 if 判断标记，然后全部唤醒
while(!flag)
r.wait();
r.notifyAll();
3. Lock()  jdk1.5 的版本
private Lock lock = ReentrantLock();
private Condition1 con = lock.newCondition();
private Condition2 con = lock.newCondition();
lock.lock();
try {
condition1.await();
condition2.signal();
}
finally{lock.unlock();}

4. 停止线程
1. 把循环停下来，以标志位做为循环条件
2. 在同步中，  Thread 中有个方法 interrupt() 中断线程
t1.interrupt();  写在主线程中，t1.start() 之后， 在线程中要用  try {} catch{ flag = false;}
5. 守护线程
t1.setDaemon(true);   //主线程不在(或者说前台线程都不在了)，后台线程自动停止
t2.setDaemon(true);
t1.start();
t2.start();
6. join()
t1.join(); t1要强夺CPU的执行权，这时，主线程是冻结状态，t1线程结束后，主线程才活过来，俗称等t1去死
7. 优先级
t1.start();
t1.setPriority(Thread.Max_PRIORITY);
max_priority
min_priority
norm_priority
8. yield()
暂停当前正在执行的线程对象，执行其它线程
Thread.yield();  可以实现两个线程交替执行
六. String
String[] s3 =new String[]{"a","b","c"};
System.out.println(s1 == s2);
int num = s.codePointAt(0);
int num1 = s.indexOf('d');
System.out.println(s3.getClass());
System.out.println(s3);
System.out.println(new String(s3,2,2));
String a = String(s3);
System.out.println(a);
char[] abc = s.toCharArray();
byte[] abc = s.getBytes();
System.out.println(abc[3]);
String ss = "liusai,lius,liunan,zhangjian,zhangbi";
System.out.println(s.replace('a','x'));
System.out.println(s.replace("abc","xyz"));
String[] ss1 = ss.split(",");
System.out.println(s.substring(2));
System.out.println(s.substring(2,4));
System.out.println(s.toUpperCase().toLowerCase());
System.out.println(s.trim());
System.out.println(s.compareTo(s1));

StringBuffer   //线程同步
StringBuffer sb = new StringBuffer();
sb = sb.append(34);
sb = sb.append("a");
sb = sb.append('a');
sb = sb.insert(2, "zzyyxxaabbcc");
sb = sb.delete(3, 5);
sb = sb.deleteCharAt(3);
sb = sb.delete(0, sb.length());  //清空StringBuffer
sb = sb.reverse();
System.out.println(sb);
char[] chs = new char[6];
sb.getChars(2, 5, chs,2);    //将指定位置指定长度的字符存入 char 型数组

StringBuilder //与StringBuffer相同，但是线程不同步

对象的包装类
byte Byte
short short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character
基本数据类型改成字符串
基本数据类型+"";   或
基本数据类型.toString(基本数据类型值);
如：  Integet.toString(34);  //将34整数变成"34"
int num = Integet.parseInt("123");   //把字符串"123"变成整成123;
自动装箱  1.5新特性
//Integer x = new Integer(4);
Integer x = 4; //自动装箱
x = x +2;   //1.5新特性，将 x 拆箱成int ，+2后在装箱，但x不能为null;
Integer a = 127;
Integer b = 127;   //a=b,因为 1.5新特性，如果在一个byte内，就不开劈新空间;

七。集合框架
1. ArrayList 最常用的集合 线程不同步 // (Vector  线程同步)   // LinkedList 
ArrayList a1 = new ArrayList();
a1.add("java01");
a1.add("java02");
a1.add("java03");
a1.add("java04");
System.out.println(a1);
ArrayList a2 = new ArrayList();
a2.add("java03");
a2.add("java04");
a2.add("java05");
a2.add("java06");
System.out.println(a2);
a1.retainAll(a2);
a1.addAll(a2);
a1.removeAll(a2);
System.out.println(a1);
a1.contains(obj)  //判断集合中的元素是否相同

2. 迭代器   Iterator //只能 .remove 
Iterator it = a1.iterator();   //但这种方法，变量it在while循环完后还存在，占用内存。所以一般用for 循环，将it变量定义在循环内部
while(it.hasNext())
{
System.out.println(it.next());
}

for(Iterator it1 = a1.iterator();it1.hasNext();)
{
System.out.println(it1.next());
}

3. 迭代器 ListIterator // Iterator的子类，list集合特有，可以对集合 增，删，改，查
ListIterator it = a1.listIterator();
while(it.hasNext())
{
System.out.println(it.next());
}
while(it.hasPrevious())
{
System.out.println(it.previous());
}

4. Vector //枚举取出，与迭代器相同 
Enumeration en = v.elements();
while(en.hasMoreElements())
{
System.out.println(en.nextElement());
}

5. LinkedList
LinkedList ll = new LinkedList();
ll.add("java01");
ll.add("java02");
ll.addFirst("java03");
ll.addLast("java04");
System.out.println(ll);
ll.removeFirst();
System.out.println(ll);
ll.pollFirst();  //remove
ll.peekFirst(); //get
ll.offerFirst(); //set
6. 存自定义类Person
取的时候要
Person p = (Person)ll.next();

7. List集合 用equals ，set集合用 hashCode

8. HashSet  // Set集合中的值无序，不允许有重复
HashSet 每存入一个值的时候，会和现有元素比较，(先用hashCope(),在用 equals())
所以，一般要复写hashCope(),equals()
例： hashCope(){return name.hashCope()+age*39} 
9. TreeSet //不以存入先后为序，但以元素的比值排序了
因为要排序，所以，TreeSet中的元素要据有比较性，或者叫容器自身据有比较性。以容器比较性优先
所以要 implements Comparable ,并复写
TreeSet ts = new TreeSet();
ts.add(new Student("jiangxi",29));
ts.add(new Student("runyu",25));
ts.add(new Student("liusai",25));
ts.add(new Student("lixiao",31));
Iterator it = ts.iterator();
while(it.hasNext()){
Student stu = (Student)it.next();
System.out.println(stu.getName());
}

public int compareTo(Object obj) 
{
if(!(obj instanceof Student))
throw new RuntimeException("not is Student");
Student s = (Student) obj;
if(this.age>s.age)
return 1;
if(this.age==s.age)
return this.name.compareTo(s.name);
return -1;
}

TreeSet ts = new TreeSet(new MyCompare); //较常用

10. 泛型
eques(); 方法不能用泛型
TreeSet ts = new TreeSet();  使用泛型
 //定义泛型类，泛型类，QQ就是一个泛型，可以指定任意类型
public class FanXing {
private QQ q;

public QQ getQ() {
return q;
}

public void setQ(QQ q) {
this.q = q;
}

}
类上定义的泛型对整个对象有校

泛型定义在方法上
public void show(T t)

静态方法上的泛型
静态方法不可以访问类上定义的泛型，
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上
public static void method(W t){} //泛型放在返回值类型的前面
泛型定义在接口上
interface Inter
class Aa implements Inter    // 泛型在定义类的时候指定，创建Aa对象的时候就不能指定了
class Aa implements Inter    //创建Aa类的时候不指定T的类型，则可以在创建Aa对象的时候指定

泛型通配符 ?
用 ? 不能使用类型特有方法
泛型限定
? extends Person  上限
? super E     下限

11. Map 集合
key -- value;  Map存的是键与值的映射关系
Hashtable  不可以存null ,同步
HashMap    哈希表数据结构，允许Null,不同步
TreeMap 二驻树，不同步，可以用于给map集合中的键排序
和set 很像
其实set底层就是使用了map集合
HashMap hm = new HashMap();
hm.put("a1", 1);
hm.put("a2",2);
hm.put("a3", "aaaa");
hm.put(1, 4);
System.out.println(hm.get(null));
System.out.println(hm);

map.put的时候，如果有重复键，将把此键的原来的值返回，并用新值替换原来的值

keySet : 把map每个键的值，都存入Set集合
Set keySet = map.keySet();  //然后可用迭代器取出 keySet 的值

entrySet() : 把映射关系存入Set集合，类型为 Map.Entry
Set> entrySet = hm.entrySet();
Iterator> it = entrySet.iterator();
while(it.hasNext())
{
Map.Entry me = it.next();
String key = me.getKey();
String value = me.getValue();
System.out.println(key+"...."+value);
}
12. 工具类
Collections 对集合进行操作
Collections.sort(list); 对list进行排序;
Collection.max();
Collection.binarySearch();  //二分搜索，以获得指定对象，必须有序
Collection.reverse();      
TreeSet ts = new TreeSet(Collections.reverseOrder());  //反转集合顺序
TreeSet ts = new TreeSet(Collections.reverseOrder(比较类));  //把现有的比较类反转

Collection.synchronizedList()  //将list同步
Collection.synchronizedMap()   //将Map集合同步
Collection.shuffle(list);  //重新随机排放元素

13. Arrays
对数组进行操作

八。其它对象
1. System   //Properties  集合，hashTable的子类，属于Map
System.out.println(System.getProperty("mykey"));
Properties prop = System.getProperties();
System.setProperty("mykey", "myvalue");
//java -Dmykey=myvalue 1.java
for(Object obj : prop.keySet())
{
String value = (String)prop.get(obj);
System.out.println(obj+"...::..."+value);
}

2. Runtime 
Runtime r = Runtime.getRuntime();   
Process p = r.exec("mstsc.exe");   //打开系统程序
Process p1 = r.exec(notepad.exe Index.java);  //用notepad 打开Index.java文本文件
p.destroy();  //杀死进程

3. Date || Calendar
Date d = new Date();
System.out.println(d);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 E hh:mm:ss");
String time = sdf.format(d);
System.out.println(time);

Calendar c = Calendar.getInstance();
System.out.println(c.get(Calendar.YEAR));
c.set(2012,2,23);   // 2 表示3月
c.add(Calendar.DAY_OF_MONTH,-8);

4. Math
double d = Math.ceil(16.34);  17
double d1 = Math.floor(12.34);  12
long l =Math.round();  四舍五入
double d2 = Math.pow(2,3)  2的3次方
int dd = (int)(Math.random()*10+1);    //产生随机数
Random r = new java.util.Random; int dd = r.nextInt(10); //也是产生随机数

九。IO流
InputStream  OutputStream Reader Writer

1. FileWriter
FileWriter fw = new FileWriter("demo.txt");  //创建空文件，如果已存在，则覆盖
FileWriter fw = new FileWriter("demo.txt",true);  //如果已存在，则在文件中追加，如果不存在，创建此文件
fw.write("abcde\r\nsdfsd");  //在缓冲，没写到文件,\r\n是换行
fw.flush();        //刷新到文件
fw.close();      //刷新并关闭

2. IO异常处理
FileWriter fw = null;
try 
{
fw = new FileWriter("demo.txt",true);
fw.write("abcde");  //在缓冲，没写到文件
fw.flush();        //刷新到文件
} 
catch (IOException e) 
{
// TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
try 
{
if(fw!=null)
fw.close();
} 
catch (IOException e) 
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}

3. FileReader
FileReader fr = new FileReader("demo.txt");
fr.read();  读一个节符，返回 -1 则表示读完
char[] buf = new char[3];
fr.read(buf);   //数据长3，所以读3个字符后就不读了
char[] buf1 = new char[3];
fr.read(buf1);   //继续读下面的字符
4. 读入字符数组
char[] buf = new char[1024];
int num = 0;
while((num=frr.read(buf)) != -1)
{
System.out.println(new String(buf,0,num));
}
frr.close();

5. BufferedWriter  字符写缓冲区
FileWrite fw = new FileWriter("buf.txt");
BufferedWriter bufw = new BufferedWriter(fw);
bufw.write("abcde");
bufw.newLine(); //写入一个行分隔符
bufw.flush();
bufw.close();

6. BufferedReader  //字符读缓冲区
bufr.readLine();    //一次读一行，但不包括换行符
FileReader fr = new FileReader("demo.txt");
BufferedReader bufr = new BufferedReader(fr);
String line = null;
while((line=bufr.readLine()) != null )
{
System.out.println(line);  
}
bufr.close();

7. 装饰设计模式
对原有对象的功能的增强，要传入一个对象

8. 装饰与继承的区别
MyReader
|--MyT
|--MyBufferT
|--MyM
|--MyBufferM
这样，MyReader 类下每多一个子类，就要在子类上加一个MyBuffer
而装饰类可以接收一个MyReader类型的对象，然后对这个对象进行增强

9. LineNumberReader 类
setLineNumberReader(100);   //设置第一行的行号为100，第二行为101....
getLineNumberReader();       显示行号

11. OutputStream  写，InputStream  读
FileOutputStream fos = new FileOutputStream("fos.txt");
fos.write("abcde".getBytes());  //不用flush,直接进文件
fos.close();
FileInputStream fis = new FileInputStream("fos.txt");   //读文件
byte[] a = new byte[5];
int ch = 0;
while((ch = fis.read(a)) != -1)
{
System.out.println(new String(a,0,ch));
picw.write(a,0,ch);
}
fis.available();

12. BufferedStream  //字节读写缓冲区
BufferedInputStream bufis = new BufferedInputStream(new BufferedInputStream("c:/2.mp3"));
BufferedOutputStream bufis = new BufferedOutputStream(new BufferedOutputStream("c:/1.mp3"));

13. 读取键盘录入
BufferedReader bufw = new BufferedReader(new OutputStreamReader(System.in));
写入键盘输出
BufferedWriter bufw = new BufferedWriter(new OutputStreamWrite(System.out));
改变键盘录入源
System.setIn(new FileInputStream("aa.java"));
System.setOut(new PrintStream("aa.java"));

PrintStream("aaa.txt");  把输出信息输入到文件

14. File 
File f = new File("file.txt");
f.createNewfile();   //没有，则创建文件，有，则不创建
deleteOnExit();
f.delete();
f.canExecute();  //是否可执行
f.exists()    是否存在
f.mkdir  //创建file.txt名的文件夹
f.mkdirs  //创建多级文件夹
f.isFile();   是不是文件
f.isDirectory();    是不是目录
f.isHidden();   //是不是隐藏文件
f.isAbsolute();     参数中的文件是不是绝对路径，不管这个文件是否存在
f.getName();
f.getPath();    相对路径包含文件名
f.getParent();   //参数中指定了绝对路径，则返回绝对路径(不包含文件名)，否则为null
f.getAbsolutePath();     绝对路径包含文件名
f.lastModified();   最后修改时间
f.length();   大小
File f1 = new File("file1.txt");
f.renameTo(f1)   重命名，或移动文件

File[] files = File.listRoots();
for(File f : files){System.out.println(f);}   //得到系统现有的盘符

File f = new File("c"\\");
String[] names = f.list();
for(String name : names ) { System.out.println(name); }  //打印C盘下所有文件

FilenameFilter  是个接口类型 ，接口下只有一个方法
取download 目录下的.txt
File dir = new File("D:/Download");
String[] arr = dir.list(new FilenameFilter()
{
public boolean accept(File dir,String name)
{
return name.endsWith(".txt");
}
}
);
for(String name : arr) {System.out.println(name);}

f.listFiles()  //获取文件夹下的文件对象

Properties  hashtable 的子类。
Properties prop = new Properties();
File file = new File("count.ini");
if(!file.exists())
file.createNewFile();
FileInputStream fis = new FileInputStream(file);
prop.load(fis);
int count=0;
String value = prop.getProperty("time");
if(value!=null)
count=Integer.parseInt(value);
count++;
prop.setProperty("time",count+"");
FileOutputstream fos = new FileOutputStream(file);
prop.store(fos,"");
fos.close();
fis.close();

PrintStream();
PrintWriter();
SequenceInputStream;  合并流

切割文件
FileInputStream fis = new FileInputStream("c:\\1.bmp");
FileOutputStream fos = null;
byte[] buf = new byte[1024*1024];
int len=0;
int count =1;
while((len=fis.read(buf)) != -1 )
{
fos=new FileOutputStream("c:\splitfiles\\"+(count++)+".part");
fos.write(buf,0,len);
fos.close();
}
fis.close();

对象的持久化，把对象存在硬盘上
类 implements Serializable 才能被序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Person.class"));
oos.writeobject(new Person());  写硬盘
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Person1.class"));
oos.writeobject(new Person());  写硬盘

ObjectInputStream
Person.Object

从硬盘上读一个对象
ObjectInputStream oos = new ObjectInputStream("Person.class");   
Person p = (Person)ois.readObject();  读硬盘 
Person p1 = (Person)ois.readObject();  读硬盘

public static final long serialVersionUID = 42L;  自己定义UID，为了序列化方便

静态是不能被序列化的
transient int age; transient 关键字修饰的  也不能被序列化

管道流
管道输入流   管道输出流
PipedInputStream in = new PipedInputStream ();
PipedOutputStream out = new PipedOutputStream();
Read r = new Read(in);   //线程类
Write w = new Write(out);  //线程类

RandomAccessFile  随机访问文件，只能操作文件。可读，也可写
r  读文件，文件不存在报异常
rw  读写，文件若存在，不会覆盖

RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
raf.write("李四".getBytes());
raf.write(97);   这里的97会变成 a ，码表

RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
raf.read(buf);  //读
raf.seek(8);   //调整对象中指针

可随机读，也可以随机写，如果所写的指针上有数据，则被覆盖

DataStream  操作基本数据类型的流对象
ByteArrayInputStream

OutputStreamWriter  转换流，字节转字符输出到硬盘文件
InputStreamReader           字符文件输入到内存转字节

十。网络
1. 获取IP地址
i1 = InetAddress.getByName("www.baidu.com");
System.out.println(i1.toString());
System.out.println(i1.getHostAddress());
System.out.println(i1.getHostName());

2. 获取IP地址数组
InetAddress i1[] = InetAddress.getAllByName("www.baidu.com");

3. UDP 无连接，一次不能超过64K

发送数据包
DatagramSocket ds = null;
ds = new DatagramSocket(10000);   //端口，不指定则随机
byte[] buf = "udp ge men lai le".getBytes();
DatagramPacket dp = null;
dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("172.16.2.109"),1000);
ds.send(dp);
ds.close();

接收数据包
DatagramSocket ds = null;
ds = new DatagramSocket(10000);
while(true)
{
byte[] buf = new byte[1024];
DatagramPacket dp = null;
dp = new DatagramPacket(buf,buf.length);
ds.recive(dp);
String ip = ip.getAddress().getHostAddress();
String data = new String(dp.getData(),0,dp.getLength());

}
ds.close();

TCP  面向连接--客户端
Socket s = new Socket("192.168.1.254",10003);
OutputStream out = s.getOutputStream();
out.write("tcp ge men lai le ".getBytes());
byte[] buf = new byte[1024];
int len.read(buf);
System.out.println(new String(buf,0,len));
s.close();

TCP 服务端   //socket可关闭，可不关闭
ServerSocket ss = new ServerSocket(10003);
Socket s = ss.accept();   //接收客户端数据
InputStream in = s.getInputStream();
byte[] buf = new byte[1024];
int len = in.read(buf);
System.out.println(new String(buf,0,len));
OutputStream out = s.getOutputStream();
out.write("Hello World!".getBytes());
s.close();  //关闭客户端;
ss.close();  可选

4. URL  
URL url = new URL("http://192.168.1.254/myweb/demo.html?name=haha&age=30");
int port = getPort();
if(port==-1)
port = 80;
System.out.println("getProtocol() :"+url.getProtocol());
System.out.println("getHost() :"+url.getHost());
System.out.println("getPort() :"+url.getPort());               //
System.out.println("getPath() :"+url.getPath());
System.out.println("getFile() :"+url.getFile());
System.out.println("getQuery() :"+url.getQuery());

5. URLConnection
URL url = new URL("http://192.168.1.254:8080/myweb/demo.html");

URLConnection conn = url.openConnection();
System.out.println(conn);

InputStream in = conn.getInputStream();

byte[] buf = new byte[1024];

int len = in.read(buf);

System.out.println(new String(buf,0,len));

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/29798713/viewspace-1664440/，如需转载，请注明出处，否则将追究法律责任。