StringBuffer 详解 (String系列之3)[通俗易懂]

StringBuffer 详解 (String系列之3)[通俗易懂]本章介绍StringBuffer以及它的API的详细使用方法。转载请注明出处:http://www.cnblogs.com/skywang12345/p/string03.htmlStringBuff

大家好,又见面了,我是你们的朋友全栈君。

 

本章介绍StringBuffer以及它的API的详细使用方法。

转载请注明出处:http://www.cnblogs.com/skywang12345/p/string03.html

StringBuffer 简介

StringBuffer 是一个线程安全的可变的字符序列。它继承于AbstractStringBuilder,实现了CharSequence接口。
StringBuilder 也是继承于AbstractStringBuilder的子类;但是,StringBuilder和StringBuffer不同,前者是非线程安全的,后者是线程安全的。

StringBuffer 和 CharSequence之间的关系图如下:

StringBuffer 详解 (String系列之3)[通俗易懂]

StringBuffer 函数列表

StringBuffer()
StringBuffer(int capacity)
StringBuffer(String string)
StringBuffer(CharSequence cs)

StringBuffer     append(boolean b)
StringBuffer     append(int i)
StringBuffer     append(long l)
StringBuffer     append(float f)
StringBuffer     append(double d)
synchronized StringBuffer     append(char ch)
synchronized StringBuffer     append(char[] chars)
synchronized StringBuffer     append(char[] chars, int start, int length)
synchronized StringBuffer     append(Object obj)
synchronized StringBuffer     append(String string)
synchronized StringBuffer     append(StringBuffer sb)
synchronized StringBuffer     append(CharSequence s)
synchronized StringBuffer     append(CharSequence s, int start, int end)
StringBuffer     appendCodePoint(int codePoint)
int     capacity()
synchronized char     charAt(int index)
synchronized int     codePointAt(int index)
synchronized int     codePointBefore(int index)
synchronized int     codePointCount(int beginIndex, int endIndex)
synchronized StringBuffer     delete(int start, int end)
synchronized StringBuffer     deleteCharAt(int location)
synchronized void     ensureCapacity(int min)
synchronized void     getChars(int start, int end, char[] buffer, int idx)
synchronized int     indexOf(String subString, int start)
int     indexOf(String string)
StringBuffer     insert(int index, boolean b)
StringBuffer     insert(int index, int i)
StringBuffer     insert(int index, long l)
StringBuffer     insert(int index, float f)
StringBuffer     insert(int index, double d)
synchronized StringBuffer     insert(int index, char ch)
synchronized StringBuffer     insert(int index, char[] chars)
synchronized StringBuffer     insert(int index, char[] chars, int start, int length)
synchronized StringBuffer     insert(int index, String string)
StringBuffer     insert(int index, Object obj)
synchronized StringBuffer     insert(int index, CharSequence s)
synchronized StringBuffer     insert(int index, CharSequence s, int start, int end)
int     lastIndexOf(String string)
synchronized int     lastIndexOf(String subString, int start)
int     length()
synchronized int     offsetByCodePoints(int index, int codePointOffset)
synchronized StringBuffer     replace(int start, int end, String string)
synchronized StringBuffer     reverse()
synchronized void     setCharAt(int index, char ch)
synchronized void     setLength(int length)
synchronized CharSequence     subSequence(int start, int end)
synchronized String     substring(int start)
synchronized String     substring(int start, int end)
synchronized String     toString()
synchronized void     trimToSize()

 

StringBuffer源码(基于jdk1.7.40)

StringBuffer 详解 (String系列之3)[通俗易懂]
StringBuffer 详解 (String系列之3)[通俗易懂]

  1 package java.lang;
  2 
  3 public final class StringBuffer
  4     extends AbstractStringBuilder
  5     implements java.io.Serializable, CharSequence
  6 {
  7 
  8     static final long serialVersionUID = 3388685877147921107L;
  9 
 10     public StringBuffer() {
 11         super(16);
 12     }
 13 
 14     public StringBuffer(int capacity) {
 15         super(capacity);
 16     }
 17 
 18     public StringBuffer(String str) {
 19         super(str.length() + 16);
 20         append(str);
 21     }
 22 
 23     public StringBuffer(CharSequence seq) {
 24         this(seq.length() + 16);
 25         append(seq);
 26     }
 27 
 28     public synchronized int length() {
 29         return count;
 30     }
 31 
 32     public synchronized int capacity() {
 33         return value.length;
 34     }
 35 
 36 
 37     public synchronized void ensureCapacity(int minimumCapacity) {
 38         if (minimumCapacity > value.length) {
 39             expandCapacity(minimumCapacity);
 40         }
 41     }
 42 
 43     public synchronized void trimToSize() {
 44         super.trimToSize();
 45     }
 46 
 47     public synchronized void setLength(int newLength) {
 48         super.setLength(newLength);
 49     }
 50 
 51     public synchronized char charAt(int index) {
 52         if ((index < 0) || (index >= count))
 53             throw new StringIndexOutOfBoundsException(index);
 54         return value[index];
 55     }
 56 
 57     public synchronized int codePointAt(int index) {
 58         return super.codePointAt(index);
 59     }
 60 
 61     public synchronized int codePointBefore(int index) {
 62         return super.codePointBefore(index);
 63     }
 64 
 65     public synchronized int codePointCount(int beginIndex, int endIndex) {
 66         return super.codePointCount(beginIndex, endIndex);
 67     }
 68 
 69     public synchronized int offsetByCodePoints(int index, int codePointOffset) {
 70         return super.offsetByCodePoints(index, codePointOffset);
 71     }
 72 
 73     public synchronized void getChars(int srcBegin, int srcEnd, char[] dst,
 74                                       int dstBegin)
 75     {
 76         super.getChars(srcBegin, srcEnd, dst, dstBegin);
 77     }
 78 
 79     public synchronized void setCharAt(int index, char ch) {
 80         if ((index < 0) || (index >= count))
 81             throw new StringIndexOutOfBoundsException(index);
 82         value[index] = ch;
 83     }
 84 
 85     public synchronized StringBuffer append(Object obj) {
 86         super.append(String.valueOf(obj));
 87         return this;
 88     }
 89 
 90     public synchronized StringBuffer append(String str) {
 91         super.append(str);
 92         return this;
 93     }
 94 
 95     public synchronized StringBuffer append(StringBuffer sb) {
 96         super.append(sb);
 97         return this;
 98     }
 99 
100     public StringBuffer append(CharSequence s) {
101         // Note, synchronization achieved via other invocations
102         if (s == null)
103             s = "null";
104         if (s instanceof String)
105             return this.append((String)s);
106         if (s instanceof StringBuffer)
107             return this.append((StringBuffer)s);
108         return this.append(s, 0, s.length());
109     }
110 
111     public synchronized StringBuffer append(CharSequence s, int start, int end)
112     {
113         super.append(s, start, end);
114         return this;
115     }
116 
117     public synchronized StringBuffer append(char[] str) {
118         super.append(str);
119         return this;
120     }
121 
122     public synchronized StringBuffer append(char[] str, int offset, int len) {
123         super.append(str, offset, len);
124         return this;
125     }
126 
127     public synchronized StringBuffer append(boolean b) {
128         super.append(b);
129         return this;
130     }
131 
132     public synchronized StringBuffer append(char c) {
133         super.append(c);
134         return this;
135     }
136 
137     public synchronized StringBuffer append(int i) {
138         super.append(i);
139         return this;
140     }
141 
142     public synchronized StringBuffer appendCodePoint(int codePoint) {
143         super.appendCodePoint(codePoint);
144         return this;
145     }
146 
147     public synchronized StringBuffer append(long lng) {
148         super.append(lng);
149         return this;
150     }
151 
152     public synchronized StringBuffer append(float f) {
153         super.append(f);
154         return this;
155     }
156 
157     public synchronized StringBuffer append(double d) {
158         super.append(d);
159         return this;
160     }
161 
162     public synchronized StringBuffer delete(int start, int end) {
163         super.delete(start, end);
164         return this;
165     }
166 
167     public synchronized StringBuffer deleteCharAt(int index) {
168         super.deleteCharAt(index);
169         return this;
170     }
171 
172     public synchronized StringBuffer replace(int start, int end, String str) {
173         super.replace(start, end, str);
174         return this;
175     }
176 
177     public synchronized String substring(int start) {
178         return substring(start, count);
179     }
180 
181     public synchronized CharSequence subSequence(int start, int end) {
182         return super.substring(start, end);
183     }
184 
185     public synchronized String substring(int start, int end) {
186         return super.substring(start, end);
187     }
188 
189     public synchronized StringBuffer insert(int index, char[] str, int offset,
190                                             int len)
191     {
192         super.insert(index, str, offset, len);
193         return this;
194     }
195 
196     public synchronized StringBuffer insert(int offset, Object obj) {
197         super.insert(offset, String.valueOf(obj));
198         return this;
199     }
200 
201     public synchronized StringBuffer insert(int offset, String str) {
202         super.insert(offset, str);
203         return this;
204     }
205 
206     public synchronized StringBuffer insert(int offset, char[] str) {
207         super.insert(offset, str);
208         return this;
209     }
210 
211     public StringBuffer insert(int dstOffset, CharSequence s) {
212         // Note, synchronization achieved via other invocations
213         if (s == null)
214             s = "null";
215         if (s instanceof String)
216             return this.insert(dstOffset, (String)s);
217         return this.insert(dstOffset, s, 0, s.length());
218     }
219 
220     public synchronized StringBuffer insert(int dstOffset, CharSequence s,
221                                             int start, int end)
222     {
223         super.insert(dstOffset, s, start, end);
224         return this;
225     }
226 
227     public StringBuffer insert(int offset, boolean b) {
228         return insert(offset, String.valueOf(b));
229     }
230 
231     public synchronized StringBuffer insert(int offset, char c) {
232         super.insert(offset, c);
233         return this;
234     }
235 
236     public StringBuffer insert(int offset, int i) {
237         return insert(offset, String.valueOf(i));
238     }
239 
240     public StringBuffer insert(int offset, long l) {
241         return insert(offset, String.valueOf(l));
242     }
243 
244     public StringBuffer insert(int offset, float f) {
245         return insert(offset, String.valueOf(f));
246     }
247 
248     public StringBuffer insert(int offset, double d) {
249         return insert(offset, String.valueOf(d));
250     }
251 
252     public int indexOf(String str) {
253         return indexOf(str, 0);
254     }
255 
256     public synchronized int indexOf(String str, int fromIndex) {
257         return String.indexOf(value, 0, count,
258                               str.toCharArray(), 0, str.length(), fromIndex);
259     }
260 
261     public int lastIndexOf(String str) {
262         // Note, synchronization achieved via other invocations
263         return lastIndexOf(str, count);
264     }
265 
266     public synchronized int lastIndexOf(String str, int fromIndex) {
267         return String.lastIndexOf(value, 0, count,
268                               str.toCharArray(), 0, str.length(), fromIndex);
269     }
270 
271     public synchronized StringBuffer reverse() {
272         super.reverse();
273         return this;
274     }
275 
276     public synchronized String toString() {
277         return new String(value, 0, count);
278     }
279 
280     private static final java.io.ObjectStreamField[] serialPersistentFields =
281     {
282         new java.io.ObjectStreamField("value", char[].class),
283         new java.io.ObjectStreamField("count", Integer.TYPE),
284         new java.io.ObjectStreamField("shared", Boolean.TYPE),
285     };
286 
287     private synchronized void writeObject(java.io.ObjectOutputStream s)
288         throws java.io.IOException {
289         java.io.ObjectOutputStream.PutField fields = s.putFields();
290         fields.put("value", value);
291         fields.put("count", count);
292         fields.put("shared", false);
293         s.writeFields();
294     }
295 
296     private void readObject(java.io.ObjectInputStream s)
297         throws java.io.IOException, ClassNotFoundException {
298         java.io.ObjectInputStream.GetField fields = s.readFields();
299         value = (char[])fields.get("value", null);
300         count = fields.get("count", 0);
301     }
302 }

View Code

 

StringBuffer 示例

源码如下(StringBufferTest.java):

  1 /**
  2  * StringBuffer 演示程序
  3  *
  4  * @author skywang
  5  */
  6 import java.util.HashMap;
  7 
  8 public class StringBufferTest {
  9 
 10     public static void main(String[] args) {
 11         testInsertAPIs() ;
 12         testAppendAPIs() ;
 13         testReplaceAPIs() ;
 14         testDeleteAPIs() ;
 15         testIndexAPIs() ;
 16         testOtherAPIs() ;
 17     }
 18 
 19     /**
 20      * StringBuffer 的其它API示例
 21      */
 22     private static void testOtherAPIs() {
 23 
 24         System.out.println("-------------------------------- testOtherAPIs --------------------------------");
 25 
 26         StringBuffer sbuilder = new StringBuffer("0123456789");
 27 
 28         int cap = sbuilder.capacity();
 29         System.out.printf("cap=%d\n", cap);
 30 
 31         char c = sbuilder.charAt(6);
 32         System.out.printf("c=%c\n", c);
 33 
 34         char[] carr = new char[4];
 35         sbuilder.getChars(3, 7, carr, 0);
 36         for (int i=0; i<carr.length; i++)
 37             System.out.printf("carr[%d]=%c ", i, carr[i]);
 38         System.out.println();
 39 
 40         System.out.println();
 41     }
 42 
 43     /**
 44      * StringBuffer 中index相关API演示
 45      */
 46     private static void testIndexAPIs() {
 47         System.out.println("-------------------------------- testIndexAPIs --------------------------------");
 48 
 49         StringBuffer sbuilder = new StringBuffer("abcAbcABCabCaBcAbCaBCabc");
 50         System.out.printf("sbuilder=%s\n", sbuilder);
 51 
 52         // 1. 从前往后,找出"bc"第一次出现的位置
 53         System.out.printf("%-30s = %d\n", "sbuilder.indexOf(\"bc\")", sbuilder.indexOf("bc"));
 54 
 55         // 2. 从位置5开始,从前往后,找出"bc"第一次出现的位置
 56         System.out.printf("%-30s = %d\n", "sbuilder.indexOf(\"bc\", 5)", sbuilder.indexOf("bc", 5));
 57 
 58         // 3. 从后往前,找出"bc"第一次出现的位置
 59         System.out.printf("%-30s = %d\n", "sbuilder.lastIndexOf(\"bc\")", sbuilder.lastIndexOf("bc"));
 60 
 61         // 4. 从位置4开始,从后往前,找出"bc"第一次出现的位置
 62         System.out.printf("%-30s = %d\n", "sbuilder.lastIndexOf(\"bc\", 4)", sbuilder.lastIndexOf("bc", 4));
 63 
 64         System.out.println();
 65     }
 66 
 67     /**
 68      * StringBuffer 的replace()示例
 69      */
 70     private static void testReplaceAPIs() {
 71 
 72         System.out.println("-------------------------------- testReplaceAPIs ------------------------------");
 73 
 74         StringBuffer sbuilder;
 75 
 76         sbuilder = new StringBuffer("0123456789");
 77         sbuilder.replace(0, 3, "ABCDE");
 78         System.out.printf("sbuilder=%s\n", sbuilder);
 79 
 80         sbuilder = new StringBuffer("0123456789");
 81         sbuilder.reverse();
 82         System.out.printf("sbuilder=%s\n", sbuilder);
 83 
 84         sbuilder = new StringBuffer("0123456789");
 85         sbuilder.setCharAt(0, 'M');
 86         System.out.printf("sbuilder=%s\n", sbuilder);
 87 
 88         System.out.println();
 89     }
 90 
 91     /**
 92      * StringBuffer 的delete()示例
 93      */
 94     private static void testDeleteAPIs() {
 95 
 96         System.out.println("-------------------------------- testDeleteAPIs -------------------------------");
 97 
 98         StringBuffer sbuilder = new StringBuffer("0123456789");
 99         
100         // 删除位置0的字符,剩余字符是“123456789”。
101         sbuilder.deleteCharAt(0);
102         // 删除位置3(包括)到位置6(不包括)之间的字符,剩余字符是“123789”。
103         sbuilder.delete(3,6);
104 
105         // 获取sb中从位置1开始的字符串
106         String str1 = sbuilder.substring(1);
107         // 获取sb中从位置3(包括)到位置5(不包括)之间的字符串
108         String str2 = sbuilder.substring(3, 5);
109         // 获取sb中从位置3(包括)到位置5(不包括)之间的字符串,获取的对象是CharSequence对象,此处转型为String
110         String str3 = (String)sbuilder.subSequence(3, 5);
111 
112         System.out.printf("sbuilder=%s\nstr1=%s\nstr2=%s\nstr3=%s\n", 
113                 sbuilder, str1, str2, str3);
114 
115         System.out.println();
116     }
117 
118     /**
119      * StringBuffer 的insert()示例
120      */
121     private static void testInsertAPIs() {
122 
123         System.out.println("-------------------------------- testInsertAPIs -------------------------------");
124 
125         StringBuffer sbuilder = new StringBuffer();
126 
127         // 在位置0处插入字符数组
128         sbuilder.insert(0, new char[]{'a','b','c','d','e'});
129         // 在位置0处插入字符数组。0表示字符数组起始位置,3表示长度
130         sbuilder.insert(0, new char[]{'A','B','C','D','E'}, 0, 3);
131         // 在位置0处插入float
132         sbuilder.insert(0, 1.414f);
133         // 在位置0处插入double
134         sbuilder.insert(0, 3.14159d);
135         // 在位置0处插入boolean
136         sbuilder.insert(0, true);
137         // 在位置0处插入char
138         sbuilder.insert(0, '\n');
139         // 在位置0处插入int
140         sbuilder.insert(0, 100);
141         // 在位置0处插入long
142         sbuilder.insert(0, 12345L);
143         // 在位置0处插入StringBuilder对象
144         sbuilder.insert(0, new StringBuffer("StringBuilder"));
145         // 在位置0处插入StringBuilder对象。6表示被在位置0处插入对象的起始位置(包括),13是结束位置(不包括)
146         sbuilder.insert(0, new StringBuffer("STRINGBUILDER"), 6, 13);
147         // 在位置0处插入StringBuffer对象。
148         sbuilder.insert(0, new StringBuffer("StringBuffer"));
149         // 在位置0处插入StringBuffer对象。6表示被在位置0处插入对象的起始位置(包括),12是结束位置(不包括)
150         sbuilder.insert(0, new StringBuffer("STRINGBUFFER"), 6, 12);
151         // 在位置0处插入String对象。
152         sbuilder.insert(0, "String");
153         // 在位置0处插入String对象。1表示被在位置0处插入对象的起始位置(包括),6是结束位置(不包括)
154         sbuilder.insert(0, "0123456789", 1, 6);
155         sbuilder.insert(0, '\n');
156 
157         // 在位置0处插入Object对象。此处以HashMap为例
158         HashMap map = new HashMap();
159         map.put("1", "one");
160         map.put("2", "two");
161         map.put("3", "three");
162         sbuilder.insert(0, map);
163 
164         System.out.printf("%s\n\n", sbuilder);
165     }
166 
167     /**
168      * StringBuffer 的append()示例
169      */
170     private static void testAppendAPIs() {
171 
172         System.out.println("-------------------------------- testAppendAPIs -------------------------------");
173 
174         StringBuffer sbuilder = new StringBuffer();
175 
176         // 追加字符数组
177         sbuilder.append(new char[]{'a','b','c','d','e'});
178         // 追加字符数组。0表示字符数组起始位置,3表示长度
179         sbuilder.append(new char[]{'A','B','C','D','E'}, 0, 3);
180         // 追加float
181         sbuilder.append(1.414f);
182         // 追加double
183         sbuilder.append(3.14159d);
184         // 追加boolean
185         sbuilder.append(true);
186         // 追加char
187         sbuilder.append('\n');
188         // 追加int
189         sbuilder.append(100);
190         // 追加long
191         sbuilder.append(12345L);
192         // 追加StringBuilder对象
193         sbuilder.append(new StringBuffer("StringBuilder"));
194         // 追加StringBuilder对象。6表示被追加对象的起始位置(包括),13是结束位置(不包括)
195         sbuilder.append(new StringBuffer("STRINGBUILDER"), 6, 13);
196         // 追加StringBuffer对象。
197         sbuilder.append(new StringBuffer("StringBuffer"));
198         // 追加StringBuffer对象。6表示被追加对象的起始位置(包括),12是结束位置(不包括)
199         sbuilder.append(new StringBuffer("STRINGBUFFER"), 6, 12);
200         // 追加String对象。
201         sbuilder.append("String");
202         // 追加String对象。1表示被追加对象的起始位置(包括),6是结束位置(不包括)
203         sbuilder.append("0123456789", 1, 6);
204         sbuilder.append('\n');
205 
206         // 追加Object对象。此处以HashMap为例
207         HashMap map = new HashMap();
208         map.put("1", "one");
209         map.put("2", "two");
210         map.put("3", "three");
211         sbuilder.append(map);
212         sbuilder.append('\n');
213 
214         // 追加unicode编码
215         sbuilder.appendCodePoint(0x5b57);    // 0x5b57是“字”的unicode编码
216         sbuilder.appendCodePoint(0x7b26);    // 0x7b26是“符”的unicode编码
217         sbuilder.appendCodePoint(0x7f16);    // 0x7f16是“编”的unicode编码
218         sbuilder.appendCodePoint(0x7801);    // 0x7801是“码”的unicode编码
219 
220         System.out.printf("%s\n\n", sbuilder);
221     }
222 }

运行结果

-------------------------------- testInsertAPIs -------------------------------
{3=three, 2=two, 1=one}
12345StringBUFFERStringBufferBUILDERStringBuilder12345100
true3.141591.414ABCabcde

-------------------------------- testAppendAPIs -------------------------------
abcdeABC1.4143.14159true
10012345StringBuilderBUILDERStringBufferBUFFERString12345
{3=three, 2=two, 1=one}
字符编码

-------------------------------- testReplaceAPIs ------------------------------
sbuilder=ABCDE3456789
sbuilder=9876543210
sbuilder=M123456789

-------------------------------- testDeleteAPIs -------------------------------
sbuilder=123789
str1=23789
str2=78
str3=78

-------------------------------- testIndexAPIs --------------------------------
sbuilder=abcAbcABCabCaBcAbCaBCabc
sbuilder.indexOf("bc")         = 1
sbuilder.indexOf("bc", 5)      = 22
sbuilder.lastIndexOf("bc")     = 22
sbuilder.lastIndexOf("bc", 4)  = 4

-------------------------------- testOtherAPIs --------------------------------
cap=26
c=6
carr[0]=3 carr[1]=4 carr[2]=5 carr[3]=6 

 

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请联系我们举报,一经查实,本站将立刻删除。

发布者:全栈程序员-站长,转载请注明出处:https://javaforall.net/155049.html原文链接:https://javaforall.net

(0)
全栈程序员-站长的头像全栈程序员-站长


相关推荐

  • 系统发育树原理_环形系统发育树怎么理解

    系统发育树原理_环形系统发育树怎么理解文章转载于 Original 2017-07-08 Berlin生信百科达尔文在19世纪中叶创立了科学的生物进化学说——达尔文进化论。以自然选择为主要核心,他第一次对

    2022年8月2日
    5
  • 概率论 协方差矩阵_方差和均值的性质

    概率论 协方差矩阵_方差和均值的性质http://blog.csdn.net/pipisorry/article/details/48788671要理解协方差矩阵,从以下几个步骤来说期望——>方差——>协方差——>协方差矩阵,这样更能理解它的由来和意义。本文主要讲意义和python里的使用,其实协方差矩阵有很强的实际意义和应用实例,有机会再补充。均值、方差和标准差给定一个含有n个样本的集合,可以得到样本的均值,方差和标准差。…

    2025年7月14日
    5
  • Java安全之jar包调试技巧

    Java安全之jar包调试技巧调试程序首先还是创建一个工程,将jar包导入进来调试模式的参数启动中需要加入特定参数才能使用debug模式,并且需要开放调试端口JDK5-8:-agentli

    2021年12月12日
    50
  • 台式机插入网线无网络问题

    台式机插入网线无网络问题1、先查看是否是ip地址无法获取:先找到“以太网”-“详细信息”像这样,就是表示无法正确获取ip地址及网关,接下来,就是手动配置ip及网关等参数这回还是点击“以太网”,点击属性点击协议版本4,点击属性,然后手动输入ip地址等参数即可。…

    2022年6月26日
    24
  • Arduino TaskScheduler入门

    Arduino TaskScheduler入门#include<TaskScheduler.h>//回调函数声明,具体要执行的函数内容voidtask_1();//…voidtask_n();//计划任务声明,Task中要执行的函数名Taskt_end();//空任务,按需添加Taskt1(1000,10,&task_1);//任务名(间隔ms,执行次数,&执行函数)//…Tasktn(1000,TASK_FOREVER,&task_n);//TASK_ONCE,执.

    2022年8月31日
    2
  • 狂神说Linux_狂神说docker笔记

    狂神说Linux_狂神说docker笔记Linux在服务器端,很多大型项目都是部署在Linux服务器上利用VM + Centos7搭建本地Linux系统你可以使用 man [命令]来查看各个命令的使用文档,如 :man cp。概念云服务器就是一个远程电脑Linux中一切皆文件根目录/,所有的文件都挂载在这个节点下/bin:bin是Binary的缩写, 这个目录存放着最经常使用的命令。/boot: 这里存放的是启动Linux时使用的一些核心文件,包括一些连接文件以及镜像文件。/dev : dev是Device(设备

    2022年8月9日
    7

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

关注全栈程序员社区公众号