红 ♬ 枫叶
红 ♬ 枫叶

13分钟了解Java容器

13分钟了解Java容器_第1张图片

13分钟了解Java容器_第2张图片

List

Vector

采用Object数组存储元素

protected Object[] elementData;

Stack

Stack继承了Vector，采用Object数组存储元素

ArrayList

顾名思义，ArrayList底层采用数组存储元素

Object[] elementData;

LinkedList

顾名思义，LinkedList底层采用链表存储元素。通过first和last指针分别指向头元素和尾元素。

/**
 * Pointer to first node.
 * Invariant: (first == null && last == null) ||
 *            (first.prev == null && first.item != null)
 */
transient Node first;
/**
 * Pointer to last node.
 * Invariant: (first == null && last == null) ||
 *            (last.next == null && last.item != null)
 */
transient Node last;

其中Node是LinkedList自定义的静态类，通过next和prev指针分别指向后驱节点和前驱节点。因此LinkedList底层是通过first和last指针分别指向头元素和尾元素的双向链表。

private static class Node {
    E item;
    Node next;
    Node prev;
    Node(Node prev, E element, Node next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

CopyOnWriteArrayList

顾名思义，CopyOnWriteArrayList底层是通过Object[] 数组存储数据，提供的构造方法在初始化时自动创建了长度为0的数组。

/** The array, accessed only via getArray/setArray. */
private transient volatile Object[] array;
/**
 * Creates an empty list.
 */
public CopyOnWriteArrayList() {
    setArray(new Object[0]);
}

CopyOnWrite的逻辑大体上都是在插入数据的时候，重新复制一份数组，在新数组中插入新数据，之后将指针指向新的数组。这种模式主要是为了针对“改动操作很少，主要是读操作”的业务。CopyOnWriteArrayList一样，在操作数据时通过ReentrantLock锁住防止并发之后，复制原数组再在新数组中操作数据，最后将指针指向新数组。

  • 相关代码
public E set(int index, E element) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        E oldValue = get(elements, index);

        if (oldValue != element) {
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len);
            newElements[index] = element;
            setArray(newElements);
        } else {
            // Not quite a no-op; ensures volatile write semantics
            setArray(elements);
        }
        return oldValue;
    } finally {
        lock.unlock();
    }
}

public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

public E remove(int index) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        E oldValue = get(elements, index);
        int numMoved = len - index - 1;
        if (numMoved == 0)
            setArray(Arrays.copyOf(elements, len - 1));
        else {
            Object[] newElements = new Object[len - 1];
            System.arraycopy(elements, 0, newElements, 0, index);
            System.arraycopy(elements, index + 1, newElements, index,
                             numMoved);
            setArray(newElements);
        }
        return oldValue;
    } finally {
        lock.unlock();
    }
}

Map

HashTable

HashTable底层通过Entry数组存储元素，

private transient Entry[] table;
  • 其中Entry类型为HashTable自定义的数据结构，内部记录了元素的hash值，key，value，以及下一节点的指针next。
private static class Entry implements Map.Entry {
    final int hash;
    final K key;
    V value;
    Entry next;
    protected Entry(int hash, K key, V value, Entry next) {
        this.hash = hash;
        this.key =  key;
        this.value = value;
        this.next = next;
    }
    @SuppressWarnings("unchecked")
    protected Object clone() {
        return new Entry<>(hash, key, value,
                              (next==null ? null : (Entry) next.clone()));
    }
    // Map.Entry Ops
    public K getKey() {
        return key;
    }
    public V getValue() {
        return value;
    }
    public V setValue(V value) {
        if (value == null)
            throw new NullPointerException();
        V oldValue = this.value;
        this.value = value;
        return oldValue;
    }
    public boolean equals(Object o) {
        if (!(o instanceof Map.Entry))
            return false;
        Map.Entry e = (Map.Entry)o;
        return (key==null ? e.getKey()==null : key.equals(e.getKey())) &&
           (value==null ? e.getValue()==null : value.equals(e.getValue()));
    }
    public int hashCode() {
        return hash ^ Objects.hashCode(value);
    }
    public String toString() {
        return key.toString()+"="+value.toString();
    }
}

HashMap

HashMap底层通过 Node数组存储元素

transient Node[] table;
  • 其中Node是HashMap自定义的数据结构，内部记录了元素的hash值，key，value，以及下一节点的指针next。
static class Node implements Map.Entry {
    final int hash;
    final K key;
    V value;
    Node next;
    Node(int hash, K key, V value, Node next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }
    public final K getKey()        { return key; }
    public final V getValue()      { return value; }
    public final String toString() { return key + "=" + value; }
    public final int hashCode() {
        return Objects.hashCode(key) ^ Objects.hashCode(value);
    }
    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }
    public final boolean equals(Object o) {
        if (o == this)
            return true;
        if (o instanceof Map.Entry) {
            Map.Entry e = (Map.Entry)o;
            if (Objects.equals(key, e.getKey()) &&
                Objects.equals(value, e.getValue()))
                return true;
        }
        return false;
    }
}

当元素hash相同时，元素会通过链表的形式通过next指针相连。在JDK1.8之后，当满足一定条件后，链表会转化为红黑树，此时，元素会从Node类型转化为TreeNode类型。

  • TreeNode为HashMap自定义的数据结构，内部记录父节点parent，左右孩子left，right，颜色标志red已经同级前驱节点prev
static final class TreeNode extends LinkedHashMap.Entry {
    TreeNode parent;  // red-black tree links
    TreeNode left;
    TreeNode right;
    TreeNode prev;    // needed to unlink next upon deletion
    boolean red;
    TreeNode(int hash, K key, V val, Node next) {
        super(hash, key, val, next);
    }
    ......
 }

具体的操作逻辑可以参考：[[HashMap]]

LinkedHashMap

LinkedHashMap继承了HashMap的逻辑，只不过添加了Entry结构。以及head，tail首尾指针。

static class Entry extends HashMap.Node {
    Entry before, after;
    Entry(int hash, K key, V value, Node next) {
        super(hash, key, value, next);
    }
}
private static final long serialVersionUID = 3801124242820219131L;
/**
 * The head (eldest) of the doubly linked list.
 */
transient LinkedHashMap.Entry head;
/**
 * The tail (youngest) of the doubly linked list.
 */
transient LinkedHashMap.Entry tail;

Entry中保存了before和after指针，指向上一个插入元素Entry以及后一个插入元素Entry。以数组+红黑树+元素链表+插入顺序链表的形式存储数据。

ConcurrentHashMap

ConcurrentHashMap底层通过Node数组存储数据

transient volatile Node[] table;
  • 其中Node是ConcurrentHashMap自定义的数据结构，内部记录了元素的hash值，key，value，以及下一节点的指针next。
static class Node implements Map.Entry {
      final int hash;
      final K key;
      volatile V val;
      volatile Node next;
      Node(int hash, K key, V val, Node next) {
          this.hash = hash;
          this.key = key;
          this.val = val;
          this.next = next;
      }
      public final K getKey()       { return key; }
      public final V getValue()     { return val; }
      public final int hashCode()   { return key.hashCode() ^ val.hashCode(); }
      public final String toString(){ return key + "=" + val; }
      public final V setValue(V value) {
          throw new UnsupportedOperationException();
      }
      public final boolean equals(Object o) {
          Object k, v, u; Map.Entry e;
          return ((o instanceof Map.Entry) &&
                  (k = (e = (Map.Entry)o).getKey()) != null &&
                  (v = e.getValue()) != null &&
                  (k == key || k.equals(key)) &&
                  (v == (u = val) || v.equals(u)));
      }
      /**
       * Virtualized support for map.get(); overridden in subclasses.
       */
      Node find(int h, Object k) {
          Node e = this;
          if (k != null) {
              do {
                  K ek;
                  if (e.hash == h &&
                      ((ek = e.key) == k || (ek != null && k.equals(ek))))
                      return e;
              } while ((e = e.next) != null);
          }
          return null;
      }
  }

当元素hash相同时，元素会通过链表的形式通过next指针相连。在JDK1.8之后，当满足一定条件后，链表会转化为红黑树，此时，table数组中的Node 元素会转化为TreeBin类型，TreeBin类型记录了由TreeNode构成红黑树的根节点root。

  • TreeBin有ConcurrentHashMap自定义，继承了Node类型。存放了下辖红黑树的根节点root。
static final class TreeBin extends Node {
    TreeNode root;
    volatile TreeNode first;
    volatile Thread waiter;
    volatile int lockState;
    // values for lockState
    static final int WRITER = 1; // set while holding write lock
    static final int WAITER = 2; // set when waiting for write lock
    static final int READER = 4; // increment value for setting read lock
    ......
}
  • TreeNode由ConcurrentHashMap自定义，跟HashMap的TreeNode类似，但是ConcurrentHashMap的TreeNode继承自Node类型。
static final class TreeNode extends Node {
    TreeNode parent;  // red-black tree links
    TreeNode left;
    TreeNode right;
    TreeNode prev;    // needed to unlink next upon deletion
    boolean red;
    TreeNode(int hash, K key, V val, Node next,
             TreeNode parent) {
        super(hash, key, val, next);
        this.parent = parent;
    }
    ......
}

具体的操作逻辑可以参考：[[ConcurrentHashMap]]

TreeMap

TreeMap 通过Entry存储数据，底层是以红黑树的逻辑结构存储。

private transient Entry root;
  • Entry是TreeMap自定义的数据结构，其中包含key，value，左右子树left，right，以及父节点parent，和标记颜色的color；
static final class Entry implements Map.Entry {
      K key;
      V value;
      Entry left;
      Entry right;
      Entry parent;
      boolean color = BLACK;
      /**
       * Make a new cell with given key, value, and parent, and with
       * {@code null} child links, and BLACK color.
       */
      Entry(K key, V value, Entry parent) {
          this.key = key;
          this.value = value;
          this.parent = parent;
      }
      ......
}

WeakHashMap

WeakHashMap底层通过Entry[] 数组存储数据，采用链表法解决hash冲突，跟HashMap 不同没有进行长链表的红黑树转化。

Entry[] table;
  • Entry为WeakHashMap自定义的数据结构继承了WeakReference，其中包含value，hash值，以及next指针。key为弱引用reference的值。
private static class Entry extends WeakReference implements Map.Entry {
    V value;
    final int hash;
    Entry next;
    /**
     * Creates new entry.
     */
    Entry(Object key, V value,
          ReferenceQueue queue,
          int hash, Entry next) {
        super(key, queue);
        this.value = value;
        this.hash  = hash;
        this.next  = next;
    }
    ......
} 

具体的操作逻辑可以参考：[[WeakHashMap]]


ConcurrentSkipListMap


ConcurrentSkipListMap底层通过跳表的数据结构提高查找效率。ConcurrentSkipListMap通过Node存储基本的key,value数据，Index存储跳表索引，HeadIndex为层级头索引。


// Node存储基本的key,value数据，是一个简单的链表
static final class Node {
    final K key;
    volatile Object value;
    volatile Node next;
    ...
}
// Index 内包含Node元素，以及向下和向右的Index指针
static class Index {
    final Node node;
    final Index down;
    volatile Index right;
    ...
} 
// HeadIndex继承了Index,添加了level索引层级属性
static final class HeadIndex extends Index {
    final int level;
    HeadIndex(Node node, Index down, Index right, int level) {
        super(node, down, right);
        this.level = level;
    }
} 


同时，ConcurrentSkipListMap通过对大部分操作添加CAS锁防止并发。




Set


HashSet


HashSet底层默认通过HashMap存储元素，数据储存在HashMap的key中，value设置为默认值Object。


private transient HashMap map;
private static final Object PRESENT = new Object(); // default value
public boolean add(E e) {
  return map.put(e, PRESENT)==null;
} 


HashSet 底层还可以通过 LinkedHashMap 存储元素。根据构造函数参数不同选择是 HashMap还是LinkedHashMap实现。


HashSet(int initialCapacity, float loadFactor, boolean dummy) {
    map = new LinkedHashMap<>(initialCapacity, loadFactor);
}


LinkedHashSet


LinkedhashSet继承了HashSet，采用LinkedHashMap存储元素。


ConcurrentSkipListSet


底层通过ConcurrentSkipListMap实现，存放的值作为key存入ConcurrentSkipListMap中，使用Boolean.TRUE对象最为默认的value。


private final ConcurrentNavigableMap m;

/**
 * Constructs a new, empty set that orders its elements according to
 * their {@linkplain Comparable natural ordering}.
 */
public ConcurrentSkipListSet() {
    m = new ConcurrentSkipListMap();
}

public boolean add(E e) {
    return m.putIfAbsent(e, Boolean.TRUE) == null;
} 


TreeSet


TreeSet底层通过TreeMap存储元素，和HashSet类似，数据存储在TreeMap 的Key中，value设置为默认值Object。


private transient NavigableMap m;
  // Dummy value to associate with an Object in the backing Map
  private static final Object PRESENT = new Object();
  
  public TreeSet(Comparator comparator) {
      this(new TreeMap<>(comparator));
  }


CopyOnWriteArraySet


底层通过CopyOnWriteArrayList实现，通过List.addIfAbsent()方法实现同一个元素只存在一个，保证了元素的唯一性。


private final CopyOnWriteArrayList al;

/**
 * Creates an empty set.
 */
public CopyOnWriteArraySet() {
    al = new CopyOnWriteArrayList();
}

public boolean add(E e) {
    return al.addIfAbsent(e);
} 




Queue


PriorityQueue


PriorityQueue优先队列，底层通过Object数组存储元素，Object[]以层次遍历的形式存储优先队列（完全二叉树）的元素值。索引n的左右孩子索引分别为$2n+1,2*(n+1)$;


transient Object[] queue;


BlockingQueue



A Queue that additionally supports operations that wait for the queue to become non-empty when retrieving an element, and wait for space to become available in the queue when storing an element.



阻塞队列接口，提供了额外的一些操作，当这些操作无法立即执行时（插入时容量满了、删除/获取元素时队列为空），不会像正常的queue一些立即返回而是阻塞一段时间直到满足条件（设置了等待时间、条件满足了）


阻塞队列的阻塞操作一般是通过创建多个条件锁ReentrantLock.Condition实现的，通过调用Condition.await()以及Condition.signal()进行线程的阻塞和唤醒。


private final Condition notEmpty;

/** Condition for waiting puts */
private final Condition notFull;


    

  • 添加元素
    

      

    • add(E e)/offer(E e)方法，当数组满了之后，直接返回false
      public boolean offer(E e) {
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        if (count == items.length)
            return false;
        else {
            enqueue(e);
            return true;
        }
    } finally {
        lock.unlock();
    }
}
      • 

    • put(E e)/offer(E e, long timeout, TimeUnit unit)方法，当数组满了之后，阻塞直到唤醒或者阻塞指定时间
      public void put(E e) throws InterruptedException {
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (count == items.length)
            notFull.await();
        enqueue(e);
    } finally {
        lock.unlock();
    }
}

public boolean offer(E e, long timeout, TimeUnit unit)
    throws InterruptedException {

    checkNotNull(e);
    long nanos = unit.toNanos(timeout);
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (count == items.length) {
            if (nanos <= 0)
                return false;
            nanos = notFull.awaitNanos(nanos);
        }
        enqueue(e);
        return true;
    } finally {
        lock.unlock();
    }
}
      • 

    • 

  • 获取元素
    

      

    • poll()，弹出队首元素，队列为空时直接return null;
      • 

    • take() ，弹出队首元素，队列为空时阻塞至队列不为空。
      • 

    • poll(long timeout, TimeUnit unit)，弹出队首元素，队列为空时阻塞指定时间后重试一次。
      • 

    • peek()，获取队首元素，队列为空时直接return null;
      • 

    • 



ArrayBlockingQueue



A bounded BlockingQueue backed by an array. This queue orders elements
FIFO (first-in-first-out). The head of the queue is that element that has been on the queue the longest time. The tail of the queue is that element that has been on the queue the shortest time. New elements are inserted at the tail of the queue, and the queue retrieval operations obtain elements at the head of the queue.



顾名思义，ArrayBlockingQueue底层是通过Object[]数组实现元素的存储的。ArrayBlockingQueue是有界队列，存储元素的数量通过初始化方法指定。当数组满了的时候，就无法直接往数组中添加元素了。ArrayBlockingQueue FIFO，添加元素到队尾，删除队首元素。


    

  • 初始化方法
    public ArrayBlockingQueue(int capacity, boolean fair) {
    if (capacity <= 0)
        throw new IllegalArgumentException();
    this.items = new Object[capacity];
    lock = new ReentrantLock(fair);
    notEmpty = lock.newCondition();
    notFull =  lock.newCondition();
}
    • 



LinkedBlockingQueue


根据初始化参数动态构造是否有界的阻塞队列。底层通过Node结构实现的链表进行存储。


    

  • Node结构
    static class Node {
    E item;

    Node next;

    Node(E x) { item = x; }
}
    • 

  • 初始化方法
    public LinkedBlockingQueue() {
    // 不指定队列容量，默认为Integer的最大值
    this(Integer.MAX_VALUE);
}

public LinkedBlockingQueue(int capacity) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
    last = head = new Node(null);
}
    • 



ArrayBlockingQueue 和LinkedBlockingQueue除了底层实现方式不同之外，ArrayBlockingQueue在进行数据操作时用的都是同一把锁final ReentrantLock lock;，而LinkedBlockingQueue初始化了二把锁插入和弹出操作使用不同的锁。final ReentrantLock putLock； final ReentrantLock takeLock；
























你可能感兴趣的:(java,容器)






    

  • Long类型前后端数据不一致
igotyback
前端

    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    

    • 

  • LocalDateTime 转 String
igotyback
java开发语言

    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    

    • 

  • Linux下QT开发的动态库界面弹出操作（SDL2）
13jjyao
QT类qt开发语言sdl2linux

    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    

    • 

  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业

    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    

    • 

  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
若博豆
java算法华为javascript

    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    

    • 

  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
二挡起步
web前端期末大作业javascripthtmlcss旅游风景

    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    

    • 

  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端

    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    

    • 

  • Day17笔记-高阶函数
~在杰难逃~
Python笔记python开发语言pycharm数据分析

    高阶函数【重点掌握】函数的本质：函数是一个变量，函数名是一个变量名，一个函数可以作为另一个函数的参数或返回值使用如果A函数作为B函数的参数，B函数调用完成之后，会得到一个结果，则B函数被称为高阶函数常用的高阶函数：map(),reduce(),filter(),sorted()1.map()map(func,iterable)，返回值是一个iterator【容器，迭代器】func:函数iterab
    

    • 

  • node.js学习
小猿L
node.jsnode.js学习vim

    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    

    • 

  • docker
igotyback
eureka云原生

    Docker容器的文件系统是隔离的，但是可以通过挂载卷（Volumes）或绑定挂载（BindMounts）将宿主机的文件系统目录映射到容器内部。要查看Docker容器的映射路径，可以使用以下方法：查看容器配置：使用dockerinspect命令可以查看容器的详细配置信息，包括挂载的卷。例如：bashdockerinspect在输出的JSON格式中，查找"Mounts"部分，这里会列出所有的挂载信息
    

    • 

  • Java 重写(Override)与重载(Overload)
叨唧唧的

    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    

    • 

  • 简单了解 JVM
记得开心一点啊
jvm

    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    

    • 

  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
Energet!c
开发语言

    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    

    • 

  • Java企业面试题3
马龙强_
java

    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    

    • 

  • JVM、JRE和 JDK：理解Java开发的三大核心组件
Y雨何时停T
Javajava

    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    

    • 

  • Java面试题精选：消息队列(二)
芒果不是芒
Java面试题精选javakafka

    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    

    • 

  • 白骑士的Java教学基础篇 2.5 控制流语句
白骑士所长
Java教学java开发语言

    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    

    • 

  • python语法——三目运算符
HappyRocking
pythonpython三目运算符

    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    

    • 

  • ArrayList 源码解析
程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea

    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    

    • 

  • Java爬虫框架（一）--架构设计
狼图腾-狼之传说
java框架java任务html解析器存储电子商务

    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    

    • 

  • Java：爬虫框架
dingcho
Javajava爬虫

    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    

    • 

  • python怎么将png转为tif_png转tif
weixin_39977276

    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    

    • 

  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
跳房子的前端
前端面试javascript开发语言ecmascript

    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    

    • 

  • JAVA·一个简单的登录窗口
MortalTom
java开发语言学习

    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    

    • 

  • WebMagic：强大的Java爬虫框架解析与实战
Aaron_945
Javajava爬虫开发语言

    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    

    • 

  • 博客网站制作教程
2401_85194651
javamaven

    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    

    • 

  • 00. 这里整理了最全的爬虫框架（Java + Python）
有一只柴犬
爬虫系列爬虫javapython

    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
    

    • 

  • JAVA学习笔记之23种设计模式学习
victorfreedom
Java技术设计模式androidjava常用设计模式

    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    

    • 

  • JavaScript `Map` 和 `WeakMap`详细解释
跳房子的前端
JavaScript原生方法javascript前端开发语言

    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
    

    • 

  • 《 C++ 修炼全景指南：四 》揭秘 C++ List 容器背后的实现原理，带你构建自己的双向链表
Lenyiin
技术指南C++修炼全景指南c++list链表stl

    本篇博客，我们将详细讲解如何从头实现一个功能齐全且强大的C++List容器，并深入到各个细节。这篇博客将包括每一步的代码实现、解释以及扩展功能的探讨，目标是让初学者也能轻松理解。一、简介1.1、背景介绍在C++中，std::list是一个基于双向链表的容器，允许高效的插入和删除操作，适用于频繁插入和删除操作的场景。与动态数组不同，list允许常数时间内的插入和删除操作，支持双向遍历。这篇文章将详细
    

    • 

  • knob UI插件使用
换个号韩国红果果
JavaScriptjsonpknob

    图形是用canvas绘制的
js代码
var paras = {
max:800,
min:100,
skin:'tron',//button type
thickness:.3,//button width
width:'200',//define canvas width.,canvas height
displayInput:'tr
    

    • 

  • Android+Jquery Mobile学习系列(5)-SQLite数据库
白糖_
JQuery Mobile

    目录导航
 
SQLite是轻量级的、嵌入式的、关系型数据库，目前已经在iPhone、Android等手机系统中使用,SQLite可移植性好，很容易使用，很小，高效而且可靠。
 
因为Android已经集成了SQLite，所以开发人员无需引入任何JAR包，而且Android也针对SQLite封装了专属的API，调用起来非常快捷方便。
 
我也是第一次接触S
    

    • 

  • impala-2.1.2-CDH5.3.2
dayutianfei
impala

    最近在整理impala编译的东西，简单记录几个要点：
根据官网的信息（https://github.com/cloudera/Impala/wiki/How-to-build-Impala）：
1. 首次编译impala，推荐使用命令：
${IMPALA_HOME}/buildall.sh -skiptests -build_shared_libs -format
2.仅编译BE
${I
    

    • 

  • 求二进制数中1的个数
周凡杨
java算法二进制

    解法一：
对于一个正整数如果是偶数，该数的二进制数的最后一位是 0 ，反之若是奇数，则该数的二进制数的最后一位是 1 。因此，可以考虑利用位移、判断奇偶来实现。
 
public int bitCount(int x){
int count = 0;
while(x!=0){
if(x%2!=0){ /
    

    • 

  • spring中hibernate及事务配置
g21121
Hibernate

    hibernate的sessionFactory配置：
<!-- hibernate sessionFactory配置 -->
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<
    

    • 

  • log4j.properties 使用
510888780
log4j

    log4j.properties 使用
一.参数意义说明
输出级别的种类
ERROR、WARN、INFO、DEBUG
ERROR 为严重错误 主要是程序的错误
WARN 为一般警告，比如session丢失
INFO 为一般要显示的信息，比如登录登出
DEBUG 为程序的调试信息
配置日志信息输出目的地
log4j.appender.appenderName = fully.qua
    

    • 

  • Spring mvc-jfreeChart柱图（2）
布衣凌宇
jfreechart

    上一篇中生成的图是静态的，这篇将按条件进行搜索，并统计成图表，左面为统计图，右面显示搜索出的结果。
第一步：导包
第二步；配置web.xml(上一篇有代码)
建BarRenderer类用于柱子颜色
import java.awt.Color;
import java.awt.Paint;
import org.jfree.chart.renderer.category.BarR
    

    • 

  • 我的spring学习笔记14-容器扩展点之PropertyPlaceholderConfigurer
aijuans
Spring3

    PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。关于BeanFactoryPostProcessor和BeanPostProcessor类似。我会在其他地方介绍。
PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java
    

    • 

  • maven 之 cobertura 简单使用
antlove
maventestunitcoberturareport

    1. 创建一个maven项目
2. 创建com.CoberturaStart.java
package com;
public class CoberturaStart {
public void helloEveryone(){
System.out.println("=================================================
    

    • 

  • 程序的执行顺序
百合不是茶
JAVA执行顺序

     
 
  刚在看java核心技术时发现对java的执行顺序不是很明白了,百度一下也没有找到适合自己的资料,所以就简单的回顾一下吧
 
代码如下;
    经典的程序执行面试题
//关于程序执行的顺序
//例如：
//定义一个基类
public class A(){
public A(
    

    • 

  • 设置session失效的几种方法
bijian1013
web.xmlsession失效监听器

    在系统登录后，都会设置一个当前session失效的时间，以确保在用户长时间不与服务器交互，自动退出登录，销毁session。具体设置很简单，方法有三种：（1）在主页面或者公共页面中加入：session.setMaxInactiveInterval(900);参数900单位是秒，即在没有活动15分钟后，session将失效。这里要注意这个session设置的时间是根据服务器来计算的，而不是客户端。所
    

    • 

  • java jvm常用命令工具
bijian1013
javajvm

    一.概述
        程序运行中经常会遇到各种问题，定位问题时通常需要综合各种信息，如系统日志、堆dump文件、线程dump文件、GC日志等。通过虚拟机监控和诊断工具可以帮忙我们快速获取、分析需要的数据，进而提高问题解决速度。 本文将介绍虚拟机常用监控和问题诊断命令工具的使用方法，主要包含以下工具:
      &nbs
    

    • 

  • 【Spring框架一】Spring常用注解之Autowired和Resource注解
bit1129
Spring常用注解

    Spring自从2.0引入注解的方式取代XML配置的方式来做IOC之后，对Spring一些常用注解的含义行为一直处于比较模糊的状态，写几篇总结下Spring常用的注解。本篇包含的注解有如下几个：
Autowired
Resource
Component
Service
Controller
Transactional
根据它们的功能、目的，可以分为三组，Autow
    

    • 

  • mysql 操作遇到safe update mode问题
bitray
update

        我并不知道出现这个问题的实际原理,只是通过其他朋友的博客,文章得知的一个解决方案,目前先记录一个解决方法,未来要是真了解以后,还会继续补全.
    在mysql5中有一个safe update mode,这个模式让sql操作更加安全,据说要求有where条件,防止全表更新操作.如果必须要进行全表操作,我们可以执行
SET
    

    • 

  • nginx_perl试用
ronin47
nginx_perl试用

    因为空闲时间比较多，所以在CPAN上乱翻，看到了nginx_perl这个项目(原名Nginx::Engine)，现在托管在github.com上。地址见：https://github.com/zzzcpan/nginx-perl
这个模块的目的，是在nginx内置官方perl模块的基础上，实现一系列异步非阻塞的api。用connector/writer/reader完成类似proxy的功能（这里
    

    • 

  • java-63-在字符串中删除特定的字符
bylijinnan
java

    
public class DeleteSpecificChars {
/**
* Q 63 在字符串中删除特定的字符
* 输入两个字符串，从第一字符串中删除第二个字符串中所有的字符。
* 例如，输入”They are students.”和”aeiou”，则删除之后的第一个字符串变成”Thy r stdnts.”
*/
public static voi
    

    • 

  • EffectiveJava--创建和销毁对象
ccii
创建和销毁对象

    本章内容：
1. 考虑用静态工厂方法代替构造器
2. 遇到多个构造器参数时要考虑用构建器（Builder模式）
3. 用私有构造器或者枚举类型强化Singleton属性
4. 通过私有构造器强化不可实例化的能力
5. 避免创建不必要的对象
6. 消除过期的对象引用
7. 避免使用终结方法
1. 考虑用静态工厂方法代替构造器
    类可以通过
    

    • 

  • [宇宙时代]四边形理论与光速飞行
comsci

       从四边形理论来推论 为什么光子飞船必须获得星光信号才能够进行光速飞行？
   一组星体组成星座  向空间辐射一组由复杂星光信号组成的辐射频带，按照四边形-频率假说  一组频率就代表一个时空的入口
   那么这种由星光信号组成的辐射频带就代表由这些星体所控制的时空通道，该时空通道在三维空间的投影是一
    

    • 

  • ubuntu server下python脚本迁移数据
cywhoyi
pythonKettlepymysqlcx_Oracleubuntu server

    因为是在Ubuntu下，所以安装python、pip、pymysql等都极其方便，sudo apt-get install pymysql，
但是在安装cx_Oracle（连接oracle的模块）出现许多问题，查阅相关资料，发现这边文章能够帮我解决，希望大家少走点弯路。http://www.tbdazhe.com/archives/602
1.安装python
2.安装pip、pymysql
    

    • 

  • Ajax正确但是请求不到值解决方案
dashuaifu
Ajaxasync

    Ajax正确但是请求不到值解决方案
 
解决方案：1 .     async: false ,    2.     设置延时执行js里的ajax或者延时后台java方法！！！！！！！
 
例如：
 
$.ajax({     &
    

    • 

  • windows安装配置php+memcached
dcj3sjt126com
PHPInstallmemcache

    Windows下Memcached的安装配置方法
1、将第一个包解压放某个盘下面，比如在c:\memcached。
2、在终端（也即cmd命令界面）下输入 'c:\memcached\memcached.exe -d install' 安装。
3、再输入： 'c:\memcached\memcached.exe -d start' 启动。（需要注意的: 以后memcached将作为windo
    

    • 

  • iOS开发学习路径的一些建议
dcj3sjt126com
ios

    iOS论坛里有朋友要求回答帖子，帖子的标题是： 想学IOS开发高阶一点的东西，从何开始，然后我吧啦吧啦回答写了很多。既然敲了那么多字，我就把我写的回复也贴到博客里来分享，希望能对大家有帮助。欢迎大家也到帖子里讨论和分享，地址：http://bbs.csdn.net/topics/390920759
 
下面是我回复的内容：
 
结合自己情况聊下iOS学习建议，
    

    • 

  • Javascript闭包概念
fanfanlovey
JavaScript闭包

    1.参考资料
http://www.jb51.net/article/24101.htm
http://blog.csdn.net/yn49782026/article/details/8549462
2.内容概述
要理解闭包，首先需要理解变量作用域问题
内部函数可以饮用外面全局变量
var n=999;
　　functio
    

    • 

  • yum安装mysql5.6
haisheng
mysql

    1、安装http://dev.mysql.com/get/mysql-community-release-el7-5.noarch.rpm
 
2、yum install mysql
 
3、yum install mysql-server
 
4、vi /etc/my.cnf   添加character_set_server=utf8
    

    • 

  • po/bo/vo/dao/pojo的详介
IT_zhlp80
javaBOVODAOPOJOpo

        JAVA几种对象的解释
PO:persistant object持久对象,可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作.
VO:value object值对象。通常用于业务层之间的数据传递，和PO一样也是仅仅包含数据而已。但应是抽象出的业务对象,可
    

    • 

  • java设计模式
kerryg
java设计模式

    设计模式的分类：
   一、 设计模式总体分为三大类：
1、创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。
2、结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。
3、行为型模式（11种）：策略模式，模版方法模式，观察者模式，迭代子模式，责任链模式，命令模式，备忘录模式，状态模式，访问者
    

    • 

  • [1]CXF3.1整合Spring开发webservice——helloworld篇
木头.java
springwebserviceCXF

    Spring 版本3.2.10
CXF 版本3.1.1
项目采用MAVEN组织依赖jar
我这里是有parent的pom，为了简洁明了，我直接把所有的依赖都列一起了，所以都没version，反正上面已经写了版本
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="ht
    

    • 

  • Google 工程师亲授：菜鸟开发者一定要投资的十大目标
qindongliang1922
工作感悟人生

    身为软件开发者，有什么是一定得投资的？ Google 软件工程师 Emanuel Saringan 整理了十项他认为必要的投资，第一项就是身体健康，英文与数学也都是必备能力吗？来看看他怎么说。（以下文字以作者第一人称撰写）） 你的健康 无疑地，软件开发者是世界上最久坐不动的职业之一。 每天连坐八到十六小时，休息时间只有一点点，绝对会让你的鲔鱼肚肆无忌惮的生长。肥胖容易扩大罹患其他疾病的风险，
    

    • 

  • linux打开最大文件数量1,048,576
tianzhihehe
clinux

    File descriptors are represented by the C int type. Not using a special type is often  considered odd, but is, historically, the Unix way. Each Linux process has a maximum number of files th
    

    • 

  • java语言中PO、VO、DAO、BO、POJO几种对象的解释
衞酆夼
javaVOBOPOJOpo

    PO:persistant object持久对象
最形象的理解就是一个PO就是数据库中的一条记录。好处是可以把一条记录作为一个对象处理，可以方便的转为其它对象。可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作。
BO:business object业务对象
封装业务逻辑的java对象
    

    •