20189200余超 2018-2019-2 移动平台应用开发实践第五做业

时间 2019-12-10

标签移动平台应用开发实践第五栏目无线繁體版

原文原文链接

20189200余超 2018-2019-2 移动平台应用开发实践第五做业

输入/输出

输入输出能够说是计算机的基本功能。做为一种语言体系，java中主要按照流(stream)的模式来实现。其中数据的流向是按照计算机的方向肯定的，流入计算机的数据流叫作输入流(inputStream)，由计算机发出的数据流叫作输出流(outputStream)。Java语言体系中，对数据流的主要操做都封装在java.io包中，经过java.io包中的类能够实现计算机对数据的输入、输出操做。在编写输入、输出操做代码时，须要用import语句将java.io包导入到应用程序所在的类中，才可使用java.io中的类和接口。

2.其中，全部输入流类都是抽象类InputStream(字节输入流)，或者抽象类Reader(字符输入流)的子类；而全部输出流都是抽象类OutputStream(字节输出流)或者Writer(字符输出流)的子类。php

3.InputStream类是字节输入流的抽象类，是全部字节输入流的父类，InputStream类具备层次结构以下图所示
java

4.java中的字符是Unicode编码的，是双字节的。InputStream是用来处理字节的，在处理字符文本时很不方便。Java为字符文本的输入提供了专门的一套类Reader。Reader类是字符输入流的抽象类，全部字符输入流的实现都是它的子类。
程序员

5.输出流OutputStream类是字节输入流的抽象类，此抽象类表示输出字节流的全部类的超类。
算法

6.Writer类是字符输出流的抽象类，全部字符输出类的实现都是它的子类。
编程

7.File类是IO包中惟一表明磁盘文件自己的对象。经过File来建立，删除，重命名文件。File类对象的主要做用就是用来获取文本自己的一些信息。如文本的所在的目录，文件的长度，读写权限等等。（有的须要记忆，好比isFile(),isDirectory(),exits();有的了解便可。使用的时候查看API）
详细以下：
File类(File类的概述和构造方法)
A:File类的概述
　　File更应该叫作一个路径
　　文件路径或者文件夹路径
　　路径分为绝对路径和相对路径
　　　　绝对路径是一个固定的路径,从盘符开始
　　　　相对路径相对于某个位置,在eclipse下是指当前项目下,在dos下
　　查看API指的是当前路径
　　文件和目录路径名的抽象表示形式
B:构造方法
　　File(String pathname)：根据一个路径获得File对象
　　File(String parent, String child):根据一个目录和一个子文件/目录获得File对象
　　File(File parent, String child):根据一个父File对象和一个子文件/目录获得File对象数组

File类(File类的建立功能)
　　A:建立功能
　　　　public boolean createNewFile():建立文件若是存在这样的文件，就不建立了
　　　　public boolean mkdir():建立文件夹若是存在这样的文件夹，就不建立了
　　　　public boolean mkdirs():建立文件夹,若是父文件夹不存在，会帮你建立出来
（使用createNewFile()文件建立的时候不加.txt或者其余后缀也是文件，不是文件夹；使用mkdir()建立文件夹的时候，若是起的名字是好比aaa.txt也是文件夹不是文件；）
注意事项：
若是你建立文件或者文件夹忘了写盘符路径，那么，默认在项目路径下。安全

File类(File类的重命名和删除功能)
　　A:重命名和删除功能
　　　　public boolean renameTo(File dest):把文件重命名为指定的文件路径
　　　　public boolean delete():删除文件或者文件夹
　　B:重命名注意事项
　　　　若是路径名相同，就是更名。
　　　　若是路径名不一样，就是更名并剪切。
　　C:删除注意事项：
　　　　Java中的删除不走回收站。
　　　　要删除一个文件夹，请注意该文件夹内不能包含文件或者文件夹服务器

File类(File类的判断功能)
　　A:判断功能
　　　　public boolean isDirectory():判断是不是目录
　　　　public boolean isFile():判断是不是文件
　　　　public boolean exists():判断是否存在
　　　　public boolean canRead():判断是否可读
　　　　public boolean canWrite():判断是否可写
　　　　public boolean isHidden():判断是否隐藏网络

File类(File类的获取功能)
　　A:获取功能
　　　　public String getAbsolutePath()：获取绝对路径
　　　　public String getPath():获取路径
　　　　public String getName():获取名称
　　　　public long length():获取长度。字节数
　　　　public long lastModified():获取最后一次的修改时间，毫秒值
　　　　public String[] list():获取指定目录下的全部文件或者文件夹的名称数组
　　　　public File[] listFiles():获取指定目录下的全部文件或者文件夹的File数组
File类(文件名称过滤器的概述及使用)
　　A:文件名称过滤器的概述
　　　　public String[] list(FilenameFilter filter)
　　　　public File[] listFiles(FileFilter filter)多线程

package com.ningmeng;

import java.io.File;

public class Test {

    public static void main(String[] args) throws Exception{
        // TODO Auto-generated method stub
        File file=new File("aa.txt");//文件默认就建立在你建立的项目下面，刷新便可看到
        System.out.println(file.exists());//判断文件是否存在
        file.createNewFile();//建立文件，不是文件夹
        System.out.println(file.exists());//再次判断是否存在
        System.out.println(file.getName());//获取文件的名字
        System.out.println(file.getAbsolutePath());//获取文件的绝对路径
        System.out.println(file.getPath());//获取文件的相对路径
        System.out.println(file.getParent());//获取文件的父路径
        System.out.println(file.canRead());//文件是否可读
        System.out.println(file.canWrite());//文件是否可写
        System.out.println(file.length());//文件的长度
        System.out.println(file.lastModified());//文件最后一次修改的时间
        System.out.println(file.isDirectory());//判断文件是不是一个目录
        System.out.println(file.isHidden());//文件是否隐藏
        System.out.println(file.isFile());//判断文件是否存在
    }

}

8.public String[] list():获取指定目录下的全部文件或者文件夹的名称数组
public File[] listFiles():获取指定目录下的全部文件或者文件夹的File数组
list()获取某个目录下全部的文件或者文件夹：

package com.ningmeng;

import java.io.File;

public class FileTest {

    public static void main(String[] args){
        File file=new File("D:/");//指定文件目录
        String[] str=file.list();//获取指定目录下的全部文件或者文件夹的名称数组
        for(String s : str){//增强for循环遍历输出
            System.out.println(s);
        }
        
    }
}

package com.ningmeng;

import java.io.File;

public class FileTest {

    public static void main(String[] args){
        File file=new File("D:/");//指定文件路径
        File[] f=file.listFiles();//获取指定目录下的全部文件或者文件夹的File数组
        for(File fi : f){//增强for循环遍历输出
            System.out.println(fi);
        }
        
    }
}

案例演示：
获取某种格式的文件好比获取某种后缀的图片，并输出文件名：

package com.ningmeng;

import java.io.File;

public class FileTest {

    public static void main(String[] args){
        File file=new File("C:\\Users\\biehongli\\Pictures\\xuniji");
        String[] str=file.list();
        
        for(String s : str){
            if(s.endsWith(".jpg") || s.endsWith(".png")){//若是后缀是这种格式的就输出
                System.out.println(s);
            }
        }
        
        
    }
}

下面演示获取文件夹下面子目录里面的文件获取（并无彻底获取子目录的子目录等等，仅仅获取了子一级目录）：

package com.ningmeng;

import java.io.File;

public class FileTest {

    public static void main(String[] args){
        File file=new File("C:\\Users\\biehongli\\Pictures\\Camera Roll");
        
        File[] f=file.listFiles();
        
        for(File fi : f){
            if(fi.isDirectory()){//判断若是是一个目录
                String[] s=fi.list();
                for(String str : s){
                    if(str.endsWith(".jpg")){
                        System.out.println(str);
                    }
                }
            }
        }
    }
}

文件名称过滤器的概述
public String[] list(FilenameFilter filter)
public File[] listFiles(FileFilter filter)

package com.ningmeng;

import java.io.File;
import java.io.FilenameFilter;

public class FileTest {

    public static void main(String[] args){
        File file=new File("C:\\Users\\biehongli\\Pictures\\Camera Roll");
        
        String[] str=file.list(new FilenameFilter() {//过滤器，匿名内部类
            
            @Override
            public boolean accept(File dir, String name) {
                // TODO Auto-generated method stub
                //System.out.println(dir);//获取文件的路径
                //System.out.println(name);//获取文件的名字
                File f=new File(dir,name);
                return f.isFile() && f.getName().endsWith(".jpg");
            }
        });
        for(String s : str){
            System.out.println(s);
        }
        
    }
}

9.下面以一些字节输入输出流具体的案例操做（操做的时候认清本身使用的是字节流仍是字符流）：
注意：read()方法读取的是一个字节,为何返回是int,而不是byte
字节输入流能够操做任意类型的文件,好比图片音频等,这些文件底层都是以二进制形式的存储的,若是每次读取都返回byte,有可能在读到中间的时候遇到111111111；那么这11111111是byte类型的-1,咱们的程序是遇到-1就会中止不读了,后面的数据就读不到了,因此在读取的时候用int类型接收,若是11111111会在其前面补上；24个0凑足4个字节,那么byte类型的-1就变成int类型的255了这样能够保证整个数据读完,而结束标记的-1就是int类型
FileInputStream的单个字节读取：
FileOutputStream的单个字节写入：

package com.ningmeng;

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class FileTest {

    public static void main(String[] args) throws Exception{
        FileInputStream fis=new FileInputStream("aaa.txt");
        FileOutputStream fos=new FileOutputStream("bbb.txt",true);
        //FileOutputStream()后面加true指文件后面可追加
        
        int a=fis.read();//read()一次读取一个字节
        System.out.println(a);//读取的一个字节输出
        
        fos.write(101);//write()一次写一个字节
        fis.close();//必定记得关闭流，养成好习惯
        fos.close();
    }
}

FileInputStream和FileOutputStream进行拷贝文本或者图片或者歌曲：

package com.ningmeng;

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class FileTest {

    public static void main(String[] args) throws Exception{
        FileInputStream fis=new FileInputStream("aaa.txt");
        FileOutputStream fos=new FileOutputStream("bbb.txt");
        //若是没有bbb.txt,会建立出一个
        
        int b;
        while((b=fis.read())!=-1){
            fos.write(b);
        }
        fis.close();
        fos.close();
    }
}

FileInputStream和FileOutputStream定义小数组进行读写操做：

package com.ningmeng;

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class FileTest {

    public static void main(String[] args) throws Exception{
        FileInputStream fis = new FileInputStream("aaa.txt");
        FileOutputStream fos = new FileOutputStream("bbb.txt");
        int len;
        byte[] arr = new byte[1024 * 8];//自定义字节数组
        
        while((len = fis.read(arr)) != -1) {
            //fos.write(arr);
            fos.write(arr, 0, len);//写出字节数组写出有效个字节个数
        }
        //IO流(定义小数组)
        //write(byte[] b)
        //write(byte[] b, int off, int len)写出有效的字节个数

        fis.close();
        fos.close();
    }
}

IO流(BufferedInputStream和BufferOutputStream拷贝)

A:缓冲思想
　　* 字节流一次读写一个数组的速度明显比一次读写一个字节的速度快不少，
　　* 这是加入了数组这样的缓冲区效果，java自己在设计的时候，
　　* 也考虑到了这样的设计思想，因此提供了字节缓冲区流
B.BufferedInputStream
　　* BufferedInputStream内置了一个缓冲区(数组)
　　* 从BufferedInputStream中读取一个字节时
　　* BufferedInputStream会一次性从文件中读取8192个, 存在缓冲区中, 返回给程序一个
　　* 程序再次读取时, 就不用找文件了, 直接从缓冲区中获取
　　* 直到缓冲区中全部的都被使用过, 才从新从文件中读取8192个
C.BufferedOutputStream
　　* BufferedOutputStream也内置了一个缓冲区(数组)
　　* 程序向流中写出字节时, 不会直接写到文件, 先写到缓冲区中
　　* 直到缓冲区写满, BufferedOutputStream才会把缓冲区中的数据一次性写到文件里

package com.ningmeng;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class FileTest {

    public static void main(String[] args) throws Exception{
        FileInputStream fis = new FileInputStream("aaa.txt");
        FileOutputStream fos = new FileOutputStream("bbb.txt");
        
        BufferedInputStream bis=new BufferedInputStream(fis);
        //使用装饰模式，把fis装饰进去bis中。使用缓冲读取速度变快
        BufferedOutputStream bos=new BufferedOutputStream(fos);
        
        int b;
        while((b=bis.read())!=-1){
            bos.write(b);
        }
        bis.close();
        bos.close();
    }
}

线程

关于Java中线程的生命周期，首先看一下下面这张较为经典的图：

Java线程具备五中基本状态

新建状态（New）：当线程对象对建立后，即进入了新建状态，如：Thread t = new MyThread();

就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经作好了准备，随时等待CPU调度执行，并非说执行了t.start()此线程当即就会执行；

运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就绪状态是进入到运行状态的惟一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；

阻塞状态（Blocked）：处于运行状态中的线程因为某种缘由，暂时放弃对CPU的使用权，中止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态。根据阻塞产生的缘由不一样，阻塞状态又能够分为三种：

1.等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；

2.同步阻塞 -- 线程在获取synchronized同步锁失败(由于锁被其它线程所占用)，它会进入同步阻塞状态；

3.其余阻塞 -- 经过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程从新转入就绪状态。

死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

Java中线程的建立常见有如三种基本形式
1.继承Thread类，重写该类的run()方法

public class ThreadTest {

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30) {
                Thread myThread1 = new MyThread();     // 建立一个新的线程  myThread1  此线程进入新建状态
                Thread myThread2 = new MyThread();     // 建立一个新的线程 myThread2 此线程进入新建状态
                myThread1.start();                     // 调用start()方法使得线程进入就绪状态
                myThread2.start();                     // 调用start()方法使得线程进入就绪状态
            }
        }
    }
}

如上所示，继承Thread类，经过重写run()方法定义了一个新的线程类MyThread，其中run()方法的方法体表明了线程须要完成的任务，称之为线程执行体。当建立此线程类对象时一个新的线程得以建立，并进入到线程新建状态。经过调用线程对象引用的start()方法，使得该线程进入到就绪状态，此时此线程并不必定会立刻得以执行，这取决于CPU调度时机。

public class ThreadTest {

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30) {
                Runnable myRunnable = new MyRunnable(); // 建立一个Runnable实现类的对象
                Thread thread1 = new Thread(myRunnable); // 将myRunnable做为Thread target建立新的线程
                Thread thread2 = new Thread(myRunnable);
                thread1.start(); // 调用start()方法使得线程进入就绪状态
                thread2.start();
            }
        }
    }
}

经过 Callable 和 Future 建立线程

public class CallableThreadTest implements Callable<Integer> {
    public static void main(String[] args)  
    {  
        CallableThreadTest ctt = new CallableThreadTest();  
        FutureTask<Integer> ft = new FutureTask<>(ctt);  
        for(int i = 0;i < 100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);  
            if(i==20)  
            {  
                new Thread(ft,"有返回值的线程").start();  
            }  
        }  
        try  
        {  
            System.out.println("子线程的返回值："+ft.get());  
        } catch (InterruptedException e)  
        {  
            e.printStackTrace();  
        } catch (ExecutionException e)  
        {  
            e.printStackTrace();  
        }  
  
    }
    @Override  
    public Integer call() throws Exception  
    {  
        int i = 0;  
        for(;i<100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" "+i);  
        }  
        return i;  
    }  
}

3.线程的优先级:每个 Java 线程都有一个优先级，这样有助于操做系统肯定线程的调度顺序。

Java 线程的优先级是一个整数，其取值范围是 1 （Thread.MIN_PRIORITY ） - 10 （Thread.MAX_PRIORITY ）。

默认状况下，每个线程都会分配一个优先级 NORM_PRIORITY（5）。

具备较高优先级的线程对程序更重要，而且应该在低优先级的线程以前分配处理器资源。可是，线程优先级不能保证线程执行的顺序，并且很是依赖于平台。

4.多线程的使用
有效利用多线程的关键是理解程序是并发执行而不是串行执行的。例如：程序中有两个子系统须要并发执行，这时候就须要利用多线程编程。

经过对多线程的使用，能够编写出很是高效的程序。不过请注意，若是你建立太多的线程，程序执行的效率其实是下降了，而不是提高了。

请记住，上下文的切换开销也很重要，若是你建立了太多的线程，CPU 花费在上下文的切换的时间将多于执行程序的时间！

并发工具

1.并发容器
工具包提供了队列的并发实现类ConcurrentLinkedQueue和ConcurrentLinkedDeque，二者都是无界非阻塞线程安全的队列。

ConcurrentMap接口继承了普通的Map接口，提供了线程安全和原子操做特性。Java 8 提供了实现类ConcurrentHashMap，ConcurrentHashMap不锁定整个Map，只锁定须要写入的部分，所以并发性能比HashTable要高不少。

ConcurrentNavigableMap接口继承了ConcurrentMap和NavigableMap接口，支持并发访问NavigableMap，还能让子Map具有并发访问的能力。NavigableMap是扩展的 SortedMap，具备了针对给定搜索目标返回最接近匹配项的导航方法。

Java 8 提供了实现类ConcurrentSkipListMap，并无使用lock来保证线程的并发访问和修改，而是使用了非阻塞算法来保证并发访问，高并发时相对于TreeMap有明显的优点。

工具包提供了NavigableSet的并发实现类ConcurrentSkipListSet，是线程安全的有序集合，适用于高并发的场景，经过ConcurrentSkipListMap实现。

工具包提供了两个写时复制容器，即CopyOnWriteArrayList和CopyOnWriteArraySet。写时复制技术是一种优化策略，多个线程能够并发访问同一份数据，当有线程要修改时才进行复制而后修改。在Linux系统中，fork进程后，子进程先与父进程共享数据，须要修改时才用写时复制获得本身的副本。在Java中，写时复制容器在修改数据后，把原来容器的引用指向新容器，来实现读写分离，在并发读写中不须要加锁。写时复制容器适用于读多写少的场景，在复制时会占用较多内存，可以保证最终一致性，但没法保证瞬时一致性。

2.线程池
工具包中Executor接口定义了执行器的基本功能，即execute方法，接收Runnable对象参数并执行Runnable中的操做。

ExecutorService接口继承Executor接口后增长了关于执行器服务的定义，如关闭、当即关闭、检查关闭、等待终止、提交有返回值的任务、批量提交任务等。经过Executors的工厂方法获取ExecutorService的具体实现，目前Executors能够返回的实现类型以下：

FixedThreadPool：固定大小的线程池，建立时指定大小；

WorkStealingPool：拥有多个任务队列（以便减小链接数）的线程池；

SingleThreadExecutor：单线程执行器，顾名思义只有一个线程执行任务；

CachedThreadPool：根据须要建立线程，能够重复利用已存在的线程来执行任务；

SingleThreadScheduledExecutor：根据时间计划延迟建立单个工做线程或者周期性建立的单线程执行器；

ScheduledThreadPool：可以延后执行任务，或者按照固定的周期执行任务。

若是但愿在任务执行完成后获得任务的返回值，能够调用submit方法传入Callable任务，并经过返回的Future对象查看任务执行是否完成，并获取返回值。

3.线程分叉与合并
ForkJoinPool 让咱们能够很方便地把任务分裂成几个更小的任务，这些分裂出来的任务也将会提交给 ForkJoinPool。任务能够继续分割成更小的子任务，只要它还能分割。分叉和合并原理包含两个递归进行的步骤。两个步骤分别是分叉步骤和合并步骤。

一个使用了分叉和合并原理的任务能够将本身分叉(分割)为更小的子任务，这些子任务能够被并发执行。以下图所示：

经过把本身分割成多个子任务，每一个子任务能够由不一样的 CPU 并行执行，或者被同一个 CPU 上的不一样线程执行。

只有当给的任务过大，把它分割成几个子任务才有意义。把任务分割成子任务有必定开销，所以对于小型任务，这个分割的消耗可能比每一个子任务并发执行的消耗还要大。

何时把一个任务分割成子任务是有意义的，这个界限也称做一个阀值。这要看每一个任务对有意义阀值的决定。很大程度上取决于它要作的工做的种类。

当一个任务将本身分割成若干子任务以后，该任务将等待全部子任务结束。一旦子任务执行结束，该任务能够把全部结果合并到同一个结果。图示以下：

4.锁
使用锁实现的同步机制很像synchronized块，可是比synchronized块更灵活。锁和synchronized的主要区别在于：

Synchronized块不能保证等待进入块的线程的访问顺序；

Synchronized块没法接收参数，不能在有超时时间限制的状况下尝试访问；

Synchronized块必须包含在单个方法中，而锁的lock和unlock操做能够在单独的方法中。

工具包提供了如下几种类型的锁：

ReadWriteLock：读写锁接口，容许多个线程读取某个资源，可是一次只能有一个线程进行写操做。内部有读锁、写锁两个接口，分别保护读操做和写操做。实现类为ReentrantReadWriteLock。

ReentrantLock：可重入锁，具备与使用 synchronized 方法和语句所访问的隐式监视器锁定相同的一些基本行为和语义，但功能更强大。ReentrantLock 将由最近成功得到锁定，而且尚未释放该锁定的线程所拥有。当锁定没有被另外一个线程所拥有时，调用 lock 的线程将成功获取该锁定并返回。若是当前线程已经拥有该锁定，此方法将当即返回。内部有一个计数器，拥有锁的线程每锁定一次，计数器加1，每释放一次计数器减1。

5.原子类型
工具包提供了一些能够用原子方式进行读写的变量类型，支持无锁线程安全的单变量编程。

本质上，这些类都扩展了volatile的概念，使用一个volatile类型的变量来存储实际数据。

工具包提供了4种类型的原子变量类型：

AtomicBoolean：可原子操做的布尔对象；

AtomicInteger：可原子操做的整形对象；

AtomicLong：可原子操做的长整形对象；

AtomicReference：可原子操做的对象引用。

网络

网络基础知识
一、OSI分层模型和TCP/IP分层模型的对应关系

这里对于7层模型不展开来说，只选择跟此次系列主题相关的知识点介绍。

二、七层模型与协议的对应关系
网络层 ------------ IP（网络之间的互联协议）

传输层   ------------     TCP（传输控制协议）、UDP（用户数据报协议）

   应用层   ------------     Telnet（Internet远程登陆服务的标准协议和主要方式）、FTP（文本传输协议）、HTTP（超文本传送协议）

三、IP地址和端口号
一、ip地址用于惟一标示网络中的一个通讯实体，这个通讯实体能够是一台主机，能够是一台打印机，或者是路由器的某一个端口。而在基于IP协议网络中传输的数据包，必须使用IP 地址来进行标示。ip地址就像写一封信，必须指定收件人的地址同样。每一个被传输的数据包中都包括了一个源IP和目标IP。

二、ip地址惟一标示了通讯实体，可是一个通讯实体能够有多个通讯程序同时提供网络服务。这个时候就要经过端口来区分开具体的通讯程序。一个通讯实体上不能有两个通讯程序使用同一个端口号。

IP地址和端口号，就像一个出差去外地入住酒店同样，IP地址表示了酒店在具体位置，而端口号则表示了这我的在酒店的房间号。

四、TCP和UDP
一、TCP是一种面向链接的保证可靠传输的协议。经过TCP协议传输，获得的是一个顺序的无差错的数据流。它可以提供两台计算机之间的可靠的数据流，HTTP、FTP、Telnet等应用都须要这种可靠的通讯通道。

二、UDP是一种无链接的协议，每一个数据报都是一个独立的信息，包括完整的源地址或目的地址，它在网络上以任何可能的路径传送目的地，至于可以达到目的地，达到目的地的时间以及内容的正确性都是不能保证的。

既然有了保证可靠传输的TCP协议，为何还要非可靠传输的UDP协议呢？缘由有两个：

一、可靠的传输是要付出代价的，对数据内容的正确性的检验必然会占用计算机处理时间和网络带宽。所以TCP的传输效率不如UDP高。

二、许多应用中并不须要保证严格的传输可靠性，好比视频会议系统，并不要求视频音频数据绝对正确，只要可以连贯就能够了。因此在这些场景下，使用UDP更合适些。

五、URL访问网上资源
一、URL对象表明统一资源定位器，是指向互联网“资源”的指针。它是用协议名、主机、端口和资源组成，即知足以下格式：

protocol://host:port/resourceName

 http://www.crazyit.org/index.php

二、经过URL对象的一些方法能够访问该URL对应的资源：

String getFile():获取该URL的资源名

 String getHost():获取主机名

 String getPath():获取路径部分

 int   getPort():获取端口号

6.Java的网络编程主要涉及到的内容是Socket编程，那么什么是Socket呢？简单地说，Socket，套接字，就是两台主机之间逻辑链接的端点。TPC/IP协议是传输层协议，主要解决数据如何在网络中传输，而HTTP是应用层协议，主要解决如何包装数据。Socket，本质上就是一组接口，是对TCP/IP协议的封装和应用(程序员层面上)。
Socket编程主要涉及到客户端和服务器端两个方面，首先是在服务器端建立一个服务器套接字(ServerSocket)，并把它附加到一个端口上，服务器从这个端口监听链接。端口号的范围是0到65536，可是0到1024是为特权服务保留的端口号，咱们能够选择任意一个当前没有被其余进程使用的端口。
客户端请求与服务器进行链接的时候，根据服务器的域名或者IP地址，加上端口号，打开一个套接字。当服务器接受链接后，服务器和客户端之间的通讯就像输入输出流同样进行操做。

下面是一个客户端和服务器端进行数据交互的简单例子，客户端输入正方形的边长，服务器端接收到后计算面积并返回给客户端，经过这个例子能够初步对Socket编程有个把握.
服务器端：

public class SocketServer {

    public static void main(String[] args) throws IOException {

        // 端口号
        int port = 7000;
        // 在端口上建立一个服务器套接字
        ServerSocket serverSocket = new ServerSocket(port);
        // 监听来自客户端的链接
        Socket socket = serverSocket.accept();

        DataInputStream dis = new DataInputStream(
                new BufferedInputStream(socket.getInputStream()));

        DataOutputStream dos = new DataOutputStream(
                new BufferedOutputStream(socket.getOutputStream()));

        do {

            double length = dis.readDouble();
            System.out.println("服务器端收到的边长数据为：" + length);
            double result = length * length;
            dos.writeDouble(result);
            dos.flush();

        } while (dis.readInt() != 0);

        socket.close();
        serverSocket.close();
    }
}

**客户端**：
public class SocketClient {

    public static void main(String[] args) throws UnknownHostException, IOException {

        int port = 7000;

        String host = "localhost";

        // 建立一个套接字并将其链接到指定端口号
        Socket socket = new Socket(host, port);

        DataInputStream dis = new DataInputStream(
                new BufferedInputStream(socket.getInputStream()));

        DataOutputStream dos = new DataOutputStream(
                new BufferedOutputStream(socket.getOutputStream()));

        Scanner sc = new Scanner(System.in);

        boolean flag = false;

        while (!flag) {

            System.out.println("请输入正方形的边长:");
            double length = sc.nextDouble();

            dos.writeDouble(length);
            dos.flush();

            double area = dis.readDouble();

            System.out.println("服务器返回的计算面积为:" + area);

            while (true) {

                System.out.println("继续计算？(Y/N)");

                String str = sc.next();

                if (str.equalsIgnoreCase("N")) {
                    dos.writeInt(0);
                    dos.flush();
                    flag = true;
                    break;
                } else if (str.equalsIgnoreCase("Y")) {
                    dos.writeInt(1);
                    dos.flush();
                    break;
                }
            }
        }
        socket.close();
    }
}