下列题目是我们基础班几个提前参加社招的同学总结的问题，希望对大家有所帮助。答案是我个人的理解所以一定会有些不全面甚至不对的地方，但是是我自己的答案，所以你们觉得有问题可以提出来我纠正。
1,说一下堆和栈的区别?
        栈的内存空间是由系统自动分配的。例如int a；系统就自动在栈里开辟个空间给a使用。
        它存取速度比堆要快，而且栈里面的数据可以共享，存放的数据是一些基本类型的数据，特点是存放在栈里的数据被调用完立马消失。
        堆的内存空间是由程序员自己申请（new）出来的。
        堆内存主要用来存储引用类型，特点是堆里面的数据被调用完毕后不会马上消失，而是在某个不确定的时间后被垃圾回收器清理掉。
2，TreeSet的排序方式有几种，详细描述？
        A.自然顺序
                让对象所属的类去实现comparable接口，然后重写这个接口的comparto方法进行比较，根据这个比较的结果去进行排序。
        B.比较器接口，comparator接口
                在创建对象时使用带参构造传一个实现比较器接口的匿名内部类并重写它的方法就可以进行比较了。
3，线程生命周期,是怎么样的？
        新建，就绪，运行，堵塞，死亡
        新建是创建线程。
        就绪是获得执行资格但是没有执行权。
        运行不解释。
        堵塞，就是当线程运行到符合某个我们定义的条件时，它会停止下来等待唤醒
        死亡就是线程结束了。
4，线程死锁是什么，为什么有死锁，怎么解决死锁？
         为了解决程序因占用资源，出现资源争抢，而出现的程序进入等待的状态（死锁）。
        举例：有A和B两个线程，有CD 两把锁， A和B嵌套CD锁，A线程中有C，D锁，B线程中有D C两把锁，当两个线程运行时，就可能会出现死锁导致
程序停滞的情况。
        怎么解决：真正意义上来说，死锁是不能被解决的，死锁是多线程中的一个需要避免的重大的问题，当我们在编写程序时，可以给共享的资源加上另外一
个把锁，控制资源的动态，同时可以设置线程的优先级使线程之间协调合理的利用CPU的时间。
5，类和对象是什么？
        类是对某种事物的抽象统称，例如学生，是一个群体，他们有着共同的特征。
        对象是类的实例，例如说在学生这个类里面有一个叫做小明的学生，他有着具体的特点，这个时候就把他叫做是这个学生类的对象。
6，集合包括哪些类？
        list--|ArrayList
                |Vector
                |LinkedList
        Set -| TreeSet
                 | HashSet
        Map -  |HashMap
                |Hashtable
                |Properties
                |TreeMap
7,java有多继承吗？
        有，接口可以多继承，因为接口只是一个功能的拓展，他多继承只是让本身具备更多的功能而已，而多继承之所以会出错的原因，比如说一个普
通类继承了多个类的时候，如果这多个类有些相同的方法时，这个类就不知道要去继承哪一个类的方法。而接口就没有这种错误，因为如果接口去继承其
他多个接口的话，哪怕其他接口有一些相同的方法，又因为接口中的方法都是抽象的没有方法体，所以在继承时也只会保留下来一个。
8、你是怎么理解面向对象的
        他有3个特点：更符合思考习惯，让程序员从执行者变成指挥者，把复杂的事情简单化。
        我是这样理解的，比如说我要得到某种结果或者完成某件事情的时候，我并不需要自己亲自的完成这一系列的过程，只需要找到能够帮助我完成
需求的工具就可以很高效的达成目标了，我觉得这个过程就叫面向对象。
9、接口跟抽象类的区别
        成员特点        抽象类中可以有成员变量跟成员常量，有构造方法，除了抽象方法外也可以有非抽象方法。
                        接口中只有常量，默认修饰符是public static final，接口中只有抽象方法默认修饰符是public abstract。
        关系特点  类跟类之间只能单继承跟多重继承。
                        类跟接口可以单实现、多实现，也可以在继承一个类的时候再实现一个或者多个接口。
                         接口跟接口可以单继承也可以多继承。       
        设计理念   继承体现的关系是is a  代表子类就是父类的一个延伸，就是说有地方用到父类的时候完全可以用子类替代。
                        接口体现的关系是like a  它定义的是整个体系的扩展内容。
10、说说你对异常的理解
        异常就是在程序编译或者运行的时候会出现的一些错误，比如说我要往一个指定的文件写入数据，但是这个时候虚拟机又不敢确定在硬盘里有没
有这个文件，所以为了避免发生错误，就需要我们来指定当出现这种情况时虚拟机要做出什么动作。例如抛出异常让虚拟机处理，或者我们用try、catch
处理。
11、list跟set的区别
        list是元素有序，并且可重复的。
                这个有序说的是存放数据时的顺序是怎么样的那我们将来取出元素调用的时候就是怎么样的，而且多个相同的元素并不会影响储存。
        set是元素无序，并且唯一的。
                无序说的是我们在取出元素时不是按照我们当初存的顺序出来的，比如说我打印这些元素会发现每次打印，元素的位置都不一样。
                但是通过实现comparable或者实现comparator接口也可以给元素排序。
12、基本的io流有哪些
        字符流两种：FileWriter、FileReader       
        字节流两种：FileOutputStream、FileInputStream
        高效字符流两种：BufferedWriter、BufferedReader
        高效字节流两种：BufferedOutputStream、BufferedInputStream
        打印流：printWriter、printReader
        转换流：InputStreamReader、OutputStreamWriter
        标准输入输出流：System.in、System.out
        序列化流：ObjectInputStream、ObjectOutputStream
13、反射是什么？反射获取字节码文件的三种方式？反射的好处？
        在运行状态下，通过class文件对象（Class的对象），去使用构造方法，成员变量，成员方法。就是反射。
        3种方法：
                A.用Object类的getClass方法得到。
                B.用任意数据类型的静态class属性可以得到
                C.用Class类的静态方法forName（String className）方法得到
        好处：只要有一个类或者一个类的对象，就可以得到这个类或对象的所有属性和方法。包括私有的。
14、单例的两种模式
        （这个我还没有透彻理解所以只给模式名）
        饿汉式
        懒汉式
16、内部类
        （这个也是了解不深）
        成员内部类，他是在class中又直接定义一个class
        局部内部类，在方法中定义一个class
        匿名内部类，他是没有名字的内部类，我用的最多的地方是在创建对象要带参的时候用到他。他是一次性的用完就不能用了。
17、map的特点，怎样获取键值
        把数据按照键跟值的特点存储在集合里，使用的时候可以通过键得到值，键是唯一的，值却可以重复。
        有个方法keySet可以得到集合里的键，有了键再遍历就可以获取值。
18、static的作用？
        1.被static修饰的成员是被所有对象共享的。
        2.随着类的加载而加载。
        3.优先于对象存在。
        4.可以直接被类名调用。
19、接口和抽象类的区别
        1.接口里面都是抽象方法，只有常量；抽象类里面不一定都是抽象方法，可以有成员变量也可以有常量
        2.接口是功能的扩展；而抽象类是抽取子类的共性功能，强制子类必须按照抽象类方法重写。
20、ArrayLIst和LinkedList的区别？为什么ArrayList查询快
        ArrayList底层是数组结构，特点是查询快增删慢；LinkedList底层是链表结构，特点是增删块查询慢。
        因为ArrayList底层是数组结构，通过数组的索引值我们就可以做到快速查询！
22、字节流和字符流的区别
        字符流的底层是字节流，最早的时候只有字节流，后来为了能够支持文字所以开发出了字符流，字符流能更高效的处理文本数据；
        同时如果要处理的是文本数据的话就可以用字符流，但如果要处理多媒体文件的时候就只能使用字节流。
        因为java使用的编码是unicode编码，一个字符等于两个字节。
23、多线程的两种实现方式，它们有什么区别
        两种，
        1.对象对应的类继承Thread类，这种可以直接调用start方法开启多线程。
        2.对象对应的类实现Runnable接口，这种要重新new一个Thread对象把对象作为参数传进去才能调用start方法。
        开发一般用第二种，他避免单继承的局限性。实现资源与线程的分离

24、对网络通信协议的理解
        （忘了）
25、线程开启调用什么方法
        如果对象对应的类继承的是Thread类的话那么用对象调用start方法就可以开启线程；
        如果对象对应的类是实现Runnable接口的话，就必须把这个对象转化成Thread类再调用start方法。转换方式就是new一个Thread对象并把实现Runnable接口的类的对象作为参数传进去就可以了。

编程题：
        1.复制某盘下所有（包括子目录）“.java”后缀的文件到另一目录下。
        2.把D盘下的所有.java文件改成.txt后缀并复制到另一个目录下，或者把绝对路径储存在.txt文档里
        3.定义一个学生类，属性有名字，语文分数，数学分数，英语分数。键盘录入5个学生跟分数，按照总分先排序再写进txt文档，要求在文档里要清晰明了查看这些数据。

支持    233333333333

明天就面试了   希望我能进入就业班  王子鹏 加油！

老司机  怎么没看见呀

楼主好人。。。

多谢分享～

谢谢分享

有用 收了

感谢分享，不错

编程题这么简单呢？？？？？？？？？？？？

楼主厉害！

感谢分享！！！

文件过滤器：
        dir.list(过滤器);把符合条件的过滤出来。
写法：
        String[] arr = dir.list(new FilenameFilter() {
                       
                        @Override
                        public boolean accept(File dir, String name) {
                                //System.out.println(dir);
                                //System.out.println(name);
                                File file = new File(dir, name);
                                return file.isFile() && file.getName().endsWith(".jpg");
                        }
                });
File 类，是一个路径。这个路径可以表示文件或者文件夹。我们通过这个File类对这个路径进行判断或者获取相应的

信息
                 如果这个路径是一个文件，那么对文件的内部内容是不做任何操作的。       

按操作类型分为两种：
                                        * 字节流 : 字节流可以操作任何数据,因为在计算机中任何数据都是

以字节的形式存储的
                                                                * InputStream (抽象父类)
                                                                                       

FileInputStream  字节输入流
                                                                * OutputStream(抽象父类)
                                                                                       

FileOutputStream 字节输出流
                                        * 字符流 : 字符流只能操作纯字符数据，比较方便。
                                                                * Reader(抽象父类)

                                                                * Writer(抽象父类)

read()方法返回值为什么是int而不是byte？
                                        其实就是因为byte取值范围只有256种，太过于短小，读图片音频等文

件时读到1111 1111，就自动停止了。

小数组的读写和带Buffered的读取哪个更快?
        * 定义小数组如果是8192个字节大小和Buffered比较的话
        * 定义小数组会略胜一筹,因为读和写操作的是同一个数组
        * 而Buffered操作的是两个数组
flush和close方法的区别：
                flush()方法 //相当于office中的保存
                        用来刷新缓冲区的,刷新后可以再次写出
                close()方法        //相当于office中的保存并退出
                        用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再

关闭流之前刷新缓冲区,关闭后不能再写出
字节流读取中文的问题
        字节流在读中文的时候有可能会读到半个中文,造成乱码
字节流写出中文的问题
        字节流直接操作的字节,所以写出中文必须将字符串转换成字节数组
        写出回车换行 write("\r\n".getBytes());

FileReader   字符输入流
        * 字符流是可以直接读写字符的IO流
        * 字符流读取字符, 就要先读取到字节数据, 然后转为字符. 如果要写出字符, 需要把字符转为字节再写出

.
        * FileReader类的read()方法可以按照字符大小读取
        //按照相应的码表去读，如果遇到中文，就一次读一个字符。


不同的字符在不同的码表中所占的字节是不同的。
        　　ASCII码：
        　　        一个英文字母（不分大小写）占一个字节的空间，一个中文汉字占两个字节的空间。
                        一个二进制数字序列，在计算机中作为一个数字单元，一般为8位二进制数，换算为十进

制。最小值0，最大值255。如一个ASCII码就是一个字节。
        　　UTF-8编码：
        　　        一个英文字符等于一个字节，一个中文（含繁体）等于三个字节。
        　　Unicode编码：
        　　        一个英文等于两个字节，一个中文（含繁体）等于两个字节。
        　　符号：
        　　        英文标点占一个字节，中文标点占两个字节。举例：英文句号“.”占1个字节的大小，中文句号“

。”占2个字节的大小。



什么情况下使用字符流：
                * 字符流也可以拷贝文本文件, 但不推荐使用. 因为读取时会把字节转为字符, 写出时还要把字符

转回字节.
                * 程序需要读取一段文本, 或者需要写出一段文本的时候可以使用字符流
                * 读取的时候是按照字符的大小读取的,不会出现半个中文,//遇到中文读一个字符，所以不会出现

半个中文
                * 写出的时候可以直接将字符串写出,不用转换为字节数组


字符流是否可以拷贝非纯文本的文件
                * 不可以拷贝非纯文本的文件
                * 因为在读的时候会将字节转换为字符,在转换过程中,可能找不到对应的字符,就会用?代替,写出

的时候会将字符转换成字节写出去
                * 如果是?,直接写出,这样写出之后的文件就乱了,看不了了  
                //不是文字就不要用字符流
BufferedReader 和 BufferedWriter 的特有方法readLine()和newLine()方法：

LineNumberReader:
        BufferedReader的子类, 具有相同的功能, 并且可以统计行号。
        * setLineNumber(100)方法可以设置当前行号//行号从101开始计算
        * getLineNumber()方法可以获取当前行号

序列流:了解//读取多个文件，往同一个文件里写时使用
        把多个字节输入流整合成一个, 从序列流中读取数据时, 将从被整合的第一个流开始读, 读完一个之后继续

读第二个, 以此类推
        //按顺序读取整合的字节输入流
内存输出流：掌握
        该输出流可以向内存中写数据, 把内存当作一个缓冲区, 写出之后可以一次性获取出所有数据
        //不是读一个显示一个，要一下子全都显示出来的情况下使用。比如QQ聊天
        //把数据都先写到内存中，然后一下子全都显示出来
随机访问流概述和读写数据 了解
//用于多线程下载 raf.seek(0);                                        //在指定位置设置指针


ObjectOutputStream 对象操作流 了解
                //该流可以将一个对象写出,执行了序列化的操作.
*序列化:将对象写出到文件

ObjectInputStream 对象操作流 了解
                //该对象可以读取一个对象到程序中，执行了反序列化的操作。
*反序列化:将文件中的字节数据翻译成对象

打印流的概述和特点        掌握
                该流可以很方便的将对象的toString()结果输出, 并且自动加上换行, 而且可以使用自动刷出的模

式
                PrintStream//打印字节流
                PrintWriter//打印字符流


                System.out就是一个PrintStream, 其默认向控制台输出信息


标准输入输出流概述和输出语句
                * System.in是InputStream,        标准输入流, 默认可以从键盘输入读取字节数据
                * System.out是PrintStream,  标准输出流, 默认可以向Console中输出字符和字节数据
                //以上两个流，如果不关联文件就不需要关闭



JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。


多线程程序实现的方式




两种方式的区别:
                * a.继承Thread : 由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方

法
                * b.实现Runnable : 构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run

()方法时内部判断成员变量Runnable的引用是否为空,
                                                        不为空编译时看的是Runnable的run(),运行时执行

的是子类的run()方法


                * 继承Thread
                        * 好处是:可以直接使用Thread类中的方法,代码简单
                        * 弊端是:如果已经有了父类,就不能用这种方法
                * 实现Runnable接口
                        * 好处是:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且

接口是可以多实现的
                        * 弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方

法,代码复杂



获取名字和设置名字:
        设置名字的两种方式

setDaemon() 守护线程        不单独执行, 当其他非守护线程都执行结束后, 自动退出


        join()加入线程, 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
        join(int), 可以等待指定的毫秒之后继续       




        yield   让出cpu                礼让线程//效果不明显，了解


        setPriority()设置线程的优先级//效果不明显，了解
        范围1-10；越大，执行的几率越多。也是几率问题，不能保证完全。也就是成功率99%也有可能爆掉装备。


同步代码块
        * 使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块
        * 多个同步代码块如果使用相同的锁对象, 那么他们就是同步的

        锁对象是任意的，但是不能是匿名对象。

同步方法
        使用synchronized关键字修饰一个方法, 该方法中所有的代码都是同步的
        使用继承Thread实现多线程时，如果使用类中的成员变量做为锁对象，那么该成员变量必须是静态的
        非静态的同步方法的锁对象是 this.
        静态的同步方法的锁对象是该类的字节码对象  xxxxx.class


//锁对象不能用匿名对象,因为匿名对象不是同一个对象


死锁：
        多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁
单例设计模式

饿汉式和懒汉式的区别
* 1,饿汉式是空间换时间,懒汉式是时间换空间
* 2,在多线程访问时,饿汉式不会创建多个对象,而懒汉式有可能会创建多个对象



两个线程间的通信
        等待唤醒机制
        wait();        当前线程等待
        this.notify();                        //随机唤醒单个等待的线程

//if语句是在哪里等待,就在哪里起来
//while循环是循环判断,每次都会判断标记


        notifyAll();//唤醒所有等待的线程


* 1,在同步代码块中,用哪个对象锁,就用哪个对象调用wait方法
* 2,为什么wait方法和notify方法定义在Object这类中?
*         因为锁对象可以是任意对象,Object是所有的类的基类,所以wait方法和notify方法需要定义在Object这个类

中
* 3,sleep方法和wait方法的区别?
* a,sleep方法必须传入参数,参数就是时间,时间到了自动醒来
*   wait方法可以传入参数也可以不传入参数,传入参数就是在参数的时间结束后等待,不传入参数就是直接等待
* b,sleep方法在同步函数或同步代码块中,不释放锁,睡着了也抱着锁睡
*         wait方法在同步函数或者同步代码块中,释放锁


线程的五种状态
                新建,就绪,运行,阻塞,死亡




网络编程，套接字编程，Socket编程

.网络编程的三要素?
        (1)IP地址        :每个设备在网络中的唯一标识
        (2)端口号        :每个程序在设备上的唯一标识，每个网络程序都需要绑定一个端口号 范围从0-65535，

1024以下的基本上都被系统程序占用了
                                 tomcat: 8080

        (3)协议                UDP        TCP

.UDP和TCP的区别?
        UDP:面向无连接，数据不安全，速度快。不区分客户端与服务端。
                把数据打包，数据有限制不超过64K，面向无连接，不安全，速度快
                举例：蓝牙，QQ单聊，打电话。

        TCP:面向连接（三次握手），数据安全，速度略低。分为客户端和服务端。
                三次握手: 客户端先向服务端发起请求, 服务端响应请求, 传输数据
                建立连接通道，无限制，面向连接，(三次握手),速度慢，安全
                举例：飞秋群聊,不保证消息一定收到
                发短信
掌握 Socket通信原理图解



这是我总结的面试题

Object类的HashCode()方法.
Object类的getClass()方法.
Object类的toString()方法.
Object类的equals()方法.
==号和equals的区别


Scanner 键盘录入的方式
Scanner 键盘录入的常见问题
解决方案


String 类
equals  比较
contains        包含
startsWith        开头
endsWith        结尾
isEmpty        空
length        长度
charAt        字节数组
indexOf        索引
toCharArray        字符串转字符数组
valueOf                把字符数组转成字符串
replace                        替换
trim                        清除两边空格

StringBuffer，StringBuilder，String的区别
append()方法   添加
replace()方法     替换
reverse()方法   删除
substring()方法        重写



冒泡，选择，二分查找


Arrays类的使用//Arrays就是数组的一个工具类
toString()                重写
sort()                排序
binarySearch()  二分查找发


String 和 StringBuffer 的互相转换
                                String--->StringBuffer   StringBuffer 构造函数转换,append()
                                StringBuffer--->String         toString，valueOf，+"",subString
任意类型和 String 之间的互相转换
                                        1，toString();
                                        2，valueOf(Object obj);
                                        3，任意类型+""
       
public String[] split(String regex)//切割功能.但是切割的时候要注意首尾

public String replaceAll(String regex,String replacement)//替换功能


按点切割，如何？
输出一个反斜杠如何？



Random类
伪随机数，根据种子算出来的随机数。


System类："不能为实例化"
* public static void gc()//了解，通知并不立刻执行
* public static void exit(int status)//掌握
        * public static long currentTimeMillis()//掌握
        获取毫秒值的两种方法

BigInteger类：
BigDecimal类 有什么用？什么时候用？

,最起码要判断有没有(hasNext),


集合体系图
数组和集合得不同
数组：可存储基本数据类型和引用数据类型
集合：只能存储引用数据类型，存100的时候自动装箱

迭代器：
并发修改异常
                        "用迭代器迭代的过程中，不能改变集合的长度"
                        解决方案：
                                不能让集合修改元素。
                                用迭代器自己修改元素
ListIterator 是 List 集合特有的迭代器


ArrayList 如何去除重复元素


栈和队列数据结构特点：
                        * 栈
                                * 先进后出               
                        * 队列
                                * 先进先出       
                               


泛型：
        就是一个过滤器，满足条件的才能赋值，不满足条件的就不能进行赋值
        常规使用：集合中。
        泛型的好处：//会用就行 不用记录
                * 提高安全性(将运行期的错误转换到编译期)
                * 省去强转的麻

? extends E
                        向下限定，E及其子类                        //？读作“什么”。什么继承于E。即E的

子类。
                                                                addAll(? extends E) //可添加E或者E

的子类对象
? super E                                //？读作“什么”。什么的爸爸E。即E的爸爸。
                        向上限定，E及其父类


        增强for  //底层是迭代器
                 好处： 简化遍历书写                                       
                        for（int i ： arr）{                //arr 要遍历的集合   i接收的参数
                                System.out.println(i);        //i就是集合中的每一个参数
                                        }
                         缺点： 不能删除添加
                                        只能遍历


集合的三种遍历方式：
静态导入：只要知道是JDK 1.5的新特性即可
                        //暴露实际开发经验的地方，开发千万不要写
                        //一般有经验的java程序员都不写，甚至忘记这个东西。
                  写法：
                        * import static 包名….类名.方法名; 把静态方法导入


JDK1.5的新特性：

增强的“for”循环（Enhanced For loop）

泛型（Generics）
枚举（Type safe enums）

可变参数(Var args)
自动装箱/ 自动拆箱（Autoboxing/unboxing）
静态导入（Static import）
互斥锁



HashSet 存储顺序不一致 也不保证该顺序一直不变
                如何保证元素的唯一性：
                        重写hashCode() 和 equals()方法


HashSet存储自定义对象保证元素唯一性:
                1.HashSet原理
                        当HashSet调用add()方法存储对象的时候, 先调用对象的hashCode()方法得到一个哈希

值, 然后在集合中查找是否有哈希值相同的对象
                        如果没有哈希值相同的对象就直接存入集合,这个时候就不调用equals()了。
                        如果有哈希值相同的对象, 就和哈希值相同的对象逐个进行equals()比较,比较结果为

false就存入, true则不存。存入时挂在同hashCode()值的元素下面。
                2.将自定义类的对象存入HashSet去重复
                        类中必须重写hashCode()和equals()方法
                        hashCode(): 属性相同的对象返回值必须相同, 属性不同的返回值尽量不同(提高效率)
                        equals(): 属性相同返回true, 属性不同返回false,返回false的时候存储


LinkedHashSet的概述和使用：
                HashSet 的儿子
                底层是链表实现的,是set集合中"唯一一个能保证怎么存就怎么取的集合对象"
                因为是HashSet的子类,所以也是保证元素唯一的,与HashSet的原理一样


TreeSet
                存储顺序不一致，二叉树结构，小的存左边(负数)，大的存右边(正数)，相等就不存(0)。用来对

象进行排序。

                TreeSet 存储自定义对象


                实现 Comparable 接口        重写compareTo()方法
                        当compareTo方法返回0的时候，集合中只有一个元素。
                        当compareTo方法返回正数的时候集合会怎么存就怎么取
                        当compareTo方法返回负数的时候集合会倒序存储
               
                构造一个比较器进行比较


两种方式的区别
                TreeSet 构造函数什么都不传, 默认按照类中Comparable的顺序(没有就报错

ClassCastException)
                TreeSet 如果传入Comparator, 就优先按照Comparator


TreeSet 不去重


Map 集合
                        双列集合
                        键唯一，值不唯一，键跟值一一对应
                Map 接口和 Collection 接口的不同
                        Map是双列的(是双列集合的根接口),Collection是单列的(是单列集合的根接口)
                        Map的键唯一,Collection的子体系Set是唯一的
                        Map集合的数据结构值针对键有效，跟值无关;如:TreeMap:键是用二叉树算法,HashMap:

键是hash算法
                        Collection集合的数据结构是针对元素有效


Map 集合的遍历方式



LinkedHashMap:
                底层是链表实现的可以保证怎么存就怎么取


统计字符串中每个字符出现的次数：
        1，可用数组实现，原理较复杂。有兴趣的同学可以找我单聊
        2，map集合实现较为简单
          
HashMap和Hashtable 的区别
        Hashtable是JDK1.0版本出现的,是线程安全的,效率低,HashMap是JDK1.2版本出现的,是线程不安全的,效率

高
        Hashtable不可以存储null键和null值,HashMap可以存储null键和null值       


异常：
                Throwable
                        |--Error
                        |--Exception --- RuntimeException
                                                 --- 编译时异常

                        面试题：
                                "常见的异常" 3到5个   切入到自己的实际开发，并以市场上QQ或者微信做比

较
                                        面试：
                                                 切入到自己的实际开发，怎么处理的。并以市场上QQ或者微

信做比较

                                        点招:
                                                 切入到自己的基础班写代码的时候，怎么处理的。

                                        空指针异常                        NullPointerException        "

最多"        找不到这个类 ClassNotFoundException  
                                        数组角标越界异常        ArrayIndexOutOfBoundsException        类型转换异

常 ClassCastException  
                                        文件未找到异常                FileNotFoundException                       

算术异常类         ArithmeticException



自己处理异常的方式：
                        1,自己处理,三种写法。
                                        * try catch
                                        * try catch finally
                                        * try finally

                                        try:用来检测异常的
                                        catch:用来捕获异常的。多个catch中，父类异常要写在下面，如果父

类异常写在上面，则子类异常捕捉的不执行。
                                        finally:释放资源

                                        try 中一旦有错误，下面代码不执行，立马转到对应错误 catch 中代

码，最后转入 finally 中。
                                        finally 执行完毕，跳出 finally ，程序继续执行。
                                        finally 的代码一定会执行，除非虚拟机 System.exit() 停止。
                                        如果报的异常没有对应的 catch ，则等于没有写try catch。程序照

常报错。

                        2,throws 抛出方式处理异常
                                        编译时异常的抛出必须对其进行处理
                                        运行时异常的抛出可以处理也可以不处理

                                        用一个方法，如果此方法抛出一个异常，运行时异常可处理也可不处

理，如果抛出编译时异常，则必须处理。
                                       
                                        throws和throw的区别：

                                        throws
                                                用在方法声明后面，跟的是异常类名
                                                可以跟多个异常类名，用逗号隔开
                                                表示抛出异常，由该方法的调用者来处理

                                        throw
                                                用在方法体内，跟的是异常对象名
                                                只能抛出一个异常对象名
                                                表示抛出异常，由方法体内的语句处理

编译期异常和运行期异常的区别：
                编译时异常:
                                在编译某个程序的时候,有可能会有这样那样的事情发生,比如文件找不到,这样

的异常就必须在编译的时候处理
                                如果不处理编译通不过。
               
                运行时异常:
                                就是程序员所犯得错误,需要回来修改代码。



面试题：//为了面试而产生的题目，实际没有一点意义
        * final,finally和finalize的区别。自己补充
        * 如果catch里面有return语句，请问finally的代码还会执行吗?如果会，请问是在return前还是return后

。
          return 建立返回路径的同时执行finally，不会改变变量赋的值。然后再 return 出去。//正常情况下不

会有这种情况，记住即可，不用深入研究
                         此时如果finally中还有return语句，会覆盖返回路径，改变值。//正常情况下不会有

这种情况，记住即可，不用深入研究，
                                                                                                       

                                  //如果在finally写返回语句,那么try和catch的结果都会被改变,所以这么写

就是犯罪
自定义异常：
        通过名字区分到底是神马异常,有针对的解决办法  举例：人的年龄
                //系统中的异常也是取个名字而已，没有方法，都是父类来做的
        自定义异常概述
                        * 继承自Exception
                        * 继承自RuntimeException
        写法：
                写一个Exception继承Exception，RuntimeException 。实现父类构造。使用的时候直接new就可

以了。


IO流：
        "对一个路径进行判断或者操作，这个路径可以是文件也可以是文件夹。"
File更应该叫做一个路径
                * 文件路径或者文件夹路径  
                * 路径分为绝对路径和相对路径
                * 绝对路径是一个固定的路径,从盘符开始
                * 相对路径相对于某个位置,在eclipse下是指当前项目下,在dos下

谢谢楼主  收藏了

谢谢楼主分享，辛苦辛苦啦

小沈同学 发表于 2015-7-20 23:11
26、==和equals()的区别?
                ==:
                        比较基本类型：比较的是基本类型的 ...

给力哈  6666666666

好棒,支持

不错 ,赞一个

mark一下，社招过的都是大神