22. Java中String类介绍
Java中String类介绍
1.String 类是一个final类，不可以被继承。字符串是一个常量，对象一旦创建，就不可以
改变了，两个或者多个字符串可以叠加到一个新的字符串对象中去，字符串用+号拼接。
不能向原有的字符串对象添加内容。字符串对象一旦初始化后，就不可以改变了。
2.String类的特点：
字符串对象一旦初始化后，就不可以改变了，是内容不会变了，但是字符串引用可以指向其他的字符串；String str = "abcd"; str = "efghd"; 是合法的，只是”abcd”字符串仍然存在而已，但是引用str指向了新的字符串efghd。
3.字符串的定义方法：
①第一种：String str = “abc”;
②第二种：String str = new String(“abc”);
4.两种定义方法的区别：
（1）String s1 = "abcd"; S tring s2 = "abcd";
System.out.println(s1 == s2); //返回结果是true
双等号==判断的是地址，确实s1和s2的地址相同。因为存在字符串常量池，在
创建一个字符串时，首先判断字符串池中是否有此字符串，如果没有就创建，
如果已经存在，则直接把存在的字符串的地址赋给引用即可，故s1和s2的地址
相同。只在字符串常量池中创建一个对象。
（2）String s3 = new String("abcd");
String s4 = new String("abcd");
System.out.println(s3 == s4);//返回结果是false
这是在堆内存中创建了两个对象，所以s3 和s4 指向不同的对象。
（3）总结：第一种方法是在字符串常量池中创建唯一的一个对象；第二种方法（利用new）是在堆内存中创建字符串对象，一个new对应一个字符串对象。
5.字符串池（string pool）:采用字面值方式赋值时，如String s= “aaa”，首先查找字符串是
否在字符串池中是否存在该字符串，若不存在，则创建此字符串对象，并返回地址；若字符串池中存在该字符串，则直接把已经存在的字符串的地址返回给引用，并没有创建新的对象。
(由于在程序编写时，会大量使用字符串string，而对于重复的不再重新分配地址，从而实现优化)
采用new的方式如String s = new String（“aaa”）；首先是在字符串池中查找有没有此字符串对象，如果有，就不在字符串池中创建此对象了，直接在堆中创建一个字符串对象，如果没有，则先在字符串池中创建这个字符串对象，然后在堆中再创建这个对象，最后把堆中的地址返回来。注意：返回的都是堆中的对象，所以new一次，就会在堆中新建一个对象，地址肯定不同，但是利用字面赋值的方法，返回的是字符串池中的地址，如果字符串内容相同，则就是同一个地址，所以采用==判断时，相同。
6.任何数据和字符串相拼接，都会转换成字符串。
7.String s1= new String（）；与String s2 =“”；和String s3 = null；不一样，前两者都创建
了对象，只不过是空字符，引用已经分配了对象地址，而第三个没有创建对象，引用为空。
8.String有很多构造方法（Constructors）：
（1）String（）：空参数的构造方法是创建一个空字符的字符串对象；
（2）String（String original）：创建一个内容为original的字符串对象；
（3）String（byte[] bytes）:将字节数组变成字符串，把这些字节值作为码值，转换成相应的符号，输出；
（4）String( char[] value): 将字符串数组变成字符串；同时还有可以设置偏移量的等等；
（5）还有很多，可以使用时查看API文档。
9.按照面向对象的思想对String的功能进行分类：
（1）获取：
①字符串的长度（字符的个数），利用方法length()获取int值；
注意：字符串需要使用length（）方法获取长度，而数组的长度是利用它的属性length得到长度值。
②根据位置获取字符；
char charAt(int index)
③根据字符获取第一次出现的位置:
int indexOf(int ch) 参数支持ACSII码，所以为int类型。
int indexOf(String str)
int indexOf(String str, int fromIndex)
intlastIndexOf(int ch)
intlastIndexOf(int ch, int fromIndex)
intlastIndexOf(String str)
intlastIndexOf(String str, int fromIndex)
④截取字符串中的一部分：
String substring(int beginIndex)
Stringsubstring(int beginIndex, int endIndex)
注意：endIndex是默认减一的，意思就是获取的字符串中不包括索引为指定的endIndex的字符，获取的子字符串的长度就是endIndex –beginIndex；如果想获取字符串的自
从beginIndex后的字符串，第二个参数应该是xxx.length() .如
"hamburger".substring(4, 8) returns "urge" ;不包括索引为8的字符
"smiles".substring(1, 5) returns "mile"
（2）转换：
①将字符串转换成字符串数组（字符串的切割）：
regular expression.正则表达式
String[]split(String regex)
String[]split(String regex, int limit)
②将字符串转换成字符数组：
char[] toCharArray()
③将字符串转换成字节数组：
byte[] getBytes()
每个中文占用两个字节。
④将字符串中的字母转成大小写：
由于字符串不可以改动，所以需要另外创建一个字符串。
String toLowerCase()
String toUpperCase()
⑤将字符串中的内容进行替换：
Stringreplace(char oldChar, char newChar)
Stringreplace(CharSequence target, CharSequence replacement)
考试题目：
S tring s1 = "abcd";
String s2 = "abcf";
String s5 = "abcd";
String s3 = s2.replace('f','d');
String s4 = s5.replace('g','d');
System.out.println(s1 == s5);
System.out.println(s1 == s3);
System.out.println(s1 == s4);
请问：输出结果是什么？
true
false
true
解析：s1、s2、s5都是通过在字符串常量池中创建对象，显然第一行输出true；对于replace方法，如果有字符替换了，则就是有了新的字符串，那么就会等同于new一个String，在堆中创建一个新对象，再将地址赋予s3，显然字符串池中的对象引用s1与s3不同；但是如果replace方法并没有完成替换，即找不到需要替换的字符时，相当于字符串没有发生任何变化，所以也就没有创建新的字符串，还是将旧的字符串的地址赋予引用s4；显然s4与s1指向同一个字符串对象。
（A）String s5 = new String("abcd");
String s4 = s5.replace('g','d');
System.out.println(s5 == s4);//结果为true
（B）String s6 = "abcd";
String s7 = s6.replace('g','d');
System.out.println(s6 == s7);//结果也为true
由A 、B 可以看出，replace方法如果没有改变字符串，则就没有创建新的字符串。
（C）String s1 = new String("abcd");
String s2 = "abcf";
String s3 = s2.replace('f','d');
System.out.println(s1 == s3);//结果为false
（D）String s11 = "abcd";
String s22 = "abcf";
String s33 = s2.replace('f','d');
System.out.println(s11 == s33);//结果为false
从C、D可以看出，replace方法如果改变了字符串，则是通过new的方式创建一个新的字符串，当然新创建的字符串与原来的无论是字符串池的还是堆内存中的都不一样了。
⑥String 中的一个方法trim（），功能是去掉字符串的两端
的空格即空字符。
⑦ concat（）方法：连接两个字符串，功能同+号；只不过
显得更专业。
⑧静态方法StringvalueOf（xxxx）：将参数转换成字符串。
（3）判断（返回值为boolean值）：
①booleanequals（String anotherString）方法：判断两个字符
串的内容是否相同；
boolean equalsIgnoreCase(String anotherString)忽略大小写
String ss = "sb";
String ss2 = "SB";
System.out.println(ss.equals(ss2));//false
System.out.println(ss.equalsIgnoreCase(ss2));//true
②booleancontains(CharSequence s)：字符串中是否包含指定
字符串。
③字符串是否以指定字符串开头后结尾？
boolean startsWith(String prefix)
boolean startsWith(String prefix, int toffset)
boolean endsWith(String suffix)
（4）比较方法：compareTo（）；
int compareTo(String anotherString)
int compareToIgnoreCase(String str)
从前到后，按照字母的顺序比较：如果前面的小于后面的，则返回负数；
如果前面的大于后面的，则返回正数；如果相等则返回0.
因为字符串本身就是一个对象，对象不能利用比较符号比较，必须通过方法进行比
较，不能利用“abc”>“adc”；这是非法的。例如：
String ss = "sb";
String ss2 = "sC";
System.out.println(https://www.wendangku.net/doc/5914407948.html,pareTo(ss2)); //返回值为31
System.out.println(https://www.wendangku.net/doc/5914407948.html,pareToIgnoreCase(ss2));//返回值为-1 实际上，返回的int值就是字符的差值，例如b比C大32，故返回32；如果忽略
大小写，则差-1；是前者减去后者。
（5）方法intern（）；对字符串池进行操作的。
String intern()
返回本字符串在字符串池的地址给引用。
例如：
String s0 = "abc";
String s1 = new String("abc");
String s2 = s0.intern();
String s3 = s1.intern();
System.out.println(s0 == s2);//结果为true
System.out.println(s1 == s3);//结果为false
System.out.println(s0 == s3);//结果为true（很关键）分析：如果利用new创建一个字符串，则会先在字符串常量池中检查是否有此字
符串，如果已经有了，直接在堆内存中创建一个字符串对象，并把堆中的字符串
对象的地址赋给引用；但是如果字符串常量池中没有此字符串，则会先在字符串
常量池中创建一个字符串对象，然后在堆内存中再创建一个字符串对象，将堆内
存中的地址传递给引用。
10.考点：package sdk.November25.am;
publicclass SwapString {
publicstaticvoid main(String[] args) {
Swap sp1 = new Swap();
System.out.println(sp1.strarr[0] + " " +sp1.strarr[1]);//结果：aaaacccc
sp1.swap(sp1.s1,sp1.s2,sp1.strarr);
System.out.println(sp1.strarr[0] + " " +sp1.strarr[1]);//结果：ffffgggg
System.out.println(sp1.s1+sp1.s2);//结果为没有交换的字符串：djkjkabdcgde
//在交换方法中实现了交换，但是调用后并没有改变对象的字符串引用的改变，显然字符串String如同int一样。这样交换不能达到目的
//而对于数组来说，虽然也是在方法中建立了局部引用，但是局部引用始终与对象的引用指向同一个数组，改变数组中的任何一个元素的值，都会引起对象中数组的改变
//如果欲想对于字符串的内容进行修改，是不可能的，因为字符串一旦建立不可修改，如s1 = “ddddd”;本质是使s1指向了这个新的字符串，原来的字符串并未改变，
//然而此引用的指向地址并不不能反传回对象中的引用，所以才不能达到目的。
}
}
class Swap{
String s1 = "djkjk";
String s2 = "abdcgde";
String[] strarr = {"aaaa","cccc"};
publicvoid swap(String s1, String s2, String[] strarr) {
String temp = "";
System.out.println(s1 == this.s1);//结果为true
temp = s1;//只是引用地址的传递（未创建新的字符串）
s1 = s2;//只是引用地址的传递
System.out.println(s1 == this.s2);//结果为true
s2 = temp;//只是引用地址的传递
System.out.println(s2 == this.s1);//结果为true
System.out.println(s1+ s2);//输出结果为交换了位置的字符串：abdcgdedjkjk
System.out.println("*************************");
s1 = "dddddd";//欲改变s1的字符串内容，实质是s1自己的指向变了，而原字符串并未改变，达不到目的
//**********************************
strarr[0] = "ffff";
strarr[1] = "gggg"; //利用传递数组名，可以实现对数组元素的赋新值
//********利用字符串交换数组***********************
String temp1;
temp = strarr[0];
strarr[0] = strarr[1];
strarr[1] = temp; //可以实现数组元素的交换
}}
11.练习题
（1）字符串数组排序：
① 字符串大小比较利用compareTo方法；
②排序利用选择或冒泡法；
③自定义一个交换两个字符串的方法，注意参数一定是数组名和需要
交换的索引号，不能是数组元素（字符串），因为字符串作为参数，
只是一种值传递的方式，并没有改变原来的字符串。实参字符串把内
容传给形参字符串，相当于在交换方法中创建了新的字符串，所以没有改变实参的字符串的顺序。
package sdk.November25.am;
publicclass StringSort {
publicstaticvoid main(String[] args) {
String[] str = {"jgdgds","djsj","sdjkhjkg","abc","aad","z","zzzz"};
printStringArray(str);
sortStringArray(str);
printStringArray(str);
}
privatestaticvoid sortStringArray(String[] str) {
for(int i = 0;i < str.length - 1;i ++)
{
for(int j = 0;j < str.length - 1 - i;j++)
{
if(str[j].compareTo(str[j+1]) > 0)//字符串的比较大小利用compareTo方法
// swapString(str[j],str[j+1]);//仍然是以值传递的方式传进去的，所以必须是传递数组名才可以
swapString(str,j,j+1);
}
}
}
privatestaticvoid swapString(String[] str,int i,int j) {//一定是把数组名传进//去private static void swapString(String string, String string2) {
//}这中字符串作为参数的方法是错误的，传进去后，就变成了局部变量
String temp = null;
temp = str[i];
str[i] = str[j];
str[j] = temp;
}
privatestaticvoid printStringArray(String[] str) {
for(int i = 0; i < str.length; i++) {
if(i != str.length-1)
System.out.print(str[i] + " ,");
else
System.out.print(str[i]);
}
System.out.println();
}
}
（2）面试题：
public class Example{
String str=new String("good");
char[]ch={'a','b','c'};
public static void main(String args[]){
Example ex=new Example();
ex.change(ex.str,ex.ch);
System.out.print(ex.str+" and ");
Sytem.out.print(ex.ch);
}
public void change(String str,char ch[]){
str="test ok";
ch[0]='g';
}
}
请问这个程序为什么输出是什么？？？？？？
答案：good and gbc
解析：这里str是一个字符串的引用，ch是个数组引用，都是引用类型；但是字符串比较特殊，字符串一旦创建，其字符串的内容就不会改变，改变的是字符串引用的值，即此字符串引用重新指向一个新的字符串，但是并不能将形参本身发生的变化返给对象的此实参，而数组始终没有改变形参本身的值，所以始终与对象中的实参保持一致。
在change方法中，str和ch都是局部引用变量，str一开始指向类中的成员变量字符串good的地址，但是str= “test ok ”，这句话就是在创建一个新的字符串，然后把地址赋给了str，此时局部引用变量指向了test ok 的地址，但是出了此方法后，对象中的str 还是指向good；因为局部变量的名字可以是任意的，如str1；而对于数组来说，把类成员数组的地址传给了ch局部引用变量，此时局部的引用和类的成员引用变量指向同一数组，且都可以对此数组进行修改。
从上面可以看出，对于引用来说，传递的都是地址，但是字符串一旦创建不可改变（字符串不可改变，但是字符串引用可以改变），如果字符串不同，就是说明创建了新的字符串，所以字符串的引用（即字符串形参）就变了；但是对于数组而言，数组引用没有发生改变，始终指向同一数组。
变式训练1.只改变方法小括号里形参名字，此时方法体中的str就是类的引用了，不再是局部引用，所以结果就不一样了。
2.如果小括号和方法体中的str都变为str11，结果还是不变。
3.对于ch数组名，变与不变，变一个或者两个都一样，都会修改数组
元素。
package sdk.November25.am;
public class Example11 {
String str = new String("good");
char[] ch = { 'a', 'b', 'c' };
public static void main(String args[]) {
Example11 ex = new Example11();
ex.change(ex.str, ex.ch);
System.out.print(ex.str + " and ");
System.out.print(ex.ch);
}
public void change(String str11, char ch11[]) {
//str11 = "test ok";//此时是局部引用变量，方法一结束，此变量就会消失了，并不会改变对象的成员变量str的指向
str = "test ok";//此时直接调用的就是对象的成员变量了
ch11[0] = 'g';//无论数组名字如何改变，因为操作数组的地址没有改变，所以操作的始终是同一个数组
}
}
（3）一个字符串中某个子字符串出现的次数。
代码如下：
方法一：利用substring方法，进行切割，这样不好，会产生很多子字符串。
方法二：思路：a. 使用indexOf（）方法；
B．需要循环语句while（）；返回值是否是-1；
C．需要有个计数的变量，返回回来。
package sdk.November25.am;
public class SearchSunstring {
public static void main(String[] args) {
String str = "nbacbsnbacbdnbanbanaanbanbabanbanbad";
int count = searchSunstring(str);
System.out.println(count);
}
private static int searchSunstring(String str) {
int index = 0;
int count = 0;
while(index != -1)
{
index = str.indexOf("nba",index+3) ;
count++;
}
return count;
}
}
（4）判断两个字符串的最大相同字符串。
思路: a.两个字符串中，先找处较短的一个，以短的为寻找样本；
B．既然是寻找最大的，则需要从短字符串中先切出长的，在切出短的；
C．然后用切出的子字符串是否在长的字符串中存在。
D．由于已经从长到短了，所以如果有了，直接返回即可，但是如果一个字符也没有，返回提示信息，无。
package sdk.November25.am;
public class FindMaxSameSunstring {
public static void main(String[] args) {
String str1 = "abcdefghijklmnabcdefg";
String str3 = "abcdefghijklmnabcdefghi";
String str2 = "xyz";
String same12 = findSameSubstring(str1,str2);
String same13 = findSameSubstring(str1,str3);
System.out.println(same12 + " "+same13);
}
private static String findSameSubstring(String str1, String str2) {
if(str1.length() < str2.length()) {
}
else {
String temp ;
temp = str1;
str1 = str2;
str2 = temp;
}
for(int i = str1.length();i > 0 ;i -- ) {
for(int j = 0;j < str1.length() + 1 - i;j++) {
if(str2.indexOf(str1.substring(j,j+i)) != -1) {//或者利用contains方法判断是否有
return str1.substring(j,j+i);//使用substring一定要注意，最后一个索引的字符并未截取下来
}
}
}
return "无";
}
}
（5）写出实现trim（）功能的代码。去除字符串两端的空格。
思路：a.判断第一个不是空字符的角标；
B．判断从后往前的第一个不是空格字符的索引；
C．取出中间的子字符串，即可。
package sdk.November25.am;
public class TrimMethod {
public static void main(String[] args) {
String str = " ddds ";
String strtrim = myTrim(str);
System.out.println(str);
System.out.println(strtrim);
System.out.println(str.length() + " " +strtrim.length());
}
private static String myTrim(String str) {
int indexmin = 0;
int indexmax = str.length()-1;
for(;str.charAt(indexmin) == ' ';indexmin++)
if(indexmin == str.length()-1)
return "";//保证此字符串不是完全空字符组成的，下面从后往前就不用再判断了，因为从前往后已经做了处理
for(;str.charAt(indexmax) == ' ';indexmax--);
System.out.println(indexmin + " " +indexmax);
String str2 = str.substring(indexmin,indexmax + 1);////使用substring 一定要注意，最后一个索引的字符并未截取下来
return str2;
}
第四单元计算机网络常见的操作系统
windos 2003 server实用教程 一、单元目标、任务：任课教师：高鹏 本单元课程标题：常见计算机网络的操作系统 授课班级 10中职5、6班 课时 2 时间 2011.11．15 授课地点 阶教 教学目标 能力（技能）目标 知识目标 1.会正确识别windos2003系列的nos及安装目标 2.能正确识别常规的网络操作系统光盘阅读相关参数 1.掌握常规的网络操作系统的类型 2.了解unix，linux，操作系统的发展背景 3.掌握windos2003 server 的四个版本类型 4.了解操作系统与网路操作系统的区别和联系 5.掌握nos的常规网络服务项目. 能力训练任务及案例
案例1：我系机房的os及os的安装选择. 任务1：常规windos2003 server的识别及分析阅读 任务2：能说出windos2003server的四个版本及适用环境. 任务3：条件充许的情况下使用虚拟机模拟安装windos2003server 参考资料 《windos 2003 server教程》新世纪高职高专教材编审委员会组编主编刘宝莲《计算机网络教程实训教程》新世纪高职高专教材编审委员会组编主编刘宝莲《计算机技术网络基础教程》第二版电子工业出版社主编严争 二、教学设计： 步骤 教学内容 教学 方法 教学 手段 学生 活动 时间 分配 内容引入 （问题） 以我院网络中心办公系统平台为列引出服务器操作系统 提问法 课件演示 提问 5 分钟
准备 （问题） 为什么服务器不能安装windos xp 操作系统呢” 告知 （教学内容、目的） 告之学生本次课程要学习的主要内容： 1．网络操作系统unix .linux windos实例的历史 2．常规的网络操作系统有哪些？如何选择。 3．Windos server 2003 操作系统的四个版本 讲授法 老师讲学生听 5 分钟 教学目的： 通过本课的讲解使同学们对常规的网络操作系统有了初步的了解,使同学们对os与nosyoule 正确的了解得区分与应用组成.为后期服务器搭建打下了良好的基础. 项目引入 （任务项目） 教学演示： 1．网络操作系统的发展历史 2．网络操作系统的功能 3．网络操作系统安装 讲授法
java对象转换String类型的三种方法
北大青鸟中关村 java对象转换String类型的三种方法在很多情况下我们都需要将一个对象转换为String类型。一般来说有三种方法可以实现：Object.toString()、(String)Object、String.valueOf(Object)。下面对这三种方法一一分析 一、采用Object.toString() toString方法是https://www.wendangku.net/doc/5914407948.html,ng.Object对象的一个public方法。在java中任何对象都会继承Object 对象，所以一般来说任何对象都可以调用toString这个方法。这是采用该种方法时，常派生类会覆盖Object里的toString()方法。 但是在使用该方法时要注意，必须保证Object不是null值，否则将抛出NullPointerException 异常。 二、采用(String)Object 该方法是一个标准的类型转换的方法，可以将Object转换为String。但是在使用该方法是要注意的是需要转换的类型必须是能够转换为String的，否则会出现CalssCastException异常错误。 代码代码如下: Object o = new Integer(100); String string = (String)o; 这段程序代码会出现https://www.wendangku.net/doc/5914407948.html,ng.ClassCastException: https://www.wendangku.net/doc/5914407948.html,ng.Integer cannot be cast to https://www.wendangku.net/doc/5914407948.html,ng.String。因为将Integer类型强制转换为String类型，无法通过。 三、String.valueOf(Object) 上面我们使用Object.toString()方法时需要担心null问题。但是使用该方法无需担心null值问题。因为在使用String.valueOf(Object)时，它会判断Object是否为空值，如果是，则返回null。下面为String.valueOf(Object)的源码： 代码代码如下: public static String valueOf(Object obj) { return (obj == null) ? "null" : obj.toString(); } 从上面我们可以看出两点：一是不需要担心null问题。二是它是以toString()方法为基础的。但是一定要注意：当object为null时，String.valueOf（object）的值是字符串对象："null"，而不是null！！！
网络操作系统重点知识
网络操作系统重点知识 1. ①操作系统的定义：操作系统是控制和管理计算机系统的硬件和软件资源、合理地组织工作流程以及方便用户的程序集合。 ②现代操作系统的基本特征：1、并发性2、共享性3、虚拟性4、不确定性 2. 操作系统在计算机系统中处于何种地位：是硬件层的第一次扩充，是计算机系统软件的重要组成部分。计算机系统的层次结构：硬件层—操作系统层—语言处理程序层—应用程序层。操作系统的作用：提高计算机系统的效率，增强系统的处理能力，充分发挥系统资源的利用率，方便用户使用。 3. 多道程序设计的硬件基础：①中断系统②通道技术③CPU与通道的通信 4. ①多道程序设计的基本原理：多道程序设计的主要目的是充分利用系统中所有资源且尽可能地让它们并行操作。采用通道技术后使CPU从繁琐的I/O操作中解放出来，它不仅能实现CPU与通道并行工作，而且也能实现通道与通道之间、各通道与外设之间的并行。 ②多道程序设计的主要特点：①多道②宏观上并行③微观上串行。 5. 实现多道程序设计要解决的几个问题：①存储保护和地址重定位。（几道程序共享同一主存）②处理机的管理和调度。（共享同一处理机）③资源的管理与分配。（共享系统资源） 9. ①系统调用：用户在程序中能用访管指令调用的，由操作系统提供的子功能集合，其中每一个子功能称为一个系统调用命令。②用户程序使用系统调用后，为什么能从算态进入管态，返回用户程序后又从管态回到算态（系统调用的实现原理）：系统调用中的访管指令的地址码可作为系统调用的功能号，它对应一个操作系统为用户提供的子功能或函数。当用户程序需要调用系统功能时，就在其程序的适当位置安排一条系统调用命令，当执行到该指令时便产生访管中断，中断的硬件装置开始响应中断，保存原来的PSW到内存的固定单元，再从内存的另一个固定单元中取出新的PSW送入PSW寄存器。由于新PSW中已事先设置了系统状态为管态，从而使处理机进入管态，在管态下执行中断处理程序。由于在管态下可以使用特权指令，所以用户要求操作系统提供的服务就很容易地被完成。中断处理程序结束后，通过恢复旧的PSW到PSW寄存器，于是又可返回到被中断的用户程序，即从管态又回到算态。 10. UNIX的系统调用的两种方式：①直接系统调用②间接系统调用。它们各是怎样处理：①直接系统调用除可使寄存器传递参数外，其它参数都跟在trap指令的后面②间接系统调用跟随trap指令的是一个指向程序数据区的指针。该程序数据区内有一个直接系统调用trap指令，其后跟以除r0外的参数。 11. ①分时：两个或两个以上的事件按时间划分轮流地使用计算机系统中的某一资源。②分时系统（又称交互作用系统）：在一个系统中，如果多个用户通过自己的终端分时地使用同一个计算机，这样的系统就称为分时系统，其上的操作系统统称为分时操作系统。UNIX 属分时系统。 ③分时系统的特点：①同时性（可同时操作，共同使用该系统）②独立性（独占感）③及时性（及时响应）④交互性（人机对话）。 调进/调出是实现分时系统的一种主要方式（分时系统实现原理）。（多流调进调出方式） 12. 实时系统分为两类：①实时控制系统（导弹发射）②实时处理系统（预订飞机票）。 设计实时系统要考虑的问题：①实时时钟管理（实时任务、延迟任务）②连续人机对话③过载的防护（任务的随机性）④高可靠性和保证（故障引起的严重后果）。 13. 分布式计算机系统：是一个由多台计算机组成的系统，在用户看来，他所拥有的计算机是一台单独的计算机，而这台计算机是一台功能扩大了的虚拟机。分布式系统的三个基本功能：①通信②资源共享③并行计算。分布式系统最为突出的特点是透明性。 分布式计算机系统具有以下主要特点： ①任意两台计算机之间可以利用通信交换信息。②各计算机具有相对的自主性或自治性。③具有透明性④具有整体性或协同性。⑤具有坚定性。（任一台故障不会使系统瘫痪。） 14. 分布式系统对资源的管理与集中式系统有何不同？ 答：分布式系统对资源的管理采用一类资源有多个管理者的分布式管理方式。分布式管理方式又可分为集中分布管理和完全分布管理两种方式。集中式系统对资源的管理采用一个管理者的方式。 17. 紧耦合与松耦合多处理机系统有何区别？ 答：主要区别在于有无共享存储器。①紧耦合多处理机系统有共享存储器，所以也称其为共享存储结构多处理机系统。 ②松耦合处理机系统中没有共享存储器，每台处理机都有一个容量较大的局部存储器，所以也称其为分布存储结构多处理机系统。
java中String类型转换方法
java中String类型转换方法 integer to String : int i = 42; String str = Integer.toString(i); or String str = "" + i double to String : String str = Double.toString(i); long to String : String str = Long.toString(l); float to String : String str = Float.toString(f); String to integer : str = "25"; int i = Integer.valueOf(str).intValue(); or int i = Integer.parseInt(str); String to double : double d = Double.valueOf(str).doubleValue(); String to long : long l = Long.valueOf(str).longValue(); or
long l = Long.parseLong(str); String to float : float f = Float.valueOf(str).floatValue(); decimal to binary : int i = 42; String binstr = Integer.toBinaryString(i); decimal to hexadecimal : int i = 42; String hexstr = Integer.toString(i, 16); or String hexstr = Integer.toHexString(i); hexadecimal (String) to integer : int i = Integer.valueOf("B8DA3", 16).intValue(); or int i = Integer.parseInt("B8DA3", 16); ASCII code to i = 64; String aChar = new Character((char)i).toString(); integer to ASCII code c = 'A'; int i = (int) c; // i will have the value 65 decimal To extract Ascii codes from a test = "ABCD"; for ( int i = 0; i < test.length(); ++i ) { char c = test.charAt( i ); int i = (int) c; System.out.println(i); }
《网络操作系统》习题(DOC)
《网络操作系统》习题 一、填空题 1. Windows Server 2003的标准版本适用于中、小型企业，主要用作服务器，提供各种常见的网络功能，如：文件服务、打印服务、通信服务、Web服务等。 2. 通过查看硬件兼容性列表文件，可以确认Windows Server 2003操作系统是否与一台计算机的硬件设备兼容。 3. 在检测软件兼容性时，需要在winnt32.exe命令后附加的参数为checkupgradeonly 。 4. Windows Server 2003支持的文件系统格式有：FAT、FAT32和NTFS 。 5. 在Windows Server 2003中，NTFS 文件系统格式支持文件加密。 6. 为了能够实现网络通信，管理员需要为计算机上的网卡等网络设备设置TCP/IP参数，包括：IP 地址、子网掩码和默认网关等。 7. 在安装硬件设备时，一般需要同时安装这个设备的驱动程序，该程序一般由硬件设备的开发厂商提供。 8. 对于即插即用的硬件设备，Windows Server 2003能够自动检测并进行安装。 9. 对于非即插即用的硬件设备，只能由用户手工安装。 10. 如果希望重新使用一个被禁用的设备，应该对该设备的执行启用的操作。 11. 在工作组中，每台计算机均把自己的资源信息和安全信息存放在本地的SAM或安全账户管理数据库中。 12. 在工作组中的一台计算机上所创建的用户账户，被称为本地或本机用户账户。 13. 在网络中工作、使用网络资源的人被称为用户。 14. 如果一个员工长时间不工作，那么为安全起见，管理员应该将他的用户帐户禁用。 15. 在一个工作组中，每台Windows计算机的内置管理员或Administrator 帐户能够在本地计算机的SAM数据库中创建并管理本地用户帐户。 16. 在Windows计算机上不能对文件实施共享，而只能对文件夹实施共享。 17. 管理员在对文件夹实施共享之后，必须设置权限，这样才能保证用户访问共享文件夹的安全。 18. 当创建共享文件夹时，如果在它的共享名的后面附加一个
STRING类函数用法总结3
C++中的string类 前言:string的角色 1string使用 1.1充分使用string操作符 1.2眼花缭乱的string find函数 1.3string insert,replace,erase2string和C风格字符串 3string和Charactor Traits 4string建议 5小结 6附录前言:string的角色 C++语言是个十分优秀的语言，但优秀并不表示完美。还是有许多人不愿意使用C或者C++，为什么？原因众多，其中之一就是C/C++的文本处理功能太麻烦，用起来很不方便。以前没有接触过其他语言时，每当别人这么说，我总是不屑一顾，认为他们根本就没有领会C++的精华，或者不太懂C++，现在我接触perl,php,和Shell脚本以后，开始理解了以前为什么有人说C++文本处理不方便了。 举例来说，如果文本格式是：用户名电话号码，文件名name.txt Tom23245332 Jenny22231231 Heny22183942 Tom23245332 ... 现在我们需要对用户名排序，且只输出不同的姓名。 那么在shell编程中，可以这样用： awk'{print$1}'name.txt|sort|uniq 简单吧？ 如果使用C/C++就麻烦了，他需要做以下工作： 先打开文件，检测文件是否打开，如果失败，则退出。 声明一个足够大得二维字符数组或者一个字符指针数组 读入一行到字符空间 然后分析一行的结构，找到空格，存入字符数组中。 关闭文件 写一个排序函数，或者使用写一个比较函数，使用qsort排序 遍历数组，比较是否有相同的，如果有，则要删除，copy... 输出信息 你可以用C++或者C语言去实现这个流程。如果一个人的主要工作就是处理这种
java 字符串常用函数及其用法
java中的字符串也是一连串的字符。但是与许多其他的计算机语言将字符串作为字符数组处理不同，Java将字符串作为String类型对象来处理。将字符串作为内置的对象处理允许Java提供十分丰富的功能特性以方便处理字符串。下面是一些使用频率比较高的函数及其相关说明。 String相关函数 1)substring() 它有两种形式，第一种是：String substring(int startIndex) 第二种是：String substring(int startIndex,int endIndex) 2)concat() 连接两个字符串 例:String s="Welcome to "; String t=s.concat("AnHui"); 3)replace() 替换 它有两种形式，第一种形式用一个字符在调用字符串中所有出现某个字符的地方进行替换，形式如下： String replace(char original,char replacement) 例如：String s=”Hello”.replace(’l',’w'); 第二种形式是用一个字符序列替换另一个字符序列，形式如下： String replace(CharSequence original,CharSequence replacement) 4)trim() 去掉起始和结尾的空格 5)valueOf() 转换为字符串 6)toLowerCase() 转换为小写 7)toUpperCase() 转换为大写 8)length() 取得字符串的长度 例：char chars[]={’a',’b’.’c'}; String s=new String(chars); int len=s.length(); 9)charAt() 截取一个字符 例：char ch; ch=”abc”.charAt(1); 返回值为’b’ 10)getChars() 截取多个字符 void getChars(int sourceStart,int sourceEnd,char target[],int targetStart) sourceStart 指定了子串开始字符的下标 sourceEnd 指定了子串结束后的下一个字符的下标。因此，子串包含从sourceStart到sourceEnd-1的字符。
CPPstring类常用函数
C++string类常用函数 string类的构造函数： string(const char *s); //用c字符串s初始化 string(int n,char c); //用n个字符c初始化 此外，string类还支持默认构造函数和复制构造函数，如string s1；string s2="hello"；都是正确的写法。当构造的string太长而无法表达时会抛出length_error异常 string类的字符操作： const char &operator[](int n)const; const char &at(int n)const; char &operator[](int n); char &at(int n); operator[]和at()均返回当前字符串中第n个字符的位置，但at函数提供范围检查，当越界时会抛出out_of_range异常，下标运算符[]不提供检查访问。 const char *data()const;//返回一个非null终止的c字符数组 const char *c_str()const;//返回一个以null终止的c字符串 int copy(char *s, int n, int pos = 0) const;//把当前串中以pos开始的n个字符拷贝到以s为起始位置的字符数组中，返回实际拷贝的数目 string的特性描述: int capacity()const; //返回当前容量（即string中不必增加内存即可存放的元素个数） int max_size()const; //返回string对象中可存放的最大字符串的长度 int size()const; //返回当前字符串的大小 int length()const; //返回当前字符串的长度 bool empty()const; //当前字符串是否为空 void resize(int len,char c);//把字符串当前大小置为len，并用字符c填充不足的部分 string类的输入输出操作: string类重载运算符operator>>用于输入，同样重载运算符operator<<用于输出操作。 函数getline(istream &in,string &s);用于从输入流in中读取字符串到s中，以换行符'\n'分开。 string的赋值： string &operator=(const string &s);//把字符串s赋给当前字符串 string &assign(const char *s);//用c类型字符串s赋值 string &assign(const char *s,int n);//用c字符串s开始的n个字符赋值 string &assign(const string &s);//把字符串s赋给当前字符串 string &assign(int n,char c);//用n个字符c赋值给当前字符串 string &assign(const string &s,int start,int n);//把字符串s中从start开始的n个字符赋给当前字符串 string &assign(const_iterator first,const_itertor last);//把first和last迭代器之间的部
java中String的“==”和equals判断相等性
1. 首先String不属于8种基本数据类型，String是一个对象。 因为对象的默认值是null，所以String的默认值也是null；但它又是一种特殊的对象，有其它对象没有的一些特性。 2. ne w String()和ne w String(“”)都是申明一个新的空字符串，是空串不是null； 3. String str=”kvill”与String str=ne w String (“kvill”)的区别： 在这里，我们不谈堆，也不谈栈，只先简单引入常量池这个简单的概念。 常量池(consta nt pool)指的是在编译期被确定，并被保存在已编译的.class文件中的 一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。 看例1： String s0=”kvill”; String s1=”kvill”; String s2=”kv”+ “ill”; Syste m.out.println( s0==s1 ); Syste m.out.println( s0==s2 ); 结果为： true
true 首先，我们要知道Java会确保一个字符串常量只有一个拷贝。 因为例子中的s0和s1中的”kvill”都是字符串常量，它们在编译期就被确定了，所以s0==s1为true；而”kv”和”ill”也都是字符串常量，当一个字符串由多个字符串常量连接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被解析为一个字符串常量，所以s2也是常量池中”kvill”的一个引用。 所以我们得出s0==s1==s2; 用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池中，它们有自己的地址空间。 看例2： String s0=”kvill”; String s1=ne w String(”kvill”); String s2=”kv”+ ne w String(“ill”); Syste m.out.println( s0==s1 ); Syste m.out.println( s0==s2 ); Syste m.out.println( s1==s2 );
string类中函数介绍
标准c++中string类函数介绍 注意不是CString 之所以抛弃char*的字符串而选用C++标准程序库中的string类，是因为他和前者比较起来，不必担心内存是否足够、字符串长度等等，而且作为一个类出现，他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。我们可以用= 进行赋值操作，== 进行比较，+ 做串联（是不是很简单?）。我们尽可以把它看成是C++的基本数据类型。 好了，进入正题……… 首先，为了在我们的程序中使用string类型，我们必须包含头文件
java中常用的一些方法
java中常用的一些方法 字符串 1、获取字符串的长度 length() 2 、判断字符串的前缀或后缀与已知字符串是否相同 前缀startsWith(String s) 后缀endsWith(String s) 3、比较两个字符串 equals(String s) 4、把字符串转化为相应的数值 int型Integer.parseInt(字符串) long型Long.parseLong(字符串) float型Folat.valueOf(字符串).floatValue() double型Double.valueOf(字符串).doubleValue() 4、将数值转化为字符串 valueOf(数值) 5、字符串检索 indexOf(Srting s) 从头开始检索 indexOf(String s ,int startpoint) 从startpoint处开始检索 如果没有检索到，将返回-1 6、得到字符串的子字符串 substring(int startpoint) 从startpoint处开始获取 substring(int start,int end) 从start到end中间的字符 7、替换字符串中的字符,去掉字符串前后空格 replace(char old,char new) 用new替换old trim() 8、分析字符串 StringTokenizer(String s) 构造一个分析器，使用默认分隔字符（空格，换行，回车，Tab，进纸符）StringTokenizer(String s,String delim) delim是自己定义的分隔符
nextToken() 逐个获取字符串中的语言符号 boolean hasMoreTokens() 只要字符串还有语言符号将返回true，否则返回false countTokens() 得到一共有多少个语言符号 文本框和文本区 1、文本框 TextField() 构造文本框，一个字符长 TextField(int x) 构造文本框，x个字符长 TextField(String s) 构造文本框，显示s setText(String s) 设置文本为s getText() 获取文本 setEchoChar(char c) 设置显示字符为c setEditable(boolean) 设置文本框是否可以被修改 addActionListener() 添加监视器 removeActionListener() 移去监视器 2、文本区 TextArea() 构造文本区 TextArea(String s) 构造文本区，显示s TextArea(String s,int x,int y) 构造文本区，x行，y列，显示s TextArea(int x,int y) 构造文本区，x行，y列 TextArea(String s,int x,ing y,int scrollbar) scrollbar的值是： TextArea.SCROLLBARS_BOTH TextArea.SCROLLBARS_VERTICAL_ONLY TextArea.SCROLLBARS_HORIZONTAL_ONLY TextArea.SCROLLBARS_NONE setText(String s) 设置文本为s
C++string类标准库常用函数
C++ string类标准库常用函数 [string类的构造函数] string(const char *s); //用c字符串s初始化 string(int n,char c); //用n个字符c初始化 [string类的字符操作] const char &operator[](int n) const; const char &at(int n) const; char &operator[](int n); char &at(int n); operator[]和at()均返回当前字符串中第n个字符的位置，但at函数提供范围检查，当越界时会抛出out_of_range 异常，下标运算符[]不提供检查访问。 const char *data() const; //返回一个非null终止的c字符数组 const char *c_str() const; //返回一个以null终止的c字符串 int copy(char *s, int n, int pos = 0) const;//把当前串中以pos开始的n个字符拷贝到以s为起始位置的字符数组中，返回实际拷贝的数目 [string的特性描述] int capacity() const; //返回当前容量（即string中不必增加内存即可存放的元素个数） int max_size() const; //返回string对象中可存放的最大字符串的长度 int size() const; //返回当前字符串的大小 int length() const; //返回当前字符串的长度 bool empty() const; //当前字符串是否为空 void resize(int len,char c); //把字符串当前大小置为len，并用字符c填充不足的部分 [string类的输入输出操作] string类重载运算符operator>>用于输入，同样重载运算符operator<<用于输出操作。 函数getline(istream &in,string &s);用于从输入流in中读取字符串到s中，以换行符'\n'分开。 [string的赋值] string &operator=(const string &s); //把字符串s赋给当前字符串 string &assign(const char *s); //用c类型字符串s赋值 string &assign(const char *s,int n); //用c字符串s开始的n个字符赋值 string &assign(const string &s); //把字符串s赋给当前字符串 string &assign(int n,char c); //用n个字符c赋值给当前字符串 string &assign(const string &s,int start,int n);//把s中从start开始的n个字符赋给当前字符串string &assign(const_iterator first,const_iterator last);//把迭代器first和last之间的部分赋给字符串 [string的连接] string &operator+=(const string &s); //把字符串s连接到当前字符串的结尾 string &append(const char *s); //把c类型字符串s连接到当前字符串结尾 string &append(const char *s,int n); //把c类型字符串s的前n个字符连接到当前字符串结尾 string &append(const string &s); //同operator+=() string &append(const string &s,int pos,int n); //把字符串s中从pos开始的n个字符连接到当前字符串的结尾 string &append(int n,char c); //在当前字符串结尾添加n个字符c string &append(const_iterator first,const_iterator last); //把迭代器first和last之间的部分连接到当前字符串的结尾
Java API----String类的方法
//===============API的使用步骤=================== 1:打开API帮助手册 2:显示--->索引-->输入要查的API 3:找到你要使用的方法 //---------------------------- 1:导包//https://www.wendangku.net/doc/5914407948.html,ng.xxx；不需要导包 2:创建类的对象 3:调用方法 //String类： //构造方法 public String(String original) public String(char[] value) public String(char[] value,int offset,int count) //直接赋值也可以是一个对象 //注意：字符串是一种比较特殊的引用数据类型，直接输出字符串对象输出的是该对象中的数据。
//String的特点 //通过构造方法创建字符串对象 String s = new String(“hello”); //直接赋值创建字符串对象 String s = “hello”; //区别是什么? //面试题: String str = new String("helloworld"); //创建两个对象，一个在堆中，一个在常量池中String str2 = "helloworld"; //创建一个对象，在常量池中 //常用方法 //判断功能方法 boolean equals(Object obj)//比较字符串的内容是否相同 boolean equalsIgnoreCase(String str)//比较字符串的内容是否相同,忽略大小写boolean startsWith(String str)//判断字符串对象是否以指定的str开头 boolean endsWith(String str)//判断字符串对象是否以指定的str结尾
网络操作系统考试试题库
一、选择题（共30分，每小题1分） 1、在操作系统中存在许多同时的或者并行的活动，这种特征称为（C） A、共享性 B、虚拟性 C、并发性 D、不确定性 2、用于连接磁带、磁鼓和磁盘等快速设备，以成组方式工作的是（D） A、字节多路通道 B、数组多路通道 C、控制器 D、选择通道 3、在静态下运行的操作系统程序中，只能在管态下执行而不能在算态下执行的特殊机器指令是（A） A、特权指令 B、系统调用指令 C、陷阱指令 D、访管指令 4、分时系统中，每个用户都有一种独点感，感到该系统好像为我一个用户在服务，这种特征是（B） A、同时性 B、独立性 C、分时性 D、交互性 5、在紧耦合多处理机系统中，处理机间实现相互通信的机制是（B） A、消息传递机制 B、共享主存 C、环形网络 D、总线网络 6、把操作系统分成若干进程，其中每个进程实现单独的一套服务，这种服务模式是（C） A、对象模式 B、对称多处理机模式 C、客户机/服务器模式 D、对等模式 7、进程从运行态进入就绪态的原因可能是（A）
A、时间片用完 B、被选中占有处理器 C、等待的I/O操作已完成 D、等待I/O操作 8、能够按照变化的情况对各种进程的优先级进行适当地调整，这种进程调度算法是（D） A、静态优先级算法 B、时间片轮转算法 C、先来先服务算法 D、动态优先级算法 9、在具有多线程机制的操作系统中，处理机调度的基本单位是（B） A、进程 B、线程 C、字节 D、块 10、为了加快查表速度，在地址变换机构中加入一组高速寄存器，这些寄存器连同管理它们的硬件构成了一个容量较小的存储器，称为（C） A、主存储器 B、辅助存储器 C、联想存储器 D、Cache 11、进程间的互斥是指进程间在逻辑上的相互关系是（D） A、调用 B、联接 C、直接制约 D、间接制约 12、在基于消息传递通信机制中，其核心成分是（A） A、通信原语 B、函数 C、参数 D、程序 13、根据通信协议来控制和管理进程间的通信的软件是（C） A、网络操作系统 B、网络传输软件 C、网络通信软件 D、网络应用软件 14、以虚拟软盘方式实现硬盘共享的软件必须具有四方面的功能，即盘卷管理、安装管理、信号量管理和（B）
Java中string的相关函数
Java中string的相关函数 字串与字元 文字字串是一个相当基本且经常被使用到的资料型态，然而在Java 中字串不象char、int 与float 一样是个基本资料型态，而是使用https://www.wendangku.net/doc/5914407948.html,ng.String 类别来加以表示，该类别定义了许多有用的方法来操作字串。String 物件是固定不变的(immutable)：一旦一个String 物件被建立了，则没有任何方法可以改变它所代表的文字，因此，每个运作字串的方法会传回一个新的String 物件，而所修正过后的字串便是储存在此新物件里。 以下的程式码展示了你可以对字串所执行的运作： // 建立字串 String s = "Now "; // String 物件有个特殊的写法 String t = s + "is the time. "; // 使用+ 运算子来串连字串 String t1 = s + " " + 23.4; // + 将其它值转换为字串 t1 = String.valueOf( 'c '); // 从字元值获得对应的字串 t1 = String.valueOf(42); // 获得整数或其他任何数值的字串版本 t1 = Object.toString(); // 使用toString() 将物件转换为字串 // 字串长度 int len = t.length(); // 字串中的字元数：16 // 字串中的子字串 String sub = t.substring(4); // 传回从char 4 到最后的子字串："is the time. " sub = t.substring(4, 6); // 传回chars 4 与5："is " sub = t.substring(0, 3); // 传回chars 0 到2："Now " sub = t.substring(x, y); // 传回从位置x 到y-1 间的子字串 int numchars = sub.length(); // 子字串的长度永远是(y-x) // 从一个字串中撷取(extract)出字元 char c = t.charAt(2); // 取得t 的第三个字元：w char[] ca = t.toCharArray(); // 将字串转换为一个字元阵列 t.getChars(0, 3, ca, 1); // 将t 中的前三个字元放到ca[1] 到ca[3] 中 // 大小写转换 String caps = t.toUpperCase(); // 转换为大写 String lower = t.toLowerCase(); // 转换为小写 // 字串比较 boolean b1 = t.equals( "hello "); // 传回flase：两字串并不相等 boolean b2 = t.equalsIgnoreCase(caps); // 忽略大小写的字串比较：true boolean b3 = t.startsWith( "Now "); // 传回true boolean b4 = t.endsWith( "time. "); // 传回true int r1 = https://www.wendangku.net/doc/5914407948.html,pareTo( "Pow "); // 传回值<0：s 在"Pow "之前 int r2 = https://www.wendangku.net/doc/5914407948.html,pareTo( "Now "); // 传回值0：两字串相等
C 中的string常用函数用法总结.
C++中的string常用函数用法总结首先，为了在我们的程序中使用string类型，我们必须包含头文件