visitor009
visitor009

数据结构java描述

接口

  1. 栈
package myjava;

public interface Stack {
    int getSize();
    boolean isEmpty();
    void push(E e);
    E pop();
    E peek();
}
  1. 队列
package myjava;

public interface Queue {
    int getSize();
    boolean isEmpty();
    E dequeue();
    void enqueue(E e);
    E getFront();
}
  1. 集合
package myjava;

public interface Set {
    void add(E e);
    void remove(E e);
    boolean contains(E e);
    int getSize();
    boolean isEmpty();
}
  1. 并查集
package myjava;

public interface UnionFind {
    int getSize();
    boolean isConnected(int p, int q);
    void unionElements(int p, int q);
}
  1. 映射
package myjava;

public interface Map {
    void add(K key, V value); // 添加
    void set(K key, V newValue); // 更新
    V remove(K key); // 删除
    V get(K key); // 得到为key 的值
    boolean contains(K key); // 是否包含元素
    boolean isEmpty(); // 是否空
    int getSize(); // 元素个数
}





数组

// 数组
package myjava;

public class Array {
    private E[] data;
     private int size;
     
     public Array(int capacity) {
         data = (E[])(new Object[capacity]);
         size = 0;
     }
     public Array() {
         this(10);
     }
     public Array(E[] arr) {
         data = (E[])(new Object[arr.length]);
         for (int i=0; i= 0 && index <= size) {
            for (int i=size-1; i>=index; i--) {
                data[i+1] = data[i];
            }
            data[index] = val;
            size++;
         }
     }
     private void resize(int capacity) { // 动态扩容数组容量
         E[] newData = (E[])new Object[capacity];
         for (int i=0; i= size) {
             throw new IllegalArgumentException("index is invalid");
         }
         return data[index];
     }
     // 更新某个位置的元素
//     @param{int}index 索引
//     @param{E}val 值
     public void set(int index, E val) { 
         if (index < 0 || index >= size) {
             throw new IllegalArgumentException("index is invalid");
         }
         data[index] = val;
     }
     public boolean contains(E val) { // 是否包含某个元素
         for (int i=0; i= size) {
             throw new IllegalArgumentException("index is invalid");
         }
         if (size == data.length / 2) { // 动态减少数组容量
             resize(data.length/2);
         }
         E ret = data[index];
         for (int i=index; i= size || j<0 || j>= size) {
             throw new ArrayIndexOutOfBoundsException("index is illegal");
         }
         E e = data[i];
         data[i] = data[j];
         data[j] = e;
     }
     @Override
     public String toString() {
         StringBuilder res = new StringBuilder();
         res.append(String.format("Array: size=%d, capacity=%d", size, data.length));
         res.append("[");
         for (int i=0; i





链表

package myjava;

public class LinkedList {
    private class Node { // 链表节点
        private E e;
        private Node next;

        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }

        public Node(E e) {
            this(e, null);
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }

    private Node dummyhead;// 虚拟头结点，方便插入动作
    private int size;

    public LinkedList(E e) {
        dummyhead = new Node(null, null);
        dummyhead.next = new Node(e);
        size = 1;
    }

    public LinkedList() {
        dummyhead = new Node(null, null);
        size = 0;
    }

    public int getSize() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    // 插入元素
//  @param{int}index 位置
//  @param{E}e 元素
    public void add(int index, E e) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("index is invalid");
        }
        Node prev = dummyhead;
        Node node = new Node(e);
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }
        prev.next = new Node(e, prev.next);
        size++;
    }
    public void addFirst(E e) {
        add(0, e);
    }
    public void addLast(E e) {
        add(size, e);
    }
    public Node get(int index) { // 得到指定位置元素
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("index is invalid");
        }
        Node cur = dummyhead.next;
        for (int i=0; i= size) {
            throw new IllegalArgumentException("index is invalid");
        }
        Node cur = dummyhead.next;
        for (int i=0; i= size) {
            throw new IllegalArgumentException("index is invalid");
        }
        Node prev = dummyhead;
        for (int i=0; i");
        }
        res.append("NULL");
        return res.toString();
    }
}





栈

  1. 数组实现
package myjava;

public class ArrayStack implements Stack {
    Array array;
    public ArrayStack(int capacity) {
        array = new Array<>(capacity);
    }
    public ArrayStack() {
        array = new Array<>();
    }
    @Override
    public int getSize() {
        return array.getSize();
    }
    @Override
    public boolean isEmpty() {
        return array.isEmpty();
    }
    public int getCapacity() {
        return array.getCapacity();
    }
    public void push(E e) { // 入栈
        array.addLast(e);
    }
    public E pop() {  // 出栈
        return array.removeLast();
    }
    public E peek() { // 栈顶元素 return{E}
        return array.get(array.getSize()-1);
    }
    @Override
    public String toString() {
        int size = array.getSize();
        StringBuilder res = new StringBuilder();
        res.append("Stack: [");
        for (int i=0; i>");
        return res.toString();
    }
}
  1. 链表实现
package myjava;

public class LinkedListQueue implements Queue {
   private class Node {
       private E e;
       private Node next;

       public Node(E e, Node next) {
           this.e = e;
           this.next = next;
       }

       public Node(E e) {
           this(e, null);
       }

       @Override
       public String toString() {
           return e.toString();
       }
   }
   private Node head, tail;
   private int size;
   public LinkedListQueue() {
       head = null;
       tail = null;
       size = 0;
   }
   public int getSize() {
       return size;
   }
   public boolean isEmpty() {
       return size == 0;
   }
   public void enqueue(E e) {
       if (tail == null) {
           head = new Node(e);
           tail = head;
       } else {
           tail.next = new Node(e);
           tail = tail.next;
       }
       size++;
   }
   public E dequeue() {
       if (isEmpty()) {
           return null;
       }
       Node retNode = head;
       head = head.next;
       retNode.next = null;
       if (head == null) {
           tail = null;
       }
       size--;
       return (E)retNode;
   }
   public E getFront() {
       if (isEmpty()) { return null; }
       return (E)head.e;
   }
   @Override
   public String toString() {
       StringBuilder res = new StringBuilder();
       Node current = head;
       res.append("Queue: Top ");
       
       while (current != null) {
           res.append(current);
           current = current.next;
           res.append("->");
       }
       res.append("NULL");
       return res.toString();
   }
}





队列

  1. 数组实现
package myjava;

public class ArrayQueue implements Queue {
   Array array;
   public ArrayQueue(int capacity) {
       array = new Array<>(capacity);
   }
   public ArrayQueue() {
       array = new Array<>();
   }
   @Override
   public int getSize() {
       return array.getSize();
   }
   @Override
   public boolean isEmpty() {
       return array.isEmpty();
   }
   @Override
   public void enqueue(E e) { // 进队
       array.addLast(e);
   }
   @Override
   public E dequeue() { // 出队 return{E}
       return array.removeFirst();
   }
   @Override
   public E getFront() {
       return array.get(0);
   }
   @Override
   public String toString() {
       StringBuilder res = new StringBuilder();
       int size = array.getSize();
       res.append("Queue: << [");
       for (int i=0; i
  1. 链表实现
package myjava;

public class LinkedListQueue implements Queue {
    private class Node {
        private E e;
        private Node next;

        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }

        public Node(E e) {
            this(e, null);
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }
    private Node head, tail;
    private int size;
    public LinkedListQueue() {
        head = null;
        tail = null;
        size = 0;
    }
    public int getSize() {
        return size;
    }
    public boolean isEmpty() {
        return size == 0;
    }
    public void enqueue(E e) {
        if (tail == null) {
            head = new Node(e);
            tail = head;
        } else {
            tail.next = new Node(e);
            tail = tail.next;
        }
        size++;
    }
    public E dequeue() {
        if (isEmpty()) {
            return null;
        }
        Node retNode = head;
        head = head.next;
        retNode.next = null;
        if (head == null) {
            tail = null;
        }
        size--;
        return (E)retNode;
    }
    public E getFront() {
        if (isEmpty()) { return null; }
        return (E)head.e;
    }
    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        Node current = head;
        res.append("Queue: Top ");
        
        while (current != null) {
            res.append(current);
            current = current.next;
            res.append("->");
        }
        res.append("NULL");
        return res.toString();
    }
}





二分搜索树

package myjava;
import java.util.Queue;
import java.util.LinkedList;

public class BST> {
    private class Node {
        public E e;
        public Node left, right;
        public Node(E e) {
            this.e = e;
            left = null;
            right = null;
        }
    }
    private Node root;
    private int size;
    public BST() {
        root = null;
        size = 0;
    }
    public int getSize() {
        return size;
    }
    public boolean isEmpty() {
        return size == 0;
    }
    public void add(E e) {
        if (root == null) {
            root = new Node(e);
            size++;
        } else {
            root = add(root, e);
        }
    }
    private Node add(Node node, E e) { // 添加
        if (node == null) {
            size++;
            return new Node(e);
        }
        if (e.compareTo(node.e) < 0) {
            node.left = add(node.left, e);
        } else if (e.compareTo(node.e) > 0) {
            node.right = add(node.right, e);
        }
        return node;
    }
    public boolean contains(E e) { // 是否包含
        return contains(root, e);
    }
    private boolean contains(Node node, E e) {
        if (node == null) {
            return false;
        }
        if (e.compareTo(node.e) == 0) {
            return true;
        } else if (e.compareTo(node.e) < 0) {
            return contains(node.left, e);
        } else {
            return contains(node.right, e);
        }
    }
    public void preOrder() { // 前序遍历
        preOrder(root);
    }
    private void preOrder(Node node) {
        if (node == null) {return ;}
        
        System.out.println(node.e);
        preOrder(node.left);
        preOrder(node.right);
    }
    public void inOrder() {// 中序遍历
        inOrder(root);
    }
    private void inOrder(Node node) {
        if (node == null) {return ;}
        
        preOrder(node.left);
        System.out.println(node.e);
        preOrder(node.right);
    }
    public void postOrder() { // 后序遍历
        postOrder(root);
    }
    private void postOrder(Node node) {
        if (node == null) {return ;}
        
        preOrder(node.left);
        preOrder(node.right);
        System.out.println(node.e);
    }
    public void levelOrder() { // 层次遍历
        Queue queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            Node cur = queue.remove();
            System.out.println(cur.e);
            if (cur.left != null) {
                queue.add(cur.left);
            }
            if (cur.right != null) {
                queue.add(cur.right);
            }
        }
    }
    public Node minimum() { // 得到最小值
        if (root == null) {return null;}
        return minimum(root);
    }
    private Node minimum(Node node) {
        if (node.left == null) {
            return node;
        }
        return minimum(node.left);
    }
    public Node maxmum() { // 得到最大值
        if (root == null) {return null;}
        return maxmum(root);
    }
    private Node maxmum(Node node) {
        if (node.right == null) {
            return node;
        }
        return maxmum(node.right);
    }
    public Node removeMin() {
        Node cur = minimum();
        root = removeMin(root);
        return cur;
    }
    private Node removeMin(Node node) {
        if (node.left == null) {
            Node rightNode = node.right;
            node.right = null;
            size--;
            return rightNode;
        }
        node.left = removeMin(node.left);
        return node;
    }
    public Node removeMax() {
        Node cur = maxmum();
        root = removeMax(root);
        return cur;
    }
    private Node removeMax(Node node) {
        if (node.right == null) {
            Node leftNode = node.left;
            node.left = null;
            size--;
            return leftNode;
        }
        node.right = removeMax(node.right);
        return node;
    }
    public void remove(E e) {
        root = remove(root, e);
    }
    private Node remove(Node node, E e) {
        if (node == null) {
            return null;
        }
        if (e.compareTo(node.e) < 0) {
            node.left = remove(node.left, e);
            return node;
        } else if (e.compareTo(node.e) > 0) {
            node.right = remove(node.right, e);
            return node;
        } else { // 匹配到
            if (node.left == null) {
                Node rightNode = node.right;
                node.right = null;
                size--;
                return rightNode;
            }
            if (node.right == null) {
                Node leftNode = node.left;
                node.left = null;
                size--;
                return leftNode;
            }
            // 两边都有子结点
            Node successor = minimum(node.right);
            successor.right = removeMin(node.right);
            successor.left = node.left;
            return successor;
        }
    }
    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        generateBSTString(root, 0, res);
        return res.toString();
    }
    private void generateBSTString(Node node, int depth, StringBuilder res) {
        if (node == null) {
            res.append(generateDepthString(depth)+"nlll\n");
            return ;
        }
        res.append(generateDepthString(depth)+node.e+"\n");
        generateBSTString(node.left, depth+1, res);
        generateBSTString(node.right, depth+1, res);
    }
    private String generateDepthString(int depth) {
        StringBuilder res = new StringBuilder();
        for (int i=0; i





集合

  1. 二分搜索树实现
package myjava;

public class BSTSet> implements Set {
   private BST bst;
   public BSTSet() {
       bst = new BST<>();
   }
   @Override
   public void add(E e) {
       bst.add(e);
   }
   @Override
   public void remove(E e) {
       bst.remove(e);
   }
   @Override
   public boolean contains(E e) {
       return bst.contains(e);
   }
   @Override
   public int getSize() {
       return bst.getSize();
   }
   @Override 
   public boolean isEmpty() {
       return bst.isEmpty();
   }
}
  1. 链表实现
package myjava;

public class LinkedListSet> implements Set {
    private LinkedList list;
    LinkedListSet() {
        list = new LinkedList<>();
    }
    @Override
    public int getSize() {
        return list.getSize();
    }
    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }
    @Override
    public boolean contains(E e) {
        return list.contains(e);
    }
    @Override
    public void add(E e) {
        if (!list.contains(e)) {
            list.addFirst(e);
        }
    }
    @Override
    public void remove(E e) {
        list.removeElement(e);
    }
}





映射

  1. 二分搜索树实现
package myjava;

public class BSTMap, V> implements Map {
    private class Node {
        public K key;
        public V value;
        public Node left, right;
        public Node(K key, V value) {
            this.key = key;
            this.value = value;
            left = null;
            right = null;
        }
    }
    private Node root;
    private int size;
    public BSTMap() {
        this.root = null;
        this.size = 0;
    }
    @Override
    public int getSize() {
        return size;
    }
    @Override
    public boolean isEmpty() {
        return size == 0;
    }
    @Override
    public void add(K key, V value) {
        if (root == null) {
            root = new Node(key, value);
            size++;
        } else {
            root = add(root, key, value);
        }
    }
    private Node add(Node node, K key, V value) { // 添加
        if (node == null) {
            size++;
            return new Node(key, value);
        }
        if (key.compareTo(node.key) < 0) {
            node.left = add(node.left, key, value);
        } else if (key.compareTo(node.key) > 0) {
            node.right = add(node.right, key, value);
        } else {
            node.value = value;
        }
        return node;
    }
    private Node getNode(Node node, K key) {
        if (node == null) {
            return null;
        }
        if (key.compareTo(node.key) == 0) {
            return node;
        } else if (key.compareTo(node.key) < 0) {
            return getNode(node.left, key);
        } else { // >0
            return getNode(node.right, key);
        }
    }
    @Override
    public boolean contains(K key) {
        Node node = getNode(root, key);
        return node != null;
    }
    @Override
    public V get(K key) {
        Node node = getNode(root, key);
        return node != null ? node.value : null;
    }
    @Override
    public void set(K key, V value) {
        Node node = getNode(root, key);
        if (node == null) {
            throw new IllegalArgumentException(key+"doesn't exit!");
        }
        node.value = value;
    }
    @Override
    public V remove(K key) {
        Node node = getNode(root, key);
        if (node != null) {
            root = remove(root, key);
            return node.value;
        }
        return null;
    }
    private Node remove(Node node, K key) {
        if (node == null) {
            return null;
        }
        if (key.compareTo(node.key) < 0) {
            node.left = remove(node.left, key);
            return node;
        } else if (key.compareTo(node.key) > 0) {
            node.right = remove(node.right, key);
            return node;
        } else { // 匹配到
            if (node.left == null) {
                Node rightNode = node.right;
                node.right = null;
                size--;
                return rightNode;
            }
            if (node.right == null) {
                Node leftNode = node.left;
                node.left = null;
                size--;
                return leftNode;
            }
            // 两边都有子结点
            Node successor = minimum(node.right);
            successor.right = removeMin(node.right);
            successor.left = node.left;
            return successor;
        }
    }
    public Node minimum() { // 得到最小值
        if (root == null) {return null;}
        return minimum(root);
    }
    private Node minimum(Node node) {
        if (node.left == null) {
            return node;
        }
        return minimum(node.left);
    }
    public Node removeMin() {
        Node cur = minimum();
        root = removeMin(root);
        return cur;
    }
    private Node removeMin(Node node) { // 删除最小值
        if (node.left == null) {
            Node rightNode = node.right;
            node.right = null;
            size--;
            return rightNode;
        }
        node.left = removeMin(node.left);
        return node;
    }
}
  1. 链表实现
package myjava;

public class LinkedListMap implements Map {
   private class Node {
       public K key;
       public V value;
       public Node next;
       
       public Node(K key, V value, Node next) {
           this.key = key;
           this.value = value;
           this.next = next;
       }
       public Node(K key) {
           this(key, null, null);
       }
       public Node() {
           this(null, null, null);
       }
   }
   private Node dummyhead;
   private int size;
   public LinkedListMap() {
       this.dummyhead = new Node();
       size = 0;
   }
   @Override
   public int getSize() {
       return size;
   }
   @Override
   public boolean isEmpty() {
       return size == 0;
   }
   private Node getNode(K key) {
       Node cur = dummyhead.next;
       while (cur != null) {
           if (cur.key.equals(key)) {
               return cur;
           }
           cur = cur.next;
       }
       return null;
   }
   @Override
   public boolean contains(K key) {
       return getNode(key) != null;
   }
   @Override
   public V get(K key) {
       Node node = getNode(key);
       return node != null ? node.value : null;
   }
   @Override
   public void add(K key, V value) {
       Node node = getNode(key);
       if (node == null) {
           dummyhead.next = new Node(key, value, dummyhead.next);
       } else {
           node.value = value;
       }
   }
   @Override
   public void set(K key, V value) {
       Node node = getNode(key);
       if (node == null) {
           throw new IllegalArgumentException(key+"doesn't exit!");
       }
       node.value = value;
   }
   @Override
   public V remove(K key) {
       Node prev = dummyhead;
       while (prev != null) {
           if (key.equals(prev.next.key)) {
               break;
           }
           prev = prev.next;
       }
       if (prev.next != null) {
           Node ret = prev.next;
           prev.next = ret.next;
           ret.next = null;
           size--;
           return ret.value;
       }
       return null;
   }
}





最大堆

package myjava;

public class MaxHeap> {
    private Array data;
    public MaxHeap(int capacity) {
        data = new Array<>(capacity);
    }
    public MaxHeap() {
        data = new Array<>();
    }
    public MaxHeap(E[] arr) {
        data = new Array<>(arr);
        for (int i=parent(arr.length-1); i>=0; i--) {
            shiftDown(i);
        }
    }
    public int getSize() {
        return data.getSize();
    }
    public boolean isEmpty() {
        return data.isEmpty();
    }
    private int parent(int index) { // 得到父节点的索引
        if (index == 0) {
            throw new ArrayIndexOutOfBoundsException("index-0 doesn't parent");
        }
        return (index-1)/2;
    }
    private int leftChild(int index) { // 返回左孩子索引
        return index*2+1;
    }
    private int rightChild(int index) { // 返回右孩子索引
        return index*2+2;
    }
    public void add(E e) {
        data.addLast(e);
        shiftUp(getSize()-1);
    }
    private void shiftUp(int k) {
        while (k>0 && data.get(parent(k)).compareTo(data.get(k)) < 0) {
            data.swap(k, parent(k));
            k=parent(k);
        }
    }
    public E findMax() {
        if (data.getSize() == 0) {
            throw new UnsupportedOperationException("heap is empty");
        }
        return data.get(0);
    }
    public E extractMax() {
        E ret = findMax();
        data.swap(0, data.getSize()-1);
        data.removeLast();
        shiftDown(0);
        return ret;
    }
    private void shiftDown(int k) {
        int size = data.getSize();
        while (leftChild(k) < size) {
            int j = leftChild(k);
            if (j+1 < size && data.get(j+1).compareTo(data.get(j))>0) {
                j = rightChild(k);
            }
            if (data.get(k).compareTo(data.get(j)) > 0) {
                break;
            }
            data.swap(k, j);
            k = j;
        }
    }
    public E replace(E e) { // 返回最大元素并放入一个新元素
        E ret = findMax();
        data.set(0, e);
        shiftDown(0);
        return ret;
    }
}





优先队列

package myjava;

public class PriorityQueue> implements Queue {
    private MaxHeap maxHeap;
    public PriorityQueue() {
        maxHeap = new MaxHeap();
    }
    @Override
    public int getSize() {
        return maxHeap.getSize();
    }
    @Override
    public boolean isEmpty() {
        return maxHeap.isEmpty();
    }
    @Override
    public E getFront() {
        return (E) maxHeap.findMax();
    }
    @Override
    public void enqueue(E e) {
        maxHeap.add(e);
    }
    @Override
    public E dequeue() {
        return (E)maxHeap.extractMax();
    }
}





前缀树

package myjava;
import java.util.TreeMap;

public class Trie {
    private class Node {
        public boolean isWord;
        public TreeMap next;
        public Node(boolean isWord) {
            this.isWord = isWord;
            next = new TreeMap<>();
        }
        public Node() {
            this(false);
        }
    }
    private Node root;
    private int size;
    public Trie() {
        root = new Node();
    }
    public void add(String word) { // 添加单词
        Node cur = root;
        for (int i=0; i





并查集

package myjava;

public class ArrayUF implements UnionFind {
    private int[] parent;
    private int[] rank;
    
    public ArrayUF(int size) {
        parent = new int[size];
        rank = new int[size];
        
        for (int i=0; i= parent.length) {
            throw new IllegalArgumentException("p is out of bound");
        }
        while (p != parent[p]) {
            parent[p] = parent[parent[p]]; // 路径压缩，缩短到根节点的距离
            p = parent[p];
        }
        return p;
    }
    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(q);
    }
    @Override
    public void unionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);
        
        if (pRoot == qRoot) {
            return;
        }
        if (rank[pRoot] < rank[qRoot]) {
            parent[pRoot] = qRoot;
        } else if (rank[pRoot] > rank[qRoot]) {
            parent[qRoot] = pRoot;
        } else {
            parent[qRoot] = pRoot;
            rank[pRoot] += 1;
        }
    }
}





哈希表

package myjava;
import java.util.TreeMap;

public class HashTable {
    private TreeMap[] hashtable;
    private int M;
    private int size;
    
    public HashTable(int M) {
        this.M = M;
        size = 0;
        hashtable = new TreeMap[M];
        for (int i=0; i();
        }
    }
    public HashTable() {
        this(97);
    }
    public int hash(K key) {
        return (key.hashCode() & 0x7ffffff) % M;
    }
    public int getSize() {
        return size;
    }
    public void add(K key, V value) {
        TreeMap map = hashtable[hash(key)];
        if (map.containsKey(key)) {
            map.put(key, value);
        } else {
            map.put(key, value);
            size++;
        }
    }
    public V remove(K key) {
        TreeMap map = hashtable[hash(key)];
        V ret = null;
        if (map.containsKey(key)) {
            ret = map.remove(key);
            size--;
        }
        return ret;
    }
    public void set(K key, V value) {
        TreeMap map = hashtable[hash(key)];
        if (!map.containsKey(key)) {
            throw new IllegalArgumentException(key+"doesn't exist!");
        }
        map.put(key, value);
    }
    public boolean contains(K key) {
        return hashtable[hash(key)].containsKey(key);
    }
    public V get(K key) {
        return hashtable[hash(key)].get(key);
    }
}

你可能感兴趣的:(数据结构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
  • 如何在 Fork 的 GitHub 项目中保留自己的修改并同步上游更新？github_fork_update iBaoxing github
    如何在Fork的GitHub项目中保留自己的修改并同步上游更新？在GitHub上Fork了一个项目后，你可能会对项目进行一些修改，同时原作者也在不断更新。如果想要在保留自己修改的基础上，同步原作者的最新更新，很多人会不知所措。本文将详细讲解如何在不丢失自己改动的情况下，将上游仓库的更新合并到自己的仓库中。问题描述假设你在GitHub上Fork了一个项目，并基于该项目做了一些修改，随后你发现原作者对
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 509. 斐波那契数(每日一题) lzyprime
    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
  • 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分别代
  • 数组去重 好奇的猫猫猫
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
  • 关于城市旅游的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：做与用户的交互行为文章目录前端学习路线
  • ARM中断处理过程 落汤老狗 嵌入式linux
    一、前言本文主要以ARM体系结构下的中断处理为例，讲述整个中断处理过程中的硬件行为和软件动作。具体整个处理过程分成三个步骤来描述：1、第二章描述了中断处理的准备过程2、第三章描述了当发生中的时候，ARM硬件的行为3、第四章描述了ARM的中断进入过程4、第五章描述了ARM的中断退出过程本文涉及的代码来自3.14内核。另外，本文注意描述ARM指令集的内容，有些sourcecode为了简短一些，删除了T
  • 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的运行
  • 回溯算法-重新安排行程 chirou_ 算法数据结构图论c++图搜索
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
  • Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redisbootstrap数据库
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
  • Faiss：高效相似性搜索与聚类的利器 网络·魚 大数据faiss
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
  • 209. 长度最小的子数组（滑动窗口） 追光者2020 leetcode双指针/滑动窗口
    题目描述给定一个含有n个正整数的数组和一个正整数target。找出该数组中满足其和≥target的长度最小的连续子数组[numsl,numsl+1,…,numsr-1,numsr]，并返回其长度。如果不存在符合条件的子数组，返回0。示例1：输入：target=7,nums=[2,3,1,2,4,3]输出：2解释：子数组[4,3]是该条件下的长度最小的子数组。示例2：输入：target=4,nums
  • 数据结构之哈希表 X同学的开始 数据结构数据结构散列表
    哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
  • Xinference如何注册自定义模型 玩人工智能的辣条哥 人工智能AI大模型Xinference
    环境：Xinference问题描述：Xinference如何注册自定义模型解决方案：1.写个model_config.json，内容如下{"version":1,"context_length":2048,"model_name":"custom-llama-3","model_lang":["en","ch"],"model_ability":["generate","chat"],"model
  • 209. 长度最小的子数组（滑动窗口法） 清榎 leetcode刷题c++leetcode算法
    209.长度最小的子数组题目描述：给定一个含有n个正整数的数组和一个正整数target。找出该数组中满足其和≥target的长度最小的连续子数组[numsl,numsl+1,...,numsr-1,numsr]，并返回其长度。如果不存在符合条件的子数组，返回0。解答：法一：直接使用暴力法。两重循环，对每一个元素向后进行寻找，若找到一个子数组≥target，比较其长度和result的大小，如果其长度
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • 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
  • 209. 长度最小的子数组-滑动窗口 hequnwang10 JavaLeetCode算法
    一、题目描述给定一个含有n个正整数的数组和一个正整数target。找出该数组中满足其和≥target的长度最小的连续子数组[numsl,numsl+1,…,numsr-1,numsr]，并返回其长度。如果不存在符合条件的子数组，返回0。示例1：输入：target=7,nums=[2,3,1,2,4,3]输出：2解释：子数组[4,3]是该条件下的长度最小的子数组。示例2：输入：target=4,nu
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列C语言
    文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
  • 白骑士的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)同样是完成了取最大值的功能。
  • 多线程编程之存钱与取钱 周凡杨 javathread多线程存钱取钱
      生活费问题是这样的：学生每月都需要生活费，家长一次预存一段时间的生活费，家长和学生使用统一的一个帐号，在学生每次取帐号中一部分钱，直到帐号中没钱时 通知家长存钱，而家长看到帐户还有钱则不存钱，直到帐户没钱时才存钱。   问题分析：首先问题中有三个实体，学生、家长、银行账户，所以设计程序时就要设计三个类。其中银行账户只有一个，学生和家长操作的是同一个银行账户，学生的行为是
  • java中数组与List相互转换的方法 征客丶 JavaScriptjavajsonp
    1.List转换成为数组。（这里的List是实体是ArrayList) 　　调用ArrayList的toArray方法。 　　toArray 　　public T[] toArray(T[] a)返回一个按照正确的顺序包含此列表中所有元素的数组；返回数组的运行时类型就是指定数组的运行时类型。如果列表能放入指定的数组，则返回放入此列表元素的数组。否则，将根据指定数组的运行时类型和此列表的大小分
  • Shell 流程控制 daizj 流程控制if elsewhilecaseshell
    Shell 流程控制 和Java、PHP等语言不一样，sh的流程控制不可为空，如(以下为PHP流程控制写法)： <?php if(isset($_GET["q"])){ search(q);}else{// 不做任何事情} 在sh/bash里可不能这么写，如果else分支没有语句执行，就不要写这个else，就像这样 if else if if 语句语
  • Linux服务器新手操作之二 周凡杨 Linux 简单 操作
    1.利用关键字搜寻Man Pages    man -k keyword  其中-k 是选项，keyword是要搜寻的关键字 如果现在想使用whoami命令，但是只记住了前3个字符who，就可以使用 man -k who来搜寻关键字who的man命令       [haself@HA5-DZ26 ~]$ man -k
  • socket聊天室之服务器搭建 朱辉辉33 socket
    因为我们做的是聊天室，所以会有多个客户端，每个客户端我们用一个线程去实现，通过搭建一个服务器来实现从每个客户端来读取信息和发送信息。    我们先写客户端的线程。 public class ChatSocket extends Thread{ Socket socket; public ChatSocket(Socket socket){ this.sock
  • 利用finereport建设保险公司决策分析系统的思路和方法 老A不折腾 finereport金融保险分析系统报表系统项目开发
    决策分析系统呈现的是数据页面，也就是俗称的报表，报表与报表间、数据与数据间都按照一定的逻辑设定，是业务人员查看、分析数据的平台，更是辅助领导们运营决策的平台。底层数据决定上层分析，所以建设决策分析系统一般包括数据层处理（数据仓库建设）。   项目背景介绍 通常，保险公司信息化程度很高，基本上都有业务处理系统（像集团业务处理系统、老业务处理系统、个人代理人系统等）、数据服务系统（通过
  • 始终要页面在ifream的最顶层 林鹤霄
    index.jsp中有ifream，但是session消失后要让login.jsp始终显示到ifream的最顶层。。。始终没搞定，后来反复琢磨之后，得到了解决办法，在这儿给大家分享下。。 index.jsp--->主要是加了颜色的那一句 <html> <iframe name="top" ></iframe> <ifram
  • MySQL binlog恢复数据 aigo mysql
    1，先确保my.ini已经配置了binlog：   # binlog log_bin = D:/mysql-5.6.21-winx64/log/binlog/mysql-bin.log log_bin_index = D:/mysql-5.6.21-winx64/log/binlog/mysql-bin.index log_error = D:/mysql-5.6.21-win
  • OCX打成CBA包并实现自动安装与自动升级 alxw4616 ocxcab
    近来手上有个项目,需要使用ocx控件 (ocx是什么? http://baike.baidu.com/view/393671.htm) 在生产过程中我遇到了如下问题. 1. 如何让 ocx 自动安装?     a) 如何签名?     b) 如何打包?     c) 如何安装到指定目录? 2.
  • Hashmap队列和PriorityQueue队列的应用 百合不是茶 Hashmap队列PriorityQueue队列
      HashMap队列已经是学过了的,但是最近在用的时候不是很熟悉,刚刚重新看以一次,   HashMap是K,v键 ,值     put()添加元素      //下面试HashMap去掉重复的 package com.hashMapandPriorityQueue; import java.util.H
  • JDK1.5 returnvalue实例 bijian1013 javathreadjava多线程returnvalue
    Callable接口： 返回结果并且可能抛出异常的任务。实现者定义了一个不带任何参数的叫做 call 的方法。 Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。        ExecutorService接口方
  • angularjs指令中动态编译的方法(适用于有异步请求的情况) 内嵌指令无效 bijian1013 JavaScriptAngularJS
            在directive的link中有一个$http请求，当请求完成后根据返回的值动态做element.append('......');这个操作，能显示没问题，可问题是我动态组的HTML里面有ng-click，发现显示出来的内容根本不执行ng-click绑定的方法！     
  • 【Java范型二】Java范型详解之extend限定范型参数的类型 bit1129 extend
    在第一篇中，定义范型类时，使用如下的方式：   public class Generics<M, S, N> { //M,S,N是范型参数 }  这种方式定义的范型类有两个基本的问题：   1. 范型参数定义的实例字段，如private M m = null;由于M的类型在运行时才能确定，那么我们在类的方法中，无法使用m，这跟定义pri
  • 【HBase十三】HBase知识点总结 bit1129 hbase
    1. 数据从MemStore flush到磁盘的触发条件有哪些？    a.显式调用flush，比如flush 'mytable'    b.MemStore中的数据容量超过flush的指定容量，hbase.hregion.memstore.flush.size,默认值是64M 2. Region的构成是怎么样？ 1个Region由若干个Store组成
  • 服务器被DDOS攻击防御的SHELL脚本 ronin47
    mkdir /root/bin vi /root/bin/dropip.sh #!/bin/bash/bin/netstat -na|grep ESTABLISHED|awk ‘{print $5}’|awk -F:‘{print $1}’|sort|uniq -c|sort -rn|head -10|grep -v -E ’192.168|127.0′|awk ‘{if($2!=null&a
  • java程序员生存手册-craps 游戏-一个简单的游戏 bylijinnan java
    import java.util.Random; public class CrapsGame { /** * *一个简单的赌*博游戏，游戏规则如下： *玩家掷两个骰子，点数为1到6，如果第一次点数和为7或11，则玩家胜， *如果点数和为2、3或12，则玩家输， *如果和为其它点数，则记录第一次的点数和，然后继续掷骰，直至点数和等于第一次掷出的点
  • TOMCAT启动提示NB: JAVA_HOME should point to a JDK not a JRE解决 开窍的石头 JAVA_HOME
    当tomcat是解压的时候，用eclipse启动正常，点击startup.bat的时候启动报错; 报错如下：   The JAVA_HOME environment variable is not defined correctly This environment variable is needed to run this program NB: JAVA_HOME shou
  • [操作系统内核]操作系统与互联网 comsci 操作系统
         我首先申明：我这里所说的问题并不是针对哪个厂商的，仅仅是描述我对操作系统技术的一些看法       操作系统是一种与硬件层关系非常密切的系统软件，按理说，这种系统软件应该是由设计CPU和硬件板卡的厂商开发的，和软件公司没有直接的关系，也就是说，操作系统应该由做硬件的厂商来设计和开发
  • 富文本框ckeditor_4.4.7 文本框的简单使用 支持IE11 cuityang 富文本框
    <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> <title>知识库内容编辑</tit
  • Property null not found darrenzhu datagridFlexAdvancedpropery null
    When you got error message like "Property null not found ***", try to fix it by the following way: 1)if you are using AdvancedDatagrid, make sure you only update the data in the data prov
  • MySQl数据库字符串替换函数使用 dcj3sjt126com mysql函数替换
    需求：需要将数据表中一个字段的值里面的所有的  .   替换成  _   原来的数据是  site.title  site.keywords  .... 替换后要为     site_title  site_keywords   使用的SQL语句如下：   updat
  • mac上终端起动MySQL的方法 dcj3sjt126com mysqlmac
    首先去官网下载: http://www.mysql.com/downloads/ 我下载了5.6.11的dmg然后安装,安装完成之后..如果要用终端去玩SQL.那么一开始要输入很长的:/usr/local/mysql/bin/mysql 这不方便啊,好想像windows下的cmd里面一样输入mysql -uroot -p1这样...上网查了下..可以实现滴. 打开终端,输入: 1
  • Gson使用一（Gson） eksliang jsongson
    转载请出自出处：http://eksliang.iteye.com/blog/2175401 一.概述 从结构上看Json，所有的数据（data）最终都可以分解成三种类型： 第一种类型是标量（scalar），也就是一个单独的字符串（string）或数字（numbers），比如"ickes"这个字符串。 第二种类型是序列（sequence），又叫做数组（array）
  • android点滴4 gundumw100 android
    Android 47个小知识 http://www.open-open.com/lib/view/open1422676091314.html Android实用代码七段（一） http://www.cnblogs.com/over140/archive/2012/09/26/2611999.html http://www.cnblogs.com/over140/arch
  • JavaWeb之JSP基本语法 ihuning javaweb
      目录   JSP模版元素  JSP表达式  JSP脚本片断  EL表达式  JSP注释  特殊字符序列的转义处理  如何查找JSP页面中的错误   JSP模版元素    JSP页面中的静态HTML内容称之为JSP模版元素，在静态的HTML内容之中可以嵌套JSP
  • App Extension编程指南（iOS8/OS X v10.10）中文版 啸笑天 ext
             当iOS 8.0和OS X v10.10发布后，一个全新的概念出现在我们眼前，那就是应用扩展。顾名思义，应用扩展允许开发者扩展应用的自定义功能和内容，能够让用户在使用其他app时使用该项功能。你可以开发一个应用扩展来执行某些特定的任务，用户使用该扩展后就可以在多个上下文环境中执行该任务。比如说，你提供了一个能让用户把内容分
  • SQLServer实现无限级树结构 macroli oraclesqlSQL Server
    表结构如下： 数据库id path titlesort 排序 1 0 首页 0 2 0,1 新闻 1 3 0,2 JAVA 2 4 0,3 JSP 3 5 0,2,3 业界动态 2 6 0,2,3 国内新闻 1 创建一个存储过程来实现，如果要在页面上使用可以设置一个返回变量将至传过去   create procedure test as begin decla
  • Css居中div，Css居中img，Css居中文本，Css垂直居中div qiaolevip 众观千象学习永无止境每天进步一点点css
    /**********Css居中Div**********/ div.center { width: 100px; margin: 0 auto; } /**********Css居中img**********/ img.center { display: block; margin-left: auto; margin-right: auto; }
  • Oracle 常用操作(实用) 吃猫的鱼 oracle
    SQL>select text from all_source where owner=user and name=upper('&plsql_name');  SQL>select * from user_ind_columns where index_name=upper('&index_name');  将表记录恢复到指定时间段以前
  • iOS中使用RSA对数据进行加密解密 witcheryne iosrsaiPhoneobjective c
      RSA算法是一种非对称加密算法,常被用于加密数据传输.如果配合上数字摘要算法, 也可以用于文件签名. 本文将讨论如何在iOS中使用RSA传输加密数据. 本文环境 mac os  openssl-1.0.1j, openssl需要使用1.x版本, 推荐使用[homebrew](http://brew.sh/)安装. Java 8 RSA基本原理 RS
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他