1. String基础:
字符串是编程时经常用到的一种数据类型。Java中使用String类和StringBuilder类来封装字符串。String类定义不变字符串,StringBuffer类则用于可变字符串处理。换句话说,String类创建的字符串时不会改变的,而StringBuffer类创建的字符串可以修改。
字符串的声明与创建:
1. 声明字符串的格式如下:
String stringName;
2. 字符串的创建可以有以下两种方法。
使用字符串构造方法,字符串的构造方法又如下四个:
public String(); //创建一个空的字符串
public String(String str); //用已有字符串创建新的字符串
public String(StringBuffer str); //用StringBuffer对象的内容初始化新字符串
public String(char value[]0); //用已有字符数组初始化新的字符串
使用赋值语句。也可以使用赋值语句创建String类型变量并赋值。
String str = "Student";
-
上面语句与使用构造方法创建字符串变量等价。
-
这里需要注意的是,字符串常量在Java中是以对象形式存储的,Java编译时将自动为每个字符串常量创建一个对象。因此将字符串常量传递给字符串变量时,Java编译器自动将常量对应的对象传递给字符串变量,因此下面的两条语句中,两个字符串变量str1和str2均指向同一个内存空间。
String str1 = "Student";
String str2 = "Student";
2. String类的要点:
- String类又被称作不可变字符序列。
- String类位于java.lang包中,Java程序默认导入java.lang包下的所有类。
- Java字符串就是Unicode字符序列,例如字符串"Java"就是4个Unicode字符组成。
- Java中没有内置的字符串类型,而是在标准Java类库中提供了一个预定义的类String,每个用双引号引起来的字符串都是String类的实例。
- java允许使用符号“+”把两个字符串连接起来。
3. 字符串类String的主要方法:
1. 获取字符串长度:
可以使用字符串.length()的形式来获得字符串的长度。
public int length();
int length = "abc".length();//返回3
2. 截取一个字符:
该方法返回指定索引处的char值。索引范围从0到length()-1.字符串的第一个char值在索引0处,第二个在索引1处,以此类推。
public char charAt();
char ch = "abc".charAt(1);//返回'b'
3. 取得子串:
public String substring(int beginIndex);
public String substring(int beginIndex,int endIndex);
诀窍:取前不取后,length = endIndex-beginIndex;
"unhappy".substring(2); //happy
"smiles".substring(1,5); //mile
4. 字符产相等比较:
public boolean equals(String str);
字符串对象调用String类的equals方法,比较当前字符串对象是否与参数制定的字符串str对象相同。
String str1 = "Hello";
String str2 = new String("Hello");
str1.equals(str2);//返回true
public boolean equalsIgnoreCase(String anotherString);
忽略大小写进行内容的比较
"hello".equalsIgnoreCase("Hello"); //true
- 需要注意的是,==运算符比较两个对象是否引用同一实例。
String str1 = "Hello"; //地址值0x5678
String str2 = "Hello"; //地址值0x5678
String str3 = new String("Hello"); //地址值0x6789
boolean bool1 = (str1 == str2); //true
boolean bool2 = (str1 == str3); //false
str1.equals(str3); //true
5. 字符串连接:
public String concat(String str);
该方法将指定字符串串联到此字符串的结尾。如果参数字符串的长度为0,则返回此String对象。
"Tom".concat("&Jerry");//返回Tom&Jerry
String str = "567"+"和789";//返回567和789
6. 字符串内容比较:
public int compareTo(String anotherString);
按字典顺序比较两个字符串,该比较基于字符串中各个字符的Unicode值。
将此String对象表示的字符序列与参数字符串所表示字符序列进行比较。
如果按字典顺序此String对象在参数字符串之前,则比较结果为一个负整数。反之为正整数。如果这两个字符串相等,则结果为0.
compareTo只有在方法equals(Object)返回true时才返回0
- 除此之外,java还提供了不考虑大小写的字典顺序比较方法,
public int compareToIgnoreCase(String str);
例如:
String s1 = "abc";
String s2 = "ABC";
String s3 = "acb";
String s4 = "abc";
System.out.println(s1.compareTo(s2)); //返回32
System.out.println(s1.compareTo(s3)); //返回-1
System.out.println(s1.compareTo(s4)); //返回0
System.out.println(s1.compareToIgnoreCase(s2)); //返回0
7. 字符串检索:
字符串检索是指确定一个字符串是否包含某一个字符或子字符串,如果包含则返回其位置;如果没有,则返回负数。
public int indexOf(int ch);
public int indexOf(int ch,int fromIndex);
public int indexOf(String stringName2);
public int indexOf(String stringName2,int fromIndex);
String s1 = "I love java";
System.out.println(s1.indexOf('a')); //返回8
System.out.println(s1.indexOf('j',2)); //返回7
System.out.println(s1.indexOf("love")); //返回2
System.out.println(s1.indexOf("love",9)); //返回-1
8. 去掉起始和末尾的空格:
trim()返回删除字符串起始和结尾的空格后的字符串,如果没有起始和结束空格,则返回此字符串。
public String trim();
String s= " this is a demo of the trim method.";
String s1 = s.trim(); //s1 = "this is a demo of the trim method.";
9. 字符串替换:
public String repalce(char oldChar,char newChar);
例如:
String s = "the war of baronets".replace('r','y'); //s = "the way of bayonets";
10. 字符串大小写转换:
public String toLowerCase();
将字符串中的所有字符全部小写
String s = "I Love Java".toLowerCase(); //s = "i love java";
public String toUpperCase();
将字符串中的所有字符全部大写
String s = "I Love Java".toUpperCase(); //s = "I LOVE JAVA";
11. 将其他数据类型转换为字符串:
public static String valueOf(boolean bool);
public static String valueOf(char c);
public static String valueOf(int i);
public static String valueOf(long l);
public static String valueOf(float f);
public static String valueOf(double d);
另外,Object类的toString方法也可以实现其他数据类型转换为字符串。例如:
String s = Double.toString(12.8); //s = "12.8";
String s = String.valueOf(12.8); //s = "12.8";
String s = String.valueOf(true); //s = "true";
需要注意的是,Object类的toString方法返回该对象的字符串表示。通常,toString方法会返回一个以文本方式表示此对象的字符串。结果应简明但易于读懂。
12. 字符串的分隔:
public String[] split(String regex);
public String[] split(String regex,int limit);
例如:
String message = "I Love Java";
String[] split = message.split(" "); //返回一个数组包含["I","Love","Java"];
4. StringBuffer类的主要方法:
String类和StringBuffer类都可以存储和操作字符串,即包含多个字符的字符串数据。String类是字符串常量,是不可更改的常量。而StringBuffer是字符串变量,他的对象是可以扩充和修改的。
- 常用的StringBuffer的构造方法:
StringBuffer(String str);//构造一个字符串缓冲区,并将其内容初始化为指定过的字符串内容。
- 主要操作有:append方法和insert方法
append方法每次只能添加字符串在末端,而insert方法可以在指定的位置进行插入。
两个方法都可以进行重载,将不同类型的数据转换成字符串,然后将该字符串的字符追加或插入到字符串缓冲区中。
String str = "start";
str.append("le"); //返回"startle"
str.insert(4,"le"); //返回"starlet"
5. 数组
数组就是相同类型的数据按顺序组成的一种复合数据类型,每个数据成为一个数据元素,用下标来表示同一数组中的不同数组元素,使用时可以哦通过数组名和下标访问数组中的元素,其下表从0开始。
数组的特点如下:
- 一个数组中的元素的数据类型应该是相同的。
- 数组中的各个元素是有序的,他们在内存中是按照先后顺序连续存放在一起的。
- 每个数组元素用其所在数组的名字和数组下标来确定。
- 数组的下标是从0开始的,数组的长度是指其所包含的数组元素的个数。
Java提供数组类型,数组元素可以是简单数据类型,也可以是引用数据类型(对象或数组)。
如果是基本数据类型,则为一维数组。数组元素仍为数组的是多维数组。Java的数组元素是引用数据类型,数组的使用步骤应该是:声明--创建--初始化--使用。
1. 一维数组:
1. 一维数组的声明:
声明一维数组的格式有如下两种:
- 数组元素类型[] 数组名;
- 数组元素类型 数组名[];
数组声明的时候,Java没有给数组进行分配空间,仅仅创建了一个引用数组的存取地址。
数组的声明的目的只是告诉系统一个新的数组的名称和类型,数组本身不能存放任何数组元素,现阶段的数组值为null。
因此,使用数组之前,需要先使用new关键字创建数组,为数组分配指定长度的内存空间。
2. 数组的创建:
为数组进行分配空间的格式如下:
数组名 = new 数组元素的类型[数组的长度];
例如:double array = new double[10];//创建了一个长度为10的数组,并分配了内存空间
这样,就给数组array分配了长度为10的内存空间,用来保存10个double类型的数据。
3. 数组的初始化:
数组创建之后,若不对数组进行初始化,系统会自动根据其类型自动为数组元素赋值。
1.byte、int、short、long类型默认为0
2.float、double默认为0.0
3.boolean默认为false、char类型默认为\u0000
4.若是引用数据类型的话,默认为null
可以在声明数组的同时进行数组内存的创建和初始化,例如:
double[] score = {98.8,85,78,100};
由于声明对象数组时,元素的默认初始化是null,因此数组初始化时需要创建对象,例如:
Student[] student = {new Student("zhangsan"),new Student("wang"),new Student("guo")};
4. 数组的使用:
数组的长度:
所有的数组都有一个属性length(长度),他存储了数组元素的个数。
数组元素的访问:
数组元素的访问可以借助数组名和元素下标来完成。
【注意】:访问数组时要注意下标不要越界,如果下标越界,则运行时会产生“数组访问越界异常”。在实际应用中,经常使用循环来控制对数组元素的访问,访问数组的下标随循环控制变量变化。
数组的复制/拷贝:
System类中有一个静态方法:arrayCopy()方法,可以将数组中的元素的值复制给另外一个元素,而又不改变原数组的值。
public static native void arrayCopy(Object src,int srcPos,Object dest,int destPos,int length);
该方法可以将src原数组中从srcPos索引开始的连续length个元素复制到dest数组的从destPos开始的位置,且src和dest数组指向不同的内存空间。
2. 多维数组:
Java语言中,二维数组可以看为数组的数组,那么三位数组可以看为二维数组的数组。以此类推...
由于多维数组的数组元素也是数组,所以需要为数组元素分配相应的存储空间,分配空间可以在创建数组的同时进行,也可以用new运算符为数组元素分配内存。
如果多维数组中每维元素的长度不同,那么就造成数组空间的分配不是连续的。当然,一维数组的空间仍然是连续分配的。
以二维数组为例,说明二维数组的定义创建和使用等。
1. 二维数组的声明:
声明二维数组有一下两种格式:
- 数组元素类型 数组名[][];
- 数组元素类型[][] 数组名;
例如:double score[][]; double[][] score;
2. 二维数组的初始化:
二维数组可以通过new关键字初始化,或是声明的同时使用赋值语句初始化
- 用new初始化:
格式:数组名 = new 数组元素类型[数组的行数][数组的列数];
例如:score = new double[4][3];
表明score是一个4行3列的而数组,初始化时每个元素均为0.0,二维数组的数组元素是一维数组,因此,初始化也可各行单独进行.Java的二维数组允许每行有不同的元素个数。
- 用赋初值的方法初始化:
类型 数组名[][] = {{1,2,3},{4,5},{6,7,8,9}};
3. 二维数组的使用:
二维数组中使用两个下标:一个表示行、一个表示列,可以看成一个矩阵,每个下标都是从0开始。
- 获取二维数组的长度:
二维数组.length ------> 二维数组的行数
二维数组[i].length----> 每一行数组的个数
- 二维数组可以存储数据表格:
二维数组可以看成一个矩阵,同时也可以看成一个表格,利用Object的二维数组可以存储任意类型的数据。
Object[] emp1 = {1001,"gsl1",18,"讲师1","2000.09.16"};
Object[] emp2 = {1002,"gsl2",18,"讲师2","2000.09.16"};
Object[] emp3 = {1003,"gsl3",18,"讲师3","2000.09.16"};
Object[] emp4 = {1004,"gsl4",18,"讲师4","2000.09.16"};
Object[][] objects = new Object[4][];
objects[0] = emp1;
objects[1] = emp2;
objects[2] = emp3;
objects[3] = emp4;
这样就可以形成一个数据表格。
3. 二维以上的数组:
- 声明:多加几个括号即可。三维数组 double score[][][];以此类推...
- 使用:使用多个下标进行确定。
4. 数组类Arrays:
Java的工具包util中提供了工具类Arrays,该类定义了常见操作数组的静态方法,可以方便的进行数组操作,如排序和搜索等等。
Arrays提供多种基本方法:
- equals()用于比较两个数组是否相等。
- fill()用于以某个值填充整个数组。
- sort()用于对数组排序。
- binarySearch()用于在已经排序的数组中查找元素。
- asList()接受任意的数组为参数,并将其转变为List容器.
5. 数组的一些基本算法:
1. 数组排序-冒泡排序:
冒泡排序是最常用的排序算法。
算法重读的走访过要排序的数组,一次比较两个元素,如果他们的顺序错误,就将他们调整过来,这样越来越大的元素由于交换慢慢“浮”到数列的顶端。
算法的基本运作
- 比较相邻的元素,如果第一个比第二个大,就交换他们两个。
- 对每一对相邻元素都做同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
- 针对所有的而元素重复以上的步骤,除了最后一个。
- 针对每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
示例:冒泡排序的基础算法:
public static void main(String[] args){
int[] values = {3,2,1,5,7,4,6};
for(int i = 0;i<values.length - 1;i++){
for(int j = 0, j<values.length-i-1;j++){
if(values[j] > values[j+1]){
int temp = values[j];
values[j] = values[j+1];
values[j+1] = temp;
}
System.out.println(Arrays.toString(values));
}
}
}
除此之外,冒泡排序可以进行优化:
根据最好情况和最差情况,当情况较好时,不需要发生多次交换,即使用flag
进行条件判断,如果需要交换的时候在交换,具体代码:
public static void main(String[] args){
int[] values = {3,2,1,5,7,4,6};
//大循环表示需要循环的次数
for(int i = 0;i<values.length-1;i++){
//设置flag=true,若没有进入过if语句,表示子序列已经有序,不需要进行下一次循环
boolean flag = true;
//小循环表示需要比较的次数
for(int j = 0;j<values.length-i-1;j++){
if(values[j]>values[j+1]){
int temp = values[j];
values[j] = values[j+1];
values[j+1] = temp;
flag = false;
}
System.out.println(Arrays.toString(values));
}
if(flag){
break;
}
}
}
2. 数组查找-二分法查找:
二分法检索(Binary search)又称作折半查找法
折半查找基本思想:
设数组的元素从小到大有序的存放在数组中
首先,将给定值key与数组中间位置(mid)上元素的关键码key比较,如果相等,则检索成功。
若key小,则在mid的前半部分数组中继续使用二分法检索;
若key大,则在mid的后半部分数组中继续使用二分法检索。
这样经过一次比较就缩小一半的检索区间,如此进行下去,直到检索成功或检索失败。
二分法是一种效率较高的检索方法。比如,我们要在数组[7,8,9,10,12,20,30,40,50,80,100]
中查找到10
元素,过程如下:
示例:折半查找法的基础算法:
public static void main(String[] args){
//有序数组
int[] nums = {7,8,9,10,12,20,30,40,50,80,100};
//进行折半查找
System.out.println(binarySearch(nums, 40));
}
private static int binarySearch(int[] values,int key){
//设置数组的最低点和最高点
int low = 0;
int high = values.length-1;
//循环条件:当最低点始终要比最高点低,如果高了就会重复
while(low <= high){
//找到数组的中间位置为mid
int mid = (low + high) / 2;
//若key大于mid的值,则继续在后面部分使用折半查找
if(key <value[mid]){
high = mid -1;
}else if(key > values[mid]){
low = mid + 1;
}else{
return mid;
}
}
//查询失败,返回索引为-1
return -1;
}
标签:Java,String,int,元素,数组,字符串,public
From: https://www.cnblogs.com/guosiliang/p/18037351