黑马程序员 JAVA基础---API常用类

                              -----------android培训、java培训、java学习型技术博客、期待与您交流！------------

            在此，分享一下自己学习JAVA的学习心得。有不对的地方请帮忙改正，也希望对想学java的同学有帮助！

JAVA基础

        ——API—常用类

API(Application Programming Interface) 应用程序编程接口。

常用类

1）Object类/Scanner类：

Object类概述及其构造方法：

1）概述：类层次结构的根类。所有类都直接或者间接的继承自该类。
2）构造方法：
    public Object()
    子类的构造方法默认访问的是父类的无参构造方法

Object类的成员方法：

1）public int hashCode()方法：

  1.返回该对象的哈希码值。

  2.实际上，由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。

  3.这一般是通过将该对象的内部地址转换成一个整数来实现的。
 
  class Object{
      public int hashCode(){
      return (对象的地址);
   }
   }
  class Student extends Object{
  }

java练习代码：

public class Demo {
public static void main(String[] args) {
Student stu1 = new Student();//实例化对象
stu1.name = "张三";//设置姓名
stu1.age = 20;//设置年龄
System.out.println("stu1--hashCode():" + stu1.hashCode());
Student stu2 = new Student();
stu2.name = "张三";
stu2.age = 20;
System.out.println("stu2--hashCode():" + stu2.hashCode());
}
}

<strong>Student类：</strong>

public class Student {String name;int age;}

2）public final Class getClass()

     class 类1{//-->Class
   void show(){//getName()
         System.out.println("类1 --> show()");
   }
    }
    class 类2{//-->Object
   public 类1 get类1(){//--getClass();
    类1 a = new 类1();
    return a;
         }
    }
    class 类3 extends 类2{//-->Student
 
    }
    main(){
  类3  a3 = new 类3();
  类1 b1 = a3.get类1();
  b1.show();
  Student stu = new Student();

        //子类Student会继承getClass()方法，所以这里通过Student对象的引用获取
 Class c = stu.getClass();
 System.out.println("Class.getName():" + c.getName());
     }
3）public String toString()

   1.返回该对象的字符串表示。toString 方法会返回一个“以文本方式表示”此对象的字符串。
   2.建议所有子类都重写此方法。
   3.Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。
     它的值等于： getClass().getName() + '@' + Integer.toHexString(hashCode())
   4.默认情况下，Object的实现基本没有什么意义，我们用不上。
   5.Object类建议重写此方法：以文本的方式，表达此对象(成员属性的值)的信息；
   6.如果将一个对象的引用传入到System.out.println()方法中时，实际上是调用这个对象的toString();
   7.使用Eclipse添加toString()方法：在类编辑界面-->右键-->Source --> Generator toString();
    

    class Object{
    public String toString(){
    }
    }
    class Student extends Object{
    public String toString(){
    }
    }
    main(){
    Student stu = new Student();
    stu.toString();//子类覆盖父类的方法，运行的是子类的toString();
    }

java练习代码：

<span style="font-size:18px;">public class Demo {

public static void main(String[] args) {
Student stu1 = new Student("章子怡",18);//通过构造函数赋值
System.out.println("stu1.toString():" + stu1.toString());
Student stu2 = new Student("刘德华",20);
System.out.println("stu2.toString():" + stu2.toString());
System.out.println(stu2);
System.out.println(stu2.toString());
}
}
</span>

<span style="font-size:18px;">Student类</span>

<span style="font-size:18px;">public class Student {private String name;private int age;//构造函数public Student(String name, int age) {super();this.name = name;this.age = age;}//get 和 set方法public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}   //重写Object类的toString()方法/*public String toString(){String str = "Student [name = " + name + ",age = " + this.age + "]";return str;}*/@Overridepublic String toString() {return "Student [name=" + name + ", age=" + age + "]";}}</span>

4）public boolean equals(Object obj)

  1.当前调用对象，和参数对象进行比较；
  2.Object的默认实现：对于任何非空引用值 x 和 y，当且仅当 x 和 y 引用同一个对象时，此方法才返回 true（x == y 具有值 true）。
  3.编程中，我们想一种情况：从控制台接收"学员信息"，程序中封装"Student对象"，有没有可能，两个对象，每个中存储的值都是一样的。这时，很有可能是用户输入错误，看串行了。
Student stu = new Student();
 stu.name = "张三";
 stu.age = 20;
 Student stu2 = new Student();
 stu2.name = "张三";
 stu2.age = 20;
        我们可以拦截这种情况：
    可以使用Object的equals（）方法，进行判断。需要我们子类重写、
   
    小结：我们一般用equals来比较两个对象内部存储的信息是否相同。如果想比较两个变量是否指向同一个对象，可以使用：==运算符；
5）protected void finalize()
6）protected Object clone()

   1.protected void finalize()：当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法；回收之前，会调用此方法；
   2.protected Object clone()：克隆。

 Scanner类概述及其构造方法：

     使用Scanner的三个步骤：
     1.导包：
     2.实例化Scanner对象
     3 .获取int值：nextInt();
     4.判断能否获取int值：hasNextInt();

java练习代码：

<span style="font-size:18px;">import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
Scanner sc  = new Scanner(System.in);//实例化对象
/*
System.out.print("请输入年龄：");
if(sc.hasNextInt()){
int age = sc.nextInt();
System.out.println("年龄值：" + age);
}else{
System.out.println("请输入整数年龄值！");
}
*/
System.out.print("请输入：");
/*
int a = sc.nextInt();//10\r\n
String str = sc.nextLine();
*/
//方案1：
int a = sc.nextInt();
//String str = sc.next();//使用next()就可以解决上面的问题；
//再一种解决方案：
sc = new Scanner(System.in);
String str = sc.nextLine();

System.out.println("a = " + a + ", str = " + str);
}
}</span>

2）String类/StringBuffer类/StringBuilder类：

 String类概述：
  字符串是由多个字符组成的一串数据(字符序列)。
  字符串可以看成是字符数组。

 构造方法
  public String()：初始化一个新创建的 String 对象，使其表示一个空字符序列。
  public String(byte[] bytes):通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
  public String(byte[] bytes,int offset,int length):

  通过使用平台的默认字符集解码指定的 byte 数组，,从offset开始，取length长度；
  public String(char[] value)：分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
  public String(char[] value,int offset,int count) ：

  分配一个新的 String，它包含取自字符数组参数一个子数组的字符。
  public String(String original):

  初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。

java练习代码：

  public class StringDemo02 {
public static void main(String[] args) {
String str = "hello";
str = "helloworld";//产生了两个对象
String str1 = "hello";
String str2 = "world";
String str3 = str1 + str2;//产生了3个对象；
//验证一下常量字符串的第二次存储
String str4 = "abcd";
String str5 = "abcd";
System.out.println("str4 == str5 : " + (str4 == str5));//true
String str6 = "hello" + "world";//3个对象空间
}
}

String的特点：字符串是常量；它们的值在创建之后不能更改。

Java代码：

练习：对String类的特点进行验证

public class StringDemo3 {
public static void main(String[] args) {
String str1 = "hello";
str1 += "world";
System.out.println("str1 = " + str1);//helloworld;
String str2 = "hello";
String str3 = "hello";
System.out.println("str2 == str3 : " + (str2 == str3));//true
System.out.println("str2.equals(str3) : " + str2.equals(str3));//true
String str4 = new String("hello");
String str5 = new String("hello");
System.out.println("str4 == str5 : " + (str4 == str5));//false
//String类重写了equals方法，否则equals方法默认是比较的两个对象的地址；
//重写后，比较的就是两个字符串对象中存储的字符序列是否完全相同；
System.out.println("str4.equals(str5) : " + str4.equals(str5));//true
String str6 = new String("hello");
String str7 = "hello";
System.out.println("str6 == str7 : " + (str6 == str7));//false
System.out.println("str6.equals(str7) : " + str6.equals(str7));//true
String str8 = "hello";
String str9 = "world";
String str10 = "helloworld";
String str11 = "hello" + "world";//String str11 = "helloworld";
String str12 = str8 + str9;
String str13 = str8 + "world";
String str14 = "hello" + str9;
System.out.println("str10 == str11 : " + (str10 == str11));//true
System.out.println("str11 == str12 : " + (str11 == str12));//false
System.out.println("str11 == str13 : " + (str11 == str13));//false
System.out.println("str11 == str14 : " + (str11 == str14));//false
}

}

String类的判断功能：

  boolean equals(Object obj):将此字符串与指定的对象比较。当且仅当该参数不为 null，并且是与此对象表示相 同字符序列的 String 对象时，结果才为 true。
   boolean equalsIgnoreCase(String str):将此 String 与另一个 String 比较，不考虑大小写。
   boolean contains(String str)：当且仅当此字符串包含指定的 char 值序列时，返回 true。区分大小写
   boolean startsWith(String str)：测试此字符串是否以指定的前缀开始。区分大小写；
   boolean endsWith(String str):测试此字符串是否以指定的后缀结束。 
   boolean isEmpty():当且仅当 length() 为 0 时返回 true。

   关于字符串的length()方法与数组的length属性：
   1.获取字符串的长度：System.out.println(str.length());//length()方法
   2.获取数组的长度：System.out.println(arr.length);//length属性-->不带一对小括号；

String类的获取功能：

int length():字符序列的长度；
char charAt(int index)：返回指定索引处的 char 值。索引范围为从 0 到 length() - 1。序列的第一个 char 值位于索引 0 处，第二个位于索引 1 处，依此类推，这类似于数组索引。 
int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。如果未出现该字符，则返回 -1。
int indexOf(String str):返回指定子字符串在此字符串中第一次出现处的索引。如果它不作为一个子字符串出现，则返回 -1。
int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从fromIndex索引开始搜索。
int indexOf(String str,int fromIndex):返回指定子字符串在此字符串中第一次出现处的索引，从fromIndex索引开始。
String substring(int start):返回一个新的字符串，它是此字符串的一个子字符串。该子字符串从start的字符开始，直到此字符串末尾。
String substring(int start,int end):返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 处开始，直到索引 endIndex - 1 处的字符。因此，该子字符串的长度为 endIndex-beginIndex。从start(包含)开始截到end(不包含);

java代码：

模拟登陆功能：

需求：1）模拟登陆。用户登录3次登录机会，如果超过三次，提示系统不允许登录；

      2）请用户输入登陆名和密码：验证：登陆名是否是5--13个字符，登录密码只能包含：小写字母和数字，而且密码只能是6位；

import java.util.Scanner;
public class Login {
public static void main(String[] args) {
String uName = "admin";
String uPassword = "123456";

int count = 3;//记录登陆次数
do {
Scanner sc = new Scanner(System.in);
System.out.print("请输入用户名：");
String loginName = sc.next();

//判断用户名的长度是否在5--13个字符之间
if ( loginName.length() < 5 || loginName.length() > 13 ){
System.out.println("用户名必须是5--13个字符之间，请确定！");
break;
}
System.out.print("请输入密码：");
String loginPassword = sc.next();
//判断密码位数是否为六位
int weishu = loginPassword.length();
if (weishu!=6){
System.out.println("密码必须是6位数");
}
//判断密码是否为小写字母和数字
char[] charArray = loginPassword.toCharArray();
//System.out.println(charArray.length);
for (int i = 0; i < charArray.length; i++) {
if ('a' < charArray[i] && charArray[i] > 'z' ||
'0' < charArray[i] && charArray[i] > '9'){
System.out.println("密码必须是小写字母和数字");
break;
}
}

//判断用户名，密码是否正确
if (!loginName.equals(uName) || !loginPassword.equals(uPassword)) {
count--;
if(count > 0)
System.out.println("输入的用户名或密码有误，请重新输入！您还有"+count+"次，机会！");
if(count ==0 ){
System.out.println("您已经没有机会了，密码提示："+"123......");
break;
}
} else {
System.out.println("恭喜，登陆成功！");
}
} while (true);
}
}

String类的转换功能：

byte[] getBytes()：使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。 
char[] toCharArray():将此字符串转换为一个新的字符数组。 
static String valueOf(char[] chs):返回 char 数组参数的字符串表示形式。字符数组的内容已被复制，后续修改不会影响新创建的字符串。
static String valueOf(int i):返回 int 参数的字符串表示形式。
String toLowerCase():使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
String toUpperCase():使用默认语言环境的规则将此 String 中的所有字符都转换为大写。

                     此方法等效于 toUpperCase(Locale.getDefault())。 
String concat(String str):将指定字符串连接到此字符串的结尾。

java练习代码：

 需求： 从外界接收一个字符串，并计算其中各种字符的个数

<span style="font-size:18px;">import java.util.Scanner;
public class charAt {
    public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("从外界接收一个字符串，并计算其中各种字符的个数：");
String str = sc.next();

int dxcount = 0;
int xxcount = 0;
int numcount = 0;
int count = 0;

for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
//判断是否为大写字母
if(c >= 'A' && c <= 'Z')
{
dxcount++;
}else if (c >= 'a' && c <= 'z'){//判断是否为小写字母
    xxcount++;
}else if(c >= '0' && c <= '9'){//判断是否位数字
numcount++;
}else{//判断是否为其他字符
count++;
}
}
System.out.println("大写字母的个数："+dxcount);
System.out.println("小写字母的个数："+xxcount);
System.out.println("数字的个数："+numcount);
System.out.println("其他字符个数："+count);
}
}</span>

String类的其他功能：

1）替换功能
String replace(char old,char new)
String replace(String old,String new)

2）去除字符串两空格
String trim()

3）按字典顺序比较两个字符串  
int compareTo(String str)
int compareToIgnoreCase(String str) 

java代码：

<span style="font-size:18px;"><span style="font-size:18px;">public class Demo {
public static void main(String[] args) {
String str = "helloworld";

System.out.println("将\"helloworld\"中的l替换为L: " + str.replace('l', 'L'));
System.out.println("替换后的原字符串：" + str);
System.out.println("将：" + str + " 中的ll替换为LL： " + str.replace("ll", "LL"));
System.out.println("替换后的原字符串：" + str);

String str1 = "a";//97
String str2 = "b";//98
String str3 = "a";//97
String str4 = "c";//99
String str5 = "A";//65
String str6 = "ac";
String str7 = "ab";
System.out.println("\"b\".compareTo(\"a\") : " + str2.compareTo(str1));//98 - 97
System.out.println("\"a\".compareTo(\"b\") : " + str1.compareTo(str2));//97 - 98
System.out.println("\"a\".compareTo(\"a\") : " + str1.compareTo(str3));//97 - 97
System.out.println("\"c\".compareTo(\"a\") : " + str4.compareTo(str1));//99 - 97
System.out.println("\"a\".compareTo(\"c\") : " + str1.compareTo(str4));//97 - 99
System.out.println("\"a\".compareTo(\"A\") : " + str1.compareTo(str4));//97 - 65
System.out.println("\"ac\".compareTo(\"ab\") : " + str6.compareTo(str7));
}
}</span></span>

StringBuffer类概述及其构造方法：

StringBuffer类概述：

1）对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。而StringBuffer就可以解决这个问题。
2）线程安全的可变字符序列。

构造方法：
public StringBuffer() 
public StringBuffer(int capacity)
public StringBuffer(String str)

StringBuffer类的成员方法：

1）添加功能
      public StringBuffer append(String str)
      public StringBuffer insert(int offset,String str)

Java代码：

<span style="font-size:18px;">public class Demo {
public static void main(String[] args) {
StringBuffer buf = new StringBuffer("wrod");
buf.append("!!");//添加
System.out.println(buf);
buf.insert(0, "hell ");//插入方法
System.out.println(buf);
}
}</span>

2）删除功能

      public StringBuffer deleteCharAt(int index)

      public StringBuffer delete(int start,int end)

3）替换功能
      public StringBuffer replace(int start,int end,String str)

Java代码：

<span style="font-size:18px;">public class Demo {
public static void main(String[] args) {
StringBuffer buf = new StringBuffer("hello wrod!!");
buf.replace(6, 10, "java");//替换方法
System.out.println(buf);
}
}</span>

<span style="font-size:18px;">结果：hello java</span>

4）反转功能  

      public StringBuffer reverse()

5）截取功能
      public String substring(int start)
      public String substring(int start,int end)

Java代码：

<span style="font-size:18px;"><span style="font-size:18px;">public class Demo {
public static void main(String[] args) {
StringBuffer buf = new StringBuffer("hello wrod!!");
String str = buf.substring(6);
System.out.println(str);//被subString方法操作后的新字符串
System.out.println("原串："+buf);
String str1 = buf.substring(0, 4);
System.out.println(str1);//新串
System.out.println("原串："+buf);
}
}</span></span>

String,StringBuffer,StringBuilder的区别：

   1）   StringBuffer：保证线程同步；多线程访问是安全，保证数据的一致性；单线程下，效率低
    2）  StringBuilder:不保证线程同步；多线程访问时，不保证数据的一致性；单线程下，效率高

Java代码：

运行结果：

StringBuffer的时间：2314 毫秒。
StringBuilder的时间：2025 毫秒。

<span style="font-size:18px;">public class Demo {
public static void main(String[] args) {
//测试一下StringBuffer和StringBuilder的效率
StringBuffer buf = new StringBuffer();
long start = System.currentTimeMillis();//开始时间
for(int i = 0 ;i < 20000000 ; i++){
buf.append(i);
}
long end = System.currentTimeMillis();//结束时间
System.out.println("StringBuffer的时间：" + (end - start) + " 毫秒。");
StringBuilder bul = new StringBuilder();
start = System.currentTimeMillis();//开始时间
for(int i = 0 ;i < 20000000 ; i++){
bul.append(i);
}
end = System.currentTimeMillis(); //结束时间
System.out.println("StringBuilder的时间：" + (end - start) + " 毫秒。");
}
}</span>

StringBuffer和数组的区别：

  1.都是引用类型：

  2.都存储字符序列； 

  不同点：

  1.StringBuffer对于我们使用者来说，是可以自动扩展长度； 

     数组对我们来说，长度不可变；  

  2.StringBufferf对于我们来说，什么数据类型都可以存；

     数组，只能存储一种数据类型；

3）数组高级和Arrays类

未完待续------
4）基本类型包装类(Integer,Character)
5）正则表达式(Pattern,Matcher)
6）Math类/Random类/System类
7）BigInteger类/BigDecimal类
8）Date类/DateFormat类/Calendar类