Java学习笔记之常用API学习笔记1

Java学习笔记之常用API学习笔记1 

       API就是Application Programming Interface(应用程序编程接口)的简写。JavaAPI是Java提供给我们使用的类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。

       常用的API有如下几种

一、Object类

       1、简介：java中Object类是所有Java类的祖先。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。在不明确给出超类的情况下，Java会自动把Object作为要定义类的超类，可以使用类型为Object的变量指向任意类型的对象。

       2、常用构造方法：只有一个无参构造方法Object();

       3、常用方法：

       publicint hashCode() //返回该对象的哈希码值(也可以理解为对象在内存中的逻辑地址值)，该“地址”是通过哈希算法计算出来的。不同对象的hashCode()一般来说不会相同。但是，同一个对象的hashCode()值肯定相同。

注意：此地址并不是实际物理地址，可以理解为逻辑地址值。在java中不能获取一个对象在内存中的实际物理地址。

public StringtoString()//返回该对象的字符串表示，建议所有子类都重写该方法。

public booleanequals(Object obj)//比较其他对象是否与此对象“相等”。该方法的底层还是用“==”比较两个对象的哈希码值(地址值)是否相同，由于比较对象的引用没有意义，一般建议重写该方法。可以手动重写，也可自动生成。重写后的方法主要用来比较两个对象的内容是否相等。

注意：==和equals()的区别。

publicfinal Class getClass()//返回此 Object 的运行时类。

protectedvoid finalize()//当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。对象的垃圾回收器是Systeml类中的

static void gc()方法，该方法释放的是堆内存。

注意：垃圾回收器并不会立刻、马上回收垃圾。

protectedObject clone()//创建并返回此对象的一个副本，该副本和原本具有完全一样的属性，但他们是两个完独立的对象，其中一个对象的变化不影响另一个对象。

4、==与equals()方法的区别：

==比较基本数据类型时，比较的是两个变量保存的值是否相等，

==比较引用数据类型时，比较的是两个引用变量的哈希码值(地址)是否相等。

       equals方法只能比较引用数据类型，比较两个独立对象的内容是否相同

二、Scanner类

1、简介

JDK5以后出现的新特新，用于获取用户的键盘输入，通过该类可以获取到任意类型的数据。该类是最终类不能被继承。一个可以使用正则表达式来解析基本类型和字

符串的简单文本扫描器，使用此类可以方便的完成输入流的输入操作。

2、常用构造方法：

public Scanner(InputStream source)//构造一个新的Scanner，它生成的值是从指定的输入流扫描的。默认参数是System.in系统输入。

3、常用方法：

public String next()//可以获取各种类型的键盘输入数据，是一个全能型的方法。

public type nextType() //获取指定Type类型的键盘录入的数据,Type代表各种基本数据类型。

public boolean hasNextType()//判断键盘输入的数据是否为Type类型的数据，Type代表各种基本数据类型

MatchResult match()//返回此扫描器所执行的最后扫描操作的匹配结果

String toString()//返回此Scanner 的字符串表示形式，重写Object类中的toString()方法。

注意Scanner类未重写超类Object类的equals()方法。

       测试实例：

         public class ScannerDemo {

        public static void main(String[] args) {

           //创建对象

           Scanner sc =new Scanner(System.in);

           System.out.println("请输入数据：");

           //判断输入的数据是否为int类型

           if (sc.hasNextInt()) {

               intnum = sc.nextInt();//保存int类型的数据

               System.out.println(num);//打印该数据

           }  

        }

}

三、String类

1、简介

String 类代表字符串常量。Java 程序中的所有字符串字面值（如"abc" ）都作为此类的实例实现。String 类对象的内容一旦被初始化就不能再改变。String是一个类不

是数据类型，因为他被final修饰所以不能被继承。String类即可直接定义变量，也可new出对象。

2、常用构造方法：

              public String()  //空参数构造方法

              publicString(byte[] bytes) //把字节数组转换成字符串

              publicString(byte[] bytes, int startIndex, int length)//把字节数组一部分转换成字符串

              public String(char[] value) //把字符数组 转换成字符串

              public String(char[] value, int startIndex, int count)//把字符数组一部分转换成字符串

              public String(String original) //把字符串转换成字符串对象

测试实例：

public class StringDemo {

        public static void main(String[] args) {

           //空参数构造方法,创建一个字符串对象

           String s1 = new String();

           s1 = "hello";            //给对象引用赋值

           System.out.println(s1);  //hello

           //把字节数组转换成字符串

           byte[]bys ={97,98,99,100,101};

           String s2 = new String(bys);   

       System.out.println(s2);  //abcde

           //把字节数组一部分转换成字符串

        String s3 = new String(bys, 2, 2);//cd

           System.out.println(s3);

           //把字符数组转换成字符串

           char[]chs = {'a','b','c','d','e'};

           String s4 = new String(chs);

           System.out.println(s4);  //abcde

           //把字符数组一部分转换成字符串

           String s5 = new String(chs, 0, 3);//包左不包右：

           System.out.println(s5);  //abc

           //把字符串转换成字符串对象

           String s6 = new String("haha");

           System.out.println(s6);  //haha

           //创建字符串最简单的方式

           String s7 = "hehe";

           System.out.println(s7);  //hehe

        }

}

输出结果：

hello

abcde

cd

abcde

abc

haha

hehe

3、常用方法：

       3.1判断功能：

booleanequals(Object obj)       //判断两个字符串内容是否相等，重写了equals方法

booleanequalsIgnoreCase(String str)//判断两个字符串内容是否相等,忽略大小写

booleancontains(String str)      //判断当前字符串是否包含给定的字符串

booleanstartsWith(String str)   //判断当前字符串是否以给定的字符串开头

booleanendsWith(String str)    //判断当前字符串是否以给定的字符串结束

booleanisEmpty()         //判断当前字符串是否为空字符串，一对双引号“”就是空字符串，双引号内什么都没有，连空格都没有。null不是空字符串

测试实例：

class  StringMethodDemo  {

       public static void method() {

              String s1 = "hello";                   //小写

              String s2 = "HELLO";                //大写

              String str ="ArrayDemo.java";   //定义一个字符串引用变量，并赋初值

              sop(s1.equals(s2));                  //用equals比较两个字符串内容是否相同

sop(s1.equalsIgnoreCase(s2)); //用equalsIgnoreCase比较2个字符串内容是否相同，忽略大小写

sop(str.isEmpty());         //判断字符串str是否为空

              sop(str.startsWith("Array"));      //判断字符串str是否是Array单词开头。

              sop(str.endsWith(".java"));        //判断字符串srt是否是.java结尾。

              sop(str.contains("Demo"));        //判断字符串srt是否包含Demo单词

       }

       public static void main(String[] args) {

              method();

       }

       public static void sop(Object obj) {

              System.out.print(obj+"  ");       //用Object接收所有的对象（万能引用）

       }

}

输出结果是：

false     true false  true  true true

3.2获取功能：

int length()//获取当前字符串的长度

char charAt(int index)//根据位置获取字符串中对应的字符

int indexOf(int ch//获取当前字符串中，给定的字符第一次出现的位置，没有找到返回-1

int indexOf(String str)//获取当前字符串中，给定的字符串第一次出现的位置，没有找到返回-1

int indexOf(int ch,int fromIndex)//从指定的位置开始，获取当前字符串中，给定的字符第一次出现的位置，没有找到返回-1

int indexOf(String str,int fromIndex)//从指定的位置开始,获取当前字符串中，给定的字符串第一次出现的位置，没有找到返回-1

String substring(int start)//从指定的位置开始，截取当前字符串到末尾，返回一个新的字符串

String substring(int start,int end)//从指定位置开始，到指定位置结束，截取当前字符串，返回一个新的字符串

注意：位置值从0下标开始，从左向右数：0 1 2 3 。。。

测试实例：

class StringMethodDemo  {

       public static void method_get() {

              String str ="abcdeakpf";

              sop(str.charAt(4));         //根据索引获取字符

sop(str.indexOf(98));    //查找ascii码值为98的字符的下标，小写字母b

              sop(str.indexOf('m',3));     //从下标3处开始查找字符m

              sop(str.indexOf("abc"));     //查找字符串"abc"第一次出现的位置

              sop(str.indexOf("abc",2));  //从下标2开始查找字符串"abc"出现的位置

              sop(str.lastIndexOf("a"));   //反向索引一个字符a出现位置

sop(s.substring(1));          //从指定位置开始到结尾。

sop(s.substring(1,5));       //包左不包右，下标从1开始到4结束。

       }

       public static void main(String[] args)  {

              method_get();

       }

       //父类引用指向子类对象，类型提升。

       public static void sop(Object obj)  {

              System.out.print(obj+“  ”);  //用Object接收所有的对象（万能引用）

       }

}

输出结果是：

e -1 -1 0 -1 5 bcdeakpf bcde

3.3转换功能：

              byte[] getBytes()                      //把当前字符串转换成字节数组 

              char[] toCharArray()                 //把当前字符串转换成字符数组

              static String valueOf(char[] chs) //等同于String(char[]value)，把给定的字符数组转换成字符串

              static String valueOf(int i)          //静态方法，把基本数据类型转换成字符串

              String toLowerCase()                //把当前字符串全部转换为小写字母

              String toUpperCase()                //把当前字符串全部转换为大写字母

              String concat(String str)            //把当前字符串与给定的字符串进行拼接

测试代码：

public class StringMethodDemo {

    public static void main(String[] args) {

       String s = "AbCdE";

       //把当前字符串转换成字节数组 

       byte[]bys = s.getBytes();

       for (inti = 0; i < bys.length; i++) {//用for循环打印字节数组

           System.out.print(bys[i] +"  ");//65  98  67 100  69

       }

       System.out.println();       //换行

       //把当前字符串转换成字符数组

       char[]chs = s.toCharArray();

       for (inti = 0; i < chs.length; i++) {

           System.out.print(chs[i] +"  ");//A  b  C d  E 

       }

       System.out.println();

       //把给定的字符数组转换成字符串

       String result = String.valueOf(chs);

       System.out.println(result); //AbCdE

       System.out.println("---------------------");

       //把基本数据类型转换成字符串

       String result2 = String.valueOf(12345);

       System.out.println(result2);    //12345

       System.out.println("---------------------");

       //把当前字符串全部转换为小写字母

       String lower = s.toLowerCase();

       System.out.println("s:"+s); //s:AbCdE

       System.out.println("小写：" +lower);  //小写：abcde

       System.out.println("---------------------");

       //把当前字符串全部转换为大写字母

       String upper = s.toUpperCase();

       System.out.println("s:"+s); //转换前

       System.out.println("大写：" +upper);  //大写：ABCDE

       System.out.println("---------------------");

       //把当前字符串与给定的字符串进行拼接

       String s1 = "hello";

       String s2 = "world";

       String s3 = s1.concat(s2);

       System.out.println(s3);  //helloworld

       System.out.println(s1 + s2 );  //helloworld

    }

}

3.4替换功能

String replace(char old,char new)//把当前字符串中，给定的旧字符，用新字符替换

String replace(String old,String new)//把当前字符串中，给定的旧字符串，用新字符串替换

3.5去除字符串两端空格

Stringtrim();//把字符串两端的空格去掉，中间的空格无法去掉。

测试实例：

classStringMethodDemo {

              public static void method() {

                     Stringss = "      HELLO JAVA      ";

                     String s = "hello java";

                     Strings0 = ss.trim();                        //去掉字符串两端的空格

                     String s1 = s.replace('q','n');            //把原字符串中的字符q替换成字符n

                     //如果要替换的字符不存在，返回的还是原串。

                     Strings2 = s.replace('h','H');            //把原字符串中的字符h替换成字符H

                     String s3 =s.replace("java","world");//把原字符串中的java替换成world

                     sop("s="+s);         //输出源字符串

                     sop("s0="+s0);     //输出去掉空格后的结果

                     sop("s1="+s1);     //输出替换后的结果

                     sop("s2="+s2);     //输出替换后的结果

                     sop("s3="+s3);     //输出替换后的结果

              }

              public static void main(String args[]) {

                     method();

              }

              public static void sop(Object obj) {

                     System.out.println(obj);      //用Object接收所有的对象（万能引用）

              }

}

输出结果：
s=hello java
s0= HELLO JAVA
s1=hello java
s2=Hello java
s3=hello world

3.6按自然顺序比较两个字符串 

int compareTo(String str)//比较字符串的大小

int compareToIgnoreCase(String str)      //比较字符串的大小,忽略大小写

测试代码：

public class StringMethodDemo{

    public static voidmain(String[] args) {

       //从两个字符串第一个字符的差值比较大小，

           String s1 = "abc123456789";

       String s2 = "abc";

       System.out.println(s1.compareTo(s2)  );//

       System.out.println("--------------------------");

       //比较字符串的大小,忽略大小写

       s1 = "Abc";//65

       s2 = "abc";//97

       System.out.println(s1.compareToIgnoreCase(s2)  );//0

    }

}

3.7字符串切割

String[]split(regex);    //用给定的规则来切割字符串

四、分析题：

1、 Strings = new String(“hello”)和String s1 = “hello”的区别?s == s1吗？

答：String s = new String(“hello”) 创建了两个对象，一个是new String()对象在堆区分配，另一个是"hello"对象，也叫字符串常量，在数据区的字符串常量池中分配。

String s1 = "hello"; 创建了一个对象，"hello"对象，在数据区的字符串常量池中分配。s和s1不相等，因为他们是两个不同的对象。

注意：在创建字符串常量时，先到常量池中查看该字符串是否已经存在，如果存在则不在重新创建，如果不存在则需要重新创建该字符串。

如图1所示。

图1

2、String s = “hello”; s += “world”; 问s的结果是多少?

答：s的结果是：helloworld

因为s是一个String类的引用变量在栈中分配，字符串“hello”是一个字符串常量，在字符串常量池中分配，s = “hello”表示把“hello”在常量池中的地址值赋给引用变量

s，也就是变量s保存的是字符串“hello”的地址，当执行s += “world”的右边时，在常量池中为“world”分配存储空间，当整个语句s += “world”执行完毕时，在常量池中

为“helloworld”分配存储空间(两个字符串相加结果还是一个字符串)，此时把新的字符串的地址值赋值给变量s，s指向字符串helloworld。如图2所示。

注意：变量S的值是可以改变的，而字符串中的内容是不能改变的。

图2

3、下列代码的执行结果，执行过程？

      Strings1 = new String("hello");

       String s2 = newString("hello");

       System.out.println(s1==s2);     //比较两个对象的地址值

       System.out.println(s1.equals(s2));//比较两个对象的内容

       String s3 = newString("hello");

       String s4 = "hello";

       System.out.println(s3==s4); //比较两个对象的地址值

       System.out.println(s3.equals(s4));//比较两个对象的内容          

       String s5 = "hello";

       String s6 = "hello";

       System.out.println(s5==s6); //比较两个对象的地址值

       System.out.println(s5.equals(s6));//比较两个对象的内容

结果是：false true false true true true

       执行过程见图3所示

图3

4、下列代码的执行结果，原因？

String s1 = "hello";

       String s2 = "world";

       String s3 = "helloworld";

       System.out.println(s3 == s1+s2);

       System.out.println(s3 =="hello" + "world");

       System.out.println(s3.equals(s1+s2)); 

结果是：false true true

用反编译软件打开编译好的.class文件发现，在执行s1+s2时底层是用创建对象的方式执行的，执行s3 == “hello” + “world”时直接把相加后的结果赋值给s3的。

五、编程练习：

1、equals()方法的练习，模拟登录,给三次机会,并提示还有几次机会。

分析： 1．已有一个账号

2．登陆，输入用户名、密码

3．判断输入的用户名、密码是否和已有的账号匹配。相同：提示“登陆成功”， 不同：提示“用户名或密码错误，请重新输入”

public class StringMethodTest {

    public static void main(String[] args) {

       // 1：已有一个账号

       String username = "123456";

       String password = "itcast";

       for (inti = 2; i >= 0;i--) {  //for循环用于输错时提示剩余次数

           // 2：登录(键盘输入用户名、密码)

           Scanner sc =new Scanner(System.in);

           System.out.println("请输入用户名:");

           String enterName = sc.nextLine();

           System.out.println("请输入密码:");

           String enterPassword =sc.nextLine();

           //3：调用登录功能

           //判断键盘输入用户名、密码是否已有QQ匹配

       if (username.equals(enterName) &&password.equals(enterPassword)) {

              //登录成功

              System.out.println("欢迎你，来到Java的天堂");

              break;//跳出循环

           } else {

              if (i == 0) {

                  System.out.println("账号已锁定，请找管理员联系");

              } else {

                  //对不起，用户名或密码错误，请重新输入

                  System.out.println("对不起，用户名或密码错误，请重新输入,

                     还有"+i +"次机会");

              }

           }

       }

    }

}

2、用charAt()方法遍历获取字符串中的每一个字符

分析： 

1:定义一个字符串

2: for循环遍历

3: 获取指定位置的元素：charcharAt(int index)

4: 打印

public class StringMethodTest{

   public static void main(String[] args) {

       //1: 定义一个字符串

       String str = "HelloWorld";

       String result = printString(str);

       System.out.println(result); //4:打印

    }

    //遍历字符串方法    [H,e,l,...]

    public static String printString(String str){

       String result = "["; //数组的起始符号

       //2: for循环遍历字符串

       for (inti = 0; i < str.length(); i++) {

           //3: 每次获取指定位置的字符

           charch = str.charAt(i);

           if (i ==str.length() -1) {//最后一个元素

              result = result + ch + "]";//数组的结束符号

           } else {

              result = result + ch + ", ";//字符串的每个元素

           }

       }

       returnresult;

    }

}

3、统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)

例如：Hello12345World

结果：

大写字符：2

小写字符：8

数字字符：5

分析：

1： 键盘输入字符串

2: 定义变量，大写个数，小写个数，数字个数

3: 遍历字符串

a:获取每一个字符  ch

b:判断当前字符的类型

大写    ch>='A' &&ch<= 'Z'

大写个数++

小写   ch>='a' &&ch<='z'

小写个数++

数字  ch>='0' &&ch<='9'

数字个数++

4: 打印

public class StringMethodTest2 {

    public static void main(String[] args) {

       //1：键盘输入字符串

       Scanner sc = new Scanner(System.in);

       System.out.println("请输入字符串：");

       String str = sc.nextLine();

       //2: 定义变量，大写个数，小写个数，数字个数

       int BigCount = 0;

       int SmallCount = 0;

       int NumberCount = 0;

       //3: 遍历字符串

       for (inti = 0; i < str.length(); i++) {

           //a:获取每一个字符 ch

           charch = str.charAt(i);

           //b:判断当前字符的类型

           if (ch>='A' && ch <= 'Z') {

              //大写个数++

              BigCount++;

           } else if (ch>='a' &&ch <='z') {

              //小写个数++

              SmallCount++;

           } else if ( ch>='0' &&ch <='9') {

              //数字个数++

              NumberCount++;

           }

       }

       //4: 打印

       System.out.println("大写字符： " +BigCount );

       System.out.println("小写字符： " +SmallCount );

       System.out.println("数字字符： " +NumberCount );

    }

}

5、把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)

aaaaAbCdEfG

方式1： 选转换为全部小写， 然后首字母大写

方式2：

a: 获取首字母，然后大写

b: 获取其他字母，然后小写

c: 拼接

分析：

1: 定义一个字符串

2: 获取首字母，然后大写

subString(0,1)获取到第一个字母，返回的结果是String，可以调用转换大写的方法

3: 获取其他字母，然后小写

subString(1)获取其他字母，返回的结果是String，可以调用转换小写的方法

4: 拼接

public class StringMethodTest {

    public static void main(String[] args) {

       //1: 定义一个字符串

       String str = "aaaaAbCdEfG";

       //2: 获取首字母，然后大写

       String start = str.substring(0, 1);

       String big = start.toUpperCase();

       //3: 获取其他字母，然后小写

       String end = str.substring(1);

       String small = end.toLowerCase();

       //4: 拼接

       String result = big + small;

       System.out.println(result);

    }

}

6、字符串反转：键盘录入”abc”，输出结果：”cba”

分析：

       1： 键盘录入

       2: 逆向遍历字符串

       3: 获取到每一个字符，打印即可

public class StringMethodTest {

    public static voidmain(String[] args) {

       //1： 键盘录入

       Scanner sc = newScanner(System.in);

       System.out.println("请输入数据：");

       String str = sc.nextLine();

       //2: 逆向遍历字符串

       for (int i =str.length()-1; i >= 0; i--) {

           //3: 获取到每一个字符，打印即可

           char ch = str.charAt(i);

           System.out.print(ch);

       }

    }

}

7、统计大串中小串出现的次数

举例：在字符串”woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun”中java出现了几次？

分析：

在字符串中找"java"，获取到位置int index =str.indexOf("java")  

找到了(位置不是-1)：

a:count++

               b: 截取字符串subString(位置)

                          位置 = index + "java".length()

              c:将返回的新字符串，覆盖原有字符串

              d:回到 步骤3 继续

              没找到(位置是 -1)：

              a:结束循环 

       打印次数

测试代码：

    public class StringTest2 {

    public static void main(String[] args) {

       //1: 定义字符串

       String str = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";

       String key = "java";//要查找的字符串

       //2：定义变量count，用来记录Java出现的次数

       int count = 0;

       //定义一个用来记录位置的变量index

       int index = -1;

       //找java出现的位置把位置赋值给index，判断这个index的值是否为-1,如果为-1,结束循环

       while ( (index =str.indexOf(key)) != -1  ) {

           // 找到了java

           count++;

           //位置 = index + "java".length(),将返回的新字符串，覆盖原有字符串

           str = str.substring(index + key.length());

       }

       //4：打印次数

       System.out.println("java出现的次数： " +count);     

    }

}

本文根据课堂内容整理的java常用API之String类的常用方法，如有错误请指正，谢谢。