-
Notifications
You must be signed in to change notification settings - Fork 0
/
index.html
794 lines (517 loc) · 36.7 KB
/
index.html
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>龙少爷的博客</title>
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<meta property="og:type" content="website">
<meta property="og:title" content="龙少爷的博客">
<meta property="og:url" content="http://lsyldliu/index.html">
<meta property="og:site_name" content="龙少爷的博客">
<meta name="twitter:card" content="summary">
<meta name="twitter:title" content="龙少爷的博客">
<link rel="icon" href="/css/images/favicon.ico">
<link rel="stylesheet" href="/css/style.css">
<!-- baidu webmaster push -->
<script src='//push.zhanzhang.baidu.com/push.js'></script>
</head>
<body class="home blog custom-background custom-font-enabled single-author">
<div id="page" class="hfeed site">
<header id="masthead" class="site-header" role="banner">
<hgroup>
<h1 class="site-title">
<a href="/" title="龙少爷的博客" rel="home">龙少爷的博客</a>
</h1>
<h2 class="site-description">
<a href="/" id="subtitle">为技术而不断超越 浙大控制系</a>
</h2>
</hgroup>
<nav id="site-navigation" class="main-navigation" role="navigation">
<button class="menu-toggle">菜单</button>
<a class="assistive-text" href="/#content" title="跳至内容">跳至内容</a><!--TODO-->
<div class="menu-main-container">
<ul id="menu-main" class="nav-menu">
<li class="menu-item menu-item-type-post_type menu-item-object-page"><a href="/">学术研究方向</a></li>
<li class="menu-item menu-item-type-post_type menu-item-object-page"><a href="/archives">C++/Java学习</a></li>
</ul>
</div>
</nav>
</header>
<div id="main" class="wrapper">
<div id="primary" class="site-content"><div id="content" role="main">
<article id="post-C-顺序容器和关联容器" class="post-C-顺序容器和关联容器 post type-post status-publish format-standard hentry">
<!---->
<header class="entry-header">
<h1 class="entry-title">
<a class="article-title" href="/2016/09/02/C-顺序容器和关联容器/">C++顺序容器和关联容器</a>
</h1>
<div class="comments-link">
<a href="javascript:void(0);" data-url="http://lsyldliu/2016/09/02/C-顺序容器和关联容器/" data-id="cismshak30000hkg2e4bdmd5j" class="leave-reply bdsharebuttonbox" data-cmd="more">Share</a>
</div><!-- .comments-link -->
</header><!-- .entry-header -->
<div class="entry-content">
<p><strong>顺序容器</strong></p>
<p> C++容器包括顺序容器和关联容器，C++新标准库提供了六种顺序容器，分别是string、vector、deque、array、list和forward_list。</p>
<p> string、vector、deque、array支持快速快速访问，但在容器中间位置进行插入删除操作，代价比较大；list、forward_list支持快速的插入、删除操作，但不能随机访问容器中的元素。</p>
<p><strong>容器适配器</strong></p>
<p> 除了顺序容器外，标准库还定义了三个顺序容器适配器：stack、queue和priority_queue。<strong>适配器</strong>（adaptor）是标准库中的一个通用概念，容器、迭代器和函数都有适配器。本质上，一个适配器是一种机制，能使某种事物的行为看起来像另外一种事物一样。一个容器适配器接受一种已有的容器类型，使其行为看起来像一种不同的类型。例如，stack适配器接受一个顺序容器（除array和forward_lsit外),并使其操作起来像一个stack一样。</p>
<p> 对于一个给定的适配器，可以使用哪些容器是有限制的。所有适配器都要求容器具有添加和删除元素的能力。因此适配器不能构造在array之上。类似的，我们也不能使用forwar_list来构造适配器。stack可以使用出array和forward_list之外的任何容器类型来构造，标准库中stack默认基于deque实现；queue适配器可以构造于list和deque之上，但不能基于vector构造，默认基于deque实现；priority_queue可以构造于vector和deque之上，但不能基于list构造，默认基于vector实现。</p>
<p><strong>关联容器</strong></p>
<p> 关联容器支持高效的关键字查找和访问。两个主要的类型是<strong>map</strong>和<strong>set</strong>。map中的元素是一些关键字-值（key-value）对；关键字起到索引的作用，值则表示与索引相关的数据。set中的每个元素只包含一个关键字；set支持高效的关键字查询操作——检查一个给定关键字是否在set中。</p>
<p> 标准库提供8个关联容器，如下所示：</p>
<p><strong>1.按关键字有序保存元素</strong></p>
<pre><code>map 关联数组：保存关键字-值对
set 关键字即值，即只保存关键字的容器
multimap 关键字可重复出现的map
multiset 关键字可重复的set
</code></pre><p><strong>2.无序集合</strong></p>
<pre><code>unordered_map 用哈希函数组织的map
unordered_set 用哈希函数组织的set
unordered_multimap 哈希组织的map:关键字可以重复出现
unordered_multiset 哈希组织的set：关键字可以重复出现
</code></pre>
</div><!-- .entry-content -->
<footer class="entry-meta">
<a href="/2016/09/02/C-顺序容器和关联容器/">
<time datetime="2016-09-02T08:01:21.000Z" class="entry-date">
2016-09-02
</time>
</a>
</footer>
</article>
<article id="post-常量指针" class="post-常量指针 post type-post status-publish format-standard hentry">
<!---->
<header class="entry-header">
<h1 class="entry-title">
<a class="article-title" href="/2016/09/01/常量指针/">指针和const限定符</a>
</h1>
<div class="comments-link">
<a href="javascript:void(0);" data-url="http://lsyldliu/2016/09/01/常量指针/" data-id="cismshalf000ahkg2vyehdyuh" class="leave-reply bdsharebuttonbox" data-cmd="more">Share</a>
</div><!-- .comments-link -->
</header><!-- .entry-header -->
<div class="entry-content">
<p> 指针是C和C++语言中最长常用的一个工具，也是很难学的一个东西，对它的理解一直在进步中。今天来介绍一个指针和const限定符。</p>
<p> 将const限定符和指针连起来用，会出现两种类型的指针，<strong>指向常量的指针</strong>和<strong>常量指针</strong>。下面通过实例来介绍一下它们的区别：</p>
<p><strong>1.指向常量的指针</strong></p>
<p> 不能用于改变改变其所指向的对象的值，而且要想存放常量对象的地址，必须使用指向常量的指针。</p>
<pre><code>const double pi = 3.14; //pi是个常量，它的值不能改变
double *ptr = &pi; //错误：ptr是个普通指针
const double *cptr = &pi; //正确：cptr可以指向一个双精度常数
*cptr = 42; //错误，不能给*cptr赋值
</code></pre><p> 当然这里要强调一下，指向常量的指针没有规定其所指向的对象必须是一个常量。所谓指向常量的指针仅仅要求不能通过该指针改变对象的值，而对象的值是可以通过其他途径改变的。</p>
<p> 另外说明一点，虽然不能修改对象的值，但可以将指向常量的指针指向另外一个常量对象，</p>
<pre><code>const double pt = 3.5;
cptr = &pt;
</code></pre><p><strong>2.常量指针</strong></p>
<p> 由于指针是对象，故可以把指针本身定为常量。常量指针必须初始化，而且一旦初始化完成，则它的值（也就是存放在指针中的那个地址）就不能再被改变了。把*放在const关键字之前用以说明指针是一个常量，这样的书写形式隐含着一层意味，即不变的是指针本身而不是指向的那个值。</p>
<pre><code>int errNumb = 0；
int *const curErr = &errNumb; //curErr将一直指向errNumb
const double pi = 3.4159;
const double *const pip = &pi; // pip是一个指向常量对象的常量指针
</code></pre><p> 指针本身是一个常量并不意味着不能通过指针修改其所指向对象的值，能否这样做完全依赖于所指向对象的类型。</p>
</div><!-- .entry-content -->
<footer class="entry-meta">
<a href="/2016/09/01/常量指针/">
<time datetime="2016-09-01T14:56:42.000Z" class="entry-date">
2016-09-01
</time>
</a>
</footer>
</article>
<article id="post-Collections-和Array类" class="post-Collections-和Array类 post type-post status-publish format-standard hentry">
<!---->
<header class="entry-header">
<h1 class="entry-title">
<a class="article-title" href="/2016/08/29/Collections-和Array类/">Collections 和Array类</a>
</h1>
<div class="comments-link">
<a href="javascript:void(0);" data-url="http://lsyldliu/2016/08/29/Collections-和Array类/" data-id="cismshake0002hkg2olv74zna" class="leave-reply bdsharebuttonbox" data-cmd="more">Share</a>
</div><!-- .comments-link -->
</header><!-- .entry-header -->
<div class="entry-content">
<p>Java 1.2添加了自己的一套实用工具，可用来对数组或列表进行排列和搜索。这些工具都属于<br>两个新类的“静态”方法。这两个类分别是用于排序和搜索数组的Arrays，以及用于排序和搜索<br>列表的Collections。这是JCF里面功能强大的工具，但初学者往往会忽视。按JCF文档的说法，这两个类提供了封装器实现（Wrapper Implementations）、数据结构算法和数组相关的应用。<br>想必大家不会忘记上面谈到的“折半查找”、“排序”等经典算法吧，Collections类提供了丰富的静态方法帮助我们轻松完成这些在数据结构课上烦人的工作：<br>binarySearch：折半查找。 </p>
<p>sort：排序，这里是一种类似于快速排序的方法，效率仍然是O(n * log n)，但却是一种稳定的排序方法。 </p>
<p>reverse：将线性表进行逆序操作，这个可是从前数据结构的经典考题哦！ </p>
<p>rotate：以某个元素为轴心将线性表“旋转”。 </p>
<p>swap：交换一个线性表中两个元素的位置。<br>……<br>Collections还有一个重要功能就是“封装器”（Wrapper），它提供了一些方法可以把一个集合转换成一个特殊的集合，如下： </p>
<p>unmodifiableXXX：转换成只读集合，这里XXX代表六种基本集合接口：Collection、List、Map、Set、SortedMap和SortedSet。如果你对只读集合进行插入删除操作，将会抛出UnsupportedOperationException异常。 </p>
<p>synchronizedXXX：转换成同步集合。 </p>
<p>singleton：创建一个仅有一个元素的集合，这里singleton生成的是单元素Set，<br>singletonList和singletonMap分别生成单元素的List和Map。 </p>
<p>空集：由Collections的静态属性EMPTY_SET、EMPTY_LIST和EMPTY_MAP表示。 </p>
<p>这次关于Java集合类概述就到这里，下一次我们来讲解Java集合类的具体应用，如List排序、删除重复元素。</p>
</div><!-- .entry-content -->
<footer class="entry-meta">
<a href="/2016/08/29/Collections-和Array类/">
<time datetime="2016-08-29T09:32:04.000Z" class="entry-date">
2016-08-29
</time>
</a>
</footer>
</article>
<article id="post-Java各各种常用集合" class="post-Java各各种常用集合 post type-post status-publish format-standard hentry">
<!---->
<header class="entry-header">
<h1 class="entry-title">
<a class="article-title" href="/2016/08/29/Java各各种常用集合/">Java各种常用集合</a>
</h1>
<div class="comments-link">
<a href="javascript:void(0);" data-url="http://lsyldliu/2016/08/29/Java各各种常用集合/" data-id="cismshal30009hkg2f4sz8qyr" class="leave-reply bdsharebuttonbox" data-cmd="more">Share</a>
</div><!-- .comments-link -->
</header><!-- .entry-header -->
<div class="entry-content">
<p><strong>1.Java集合类图</strong></p>
<p>1.1</p>
<p><img src="http://pic002.cnblogs.com/images/2012/80896/2012053020260298.jpg" alt=""></p>
<p>1.2</p>
<p><img src="http://pic002.cnblogs.com/images/2012/80896/2012053020261738.gif" alt=""></p>
<p> 首先来看两张经典的Java集合框架图，上述类图中，实线边框的是实现类，比如ArrayList，LinkedList，HashMap等，折线边框的是抽象类，比如AbstractCollection，AbstractList，AbstractMap等，而点线边框的是接口，比如Collection，Iterator，List等。点线箭头表示一个<br>特定的类准备实现一个接口（ 在抽象类的情况下，则是“部分”实现一个接口） 。双线箭头表示<br>一个类可生成箭头指向的那个类的对象。例如，任何集合都可以生成一个反复器<br>（ Iterator） ，而一个列表可以生成一个ListIterator（ 以及原始的反复器，因为列表是从集合继<br>承的）。</p>
<p> 刚看这两张图时候可能让人有点儿摸不着头脑，但仔细研究之后会发现，它实际只有三个接口组件：Map，List和Set。而且每个组件实际只有两、三种实现方式，而且通常都只有一种特别好的方式。只要看出了这一点，集合就不会再令人生畏。</p>
<p><strong>2.Java具体接口及实现类介</strong></p>
<p> 仔细观察上图可以知道，Java集合中包含了六大接口，分别是<strong>Collection，Set，List，Map，Iterator，Comparable</strong>，Iterator是根接口，Collection接口实现了Iterator，Collection接口有两个实现的子接口List，Set，Map没有继承Collection接口，也是一个独立的父接口。</p>
<p><strong>2.1 Iterator接口</strong></p>
<p> 该接口是一个根接口，集合框架中的其他接口都或多或少实现了该接口，而且所有的实现类都实现了该接口。所有实现了Collection接口的容器类都有iterator方法，用于返回一个实现了Iterator接口的对象。Iterator对象称作迭代器，Iterator接口方法能以迭代方式逐个访问集合中各个元素，并可以从Collection中除去适当的元素。</p>
<p><strong>2.2 Collection接口</strong></p>
<p> Collection是最基本集合接口，它定义了一组允许重复的对象。Collection接口派生了两个子接口Set和List，分别定义了两种不同的存储方式，如下：</p>
<p><strong>2.3 List接口</strong></p>
<p> List接口同样也继承于Collection接口，但是与Set接口恰恰相反，List接口的集合类中的元素是对象有序且可重复。</p>
<p> 特征：有序且可重复。</p>
<p> 两个重要的实现类：ArrayList和LinkedList</p>
<p> 1.ArrayList特点是有序可重复的</p>
<p> 2.LinkedList是一个双向链表结构的。</p>
<p><strong>2.4 Set接口</strong></p>
<p> Set接口继承于Collection接口，它没有提供额外的方法，Set完全就是一个Collection，只是具有不同的行为，但实现了Set接口的集合类中的元素是无序且不可重复。</p>
<p> 特征：无序且不可重复。<br> 两个重要的实现类：HashSet和TreeSet</p>
<p> 1. HashSet是通过HashMap实现的,TreeSet是通过TreeMap实现的,只不过Set用的只是Map的key</p>
<p> 2. Map的key和Set都有一个共同的特性就是集合的唯一性.TreeMap更是多了一个排序的功能.</p>
<p><strong>2.5 Map接口</strong></p>
<p> Map也是接口，但没有继承Collection接口。该接口描述了从不重复的键到值的映射。Map接口用于维护键/值对（key/value pairs）。</p>
<p> 特征：它描述了从不重复的键到值的映射。</p>
<p> 两个重要的实现类：HashMap和TreeMap</p>
<p> 1.HashMap，中文叫散列表，基于哈希表实现，特点就是键值对的映射关系。一个key对应一个Value。HashMap中元素的排列顺序是不固定的。更加适合于对元素进行插入、删除和定位。</p>
<p> 2.TreeMap，基于红黑书实现。TreeMap中的元素保持着某种固定的顺序。更加适合于对元素的顺序遍历。</p>
<p><strong>2.6 Comparable接口</strong></p>
<p> Comparable可以用于比较的实现，实现了Comparable接口的类可以通过实现comparaTo方法从而确定该类对象的排序方式。</p>
<p><strong>总结</strong></p>
<p> Collection集合分别派生自Collection和Map接口，Collection有两个常用子接口List和Set，分别表示有序可重复，无序不可重复的集合。而Map存储的是key-value的映射。上面讲了那么多，Java2的集合框架，抽其核心，主要有三种：List、Set和Map。</p>
<p> 上面的总结看上去很多，很繁琐，其实你只要记得一点：collection是用于处理各种数据结构的，根据各种数据结构的特点理解，一切都会变简单。</p>
</div><!-- .entry-content -->
<footer class="entry-meta">
<a href="/2016/08/29/Java各各种常用集合/">
<time datetime="2016-08-29T08:43:53.000Z" class="entry-date">
2016-08-29
</time>
</a>
</footer>
</article>
<article id="post-JJava内部类与普通类的访问控制" class="post-JJava内部类与普通类的访问控制 post type-post status-publish format-standard hentry">
<!---->
<header class="entry-header">
<h1 class="entry-title">
<a class="article-title" href="/2016/08/29/JJava内部类与普通类的访问控制/">Java内部类与普通类的访问控制</a>
</h1>
<div class="comments-link">
<a href="javascript:void(0);" data-url="http://lsyldliu/2016/08/29/JJava内部类与普通类的访问控制/" data-id="cismshakm0004hkg2j76qm4vh" class="leave-reply bdsharebuttonbox" data-cmd="more">Share</a>
</div><!-- .comments-link -->
</header><!-- .entry-header -->
<div class="entry-content">
<p>Java中，普通（ 非内部） 类不可设为private或protected——只允许public或者“友好的”。而内部类可设为private或protected.</p>
<p> 由于Selector是一个接口，所以其他许多类都能用它们自己的方式实现接<br>口，而且许多方法都能将接口作为一个自变量使用，从而创建一般的代码</p>
<p> Java中的集合包括：Vector类， BitSet类，Stack类， 以及HashTable，这个类继承自抽象类Dictionary。</p>
</div><!-- .entry-content -->
<footer class="entry-meta">
<a href="/2016/08/29/JJava内部类与普通类的访问控制/">
<time datetime="2016-08-29T02:27:27.000Z" class="entry-date">
2016-08-29
</time>
</a>
</footer>
</article>
<article id="post-就业城市选择" class="post-就业城市选择 post type-post status-publish format-standard hentry">
<!---->
<header class="entry-header">
<h1 class="entry-title">
<a class="article-title" href="/2016/08/28/就业城市选择/">就业城市选择</a>
</h1>
<div class="comments-link">
<a href="javascript:void(0);" data-url="http://lsyldliu/2016/08/28/就业城市选择/" data-id="cismshalz000chkg2972y65qb" class="leave-reply bdsharebuttonbox" data-cmd="more">Share</a>
</div><!-- .comments-link -->
</header><!-- .entry-header -->
<div class="entry-content">
<p> 刚看了了马云为G20代言的视频，视频中马云讲到为什么不把阿里巴巴的总部放到北京或上海？原因是杭州是一个有创业精神的城市，包容民营企业发展。而北京人更追捧国企，在上海跨国公司更受青睐。分析一下觉得说的有一定的道理。北京是帝都，天子脚下，进国企确实是一个不错的选择；上海是国际化大都市，这里有很大的国际大公司的中国区总部，国际氛围很好。然而杭州乃至浙江省，民营企业的发展确实走在全国的前列，浙江人的创业精神很好，我上次去温州乐清也感受到了，几个人宁愿开个小作坊式的公司，也不去给别人打工，这里有很好的创业环境。除此之外，深圳也是一个创新之城，这里的科技型创业公司很多，创业环境也很好。最近深圳政府出台一系列政策引进高校和高端人才，为这座正在快速发展中的城市，注入更多的科技血液。</p>
<p> 总结以上，由于我对自己工作的定位是互联网及其相关行业的技术研发，因此对上面四个城市进行筛选和排序，结果如下，北京不去，然后首选上海或深圳，这两个还不能确定，虽说上海是大都市，但进入外企并不一定是个好的选择，而深圳确定不错，但地理位置有点远，最后选择杭州，杭州虽然互联网环境也不错，但城市规模不大，发展有限，然而杭州的优势是适合居住，节奏没有那么快。</p>
</div><!-- .entry-content -->
<footer class="entry-meta">
<a href="/2016/08/28/就业城市选择/">
<time datetime="2016-08-28T09:55:45.000Z" class="entry-date">
2016-08-28
</time>
</a>
</footer>
</article>
<article id="post-Java-句柄" class="post-Java-句柄 post type-post status-publish format-standard hentry">
<!---->
<header class="entry-header">
<h1 class="entry-title">
<a class="article-title" href="/2016/08/27/Java-句柄/">Java 句柄</a>
</h1>
<div class="comments-link">
<a href="javascript:void(0);" data-url="http://lsyldliu/2016/08/27/Java-句柄/" data-id="cismshakj0003hkg2cakt4szh" class="leave-reply bdsharebuttonbox" data-cmd="more">Share</a>
</div><!-- .comments-link -->
</header><!-- .entry-header -->
<div class="entry-content">
<p> 这几天在学习Java，一直在看think in Java这本书，这本书确实不错，让我对面向对象的编程有了更深一层的理解。书里面一直在强调“句柄”这个概念，之前学习C++的时候，并没有去理解这个概念，故写下对它的理解。</p>
<p>1.数组句柄</p>
<pre><code>int[] a1;
这里创建了一个句柄a1，a1指向一个数组，但并没有给数组分配存储空间，所以数组实际上并不存在。
</code></pre><p>当令</p>
<pre><code>a1 = new int[10]；
</code></pre><p> 此时new int[10]则创建了拥有10个元素的整形数组对象，并令句柄a1指向该数组的首地址，此时可以按操作数组的方式对a1进行操作。</p>
<p> 当然句柄也可以进行复制操作，这里在创建另外一个数组句柄，前提是要对a1进行初始化。</p>
<pre><code>int[] a1 = { 1, 2, 3, 4, 5 };
int[] a2;
a2 = a1;
</code></pre><p> 下面以一段可用的代码来演示一下句柄复制的过程。</p>
<pre><code>public class Arrays {
public static void main(String[] args) {
int[] a1 = { 1, 2, 3, 4, 5 };
int[] a2;
a2 = a1;
for(int i = 0; i < a2.length; i++)
a2[i]++;
for(int i = 0; i < a1.length; i++)
prt("a1[" + i + "] = " + a1[i]);
}
static void prt(String s) {
System.out.println(s);
}
} ///
</code></pre><p>2.对象句柄</p>
<p> 首先创建一个类Number,</p>
<pre><code>class Number {
int i;
}
</code></pre><p>然后创建该类的两个实例</p>
<pre><code>Number n1 = new Number();
Number n2 = new Number();
</code></pre><p>n1和n2为该类的两个句柄，这两个句柄分别指向该类的两个对象，这里通过new Number()创建类的对象，当然和数组句柄一样，对象句柄也能进行复制，</p>
<pre><code>n2 = n1; 这里令句柄n2指向n1的对象，改变n1的同时也会改变n2,n2的对象则会被垃圾收集器回收
</code></pre><p>同样这里以实例来演示这种变化</p>
<pre><code>class Number {
int i;
}
public class Assignment {
public static void main(String[] args) {
Number n1 = new Number();
Number n2 = new Number();
n1.i = 9;
n2.i = 47;
System.out.println("1: n1.i: " + n1.i +", n2.i: " + n2.i);
n1 = n2;
System.out.println("2: n1.i: " + n1.i +", n2.i: " + n2.i);
n1.i = 27;
System.out.println("3: n1.i: " + n1.i +", n2.i: " + n2.i);
}
}
</code></pre><p>输出结果如下：</p>
<pre><code>1: n1.i: 9, n2.i: 47
2: n1.i: 47, n2.i: 47
3: n1.i: 27, n2.i: 27
</code></pre>
</div><!-- .entry-content -->
<footer class="entry-meta">
<a href="/2016/08/27/Java-句柄/">
<time datetime="2016-08-27T10:59:34.000Z" class="entry-date">
2016-08-27
</time>
</a>
</footer>
</article>
<article id="post-Java的几种数据存储方式" class="post-Java的几种数据存储方式 post type-post status-publish format-standard hentry">
<!---->
<header class="entry-header">
<h1 class="entry-title">
<a class="article-title" href="/2016/08/27/Java的几种数据存储方式/">Java的几个数据保存地方</a>
</h1>
<div class="comments-link">
<a href="javascript:void(0);" data-url="http://lsyldliu/2016/08/27/Java的几种数据存储方式/" data-id="cismshalg000bhkg2m8srnhwr" class="leave-reply bdsharebuttonbox" data-cmd="more">Share</a>
</div><!-- .comments-link -->
</header><!-- .entry-header -->
<div class="entry-content">
<p> <strong>程序运行时，有六个地方可以保存数据，其实这里讲数据保存到不同的地方也是指内存分配方式的不同，下面来介绍一下它们的区别。</strong></p>
<ol>
<li><p>寄存器。这是最快的保存区域，因为它位于和其他所有保存方式不同的地方：处理器内<br>部。然而，寄存器的数量十分有限，所以寄存器是根据需要由编译器分配。我们对此没有直<br>接的控制权，也不可能在自己的程序里找到寄存器存在的任何踪迹。</p>
</li>
<li><p>堆栈。驻留于常规RAM（ 随机访问存储器） 区域，但可通过它的“堆栈指针”获得处理的直<br>接支持。堆栈指针若向下移，会创建新的内存；若向上移，则会释放那些内存。这是一种特<br>别快、特别有效的数据保存方式，仅次于寄存器。创建程序时，Java编译器必须准确地知道<br>堆栈内保存的所有数据的“长度”以及“存在时间”。</p>
</li>
<li><p>堆。一种常规用途的内存池（ 也在RAM区域） ，其中保存了Java对象。和堆栈不同，“内<br>存堆”或“堆”（ Heap） 最吸引人的地方在于编译器不必知道要从堆里分配多少存储空间，也不<br>必知道存储的数据要在堆里停留多长的时间。因此，用堆保存数据时会得到更大的灵活性。<br>要求创建一个对象时，只需用new命令编制相关的代码即可。 </p>
</li>
<li><p>静态存储。这儿的“静态”（ Static） 是指“位于固定位置”（ 尽管也在RAM里） 。程序运行期<br>间，静态存储的数据将随时等候调用。可用static关键字指出一个对象的特定元素是静态的。<br>但Java对象本身永远都不会置入静态存储空间。</p>
</li>
<li><p>常数存储。常数值通常直接置于程序代码内部。这样做是安全的，因为它们永远都不会改<br>变。有的常数需要严格地保护，所以可考虑将它们置入只读存储器（ROM）。</p>
</li>
<li><p>非RAM存储。若数据完全独立于一个程序之外，则程序不运行时仍可存在，并在程序的控<br>制范围之外。其中两个最主要的例子便是“流式对象”和“固定对象”。对于流式对象，对象会变<br>成字节流，通常会发给另一台机器。而对于固定对象，对象保存在磁盘中。即使程序中止运<br>行，它们仍可保持自己的状态不变。对于这些类型的数据存储，一个特别有用的技巧就是它<br>们能存在于其他媒体中。一旦需要，甚至能将它们恢复成普通的、基于RAM的对象。</p>
</li>
</ol>
<p><strong>注：</strong>前面讲到的静态数组和动态数组创建时内存分配的区别，与这里的堆栈和堆分别对应。</p>
</div><!-- .entry-content -->
<footer class="entry-meta">
<a href="/2016/08/27/Java的几种数据存储方式/">
<time datetime="2016-08-27T04:52:14.000Z" class="entry-date">
2016-08-27
</time>
</a>
</footer>
</article>
<article id="post-Java-类边界关键字" class="post-Java-类边界关键字 post type-post status-publish format-standard hentry">
<!---->
<header class="entry-header">
<h1 class="entry-title">
<a class="article-title" href="/2016/08/27/Java-类边界关键字/">Java 类边界关键字</a>
</h1>
<div class="comments-link">
<a href="javascript:void(0);" data-url="http://lsyldliu/2016/08/27/Java-类边界关键字/" data-id="cismshakq0005hkg27wr5kax1" class="leave-reply bdsharebuttonbox" data-cmd="more">Share</a>
</div><!-- .comments-link -->
</header><!-- .entry-header -->
<div class="entry-content">
<p> Java采用三个显式（ 明确） 关键字以及一个隐式（ 暗示） 关键字来设置类边界：public，<br>private，protected以及暗示性的friendly。若未明确指定其他关键字，则默认为后者。这些关<br>键字的使用和含义都是相当直观的，它们决定了谁能使用后续的定义内容。</p>
<p> “public”（ 公共）意味着后续的定义任何人均可使用。而在另一方面，“private”（ 私有） 意味着除您自己、类型的创建者以及那个类型的内部函数成员，其他任何人都不能访问后续的定义信息。private在您与客户程序员之间竖起了一堵墙。若有人试图访问私有成员，就会得到一个编译期错误。“friendly”（ 友好的） 涉及“包装”或“封装”（ Package） 的概念——即Java用来构建库的方法。若某样东西是“友好的”，意味着它只能在这个包装的范围内使用（ 所以这一访问级别有时也叫作“包装访问”） 。“protected”（ 受保护的） 与“private”相似，只是一个继承的类可访问受保护的成员，但不能访问私有成员。</p>
</div><!-- .entry-content -->
<footer class="entry-meta">
<a href="/2016/08/27/Java-类边界关键字/">
<time datetime="2016-08-27T01:55:14.000Z" class="entry-date">
2016-08-27
</time>
</a>
</footer>
</article>
<article id="post-Longest-Substring-Without-Repeating-Characters" class="post-Longest-Substring-Without-Repeating-Characters post type-post status-publish format-standard hentry">
<!---->
<header class="entry-header">
<h1 class="entry-title">
<a class="article-title" href="/2016/08/26/Longest-Substring-Without-Repeating-Characters/">Longest Substring Without Repeating Characters</a>
</h1>
<div class="comments-link">
<a href="javascript:void(0);" data-url="http://lsyldliu/2016/08/26/Longest-Substring-Without-Repeating-Characters/" data-id="cismshaku0006hkg2ch69v3vv" class="leave-reply bdsharebuttonbox" data-cmd="more">Share</a>
</div><!-- .comments-link -->
</header><!-- .entry-header -->
<div class="entry-content">
<p>Given a string, find the length of the longest substring without repeating characters.</p>
<p>Examples:</p>
<p>Given “abcabcbb”, the answer is “abc”, which the length is 3.</p>
<p>Given “bbbbb”, the answer is “b”, with the length of 1.</p>
<p>Given “pwwkew”, the answer is “wke”, with the length of 3. Note that the answer must be a substring, “pwke” is a subsequence and not a substring.</p>
<p>Subscribe to see which companies asked this question</p>
<p>本题使用两种解法，第一种用标志数组，用于记录字符串中元素是否已经被遍历过，如未遍历，则置为true；方法2使用HashTable,将未遍历的字符放入HashMap中，再依次查询是否有重复元素，从而找到最大子串。这里用Java语言描述。</p>
<p>Solution 1:</p>
<pre><code>public int lengthOfLongestSubstring(String s) {
if(s == null)
return 0;
boolean[] flag = new boolean[256];
int start = 0;
int result = 0;
char[] arr = s.toCharArray();
for(int i =0; i < arr.length; i++){
char current = arr[i];
if(!flag[current]){
flag[current] = true;
}
else{
result = Math.max(result, i - start);
for(int k = start; k < i; k++){
if(arr[k] == current){
start = k + 1;
break;
}
flag[arr[k]] = false;
}
}
}
result = Math.max(arr.length - start, result);
return result;
}
</code></pre><p>Solution 2:</p>
<pre><code>public int lengthOfLongestSubstring(String s) {
if(s == null)
return 0;
int start = 0;
int result = 0;
HashMap<Character,Integer> map = new HashMap<Character, Integer>();
for(int i = 0; i < s.length(); i++){
char c = s.charAt(i);
if(map.containsKey(c)){
result = Math.max(result, map.size());
while(map.containsKey(c)){
map.remove(s.charAt(start));
start++;
}
map.put(c, i);
}
else{
map.put(c, i);
}
}
result = Math.max(result, map.size());
return result;
}
</code></pre>
</div><!-- .entry-content -->
<footer class="entry-meta">
<a href="/2016/08/26/Longest-Substring-Without-Repeating-Characters/">
<time datetime="2016-08-26T12:50:45.000Z" class="entry-date">
2016-08-26
</time>
</a>
</footer>
</article>
<nav id="pagination">
<nav id="page-nav">
<span class="page-number current">1</span><a class="page-number" href="/page/2/">2</a><a class="extend next" rel="next" href="/page/2/">Next »</a>
</nav>
</nav>
</div></div>
<div id="secondary" class="widget-area" role="complementary">
<aside id="search" class="widget widget_search"><form role="search" method="get" accept-charset="utf-8" id="searchform" class="searchform" action="//google.com/search">
<div>
<input type="text" value="" name="s" id="s" />
<input type="submit" id="searchsubmit" value="搜索" />
</div>
</form></aside>
<aside class="widget">
<h3 class="widget-title">Recents</h3>
<div class="widget-content">
<ul>
<li>
<a href="/2016/09/02/C-顺序容器和关联容器/">C++顺序容器和关联容器</a>
</li>
<li>
<a href="/2016/09/01/常量指针/">指针和const限定符</a>
</li>
<li>
<a href="/2016/08/29/Collections-和Array类/">Collections 和Array类</a>
</li>
<li>
<a href="/2016/08/29/Java各各种常用集合/">Java各种常用集合</a>
</li>
<li>
<a href="/2016/08/29/JJava内部类与普通类的访问控制/">Java内部类与普通类的访问控制</a>
</li>
</ul>
</div>
</aside>
</div>
</div>
<footer id="colophon" role="contentinfo">
<p>© 2016 龙少爷
All rights reserved.</p>
<p>Powered by <a href="http://hexo.io/" target="_blank">Hexo</a></p>
</footer>
<script>window._bd_share_config={"common":{"bdSnsKey":{},"bdText":"","bdMini":"1","bdMiniList":false,"bdPic":"","bdStyle":"2","bdSize":"16"},"share":{}};with(document)0[(getElementsByTagName('head')[0]||body).appendChild(createElement('script')).src='http://bdimg.share.baidu.com/static/api/js/share.js?v=89860593.js?cdnversion='+~(-new Date()/36e5)];</script>
<script src="/js/jquery-2.0.3.min.js"></script>
<link rel="stylesheet" href="/fancybox/jquery.fancybox.css">
<script src="/fancybox/jquery.fancybox.pack.js"></script>
<script src="/js/script.js"></script>
<script src="/js/navigation.js"></script>
<div id="bg"></div>
</div>
</body>
</html>