八达博客
0%

发表于 更新于 分类于
本文字数： 943 阅读时长 ≈ 1 分钟

元素有序且不能重复。

1
2
3
4
5
6
7
8
9
10
11
/**
    * 实现 Cloneable 接口
    *          这个类是 java.lang.Cloneable，前面我们讲解深拷贝和浅拷贝的原理时，
    *          我们介绍了浅拷贝可以通过调用 Object.clone() 方法来实现，
    *          但是调用该方法的对象必须要实现 Cloneable 接口，
    *          否则会抛出 CloneNoSupportException异常。
    * 实现 Serializable 接口
    *          序列化
    */
    public class LinkedHashSet<E> extends HashSet<E> implements Set<E>,
    Cloneable,java.io.Serializable{}

看上面似乎LinkedHashSet 是由HashSet实现的集合，其实是LinkedHashMap实现的。从下面的构造方法即可看出。

构造方法

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
 /**
  * 依然是提供三种构造方法，实现都是super方法，下面我们看看是怎么实现的 
  */
public LinkedHashSet() {
     super(16, .75f, true);
 }
 
public LinkedHashSet(Collection<? extends E> c) {
     super(Math.max(2*c.size(), 11), .75f, true);
     addAll(c);
 }
 
 public LinkedHashSet(int initialCapacity) {
     super(initialCapacity, .75f, true);
 }
 
 
 /**
  * 之前还疑惑这里dummy为啥没用，原来是为了用到这里做区分的
  * 明显看出看出LinkedHashSet 是由LinkedHashMap实现的集合
  */
 HashSet(int initialCapacity, float loadFactor, boolean dummy) {
     map = new LinkedHashMap<>(initialCapacity, loadFactor);
 }

其他方法基本都可以看HashSet了

发表于 更新于 分类于
本文字数： 6k 阅读时长 ≈ 5 分钟

LinkedHashMap 是基于 HashMap实现的一种集合，有序，它单独维护了一个具有所有数据的双向链表，该链表保证了元素迭代的顺序。

1
2
3
4
/**
 * 继承HashMap，实现Map
 */
public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>{}

成员变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
    * 双向链表头
    */
   transient LinkedHashMap.Entry<K,V> head;

   /**
    * 双向链表尾
    */
   transient LinkedHashMap.Entry<K,V> tail;

   /**
    * 决定迭代排序方法：true是根据访问顺序来排序，false是根据插入顺序来排序
    */
   final boolean accessOrder;

构造函数

4种构造方法，都用HaspMap的实现方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public LinkedHashMap() {
    super();
    accessOrder = false;
}

public LinkedHashMap(int initialCapacity) {
    super(initialCapacity);
    accessOrder = false;
}
public LinkedHashMap(int initialCapacity, float loadFactor) {
    super(initialCapacity, loadFactor);
    accessOrder = false;
}

public LinkedHashMap(int initialCapacity,
                     float loadFactor,
                     boolean accessOrder) {
    super(initialCapacity, loadFactor);
    this.accessOrder = accessOrder;
}
阅读全文 »

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

HashSet 是一个由 HashMap 实现的集合，元素无序且不能重复。
其方法基本都是HashMap的方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
    * 继承 AbstractSet
    *          AbstractSet也是实现了Set接口的，跟HashMap一个毛病，脱裤子放屁....
    * 实现 Set 接口
    *          这个接口是 Set 类集合的上层接口，定义了实现该接口的类都必须要实现的一组方法
    * 实现 Cloneable 接口
    *          这个类是 java.lang.Cloneable，前面我们讲解深拷贝和浅拷贝的原理时，
    *          我们介绍了浅拷贝可以通过调用 Object.clone() 方法来实现，
    *          但是调用该方法的对象必须要实现 Cloneable 接口，
    *          否则会抛出 CloneNoSupportException异常。
    * 实现 Serializable 接口
    *          序列化
    */
   public class HashSet<E> extends AbstractSet<E>
   implements Set<E>, Cloneable, java.io.Serializable{}

成员变量

1
2
3
4
5
6
7
8
/**
 * 就是一个HashMap，说明靠这个来存储数据了
 */
  private transient HashMap<E,Object> map;
/**
 * 向HashSet中添加数据，数据在上面的 map 结构是作为 key 存在的，而value统一都是 PRESENT
 */
private static final Object PRESENT = new Object();
阅读全文 »

发表于 更新于 分类于
本文字数： 24k 阅读时长 ≈ 21 分钟

基本知识

Hash表也称为散列表，也有直接译作哈希表，Hash表是一种根据关键字值（key-value）而直接进行访问的数据结构。也就是说它通过把关键码值映射到表中的一个位置来访问记录，以此来加快查找的速度。在链表、数组等数据结构中，查找某个关键字，通常要遍历整个数据结构，也就是O(N)的时间级，但是对于哈希表来说，只是O(1)的时间级。（更多知识自行百度Google）

HashMap是一个利用哈希表原理来存储元素的无序不安全键值都可为空的集合。遇到冲突时，HashMap 是采用的链地址法来解决，在 JDK1.7 中，HashMap 是由 数组+链表构成的。但是在JDK1.8中，HashMap是由数组+链表+红黑树构成，新增了红黑树作为底层数据结构，结构变得复杂了，但是效率也变的更高效。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
 * 继承 AbstractMap
 *          AbstractMap也是实现了Map类的，既继承AbstractMap又实现Map，脱裤子放屁....
 * 实现 Map 接口
 *          这个接口是 Map 类集合的上层接口，定义了实现该接口的类都必须要实现的一组方法
 * 实现 Cloneable 接口
 *          这个类是 java.lang.Cloneable，前面我们讲解深拷贝和浅拷贝的原理时，
 *          我们介绍了浅拷贝可以通过调用 Object.clone() 方法来实现，
 *          但是调用该方法的对象必须要实现 Cloneable 接口，
 *          否则会抛出 CloneNoSupportException异常。
 * 实现 Serializable 接口
 *          序列化
 */
public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {}
阅读全文 »

发表于 更新于 分类于
本文字数： 316 阅读时长 ≈ 1 分钟

假设没有虚拟机！

vm安装centos7

redis的操作

  • 下载忽略，下载到/usr/local

  • 进到redis根目录，yum install gcc，下载gcc，然后make MALLOC=libc

  • 进入src, make install

  • 回到根目录，vi redis.conf

    1、注释bind 127.0.0.1或一些bind相关的
    2、修改protected-mode=no，开放外界访问redis
    3、daemonize属性改为yes，表明需要在后台运行

  • 防火墙的处理

    停止使用firewall
    systemctl stop firewalld.service
    禁止在开机启动
    systemctl disable firewalld.service docker ps

  • 安装结束

发表于 更新于 分类于
本文字数： 377 阅读时长 ≈ 1 分钟

查看内存使用情况

free -g

当观察到free栏已为0的时候，表示内存基本被吃完了，那就释放内存吧

查看磁盘使用情况

df -h

当发现磁盘使用率很高时，那就要释放磁盘空间了，删除一些不必要的文件（查看各个目录占用磁盘空间，参考之前的du命令文章）

阅读全文 »

发表于 更新于 分类于
本文字数： 7.7k 阅读时长 ≈ 7 分钟

　LinkedList 是一个用链表实现的集合，元素有序且可以重复。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
 * 实现 List 接口
 *          这个接口是 List 类集合的上层接口，定义了实现该接口的类都必须要实现的一组方法
 * 实现 Deque 接口
 *          这是一个双向队列接口，双向队列就是两端都可以进行增加和删除操作。
 * 实现 Cloneable 接口
 *          这个类是 java.lang.Cloneable，前面我们讲解深拷贝和浅拷贝的原理时，
 *          我们介绍了浅拷贝可以通过调用 Object.clone() 方法来实现，
 *          但是调用该方法的对象必须要实现 Cloneable 接口，
 *          否则会抛出 CloneNoSupportException异常。
 * 实现 Serializable 接口
 *          序列化
 */
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{}

成员变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
 * 链表的个数，也就是集合的大小吧
 */
transient int size = 0;

/**
 * 链表的头
 */
transient Node<E> first;

/**
 * 链表的尾
 */
transient Node<E> last;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 /**
  * 链表的类
  */
private static class Node<E> {
     // 存的值
     E item;
     // 指向下一个节点的引用
     Node<E> next;
     // 指向上一个节点的引用
     Node<E> prev;

     Node(Node<E> prev, E element, Node<E> next) {
         this.item = element;
         this.next = next;
         this.prev = prev;
     }
 }

阅读全文 »

发表于 更新于 分类于
本文字数： 7k 阅读时长 ≈ 6 分钟

ArrayList 是一个用数组实现的集合，支持随机访问，元素有序且可以重复。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
 * 实现 List 接口
 *          这个接口是 List 类集合的上层接口，定义了实现该接口的类都必须要实现的一组方法
 * 实现 RandomAccess 接口
 *          这是一个标记接口，一般此标记接口用于 List 实现，
 *          以表明它们支持快速（通常是恒定时间）的随机访问。
 *          该接口的主要目的是允许通用算法改变其行为，
 *          以便在应用于随机或顺序访问列表时提供良好的性能
 * 实现 Cloneable 接口
 *          这个类是 java.lang.Cloneable，前面我们讲解深拷贝和浅拷贝的原理时，
 *          我们介绍了浅拷贝可以通过调用 Object.clone() 方法来实现，
 *          但是调用该方法的对象必须要实现 Cloneable 接口，
 *          否则会抛出 CloneNoSupportException异常。
 * 实现 Serializable 接口
 *          序列化
 */
public class ArrayList<E> extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{}

成员变量

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
/**
 * 默认初始大小.
 */
private static final int DEFAULT_CAPACITY = 10;

/**
 * 用于空实例的共享空数组实例。
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * 共享空数组实例，用于默认大小的空实例。我们将其与空元素数据区分开来，
 * 以了解添加第一个元素时要加多少量。
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
 * 存储集合元素的数组缓冲区。集合的容量是这个数组缓冲区的长度。
 * 任何带有elementdata==DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空集合
 * 将在添加第一个元素时扩展为默认容量。
 */
transient Object[] elementData;

/**
 * 集合大小
 */
private int size;

阅读全文 »

发表于 更新于 分类于
本文字数： 80k 阅读时长 ≈ 1:13

源码的类注释：This class contains various methods for manipulating arrays (such as sorting and searching). This class also contains a static factory that allows arrays to be viewed as lists.
可见这就是一个处理数组的类，直接研究含有的方法。

asList

1
2
3
4
5
6
 /**
  * 就是数组转换成List集合
  */
public static <T> List<T> asList(T... a) {
     return new ArrayList<>(a);
 }
阅读全文 »

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

FROM指令

    脚本的第1行是FROM指令。通过FROM指令，docker编译程序能够知道在哪个基础镜像执行来进行编译。所有的Dockerfile都必须以FROM指令开始。

1
FROM devops-reg.io/public/openjdk:8

MAINTAINER指令

    第二条指令MAINTAINER，用来标明这个镜像的维护者信息。

1
#MAINTAINER xxxx@qq.com

RUN指令

    接下来是RUN指令。这条指令用来在docker的编译环境中运行指定命令。上面这条指令会在编译环境运行/bin/sh -c “apt-get update && apt-get -y install …”。RUN指令还有另外一种格式：

1
RUN ["程序名", "参数1", "参数2"]
阅读全文 »