Java面试准备2

好像是以选择题的形式, 所以暂时准备选择题.

刷了一下感觉没什么意思, 还是搞算法吧.

京东2019春招京东Java开发类试卷

在对问题的解空间树进行搜索的方法中，一个结点有多次机会成为活结点的是: 回溯法
京东商城plus会员的消费记录金额分别为900，512，613，700，810，若采用选择排序算法对其进行从小到大的排序，第三趟排序结果为：512，613，700，900，810

(关于选择排序: 给定一个数组arr,其长度为n; 第一次从 arr[0] 到 arr[n-1] 中选取一个最值（按照需求，可以是最大值，可以是最小值，下同）与arr[0]进行交换; 第二次从arr[1] 到 arr[n-1] 中选取一个最值与arr[1]进行交换；以此类推，直到arr[n-2]到arr[n-1]中选出最值交换后即完成排序。)
线性链表中的各元素在存储空间中的位置不一定是连续的，且各元素的存储顺序也是任意的
关于TCP协议的描述，错误的是可提供多播服务, 广播和多播仅应用于UDP；TCP是一个面向连接的协议.
在 bash shell 环境下，当一命令正在执行时，按下 control-Z 会将前台任务转入后台
对象间存在一对多关系，当一个对象被修改时，则会自动通知它的依赖对象，采用观察者模式设计模式最好 (观察者模式：对象间存在一对多关系，如果一个对象被修改时，会自动通知它的依赖对象。)
关于redis说法错误的是分区可以让Redis管理更大的内存. Redis Cluster在设计中没有使用一致性哈希(Consistency Hashing),而是使用数据分片引入哈希槽(hash slot)来实现
元数据区区域不属于新生代. Java 中的堆是 JVM 所管理的最大的一块内存空间，主要用于存放各种类的实例对象。在 Java 中，堆被划分成两个不同的区域：新生代 ( Young )、老年代 ( Old )。新生代 ( Young ) 又被划分为三个区域：Eden、From Survivor、To Survivor。这样划分的目的是为了使 JVM 能够更好的管理堆内存中的对象，包括内存的分配以及回收。

程序:

1int a =100,b=50,c=a---b,d=a---b;
2        System.out.println(a);
3        System.out.println(b);
4        System.out.println(c);
5        System.out.println(d);

输出98 50 50 49, 这样看: a– -b, a– -b.

JVM内存不包含Heap Frame. 包含Heap, Stacks, PC寄存器
java有8种基本类型，请问byte、int、long、char、float、double、boolean各占1 4 8 2 4 8 1字节.
程序:
```
1Integer a = 1;
2Integer b = 1;
3Integer c = 500;
4Integer d = 500;
5System.out.print(a == b);
6System.out.print(c == d);
```
返回true、false. Integer类型在-128–>127范围之间是被缓存了的，也就是每个对象的内存地址是相同的，赋值就直接从缓存中取，不会有新的对象产生，而大于这个范围，将会重新创建一个Integer对象，也就是new一个对象出来，当然地址就不同了，也就！=；
java8中，HashMap类用到了解决哈希冲突的开放定址法
当我们需要所有线程都执行到某一处，才进行后面的的代码执行我们可以使用CyclicBarrier. CountDownLatch 是等待一组线程执行完，才执行后面的代码。此时这组线程已经执行完。 CyclicBarrier 是等待一组线程至某个状态后再同时全部继续执行线程。此时这组线程还未执行完。
volatile能保证数据的可见性，但不能完全保证数据的原子性，synchronized即保证了数据的可见性也保证了原子性. volatile关键字是线程同步的轻量级实现，所以volatile性能肯定比synchronized关键字要好。但是volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块。实际开发中使用 synchronized 关键字的场景还是更多一些。

多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能会发生阻塞

volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证。

volatile关键字主要用于解决变量在多个线程之间的可见性，而 synchronized关键字解决的是多个线程之间访问资源的同步性。
在方法中，修改一个基础类型的参数不会影响原始参数值; 在方法中，改变一个对象参数的引用不会影响到原始引用(Java中方法的参数传递都是值传递); 在方法中，修改一个对象的属性会影响原始对象参数; 在方法中，修改集合和Maps的元素会影响原始集合参数.
spring默认使用jdk动态代理，那么下面配置<aop:aspectj-autoproxy proxy-target-class=“true”/>是开启强制使用cglib代理
算法的基本要素有对数据对象的运算和操作和算法的控制结构.
执行以下shell语句，可以生成/test文件的是（假定执行前没有/test文件）：touch /test, a=\touch /test, >/test
不合法的shell头是(不合法指运行会报错)：!#/bin/bas (如果不是#!开头的话默认都是认为是注释的)
可以用来获取shell脚本参数的是$1, $*
Redis支持的数据类型是 String hash list set sortedset

数据结构

数组

长度为n 的非空顺序表，若在第i个位置插入新的元素X，则i的取值范围是 1≤i≤n+1，需要移动的元素个数为n-i+1
数组A[8][10] 中（下标均从0开始），每个元素的长度为3个字节，按列存储时，元素A[4][7]的起始地址为（SA为数组存储时的首地址）SA+180
稀疏矩阵压缩的存储方法是三元组, 十字链表.

字符串

执行以下代码段(程序已包含所有必需的头文件)会输出4, 3
```
1  char a[] = "abc";
2  char b[] = {'a', 'b', 'c'};
3  printf("%d, %d", sizeof(a), sizeof(b));
```
不同的是数组a的长度是4个字符，而数组b的长度为3个字符，因为字符串后面会有一个'\0’作为结束符
有如下一段代码，The phrase of PRAISE has 42 letters and occupies 43 memory cells.是该段代码的正确输出。
```
1int  main(){
2  printf("The phrase of PRAISE has %zd letters ",strlen(PRAISE));
3  printf("and occupies %zd memory cells.",sizeof(PRAISE));
4  return 0;
5}
```
使用strlen可得到字符串中包括空格和标点符号在内的字符数。

使用sizeof运算符，得到的数会更大，因为它会把字符串末尾不可见的空字符也计算在内
设栈的初始状态为空，当字符序列 “a3_” 作为栈的输入时，输出长度为 3 的且可以用作 C 语言标识符的字符串序列有3个。(C语言的标识符不能以数字开头，去除3a_和3_a 答案为3)
已知串 S= “babab “, 其 Next 数值序列为01123.

Next数值序列需要计算字符串前缀和后缀最长匹配相同的长度加一而得。

第1位一定是0

看S第一位“b” ，没有前缀和后缀所以一般第2位一定是1（0+1）；

看S.substring（0,2）“ba” 前缀b后缀a，相等长度为0，第3位是1（0+1）；

看S.substring（0,3）“bab” 前缀b=后缀b，相等长度为1，第4位是2（1+1）；

看S.substring（0,4）“baba” 前缀ba=后缀ba，相等长度为2，第5位是3（2+1）；

则S的Next数值序列为 01123
Java中，String类型的数据存放有两种情况；

如果是String s=“nowcoder”,则是放在字符串常量池中。

如果是String ss=new String(“nowcoder”)，则是放在堆中。
由 4 个 “1” 和 4 个 “0” 组成的 8 位二进制补码，能表示的最小整数是：-121. 最大和最小分别是01111000 10000111,那么10000111的原码是11111001为-121
已知一段文本有1382个字符，使用了1382个字节进行存储，这段文本全部是由a、b、c、d、e这5个字符组成，a出现了354次，b出现了483次，c出现了227次，d出现了96次，e出现了232次，对这5个字符使用哈夫曼（Huffman）算法进行编码，则

A正确，Huffman树就是求最优解。可以有多套方案，但最终每套方案生成的编码长度都相同且都是最优解。

B错误，我们可以将左子树定为1右子树定为0也可以反之，不同的方案获得的编码值是不同的，但每个字符的编码长度是固定的。

C正确，不同的方案影响的只是通向节点的路径为0还是1，而不会影响Huffman树的层次结构

D正确，生成了Huffman树之后，我们就能看到，出现频率越高的节点越靠近根，深度越小即编码值尾数越短；出现频率越低的节点越远离根，深度越大即编码位数越长。
字符串是一种对象, 是一种数据类型, 是一种引用数据类型.

链表

关于线性表的说法不正确的是线性表中的每个结点都有且只有一个直接前趋和直接后继。

线性表中的数据元素可以是数字、字符、记录等不同类型。(Object类)

线性表中包含的数据元素个数不是任意的。(顺序表提前分配好空间)

存在这样的线性表：表中各结点都没有直接前趋和直接后继。(空表, 单元素表)

是正确的.
某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素,则采用仅有尾指针的单循环链表存储方式最节省运算时间。

栈

链栈与顺序栈相比，其特点之一是通常不会出现栈满的情况。采用链栈不必预先估计栈的最大容量，只要系统有可用空间，就不会溢出。
new 创建对象时，对象的内存和指向对象的指针分别分配在堆区，栈区
堆：自己做菜自己吃，什么时候收盘子自己知道，但是可能会浪费（产生碎片），因为可能自己一个人吃不完。桟：公司食堂，你吃饭由食堂工作人员帮你打饭和分配位置，吃完了工作人员帮你收盘子。你浪费粮食（碎片）那是不可能的，因为食堂会把碎片拿去喂猪。
局部变量是分配在栈上的，new出来的对象是分配在堆上的
用俩个栈模拟实现一个队列，如果栈的容量分别是O和P(O>P)，那么模拟实现的队列最大容量是2P+1

队列

用链接方式存储的队列，在进行删除运算时头、尾指针可能都要修改.

1> 当有多于一个节点时，链表表示的队列的删除操作只需要修改头指针即可，将头指针定义为head=head.next 此时不需要修改尾指针；

2> 当队列只有一个节点时，该节点既是头又是尾，如果head==tail 则需要修改尾指针将队列置空。
已知循环队列存储在一维数组A[0..n-1]中，且队列非空时 front 和 rear 分别指向队头和队尾元素。若初始时队列为空，且要求第 1 个进入队列的元素存储在 A[0]处，则初始时 front和 rear 的值分别是0， n-1.

当进元素时，rear将后移，以便指向新的队尾元素。出队时，front后移，更新指向新的队头。

反推，front不用动，但是rear要退一个位置，往哪退？按照循环，第一个元素位置可以直接到最后一个位置上，因此，如图所示。所以在数组中初态就是0，n-1.
某带链的队列初始状态为 front=rear=NULL 。经过一系列正常的入队与退队操作后， front=rear=10 。该队列中的元素个数为1.

初始时 front=rear=0 , 插入第 1 个元素时， rear+1 指向该元素， front+1 也指向该元素，插入第 2 个元素时 rear+1 ， front 不变，删除 1 个元素时 front+1 。即 front=rear 不为空时带链的队列中只有一个元素。

基础算法

复杂度

设某堆中有 n 个结点，则在该堆中插入一个新结点的时间复杂度为 O(log2n)
归并排序法的最好时间复杂度和此情况下的空间复杂度分别是O(nlogn) 和O(n)
一个算法所需时间由下述递归方程表示：T(n)=2T(n/2)+n, 该算法的时间复杂度是O(n*log(n))
给定一个递归算法的时间复杂度表达式，为T(n)=4T(n/2)+3n^2+2n , 则该算法的时间复杂度为O(n^2 * logn)

(master公式: T(N)=a*T(N/b) + O(N^d), 则当logba < d时, O(N^d)); 当logba>d, O(N^logba); 当logba=d, O(N^d * logN) ) logba是以b为底a的对数.

排序

归并排序平均时间复杂度为O(nlogn)

选择排序平均时间复杂度为O(n^2)

希尔排序平均时间复杂度为O(n^1.5)

堆排序平均时间复杂度为O(nlogn)

冒泡排序平均时间复杂度O(n^2)
插入排序是一种最简单的排序方法，它的基本操作是将一个记录插入到已排好序的有序表中，从而得到一个新的、记录数增1的有序表。

冒泡排序每轮排序从前往后扫，如果当前位置的数比其后面相邻的数大，则交换两个位置的数。

希尔排序为插入排序的改进，先将序列分成若干个子序列进行直接插入排序，待整个序列中的记录“基本有序”是，再对全体记录进行依次直接插入排序。

快速排序从未排序序列中选择一个元素，该元素将当前参加排序的那些元素分成前后两个部分，前一部分中所有元素都小于等于所选元素，后一部分中所有元素都大于等于所选元素，而所选元素处在排序的最终位置。
采用递归方式对顺序表进行快速排序, 递归次数与每次划分后得到的分区处理顺序无关
基本有序的情况下：快排最慢，堆排最快。

直接插入排序是数据越有序越快，最快时间复杂度可达到O(n) .

选择排序无论何时都是O（n^2）

归并排序固定O(n*log n)，有序只是减少了元素交换次数。

快速排序越有序越慢，它要从后到前遍历找比基准小的，时间复杂度达到O(n)
精俭排序，即一对数字不进行两次和两次以上的比较，是“精俭排序”的是插入排序, 归并排序

查找

哈希

设哈希表长m=13,哈希函数H(key)=key MOD 11。表中已有4个节点:addr(16)=5,addr(28)=6,addr(84)=7,addr(19)=8，其余地址为空,如用线性探测再散列处理冲突，则关键字为38的地址为9
假设把整数关键码K散列到有N个槽的散列表，h(k)=k mod N是好的散列函数, 而h(k)=(k + Random(N )) mod N；Random(N)返回一个0到N-1的整数不是. 使用随机函数可以使得数更均匀随机地分布在各个槽中，但当查找时由于散列函数是个随机函数所以得到的值对应的槽内可能压根没有放关键码k，可能会使得查找失败。
一个线性序列（30，14，40，63，22，5），假定采用散列函数Hash(key)=key%7来计算散列地址，将其散列存储在A[0~6]中，采用链地址法解决冲突。若查找每个元素的概率相同，则查找成功的平均查找长度是4/3.
线程安全的map在JDK 1.5及其更高版本环境有哪几种方法可以实现:

Map map = new ConcurrentHashMap();

Map map = Collections.synchronizedMap(new HashMap());

1.HashMap,TreeMap 未进行同步考虑，是线程不安全的。

2.HashTable 和 ConcurrentHashMap 都是线程安全的。区别在于他们对加锁的范围不同，HashTable 对整张Hash表进行加锁，而ConcurrentHashMap将Hash表分为16桶(segment)，每次只对需要的桶进行加锁。

3.Collections 类提供了synchronizedXxx()方法，可以将指定的集合包装成线程同步的集合。比如， List list = Collections.synchronizedList(new ArrayList()); Set set = Collections.synchronizedSet(new HashSet());

递归

求解第n个斐波那契数的递归写法，分析它的时间复杂度是O(2^N)

1int func(unsigned int n)
2{
3  if(n<2)
4    return n;
5  return fabonaci(n-1) + fabonaci(n-2);
6}

计算机基础

设计模式

如果需要在不影响其他对象的情况下，以动态，透明的方式给对象添加职责，应该选择装饰模式.
假设一个电源总开关可以控制四盏灯、一个风扇、一台空调和一台电视机的启动和关闭。通过该电源总开关可以同时控制上述所有电器设备，可以使用外观模式来模拟设计该系统。
不同级别的用户对同一对象拥有不同的访问权利或某个客户端不能直接操作到某个对象，但又必须和那个对象有所互动，这种情况最好使用Proxy模式设计模式。
KFC套餐一般包含主食（如汉堡、鸡肉卷等）和饮料（如果汁、可乐等）等组成部分，不同的套餐有不同的组成部分，而KFC的服务员可以根据顾客的要求，一步一步装配这些组成部分，构造一份完整的套餐，然后返回给顾客。可以使用建造者模式描述KFC如何创建套餐。
创建型模式关注的是对象创建
共享网络设备模拟：很多网络设备都是支持共享的，如交换机、集线器等，多台终端计算机可以连接同一台网络设备，并通过该网络设备进行数据转发。共享网络设备可以使用享元模式模拟共享网络设备的设计原理。
策略模式和模板模式的联系与区别策略模式和模板模式在某些应用场景下可以互换。模板模式使用的是继承关系实现，策略模式使用的是组合关系实现。模板模式倾向于把解决问题过程定义为一个完整框架，把过程中的若干实现步骤延迟到子类中实现。
用户已经有一个两相插座，最的又买了一个三相插座。现在用户想使用新的三相插座来使用三相的洗衣机和二相插座的电视机，这种问题可以使用适配器模式模式来进行设计。
在模拟毛笔的使用过程中提供了大中小3种型号的画笔，够绘制5种不同颜色。我们可以使用桥接来模拟实现模拟毛笔的使用。
关于简单工厂模式与工厂方法模式

1、简单工厂模式中包含判断什么对象的逻辑，而工厂方法模式则需要调用者判断要实例化什么具体类型的工厂进而创建出想要的对象。当增加新类时，简单工厂模式需要修改工厂类，而工厂方法模式不需要，因此工厂方法模式遵守了开闭原则，而简单工厂模式没遵守。

2、简单工厂模式因为采用了静态方法，所以不利于继承，而工厂方法模式恰恰相反，需要利用到继承来从抽象工厂中派生出各种各样的具体工厂。

3、工厂模式就是为了消除if else
工厂模式可理解为：当客户获取产品时，工厂模式作为获取产品的接口。

1、简单工厂模式：由接口直接负责获取产品

2、工厂方法模式：客户必须清楚地指出想获取哪种产品；由接口的子类负责获取产品

3、抽象工厂模式：客户不知道其想获取哪种产品；由接口中判断调用哪个子类，通过子类获取产品。

网络基础

www.tsinghua.edu.cn

cn：顶级域名

edu：二级域名

tsinghua：三级域名

www：主机名（万维网主机）

DNS（端口53）同时占用UDP和TCP是公认的，DNS在进行区域传输或者响应报文超过512字节的时候使用TCP协议，其它时候则使用UDP协议。
IP数据报分片在信源机或者路由器，重组在目的机
一台交换机具有 24 个 10/100Mbps 全双工端口和 2 个 1000Mbps 全双工端口，如果所有的端口都工作在全双工状态，那么交换机总带宽等于8.8Gbps。

数据库

设有两个数据库表，父表和子表之间是一对多的联系，为控制子表和父表的关联，可以设置"参照完整性规则”，为此要求这两个表在父表连接字段上建立主索引，在子表连接字段上建立普通索引.
Mysql中表student_table(id,name,birth,sex)，插入如下记录：

(‘1004’ , ‘张三’ ,‘2000-08-06’ , ‘男’); (‘1009’ , ‘李四’, ‘2000-01-01’, ‘男’); (‘1010’ , ‘李四’, ‘2001-01-01’, ‘男’); (‘1006’ , ‘王五’, ‘2000-08-06’ , ‘女’); (‘1008’ , ‘张三’, ‘2002-12-01’, ‘女’); (‘1012’ , ‘张三’, ‘2001-12-01’, ‘女’); (‘1011’ , ‘李四’, ‘2002-08-06’ , ‘女’);

执行

select t1.,t2. from ( select * from student_table where sex = ‘男’ ) t1 right join (select * from student_table where sex = ‘女’)t2 on t1.name = t2.name ; 的结果行数是5

1）不论左右连接，两表排序都是先写的放在左边，后写的放在右边 2）左右连接中，以谁为主表，则其信息全部保存。从表中有多于一项符合条件的，则额外重复一次主表从而列出全部从表情况
ACCESS中表和数据库的关系是一个数据库可以包含多个表
3NF消除主属性对码的部分和传递函数依赖规范化为BCNF。
数据库三级模式体系结构的划分，有利于保持数据库的数据独立性
在高并发的线上事务中，几乎无法避免锁等待或死锁的产生
有关系 R 和 S ， R －（ R － S ）的运算等价于R∩S
左连接时，结果集的行数可能大于左表的行数
概念数据模型是现实世界到信息世界的第一层抽象。数据结构模型是对现实世界进行的第二层抽象。

操作系统

相比于单道程序设计（内存中仅有一道作业），多道程序设计按照一定的作业调度算法将作业队列中的作业调入内存，使他们共享CPU和各种资源。因此需要更大的内存以容纳超过一道的作业。
不管系统中是否有线程，进程都是拥有资源的独立单位. 用户级线程切换不涉及内核，在进程的时间片内，由用户程序控制线程的切换，然后使用进程获取的资源. 对于普通的操作系统，未引入线程的话，进程是系统进行资源分 配和调度的独立单位。在多处理机操作系统中，引入线程后，进程是资源的分配单 位或者叫做资源的容器，线程是处理机的调度单位。
renice命令可以改变进程的优先级
使用一个信号量协调6个进程对4个同类临界资源的访问, 信号量值可以出现-2 到 4
连续分配方式可能产生外部碎片，可以考虑采用“紧凑”的方法将内存中所有作业进行移动，从而使得外部碎片集中在一起形成一个大的分区。为了使移动后的作业能正常运行，需要进行动态重定位.
为了实现设备独立性，在操作系统中，用户在使用I/O设备时，通常采用逻辑设备名
软链接也叫符号链接, 如果原始文件被删除，所有指向它的软链接也都被破坏, 软链接指明了原始文件的位置，用户需要对原始文件的位置有访问权限才可以使用, 软链接可以跨文件系统，可以指向远程文件系统的文件
页表的作用是实现从页号到物理块号的地址映射
32位处理器是指处理器的数据总线是32位的
静态重定位的时机是程序装入时
在段式存储管理中，一个段是一个不定长的连续区域。

Java

抽象类必须有“abstract class”修饰, 抽象类是可以实现接口的，而且抽象类也可以继承自抽象类 , 抽象类指有abstract修饰的class，其可以包含抽象方法，也可以不包含 , 抽象类和接口都是不能被实例化的，只有具体的类才可以被实例化

下面程序的运行结果是pongping

 1public static void main(String args[]) {
 2    
 3    Thread t = new Thread() {
 4           public void run() {
 5                pong();
 6           }
 7     };
 8    
 9    t.run();
10    System.out.print("ping");
11}
12    
13   static void pong() {
14     System.out.print("pong");
15    }
16    
17

t.run是调用的Thead类中的run()方法，t.start才是执行线程，所以这题就是执行普通run()方法，先输出pong，在输出ping。 t.start是另起线程，与当前线程同时竞争cpu资源，结果存在不确定性

Log4j的日志打印级别不可以在运行时重新设置
方法重载：同一类中的相同的方法名，参数和返回值均可不同。方法重写：之类对父类已经实现的方法重新定义。
int a = ‘2’,这种定义与int a = 2是完全不同的

int a = ‘2’中的数字2使用单引号来表示字符2，字符2对用的ascii码值是50，因此这种情况下，a的值是50

int a = 2中的数字2表示了数字本身，这种情况下，a的值是2
创建并启动线程的过程为：定义线程->实例化线程->启动线程。

定义线程有两种方式，一种是继承java.lang.Thread类，一种是实现java.lang.Runnable接口。这两种方式实例化线程区别在于，如果是继承了Thread类，直接new一个对象就可以了，如果是实现了Runnable接口的类，则需要用Thread的构造方法new Thread(new MyRunnable()).start()
CMS垃圾回收器在初始标记, 重新标记阶段是没用用户线程参与的
事务隔离级别是由数据库系统实现的
new URL()时必须捕获检查异常，但这个异常是由于字符串格式和URL不符导致的，与网址是否存在无关。URL的toString方法返回字符串，无论网址是否存在。
抽象类中可以有普通成员变量，接口中没有普通成员变量。抽象类和接口中都可以包含静态成员常量。一个类可以实现多个接口，但只能继承一个抽象类. 抽象类中可以包含非抽象的普通方法，接口中的方法必须是抽象的，不能有非抽象的普通方法。
java中创建对象有以下几种方法：

1.用new语句创建对象，这是最常用的创建对象的方式。

    2.运用反射手段，调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。  

   3.调用对象的clone()方法。  

   4.运用反序列化手段，调用java.io.ObjectInputStream对象的readObject()方法.

下面的输出结果是false

 1public class Demo {
 2  public static void main(String args[])
 3  {
 4    String str=new String("hello");
 5    if(str=="hello")
 6    {
 7      System.out.println("true");
 8    }      
 9    else     {
10      System.out.println("false");
11    }
12  }
13}

==判断的是对象引用地址是否相同， String str=new String(“hello”); 这句话new了一个新的String对象，所以地址与"hello"字符串常量的地址不同，答案为false 如果判断字符串是否相等应给用str.equals(“hello”)方法

ArrayList list = new ArrayList(20);中的list扩充0次. Arraylist默认数组大小是10，扩容后的大小是扩容前的1.5倍，最大值小于Integer 的最大值减8，如果新创建的集合有带初始值，默认就是传入的大小，也就不会扩容

以下代码结果是代码可以编译运行，输出“AB.B”。

 1public class foo {
 2    public static void main(String sgf[]) {
 3     
 4        StringBuffer a=new StringBuffer("A");
 5     
 6        StringBuffer b=new StringBuffer("B");
 7     
 8        operate(a,b);
 9     
10        System.out.println(a+"."+b);
11    }
12    static void operate(StringBuffer x,StringBuffer y) {
13        x.append(y);
14        y=x;
15    }
16}

a,b,x,y就是四个指针. “=”, y就指向了x所指向的目标即是a指向的对象，因此原来b所指向的目标并没有发生任何改变。

下列程序运行的结果good and gbc
```
 1public class Example{
 2    String str = new String("good");
 3    char[ ] ch = { 'a' , 'b' , 'c' };
 4    public static void main(String args[]){
 5        Example ex = new Example();
 6        ex.change(ex.str,ex.ch);
 7        System.out.print(ex.str + " and ");
 8        System.out.print(ex.ch);
 9    }
10    public void change(String str,char ch[ ]){
11        str = "test ok";
12        ch[0] = 'g';
13    }
14}
```
首先说下String确实是个不可变对象，这个不可变是JDK特有的，写JAVA的人特意针对的

但是这与本题无关，题目中的形参str只是原引用ex.str的一个引用副本，传的是一个副本地址值，这个值与ex.str地址值是不一样的,但是它们同时指向了堆中的对象new String(“good”)，当你在函数中改变形参也就是地址的副本值也就是这句str=“test ok"只是将副本地址指向常量"test ok”，并没有改变原ex.str的指向方向，它还是指向对象new String(“good”)的

char数组与String一样传的也是地址的副本，但是关键是形参ch它没有新的指向 ch[0]只是ch在指向原对象时改变了对象的内部结构, 所以在ex.ch指向与它是同一个对象的情况下当然也会随之变化
静态方法中没有this关键词，因为静态方法是和类同时被加载的，而this是随着对象的创建存在的，静态比对象优先存在. 静态可以访问静态，但静态不能访问非静态而非静态可以访问静态。

在静态方法中可直接调用本类的静态方法，也可以通过类名.静态方法名的方式来调用其他类的静态方法

静态方法不能直接调用实例方法和对象，但可以通过在静态方法中创建类的实例的方式间接调用。
HashMap是非线程安全的，其对应的线程安全类是HashTable

Vector(相当于一个线程安全的List), StringBuffer(相当于一个线程安全的StringBuilder), Properties是线程安全的
interface中的方法默认为public abstract 的，变量默认为public static final

接口中不允许有static类型的方法

JDK8及以后，允许我们在接口中定义static方法和default方法。

在jdk8之前，interface之中可以定义变量和方法，变量必须是public、static、final的，方法必须是public、abstract的。这些修饰符都是默认的