Day8.03

最新推荐文章于 2023-09-14 12:29:27 发布

无心_IT

最新推荐文章于 2023-09-14 12:29:27 发布

阅读量425

点赞数

分类专栏： JAVA学习文章标签： fileoutputstream 数据写入构造方法写入数据

JAVA学习专栏收录该内容

17 篇文章 0 订阅

订阅专栏

1.FileOutputStream

用于写入诸如图像数据之类的原始字节的流。要写入字符流，请考虑使用 FileWriter。
文件输出流是用于将数据写入 File 或 FileDescriptor 的输出流

构造方法摘要
FileOutputStream(File file)
创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(File file, boolean append)
创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(FileDescriptor fdObj)
创建一个向指定文件描述符处写入数据的输出文件流，该文件描述符表示一个到文件系统中的某个实际文件的现有连接。
FileOutputStream(String name)
创建一个向具有指定名称的文件中写入数据的输出文件流。
FileOutputStream(String name, boolean append)
创建一个向具有指定 name 的文件中写入数据的输出文件流。
方法摘要
void close()
关闭此文件输出流并释放与此流有关的所有系统资源。
protected void finalize()
清理到文件的连接，并确保在不再引用此文件输出流时调用此流的 close 方法。
FileChannel getChannel()
返回与此文件输出流有关的唯一 FileChannel 对象。
FileDescriptor getFD()
返回与此流有关的文件描述符。
void write(byte[] b)
将 b.length 个字节从指定 byte 数组写入此文件输出流中。
void write(byte[] b, int off, int len)
将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
void write(int b)
将指定字节写入此文件输出流。

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.net.URL;

public class Url12 {
    public static void main(String[] args) {
        try {
            URL url=new URL("http://www.ecolaw.co.kr/news/photo/201110/35361_10894_247.jpg");//读取图片的地址
            File img=new File("d://11.jpg");
            if(!img.exists()){
                img.createNewFile();
            }
            OutputStream os=new FileOutputStream(img);//
            InputStream is=url.openStream();
            byte[] array=new byte[1024];
            int i=is.read(array);
            while(i!=-1){
                os.write(array, 0, i);
                i=is.read(array);
            }
            os.flush();
            os.close();
            is.close();
        } catch (MalformedURLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

2.类URL

代表一个统一资源定位符，它是指向互联网“资源”的指针。资源可以是简单的文件或目录，也可以是对更为复杂的对象的引用，例如对数据库或搜索引擎的查询。

构造方法摘要
FileOutputStream(File file)
创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(File file, boolean append)
创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(FileDescriptor fdObj)
创建一个向指定文件描述符处写入数据的输出文件流，该文件描述符表示一个到文件系统中的某个实际文件的现有连接。
FileOutputStream(String name)
创建一个向具有指定名称的文件中写入数据的输出文件流。
FileOutputStream(String name, boolean append)
创建一个向具有指定 name 的文件中写入数据的输出文件流。
方法摘要
void close()
关闭此文件输出流并释放与此流有关的所有系统资源。
protected void finalize()
清理到文件的连接，并确保在不再引用此文件输出流时调用此流的 close 方法。
FileChannel getChannel()
返回与此文件输出流有关的唯一 FileChannel 对象。
FileDescriptor getFD()
返回与此流有关的文件描述符。
void write(byte[] b)
将 b.length 个字节从指定 byte 数组写入此文件输出流中。
void write(byte[] b, int off, int len)
将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
void write(int b)
将指定字节写入此文件输出流。

URL url=new URL("http://www.ecolaw.co.kr/news/photo/201110/35361_10894_247.jpg");
File img=new File("d://11.jpg");

3.DatagramSocket

<此类表示用来发送和接收数据报包的套接字。

数据报套接字是包投递服务的发送或接收点。每个在数据报套接字上发送或接收的包都是单独编址和路由的。从一台机器发送到另一台机器的多个包可能选择不同的路由，也可能按不同的顺序到达。

在 DatagramSocket 上总是启用 UDP 广播发送。为了接收广播包，应该将 DatagramSocket 绑定到通配符地址。在某些实现中，将 DatagramSocket 绑定到一个更加具体的地址时广播包也可以被接收。

示例：DatagramSocket s = new DatagramSocket(null); s.bind(new InetSocketAddress(8888)); 这等价于：DatagramSocket s = new DatagramSocket(8888); 两个例子都能创建能够在 UDP 8888 端口上接收广播的 DatagramSocket。
构造方法摘要
DatagramSocket()
构造数据报套接字并将其绑定到本地主机上任何可用的端口。
protected DatagramSocket(DatagramSocketImpl impl)
创建带有指定 DatagramSocketImpl 的未绑定数据报套接字。
DatagramSocket(int port)
创建数据报套接字并将其绑定到本地主机上的指定端口。
DatagramSocket(int port, InetAddress laddr)
创建数据报套接字，将其绑定到指定的本地地址。
DatagramSocket(SocketAddress bindaddr)
创建数据报套接字，将其绑定到指定的本地套接字地址。
方法摘要
void bind(SocketAddress addr)
将此 DatagramSocket 绑定到特定的地址和端口。
void close()
关闭此数据报套接字。
void connect(InetAddress address, int port)
将套接字连接到此套接字的远程地址。
void connect(SocketAddress addr)
将此套接字连接到远程套接字地址（IP 地址 + 端口号）。
void disconnect()
断开套接字的连接。
boolean getBroadcast()
检测是否启用了 SO_BROADCAST。
DatagramChannel getChannel()
返回与此数据报套接字关联的唯一 DatagramChannel 对象（如果有）。
InetAddress getInetAddress()
返回此套接字连接的地址。
InetAddress getLocalAddress()
获取套接字绑定的本地地址。
int getLocalPort()
返回此套接字绑定的本地主机上的端口号。
SocketAddress getLocalSocketAddress()
返回此套接字绑定的端点的地址，如果尚未绑定则返回 null。
int getPort()
返回此套接字的端口。
int getReceiveBufferSize()
获取此 DatagramSocket 的 SO_RCVBUF 选项的值，该值是平台在 DatagramSocket 上输入时使用的缓冲区大小。
SocketAddress getRemoteSocketAddress()
返回此套接字连接的端点的地址，如果未连接则返回 null。
boolean getReuseAddress()
检测是否启用了 SO_REUSEADDR。
int getSendBufferSize()
获取此 DatagramSocket 的 SO_SNDBUF 选项的值，该值是平台在 DatagramSocket 上输出时使用的缓冲区大小。
int getSoTimeout()
获取 SO_TIMEOUT 的设置。
int getTrafficClass()
为从此 DatagramSocket 上发送的包获取 IP 数据报头中的流量类别或服务类型。
boolean isBound()
返回套接字的绑定状态。
boolean isClosed()
返回是否关闭了套接字。
boolean isConnected()
返回套接字的连接状态。
void receive(DatagramPacket p)
从此套接字接收数据报包。
void send(DatagramPacket p)
从此套接字发送数据报包。
void setBroadcast(boolean on)
启用/禁用 SO_BROADCAST。
static void setDatagramSocketImplFactory(DatagramSocketImplFactory fac)
为应用程序设置数据报套接字实现工厂。
void setReceiveBufferSize(int size)
将此 DatagramSocket 的 SO_RCVBUF 选项设置为指定的值。
void setReuseAddress(boolean on)
启用/禁用 SO_REUSEADDR 套接字选项。
void setSendBufferSize(int size)
将此 DatagramSocket 的 SO_SNDBUF 选项设置为指定的值。
void setSoTimeout(int timeout)
启用/禁用带有指定超时值的 SO_TIMEOUT，以毫秒为单位。
void setTrafficClass(int tc)
为从此 DatagramSocket 上发送的数据报在 IP 数据报头中设置流量类别 (traffic class) 或服务类型八位组 (type-of-service octet)。

public class Myreceive {

    public static void main(String[] args) {
        try {
            DatagramSocket receiver=new DatagramSocket(8082);
            DatagramSocket send=new DatagramSocket();
            byte[] array=new byte[1024];

            Scanner scanner=new Scanner(System.in);
            while(true){
                DatagramPacket packet=new DatagramPacket(array, 1024);
                receiver.receive(packet);
//              byte[] data=packet.getData();

            System.out.println("Receiver接收到的数据\n:"+new String(array,0,packet.getLength()));//String返回字符串长度[]
            //以上接收信息
            String sendStr=scanner.next();
            System.out.println("Receive发送的数据是："+sendStr);
            byte[] sendByte=sendStr.getBytes();
            DatagramPacket packetSend=new DatagramPacket(sendByte, sendByte.length,InetAddress.getByName("192.168.0.46"),8085);
            send.send(packetSend);
            }

4.类 DatagramPacket

此类表示数据报包。

数据报包用来实现无连接包投递服务。每条报文仅根据该包中包含的信息从一台机器路由到另一台机器。从一台机器发送到另一台机器的多个包可能选择不同的路由，也可能按不同的顺序到达。不对包投递做出保证。

5.枚举

>
语法（定义）

创建枚举类型要使用 enum 关键字，隐含了所创建的类型都是 java.lang.Enum 类的子类（java.lang.Enum 是一个抽象类）。枚举类型符合通用模式 Class Enum<E extends Enum<E>>，而 E 表示枚举类型的名称。枚举类型的每一个值都将映射到 protected Enum(String name, int ordinal) 构造函数中，在这里，每个值的名称都被转换成一个字符串，并且序数设置表示了此设置被创建的顺序。
```

package com.hmw.test;
/**
* 枚举测试类
* @author 何明旺
*/
public enum EnumTest {
MON, TUE, WED, THU, FRI, SAT, SUN;
}

这段代码实际上调用了7次 Enum(String name, int ordinal)：
new Enum(“MON”,0);
new Enum(“TUE”,1);
new Enum(“WED”,2);
… …
遍历、switch 等常用操作

对enum进行遍历和switch的操作示例代码：
public class Test {
public static void main(String[] args) {
for (EnumTest e : EnumTest.values()) {
System.out.println(e.toString());
}

    System.out.println("----------------我是分隔线------------------");

    EnumTest test = EnumTest.TUE;
    switch (test) {
    case MON:
        System.out.println("今天是星期一");
        break;
    case TUE:
        System.out.println("今天是星期二");
        break;
    // ... ...
    default:
        System.out.println(test);
        break;
    }
}

}

输出结果：
MON
TUE
WED
THU
FRI
SAT
SUN
----------------我是分隔线------------------
今天是星期二
enum 对象的常用方法介绍

int compareTo(E o)
          比较此枚举与指定对象的顺序。

Class<E> getDeclaringClass()
          返回与此枚举常量的枚举类型相对应的 Class 对象。

String name()
          返回此枚举常量的名称，在其枚举声明中对其进行声明。

int ordinal()
          返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。

String toString()

           返回枚举常量的名称，它包含在声明中。

static <T extends Enum<T>> T valueOf(Class<T> enumType, String name)
          返回带指定名称的指定枚举类型的枚举常量。
public class Test {
    public static void main(String[] args) {
        EnumTest test = EnumTest.TUE;

        //compareTo(E o)
        switch (test.compareTo(EnumTest.MON)) {
        case -1:
            System.out.println("TUE 在 MON 之前");
            break;
        case 1:
            System.out.println("TUE 在 MON 之后");
            break;
        default:
            System.out.println("TUE 与 MON 在同一位置");
            break;
        }

        //getDeclaringClass()
        System.out.println("getDeclaringClass(): " + test.getDeclaringClass().getName());

        //name() 和  toString()
        System.out.println("name(): " + test.name());
        System.out.println("toString(): " + test.toString());

        //ordinal()， 返回值是从 0 开始
        System.out.println("ordinal(): " + test.ordinal());
    }
}
输出结果：
TUE 在 MON 之后
getDeclaringClass(): com.hmw.test.EnumTest
name(): TUE
toString(): TUE
ordinal(): 1
给 enum 自定义属性和方法

给 enum 对象加一下 value 的属性和 getValue() 的方法：
package com.hmw.test;

/**
 * 枚举测试类
 * 
 * @author <a href="mailto:hemingwang0902@126.com">何明旺</a>
 */
public enum EnumTest {
    MON(1), TUE(2), WED(3), THU(4), FRI(5), SAT(6) {
        @Override
        public boolean isRest() {
            return true;
        }
    },
    SUN(0) {
        @Override
        public boolean isRest() {
            return true;
        }
    };

    private int value;

    private EnumTest(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public boolean isRest() {
        return false;
    }
}
public class Test {
    public static void main(String[] args) {
        System.out.println("EnumTest.FRI 的 value = " + EnumTest.FRI.getValue());
    }
}
输出结果：
EnumTest.FRI 的 value = 5
EnumSet，EnumMap 的应用
public class Test {
    public static void main(String[] args) {
        // EnumSet的使用
        EnumSet<EnumTest> weekSet = EnumSet.allOf(EnumTest.class);
        for (EnumTest day : weekSet) {
            System.out.println(day);
        }

        // EnumMap的使用
        EnumMap<EnumTest, String> weekMap = new EnumMap(EnumTest.class);
        weekMap.put(EnumTest.MON, "星期一");
        weekMap.put(EnumTest.TUE, "星期二");
        // ... ...
        for (Iterator<Entry<EnumTest, String>> iter = weekMap.entrySet().iterator(); iter.hasNext();) {
            Entry<EnumTest, String> entry = iter.next();
            System.out.println(entry.getKey().name() + ":" + entry.getValue());
        }
    }
}
原理分析

        enum 的语法结构尽管和 class 的语法不一样，但是经过编译器编译之后产生的是一个class文件。该class文件经过反编译可以看到实际上是生成了一个类，该类继承了java.lang.Enum<E>。EnumTest 经过反编译(javap com.hmw.test.EnumTest 命令)之后得到的内容如下：
public class com.hmw.test.EnumTest extends java.lang.Enum{
    public static final com.hmw.test.EnumTest MON;
    public static final com.hmw.test.EnumTest TUE;
    public static final com.hmw.test.EnumTest WED;
    public static final com.hmw.test.EnumTest THU;
    public static final com.hmw.test.EnumTest FRI;
    public static final com.hmw.test.EnumTest SAT;
    public static final com.hmw.test.EnumTest SUN;
    static {};
    public int getValue();
    public boolean isRest();
    public static com.hmw.test.EnumTest[] values();
    public static com.hmw.test.EnumTest valueOf(java.lang.String);
    com.hmw.test.EnumTest(java.lang.String, int, int, com.hmw.test.EnumTest);
}
所以，实际上 enum 就是一个 class，只不过 java 编译器帮我们做了语法的解析和编译而已。
总结

    可以把 enum 看成是一个普通的 class，它们都可以定义一些属性和方法，不同之处是：enum 不能使用 extends 关键字继承其他类，因为 enum 已经继承了 java.lang.Enum（java是单一继承）。
##6.XML解析
###1.DOM解析

import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class Domtest {

public static void main(String[] args) {
    // TODO Auto-generated method stub
    DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();

    try {
        DocumentBuilder builder = factory.newDocumentBuilder();//创建dom解析器的工厂
        Document document=builder.parse("d:\\11.txt");//使用解析器解析文档生成树的document
        NodeList list=document.getElementsByTagName("Weather");//得到文档中的所有weather标签      
        Node node=list.item(0);                                //得到第一个weather
        Node child=node.getFirstChild();                       //得到weather标签的第一个子标签child        
        Node next=child.getNextSibling();                      //达到子标签city的下一个标签 
        while(next !=null){                                 //判断有没有走到最后一个标签
            if(next.getNodeType()==Node.ELEMENT_NODE){      //判断节点类型是ELEMENT_NODE
              Node content=next.getFirstChild();            //看到该节点的第一个子节点不能为空
              if(content!=null){
                  System.out.println(next.getFirstChild().getNodeValue().trim());

              }
            }
            next=next.getNextSibling();
        }

    } catch (ParserConfigurationException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (SAXException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }


}

}

###SAX解析
<d

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class Saxtest extends DefaultHandler{
public boolean isArrive=false;
@Override
public void characters(char[] ch, int start, int length) throws SAXException {
// TODO Auto-generated method stub
super.characters(ch, start, length);
if(isArrive){
System.out.println(“我找到了city”+new String(ch,start,length));
}
System.out.println(new String(ch,start,length));
}

@Override
public void endDocument() throws SAXException {
    // TODO Auto-generated method stub
    super.endDocument();
    System.out.println("解析文档结束");
}

@Override
public void endElement(String uri, String localName, String qName) throws SAXException {
    // TODO Auto-generated method stub
    super.endElement(uri, localName, qName);
    System.out.println("标签结束"+qName);
}

@Override
public void startDocument() throws SAXException {
    // TODO Auto-generated method stub
    super.startDocument();
   System.out.println("解析文档开始");
}

@Override
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
    // TODO Auto-generated method stub
    super.startElement(uri, localName, qName, attributes);
      isArrive=qName.equals("city");
     System.out.println("标签开始"+qName);
}

}


###JSON解析（重点）

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

public class Json {

public static void main(String[] args) {
    String json = creatJSON();

    JSONObject obj = JSONObject.fromObject(json);
    System.out.println(obj.get("city"));

    JSONObject today = obj.getJSONObject("today");
    JSONArray array = today.getJSONArray("index");
    for (int i = 0; i < array.size(); i++) {
        JSONObject obj1 = array.getJSONObject(i);
        System.out.println(obj1.getString("name"));
    }

}

private static String creatJSON() {
    JSONObject obj = new JSONObject();
    obj.put("city","北京");
    obj.put("cityid","123");
    JSONObject today = new JSONObject();
    today.put("date", "2015-8-03");
    today.put("week", "星期3");
    JSONArray array = new JSONArray();
    JSONObject index1 = new JSONObject();
    index1.put("name", "感冒");
    JSONObject index2 = new JSONObject();

    index2.put("name", "防晒");
    JSONObject index3 = new JSONObject();
    index3.put("name", "炎热");
    array.add(index1);
    array.add(index2);
    array.add(index3);
    today.put("index", array);
    obj.put("today",today);
    System.out.println(obj.toString());
    return obj.toString();

}

}
“`