Java人生

ClassLoader详解

jame — Sat, 22 Oct 2011 07:20:14 +0000

　　顾名思义，类加载器（class loader）用来加载 Java 类到 Java 虚拟机中。基本上所有的类加载器都是 java.lang.ClassLoader 类的一个实例。java.lang.ClassLoader 类的基本职责就是根据一个指定的类的名称，找到或者生成其对应的字节代码，然后从这些字节代码中定义出一个 Java 类，即 java.lang.Class 类的一个实例。除此之外，ClassLoader 还负责加载 Java 应用所需的资源，如图像文件和配置文件等。不过本文只讨论其加载类的功能。为了完成加载类的这个职责，ClassLoader 提供了一系列的方法.

类加载器的树状组织结构
　　Java 中的类加载器大致可以分成两类，一类是系统提供的，另外一类则是由 Java 应用开发人员编写的。系统提供的类加载器主要有下面三个：
　　引导类加载器（bootstrap class loader）：它用来加载 Java 的核心库，是用原生代码来实现的，并不继承自 java.lang.ClassLoader。
　　扩展类加载器（extensions class loader）：它用来加载 Java 的扩展库。Java 虚拟机的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java 类。
　　系统类加载器（system class loader）：它根据 Java 应用的类路径（CLASSPATH）来加载 Java 类。一般来说，Java 应用的类都是由它来完成加载的。可以通过 ClassLoader.getSystemClassLoader() 来获取它。
　　除了系统提供的类加载器以外，开发人员可以通过继承 java.lang.ClassLoader 类的方式实现自己的类加载器，以满足一些特殊的需求。
　　除了引导类加载器之外，所有的类加载器都有一个父类加载器。通过ClassLoader类的 getParent() 方法可以得到。对于系统提供的类加载器来说，系统类加载器的父类加载器是扩展类加载器，而扩展类加载器的父类加载器是引导类加载器；对于开发人员编写的类加载器来说，其父类加载器是加载此类加载器 Java 类的类加载器。因为类加载器 Java 类如同其它的 Java 类一样，也是要由类加载器来加载的。一般来说，开发人员编写的类加载器的父类加载器是系统类加载器。类加载器通过这种方式组织起来，形成树状结构。树的根节点就是引导类加载器

1
2
3
4
5
6
7
8
9
10
11
12
13

public class ClassLoaderTree
{
public static void main(String[] args){
ClassLoader loader = ClassLoaderTree.class.getClassLoader();
while(loader!=null){
System.out.println(loader.toString());
loader = loader.getParent();
}
}
}
输出：
sun.misc.Launcher$AppClassLoader@addbf1
sun.misc.Launcher$ExtClassLoader@42e816

体系结构：
Bootstrap ClassLoader/启动类加载器
主要负责jdk_home/lib目录下的核心 api 或 -Xbootclasspath 选项指定的jar包装入工作。
Extension ClassLoader/扩展类加载器
主要负责jdk_home/lib/ext目录下的jar包或 -Djava.ext.dirs 指定目录下的jar包装入工作。
System ClassLoader/系统类加载器
主要负责java -classpath/-Djava.class.path所指的目录下的类与jar包装入工作。
User Custom ClassLoader/用户自定义类加载器(java.lang.ClassLoader的子类)
在程序运行期间, 通过java.lang.ClassLoader的子类动态加载class文件, 体现java动态实时类装入特性。

ClassLoader 类加载逻辑分析，以下逻辑是除 BootstrapClassLoader 外的类加载器加载流程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// 检查类是否已被装载过
Class c = findLoadedClass(name);
if (c == null ) {
// 指定类未被装载过
try {
if (parent != null ) {
// 如果父类加载器不为空，则委派给父类加载
c = parent.loadClass(name, false );
} else {
// 如果父类加载器为空，则委派给启动类加载加载
c = findBootstrapClass0(name);
}
} catch (ClassNotFoundException e) {
// 启动类加载器或父类加载器抛出异常后，当前类加载器将其
// 捕获，并通过findClass方法，由自身加载
c = findClass(name);
}
}

Java参数传递的两种方式

jame — Sun, 16 Oct 2011 02:30:34 +0000

首先，Java中传递参数的有传值和传引用两种方式。
对于原始数据类型(原生类)，也就是int、long、char等类型，参数传递是传值的。开发者在方法中修改了参数值，方法调用结束后，那个变量的值并没有发生改变。也就是说，在参数传递的过程中，该变量的值在方法调用期间会复制给形参。因为形参是方法的局部变量，所以对形参做出的任何修改在调用结束都不会影响该变量的值。

如果传递的是指向对象的引用，那么就会传递引用值。这意味着，在方法调用期间，实参和形参都是该引用值所代表对象的别名，对形参的修改就会导致实参的修改，而数组就是作为对象引用值来传递的

1
2
3
4
5
6
7
8

class test{
public static void main(String[] args){
int[]x[] = {{1,2},{3,4,5},{6,7,8,9}};
int[][]y = x;
y[2][1] = 6;
System.out.print(x[2][1]);
}
}

因此，上面的例子就是输出6，而不是7
另外，再看一道SCJP的题：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Given:
class Batman{
int squares = 81;
public static void main(String[] args){
new Batman().go();
}
void go(){
incr(++squares);
System.out.println(squares);
}
void incr(int squares){squares += 10;}
}
What is the result?
A. 81
B. 82
C. 91
D. 92
E. Compilation fails.
F. An exception is thrown at runtime.

输出的是82，而不是92，因为int类型是传值

属性覆盖问题

jame — Sun, 16 Oct 2011 02:24:52 +0000

在Java中，对于方法覆盖，那是很常见的，但对于属性覆盖呢？其实也是很常见的，只是我们没有加以注意而已，本文就过去对属性覆盖的各种问题的验证结果写到这里，希望能给有需要的朋友一点帮助。首先我们来看一道SCJP考试的题目：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Foo {
public int a = 3;
public void addFive() { a += 5; System.out.print("f "); }
}
class Bar extends Foo {
public int a = 8;
public void addFive() { this.a += 5; System.out.print("b " ); }
}

Invoked with:
Foo f = new Bar();
f.addFive();
System.out.println(f.a);
What is the result?
A. b 3
B. b 8
C. b 13
D. f 3
E. f 8
F. f13
G. Compilation fails.
H. An exception is thrown at runtime.
Answer: A

对于属性的覆盖，有如下结论：
1. 由于private变量受访问权限的限制，它不能被覆盖。
2. 属性的值取父类还是子类并不取决于我们创建对象的类型，而是取决于我们定义的变量的类型。
3. friendly、protected和public修饰符并不影响属性的覆盖。
4. 静态变量和静态常量属于类，不属于对象，因此它们不能被覆盖。
5. 常量可以被覆盖。

对于第2条，也就是说Foo f = new Bar();
取决于Foo类型，而不是Bar类型

因此，本题中由于是Foo f = new Bar();编译时看父类，执行看子类，将会执行子类addFive()方法，而在方法体中属性a带有this，也就是说它自身的属性，然后输出b，然后再执行f.a，由于f是Foo类的对象，因此它将调用的是Foo类的属性a，正是上面的第2条

广州从兴电子开发2012校园招聘笔试题

jame — Sun, 16 Oct 2011 02:14:03 +0000

昨天去了文汇面试，发现是五个人一起的，还是第一次被群面。主要就是让我们提出一个SSO(单点登录系统)的解决方案，要求保证安全性，实用性等。题目不难，关键是看解决问题时的过程，及各自的看法，因为面我们的两位美女都是HR(不懂技术的)，结束时还让我们自己投票。意外的是，晚上十点多的时候电话打给我说今天下午去复试，真是太兴奋了，不管结果怎样，我都要去努力去拼一拼，加油~~~

说了那么多，还是回到本文的重点吧，其实该题是10.13考的，今天才有时间写点东西，所以就放上来了，题目如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class Confusing
{
private Confusing(Object o){
System.out.println("Object");
}
private Confusing(double[] dArray){
System.out.println("double array");
}
public static void main(String[] args)
{
new Confusing(null);
}
}
A.Object B.double array C.null D.抛出空指针异常

这道题，笔试时居然做错了，主要还是不了解数组的本质。数组的本质就是对象，也就是可以这样赋值:double[] a = null;因此，在这道题中更匹配的数组的类型，程序将输出double array;若把null换成2，不再匹配数组类型，将输出Object。
另外，有个小疑问，既然它是最佳匹配的，而数组类型是可以赋值为null，所以才会去匹配它的，那String类型也是可以赋值为null，那在原代码的基础上再加上如下代码会得到什么样的结果呢？

1
2
3

private Confusing(String str){
System.out.println("string");
}

分析：由于加了个String对象后，它将有两个都能同时匹配，因此编译器不知道该匹配谁，于是就成了编译错误：
Confusing.java:15: 对 Confusing 的引用不明确，Confusing 中的方法 Confusing(double[]) 和 Confusing 中的方法 Confusing(java.lang.String) 都匹配new Confusing(null);

约瑟夫环

jame — Sat, 15 Oct 2011 09:02:47 +0000

问题描述：已知n个人（以编号1，2，3...n分别表示）围成一圈。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列，求最后一个出列人的编号。

1
2
3
4
5

int Josephus(int n,int m,int k){ //参数分别为：人数，出圈步长，起使报数位置,
for (int i = 1; i <= n; i++)
k = (k + m - 1) % i + 1;
return k; //返回最后一人的位置
}

某安全公司2012校招笔试题

jame — Fri, 14 Oct 2011 15:08:02 +0000

m个人坐成一圈，编号1~m，从1开始报数，报到n的倍数的离开，求最后剩下的那个人编号。语言不限。

两个大数相乘

jame — Tue, 11 Oct 2011 11:07:13 +0000

其实，两个大数相乘，难免会出现溢出的现象，若两个很大的int值相乘，肯定会超过2³¹-1。然而，要实现这个运算，你首先会想到的是BigDecimal和BigInteger类，通过这两个类的方法可以很方便的进行大数的运算，但是如何我们自己来实现呢？这里我将两数相乘的代码给出，其思想就是我们手工乘法的过程，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

import java.util.Arrays;
import java.util.Scanner;
public class BigMultiTest {

public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
String numStr1 = reader.next();
String numStr2 = reader.next();

int[] intNum1 = changetoArray(numStr1);
int[] intNum2 = changetoArray(numStr2);

multiply(intNum1, intNum2);
}

/**
* 将字符串转换成int类型数组，注意从字符串的尾端开始存入数组中
* @param numStr
* @return
*/
public static int[] changetoArray(String numStr) {
int length = numStr.length();
int[] intNum = new int[length];
for (int i = 0; i < length; i++)
intNum[length - i - 1] = Integer.parseInt(String.valueOf((numStr.charAt(i))));
System.out.println(Arrays.toString(intNum));
return intNum;
}

/**
* 两数相乘的核心算法
* @param num1
* @param num2
* @return
*/
public static int[] multiply(int[] num1,int[] num2){
int length1 = num1.length;
int length2 = num2.length;
int[] result = new int[length1 + length2];
for (int i = 0; i < length1; i++){
for (int j = 0; j <length2;j++) {
int temp = result[i + j] + num1[i] * num2[j];
result[i + j] = temp % 10; //将两数相乘与前面数的最高位相加的结果的个位存入数组
result[i + j + 1] += temp / 10; //下一位存入与之前结果的和的十位
//如果大于10，就进1
if (result[i + j + 1] > 10) {
result[i + j + 1] %= 10;
result[i + j + 2]++;
}
}
}
StringBuffer sb = new StringBuffer();
System.out.println(Arrays.toString(result));
for (int i = result.length - 1; i >= 0; i--)
sb.append(result[i]);
String tempStr = sb.toString();
//去掉字符串开始的0
int flag =0;
for (flag = 0; flag < result.length; flag++) {
if (tempStr.charAt(flag)!='0') {
break;
}
}
String resultStr = tempStr.substring(flag);
System.out.println(resultStr);

return result;
}
}

将String转换成int的实现

jame — Tue, 11 Oct 2011 10:47:45 +0000

看到标题，也许你会问，用Integer.parseInt(String str)方法不就可以搞定了？没错，但这是Java已经写好的方法了，这里我要说的是我们自己来实现这个过程，大致代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class StringToInt {
public static int changetonum(String str) {
int result = 0;
int len = str.length();
for (int i = 0; i < len; i++) {
result +=(str.charAt(i)-'0')*Math.pow(10, (len-i-1));
}

System.out.println(result);
return result;
}
public static void main(String[] args) {
changetonum("345");
}
}

当然，看完代码的你会说，这代码有很大问题。没错，我这里只写了转换的核心思想，就是将字符串的每个字母转换成char，然后利用ASCII码来进行转换，而没有考虑原数超出int的范围、输入含有非数字的字母的异常捕获等问题，有兴趣的朋友可以自己完善一下。

树的一些概念

jame — Sun, 02 Oct 2011 08:06:25 +0000

1.树结构

非终端节点:有子节点的节点
终端节点或叶子节点:没有子节点的节点
节点的度:一个节点的度是它拥有的子节点数;而一棵树的度是指树内各节点所拥有的度的最大值
层次:树中节点世代的关系，一代为一个层次，根的层为1
高度：树中某节点的高度表示此节点到叶子节点的最长路径长度
深度：某个节点的深度为根至此节点的路径长度

2.二叉树
二叉树：每个节点至多只有两颗子树（即二叉树中不存在度大于2的节点），并且二叉树中的子树有左右之分，其次序不能任意颠倒
性质：

i．在二叉树的第i层上至多有2^i-1个节点(i>=1)
ii．深度为k的二叉树至少有2^k-1个节点，至多有2^k-1个节点(k>=1)
iii．对任何一颗二叉树T，如果其终端节点数为n₀，度为2的节点数为n₂，则n₀=n₂+1

一棵深度为k，且有2^k-1个节点的二叉树称为满二叉树
对满二叉树进行编号，编号约定为从根节点开始，从上到下，从左到右。深度为k的，有n个节点的二叉树，当且仅当其每个节点都与深度为k的满二叉树中编号从1到n的节点一一对应，称之为完全二叉树

性质：具有n个节点的完全二叉树的深度为⌊log₂n⌋+1

3.哈夫曼树
假设有n个权值{w₁,w₂,w₃,...w_n},试构造一棵有n个叶子节点的二叉树，每个叶子节点带权为w_i，则其中带权路径长度WPL最小的二叉树为最优二叉树或者哈夫曼树

对于有n个叶子节点的哈夫曼树，总共有2n-1个节点。

4.二叉查找树
二叉查找树可以是空集合，假设不是，则树中每个节点均含有一个关键字(key value),且具有如下特性：
i. 在左子树的所有关键字均小于根的关键字
ii. 在右子树的所有关键字均大于根的关键字
iii. 左子树和右子树是二叉查找树

双向链表结构

jame — Sun, 02 Oct 2011 07:47:12 +0000

在双向链表的节点中有两个指针域，其一指向直接后继，另一指向直接前继。另外，双向链表也可以是循环的，最后节点的后继指针指向头节点，首先，双向链表的构造代码如下：

1
2
3
4
5
6
7
8

class Node{
int data;
Node llink;
Node rlink;
}
head = new Node();
head.rlink = head;
head.llink = head;

1.在头节点处插入节点,先把新增节点的左右指针赋值,然后在把该新增节点赋给旁边的节点

1
2
3
4
5
6
7

current = head.rlink;
Node node = new Node();
node.data = i;
node.rlink = current;
node.llink = head;
head.rlink = node;
current.llink = node;

2.在链表尾部插入节点,由于是双向循环链表,因此找到尾节点就相当容易:

1
2
3
4
5
6
7

current = head.llink;
Node node = new Node();
node.data = i;
node.llink = current;
node.rlink = head;
current.rlink = node;
head.llink = node;

3.在任意位置插入节点:

1
2
3
4
5
6
7
8
9
10
11

current = head.rlink;
while (current!=head && current.data != 4) {
pre = current;
current = current.rlink;
}
Node node = new Node();
node.data = 11;
node.rlink = current;
node.llink = pre;
pre.rlink = node;
current.llink = node;

4.在头部删除节点:

1
2
3
4

current = head.rlink;
current.rlink.llink = head;
head.rlink = current.rlink;
current = null;

5.在尾部删除节点:

1
2
3
4

current = head.llink;
current.llink.rlink = head;
head.llink = current.llink;
current = null;

6.在任意位置删除节点:

1
2
3
4
5
6
7
8

current = head.rlink;
while (current!=head && current.data != 11) {
pre = current;
current = current.rlink;
}
current.rlink.llink = pre;
pre.rlink = current.rlink;
current = null;

完整代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

public class DoubleLinkedList {
class Node{
int data;
Node llink;
Node rlink;
}
static Node head;
static Node current;
static Node pre;
public DoubleLinkedList() {
head = new Node();
head.rlink = head;
head.llink = head;
}
//添加节点到头部
public void addFront(int i) {
current = head.rlink;
Node node = new Node();
node.data = i;
node.rlink = current;
node.llink = head;
head.rlink = node;
current.llink = node;
}
//添加节点到尾部
public void addRear(int i) {
current = head.llink;
Node node = new Node();
node.data = i;
node.llink = current;
node.rlink = head;
current.rlink = node;
head.llink = node;
}
//添加节点到任一位置
public void add() {
current = head.rlink;
while (current!=head && current.data != 4) {
pre = current;
current = current.rlink;
}
Node node = new Node();
node.data = 11;
node.rlink = current;
node.llink = pre;
pre.rlink = node;
current.llink = node;
}

//在头部删除节点
public void removeFront() {
current = head.rlink;
current.rlink.llink = head;
head.rlink = current.rlink;
current = null;
}
//在尾部删除节点
public void removeRear() {
current = head.llink;
current.llink.rlink = head;
head.llink = current.llink;
current = null;
}
//在任意位置删除节点
public void remove() {
current = head.rlink;
while (current!=head && current.data != 11) {
pre = current;
current = current.rlink;
}
current.rlink.llink = pre;
pre.rlink = current.rlink;
current = null;
}
public static void main(String[] args) {
DoubleLinkedList dll = new DoubleLinkedList();
dll.addFront(1);
dll.addFront(2);
dll.addFront(3);
dll.addFront(4);
dll.addFront(5);
dll.addFront(6);
dll.addFront(7);
dll.addFront(8);
dll.addFront(9);
current = head.rlink;
while (current!=head) {
System.out.print(current.data+" ");
current = current.rlink;
}
System.out.println("\n=======================");

dll.addRear(10);
current = head.rlink;
while (current!=head) {
System.out.print(current.data+" ");
current = current.rlink;
}

System.out.println("\n=======================");
dll.add();
current = head.rlink;
while (current!=head) {
System.out.print(current.data+" ");
current = current.rlink;
}

System.out.println("\n=======================");
dll.removeFront();
current = head.rlink;
while (current!=head) {
System.out.print(current.data+" ");
current = current.rlink;
}

System.out.println("\n=======================");
dll.removeRear();
current = head.rlink;
while (current!=head) {
System.out.print(current.data+" ");
current = current.rlink;
}

System.out.println("\n=======================");
dll.remove();
current = head.rlink;
while (current!=head) {
System.out.print(current.data+" ");
current = current.rlink;
}
}
}

您可能也喜欢：
希尔排序	快速排序	直接插入排序
无觅

您可能也喜欢：
希尔排序	ClassLoader详解	快速排序	直接插入排序
无觅

您可能也喜欢：
某安全公司2012校招笔试题	希尔排序	直接插入排序	ClassLoader详解
无觅

您可能也喜欢：
二分查找	希尔排序	快速排序	直接插入排序
无觅