Java基础知识整理

对象：指的是客观的事物

面向对象：找到对象---调用对象的方法

类：对象的抽取，对象的模板，客观事物在人脑中的主观的反映

流和文件使用完了必须要关闭.

实例变量：1.定义在类以内，方法以外的 2.有默认值，可以先不赋值 3.作用域至少在全类内有效 4.可以和局部变量命名一致，局部优先

方法（声明能干什么）有返回类型，方法名，参数名，抛出异常

方法体：怎么去干

重载（overloading）1、方法名相同，2参数列表不同3.返回值没有要求
编译时多态：就近类型匹配
构造方法:1.方法名要和类名相同 2.没有返回值，但是不能有关键字void 3.用户不能直接调用，必须通过new关键字自动调用它
构造方法的重载:多个构造函数
在构造对象时只能调用一个构造函数例如：Cat c=new Cat("哺乳动物"，2，"喵喵");
构造对象的步骤：1.分配空间2.初始化实例变量，初始化代码块3.调用构造函数（赋值）
访问对象：通过引用访问对象 例如：Cat c=new Cat(); c.eat();;
this:1.指代当前对象2.调用其他构造函数，只能出现在构造函数中
封装：public ---公开的 private---私有的，只能在本类中使用；所谓的封装就是把属性和方法都用private修饰，如果不加修饰符则默认为default,即属性要私有，方法要公开。
访问控制符：private :同一类中 friendly:同一类中和同一包中 protected:同一类中，同一包中还有不同包中的子类 public:同一类中 ，同一包中，不同包中的子类，不同包中的非子类
override(重写)：发生在父子类之间，要求:方法名，返回值，参数表都必须相同，改写父类的实现，把父类中一般的实现改成特殊的实现，修饰符只能更宽。使用步骤：1.分配空间2.初始化父类对象（初始化父类属性，调用父类构造函数）3.初始化子类属性4.调用子类构造函数
java中只允许单继承(继承一个类)
super:调用父类的构造函数，调用父类被覆盖的
多态：把子类当成父类来看 Animal(引用类型也叫主观类型) a=new new Dog()(对象类型);以主观类型为主。特点：1.对象类型不变2.子类引用只能调用父类中的方法3.运行时，调用子类覆盖后的方法（运行时多态）
数组：存放相同数据类型的一组数据
声明：Int[] a;或int a[];分配空间：int[] a=new int[4];数组有默认值
数组的扩充：System.array(a,0,b,0,a.length)把数组A中下标从0-a拷贝到数组B的下标从0-b中,长度为：a.length
static :修饰属性，修饰方法（要求：共有的方法用类名直接调用，在静态方法中不能使用非静态的，而非静态的方法中可以使用静态变量成员，没有多态），还有初始化代码块
变量分为：局部变量，实例变量，还有类变量，其中实例变

量和类变量称为属性，属性和方法称为成员。
final：修饰变量（局部变量）用fianl修饰的变量都大写；修饰类 不能被子类继承 修饰方法：不能被覆盖 final类中所有的方法都是final
abstract：类可以声明引用，不能new对象 方法：只有声明，没有方法的实现，如果类中有抽象方法则一定是抽象类；如果子类既想继承抽象方法又想new对象，则子类必须实现父类中所有的方法，他将方法的声明和实现分离，声明放在父类，实现放在子类更体现继承共性的父类说法。

String:str.inter(),获得相同的空间，返回值是字符串在串池中的地址，String型的属性都是fianl
StringBuffer:内容可以改变，不会创建新对象，不会改变原有的地址
.append(" ")方法在字符串的后面追加另一个字符串
str[i]=String.ValueOf(i),把i看成一个字符串赋给str[i]
long time=System.nanoTime(); System.out.println(time);输出当前系统的时间
StringBuilder和StringBuffer相同，但是速度要快
接口就是一个特殊的抽象类1.所有属性都是公开的静态常量2.所有的方法都是公开的抽象方法3，没有构造函数 抽象类中有构造函数
特点：支持多继承(接口间的继承)，一个类可以有一个父类实现多个接口
接口的作用：1.多继承，接口是次要的抽象，不会破坏类的树形继承关系，首先继承父类，其次才是实现接口2.标准，弱耦合性的体现，解耦合的工具3.接口回调，先有接口和接口的使用者，再有接口的实现者
Object o引用指向任何对象，方法：所有类都有方法 getClass对象类型
finalize()对象在垃圾回收时系统自动调用GC
Java的语法部分已经结束，下面进入高级Java部分！！！！！！！！
*****************************************************************************************************************************
包装类：
int i=10; Integer ii=new Integer(i);
String s=String.valueOF(i);把int型的转换成String类型
i=Integer.parseInt();把i转化成int型的
Integer iii=new Integer(s);
S=iii.toString();
集合：
Map：有键值对，key和value都是Object通过Key的值找value的地址，不允许重复，对key进行排序，它没有直接的实现类
List：特点：有序，有下标，元素可以重复
.利用Vector存放1-100000这10000个数字，并打印出程序开始执行以及结束时的时间。
2.利用ArrayList存放1-100000这100000个数字，并打印出程序开始执行以及结束时的时间。
比较一下俩种方式的执行效率。
public static void main(String[] args){
List list1=new Vector();
long m=System.nanoTime();
System.out.println(m);
for(int i=1;i<100000;i++){
list1.add(i);
}
m=System.nanoTime();
System.out.println(m);
System.out.println("========第二题=========")
List list2=new ArrayList();
long n=System.nanoTime();
Sy

stem.out.println(n);
for(int i=1;i<100000;i++){
list2.add(i);
}
n=System.nanoTime();
System.out.println(n);
System.out.println("通过比较ArrayList的效率比较高");
}
3.使用泛型集合将某班学员信息放入HashMap中，key：学号，name：姓名（提示：使用HashMap），最后将学生信息打印出来。
信息如下：

学号 | 姓名
======================
40001 徐敏
40002 丁龙祥
40003 张哲
40004 王峰
40005 刑天
public static void main(String[] args){
Map map=new HashMap();
map.put("40001","徐敏");
map.put("40002","丁龙祥");
//Collection c=map.values();因为Map是通过key来寻找value的地址的，所有不用它儿用
Set key=map.keySet();
Iterator it=key.iterator();
System.out.println("学号"+"\t"+"姓名");
System.out.println("===================");
while(it.hasNext()){
String key=it.next();
String value=map.get(key);//通过key来寻找value的地址
System.out.println(key+"\t"+value);

}
}
1. 假如有以下email数据“aa@,bb@,cc@,..”现需要把email中的用户部分和邮件地址部分分离，分离后以键值对应的方式放入HashMap
public static voic main(String[] args){
String str="aa@,bb@,cc@";
String[] s1=str.split(",");
Map map=new HashMap();
for(int i=0;iString[] s2=s1[i].split("@");
map.put(s2[0],s2[1])
}
Set key=map.keySet();
Iterator it=key.iterator();
while(it.hasNext()){
String key=it.next();
String value=map.get(key);
System.out.println("用户名："+key+"邮件地址:"+value);
}
}
2. 产生一组班级对象，并放入集合ArrayList对象中
public static void main(String[] args){
List list=new ArrayList();
Classes c1=new Classes("一班");
Classes c2=new Classes("二班");
list.add(c1);
list.add(c2);
for(int i=0;iSystem.out.println(list.get(i));
}
}
class Classes{
String name;
public Classes(String name){
super();
=name;
}
public String toString(){//重写toString()方法
return "班级名："+name;
}
}
3.编写类，将客户的地址信息封装到Customer对象中，对象包括姓名、街道、市（县）、省（自治区）、和国家（地区）等字段信息，将客户信息存放到Vector中。结果如图：（注意换行）
public static void main(String[] args){
List list=new Vector();
list.add(new Customer("张三","黄河路","济南市","山东省","中国"));
list.add(new Customer("李四","长江路","长沙市","湖南省","中国"));
for(int i=0;iSystem.out.println(list.get(i));
}
}
class Customer{
String name;
String street;
String city;
String provence;
String country;
public Customer(String name,String street,String city,String provence,String country){
super();
=name;
this.street=street;

this.city=city;
this.provence=proven
}
}
4..编写类，该类有方法接收一些字符串(apple,graps,organge,lemon,pineapple),并将这些值存储在ArrayList中。倒序显示ArrayList中的内容。
public void Test6{
public static void main(String[] args){
List list=new ArrayList();
Fruit f1=new Fruit("apple");
Fruit f2=new Fruit("graps");
Fruit f3=new Fruit("orange");
Fruit f4=new Fruit("lemone");
Fruit f5=new Fruit("pineapple");
list.add(f1);
list.add(f2);
list.add(f3);
list.add(f4);
list.add(f5);
int j=0;
for(j=list.size()-1;j>=0;j--){
System.out.println(list.get(j));
}
}
}
class Fruit{
String fruit;
public Fruit(String fruit){
super();
this.fruit=fruit;
}
public String toString(){
return fruit;
}
}
5.定义学生信息实体类student，包含学生的姓名和成绩俩个字段。将该实体存入泛型HashMap。学员的姓名和他们的分数：张三，90分；李四，88分。然后从HashMap对象中获取者俩个人的成绩并显示出来，接着把张三的成绩改为99分再把它们的成绩显示出来
public class Test7{
public static void main(String[] args){
Map map=new HashMap();
map.put("张三",new Student("张三",90));
map.put("李四",new Student("李四",88));
Set set=map.keySet();
Iterator it=set.iterator();
while(it.hanNext()){
String s=(String)it.next();
Student stu=(Student)map.get(s);
System.out.println(stu);
}
System.out.println("======修改后的成绩为=======");
Student s=map.get("张三");
s.score=s.scoure+9;
Set set2=map.keySet();
Iterator it2=set2.iterator();
while(it2.hasNext()){
String s2=(String)it2.next();
Studnet stu=(Student)map.get(s2);
System.out.println(stu);
}

}
}
class Student{
String name;
int score;
public Student(String name, int score) {
super();
= name;
this.score = score;
}
@Override
public String toString() {
return name+"的成绩为："+score;
}

}
============================I/O================================
字节流的使用步骤：
1.创建节点流:OutputStream out=new OutputStream(f);
2.封装过滤流:DataoutputStream dos=new FileOutputStream(out);
3.读写数据dos.write();
4.关闭流dos.close();
字符流的使用步骤：(只用以Reader结尾的为字符流)
1.创建节点流：OutputStream os=new FileOutputStream("D:\\1.txt");
2.桥转换:OutputStreamWriter osw=new OutputStreamWriter(os);
3.封装过滤流:PrintWriter pw=new PrintWriter(osw);
4.读写数据:out.println("葡萄美酒夜光杯")
5.关闭流out.close();
1.对指定的图片进行复制，将其复制到另外一个文件夹下。
public class Test1_1 {

public static void main(String[] args) {
File f1=new File("E:\\1_1\\Sunset.jpg");
File f2=new File("E:\\1_1\\a\\Sunset.jpg");
byte[] b=new byte[1000];
InputStream in=null;
OutputStream out

=null;
try{
f2.createNewFile();
in=new FileInputStream(f1);
out=new FileOutputStream(f2);
while(true){
int i=in.read(b);
if(i==-1)break;
out.write(b);
}
}catch (IOException e){
e.printStackTrace();
}finally{
if(in!=null && out!=null){
try {
in.close();
out.close();
} catch (IOException e) {
e.printStackTrace();
}

}
}
}

}

2.对指定的文本文件进行从头到尾的遍历，并将遍历的内容写入到另外一个文件里。
public class Test2{
public static void main(String[] args){
File f1=new File("D:\\2.txt");
File f2=new File("D:\\2_2.txt");
InputStream in=null;
OutputStream out=null;
byte[] b=new byte[1024];
try{
f2.createNewFile();
in=new FileInputStream(f1);
Out=new FileOutputStream(f2);
while(true){
int i=in.read(b);
if(i==-1)break;
out.write(b);
for(int j=0;jSystem.out.println((char)b[j]+"\t");
}
}
}catch(IOException e){
e.printStackTrace();
}finally{
if(in!=null && out!=null){
in.close();
out.close();
}catch(IOException e){
e.printStackTrace();
}
}
}
}
3.把键盘输入的内容写入到文本文件中,按以下格式
public class Test3{
public static void main(String args[])
System.out.println("请输入您要输入数据的数目：");
int m=SystemIn.readInt();
String[] b=new String[10];
for(int i=0;iSystem.out.print(">");
b[i]=SystemIn.readString();
}
System.out.println(">这是一个从键盘测试输入的数据：");
System.out.println(">quit");
System.out.println("press any key to continue....");
File f=new File("E:\\3_3\\3.txt");

OutputStream out=null;
try{
out=new FileOutputStream(f);
f.createNewFile();
for(int i=0;iout.write(b[i].getBytes());
}
}catch (IOException e){
e.printStackTrace();
}finally{
if(out!=null){
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
4.将一个文件的内容装换为大写，显示出来，并把内容复制到文件中去。
public class Test4{
public static void main(String[] args){
// File f1=new File("E:\\4_4\\4.txt");
// File f2=new File("E:\\4_4\\4_4.txt");
// OutputStream out=null;
// InputStream in=null;
// int j=0;
// byte[] b=new byte[100];
// try{
// in=new FileInputStream(f1);
// out=new FileOutputStream(f2);
// f2.createNewFile();
// while(true){
// b[j]=(byte) in.read(b);
// if(b[j]==-1) break;
// j++;
// //String s=String.valueOf(i);
// System.out.println(b[j]);
//
// System.out.print(Character.toUpperCase((char)b[j]));
// out.write(Character.toUpperCase((char)b[j]));
//
// }
// }catch (IOException e){
// e.printStackTrace();
// }finally{
// try {
// in.close();
// out.close();
//

} catch (IOException e) {
// e.printStackTrace();
// }
//
// }
//使用字符流
File f1=new File("E:\\4_4\\4.txt");
File f2=new File("E:\\4_4\\4_4.txt");
FileReader fr=null;
BufferedReader br=null;
FileWriter fw=null;
BufferedWriter bw=null;
try{
f2.createNewFile();
fr=new FileReader(f1);
br=new BufferedReader(fr);
fw=new FileWriter(f2);
bw=new BufferedWriter(fw);
while(true){
String str=br.readLine();
if(str==null) break;
fw.write(str.toUpperCase());
System.out.println(str.toUpperCase());
}
}catch (IOException e){
e.printStackTrace();
}finally{
try {
if(fr!=null && fw!=null && br!=null && bw!=null)
fr.close();
fw.close();
br.close();
bw.close();
} catch (IOException e) {
e.printStackTrace();
}

}
}
}
***************************************XML*******************************************
BookDatils.xml文件如下：



史记
司马迁
199.00


平凡的世界
路遥
56.80


西方经济学
保罗.萨缪而森
98.80


1.分别使用SAX，DOM及DOM4J读取BookDetails.xml文件的内容
public class Sax{
public static void main(String[] args){
SAXParserFactory spf=SAXParserFactory.newInstance();
SAXParser sp=spf.newSAXPaer();
sp.parse(new File("D:\\BookDetails.xml"),new MyHandler);
}
}
class MyHandler extends DefaultHandler{
public void characters(char[] arg0,int arg1,int arg2)throws SAXException{
String s=new String(arg0,arg1,arg2);
System.out.println("开始处理文本"+s);
}
public void endDocument()throws SAXException{
System.out.println("文档结束");
}
public void endElement(String arg0,String arg1,String arg2)throws SAXException{
String s=new String();
System.out.println("标签结束");
}
public void startDocument()throws SAXException{
System.out.println("文档开始");
}
public void startElement(String uri,String localName,String qname,Attributes att)throws SAXException{
String s=new String();
System.out.println("标签开始："+qname);
}
}
public class TestDom {
public static void main(String[] args)throws Exception {
DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
DocumentBuilder db=dbf.newDocumentBuilder();
Document d=db.parse("D:\\BookDetails.xml");
Element s=d.getDocumentElement();
NodeList nl=s.getChildNodes();
// NodeList nl = d.getElementsByTagName("book");
for(int i=0;iNode n=nl.item(i);
if(n instanceof Element){
Element e=(Element) n;
System.out.println("Element:"+e.getNodeName());
NodeList n2=n.getChildNodes();
for(int j=0;j

Length();j++){
Node n3=n2.item(j);
if(n3 instanceof Element){
Element e2=(Element) n3;
System.out.println("Elementchild:"+e2.getNodeName());
}
if(n3 instanceof Text)
System.out.println("ElementText:"+n3.getTextContent().trim());
}

}


}

}
}


}
2.使用DOM4J写出与BookDetails.xml一样的XML文件
public class BookDetails{
public static void main(String[] args){
Document d=DocumentHelper.createDocument();
DocumentType dt=new DOMDocumentType("library","E:\\BookDetalis.xml\\a.dtd");
d.setDocType(dt);
d.setXMLEncoding("GBK");
Element root=DocumentHelper.createElement("library");
Element s1=DocumentHelper.createElement("book");
Element s1_name=DocumentHelper.createElement("booktitle");
Text s1_name_text=DocumentHelper.createText("史记");
Element s1_author=DocumentHelper.createElment("author");
Text s1_author_text=DocumentHelper.createText("司马迁");
Element s1_price=DocumentHelper.createElment("price");
Text s_price_text=DocumentHelper.create("199.0");

Element s2=DocumentHelper.createElement("book");
Element s2_name=DocumentHelper.createElement("name");
Text s2_name_text=DocumentHelper.createText("平凡的世界");
Element s2_author=DocumentHelper.createElement("author");
Text s2_author_text=DocumentHelper.createElement("路遥");
Element s2_price=DocumentHelper.createElement("price");
Text s2_price_text=DocumentHelper.createText("50.5");

Element s3=DocumentHelper.createElement("book");
Element s3_name=DocumentHelper.creatElement("name");
Text s3_name_text=DocumentHelper.createText("西方经济学");
Element s3_author=DocumentHelper.createElement("author");
Text s3_author_text=DocumentHelper.createText("萨缪尔保罗.森");
Element s3_price=DocumentHelper.createElement("price");
Text s3_price_text=DocumentHelper.createText("98.0");

s1.add(s1_name);
s1_name.add(s1_name_text);
s1.add(s1_author);
s1_author.add(s1_author_text);
s1.add(s1_price);
s1_price.add(s1_price_text);

s2.add(s2_name);
s2_name.add(s2_name_text);
s2.add(s2_author);
s2_author.add(s2_author_text);
s2.add(s2_price);
s2_price.add(s2_price_text);

s3.add(s3_name);
s3_name.add(s3_name_text);
s3.add(s3_author);
s3_author.add(s3_author_text);
s3.add(s3_price);
s3_price.add(s3_price_text);

root.add(s1);
root.add(s2);
root.add(s3);

d.add(root);
OutputFormat format=new OutputFormat();
format.setEncoding("GBK");
format.setNewlines(true);
format.setIndentSize(4);
try{
FileWriter fw=new FileWriter("D:\\success.xml");//FileWriter extends OutputStreamWriter
XMLWriter out=new XMLWriter(fw,format);
out.write(d);
out.flush();
out.close();
}catch(IOException e){
e.printStackTrace();
}
}
}
*******************************多线程*********************

***************
1.有两个线程a,b和一个变量i，其中线程a对i加1，线程b对b减1，是i的输出形式为010*******..
public class Test1{
public static void main(String [] args){
Test t=new Test();
Thread t1=new Thread1()；
Thread t2=new Thread2();
t1.start();
t2.start();
}
}
class Test{
int i=0;
public synchronized void add(){
try{
while(i==1)
this.wait();
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(i+"\t");
i++;
this.notifyAll();
}
public synchronized void remove(){
try{
while(i==0)
this.wait();
Thread.sleep(1000);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(i+"\t");
i--;
this.notifyAll();
}
}
class Thread1 extends Thread{
Test t;
public Thread1(Test t){
super();
this.t=t;
}
public void run(){
for(int i0;i<100;i++){
t.add();
}
}
}
class Thread2 extends Thread{
Test t;
public Thread2(Test t) {
super();
this.t = t;
}
public void run() {
for(int i=0;i<100;i++){
t.remove();
}
}

}
3. 线程1 run 打印数字 线程2 run 打印字母 12A34B56C78D………
public class Test3{
public static void main(String[] args){

}
}
class Print{
int i=1;
char ch='A';
int length1=0;
int length2=0;
public synchronized void print1(){
try{
for(int a=1;a<52;a++){
length2=0;
while(length1==2){
this.wait();
length++;
system.out.println(a);
this.notifyAll();
}
}catch(InterruptException e){
e.printStckTrace();
}
}
}
public synchronized void print2(){
try{
for(int i=1;i<=26;i++){
length1=0;
while(length2==1)
this.wait();
length2++;
System.out.println(ch);
ch++;
this.notifyAll();
}
}catch(InteruptedException e){
e.printStackTrace();
}
}
}
************************************SOCket编程*********************************************
1.广播式聊天
=================================
public class TCPClient{
public static void main(String[] args)throws Exception,Exception{
Socket s=new Socket("localhost",9000);
//从网络中读取数据
InputStream is=s.getInputStream();
InputStreamReader isr=new InputStreamReader(is);
BufferedReader br=new BufferecReader(isr);
//向网络中写出数据
OutputStream os=s.getOutputStream();
PrintWriter pw=new PrintWrter(os);
while(true){
System.out.println("Client:");
String str=SystemIn.readString();
pw.printIn(str);
pw.flush();
String strread=br.readLine();
System.out.println("Server:"+strread);
}
}
}
=============================
public class TCPServer{
public static void main(String[] args){
ServerSocket ss=new ServerSocket(9000);
while(true){
Socket s=ss.accept();
Thread t=new ServerThread(s);
t.start();
}
}
}
class ServerThread extends Thread{
Socket s;
BufferedReader i

n;
PrintWriter out;
public ServerThread(Socket s){
super();
this.s=s;
try{
InputStream is=s.getInputStream();
InputStreamReader isr=new InputStreamReader(is);
in=new BufferedReader(isr);
out=new PrintWriter(s.getOutputStream());
}catch(IOException e){
e.printStackTrace();
}
}
public void run(){
while(true){
read();
write();
}
}
public void read(){
String str;
try{
str=in.readLine();
System.out.println("Client:"+str);
}catch(IOException e){
e.printStackTrace();
}
}
public void write(){
System.out.println("Serc=ver:");
String str=SystemIn.readString();
out.println(str);
out.flush();
}

}
2点对点聊天.
=============================
public class QQClient{
public static void main(String[] args)throws Exception,Exception{
Socket s=new Socket("localhost",8000);
Thread t1=new ReceiveThread(s);
Thread t2=new SendThread(s);
t1.start();
t2.start();
}
}
class ReceiveThread extends Thread{
Socket s;

public ReceiveThread(Socket s) {
super();
this.s = s;
}
public void run(){
try{
InputStream is=s.getInputStream();//创建节点流
InputStreamReader isr=new InputStreamReader(is);//桥转换
BufferecReader in=new BufferedReader(isr);//封装过滤流
//BufferedReader in=new BufferedReader(new InputStreamReader (s.getInputStream));
while(true){
String str=in.readLine();
if(str!=null){
System.out.println(str);
}
}
}catch(IOException e){
e.printStackTrace();
}
}
}
class SendThread extends Thread{
Socket s;
public SendThread(Socket s) {
super();
this.s = s;
}
public void run(){
try{
PrintWriter out=new PrintWriter(s.getOutputStream());
while(true){
String str=SystemIn.readString();
if(str!=null){
if(str.equals(("bye"))
break;
out.println(str);
out.flush();
}
}
s.close();
}catch(IOException e){
e.printStackTrace();
}
}
}
===================
public class QQServer {
static List l = new ArrayList();
public static void main(String[] args) throws Exception{
ServerSocket ss = new ServerSocket(9000);
while(true){
Socket s = ss.accept();
l.add(s);
Thread t = new QQServerThread(s);
t.start();
}
}
}
class QQServerThread extends Thread{
Socket s;
BufferedReader in;
PrintWriter out;
public QQServerThread(Socket s) {
this.s = s;
try {
InputStream is = s.getInputStream();
InputStreamReader isr = new InputStreamReader(is);
in = new BufferedReader(isr);

out = new PrintWriter(s.getOutputStream());
} catch (IOException e) {
e.printStackTrace();
}
}
public void run() {
try {
while(true){
//a传haha
String str = in.readLine();
//0:key:say
//1:上线或者上线
if(str!=null){
for(int i = 0;i//b socket
Socket socket = QQSe

rver.l.get(i);
//if(socket.equals(s));
//else{
//向b输出数据的流
PrintWriter pw = new PrintWriter(socket.getOutputStream());
pw.println(str);
pw.flush();
//}
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
}

}