精华内容
下载资源
问答
  • OpenJDK8 Map相关内容

    2021-04-08 21:05:52
    其中,Hashtable线程安全(从1.0版本就有),而HashMap非线程安全(1.2版本),下文主要以两者的区分进行源码分析。 1. Hashtable 1.1 数据结构 数组+链表 1.2 初始化 默认容量大小11 默认负载因子0.75 1.3 扩容...

    还记得之前有过源码学习记录,这次重新回顾,还是有一些新的收获。
    今天的内容暂不包含JUC包下的Map类型,先上整体的类结构图。
    在这里插入图片描述

    所有的类型实现Map接口,最最常见的是Hashtable和HashMap。其中,Hashtable线程安全(从1.0版本就有),而HashMap非线程安全(1.2版本),下文主要以两者的区分进行源码分析。

    1. Hashtable

    1.1 数据结构

    数组+链表
    在这里插入图片描述

    1.2 初始化

    默认容量大小11
    默认负载因子0.75

    1.3 扩容时机

    当put新元素时,先扩容再插入

    	private void addEntry(int hash, K key, V value, int index) {
            modCount++;
    
            Entry<?,?> tab[] = table;
            if (count >= threshold) {
                // 当元素量达到阈值时(容量*0.75),进行rehash扩容操作
                rehash();
    
                tab = table;
                hash = key.hashCode();
                index = (hash & 0x7FFFFFFF) % tab.length;
            }
    
            // 头插法添加新的元素
            @SuppressWarnings("unchecked")
            Entry<K,V> e = (Entry<K,V>) tab[index];
            tab[index] = new Entry<>(hash, key, value, e);
            count++;
        }
    

    1.4 扩容大小

    源码主要在上面调用的rehash()

    	protected void rehash() {
            int oldCapacity = table.length;
            Entry<?,?>[] oldMap = table;
    
            // 新的容量大小设置,正常情况都是按 newCap=2*oldCap+1
            int newCapacity = (oldCapacity << 1) + 1;
            if (newCapacity - MAX_ARRAY_SIZE > 0) {
                if (oldCapacity == MAX_ARRAY_SIZE)
                    return;
                newCapacity = MAX_ARRAY_SIZE;
            }
            Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];
    
            modCount++;
            threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
            table = newMap;
            
            // 旧的元素迁移到新分配的newMap中(hash+头插)
            for (int i = oldCapacity ; i-- > 0 ;) {
                for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
                    Entry<K,V> e = old;
                    old = old.next;
    
                    int index = (e.hash & 0x7FFFFFFF) % newCapacity;
                    e.next = (Entry<K,V>)newMap[index];
                    newMap[index] = e;
                }
            }
        }
    

    扩容大小 int newCapacity = (oldCapacity << 1) + 1,即新容量=旧容量*2+1
    之所以要+1,是要尽量保持容量为质数,保证hash分布尽量均匀,以减少发生hash冲突的概率,同时能够减少单个桶内链表的长度;

    1.5 遍历方式

    支持旧的Enumeration方式(1.0版本既有);
    支持Iterator方式(1.2版本,官方推荐,支持fail-fast)

    2. HashMap

    2.1 数据结构

    数组+链表/红黑树

    2.2 初始化

    默认容量大小16
    默认负载因子0.75

    2.3 扩容时机

    当put新元素时,先插入再扩容

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                       boolean evict) {
            Node<K,V>[] tab; Node<K,V> p; int n, i;
            if ((tab = table) == null || (n = tab.length) == 0)
                n = (tab = resize()).length;
            if ((p = tab[i = (n - 1) & hash]) == null)
                // 桶中无节点,直接新建链表节点
                tab[i] = newNode(hash, key, value, null);
            else {
                Node<K,V> e; K k;
                // 桶中刚好存在该key,且就在链表头
                if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                    e = p;
                else if (p instanceof TreeNode)
                    // 如果桶中存储的是树形结构,添加树节点
                    e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
                else {
                    for (int binCount = 0; ; ++binCount) {
                        // 现有hashMap中不存在该key
                        if ((e = p.next) == null) {
                            p.next = newNode(hash, key, value, null);
                            // 达到树形化阈值,将桶中元素树形化
                            if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                                treeifyBin(tab, hash);
                            break;
                        }
                        // 现有hashMap中已存在该key
                        if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                            break;
                        p = e;
                    }
                }
                // 替换原key中的旧值,并返回该旧值
                if (e != null) { 
                    V oldValue = e.value;
                    if (!onlyIfAbsent || oldValue == null)
                        e.value = value;
                    afterNodeAccess(e);
                    return oldValue;
                }
            }
            ++modCount;
            // 插入新元素后,元素量达到阈值,才执行resize扩容操作
            if (++size > threshold)
                resize();
            afterNodeInsertion(evict);
            return null;
        }
    

    2.4 扩容大小

    相关逻辑主要在上面调用的resize()方法。

    final Node<K,V>[] resize() {
            Node<K,V>[] oldTab = table;
            int oldCap = (oldTab == null) ? 0 : oldTab.length;
            int oldThr = threshold;
            int newCap, newThr = 0;
            if (oldCap > 0) {
                if (oldCap >= MAXIMUM_CAPACITY) {
                    threshold = Integer.MAX_VALUE;
                    return oldTab;
                }
                // 新的容量大小扩大为原来的2倍
                else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                         oldCap >= DEFAULT_INITIAL_CAPACITY)
                    newThr = oldThr << 1; // double threshold
            }
            else if (oldThr > 0) // initial capacity was placed in threshold
                newCap = oldThr;
            else {               // zero initial threshold signifies using defaults
                newCap = DEFAULT_INITIAL_CAPACITY;
                newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
            }
            if (newThr == 0) {
                float ft = (float)newCap * loadFactor;
                newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                          (int)ft : Integer.MAX_VALUE);
            }
            threshold = newThr;
            ...
            // 省略后面的大坨元素rehash步骤,
        }
    

    newCap = oldCap*2,且容量永远为2的幂次大小。
    补充点:

    1. jdk8中对HashMap的rehash做了优化,通过(e.hash & oldCap)==0来判断将原元素放回原来的j桶还是挪到新的j+oldCap桶中。这也是HashMap保持2的幂次容量的优势所在。感兴趣的话,可以自行服用
    2. 同时必须提一点:JDK7之前,resize过程中采用类似Hashtable中的头插法, 这在多线程环境下可能产生链表循环导致死锁,因此JDK8中做了改进,采用尾插法处理桶中元素,避免了死锁。

    2.5 遍历方式

    只支持Iterator迭代器方式

    3. 附上Hashtable与HashMap主要的异同点整理

    Hashtable HashMap IdentityHashMap
    数据结构 数组+链表 数组+链表/红黑树 数组
    默认容量 11 16 64
    负载因子 0.75 0.75 -
    扩容时机 先扩容再插入 先插入再扩容 先计数再扩容最后插入
    扩容大小 2*n+1 2*n 2*n
    扩容元素rehash 头插法 尾插法 数组遍历
    迭代方式 Enumeration、Iterator Iterator -
    线程安全性 安全 不安全 不安全

    4. jdk8中对Map接口的扩充

    	 /**
         * 如果key存在,返回key对应的值;
         * 如果key不存在,返回默认值defaultValue
         * @since 1.8
         */
        default V getOrDefault(Object key, V defaultValue) 
    
        /**
         * @since 1.8
         */
        default void forEach(BiConsumer<? super K, ? super V> action) 
    
        /**
         * @since 1.8
         */
        default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function)
    
        /**
         * 如果key存在,不变,返回原来的值
         * 如果key不存在,设置value值,并返回null
         * @since 1.8
         */
        default V putIfAbsent(K key, V value) 
    
        /**
         * 如果存在指定键值对(key,value都要一致),删除指定键值对的元素,返回true
         * 如果不存在指定键值对,删除指定键值对的元素,返回false
         * @since 1.8
         */
        default boolean remove(Object key, Object value) 
    
        /**
         * 根据指定键值对,设置新值
         * @since 1.8
         */
        default boolean replace(K key, V oldValue, V newValue) 
    
        /**
         * 如果存在key,替换值,返回旧值
         * 如果不存在key,不作操作,返回null
         * @since 1.8
         */
        default V replace(K key, V value) 
    
        /**
         * @since 1.8
         */
        default V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) 
    
        /**
         * @since 1.8
         */
        default V computeIfPresent(K key,
                BiFunction<? super K, ? super V, ? extends V> remappingFunction)
    
        /**
         * @since 1.8
         */
        default V compute(K key,BiFunction<? super K, ? super V, ? extends V> remappingFunction)
    
         /**
         * @since 1.8
         */
        default V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction)
    

    5. 其它结构

    5.1 LinkedHashMap

    继承自HashMap类,其中的Entry元素内部添加了两个指针,分别表示前继元素和后继元素,从而实现带有双向链表的HashMap结构。
    主要的三个属性

        /**
         * 双向链表的头节点(最老)
         */
        transient LinkedHashMap.Entry<K,V> head;
    
        /**
         * 双向链表的尾节点(最新)
         */
        transient LinkedHashMap.Entry<K,V> tail;
    
        /**
         * 链式hashmap的迭代顺序
         * true 基于访问顺序
         * false 基于插入顺序(默认)
         * 定义为final, 初始化后不能改变,不然计算modCount结构变动次数会乱
         * @serial
         */
        final boolean accessOrder;
    

    其中,可以关注的是accessOrder属性,分为两种模式:

    1)true : 基于访问顺序方式。

    由于LinkedHashMap重写了父类get及getOrDefault方法,每次get某个key时,会调用afterNodeAccess(e),将最近查询的节点挪到链表末尾,从而很容易就能实现LRU等类似的缓存逻辑。

     /**
         * 根据键获取值
         * 重写方法,追加访问序时的结构变动记录
         */
        public V get(Object key) {
            Node<K,V> e;
            if ((e = getNode(hash(key), key)) == null)
                return null;
            if (accessOrder)
                afterNodeAccess(e);
            return e.value;
        }
    
        /**
         * 重写方法,追加访问序时的结构变动记录
         * {@inheritDoc}
         */
        public V getOrDefault(Object key, V defaultValue) {
           Node<K,V> e;
           if ((e = getNode(hash(key), key)) == null)
               return defaultValue;
           if (accessOrder)
               afterNodeAccess(e);
           return e.value;
       }
    

    注意点
    由于每次调用get(Object key)时,LinkedHashMap会将最近访问的元素挪到链表末尾,因此迭代时不能使用get方法,否则会报ConcurrentModifedException.

    2)false: 基于插入顺序方式(默认)

    链表按key的插入顺序进行维护,更新已有的键值对不会更新现有的链表顺序。

    5.2 TreeMap

    继承自AbstractMap和SortedMap基于红黑树存储的实现,其中元素顺序遵从key排序,同时支持自定义key的比较器。

      /**
         * 决定节点排序的自定义比较器
         * @serial
         */
        private final Comparator<? super K> comparator;
    
        /**
         * 红黑树的根节点
         */
        private transient Entry<K,V> root;
    

    因为采用了树形结构,所以并不需要像HashMap和Hashtable中那样的resize及rehash操作。
    TreeMap(1.6)提供了一系列方便获取节点的操作,简单列举如下:

    	/**
         * 返回小于指定key的元素(键值对)
         * @since 1.6
         */
        public Map.Entry<K,V> lowerEntry(K key)
        /**
         * 返回小于指定key的键
         * @since 1.6
         */
        public K lowerKey(K key) 
        /**
         * 返回小于等于指定key 的最大元素(键值对)
         * @since 1.6
         */
        public Map.Entry<K,V> floorEntry(K key)
        /**
         * 返回小于等于指定key的最大key
         * @since 1.6
         */
        public K floorKey(K key) 
        /**
         * 返回大于等于指定key的最小元素
         * @since 1.6
         */
        public Map.Entry<K,V> ceilingEntry(K key)
        /**
         * 返回大于等于指定key的最小key
         * @since 1.6
         */
        public K ceilingKey(K key)
        /**
         * 返回大于指定key的最小元素
         * @since 1.6
         */
        public Map.Entry<K,V> higherEntry(K key)
        /**
         * 返回大于指定key的最小key
         * @since 1.6
         */
        public K higherKey(K key) 
    

    截取子map操作

    /**
         * 截取子map,支持指定左边界、右边界自定义
         * @since 1.6
         */
        public NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)
        public NavigableMap<K,V> headMap(K toKey, boolean inclusive)
        public NavigableMap<K,V> tailMap(K fromKey, boolean inclusive)
        public SortedMap<K,V> subMap(K fromKey, K toKey)
        public SortedMap<K,V> headMap(K toKey) 
        public SortedMap<K,V> tailMap(K fromKey)
    

    5.3 IdentityHashMap

    继承自AbstractMap,而不是HashMap。主要区别在于其它类型都是针对key的equals方法查找目的元素,而IdentityHashMap是针对key的引用("==")查找。

    5.3.1 数据结构

    采用数组。key和value连着存储,占两个数组索引

    5.3.2 初始化

    初始化容量(没有实际属性): 32
    初始化table大小: 容量*2

    5.3.3 扩容时机

    当前元素size*3> table大小时,触发扩容。
    总的来说是:先计数,再扩容,最后插入元素

    public V put(K key, V value) {
            final Object k = maskNull(key);
    
            retryAfterResize: for (;;) {
               ...
    
                // 先计数
                final int s = size + 1;
                // Use optimized form of 3 * s.
                // Next capacity is len, 2 * current capacity.
                // 扩容
                if (s + (s << 1) > len && resize(len))
                    continue retryAfterResize;
    
                modCount++;
                // 插入k-v
                tab[i] = k;
                tab[i + 1] = value;
                size = s;
                return null;
            }
        }
    

    5.3.4 扩容大小

    新容量扩为原来的2倍

    private boolean resize(int newCapacity) {
            // 新容量扩大为2倍
            int newLength = newCapacity * 2;
    
            Object[] oldTable = table;
            int oldLength = oldTable.length;
            if (oldLength == 2 * MAXIMUM_CAPACITY) { // can't expand any further
                if (size == MAXIMUM_CAPACITY - 1)
                    throw new IllegalStateException("Capacity exhausted.");
                return false;
            }
            if (oldLength >= newLength)
                return false;
    
            Object[] newTable = new Object[newLength];
    
            for (int j = 0; j < oldLength; j += 2) {
                Object key = oldTable[j];
                if (key != null) {
                    Object value = oldTable[j+1];
                    oldTable[j] = null;
                    oldTable[j+1] = null;
                    int i = hash(key, newLength);
                    // 发生hash冲突,往右边遍历找空位
                    while (newTable[i] != null)
                        i = nextKeyIndex(i, newLength);
                    newTable[i] = key;
                    newTable[i + 1] = value;
                }
            }
            table = newTable;
            return true;
        }
    

    以上主要是我个人阅读源码的一点记录汇总,不得不说整理还是比较耗时间的,我人又不是那么勤快,所以每次只能弄一部分。
    如果内容有所纰漏,请及时指出,我会及时修正,谢谢!

    展开全文
  • 注意用yum安装注意区分openjdk和jdk,openjdk不是oracle的官方jdk,是一个开源jdk,官方的是oracle公司的jdk jdk第一种安装方式:yum一键式安装 安装命令:yum install -y java-1.8.0-openjdk-devel.x86_64 安装过程...

    Linux环境下安装jdk及环境配置的两种方式

    第一步判断有没有安装jdk
    命令:java -version
    jdk尚未安装:
    还没有安装idk
    jdk已完成安装:
    jdk已经安装成功
    注意用yum安装注意区分openjdk和jdk,openjdk不是oracle的官方jdk,是一个开源jdk,官方的是oracle公司的jdk

    jdk第一种安装方式:yum一键式安装
    安装命令:yum install -y java-1.8.0-openjdk-devel.x86_64
    安装过程 控制台停止选择输入(y)继续执行直到控制台返回Complete安装成功
    安装完毕
    查看版本信息
    一键安装jdk

    jdk第二种安装方式:手动安装(个人推荐)

    1.创建文件夹命令:mkdir /usr/local/java
    在这里插入图片描述
    2.将官网上下载linux版本的JDK并上传解压
    上传:
    在这里插入图片描述
    解压:tar -xvf jdk-8u271-linux-aarch64.tar.gz
    解压
    3.配置环境变量
    命令 vim /etc/profile
    配置环境变量
    在文件尾部添加如下信息:

    JAVA_HOME=/usr/local/java/jdk1.8.0_271(jdk解压文件夹目录)
    PATH=$JAVA_HOME/bin:$PATH
    CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
    export JAVA_HOME
    export PATH
    export CLASSPATH
    

    配置环境变量
    4.编辑保存完毕刷新资源环境变量生效
    命令:source /etc/profile
    在这里插入图片描述

    卸载jdk
    1.查看JDK的安装路径命令:which java
    2.卸载 JDK命令:rm -rf /usr/bin/java(注意文件夹为指执行which java后文件夹)
    找到jdk的安装目录
    在这里插入图片描述

    展开全文
  • 之前专门编译通过,昨天调整了目录结构,准备做个备份,...吾使用脚本自动区分Win32/x64,并进行相应的复制工作。 使用的目录只有lib,没有include。  明白了这个原因,那好办,改进了一下脚本,编译顺利进行。 ...

      之前专门编译通过,昨天调整了目录结构,准备做个备份,结果就出了这样的错误。

      后来终于明白:

    • 吾使用脚本自动区分Win32/x64,并进行相应的复制工作。
    • 使用的目录只有lib,没有include。

      明白了这个原因,那好办,改进了一下脚本,编译顺利进行。

    展开全文
  • Ubuntu Linux下安装Oracle JDK

    万次阅读 2014-04-22 18:40:55
    Ubuntu Linux下安装Oracle JDK Dennis Hu 2014-4-22 说明:由于很多系统不支持使用OpenJDK,因此在ubuntu下会需要安装Oracle JDK。而Oracle JDK的安装貌似没有提供apt方式,因此...第一步:区分32位还是64位操
    Ubuntu Linux下安装Oracle JDK
    Dennis Hu 2014-4-22

    说明:由于很多系统不支持使用OpenJDK,因此在ubuntu下会需要安装Oracle JDK。而Oracle JDK的安装貌似没有提供apt方式,因此安装Oracle JDK的方式相对麻烦一些,我经常安装,为了方便别人同时方便自己查看,把它记下来。

    第一步:区分32位还是64位操作系统
    先确定你的ubuntu linux是32位还是64位的,方法很多,这里介绍一种即可。
    $uname -a

    第二步:卸载OpenJDK
    先执行如下命令看是否安装了OpenJDK,如果已经安装,会显示java的信息。
    $java -version

    如果安装了OpenJDK,可用如下方法全部卸载:
    $sudo apt-get purge openjdk-\*

    第三步:下载Oracle JDK版本
    注:这里以Oracle 1.6 64位的为例
    进入 http://www.oracle.com/technetwork/java/javasebusiness/downloads/java-archive-downloads-javase6-419409.html,选择"Java SE Development Kit 6u45",然后在新打开的页面点选接受"Accept License Agreement". 接受之后,选择" jdk-6u45-linux-x64.bin"即可进行下载。如果你没有登录,系统会先转到登录页面,输入你在Oracle网站注册的用户名和密码即可。

    第三步:安装Oracle JDK
    (1) 创建java目录
    $ sudo mkdir -p /usr/local/java
    将你下载的jdk-6u45-linux-x64.bin拷贝至/usr/local/java目录
    $ cd /usr/local/java
    $ sudo cp /home/dennis/Downloads/jdk-6u45-linux-x64.bin .

    (2) 解压bin文件
    $ sudo chmod +x jdk-6u45-linux-x64.bin
    $ sudo ./jdk-6u45-linux-x64.bin
    $ sudo rm -rf jdk-6u45-linux-x64.bin

    第四步:配置Orache JDK
     (1) 配置JAVA_HOME和PATH环境变量
    $ sudo vi /etc/profile
    在该文件的末尾加上如下部分:
    JAVA_HOME=/usr/local/java/jdk1.6.0_45
    PATH=$PATH:$HOME/bin:$JAVA_HOME/bin
    export JAVA_HOME
    export PATH

    (2) 配置ubuntu的JDK和JRE的位置
    $ sudo update-alternatives --install "/usr/bin/java" "java" "/usr/local/java/jdk1.6.0_45/bin/java" 1
    $ sudo update-alternatives --install "/usr/bin/javac" "javac" "/usr/local/java/jdk1.6.0_45/bin/javac" 1
    $ sudo update-alternatives --install "/usr/bin/javaws" "javaws" "/usr/local/java/jdk1.6.0_45/bin/javaws" 1

    (3) 配置Oracle为系统默认JDK/JRE
    $ sudo update-alternatives --set java /usr/local/java/jdk1.6.0_45/bin/java
    $ sudo update-alternatives --set javac /usr/local/java/jdk1.6.0_45/bin/javac
    $ sudo update-alternatives --set javaws /usr/local/java/jdk1.6.0_45/bin/javaws

    配置完成后,执行如下命令使其立即生效。
    $ . /etc/profile
    再次执行"java -version"显示如下:
    dennis@dubuntu1404:~$ java -version
    java version "1.6.0_45"
    Java(TM) SE Runtime Environment (build 1.6.0_45-b06)
    Java HotSpot(TM) 64-Bit Server VM (build 20.45-b01, mixed mode)


    参考资料:

    展开全文
  • 第一步:区分系统是32位还是64位 #uname -a 第二步:卸载OpenJDK $java -version //查看是否安装的是OpenJDK $sudo apt-get purge openjdk-\* //如果是,则卸载 第三步:下载Oralce JDK 访问Oracle官方...
  • 第一步:区分32位还是64位操作系统 先确定你的ubuntu linux是32位还是64位的,方法很多,这里介绍一种即可。 $uname -a 第二步:卸载OpenJDK 先执行如下命令看是否安装了OpenJDK,如果已经安装,会显示java的信息。 ...
  • 1.下载 ORACLE JDK地址:点此2....区分32位还是64位操作系统先确定你的ubuntu linux是32位还是64位的,方法很多,这里介绍一种即可。$uname -a4.卸载OpenJDK先执行如下命令看是否安装了OpenJDK,如果已...
  • 简单的不区分大小写的目录搜索。 用纯Java 11编写。 准备好了 准备好了 ISC许可证 高覆盖率自动化测试套件 动机 提供了FileChooser和DirectoryChooser类,它们委托给每个平台上操作系统的默认文件选择器实现。 这...
  • JDK环境变量配置记录

    2020-04-21 17:17:01
      写这篇文章呢只是为了以后再配Java环境的时候不去搜索环境搭建教程,虽然大学到...1.首先到该网站https://www.oracle.com/java/technologies/javase-downloads.html,注意区分JDK和OpenJDK,我的JDK是jdk1.8.0_...
  • spark的部署方式

    2015-12-25 11:53:00
    一直以为spark区分几种集群的模式是由配置更改而改变. 经过使用发现,区分这几种模式的在于启动命令时指定的master. ...export JAVA_HOME=/usr/lib/jvm/java-1.7.0-openjdk-1.7.0.65.x86_64/ export S...
  • Chapter 1 Java平台概论

    2017-10-16 14:58:14
    Chapter 1 Java平台概论Chapter 1 ...14 Oracle JDK与OpenJDK 15 建议的学习路径 2 JVMJREJDK 21 什么是JVM 22 区分JRE与JDK 23 下载安装JDK 24 认识JDK安装内容1.1 Java不只是语言从1995年至今,Java已经过20个年头
  • centos

    2018-04-07 18:25:00
    yum install java-1.8.0-openjdk* ls 显示结果以不同的颜色来区分文件类别。 蓝色代表目录,灰色代表普通文件,绿色代表可执行文件,红色代表压缩文件,浅蓝色代表链接文件。 cp 文件 文件夹 //将文件copy到...
  • 说明:由于很多系统不支持使用OpenJDK,因此在ubuntu下会需要安装OracleJDK。而Oracle JDK的安装貌似没有提供apt方式,因此安装OracleJDK的方式相对麻烦一些,我经常安装,为了方便别人同时方便自己查看,把它记下来...
  • aosp编译环境搭建

    2016-12-27 00:07:29
    说明:由于Android-5.0 之前不支持使用OpenJDK进行aosp的编译,因此在ubuntu下会需要安装Oracle JDK(有两种方式)。方式一:使用apt安装–需要配置对应的ppa.方式二: 手动下载jdk安装,下面将安装过程整理一下 第...
  • linux下安装jdk

    2018-05-23 13:41:21
    最近在linux下倒腾部署项目,其中一个项目启动老失败,查看了一下日志,发现缺少一个依赖,最后检查的时候发现这个服务器用的是openjdk,于是卸载重新安装 然后下面是网上找的攻略:     步骤一、下载安装包 ...
  • 说明:由于很多系统不支持使用OpenJDK,因此在ubuntu下会需要安装Oracle JDK。而Oracle JDK的安装貌似没有提供apt方式,因此安装Oracle JDK的方式相对麻烦一些,我经常安装,为了方便别人同时方便自己查看,把它记...

空空如也

空空如也

1 2
收藏数 24
精华内容 9
关键字:

区分openjdk