文档章节

知识整理一:Java基础

流鱼不乖
 流鱼不乖
发布于 2017/01/13 15:53
字数 8087
阅读 35
收藏 1

1.       增强for循环和for 区别:

增强for循环内部是使用的Iterator来遍历的,只能遍历数组和实现了Iterable接口的集合。优点是写法简便,无需获得数组、集合长度,也无需根据索引来访问元素。缺点是不能在循环里动态的删除元素和获取元素下标。

任何的增强for循环都可以改写为普通for循环。遍历集合所有元素的话用增强for循环更加简洁,如果是复杂的循环,还是用for循环比较好,for循环功支持索引取元素,可以使用下标来控制位置。

高级for有一个局限性,必须有被遍历的目标。

单线程中  增强for不能动态删除元素,用Iterator能实现

ArrayList由于使用数组实现,因此下标明确,最好使用普通循环
3.而对于 LinkedList 由于获取一个元素,要从头开始向后找,因此建议使用 增强for循环,也就是iterator

Svn git区别

1.       GIT 版本控制 分布式系统

也就是每个开发人员从中心版本库/服务器上chect out代码后会在自己的机器上克隆一个自己的版本库。

2.       GIT把内容按元数据方式存储,而SVN是按文件:

3.       GIT分支和SVN的分支不同

 git从同一个工作目录下快速的在几个分支间切换。你很容易发现未被合并的分支,你能简单而快捷的合并这些文件

4.       GIT没有一个全局的版本号,而SVN有:

 SVN的版本号实际是任何一个相应时间的源代码快照。

5.       GIT的内容完整性要优于SVN:

GIT的内容存储使用的是SHA-1 哈希算法。这能确保代码内容的完整性,确保在遇到磁盘故障和网络问题时降低对版本库的破坏。

6.     Git下载下来后,在OffLine状态下可以看到所有的Log,SVN不可以,可以不依赖于网络做任何事

Git的分支名是可以使用不同名字的

可以在Git的任意一个提交点(commit point)开启分支

SVN又叫做集中式版本控制器。严重的依赖服务器端,当服务器端无法使用的时候,版本控制也就无法再使用了

 

 

创建对象的几种方式

1.       new

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

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

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

5.      

Object方法

Equals

判断两个对象是否具有相同的引用

Java中,要求equals方法具有下面的特性:

自反性,x.equals(x)返回ture。

对称性,x.equals(y),和y.equals(x)返回相同的值。

传递性,对于任何引用x,y,z,如果x.equals(y)返回true,y.equals(z)返回true,那么x.equals(z)也要返回true。

一致性,如果x和y所引用的对象没有变化,反复调用x.equals(y)应该返回同样的结果。

对于任意非空引用x,x.euqals(null)应该返回false。

 

Hashcode

1.       散列吗,是由对象导出的一个整型值。

2.       返回该对象的存储地址

3.       如果重写了equals方法,则必须重写HashCode方法,因为这两个方法必须一致:如果equals方法返回true,则HashCode方法必须返回相同值。

4.       Java对象的eqauls方法和hashCode方法是这样规定的:

相等(相同)的对象必须具有相等的哈希码(或者散列码)。

  因为:HashMap不允许存放重复元素。

如果两个对象的hashCode相同,它们并不一定相同。

因为;A和B的哈希码相等,将A和B都存入HashMap时会发生哈希冲突,也就是A和B存放在HashMap内部数组的位置索引相同,这时HashMap会在该位置建立一个链接表,将A和B串起来放在该位置,

5.       对象类中  不重写hashCode和equlas,那么如果直接new A().不会重复,使用new方法创建对象,hashCode 不同;重解决方法:重写hashCode和equlas

 

 

toString

wait

notify/notifyAll

hashset

hashset中又是怎样判定元素是否重复

   1.判断两个对象的hashCode是否相等

             如果不相等,认为两个对象也不相等,完毕

  2.判断两个对象用equals运算是否相等
            如果不相等,认为两个对象也不相等
            如果相等,认为两个对象相等(equals()是判断两个对象是否相等的关键)

队列和栈

吃多了拉就是队列

吃多了吐就是栈

生产者消费者模式

1.       1)采用某种机制保护生产者和消费者之间的同步

2)在生产者和消费者之间建立一个管道

2. 同步机制保障数据完整性。

     1.加锁;2.采用信号。

(1)wait() / notify()方法

(2)await() / signal()方法

(3)BlockingQueue阻塞队列方法

(4)PipedInputStream / PipedOutputStream

3.  wait() / nofity()方法是基类Object的两个方法,也就意味着所有Java类都会拥有这两个方法,这样,我们就可以为任何对象实现同步机制。

wait()方法:当缓冲区已满/空时,生产者/消费者线程停止自己的执行,放弃锁,使自己处于等等状态,让其他线程执行。

notify()方法:当生产者/消费者向缓冲区放入/取出一个产品时,向其他等待的线程发出可执行的通知,同时放弃锁,使自己处于等待状态。

4.线程池。

 

 

==  equals

1.       比较的是引用地址

2.       Equals原始  比较引用地址

3.       重写equals,重写hashCode ,比较值,比较相似,不在比较绝对地址相等。

工具类

1.       工具类不能被实例化,所以必须加一个 无参私有构造方法。就new 不了。

2.       就可以用同一个对象直接调静态方法。

Final—不可变

1.       修饰类 方法 变量

2.       用final修饰的类不能被继承,即不能拥有自己的子类。

3.       修饰方法:方法不能被重写(可以重载多个final修饰的方法)。

但可以继承;

4.       修饰变量:变量不可以被更改,初始化一次。

5.       什么是immutable类,怎么写一个immutable类

不可变的咧。那些一旦被创建,它们的状态就不能被改变的Object--它不仅能够保证对象的状态不被改变,而且还可以不使用锁机制就能被其他线程共享。

例如:String Integer 以及其他包装类;java.lang.String 的trim,uppercase,substring等方法,它们返回的都是新的String对象,而并不是直接修改原来的对象

6.       Java中写出Immutable的类?

要写出这样的类,需要遵循以下几个原则:

1)immutable对象的状态在创建之后就不能发生改变,任何对它的改变都应该产生一个新的对象。

2)Immutable类的所有的属性都应该是final的。

3)对象必须被正确的创建,比如:对象引用在对象创建过程中不能泄露(leak)。

4)对象应该是final的,以此来限制子类继承父类,以避免子类改变了父类的immutable特性。

5)如果类中包含mutable类对象,那么返回给客户端的时候,返回该对象的一个拷贝,而不是该对象本身(该条可以归为第一条中的一个特例)

7.  使用Immutable类的好处:
1)Immutable对象是线程安全的,可以不用被synchronize就在并发环境中共享

2)Immutable对象简化了程序开发,因为它无需使用额外的锁机制就可以在线程间共享

3)Immutable对象提高了程序的性能,因为它减少了synchroinzed的使用

4)Immutable对象是可以被重复使用的,你可以将它们缓存起来重复使用,就像字符串字面量和整型数字一样。你可以使用静态工厂方法来提供类似于valueOf()这样的方法,它可以从缓存中返回一个已经存在的Immutable对象,而不是重新创建一个。

immutable也有一个缺点就是会制造大量垃圾,由于他们不能被重用而且对于它们的使用就是”用“然后”扔“,字符串就是一个典型的例子,它会创造很多的垃圾,给垃圾收集带来很大的麻烦。当然这只是个极端的例子,合理的使用immutable对象会创造很大的价值。

Static---全局

1.       静态导包

 然后直接调用方法名,不用再类名.方法名。

1.       static 修饰的变量 方法  静态块  可以在它的任何对象创建之前访问,无需引用任何对象

2.       类的所有实例共享同一个static变量

3.       static  private 表示只可以再本类使用。

4.       jvm只为静态分配一次内存空间。

   静态变量:被static修饰;实例变量:没被sttaic修饰,每创建一次实例变量,就分配一次内存。

5.       静态方法:不可以抽象,独立于任何实例,必须被实现。

6.       静态代码块:按代码顺序执行。

7.       Final static:全局常量。

String

 String类型和StringBuffer类型的主要性能区别在于String是不可变的对象

使用StringBuffer,特别是字符串对象经常改变的情况

StringBuilder是也是一个可变的字符序列,与StringBuffer的区别是不保证线程安全,用在字符串缓冲区单个线程使用的时候

集合

 

1.      集合 vs 数组

数组大小固定;同一个数组数据类型相同;

集合 可以存储各种数据类型,大小不定。

toArray();Arrays.asList();

2.      集合:

  List  set map;

  List.set 继承自collection;提供基于索引的对成员的随机访问

  Set 不允许重复,只能通过游标取值;HashSet TreeSet

  List 有序可有重复元素:arraylist linkedlist vector;vector线程安全。

  Map:key 不能重复,value重复:HashMap,treeMap,hashTable;table线程安全,

3.      hashMap用hash表实现的Map,就是利用对象的hashcode(hashcode()是Object的方法)进行快速散列查找.

4.       List(列表)、Set(保证集合中元素唯一)、Map(维护多个key-value键值对,保证key唯一)

5.      Collections.synchronized创建同步对象:synchronizedList

6.      ArrayList、Vector是线性表,不用考虑多线程时应使用ArrayList来提升效率。

Vector add方法上多了synchronized关键字

7. LinkedList是链表,略懂数据结构就知道其实现原理了。链表随机位置插入、删除数据时比线性表快,遍历比线性表慢。

8. Vector:

  线程安全

  当一个Iterator被创建而且正在被使用,另一个线程改变了 Vector的状态(例如,添加或删除了一些元素),这时调用Iterator的方法时将抛出 ConcurrentModificationException,因此必须捕获该异常。

9. Stack:Stack继承自Vector  栈

10.      Map 原理:

HashMap结构的实现原理是将put进来的key-value封装成一个Entry对象存储到一个Entry数组中,位置(数组下标)由key的哈希值与数组长度计算而来。如果数组当前下标已有值,则将数组当前下标的值指向新添加的Entry对象。

TreeMap是由Entry对象为节点组成的一颗红黑树,put到TreeMap的数据默认按key的自然顺序排序,new TreeMap时传入Comparator自定义排序

11.   Set结构其实就是维护一个Map来存储数据的,利用Map结构key值唯一性

HashSet、TreeSet分别默认维护一个HashMap、TreeMap。

12.  Itaretor迭代器。

13.  总结
  如果涉及到堆栈,队列等操作,应该考虑用List,

快速插入,删除元素,用LinkedList

快速随机访问元素,用ArrayList。
 单线程环境中,或者访问仅仅在一个线程中进行,考虑非同步的类,其效率较高,如果多个线程可能同时操作一个类,应该使用同步的类。
  要特别注意对哈希表的操作,作为key的对象要正确复写equals和hashCode方法。
  尽量返回接口而非实际的类型,这就是针对抽象编程。

   元素的数目 超出了内部数组目前的长度它们都需要扩展内部数组的长度,Vector缺省情况下自动增长原来一倍的数组长度,ArrayList是原来的50%,,要在集合中保存大量的数据那么使用Vector有一些优势

  ensureCapacity(int paramInt)用来初始化或者扩大ArrayList的空间比较有效率,速度快 list.ensureCapacity(N);  

14.  HashMap与TreeMap

        2、  HashMap通过hashcode对其内容进行快速查找,而TreeMap中所有的元素都保持着某种固定的顺序,如果你需要得到一个有序的结果你就应该 使用TreeMap(HashMap中元素的排列顺序是不固定的)。集合框架”提供两种常规的Map实现:HashMap和TreeMap (TreeMap实现SortedMap接口)。

         3、在Map 中插入、删除和定位元素,HashMap 是最好的选择。但如果您要按自然顺序或自定义顺序遍历键,那么TreeMap会更好。使用HashMap要求添加的键类明确定义了hashCode() equals()的实现。  这个TreeMap没有调优选项,因为该树总处于平衡状态。

     二树map一样,但顺序不一样,导致hashCode()不一样。
      同样做测试:
      在hashMap中,同样的值的map,顺序不同,equals时,false;
      而在treeMap中,同样的值的map,顺序不同,equals时,true,说明,treeMap在equals()时是整理了顺序了的。

hashtable与hashmap

一.历史原因:Hashtable是基于陈旧的Dictionary类的,HashMap是Java 1.2引进的Map接口的一个实现 ----接口实现不同

二.同步性:Hashtable是线程安全的,也就是说是同步的,而HashMap是线程序不安全的,不是同步的

三.值:只有HashMap可以让你将空值作为一个表的条目的key或value

HashMap具有较高的速度(查询),TreeMap则提供了按照键进行排序的功能。

   Hashtable的Key  value不可以为null

15.  HashMap的初始容量为0,每增加一对值,容量曾1

16.  面试 hashMap: 要查找数组中超过2/n的数

  用hashMap;将元素作为key,初始value=1;为出现的次数。

 

17.  arrayList基于下标;Linkedlist基于链表

18.  Linkedlist底层双向循环列表:一个数据data,2个指针,一个指向前一个节点,一个指向后一个节点。

19.  WeakHashMap多用于缓存系统,就是说在系统内存紧张的时候可随时进行GC,但是如果内存不紧张则可以用来存放一些缓存数据。因为如果使用HashMap的话,它里面的值基本都是强引用,即使内存不足,它也不会进行GC

20.  集合类有哪些:

  Colletion:  list                 set                    queue

Linkedlist  arraylist vector   sortedset hashSet        deque

                          treeSet   linkedHashSet

  Map:   hashMap            sortedmap    weakedHashMap  hashTable

        linkedHashMap        TreeMap

21. 1HashMapHashTable

      相同点:二者都实现了Map接口,因此具有一系列Map接口提供的方法。

      不同点:

            1、HashMap继承了AbstractMap,而HashTable继承了Dictionary。

            2、HashMap非线程安全,HashTable线程安全,到处都是synchronized关键字。

            3、因为HashMap没有同步,所以处理起来效率较高。

            4、HashMap键、值都允许为null,HashTable键、值都不允许有null。

            5、HashTable使用Enumeration,HashMap使用Iterator。

22. set接口和List接口

  相同点:都实现了Collection接口

    不同点: LIST保证顺序 可重复;set无序 不重复

1、 Set接口不保证维护元素的顺序,而且元素不能重复。List接口维护元素的顺序,而且元素可以重复

23.set如何保证不重复:底层HashMap存放数据,。利用Key的唯一性。Vector用synchrobized

23. TreeMapHashMap

     HashMap具有较高的速度(查询),TreeMap则提供了按照键进行排序的功能。

24. ArrayListVector

      同步性:Vector是线程安全的,也就是说是同步的,而ArrayList是线程序不安全的,不是同步的。

      数据增长:当需要增长时,Vector默认增长为原来一培,而ArrayList却是原来的一半

25. 集合排序
Collections还提供了集中对集合进行排序的方法。
reverse——对List中的元素进行转置

shuffle——对List中的元素随即排列

sort——对List中的元素排序
swap——交换List中某两个指定下标位元素在集合中的位置。
rotate——循环移动

26. Java中数据存储方式最底层的两种结构,一种是数组,另一种就是链表

   数组查找快;链表空间不连续,增删快;哈希表增删快,查找快

   哈希表:出事容量  16;

27. ConcurrentHashMap基于concurrentLevel划分出了多个Segment来对key-value进行存储,从而避免每次锁定整个数组,在默认的情况下,允许16个线程并发无阻塞的操作集合对象,尽可能地减少并发时的阻塞现象。ReentrantLock

28. 数组没有length()这个方法,有length的属性。String有有length()这个方法。

1. hashCode和equal()是HashMap用的, 因为无需排序所以只需要关注定位和唯一性即可.

   a. hashCode是用来计算hash值的,hash值是用来确定hash表索引的.

   b. hash表中的一个索引处存放的是一张链表, 所以还要通过equal方法循环比较链上的每一个对象 才可以真正定位到键值对应的Entry.

   c. put时,如果hash表中没定位到,就在链表前加一个Entry,如果定位到了,则更换Entry中的value,并

2. Java中Collection和Collections的区别

①java.util.Collection 是一个集合接口,它提供了对集合对象进行基本操作的通用接口方法。java.util.Collections 是一个包装类。

②它包含有各种有关集合操作的静态多态方法。此类不能实例化,就像一个工具类,服务于Java的Collection框架。

3. 一个集合可以放任何类型的对象,相应地从集合里面拿对象的时候我们也不得不对他们进行强制得类型转换。

 

 

 

排序 以及复杂度

1.       SortedSetSortedMap排序

2.       插入排序、选择排序、冒泡排序、快速排序(重点)、堆排序、归并排序

3.      

4.        

     时间复杂度:主要是分析关键字的比较次数和记录的移动次数。

        空间复杂度:分析排序算法中需要多少辅助内存

        稳定性:若两个记录A和B的关键字值相等,但排序后A、B的先后次序保持不变,则称这种算法是稳定的

直接选择排序((n*n))

1.       其关键就是对n个数据要进行n-1趟比较,每趟比较的目的就是选择出本趟比较中最小的数据,并将选择出的数据放在本趟中的第一位。(每一位跟后面的数比较,然后交换位置,将最小的放在该位置上,该数放在替换的数上,然后继续下一轮比较)

2.       稳定性; 由于每次都是选取未排序序列A中的最小元素x与A中的第一个元素交换,因此跨距离了,很可能破坏了元素间的相对位置,因此选择排序是不稳定的

 

直接插入排序(n---n*n)

1. 依次将带排序的数据元素按其关键字排序的大小插入前面的有序序列。

2. 稳定性;在插入排序中,K1是已排序部分中的元素,当K2和K1比较时,直接插到K1的后面;是稳定的

 

冒泡排序(n---n*n)

1.       两两比较相邻记录的关键码,小的往前放,

2.复杂度:最好情况下:正序有序,则只需要比较n次。故,为O(n)  
      最坏情况下 逆序有序,则需要比较(n-1)+(n-2)+……+1,故,为O(N*N)

3.稳定性:排序过程中只交换相邻两个元素的位置。因此,当两个数相等时,是没必要交换两个数的位置的。所以,它们的相对位置并没有改变,冒泡排序算法是稳定的

4. 代码实例:

  

快速排序(nlgn)(10的K次方等于n的n次方)

1.       交换排序

2.       最核心的思想是将小的部分放在左边,大的部分放到右边,实现分割。。然后对这两部分分别进行快速排序,整个排序是一个递归调用的过程,最终实现整个序列有序。

3.       时间复杂度:最好的情况下:因为每次都将序列分为两个部分(一般二分都复杂度都和logN相关),故为 O(N*logN)  
      最坏的情况下:基本有序时,退化为冒泡排序,几乎要比较N*N次,故为O(N*N)

4.       稳定性:由于每次都需要和中轴元素交换,因此原来的顺序就可能被打乱。所以不稳定

5.       逻辑

 

代码:

 

 

堆排序(nlgn)

归并排序(nlgn)

二分查找(log(n))

算法思想】首先,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功;否则利用中间位置记录将表分成前、后两个子表,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表。

重复以上过程,直到找到满足条件的记录,使查找成功,或直到子表不存在为止,此时查找不成功。

 

 

序列化

1.      用于:加密 持久化;

2.      (序列化)数据结构、对象 <->二进制数据(饭序列化)

3.      序列化的位二进制串存储在内存中

4.      形式:soap  xml  json

5.      序列化用途:网络传输只能是字节序列。

1.      把对象的字节序列永久地保存到硬盘上,通常存放在一个文件中

2.      在网络上传送对象的字节序列。

6.      输出流:写  序列化;

如果一个类实现了Externalizable接口,那么将完全由这个类控制自身的序列化行为。

实现Serializable接口的类都有一个表示序列化版本标识符的静态变量,默认序列化方式

hashMap原理

1.      能够快速定位元素,能够自动扩充容量

快速定位元素属于算法数据结构的范畴,通常情况下哈希(Hash)算法是一种简单可行的算法。所谓哈希算法,是将任意长度的二进制值映射为固定长度的较小二进制值。常见的MD2,MD4,MD5,SHA-1等都属于Hash算法的范畴。由于将一个较大的集合映射到一个较小的集合上,所以必然就存在多个元素映射到同一个元素上的结果,这个叫“碰撞”。

rehash过程:一个元素映射到了某个位置,现在一旦扩充了容量,也就意味着元素映射的位置需要变化。因为对于Hash算法来说,调整了映射的小集合,那么原来映射的路径肯定就不复存在,那么就需要对现有重新计算映射路径

2.hashMap解决碰撞: (链表插入和删除;数组:查找)

             同一个索引的数组元素组成一个链表,查找允许时循环链表找到需要的元素。

           尽可能的将元素均匀的分布在数组上。

    3. loadFactor的默认值0.75和capacity的默认值16是经过大量的统计分析得出

    4. 可以看到扩充过程会导致元素数据的所有元素进行重新hash计算,这个过程也叫rehash。显然这是一个非常耗时的过程,否则扩容都会导致所有元素重新计算hash。因此尽可能的选择合适的初始化大小是有效提高HashMap效率的关键。太大了会导致过多的浪费空间,太小了就可能会导致繁重的rehash过程。在这个过程中loadFactor也可以考虑。

 

Comparable和Comparator

垃圾回收

1.      Java不用直接操作内存,通过jvm虚拟机来实现。

2.     

jvm虚拟机栈:一个是线程独有的,每次启动一个线程,就创建一个jvm虚拟机栈,线程退出的时候就销毁。这里面主要保存线程本地变量名和局部变量值。

本地方法栈: 调用本地jni方法的时候而创建的。这里分配的jvm之外的内存空间。方法调用结束之后销毁

堆:主要保存创建的对象。

方法区:保存class相关的信息。主要是class的一个内存结构信息

常量池:方法区的一部分,主要保存class内存结构中常量值 例如String值,public static final 类型的值

3.   jvm如何回收

引用计数法:

每个对象上都有一个引用计数,对象每被引用一次,引用计数器就+1,对象引用被释放,引用计数器-1,直到对象的引用计数为0,对象就标识可以回收---循环引用的对象不会回收

root搜索算法:

          如果对象能够达到root,就不会被回收,如果对象不能够达到root,就会被回收。  -----强引用(new A)

Java内存模型  和GC

1.      意义:

JVM主要管理两种类型内存:堆和非堆,堆内存(Heap Memory)是在 Java 虚拟机启动时创建,非堆内存(Non-heap Memory)是在JVM堆之外的内存。堆是Java代码可及的内存,留给开发人员使用的;非堆是JVM留给自己用的,包含方法区、JVM内部处理或优化所需的内存(如 JIT Compiler,Just-in-time Compiler,即时编译后的代码缓存)、每个类结构(如运行时常数池、字段和方法数据)以及方法和构造方法的代码。

2.      Java的内存管理实际上就是变量和对象的管理,其中包括对象的分配和释放。

3.      创建对象时,GC就开始监控这个对象的地址、大小以及使用情况。

GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是"可达的",哪些对象是"不可达的".当GC确定一些对象为"不可达"时,GC就有责任回收这些内存空间。但是,为了保证 GC能够在不同平台实现的问题,Java规范对GC的很多行为都没有进行严格的规定。例如,对于采用什么类型的回收算法、什么时候进行回收等重要问题都没有明确的规定。因此,不同的JVM的实现者往往有不同的实现算法。(不可达:对象所有引用赋值为null)

4.       Finalize:内存回收(回收对象)

  在finalize运行完成之后,该对象可能变成可达的,GC还要再检查一次该对象是否是可达的。因此,使用 finalize会降低GC的运行性能。finalize用于一些不容易控制、并且非常重要资源的释放,例如一些I/O的操作,数据的连接。这些资源的释放对整个应用程序是非常关键的。

finalize() 是一个用于释放非 Java 资源的方法。但是,JVM 有很大的可能不调用对象的finalize() 方法,因此很难证明使用该方法释放资源是有效的。

但没法保证何时调  和是否会运行

5.      GC优化

 尽早释放无用对象的引用。复制为null;

 少用finalize函数-----加大GC工作量

集合数据类型,包括数组,树,图,链表等数据结构,GC回收更为复杂。

全局的变量,静态变量。造成内存浪费。

(堆里放  对象+数组)数组是对象 在堆里 
基础数据类型直接在栈空间stack分配

Socket—套接字

HTTP  VS  REST

1.       RestTemplate简化HTTP服务器通信,处理HTTP连接,使应用程序代码通过提供url和响应类型(可能的模板变量)便可提取结果。

2.    

3.    

4.       以上为post  get 请求

异步:AsyncRestTemplate

5.        AsyncRestTemplate是在Spring4.0中对RestTemplate进行扩展产生的新类,其为客户端提供了异步http请求处理的一种机制,通过返回ListenableFuture对象生成回调机制,以达到异步非阻塞发送http请求。 

数据结构

1.       索引  主要适用的数据结构:树、BTree索引

2.       Collections.sort()使用的排序:timeSort 增强型的归并排序

1.       LinkedList
LinkedList是采用双向循环链表实现的。
利用LinkedList实现栈(stack)、队列(queue)、双向队列(double-ended queue )。
它具有方法addFirst()、addLast()、getFirst()、getLast()、removeFirst()、removeLast()等。

用LinkedList实现队列:
队列(Queue)是限定所有的插入只能在表的一端进行,而所有的删除都在表的另一端进行的线性表。
表中允许插入的一端称为队尾(Rear),允许删除的一端称为队头(Front)。
队列的操作是按先进先出(FIFO)的原则进行的。
队列的物理存储可以用顺序存储结构,也可以用链式存储结构。

用LinkedList实现栈:
栈(Stack)也是一种特殊的线性表,是一种后进先出(LIFO)的结构。
栈是限定仅在表尾进行插入和删除运算的线性表,表尾称为栈顶(top),表头称为栈底(bottom)。
栈的物理存储可以用顺序存储结构,也可以用链式存储结构。

2.       集合是一个保存其他对象的对象
Collection接口除了实现映射的集合类之外的所有集合类定义了一些方法
List集合类型描述了一种按位置存储数据的对象,有序的。
ArrayList是一种在内存连续区域 中存储数据的通用数组

3.       HashMap实现原理---散列
Hash哈希算法的意义在于提供了一种快速存取数据的方法,它用一种算法建立键值与真实值之间的对应关系。散列表又称为哈希表。散列表算法的基本思想是:以结点的关键字为自变量,通过一定的函数关系(散列函数)计算出对应的函数值,以这个值作为该结点存储在散列表中地址。
当散列表中的元素存放太满,就必须进行再散列,将产生一个新的散列表,所有元素存放到新的散列表中,原先的散列表将被删除。在Java语言中,通过负载因子(load factor)来决定何时对散列表进行再散列。例如:如果负载因子0.75,当散列表中已经有75%位置已经放满,那么将进行再散列。
负载因子越高(越接近1.0),内存的使用效率越高,元素的寻找时间越长。负载因子越低(越接近0.0),元素的寻找时间越短,内存浪费越多。

4.       TreeMap中是根据键(Key)进行排序的。而如果我们要使用TreeMap来进行正常的排序的话,Key 中存放的对象必须实现Comparable 接口。

5.       HashSet如何过滤重复元素
调用元素HashCode获得哈希码--》判断哈希码是否相等,不相等则录入
---》相等则判断equals()后是否相等,不相等在进行 hashcode录入,相等不录入

本文转载自:

流鱼不乖
粉丝 1
博文 22
码字总数 2491
作品 0
南京
私信 提问
Java培训实战教程之Java基础知识精华部分(一)(二)(三)

Java培训实战教程之Java基础知识精华部分(一)_java概述 =============================================================================Java培训实战教程之Java基础知识精华部分(一)_java概...

黑泽明军
2018/04/13
0
0
安卓开发必备知识体系:Java篇

大家好我是张拭心,自从各位朋友帮点广X开始,我发现我每天更有奔头了,走起路来也更有劲了,说啥也得更新的勤快一点。不过放心,我一定推送有价值的内容给大家,还请朋友们照旧动动手指点点...

d29h1jqy3akvx
2018/05/10
0
0
个人整理的学习Android步骤

嫌字多废话多,看加粗字体就行 学习Android就一定要学习Java,为什么呢?没有Java基础的话,你会觉得一些东西看着不难但是很陌生,抓不准。所以说,第一步就是先简单看一下Java知识点 等你有...

牛板腩天下第一
2018/02/20
0
0
BAT等大厂Android面试书单和知识点清单

java是Android开发的基础,在BAT的初面中,会涉及到比较多的java基础知识,所以比较重要,下面我介绍的书籍内容是由浅到深。 1.Thinking in java:这本书被称为Java的三大圣经之一,虽然书比...

android自学
2018/07/25
0
0
你必须掌握的 21 个 Java 核心技术!(干货)

点击上方“java进阶架构师”,选择右上角“置顶公众号” 20大进阶架构专题每日送达 51闲来无事,师长一向不(没)喜(有)欢(钱)凑热闹,倒不如趁着这时候复盘复盘。而写这篇文章的目的是想...

Java进阶架构师
05/03
0
0

没有更多内容

加载失败,请刷新页面

加载更多

《Designing.Data-Intensive.Applications》笔记 四

第九章 一致性与共识 分布式系统最重要的的抽象之一是共识(consensus):让所有的节点对某件事达成一致。 最终一致性(eventual consistency)只提供较弱的保证,需要探索更高的一致性保证(stro...

丰田破产标志
今天
4
0
docker 使用mysql

1, 进入容器 比如 myslq1 里面进行操作 docker exec -it mysql1 /bin/bash 2. 退出 容器 交互: exit 3. mysql 启动在容器里面,并且 可以本地连接mysql docker run --name mysql1 --env MY...

之渊
今天
6
0
python数据结构

1、字符串及其方法(案例来自Python-100-Days) def main(): str1 = 'hello, world!' # 通过len函数计算字符串的长度 print(len(str1)) # 13 # 获得字符串首字母大写的...

huijue
今天
4
0
OSChina 周日乱弹 —— 我,小小编辑,食人族酋长

Osc乱弹歌单(2019)请戳(这里) 【今日歌曲】 @宇辰OSC :分享娃娃的单曲《飘洋过海来看你》: #今日歌曲推荐# 《飘洋过海来看你》- 娃娃 手机党少年们想听歌,请使劲儿戳(这里) @宇辰OSC...

小小编辑
今天
989
11
MongoDB系列-- SpringBoot 中对 MongoDB 的 基本操作

SpringBoot 中对 MongoDB 的 基本操作 Database 库的创建 首先 在MongoDB 操作客户端 Robo 3T 中 创建数据库: 增加用户User: 创建 Collections 集合(类似mysql 中的 表): 后面我们大部分都...

TcWong
今天
40
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部