Java学习笔记：集合

最新推荐文章于 2024-06-09 18:24:15 发布
最新推荐文章于 2024-06-09 18:24:15 发布
阅读量303 收藏
点赞数 1
分类专栏： 学习笔记 文章标签： java hashmap 集合 arraylist
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Carmelo7A/article/details/113755010
版权

AJava学习笔记：集合

文章目录

一：集合框架概述

​ 集合、数组都是对多个数据进行存储操作的结构，简称Java容器

说明：此时的存储，主要指的是内存层的面的存储，不涉及到持久化的存储（.txt，.jpg，.avi，数据库中存储）

集合框架：

Collection接口：单列接口，用来存储一个一个的对象

list接口：存储有序的、可重复的数据。—>“动态”数组

ArrayList、LinkedList、Vector

Set接口：存储无序的、不可重复的数据。—>高中讲的“集合”

HashSet、LinkedHashList、TreeSet

Map接口：双列接口，用来存储一对（key-value）的数据—>高中函数：y=f(x),x相当于key，y相当于value

HashMap、LinkedList、TreeMap、Hashtable、Properties

二：Collection接口：单列接口，用来存储一个一个的对象

1.Collection常用方法

​ add（object e）：将e添加进集合中

​ size():获取添加元素的个数

​ addAll（Collection coll1）：将coll1添加进集合coll中、

​ clear():删除集合中所有元素

​ contains(Object obj):判断当前集合中是否包含obj，此方法在判断时会调用obj所在类的equals()

​ containsAll(Collection coll1):判断参数集合是否去全部存在于当前集合中

​ remove(Object obj):从当前集合移除一个数据，成功返回true，失败返回false

​ removeAll(Collection coll1):（把当前集合修改了）从当前集合移除全部coll1中的元素(移除交集)

​ retainAll(Collection coll1)：求交集，（把当前集合修改了）

​ equals(Object obj):判断两个集合是否完全相等

​ hasCode():返回当前对象的哈希值

​ toArray():集合转换为数组

//拓展：数组-->集合  调用Arrays类的静态方法asList()
        List<Object> objects = Arrays.asList(array);
        System.out.println(objects);

        List<int[]> ints = Arrays.asList(new int[]{123, 456});
        System.out.println(ints);//识别为一个元素
        System.out.println(ints.size());//1

        List ints1 = Arrays.asList(new Integer[]{123, 456});
        System.out.println(ints1.size());//2

​ iterator():返回Iterator接口的实例，用于遍历集合元素

2.集合的遍历

方式一：迭代器

集合元素的遍历操作,使用迭代器Iterator接口
hasnext() 与next()混合使用
每次用集合调用iterator()都会得到一个全新的迭代器对象，默认游标都在第一个元素之前。

public class IteratorTest {
    @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add("aa");
        coll.add("bb");
        coll.add(123);
        coll.add(new Date());

        Iterator iterator = coll.iterator();
        //方式一：
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
        //异常：NoSuchElementException
//        System.out.println(iterator.next());
        //方式二：不推荐
//        for (int i = 0; i < coll.size(); i++) {
//            System.out.println(iterator.next());
//        }
        //方式三：推荐
        //hasNext()：判断是否还有下一个元素
        while (iterator.hasNext()){
            //next()：①指针下移②将下移后集合位置上的元素返回
            System.out.println(iterator.next());
        }

    }
}
方式二：foreach

jdk5.0新增了foreach，用于遍历集合和数组。

public class ForTest {
    @Test
    public void test1() {
        Collection coll = new ArrayList();
        coll.add("aa");
        coll.add("bb");
        coll.add(123);
        coll.add(new Date());
        //for(集合元素的类型 局部变量名：集合对象)
        //内部仍然调用了迭代器
        for (Object object : coll) {
            System.out.println(object);
        }
    }

    @Test
    public void test2() {
        int[] arr = new int[]{1, 2, 3, 4, 5};
        for (int i : arr) {
            System.out.println(i);
        }
    }

    @Test
    public void test3() {
        String[] arr = new String[]{"gg", "gg", "gg"};
        //方式一：普通for循环赋值，原数组改变
//        for (int i = 0; i < arr.length; i++) {
//            arr[i] = "mm";
//        }
        //方式二：foreach循环赋值，取arr中每一个赋值给String s，对s赋值，原数组不改变
        for (String s : arr
        ) {
            s = "mm";
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}
方式三：Lambda表达式
list.forEach(s -> System.out.println(s));

3.list接口：存储有序的、可重复的数据。—>“动态”数组

list接口：存储有序的、可重复的数据。—>“动态”数组

ArrayList：作为List接口的主要实现类，线程不安全的，执行效率高，底层使用Object[] elementData存储

LinkedList：对于频繁的插入、删除操作，此类效率比ArrayList高，底层使用双向链表存储

Vector：作为List接口的古老实现类，线程安全的，执行效率低，底层使用Object[] elementData存储

3.1 ArrayList

ArrayList：作为List接口的主要实现类，线程不安全的，执行效率高，底层使用Object[] elementData存储。

ArrayList源码分析：

jdk7：
 *   ArrayList list = new ArrayList();//底层创建一个Object类型的数组，长度为10
 *   list.add(123);//elementData[0]=new Integer(123);
 *   ...
 *   list.add(11)//如果此次添加导致底层elementData数组容量不够，则扩容。
 *   默认情况下，扩容为原来的1.5倍，同时需要将原有数组中的数据复制到新的数组中。
 *   结论：建议开发中使用带参的构造器ArrayList list = new ArrayList(int Capacity)，避免扩容提高效率
jdk8中ArrayList的变化：
 *   ArrayList list = new ArrayList();//底层Object类型的数组 elementData初始化为{}，并没有创建长度为10的数组
 *   add.（123）//第一次调用add()时，底层才创建长度为10的数组，并添加第一个数据
 *   ...
 *   后续添加与扩容与jdk7无异。

小结：jdk7中的ArrayList的对象的创建类似于单例的饿汉式，jdk中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节约内存。

3.2 LinkedList

LinkedList：对于频繁的插入、删除操作，此类效率比ArrayList高，底层使用双向链表存储。

LinkedList源码分析：

 LinkedList list = new LinkedList()//内部声明了Node类型的first和last属性，默认值为null
 list.add(123)//将123封装到Node中，创建了Node对象。
3.3 Vector

作为List接口的古老实现类，线程安全的，执行效率低，底层使用Object[] elementData存储。

Vector源码分析：底层创建一个Object类型的数组，长度为10，默认情况下，扩容为原来的2倍。

面试题：ArrayList、LinkedList、Vector三者的异同？

同：都实现的List接口，存储数据的特点相同：存储有序的、可重复的数据。

3.4 List常用方法及遍历
public class ListTest {
    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("aaa");
        list.add("bbb");
        System.out.println(list);
        //add(int index,Object element):在index位置插入element
        list.add(1,"charu");
        //addAll(int index,Collection c):在index位置插入集合
        //get(int index):返回index的元素
        //indexOf(Object o)、lastindexOf(Object o):返回o在集合第一次(最后一次)出现的位置，不存在返回-1
        //remove(int index)：删除指定index位置的元素并返回此元素
        //set(int index,Object ele):设置index位置的元素为ele
        //subList(int fromIndex，int toIndex)：返回从fromIndex到toIndex位置的子集合（左闭右开）
    }
  //遍历：
  @Test
    public void test2(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("aaa");
        list.add("bbb");
        //方式一：iterator方式遍历
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("******************");
        //方式二：for、foreach方式遍历
        for (Object o:list
             ) {
            System.out.println(o);
        }
        System.out.println("******************");
        //方式三：lambda表达式
        list.forEach(s -> System.out.println(s+"lambda"));
    }
}

4.Set接口：存储无序的、不可重复的数据。—>高中讲的“集合”

Set接口：存储无序的、不可重复的数据。—>高中讲的“集合”

HashSet：作为Set接口的主要实现类，线程不安全的，可以储存null值

LinkedHashList：作为HashSet的子类；遍历其内部顺序时，可以按照添加的顺序去遍历作为HashSet的子类；遍历其内部顺序时，可以按照添加的顺序去遍历，对于频繁的遍历操作，LinkedHashSet高于HashSet

TreeSet：可以按照添加对象的指定属性，进行排序。

要求：

向Set中添加数据的类一定要重写hashCode()和equals()方法，

重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码。

4.1 HashSet

HashSet底层：数组+链表

一：Set：存储无序的、不可重复的数据
以HashSet为例说明：
1.无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的

2.不可重复性：保证添加的元素按照equals()判断时，不能返回true，即相同的元素只能添加一个。
二：添加元素的过程：以HashSet为例说明：
        向HashSet中添加元素a，首先调用元素a所在类的hashcode()方法，计算元素a的哈希值，此哈希值通过某种算法
        计算出在HashSet底层数组中的存放位置（即为索引位置），判断数组此位置上是否已经有元素：
        如果此位置上没有其他元素，直接把a放进去
        如果此位置上有其他元素b（或以链表形式存在的多个元素），则比较元素a与b的哈希值：
            如果哈希值不同，则元素a添加成功（jdk7以链表的方式接在b后面，jdk7把b挤走放在b的位置）（jdk7上jdk8下）
            如果哈希值相同，进而需要调用a所在类的equals()方法：
                equals()返回true，元素a添加失败。
                equals()返回false，元素a添加成功。

在这里插入图片描述

@Test
    public void test1(){
        Set set = new HashSet();
        set.add(456);
        set.add(123);
        set.add("aa");
        set.add("bb");

        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
4.2 LinkedHashSet

LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据的前一个和后一个数据。

优点：对于频繁的遍历操作，LinkedHashSet高于HashSet。

 @Test
    public void test2(){
        Set set = new LinkedHashSet();
        set.add(456);
        set.add(123);
        set.add("aa");
        set.add("bb");

        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
4.3 TreeSet

1.向TreeSet中添加的数据，必须是相同类的对象
2.两种排序方式：自然排序(集合中存的类实现Comparable接口)，定制排序（Comparator）(常用类中讲过)
添加数据的所属类实现一个Comparable接口，重写compareTo()方法
3.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0，不再是equals()
4.定制排序中，比较两个对象是否相同的标准为：compare()返回0，不再是equals()

public class TreeSetTest{
//自然排序
    @Test
    public void test1(){
        TreeSet set = new TreeSet();
        set.add(456);
        set.add(123);
        set.add(-534);
        set.add(55);

        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
//定制排序
    @Test
    public void test2(){
        Comparator comparator = new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return 0;
            }
        };
        TreeSet set = new TreeSet(comparator);

    }
}
4.4 关于HashSet底层结构的一个小练习
public class SetJingdian {
    @Test
    public void test1() {
        HashSet set = new HashSet();
        Person p1 = new Person(1001, "AA");
        Person p2 = new Person(1002, "BB");
		//Person类有id，name两个属性并提供构造方法，toString()以及equals()、hashCode()
        set.add(p1);
        set.add(p2);
        System.out.println(set);//2个

        p1.name = "CC";
        set.remove(p1);//移除1001CC计算出hash值的位置的p1，移除失败
        System.out.println(set);//2个
        set.add(new Person(1001, "CC"));//1001CC的哈希值位置上为空，不比equals，添加成功
        System.out.println(set);//3个
        set.add(new Person(1001, "AA"));//1001AA哈希值位置上有一个修改过的1001CC，比较equals不同，添加成功
        System.out.println(set);//4个

    }
}

三：Map接口：双列接口，用来存储一对（key-value）的数据—>高中函数：y=f(x),x相当于key，y相当于value

Map概述：

Map：双列数据，存储key-value对的数据—类似于高中函数 y=f（x）

HashMap：作为Map的主要实现类；线程不安全的，效率高；可以存储null的key和value

LinkedHashMap：保证在遍历map元素时，可以按照添加顺序去遍历

原因：在原有HashMap底层结构基础上，添加了一对指针，指向前一个和后一个键值对,对于频繁的遍历操作，此类执行效率高于HashMap

TreeMap：保证按照添加的key-value对进行排序，实现排序遍历。（key的自然排序和定制排序）底层使用红黑树。

Hashtable：作为古老的实现类；线程安全的，效率低；不能存储null的key和value

Properties：常用来处理配置文件。key和value都是String类型

Map的结构理解:

Map中的key：无序的、不可重复的，使用Set存储所有key —>hashMap中，key所在的类要重写equals()和hashCode()

Map中的value：无序的、不可重复的，使用Collection存储所有value —>value所在的类要重写equals()
一个键值对中：key-value构成一个Entry对象

Map中的Entry：无序的、不可重复的，使用Set存储所有Entry

在这里插入图片描述

1.HashMap

HashMap底层：数组+链表（jdk7之前）

​ 数组+链表+红黑树（jdk8）

HashMap的底层实现原理：

HashMap的底层实现原理?以jdk7为例说明
*      HashMap map = new HashMap();
*      实例化后，底层创建一个长度为16的一维数组Entry[] table
*      ...多个put后...
*      map.put(key1,value1)；
*      首先，调用key1所在类的hashCode()计算key1的哈希值，此哈希值经过某种算法后，得到在Entry数组中的存放位置。
*      如果此位置上数据为空，此时Entry（key1-value1）添加成功。
*      如果此位置上数据不为空，(意味着此位置上存在一个或多个(以链表形式存在)数据)，比较key1和已经存在的一个或多个数据的哈希值：
*          如果key1的哈希值与已经存在的数据的哈希值都不同，此时Entry（key1-value1）添加成功
*          如果key1的哈希值与已经存在的某个数据的哈希值相同，继续比较key1的equals()方法，比较：
*              如果equals()返回false：此时Entry（key1-value1）添加成功
*              如果equals()返回true：使用value1替换原有的value
*
*     ☆在不断添加过程中，会涉及扩容问题，占用超过12个时，默认扩容为原来容量的2倍，并将原有数据复制过来
*
*       jdk8相较于jdk7在底层实现方面的不同：
*       1.new HashMap()时底层没有创建一个长度为16的数组
*       2.jdk8底层的数组是：Node[]，而非Entry[]
*       3.首次调用put()方法时，底层创建长度为16的数组
*       4.jdk7底层只有数组+链表；jdk8中底层数组+链表+红黑树。当数组的后一个索引位置上的元素以链表形式存在的数据个数>8且当前数组长度>64，
*       此时此索引位置上的所有数据改为使用红黑树存储。
2.LinkedHashMap

LinkedHashMap：保证在遍历map元素时，可以按照添加顺序去遍历

  •                  原因：在原有HashMap底层结构基础上，添加了一对指针，指向前一个和后一个键值对

  •                  对于频繁的遍历操作，此类执行效率高于HashMap
3.TreeMap
  • 向TreeMap中添加key-value，要求key必须是由同一个类创建的对象
  • 因为要按照key进行排序：自然排序、定制排序
4.Map的常用方法及遍历

Map中定义的方法：

  • 添加：put（）
  • 删除：remove（）
  • 修改：put()
  • 查询：get()
  • 长度：size()
  • 遍历：keySet()、values()、entrySet()
public class MapTest {

    @Test
    public void test1(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put("BB",5634);
        map.put("CC",999);
        //与上一个key“AA”相同，替换value
        map.put("AA",456);

        System.out.println(map);

        Map map1 = new HashMap();
        map1.put("DD",5634);
        map1.put("EE",999);
        map.putAll(map1);

        Object cc = map.remove("CC");//返回value
        System.out.println(cc);

        map.clear();
        System.out.println(map.size());

        //遍历所有key集：keySet()
        Set set = map.keySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        //遍历所有value集：values()
        Collection values = map.values();
        for (Object o:values
             ) {
            System.out.println(o);
        }

        //遍历所有key-values:entrySet()
        Set set1 = map.entrySet();
        Iterator iterator1 = set1.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();
            Map.Entry entry = (Map.Entry)obj;
            System.out.println(entry.getKey()+"-->"+entry.getValue());
        }
        //方法二：
        Set set2 = map.keySet();
        Iterator iterator2 = set2.iterator();
        while (iterator2.hasNext()){
            Object key = iterator2.next();
            Object value = map.get(key);
            System.out.println(key+"------"+value);
        }

    }
}

四：Collections

Collections:操作Collection、Map的工具类

面试题：Collection和Collections的区别？
 Collections是操作Collection、Map的工具类
 Collection是创建集合的接口，包括list和set

常用方法：

  • reverse(list):反转List中元素的顺序

  • shuffle(list):对List集合中的元素随机排序

  • sort(list)：根据元素的自然顺序对指定List集合排序（升序）

  • sort(list，Comparator)：根据指定的Comparator产生的顺序对List集合排序

  • swap(list,int i,int j):将list集合中的i处元素与j处元素进行交换
    *

  • Object max/min(Collection)

  • Object max/min(Collection，Comparator)

  • int frequency(Collection,Object):返回指定集合中指定元素的出现次数

  • void copy(List dest，List src):将src中的内容复制到dest中(易错，如下代码)

  • boolean replaceAll(List list，Object oldVal，Object newVal)：

  • synchronizedList(List list)：将list改为线程安全的

    说明：

    在使用copy方法时需注意：dest的size()，也就是dest中存的元素个数要不小于list中的元素个数才能复制

public class CollectionsTest {
    @Test
    public  void test1(){
        List list = new ArrayList();
        list.add(123);
        list.add(-9);
        list.add(7);
        list.add(96);

        //java.lang.IndexOutOfBoundsException: Source does not fit in dest
        //ArrayList dest = new ArrayList();
        //Collections.copy(dest,list);
        //dest的size()，也就是dest中存的元素个数要不小于list中的元素个数才能复制
        List dest = Arrays.asList(new Object[list.size()]);
        System.out.println(dest.size());
        Collections.copy(dest,list);
        System.out.println(dest);
    }
}
法式浪漫主义干拉
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Java学习笔记：高阶语法
坤舆湖畔的万某某的博客
09-08 1873
Java多线程、集合、队列、栈等知识的简单介绍与演示。
Java集合学习笔记.pdf
11-28
Java集合学习笔记.pdf
carmelo：Carmelo是一种专为在线游戏设计的快速，可扩展的Java服务器框架。 它使用Netty和Fastjson进行高效的网络传输，并支持两种TCPHTTP协议
02-05
Carmelo是为在线游戏设计的快速，可扩展的Java服务器框架。 它使用和进行高效的网络传输，并支持多种协议。 它还将用于业务逻辑，将用于数据持久性。 该框架实现了自己的servlet来处理客户端请求，因此您可以轻松地对其进行扩展以构建自己的服务器。 从这里开始 先决条件：请安装Java 1.8，Maven 3.x，Eclipse和MySQL5.6.x。 建立 git克隆 CD卡梅罗 mvn eclipse：eclipse Eclipse->文件->导入-> Maven->现有的Maven项目->选择carmelo项目 Eclipse中的carmelo项目->右键单击pom.xml->运
java 自己搭建简单游戏框架（适合有想法却无法入手的新手。）
liqfree的专栏
11-17 2323
我想做一个游戏，但是不知从何下手？ 网上可以看到很多游戏开发的例子，不过这个是我自己研究的，一个简单却实在的游戏框架。 首先，我甚至不知道游戏到底要什么效果，但是游戏肯定要有自动能动的东西。一个可以显示在屏幕上的单位。 Class Unit{ int x; int y; ……//一堆属性，当然现在我不知道自己要多少属性，但是位置属性要有，其它属性呢？比如我要用一张图片显示？那就Imag
Java游戏运行框架
Canon_M的博客
05-26 4586
初步建立一个游戏的基本框架，其中包含了三部分代码：第一部分用来实现游戏规则并实时更新游戏逻辑，第二部分用来进行离屏绘制，第三部分用来进行前屏显示。可以用以下代码来描述游戏程序的运行框架//一个完整的游戏运行框架 public void gameLoop() { while(true) { gameUpdata(){ //更新游戏逻辑 x++; } } gameRender()...
Java学习笔记：ArrayList集合
Li__Daxia的博客
03-23 1034
超级详细的Java整理学习笔记：ArrayList集合、Java和python数据结构的区别，以及Java如何实现处理多样的数据组！！！
Java学习笔记：Map集合
Z_jl123的博客
02-10 956
1、Map集合介绍 Map集合通过键值对（key-value)的形式来存储数据。(键值对：一个对象并不是单纯的只有一个内容，而是包含key和value两部分内容，key和value存在对应关系） Map中key可以为任意类型，实际开发建议使用String，value也可以是任意类型。 Map集合通过键获取值，查询速度非常快。 2、Map的实现类 HashMap（使用频率最高）（无序）； TreeMap（自然升序）； HashTable（无序）； 三个实现类使用步骤类似，我们以HashMap为
java学习笔记：集合的体系结构
黄道婆的专栏
07-11 107
java学习笔记：集合的体系结构
java学习笔记：集合框架之TreeSet
Leo's workspace
05-08 3957
|--------TreeSet  数据结构是二叉树，比较方式很优秀，遍历的速度很快。 TreeSet可以对集合中的元素进行排序： 一、让元素自身具有比较性：   实现Comparable接口，并且覆盖里面的   compareTo方法。通过teturn 0判断元素是否相同,来保证数据的唯一性。 class Person implements Comparable { pr
Java学习笔记——集合
D77的博客
08-01 624
Java 集合框架主要包括两种类型的容器： 集合（Collection）—— 存储一个元素集合； 图（Map）—— 存储键/值对映射；
java学习笔记
12-22
匿名对象4.Random类5.ArrayList集合5.String类6.static关键字7.Arrays数组工具类8.Math数学工具类继承与多态1.继承2.抽象类3.接口4.多态5.final关键字6.权限修饰符7.内部类常用API第二部分1.Date类2.Calender类3.Sys
java学习笔记（基础集合）
10-02
java学习笔记（基础集合）
java基础学习笔记之泛型
09-02
所谓泛型，就是变量类型的参数化。泛型是JDK1.5中一个最重要的特征。通过引入泛型，我们将获得编译时类型的安全和运行时更小的抛出ClassCastException的...在JDK1.5中，你可以声明一个集合将接收/返回的对象的类型。
Java学习笔记整理
05-21
自己学习时整理的笔记，从面向对象到集合框架，学习交流
Java学习笔记
stange1的博客
05-06 5236
1.2.1 首先找到此电脑，右键点击属性，可以按照下面的界面；点击【高级系统设置】，再点击【环境变量】 1.2.2 找到JDK的bin目录，复制一下 1.2.3 将JDK的bin目录粘贴在Path环境变量后面 1.2.4.在CMD输入javac -version 看提示信息是否显示你安装JDK的版本号​ 1、java 基础（Java SE）标准版 2、就业方向：①JavaEE软件工程师②大数据③android开发 3、运行原理示意图 4、Java 开发注意事项和细节说明 5、如何快速掌握技术或知识点 代
Collection集合 --java学习笔记
m0_71386740的博客
03-29 1286
常见List系列集合—— ArrayList、LinkdList：有序、可重复、有索引运行结果。
简单的项目部署脚本（转载）
u010230019的博客
06-09 597
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
最新发布
m0_74100417的博客
06-09 1217
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
thinking in java 学习笔记
01-08
《Thinking in Java》是一本经典的Java编程入门教材，通过阅读该书可以系统地学习Java编程的基础知识和高级概念。...希望这份学习笔记能够帮助到其他想要学习Java的同学，让他们能够更快地入门和掌握这门编程语言。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值