Long Luo's Life Notes

每一天都是奇迹

发表于 更新于 分类于 Waline： 阅读次数： 本文字数： 1.9k 阅读时长 ≈ 2 分钟

翻译 By Long Luo

本文翻译自 The Interface and Class Hierarchy Diagram of Java Collections ，主要通过一系列简单易懂的图片让你迅速了解Java容器类，容器接口以及类层级关系。

大段文字会看得很烦，图片才是王道！

一、 Collection vs Collections

“Collection”和”Collections”是2个完全不同的概念，在Java容器的类层级图中，“Collection”是一个根接口，但是”Collections”仅仅只是一个提供多种静态方法的类用于操作一些Collection类型。

Collection Vs Collections

二、 Collection的类层级图

下图展示了Collection的类层级图：

java-collection-hierarchy

三、 Map的类层级图

下图是一张Map的类层级图：

MapClassHierarchy

四、 总结

collection summary

五、 代码示例

下面展示容器类的一个代码示例：

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
List<String> a1 = new ArrayList<String>();
a1.add("Program");
a1.add("Creek");
a1.add("Java");
a1.add("Java");
System.out.println("ArrayList Elements");
System.out.print("\t" + a1 + "\n");
 
List<String> l1 = new LinkedList<String>();
l1.add("Program");
l1.add("Creek");
l1.add("Java");
l1.add("Java");
System.out.println("LinkedList Elements");
System.out.print("\t" + l1 + "\n");
 
Set<String> s1 = new HashSet<String>(); // or new TreeSet() will order the elements;
s1.add("Program");
s1.add("Creek");
s1.add("Java");
s1.add("Java");
s1.add("tutorial");
System.out.println("Set Elements");
System.out.print("\t" + s1 + "\n");
 
Map<String, String> m1 = new HashMap<String, String>(); // or new TreeMap() will order based on keys
m1.put("Windows", "2000");
m1.put("Windows", "XP");
m1.put("Language", "Java");
m1.put("Website", "programcreek.com");
System.out.println("Map Elements");
System.out.print("\t" + m1);

输出如下：

1
2
3
4
5
6
7
8
ArrayList Elements
	[Program, Creek, Java, Java]
LinkedList Elements
	[Program, Creek, Java, Java]
Set Elements
	[tutorial, Creek, Program, Java]
Map Elements
	{Windows=XP, Website=programcreek.com, Language=Java}

以上！

发表于 更新于 分类于 Waline： 阅读次数： 本文字数： 4.4k 阅读时长 ≈ 4 分钟

翻译 By Long Luo

下面这些问题 Stackoverflow 上关于Java collections提问和讨论最多的问题。在你阅读这些问题之前，有必要先阅读下这篇文章 3分钟速读：图解Java Collections的接口以及类层级关系 。

1. 什么时候用LinkedList？什么时候用ArrayList？

ArrayList本质上是一个数组。它的元素可以直接通过索引值直接访问。但是如果数组已经满了，那么需要重新分配一个更大的数组并且将全部的元素移动到新的数组需要花费O(n)的时间。当然从现有的数组中增加或者删除一个元素都需要移动现有的元素。这个可能是使用ArrayList中最大的不便之处。

LinkedList是一个双端链表。正因为如此，如果要获取一个链表中间的元素，需要从链表的头部开始查找。另一方面，增加或者删除链表中的元素将会很快，因为只需要在本地修改即可。

下表总结了最快情况下的比较需要耗费时间：

MethodArraylistLinkedList
get(index)O(1)O(n)
add(E)O(n)O(1)
add(E, index)O(n)O(n)
remove(index)O(n)O(n)
Iterator.remove()O(n)O(1)
Iterator.add(E)O(n)O(1)

不管运行时间，当大型列表需要额外考虑内存占用。LinkedList每个node至少需要2个额外的指针用于连接前后2个node。而在ArrayList中只需要数组存储元素值即可。

2. 当遍历容器时，高效等价于移除元素的操作？

最正确的方式就是在遍历容器时用Iterator.remove()去修改一个容器，如下代码所示：

1
2
3
4
5
Iterator<Integer> itr = list.iterator();
while(itr.hasNext()) {
   // do something
   itr.remove();
}

另外一个非常高频的使用但是不正确的代码是这样的：

1
2
3
for(Integer i: list) {
  list.remove(i);
}

运行上面的代码时你会得到一个ConcurrentModificationException。原因是因为一个迭代器自生成之后(在for循环中)，用于横贯这个列表。与此同时，这个列表同时也被Iterator.remove()修改了。在Java语言中，当一个线程在修改一个容器时而另外一个线程在遍历它是不允许的。

3. 如何将List转换成int[]？

最快捷的方式可能是用Apache Commons Lang库中的ArrayUtils。

1
int[] array = ArrayUtils.toPrimitive(list.toArray(new Integer[0]));

在JDK中，没有快捷方式。请注意你不能使用List.toArray()，因为那会将列表转换成Integer[]。正确的方式应该是这样的：

1
2
3
4
int[] array = new int[list.size()];
for(int i=0; i < list.size(); i++) {
  array[i] = list.get(i);
}
阅读全文 »

发表于 更新于 分类于 Waline： 阅读次数： 本文字数： 2.4k 阅读时长 ≈ 2 分钟

本文将展示Java Array的最重要的10个方法：

0. 声明一个数组

1
2
3
String[] aArray = new String[5];
String[] bArray = {"a","b","c", "d", "e"};
String[] cArray = new String[]{"a","b","c","d","e"};

1. 打印数组

1
2
3
4
5
6
7
8
9
int[] intArray = { 1, 2, 3, 4, 5 };
String intArrayString = Arrays.toString(intArray);
 
// print directly will print reference value
System.out.println(intArray);
// [I@7150bd4d
 
System.out.println(intArrayString);
// [1, 2, 3, 4, 5]

2. 从一个数组中创建一个ArrayList

1
2
3
4
String[] stringArray = { "a", "b", "c", "d", "e" };
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));
System.out.println(arrayList);
// [a, b, c, d, e]

3. 判断数组中是否包含一个特定的值

1
2
3
4
String[] stringArray = { "a", "b", "c", "d", "e" };
boolean b = Arrays.asList(stringArray).contains("a");
System.out.println(b);
// true

4. 连接2个数组

1
2
3
4
int[] intArray = { 1, 2, 3, 4, 5 };
int[] intArray2 = { 6, 7, 8, 9, 10 };
// Apache Commons Lang library
int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2);

5. 声明一个inline数组

1
method(new String[]{"a", "b", "c", "d", "e"});

6. 将一个数组中元素变成一个字符串

1
2
3
4
5
// containing the provided list of elements
// Apache common lang
String j = StringUtils.join(new String[] { "a", "b", "c" }, ", ");
System.out.println(j);
// a, b, c
阅读全文 »

发表于 更新于 分类于 Waline： 阅读次数： 本文字数： 1.6k 阅读时长 ≈ 1 分钟

Java语言中，String一直很基础，但很多人都很多概念还是很模糊。这里我们选取了网络上最常见的10个问题，希望通过这篇文章让大家对Java String有更深刻的认识。

1. 如何对字符串进行比较？用“==” 还是equals()？

简单来说，如果引用是否相同那么使用==， 判断值是否相等则用equals()。除非你想判断2个字符串是否是同一对象，否则你都应该使用equals()。

2. 为什么在安全敏感信息场合应该用char[]而不是string？

String具有不可变的特性，当字符串一旦被创建，那么知道垃圾收集器处理之前他们都是不可变的。如果使用数组，那么你可以明确地改变其内部单元数据。因此，安全敏感的信息例如密码不应该在系统中任何时候都存在。

3. 我们可以在switch语句中使用string吗？

是的，在Java 7中可以！JDK7中，我们可以在switch中使用string。但是之前的Java版本是不可以的。

1
2
3
4
5
6
7
8
9
10
// java 7 only!
switch(str.toLowerCase()){
	case "a":
		value = 1;
		break;

	case "b":
		value = 2 ;
		break;
	}

4. 如何将字符转成Int类型？

1
int n = Integer.parseInt("10");

就是这样简单！

5. 如何用白色空格字符分离一个字符串？

可以使用正则表达式分离字符串。““表示白色空格字符比如” “,”“。

1
String [] strArray = aString.split("\\s+");

6. substring()这个方法起什么作用？

在JDK6中，substring()方法并不会创建一个新的字符数组，而是给现存的字符串一个窗口用于表示当前字符串。如果想用一个新的字符数组来表示新的字符串，你可以加一个空支付串来实现，如下所示：

1
str.substring(m, n) + ""

使用上述方法，会创建一个新的字符数组来表示新的字符串。有时候可以让你的代码更快，因为垃圾收集器会收集一些没有使用的大字符串但子字符串确实保留的。

JDK7中，substring()会创建一个新的字符数组，而不是使用现在的这个。

阅读全文 »

发表于 更新于 分类于 Waline： 阅读次数： 本文字数： 2.3k 阅读时长 ≈ 2 分钟

By Long Luo

Android中自定义控件一直都是Android开发中的一个难点。

最近看大牛 @Tomcat的猫 写的 《Android群英传》 里面的第六章Android绘图机制及处理技巧，里面通过Canvas实现了一个如下所示的仪表盘：

仪表盘

在书中详细描述了如何实现这个仪表盘，这里就不赘述了，可以参考其 具体实现代码 。

但是这个表盘的指针是静止不动的，如果我们能让这个表盘的指针展示当前时间，随着时间而转动，那么我们就可以一款模拟时钟了。

那么，问题就来了：

如何才能让时钟的指针动起来呢？

这个问题，我们可以考虑分为2步去实现，第一步先绘制出当前的时间，第二部再让指针动起来。通过这样我们就可以实现一款模拟时钟。

一、绘制当前时间

1.1 获取当前时间

要绘制当前时间，我们要先获取当前时间。

1
mTime.setToNow();

1.2 获取指针角度

当前时间可分为时，分，秒。

我们最终要获取的是时分秒3个指针对应的精确角度。

秒针角度：最简单，直接乘以6即可获得。 分针角度：当前分钟 * 6 + 6 * 秒 / 60F 时针角度：(当前小时 % 12) * 30 + 30 * 当前分钟角度 / 360F;

1.3 绘制指针

获取到指针角度之后，接下来就是在表盘绘制指针了。这里我们要利用canvas.rotate()这个方法来实现绘制指针，具体实现代码如下所示：

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
private void drawTime(Canvas canvas) {
    // 当前时间
    mTime.setToNow();

    // 当前时间对应的角度
    float secRot = mTime.second * 6;
    float minRot = mTime.minute * 6 + 6 * mTime.second / 60F;
    float hrRot = (mTime.hour % 12) * 30 + 30 * minRot / 360F;

    Log.d(TAG, "hrRot=" + hrRot + ",minRot=" + minRot + ",secRot=" + secRot);

    // 画指针
    Paint paintHour = new Paint();
    paintHour.setStrokeWidth(20);
    Paint paintMinute = new Paint();
    paintMinute.setStrokeWidth(10);
    Paint paintSecond = new Paint();
    paintSecond.setStrokeWidth(5);

    canvas.save();

    // 时针
    canvas.rotate(hrRot, mWidth / 2, mHeight / 2);
    canvas.drawLine(mWidth / 2, mHeight / 2, mWidth / 2, mHeight / 2 - mWidth / 2 + 320,
            paintHour);
    canvas.rotate(-hrRot, mWidth / 2, mHeight / 2);

    // 分针
    canvas.rotate(minRot, mWidth / 2, mHeight / 2);
    canvas.drawLine(mWidth / 2, mHeight / 2, mWidth / 2, mHeight / 2 - mWidth / 2 + 230,
            paintMinute);
    canvas.rotate(-minRot, mWidth / 2, mHeight / 2);

    // 秒针
    canvas.rotate(secRot, mWidth / 2, mHeight / 2);
    canvas.drawLine(mWidth / 2, mHeight / 2, mWidth / 2, mHeight / 2 - mWidth / 2 + 150,
            paintSecond);
    canvas.rotate(-secRot, mWidth / 2, mHeight / 2);

    canvas.restore();
}
阅读全文 »
0%