Java从入门到精通(二)

第五章 字符串

5.1 String 类

5.1.1 声明字符串

声明一个字符串就是创建一个字符串对象

//语法String a;String a,b,c;//**注意:  String a;   相当于  String a = null**

给字符串赋值就是创建字符串的过程
给字符串的方法

1. 引用字符串常量 //掌握
2. 利用构造方法直接实例化 //掌握
3. 利用字符数组实例化 //了解
4. 利用字节数组实例化 //了解

//  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());    }}//此时输出结果都是15

5.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); // 输出信息    }    //输出  hel

5.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  11

5.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)将给定所引处的字符修改为chStringBuffer sbf = new StringBuffer("0123456");sbf.setCharAt(3,'A');//sbf= 012A456

3.插入字符串

public StringBuffer insert(int offset,String ctr)//将字符串插入到此字符序列中StringBuffer sbf = new StringBuffer("0123456");sbf = sbf.insert(5,"F");//sbf = 01234F56

4.字符串反序

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];

一维数组的初始化: 就是给数组赋初值
三种初始化方法:

//错误1int 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 填充替换数组元素

填充和批量替换数组元素

//语法:1Arrays.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;i<a.length;i++) {            System.out.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+" ");        }    }}