java面试(基础篇)

转自 https://blog.csdn.net/qq_25373015/article/details/78158102

1、JDK和JRE的区别以及跨平台的原理
    JRE:java的运行环境,包括java虚拟机和java程序所需的核心类库,JVM+类库

    JDK:java的开发工具包,包含java的开发工具,编译工具、打包工具等

    JDK  =  JRE+Java的开发工具

    跨平台的原理:实现跨平台需要依赖java的虚拟机JVM,不同平台使用不同的java虚拟机,实现一次编译处处运行。

2、java的关键字和标识符及其特点
    java关键字:被java语言赋予特定含义的单词

    特点:组成关键字的字母全部小写,常见的代码编辑器对关键会有特殊的颜色标记

    标识符:给类、方法、变量等起名字

    特点:由字符、下划线、美元符$组成,不能以数字开头、不能是java的关键字

3、java的数据类型和分类
        分类:

            基本数据类型:四类八种

            引用数据类型:类、接口、数组

4、java的运算符种类
4.1、算术运算符
        对常量和变量进行操作的运算符

        字符参与运算:其实就是该字符对应的数值操作

        字符串和其它数据类型的数组做拼接,结果是字符串类型

4.2、赋值运算符
4.3、关系运算符
        关系运算符的结果都是boolean性,要么是true要么是false

4.4、逻辑运算符
4.5、三元运算符
 

5、&&和&的区别以及|和||的区别:
&&和&的区别
        &&和&都是逻辑与运算,都是要求运算符两侧的表达式为true,结果才为true。&& 具有短路效果,当左侧的表达式结果为false时,右侧将不再执行。&是无论左侧是     否为false,将继续执行下去。&还可以用于按位与

   

|和||的区别
        最终的结果是一样的,||具有短路效果,左侧为true,右边将不再执行,|是无论 左边是false还是true,右边都会执行

6、键盘录入的对象创建
    Scannersc = new Scanner(System.in);

    再调用sc.nextInt()的等函数

7、数组
    数组是存储同一种数据类型多个元素的容器

两种初始化方式:
        初始化:就是为数组中的数组元素分配内存空间,并为每个数组元素赋值

        动态初始化:初始化时只指定数组长度、并有系统为数组分配初始化值

        静态初始化:初始化指定每个数组元素的初始化值,有系统决定数组长度

8、JVM的内存划分
    栈:存储局部变量

    堆:存储new出来的东西

    方法区:

    本地方法区:与系统相关

    寄存器:给CPU使用

9、方法重载和方法重写
    方法重载:在同一个类中,允许多个同名方法,只要他们的参数个数或者参数类型不同即可,方法名相同,参数类型不同,分为参数个数不同,参数类型不同,与返回值无关

    方法重写:存在于子父类之间,子类的方法的权限修饰符权限大于或等于父类的,方法名和参数类型完全相同,与返回值有关

10、方法中的参数传递
    形参为基本数据类型:形参的改变不影响实际参数

    形参为引用数据类型:形参的改变会影响实际参数

11、面向对象的特征
1、封装
        将客观事物封装成抽象的类,一个类就是一个封装了数据和操作的这些数据的代码        的逻辑实体

2、继承
        可以让其他类型的得对象获得另一个类型的对象的属性的方法。它可以使用          现有类的所有功能,并在无需重写原来类的情况下对这些功能进行扩展

3、多态
        父类或父接口引用指向的子类对象

 

12、面向对象的特点
    更符合我们的思考方式,将事情将给其他人去做,将复杂事情简单化,我们从执行者变    成了指挥者角色

 

13、类与对象的关系
    类:是一组相关属性和行为的集合

    对象:是该类事物的具体体现

 

14、String、StringBuffer、StringBuilder
    String:字符串常量,字符串长度不变,是被声明程final的,一次赋值不可改变

    StringBuffer:字符串变量,线程安全,如果需要频繁的对字符串内容进行修改,处于效率考虑最好使用StringBuffer。StringBuffer,在任意时间点上都包含特定的字符序列,但通过方法调用改变长度和内容

    StringBuilder:字符串变量,非线程安全。StringBuilder对象被当做一个包含字符序列的变长数组,是在JDK1.5后新增的,可用于字符串缓冲区被单线程使用时使用

 

15、String对象的两种创建方式
    通过构造方法创建字符串对象是在堆内存

    直接赋值方式创建对象是方法区的常量池

 

16、String是基本的数据类型
    String类是final类型,因此这个类不能被继承,不能修改。为了提高效率节省空间,使用StringBuilder类

 

17、GC是什么?为什么要用GC
    GC是垃圾回收的意思,内存处理是编程人员容易出现的问题的地方,忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃,java提供的GC功能可以自动检测对象是否超过作用域从而达到自动回收的目的,java语言没有提供释放已分配内存的显示操作方法。

 

18、java中有几种类型的流
    字节输入流:InputStream 字节输出流:OutputStream

    字符输入流:Reader      字符输出流:Writer

 

19、什么是java序列化,如何实现java序列化
    java对象的序列化是指将一个java对象写入IO流中,于此对应的是,对象的反序列化则是从IO流中恢复的Java对象。如果要让某个对象支持反序列化机制,必须让它的类是可序列化,则需要实现Serializable接口或者Externalizable接口

 

20、对象在序列化时不想给一个字段的数据保存到硬盘上
    使用transient关键字

 

21、IO中的适配器模式
    适配器模式:讲一个累的接口转换成客户希望的另一个接口,使得原本由于接口不兼容而不能一起工作的哪些类可以一起工作在java IO中。

    BufferedReaderbr = new BufferedReader(new InputStreamReader(is2,"utf8"));

        (将字节流接口,转换成字符流接口)

    br.readLine();

    因为要逐行解析字符串, 我们需要使用字符流,对文件内容进行处理, 所以使用Reader输入流下面的BufferedReader,BufferedReader并不能直接处理文件,它需要传入一个Reader类型的参数,Reader下面能处理文件的类:InputStreamReader,以及其子类FileReader,这2个类都需要一个InputStream来读取文件中的内容并转换, 这2个类其实就是适配器, 可以把字节流转换成字符流, 然后使用Reader来解析其中的内容

 

22、IO中的装饰模式
    装饰模式就是对一个类进行装饰,增强其方法行为,在装饰模式中,作为原来的这个类的使用者应该感受不到装饰前和装饰后的不同。装饰模式就是对原有功能的扩展。

 

22、适配器模式和装饰模式的总结
    适配器模式主要是将一个接口转变成另一个接口,它的目的是通过改变接口来达到重复使用的目的。装饰模式则是不是改变被装饰对象的接口,而是保持原来的接口,但是增强了元有对象的功能,或改变原有对象的方法而提高性能

 

23、同步和异步、阻塞和非阻塞
    同步:当一个同步调用发出后,调用者要一直等待返回消息通知后,才能进行后续执行

    异步:当一个异步过程调用发出后,调用者不能立刻得到返回消息。在调用结束后,通过消息回调来通知调用者是否成功

    阻塞:阻塞调用是指调用结果返回之前,当前线程会被挂起,一直处于等待消息通知,不能够执行其他业务,函数只有在得到结果后才会返回

    非阻塞:非阻塞和阻塞的概念相对应,指再不能立刻得到借过钱,该函数不会阻塞当前线程,而会立刻返回

 

    同步和异步的重点在于消息通知的方式,也就是调用结果通知的方式

    阻塞和非阻塞的重点是当前线程等待消息返回的行为

    分类:同步阻塞、同步非阻塞、异步阻塞、异步非阻塞

 

24、进程和线程的区别
    进程是正在进行中的程序。线程其实就是进程中一个程序执行控制单元,一条执行路径。进程负责的是应用程序的空间的标示。

    一个进程至少有一个线程在运行,当一个进程中出现多个线程时,这个应用程序就是多线程应用程序,每个线程在栈区都有自己的执行空间,自己的方法区、自己的变量。

 

25、线程的运行
       start方法,作用1、启动了线程,2)、让jvm调用了run方法

 

26、创建线程的方式
    1)、继承Thread,由子类重写run方法,由run方法体来完后曾线程需要做的事

    2)、实现了Runnable接口,由run方法体来完后曾线程需要做的事

    3)、通过Callable和FutrueTask创建线程。创建Callable的实现类,实现call()方法,该call()方法作为线程执行体,并有返回值

    创建Callable实现类的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。

 

27、多线程安全问题
    当一个线程执行多条语句时,并运算同一个数据时,在执行过程中,其他线程参与进来,并操作这个数据,导致了错误数据的产生

    涉及到两个因素

        1、多个线程在操作共享数据

        2、有多条数据对共享数据进行运算

    解决方案:

        只要将操作共享数据的语句在某一个时段让一个线程执行完,在执行过程中,其他线程不能进来执行就可以解决--------使用同步代码块

   

28、同步的好处与弊端
    好处是解决了线程安全问题,弊端是相对降低性能,因为判断锁需要资源,产生了死锁

    前提:必须有两个及以上的线程才需要同步,多个线程必须保证是同一个锁

 

29、同步代码块和同步函数的区别
    同步代码块使用的锁可以是任意对象

    同步函数使用的锁是this,静态同步函数的锁是该类的字节码文件对象

    在一个类中只有一个同步,可以使用同步函数。如果有多同步,必须使用同步代码块,来确定不同的锁。同步代码块相对灵活一些

 

30、请写一个延迟加载的单例模式?写懒汉式;当出现多线程访问时怎么解决?加同步,解决安全问题;效率高吗?不高;怎样解决?通过双重判断的形式解决。

//懒汉式:延迟加载方式。

当多线程访问懒汉式时,因为懒汉式的方法内对共性数据进行多条语句的操作。所以容易出现线程安全问题。为了解决,加入同步机制,解决安全问题。但是却带来了效率降低。

为了效率问题,通过双重判断的形式解决。

class Single{

    privatestatic Single s = null;

    privateSingle(){}

    publicstatic Single getInstance(){ //锁是谁?字节码文件对象;

        if(s== null){

            synchronized(Single.class){

                if(s== null)

                    s= new Single();

            }

        }

        returns;

    }

}

   

31、等待唤醒机制
    wait:将同步中的线程处于冻结状态。释放了执行权,释放了资格,同时将线程对象存在线程池中

    notify:唤醒线程池中的某一个等待线程

    notifyAlll:唤醒的是线程池中的所有线程

 

32、sleep和wait的区别
    wait:可以指定时间也可以不指定时间,不指定时间,只能由对应的notify或者notifyall来唤醒

    sleep:必须指定时间,时间到自动从冻结状态转成运行状态(临时阻塞状态)

    wait:线程会释放执行权,而且线程会释放锁

    sleep:线程会释放执行权,但不释放锁

 

33、线程死锁的出现和解决办法
    当线程任务出现了多个同步(多个锁)时,如果同步嵌套了其他的同步,这时容易引发一种现象:线程出现无限等待,都在等待对方的执行结束

    解决方案:线程按照一定的顺序加锁,按照同一顺序访问对象,避免事务中用户的交互,保持事务处于一个批处理,死锁检测

 

34、lock和synchronize的区别
    lock不是java内置的,synchronize是java的关键字,lock是一个类,通过这个类可以实现同步访问

    Lock和Synchronize的最大不同:采用Synchronize不需要用户去手动加锁,当Synchronize方法或者代码块执行完成后,系统会自动让线程释放对锁的占用,而lock则必须要用户手动释放锁,如果没有自动释放锁,会出现死锁的现象

 

35、启动一个线程是run()还是start()?它们的区别?
    启动一个线程是start()

    区别:

        start: 启动线程,并调用线程中的run()方法

        run  : 执行该线程对象要执行的任务

 

36、单例设计模式
    两种方式

A:饿汉式:当类加载时就创建对象
        class Student{

            privateStudent(){}

   

            private static final Student s = newStudent();

       

            publicstatic Student getInstance(){

                returns;

            }

        }

B:懒汉式 当使用的时候,才去创建对象
        classStudent{

            privateStudent(){}

   

            privatestatic final Student s = null;

       

            publicstatic Student getInstance(){

                if(s==null){

                    //线程1进来了,线程2就进来了

                    s= new Student();

                }

                returns;

            }

        }

饿汉式和懒汉式的区别
        饿汉式是类一加载就创建好对象,

        懒汉式是类加载进内存,对象还没有存在,只有调用getInstance()方法才创建对象

       

        懒汉式是延迟加载,如果多个线程同时操作懒汉式就可以出现线程安全问题,

        开发中常使用饿汉式,因为饿汉式安全。

 

37、Java中创建(实例化)对象的五种方式
    1、用new语句创建对象,这是最常见的创建对象的方法。

    2、通过工厂方法返回对象,如:String str = String.valueOf(23);

    3、运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()     实例方法。如:Object obj =Class.forName("java.lang.Object").newInstance();

    4、调用对象的clone()方法。

    5、通过I/O流(包括反序列化),如运用反序列化手段,调用java.io.ObjectInputStream     对象的 readObject()方法。

 

38、异常
    程序运行过程中的不正常现象叫做异常

    异常的根类是Throwable

        |--Error:重大问题,处理不了,例如JVM内存溢出  

        |--Exception:一般性错误,需要我们编写代码进行处理

           

39、异常的分类:
    编译时异常
            在编译时,如果没有处理,编译失败

    运行时异常
            在编译时,不需要处理,编译器不检查

            该异常的发生,减一不处理,让程序停止,需要对代码进行修正

 

40、java中三种常见内存溢出错误的处理方法
    jvm管理的内存大致包括三种不同类型的内存区域:Permanent Generation space(永久保存区域)、Heapspace(堆区域)、Java Stacks(Java栈)。

第一种OutOfMemoryError: PermGen space
        原因是:程序中使用了大量的jar或class,使java虚拟机装载类的空间不够   

        解决方案:

            1、增加java虚拟机中的XX:PermSize和XX:MaxPermSize参数的大小,其中         XX:PermSize是初始永久保存区域大 小,XX:MaxPermSize是最大永久保存区域大小。

            2、清理应用程序中web-inf/lib下的jar,如果tomcat部署了多个应用,很多           应用都使用了相同的jar,可以将共同的jar移到tomcat共同的lib下,减少类的重     复加载。

第二种OutOfMemoryError:  Java heap space
        原因是java虚拟机创建的对象太多,在进行垃圾回收之间,虚拟机分配的到堆内     存空间已经用满了,与Heapspace有关

    解决方案:

        1、检查程序,看是否有死循环或不必要地重复创建大量对象。找到原因后,修改 程序和算法。

        2、增加Java虚拟机中Xms(初始堆大小)和Xmx(最大堆大小)参数的大小。

第三种OutOfMemoryError:unable to create new native thread
        因为JVM已经被系统分配了大量的内存,并且它至少要占用可用内存的一半

        要想创建更多的线程,你必须减少分配给JVM的最大内存

 

41、final、finally、finalize区别
    final是最终的意思,可以用于修饰类、成员变量、成员方法

        它修饰的类不能被继承,修饰的变量是常量,修饰方法不能被重写

    finally:是一场处理里面的关键字

        它其中的代码永远会被执行,特殊情况:在执行前jvm退出

    finalize是Object类中的一个方法

        它用于垃圾回收器调用方式

42、什么是锁?锁的作用是什么?
    锁就是对象

    锁的作用是保证线程同步,解决线程安全问题。

    持有锁的线程可以在同步中执行,没有锁的线程即使获得cpu执行权,也进不去。

 

43、什么是ThreadLocal类,怎么使用它?
    ThreadLocal类提供了线程局部 (thread-local) 变量。是一个线程级别的局部变量,并非“本地线程”。

    ThreadLocal为每个使用该变量的线程,提供了一个独立的变量副本,每个线程修改副本时不影响其它线程对象的副本

 

    下面是线程局部变量(ThreadLocal variables)的关键点:

        一个线程局部变量(ThreadLocal variables)为每个线程方便地提供了一个单独的变量。

       ThreadLocal实例通常作为静态的私有的(private static)字段出现在一个类中,这个类用来关联一个线程。

        当多个线程访问 ThreadLocal 实例时,每个线程维护 ThreadLocal 提供的独立的变量副本。

        常用的使用可在 DAO 模式中见到,当 DAO 类作为一个单例类时,

        数据库链接(connection)被每一个线程独立的维护,互不影响。(基于线程的单例)

 

44、集合和数组的区别
    数组的长度是固定的,而集合长度是可变的

    数组值可以存储对象,还可以存储基本数据类型;而集合只能够只能存储对象

    数组存储的数据类型是固定的,而集合存储的数据类型不固定

 

45、HashSet是如何保证元素唯一性的呢?
    如果两元素的hashCode值不同,则不会调用equals方法

    如果两元素的hashCode值相同,则继续判断equals是否返回true;

    hashCode和equals方法虽然定义在自定义对象类里面,但不是我们手动调用而是往           HashSet集合里面存储元素的时候,集合底层自己调用hashCode和equals它自己      拿对象去判断,自己判断两元素是否是同一个元素。

 

46、Map
    Map:顶层接口,该集合存储的是键值对,而且键是唯一的,Map和Set很像,Set集合底层就   是使用了Map集合。

    Map集合没有迭代器,要取出元素必须先将Map集合转换成Set集合才能遍历元素

       |--->HashTable(JDK1.0):

        底层是哈希表数据结构;

        不可以使用null键和null值;

        用作键的对象必须实现hashCode和equals方法来保证键的唯一性

        线程同步,效率低

       |--->HashMap(JDK1.2):

        底层是哈希表数据结构;

        允许使用null键和null值;

        线程不同步,效率高;

        保证元素唯一性的:

             原理:先判断元素的hashCode值是否相同,再判断两元素的equals方法是     否为true

         (往HashSet里面存的自定义元素要复写hashCode和equals方法,以保证元素的    唯一性!)

 

47、LisIterator、Comparable、Comparator、Collections和Arrays
    LisIterator:系列表迭代器,允许程序员按任一方向遍历列表、迭代期间修改列表       Comparable:此接口强行对实现它每个类的对象进行整体自然排序。使元素具备比较性

    Comparator:强行对某个对象collection进行整体排序的比较函数,使集合具备比较性

    Collections:此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。

    Arrays:此类包含用来操作数组(比如排序和搜索)的各种静态方法

 

48、Map集合和Collection集合的区别?
    (1)

        Map中一次存储是键值对。

        Collection中一次存储是单个元素。

    (2)

        Map的存储使用的put方法。

        Collection存储使用的是add方法。

    (3)

        Map集合没有迭代器,Map的取出,是将Map转成Set,在使用迭代器取出。

        Collection取出,使用就是迭代器。

    (4)

        如果对象很多,必须使用集合存储。

        如果元素存在着映射关系,可以优先考虑使用Map存储或者用数组,

        如果没有映射关系,可以使用Collection存储。

 

49、IO流常用基类方法摘要:
        **字节写入流:OutputStream:

            voidclose() 关闭此输出流并释放与此流有关的所有系统资源。

            voidflush()刷新此输出流并强制写出所有缓冲的输出字节。

            abstract  void write(int b)  将指定的字节写入此输出流。

            voidwrite(byte[] b) 将 b.length 个字节从指定的 byte数组写入此输出流。   

            voidwrite(byte[] b, int off, int len)

                    将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。

        **字节读取流:InputStream:

            voidclose() 关闭此输入流并释放与该流关联的所有系统资源。

            intavailable() (特有方法!!)

                返回此输入流下一个方法调用可以不受阻塞地从此输入流读取(或跳过)                的估计字节数。

            abstract  int read() 从输入流中读取数据的下一个字节。

            intread(byte[] b)从输入流中读取一定数量的字节,并将其存储在缓冲区数组                  b中。

            intread(byte[] b, int off, int len) 将输入流中最多len个数据字节读入byte数组。

            longskip(long n) 跳过和丢弃此输入流中数据的 n 个字节。

          

        **字符写入流:Writer:

            abstract  void close() 关闭此流,但要先刷新它。

            abstract  void flush() 刷新该流的缓冲。

            voidwrite(int c) 写入单个字符。

            voidwrite(char[] cbuf) 写入字符数组。         

            abstract  void write(char[] cbuf, int off, int len) 写入字符数组的某一部分。

            voidwrite(String str) 写入字符串。

            voidwrite(String str, int off, int len) 写入字符串的某一部分。

        **字符读取流:Reader:

            abstract  void close() 关闭该流并释放与之关联的所有资源。

            intread() 读取单个字符。

            intread(char[] cbuf)  将字符读入数组

            abstract  int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分。

            longskip(long n)  跳过字符。

 

50、流的操作流程
    (1)第一步:先明确源和目的

        源:

            文本:用Reader

            字节:用InputStream

        目的:

            文本:用Writer

            字节:用OutputStream

    (2)第二步:明确是不是纯文本

        是:用字符流;

        不是:用字节流

    (3)第三步:明确流体系后,通过设备来明确具体使用哪个流对象

        源设备:

            键盘:System.in

            硬盘:文件流File

            内存:数组流ArrayStream

        目的设备:

            键盘:System.out

            硬盘:文件流File

            内存:数组流ArrayStream

 

51、File类常见需求:
(1)文件名过滤:列出给定目录的所有.java文件
        publicvoid showFileName(File file)

        {

            String[]filenames = file.list(new FilenameFilter()//匿名内部类

            {

                publicboolean accept(File dir,String name)//复写唯一方法

                {

                    returnname.endsWith(".java");//列出所有.java文件

                }

            });

        }

(2)列出指定目录下的所有文件和文件夹(递归)
    **示例1:不带层次递归:

    publicstatic void showDir(File dir)

    {

        File[]files = dir.listFile();

        for(inti = 0;i<files.length;i++)

        {

            if(files[i].isDirectory&&!files[i].isHidden())

                showDir(files[i]);

            else

                sop(files[i]);

        }

    }

    **示例2:带层次递归:

    publicstatic void showDir(File dir,int level)

    {

        sop(getLevel(level)+C);//进来先打印层次和目录

        level++;

        File[]files = dir.listFile();

        for(inti = 0;i<files.length;i++)

        {

            if(files[i].isDirectory&&!files[i].isHidden())

                showDir(files[i]);

            else

                sop(getLevel(level)+files[i]);//是文件就打印层次和目录

        }

    }

    publicstatic String getLevel(int level)

    {

        sop("|--");

        StringBuildersb = new StringBuilder();

        for(inti=0;i<level;i++)

        {

            sb.inset(0."|  ")

        }

        returnsb.toString();

    }

(3)需求:删除带内容的目录:
    publicstatic void removeDir(File dir)

    {

        File[]files = file.listFile();

        for(inti = 0;i<files.length;i++)

        {

            if(files[i].isDirectory&&!files[i].isHidden())

                removeDir(files[i]);//如果是文件夹则继续调用函数

            else//如果是文件则删除。注意删除的时候打印删除的结果,防止误删或者重删的情况

                sop(files[i].toString()+"::"+files[i].delete());

        }

        sop(dir+"::"+dir.delete());

    }

 (4)需求:将制定目录下java文件的绝对路径存储到文本文件中。
       思路:

       **对指定目录进行递归

       **获取递归过程中所有java文件的路径

       **将这些路径存储到集合中

       **将集合中的数据写入文件中

     //对指定目录进行递归并将所以Java文件存储到集合中

    publicstatic void getFileName(File file,ArrayList<File> arraylist){

        File[]files = file.listFiles();

        for(int i = 0; i < files.length; i++) {

            if(files[i].isDirectory()&&!files[i].isHidden()){

                getFileName(files[i],arraylist);

            }else{

                if(files[i].getName().endsWith(".java")){

                    arraylist.add(files[i]);

                }

            }

        }

    }

    //将集合中所有数据存储到新文件中

    publicstatic void saveFileToNewDir(ArrayList<File> arraylist,File newDir){

        BufferedWriterbufw = null;

        try{

            bufw= new BufferedWriter(new FileWriter(newDir));

            for(File file : arraylist) {

                StringfileAbsolutePath = file.getAbsolutePath();

                bufw.write(fileAbsolutePath);

                bufw.newLine();

                bufw.flush();  

            }

        }catch (Exception e) {

            System.out.println("文件写入失败");

        }finally{

            try{

                if(bufw!=null)

                    bufw.close();

            }catch (Exception e2) {

                System.out.println("文件写入流关闭失败");

            }

        }

    }

 

52、Properties
    (1)Properties是HashTable的子类,具备Map集合的特点,里面存储的是键值对

    (2)Properties是IO流合集合相结合的集合容器

    (3)Properties的特点是可以用于存储键值对形式的配置文件

 

53、网络模型:
OSI模型
        应用层、表示层、会话层、传输层、网络层、数据连接层、物理层

TCP/IP模型
        应用层、传输层、网际层、主机至网络层

 

54、UDP和TCP的区别:
UDP
        将数据及源和目的封装成数据包中,不需要建立连接

        每个数据报的大小在限制在64k内

        因无连接,是不可靠协议

        不需要建立连接,速度快

TCP
        建立连接,形成传输数据的通道。

        在连接中进行大数据量传输

        通过三次握手完成连接,是可靠协议

        必须建立连接,效率会稍低

55、XML文档的定义形式?他们之间的本质区别,解析XML文档的方式

    XMl文档定义分为DTD和Schema两种形式,二者都是对XML语法的约束,其本质的区别在于Schema本省就是一个xml文件,可以被XML解析器解析,而且乐意为XML承载的数据定义类型约束比DTD更强大。

    对XML的解析主要有DOM(文档对象模型),SAX和StAX。

    DOM处理大型文件时其性能下降的非常厉害,这个问题是由DOM树结构占用的内存较多造成的,而且DOM解析方式必须在解析文件之前把整个文档装入内存,适合对XML的随机访问(典型的用空间换取时间的策略);SAX是事件驱动型的XML解析方式,它顺序读取XML文件,不需要一次全部装载整个文件。当遇到像文件开头,文档结束,或者标签开头与标签结束时

 

56、你在项目中哪些地方用到了XML?

    XML的主要作用有两个方面:数据交换和信息配置。在做数据交换时,XML将数据用标签组装成起来,然后压缩打包加密后通过网络传送给接收者,接收解密与解压缩后再从XML文件中还原相关信息进行处理,XML曾经是异构系统间交换数据的事实标准,但此项功能几乎已经被JSON(JavaScriptObjectNotation)取而代之。
 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值