Java从入门到精通(二)
第五章 字符串
5.1 String 类
5.1.1 声明字符串
声明一个字符串就是创建一个字符串对象
//语法
String a;
String a,b,c;
//**注意: String a; 相当于 String a = null**给字符串赋值就是创建字符串的过程
给字符串的方法
- 引用字符串常量 //掌握
- 利用构造方法直接实例化 //掌握
- 利用字符数组实例化 //了解
- 利用字节数组实例化 //了解
// ctrl + shift +f 自动调整格式
1.引用字符串常量
String a = "时间就是金钱";
String b = "锄禾日当午","小鸡顿蘑菇";
String str1,str2;
str1 = "we re students";
str2 = "we re students"
// 2.利用构造方法直接实例化
String a = new String("我爱清汤小肥羊");
String b = new String(a);//3.利用字符数组实例化
char[] charArray = {'t','i','m','e'};
String a = new String(charArray);//利用字符数组实例化的第二种用法
语法: public String(char[] value, int offse, int count);
实例:
char charArray = {'时','间','就,'是','金','钱'};
String a = new String(charArray,4,2);//4.利用字节数组实例化
语法 public String(byte[] bytes)
byte[] byteArray = {-60,-6,-70,-61};
String a = new String(byteArray);5.2 连接字符串
5.2.1 连接多个字符串
利用”+”运算符可以实现连接多个字符串的功能.”+”运算符可以连接多个运算符并产生一个String对象.
public static void main(String args[]) { // 主方法
String s1 = new String("hello"); // 声明String对象s1
String s2 = new String("word"); // 声明String对象s2
String s = s1 + " " + s2; // 将对象s1和s2连接后的结果赋值给s
System.out.println(s); // 将s输出
}Java中相连的字符串不能 分开在两行中写
可以用”+”将两个字符串串联起来
System.out.println(“I like ”
“Java”);
5.2.2 连接其他数据类型
public class Link { // 创建类
public static void main(String args[]) { // 主方法
int booktime = 4; // 声明的int型变量booktime
float practice = 2.5f; // 声明的float型变量practice
// 将字符串与整型、浮点型变量相连，并将结果输出
System.out.println("我每天花费" + booktime + "小时看书；"
+ practice + "小时上机练习");
}
}本例中是将字符串常量和整型.浮点型常量相连后结果输出,这里booktime,practice都不是字符串,当他们与字符串相连后会调用toString()方法,将其转换成字符串形式,然后输出.
5.3 获取字符串信息
5.3.1 获取字符串长度
// 语法 str.length();
String str = "We are students";
int size = str.length();5.3.2 字符串查找
String 类提供两种字符串查找的方法,indexOf() 与 lastIndexOf().
这两种方法返回的是搜索的字符或字符串首次出现 和 最后一次出现的位置.
//1.indexOf(String s)
语法: str.indexOf(substr);
实例:
String str = "We are studets";
int size = str.indexOf("a"); //此时size变量的值是3//2.lastIndexOf(String s)
语法: str.lastIndexOf(substr)
//如果lastIndexOf()方法中参数就是空字符串""(注意没有空格),则返回的结果与调用该字符串的length()方法的返回结果相同.
public class Text { //创建类
public static void main(String args[]) { //主方法
String str = "We are students"; //定义字符串str
//将空格在str中的索引位置赋值给变量size
int size = str.lastIndexOf(" ");
//将变量size输出
System.out.println("空格在字符串str中的索引位置是：" + size);
//将字符串str的长度输出
System.out.println("字符串str的长度是：" + str.length());
}
}
//此时输出结果都是155.4获取子字符串
5.4.1 获取子字符串
substring()方法提供了两种不同的方法重载,来满足不同的需要
(1.) substring(int beginIndex)
String str = "Hello World";
String substr = str.substring(4);//此时返回 o World(2.) substring(int beginIndex, int endIndex)
public static void main(String args[]) { // 主方法
String str = "hello word"; // 定义字符串str
char mychar = str.charAt(6); // 将字符串str中索引位置是6的字符返回
System.out.println("字符串str中索引位置是6的字符为：" + mychar); // 输出信息
}
//输出 hel5.4.2去除空格
str.trim()
ublic static void main(String args[]) { // 主方法
String str = " Java class "; // 定义字符串str
System.out.println("字符串原来的长度：" + str.length()); // 将str原来的长度输出
System.out.println("去掉空格后的长度：" + str.trim().length());
// 将str去掉前导和尾部的空格后的结果输出
}
//16 115.4.3 字符串替换
语法 : str.replace(char oldChar,char newChar)
public static void main(String args[]) { // 主方法
String str = "address"; // 定义字符串str
// 字符串str中的字符"a"替换成"A"后返回的新字符串newstr
String newstr = str.replace("a", "A");
System.out.println(newstr); // 将字符串newstr输出
}如果要替换的字符oldChar 在字符中出现多次,replace()方法会将所有oldChar全部替换成newChar.
5.4.4 判断字符串的开始结尾
starts With()与endWith()方法分别用于判断字符串是否以指定的内容开始或结束.这两个方法返回都是boolean的值.
public static void main(String args[]) { // 主方法
String num1 = "22045612"; // 定义字符串num1
String num2 = "21304578"; // 定义字符串num2
boolean b = num1.startsWith("22"); // 判断字符串num1是否以'22'开头
boolean b2 = num1.endsWith("78"); // 判断字符串num1是否以'78'结束
boolean b3 = num2.startsWith("22"); // 判断字符串num2是否以'22'开头
boolean b4 = num2.endsWith("78"); // 判断字符串num2是否以'78'结束
System.out.println("字符串num1是以'22'开始的吗？" + b);
System.out.println("字符串num1是以'78'结束的吗？" + b2); // 输出信息
System.out.println("字符串num2是以'22'开始的吗？" + b3);
System.out.println("字符串num2是以'78'结束的吗？" + b4);
}5.4.5判断字符串是否相等
对字符串对象进行比较不能简单的使用比较运算符”==”,因为比较运算符比较的是两个字符串的地址是否相同.及时两个字符串的内容相同,两个对象的内存地址也是不同的,使用比较运算符仍然会返回false.
(1)equals()方法
两个字符串具有相同的字符和长度
语法: str.equals(String otherstr)
(2).equalsIgnoreCase()方法
使用equals()方法区分大小写,而equalsIgnoreCase()方法是在忽略了大小写的情况下比较两个字符串字符串是否相等,返回值仍未boolean类型.
public static void main(String args[]) { // 主方法
String s1 = new String("abc"); // 创建字符串对象s1
String s2 = new String("ABC"); // 创建字符串对象s2
String s3 = new String("abc"); // 创建字符串对象s3
boolean b = s1.equals(s2); // 使用equals()方法比较s1与s2
// 使用equalsIgnoreCase()方法比较s1与s2
boolean b2 = s1.equalsIgnoreCase(s2);
System.out.println(s1 + " equals " + s2 + " :" + b); // 输出信息
System.out.println(s1 + " equalsIgnoreCase " + s2 + " :" + b2);
}5.4.6 按字典顺序比较两个字符串
语法: str.compareTo(String otherstr)
compareTo()方法只有在equals(Object )方法返回true时才返回0.
public static void main(String args[]) { // 主方法
String str = new String("b");
String str2 = new String("a"); // 用于比较的3个字符串
String str3 = new String("c");
System.out.println(str + " compareTo " + str2 + ":"
+ str.compareTo(str2)); // 将str与str2比较的结果输出
System.out.println(str + " compareTo " + str3 + ":"
+ str.compareTo(str3)); // 将str与str3比较的结果输出
}5.4.7 字母大小写转换
(1).toLowerCase()方法
大写转小写
(2.) toUperCase()
小写转大写
public static void main(String args[]) { // 主方法
String str = new String("abc DEF"); // 创建的字符串str
String newstr = str.toLowerCase(); //使用toLowerCase()方法实行小写转换
String newstr2 = str.toUpperCase();//使用toUpperCase()方法实行大写转换
System.out.println(newstr);// 将转换后的结果输出
System.out.println(newstr2);
}使用这两种方法进行大小写转换时,数字或非字符不受影响
5.4.8 字符串分割
(1.)split(String sign)
语法 : str.split(String sign)
该方法根据给定的分隔符对字符串进行拆分,也可以使用正则表达式
(2.)split (String sign,int limit)
该方法根据给定的分隔符对字符串进行拆分,并限定拆分的次数
语法: str.split(String sign,int limit)没有统一的对字符进行分割的符号.如果想定义多个分隔符,可以使用符号”|”.例如,”,|=”表示分割符为”,”和”=”
例子
public static void main(String[] args) {
// 创建字符串
String str = "192.168.0.1";
// 按照"."进行分割
String[] firstArray = str.split("\\.");
// 按照"."进行两次分割
String[] secondArray = str.split("\\.", 2);
// 输出str原值
System.out.println("str的原值为：[" + str + "]");
// 输出全部分割的结果
System.out.print("全部分割的结果：");
for (String a : firstArray) {
System.out.print("[" + a + "]");
}
System.out.println();// 换行
// 输出分割两次的结果
System.out.print("分割两次的结果：");
for (String a : secondArray) {
System.out.print("[" + a + "]");
}
System.out.println();
}5.5.1 日期和时间字符串格式化
在用程序当中,我们经常要显式一些时间啊数字之类的,而这些数字和时间往往都是不同的格式
package Demo;
import java.util.Date;
public class Demo {
public static void main(String[] args) {
Date date = new Date();
String str = String.format("%tF", date);
System.out.println(str);
String year = String.format("%tY", date);
String mouth = String.format("%tB", date);
String day = String.format("%td", date);
System.out.println("今年是"+year+"年");
System.out.println("现在是"+mouth);
System.out.println("今天是"+day+"日");
System.out.println("------------------");
String hour = String.format("%tH", date);
String minute = String.format("%tM", date);
String second = String.format("%tS", date);
System.out.println("今年是"+hour+"时"+minute+"分"+second+"秒");
}
}5.5.2 常规类型格式化
//语法:
str.format(String format,Object...args)package Demo;
public class Demo2 {
public static void main(String[] args) {
//System.out.println(String.format("字母x大写:%c", 'X'));
//下面这种跟上面一样
String str = String.format("字母x大写:%c", 'X');
System.out.println(str);
System.out.println(String.format("1234+4689的结果是%d", 1234+4689));
System.out.println(String.format("π取两位小数点:%.2f", Math.PI));
System.out.println(String.format("2<3的结果:%b",2<3));
System.out.println(String.format("1200000.1用科学计数法表示:%e",1200000.1));
}
}
结果:
e 是 十的六次方
常规转换符
5.6使用正则表达式
正则表达式通常用于判断语句中,用来检查某一字符串是否满足某一格式. 正则表达式是含有一些具有特殊意义字符的字符串,这些特殊字符成为正则表达式的元字符
正则表达式是 一组公式,描述了一种字符串匹配的格式.
在正则表达式中”.”代表任意一个字符,因此在正则表达式中如果想使用普通意义的点字符”.”,必须使用转义字符”\”.
在正则表达式中可以使用方括号括起若干个字符来表示一个元字符,该元字符可代表方括号中的任何一个字符.reg = “[abc]4”,这样字符串a4,b4,c4都是和正则表达式匹配的字符串.方括号元字符还可以为其他格式,如下:
5.7 字符串生成器
StringBuffer类: 是线程安全的可变序列.一个类似于String的字符串缓冲区.前面内容介绍过String创建的字符串对象是不可修改的,这一节介绍的StringBuffer类创造的是可修改的字符串序列,且实体容量会随着存放的字符串增加而自动增加.
1.创建StringBuffer类
创建一个新的StringBuffer对象必须使用new方法,而不能像String对象那样直接饮用字符串常量.
StringBuffer sbf = new StringBuffer(); //创建一个对象,无初始值
StringBuffer sbf = new StringBuffer("abc"); //创建一个对象,初始值为"abc"
StringBuffer sbf = new StringBuffer(32);
常用方法:
1.追加字符串:(也就是String中拼接的效果)
piblic StringBuffer append(Object obj)
将参数转换成字符串,将所得字符串中字符追加到此序列中.
StringBuffer sbf = new StringBuffer("门前大桥下");
sbf.append("游过一群鸭");
StringBuffer tem = new StringBuffer("快来快来数一数");
sbf.append(tem);
int x = 24678;
sbf.append(x);2.修改指定索引处的字符
public void setCharAt(int index,char ch)
将给定所引处的字符修改为ch
StringBuffer sbf = new StringBuffer("0123456");
sbf.setCharAt(3,'A');
//sbf= 012A4563.插入字符串
public StringBuffer insert(int offset,String ctr)
//将字符串插入到此字符序列中
StringBuffer sbf = new StringBuffer("0123456");
sbf = sbf.insert(5,"F");
//sbf = 01234F564.字符串反序
public StringBuffer reverse()
该方法可以将字符串反序输出
StringBuffer sbf = new StringBuffer("同一个世界,同一个梦想");
sbf = sbf.reverse();
//sbf = 想梦.....同5删除子字符串
与String类似的方法
StringBuffer\StringBuilder\String的不同
1.
2.而StringBuffer.StringBuilder不同
如何选择使用哪种对象
第六章 数组
数组是具有相同数据类型的一组数据的集合.
1.创建一维数组
语法:
数组元素类型 数组名字[];
数组元素类型[] 数组名字;
int arr[];
int[] arr2;
//要想使用数组还要给它分配内存空间,因为在数组分配内存空间时必须指明数组的长度
int arr3[] = new int[5];
一维数组的初始化: 就是给数组赋初值
三种初始化方法:
//错误1
int arr[] = new int[3]{4,5,6};//语法错误
int arr[] = new int[]{4,5,6};
int arr[] = new int[3];
####使用一维数组
public static void main(String[] args) { // 主方法
// 创建并初始化一维数组
int day[]=new int[]{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
for (int i = 0; i < 12; i++) { // 利用循环将信息输出
System.out.println((i + 1) + "月有" + day[i] + "天"); // 输出的信息
}
}6.3 二维数组额创建及使用
一维数组的各个元素仍是一个数组,那么它就是一个二维数组
创建二维数组的语法:
数组元素类型 数组名字[][];
数组元素类型[][] 数组名字;
二维数组初始化
public static void main(String[] args) {
char array[][] = new char[4][];
array[0] =new char[] {'春','眠','不','觉','晓'};
array[1] =new char[] {'处','处','闻','啼','鸟'};
array[2] =new char[] {'夜','来','风','雨','声'};
array[3] =new char[] {'花','落','知','多','少'};
System.out.println("----------横版-----------");
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j]);
}
if (i%2 == 0) {
System.out.println(",");
}else {
System.out.println(".");
}
}
System.out.println("---------------竖版------------------");
for (int j = 0; j < array[0].length; j++) {
for (int i = 3; i >= 0; i--) {
System.out.print(array[i][j]);
}
System.out.println();
}
System.out.println(". , . ,");
}6.4数组的基本操作
6.4.1遍历数组:就是获取数组中的每个元素.
1.双for循环
2.双foreach循环
char array[][] = new char[4][];
array[0] =new char[] {'春','眠','不','觉','晓'};
array[1] =new char[] {'处','处','闻','啼','鸟'};
array[2] =new char[] {'夜','来','风','雨','声'};
array[3] =new char[] {'花','落','知','多','少'};
//遍历数组的双foreach循环
for(char a[]:array) {
for(char b:a) {
System.out.print(b);
}
System.out.println();
}6.4.2 填充替换数组元素
填充和批量替换数组元素
//语法:1
Arrays.fill(arr,int value);//arr 填充的数组, value 填充的值
//第二种
Arrays.fill(arr ,int fromIndex, int toIndex, int value);
// 填充的第一个索引(包括) 填充的最后一个索引(不包括)//第一种
public static void main(String[] args) { // 主方法
int arr[] = new int[5]; // 创建int型数组
Arrays.fill(arr, 8); // 使用同一个值对数组进行填充
for (int i = 0; i < arr.length; i++) { // 循环遍历数组中的元素
// 将数组中的元素依次输出
System.out.println("第" + i + "个元素是：" + arr[i]);
}
}public static void main(String[] args) { // 主方法
int arr[] = new int[] { 45, 12, 2, 10 }; // 定义并初始化int型数组arr
Arrays.fill(arr, 1, 2, 8); // 使用fill方法对数组进行初始化
for (int i = 0; i < arr.length; i++) { // 循环遍历数组中元素
// 将数组中的每个元素输出
System.out.println("第" + i + "个元素是：" + arr[i]);
}
}作用:
iport java.util.Arrays;
int arr[] = {1,8,6,9,8,7,6,5,4,3,2};
Arrays.fill(arr,3,7,0);
for(int i = 0;i <arr.length;i++){
if(arr[i] == 0){
System.out.print("*");
}else{
System.out.print(arr[i]);
}
}6.4.3对数组进行排序
//语法:
Arrays.sort(arr);
//示例
int arr[] = new int[]{32,42,12,8};
Arrays.sort(arr);6.4.4复制数组
语法:
Array.copyOf(arr,newlength)
// 数组 指复制后的新数组的长度
import java.util.Arrays;
public static void main(String[] args) {
int arr[] = {1,2,3};
int b[] = Arrays.copyOf(arr, 3);
b[0] = 77;
System.out.println("arr数组");
for(int temp:arr) {
System.out.print(temp+" ");
}
System.out.println("\nb数组");
for (int temp:b) {
System.out.print(temp);
}
}
//语法二:Array.copyOfRange(arr , formIndex,toIndex);
//formIndex指定开始复制数组的索引位置(包括)
//toIndex要复制数组的最后索引位置不包括
6.4.5 数组查询
Array类的binarySearch()方法,可使用二分搜索法来搜索指定数组,以获得指定对象.该方法返回要搜索元素的的索引值.binarySearch()方法提供了多种重载形式,用于满足各种类型数组的查找需要.binarySearch()方法有两种参数类型.
(1.)binarySearch(Object[],Object key)
//语法:binarySearch(Object[] a,Object key)
//a搜索的数组 key:要搜索的值
package BookPractice;
import java.util.*;
public class Example { // 创建类
public static void main(String[] args) { // 主方法
int ia[] = new int[] { 1, 8, 9, 4, 5 }; // 定义int型数组ia
Arrays.sort(ia); // 将数组进行排序
int index = Arrays.binarySearch(ia, 4); // 查找数组ia中元素4的索引位置
System.out.println("4的索引位置是：" + index); // 将索引输出
}
}(2.) binarySearch(Object[],int formIndex,int toIndex,Object key)
//语法:binarySearch(Object[] a,int formIndex,int toIndex,Object key)
public class Rakel { // 创建类
public static void main(String[] args) { // 主方法
// 定义String型数组str
String str[] = new String[] { "ab", "cd", "ef", "yz" };
Arrays.sort(str); // 将数组进行排序
// 在指定的范围内搜索元素"cd"的索引位置
int index = Arrays.binarySearch(str, 0, 2, "cd");
System.out.println("cd的索引位置是：" + index); // 将索引输出
}
}6.5 数组排序算法
6.5.1 冒泡排序
重点
public class BubbleSort {
public static void main(String[] args) {
int a[] = {5,48,36,15,42};
for(int i=1;i< a.length;i++ ) {
for(int j = 0;j < a.length-i;j++ ) { //这里减去的i是轮数,随着轮数增加,比较次数减少
if (a[j] < a[j+1]) {
int tmp = a[j+1];
a[j+1] = a[j];
a[j] = tmp;
}
}
}
for(int i = 0;iout.println(a[i]);
}
}
} 6.5.2 直接选择排序
ublic static void main(String[] args) {
int a[] = {5,48,36,15,42};
int index; //作为一个指针,会一直指向数组中最大的那一个
for (int i = 1; i < a.length; i++) {//排序过程中一共排序多少趟
index = 0;
for (int j = 1; j <= a.length - i; j++) {//j要循环多少遍呢,保证j能取到最后一个下标
if (a[index] < a[j]) {
index = j;
}
}
int tmp = a[a.length-i];//和最后那个元素交换
a[a.length-i] = a[index];
a[index] = tmp; //不是下标,而是数
}
System.out.println("选择排序的结果为");
for(int tmp:a) {
System.out.print(tmp+" ");
}
}6.5.3反转排序
以相反的顺序把把原有数组的内容重新排序.
反转排序是对数组两边的数组进行替换,所以只需循环数组的长度的半数次,如长度为7,那么for循环只需要循环3次.
public class ReverseSort {
public static void main(String[] args) {
int a[] = {10,20,30,40,50,60};
int tmp;
for (int i = 0; i < a.length/2; i++) {
tmp = a[a.length-1-i];
a[a.length-1-i] = a[i];
a[i]= tmp;
}
System.out.println("反转后");
for(int temp:a) {
System.out.print(temp+" ");
}
}
}